BlogJava-努力创造未来！-随笔分类-springhttp://www.blogjava.net/pdw2009/category/17723.htmlJ2EE相关应用技术日志zh-cnMon, 26 May 2008 04:23:58 GMTMon, 26 May 2008 04:23:58 GMT60spring+atomikos+JTA完整例子http://www.blogjava.net/pdw2009/archive/2008/05/25/202725.html有猫相伴的日子有猫相伴的日子Sun, 25 May 2008 07:19:00 GMThttp://www.blogjava.net/pdw2009/archive/2008/05/25/202725.htmlhttp://www.blogjava.net/pdw2009/comments/202725.htmlhttp://www.blogjava.net/pdw2009/archive/2008/05/25/202725.html#Feedback0http://www.blogjava.net/pdw2009/comments/commentRss/202725.htmlhttp://www.blogjava.net/pdw2009/services/trackbacks/202725.html
    <!--Atomikos  JTA 事务 begin-->   
    <bean id="dataSource1" class="com.atomikos.jdbc.SimpleDataSourceBean" init-method="init" destroy-method="close">   
        <property name="uniqueResourceName">   
            <value>mysql/main</value>   
        </property>   
        <property name="xaDataSourceClassName">   
            <!-- 使用Mysql XADataSource(mysql>=5.0, Connector/J>=5.0才可以支持XADatasource)-->   
            <value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value>   
        </property>   
        <property name="xaDataSourceProperties">   
            <value>URL=jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8;user=root;password=123456</value>   
        </property>   
        <property name="exclusiveConnectionMode">   
            <value>true</value>   
        </property>   
        <property name="connectionPoolSize">   
            <value>3</value>   
        </property>   
        <property name="validatingQuery">   
            <value>SELECT 1</value>   
        </property>   
    </bean>       
    
    <bean id="dataSource2" class="com.atomikos.jdbc.SimpleDataSourceBean" init-method="init" destroy-method="close">   
        <property name="uniqueResourceName">   
            <value>mysql/secondary</value>   
        </property>   
        <property name="xaDataSourceClassName">   
            <!-- 使用Mysql XADataSource(mysql>=5.0, Connector/J>=5.0才可以支持XADatasource)-->   
            <value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value>   
        </property>
        <property name="xaDataSourceProperties">   
            <value>URL=jdbc:mysql://localhost:3306/aotsf?useUnicode=true&amp;characterEncoding=utf-8;user=root;password=123456</value>   
        </property>
        <property name="exclusiveConnectionMode">   
            <value>true</value>   
        </property>
        <property name="connectionPoolSize">   
            <value>3</value>   
        </property>
        <property name="validatingQuery">
            <value>SELECT 1</value>   
        </property>   
    </bean>     
    
    <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">   
        <property name="forceShutdown"><value>true</value></property>   
    </bean>
    
       
    <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">   
        <property name="transactionTimeout" value="300"/>    
    </bean>
    <bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">   
        <property name="transactionManager">
            <ref bean="atomikosTransactionManager"/>
        </property>
        <property name="userTransaction">
            <ref bean="atomikosUserTransaction"/>
        </property>
    </bean>
    
     <bean id="atomikosTransactionProxy"
          class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
          abstract="true">
          <property name="transactionManager">
               <ref bean="springTransactionManager" />
          </property>
          <property name="transactionAttributes">
               <props>
                <prop key="*">PROPAGATION_REQUIRED,-Exception</prop>
               </props>
          </property>
     </bean>
    
    
    <bean id="jdbcBookDAO" class="dao.jdbc.BookDAO">
        <property name="dataSource">
            <ref bean="dataSource1"/>
        </property>
    </bean>
    
    <bean id="jdbcTestDAO" class="dao.jdbc.TestDAO">
        <property name="dataSource">
            <ref bean="dataSource2"/>
        </property>
    </bean>
    
    <bean id="atomikosJTAServiceDemo" parent="atomikosTransactionProxy">
        <property name="target">
            <bean class="service.AtomikosJTAServiceDemo">
                <property name="jdbcBookDAO">
                    <ref bean="jdbcBookDAO"/>
                </property>
                <property name="jdbcTestDAO">
                    <ref bean="jdbcTestDAO"/>
                </property>                
            </bean>
        </property>
    </bean>
    
    
    <!--Atomikos  JTA 事务 end  -->

DAO层代码
package dao.jdbc;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import domain.Book;

public class BookDAO extends JdbcDaoSupport{
    public void addBook(Book book){
        try{
            JdbcTemplate jt=getJdbcTemplate();
            String str_sql="insert into Book(isbn,bookname,author,note)VALUES(?,?,?,?)";
            String[] args={book.getIsbn(),book.getBookname(),book.getAuthor(),book.getNote()};
            jt.update(str_sql, args);
        }catch(RuntimeException e){
            System.out.println("添加Book失败");
            e.printStackTrace();
            throw e;
        }
    }
}

package dao.jdbc;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;


public class TestDAO extends JdbcDaoSupport{
    
    public void addBook(Integer id, String email){
        try{
            JdbcTemplate jt=getJdbcTemplate();
            String str_sql="insert into test(id,email)VALUES(?,?)";
            Object[] args={id,email};
            jt.update(str_sql, args);
        }catch(RuntimeException e){
            System.out.println("添加Test失败");
            e.printStackTrace();
            throw e;
        }
    }
}

事层代码
package service;

import dao.jdbc.BookDAO;
import dao.jdbc.TestDAO;
import domain.Book;

public class AtomikosJTAServiceDemo {
    private BookDAO jdbcBookDAO;
    private TestDAO jdbcTestDAO;
    
    public String ok(){
        System.out.println("开始.");
        jdbcTestDAO.addBook(Integer.valueOf("2"), "pdw2009  tom.com");
        
        Book book=new Book();
        book.setIsbn("ccdada66");
        book.setAuthor("小东");
        book.setNote("JTA测试");
        book.setBookname("Atomikos学习");
        jdbcBookDAO.addBook(book);
        
        System.out.println("结束.");
        return "ok";
    }

    public BookDAO getJdbcBookDAO() {
        return jdbcBookDAO;
    }

    public void setJdbcBookDAO(BookDAO jdbcBookDAO) {
        this.jdbcBookDAO = jdbcBookDAO;
    }

    public TestDAO getJdbcTestDAO() {
        return jdbcTestDAO;
    }

    public void setJdbcTestDAO(TestDAO jdbcTestDAO) {
        this.jdbcTestDAO = jdbcTestDAO;
    }
    
    
}
测试用例
package services;


import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import service.AtomikosJTAServiceDemo;

public class AtomikosJTAServiceDemoTest {
    ApplicationContext acx=null;
    AtomikosJTAServiceDemo atomikosJTAServiceDemo=null;
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }

    @Before
    public void setUp() throws Exception {
        acx=new ClassPathXmlApplicationContext("applicationContext.xml");
        atomikosJTAServiceDemo=(AtomikosJTAServiceDemo) acx.getBean("atomikosJTAServiceDemo");
    }

    @After
    public void tearDown() throws Exception {
    }
    
    @Test
    public void notnullTest()throws Exception{
        assertNotNull(atomikosJTAServiceDemo);
    }
    @Test
    public void okTest()throws Exception{
        assertEquals(atomikosJTAServiceDemo.ok(),"ok");
        
    }
}



有猫相伴的日子 2008-05-25 15:19 发表评论
]]>struts2和spring2整合（转）http://www.blogjava.net/pdw2009/archive/2007/10/24/155648.html有猫相伴的日子有猫相伴的日子Wed, 24 Oct 2007 09:54:00 GMThttp://www.blogjava.net/pdw2009/archive/2007/10/24/155648.htmlhttp://www.blogjava.net/pdw2009/comments/155648.htmlhttp://www.blogjava.net/pdw2009/archive/2007/10/24/155648.html#Feedback1http://www.blogjava.net/pdw2009/comments/commentRss/155648.htmlhttp://www.blogjava.net/pdw2009/services/trackbacks/155648.html

整合 Spring 和 Strust2 一起工作

关键字:   struts2 spring    
在Struts2中整合Spring的IoC支持是一件十分简单的事情。让我们一步一步来实现：
1）复制struts2-spring-plugin-x-x-x.jar和相应的spring.jar到/WEB-INF/lib目录下。
2）在struts.properties中设置struts.objectFactory属性值

struts.properties
  1. struts.objectFactory = spring  

或者是在XML文件中进行常量配置

struts.xml
  1. <struts>  
  2.     <constant name="struts.objectFactory" value="spring" />  
  3. </struts>  

3）配置Spring监听器

web.xml
  1. <listener>  
  2.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  3. </listener>  

通过Spring配置来注册对象

applicationContext.xml
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE beans PUBLIC    
  3.     "-//SPRING//DTD BEAN//EN"   
  4.     "http://www.springframework.org/dtd/spring-beans.dtd">  
  5. <beans default-autowire="autodetect">  
  6.     <bean id="hello" class="hpfyeah.struts2.spring.HelloWorldAction"/>  
  7. </beans>  

当然你也可以拥有更多的Spring配置文件。在web.xml中进行下列设置，从而使Spring的ApplicationContext通过匹配所给定模式的文件来初始化对象

web.xml
  1. <!-- 用来定位Spring XML文件的上下文配置 -->  
  2. <context-param>  
  3.     <param-name>contextConfigLocation</param-name>  
  4.     <param-value>
  5.         /WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml
  6.     </param-value>  
  7. </context-param>  

4）修改你的Struts配置文件

struts.xml
  1. <!DOCTYPE struts PUBLIC      
  2.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"      
  3.     "http://struts.apache.org/dtds/struts-2.0.dtd">     
  4. <struts>     
  5.     <include file="struts-default.xml"/>     
  6.     <package name="default" extends="struts-default">     
  7.         <action name="pureStruts" class="hpfyeah.struts2.spring.HelloWorldAction">
  8.             <result>hello.jsp</result>     
  9.         </action>  
  10.         <action name="springStruts" class="hello">      
  11.             <result>hello.jsp</result>     
  12.         </action>     
  13. </struts>  

默认情况下，Spring从上面显示的applicationContext.xml文件中寻找为hello所做的配置

5）好了，现在你的Struts2和Spring就能正常的一起工作了。有几个配置技术点需要详细说明下：
装配模式。你可以通过设置修改struts.properties中下列属性的值来改变装配模式。

name 按照你的action的属性的名字和Spring里的bean的名字匹配，如果匹配就自动装配。这是缺省的
type 按照你的action的属性的类型，在Spring注册的bean中查找，如果相同就自动装配。这需要你在Spring中仅注册了一个此类型的bean
auto Spring会试图自动监测来找到最好的方法自动装配你的action
constructor Spring会自动装配bean的构造函数的参数

是否使用类缓存。你可以通过设置修改struts.properties中下列属性的值来改变是否使用Spring自身的类缓存机制。可以设定的值为true或false，默认为true。

struts.properties
  1. struts.objectFactory.spring.useClassCache = false 
按照以上步骤做了，但出错、异常信息如下
Messages:
  1. springhello
  2. Action class [springhello] not found
File: com/caucho/loader/DynamicClassLoader.java
Line number: 1,124


有猫相伴的日子 2007-10-24 17:54 发表评论
]]>SpringMVC http://www.blogjava.net/pdw2009/archive/2007/10/04/150366.html有猫相伴的日子有猫相伴的日子Thu, 04 Oct 2007 07:25:00 GMThttp://www.blogjava.net/pdw2009/archive/2007/10/04/150366.htmlhttp://www.blogjava.net/pdw2009/comments/150366.htmlhttp://www.blogjava.net/pdw2009/archive/2007/10/04/150366.html#Feedback0http://www.blogjava.net/pdw2009/comments/commentRss/150366.htmlhttp://www.blogjava.net/pdw2009/services/trackbacks/150366.html Spring 角色：
1、核心控制器DispatcherServlet
       它类似于struts中的ActionServlet,WebWork中的ServletDispacher.
负责拦截主求，将请求参数封装成对象，然后根据处理器映射策略，将请求转发给不同的业务控制器。DispatcherServlet应该配置成load-on-startup Servlet方式，它不仅负责处理请求，而且负责创建ApplicationContext，核心控制器启动时加载，在web.xml配置如下。
  <servlet>
    <servlet-name>firstmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>firstmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
如上面配置,DispatcherServlet应对的配置文件是firstmvc-servlet.xml文件。

2、业务控制器
       不管直接实现还是继承实现类，Spring的业务控制器都必须实现Controller接口,Spring提供了多种控制器实现的接口。这个业务控制器等同于Struts中的Action类，但两者实现方法不一样.Struts使用了类继承，Spring使用了接口。并提供了以下实现类
AbstractController  功以有限通常不支持使用
ParameterizableViewController ：与上面那个类相似，但可以返回视图名，而不是硬编码的视图名
UrlFilenameViewController : 根据URL并获取请求的文件名
ServletForwardingController: 将请求转发给某Servlet。
SimpleFormController ： 用于处理表单参数的控制器
MultiActionController :  多动作控制器
AbstractCommandController ：命令控制器

在这里详说MultiActionController，其它控制器自己找资料
 MultiActionController有两种使用方式
1、继承MultiActionController，并在子类中指定MethodNameResolver解析的方法，在这种情况下，不需要配置Delegate参数
2、不继承MultiActionController，将动作定义在代理对象里，由代理调用Resolver解析的方法。
MethodNameResolver主要有如下三种实现，需要的时候可以也可以自己提供
1、ParameterMethodNameResolver，解析特定参数值，将参数值作为方法名。
2、InternalPathMethodNameResolver:从请求路径中解析文件名作为方法名。
3、PropertiesMethodNameResolver：使用自定义属性对象,将请求的URL景射到方法名.
firstmvc-servlet.xml配置如下：
    <!-- 动作代理 -->
    <bean id="paramResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
        <property name="paramName">
            <value>method</value>
        </property>
    </bean>
    <bean name="/paramMultiController.do" class="org.springframework.web.servlet.mvc.multiaction.MultiActionController">
        <property name="methodNameResolver">
            <ref bean="paramResolver"/>
        </property>
        <property name="delegate">
            <ref bean="sampleDelegate"/>
        </property>
    </bean>
    <bean id="sampleDelegate" class="com.mvc.SampleDelegate" />




3、处理影射  
      控制器根据该策略，将请求转发给对应的业务控制器。通常有下面两种策略
      BeanNameUrlHandlerMapping 根据请求名转发
      SimpleUrlHandlerMapping 根据定义转发请求
      HandlerMapping 的基本功能是将请求传递到HandlerExecutionChain。BeanNameUrlHandlerMapping 是一个简单而强大的控制映射器，它将HTTP的请求映射转发给context中同名的bean。firstmvc-servlet.xml文件如下
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="handlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />
    <bean name="/hello.do" class="com.mvc.HelloAction">
        <property name="jsp">
            <value>WEB-INF/jsp/hello.jsp</value>
        </property>
    </bean>
</beans>
HelloAction.java代码如下：
package com.mvc;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class HelloAction implements Controller{
    
    public String jsp;
    public void setJsp(String jsp){
        this.jsp=jsp;
    }
    
    public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {
        
        return new ModelAndView(jsp,"model",null); 
        
    }
    
}
SimpleUrlHandlerMapping 是功能强大的控制器映射，但不喜欢用，
用的时候再找资料吧。。。。


4、视图和视图解析
5、模型
     Spring根本没提供专门的模型角色，Spring的Model对象由普通map对象充当，Key不能为空，值可以为空
6、Command对象
     Command对象是普通的java对象，用于封装用记请求参数     



有猫相伴的日子 2007-10-04 15:25 发表评论
]]>Spring 事务管理和mysql乱码解决http://www.blogjava.net/pdw2009/archive/2007/09/28/149392.html有猫相伴的日子有猫相伴的日子Fri, 28 Sep 2007 15:51:00 GMThttp://www.blogjava.net/pdw2009/archive/2007/09/28/149392.htmlhttp://www.blogjava.net/pdw2009/comments/149392.htmlhttp://www.blogjava.net/pdw2009/archive/2007/09/28/149392.html#Feedback0http://www.blogjava.net/pdw2009/comments/commentRss/149392.htmlhttp://www.blogjava.net/pdw2009/services/trackbacks/149392.html
package com.spring;

import java.sql.Connection;
import java.sql.Statement;

import javax.sql.DataSource;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.orm.toplink.TopLinkTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class TransactionDemo {
    /**
     * spring事务模板例子
     *
     */
    public void templateTemplateDemo(){
        final ApplicationContext ctx=new ClassPathXmlApplicationContext("src/bean.xml"); 
        //ClassPathResource cpr=new ClassPathResource("bean.xml");
        //final XmlBeanFactory factory=new XmlBeanFactory(cpr);
        PlatformTransactionManager ptm=(PlatformTransactionManager)ctx.getBean("transactionManager");
        TransactionTemplate tt=new TransactionTemplate(ptm);
        tt.execute(new TransactionCallbackWithoutResult(){
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus ts) {
                try{
                    DataSource ds=(DataSource)ctx.getBean("dataSource");
                    Connection conn=DataSourceUtils.getConnection(ds);
                    Statement stmt=conn.createStatement();
                    stmt.execute("insert into tuser values(123,'裴德万')");
                    
                }catch(Exception e){
                    ts.setRollbackOnly();
                    e.printStackTrace();
                }
            }
            
        });
    }
    /**
     * 使用PlatforTransactionManager实现类管理事务
     *
     */
    public void PlatforTransactionManagerDemo(){
        ApplicationContext ctx=new ClassPathXmlApplicationContext("bean.xml"); 
        PlatformTransactionManager tm=(PlatformTransactionManager)ctx.getBean("transactionManager");
        DefaultTransactionDefinition dtf=new DefaultTransactionDefinition();//初始化一个默认事务
        dtf.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);//设置事务定义对象的事务传达室播属性
        TransactionStatus ts=tm.getTransaction(dtf);//TransactionStatus代表事务对象本身，getTransaction开始一个事务
        try{
            DataSource ds=(DataSource)ctx.getBean("dataSource");
            Connection conn=DataSourceUtils.getConnection(ds);
            Statement stmt=conn.createStatement();
            stmt.execute("insert into tuser values(123,'裴德万')");
            tm.commit(ts);
        }catch(Exception e){
            tm.rollback(ts);
            e.printStackTrace();
        }
    }
    public static void main(String[] args){
        TransactionDemo td=new TransactionDemo();
        td.templateTemplateDemo();
    }
    
}
对应的XML文件配置(jdbc)如下：
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="url">
            <value>jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8</value>
        </property>
        <property name="username">
            <value>root</value>
        </property>
        <property name="password">
            <value>123456</value>
        </property>
        
    </bean>

JTA的配置如下
    <bean id="transactionManager" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="dataSource">
           <property name="jndiName">
              <value>jdbc/kkmei</value>
           </property>
    </bean>

<bean id="jtatm" class="org.springframework.transaction.jta.JtaTransactionManager">
   
</bean>
使用ApplicationContext时只能通过applicationContext.xml来初始化容器
final ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");

mysql 乱码问题由来已久，今天发现把my.ini中的字符编码改为utf-8时，mysql无法启动。在这个例子中我们使用了utf-8编码，那么我们要把test数据库的编码，表编码，字段编码全改成utf-8就没问题了，mysql-front停止开发了，郁闷

有猫相伴的日子 2007-09-28 23:51 发表评论
]]>BeanFactory与Application的区别http://www.blogjava.net/pdw2009/archive/2007/09/28/149382.html有猫相伴的日子有猫相伴的日子Fri, 28 Sep 2007 15:15:00 GMThttp://www.blogjava.net/pdw2009/archive/2007/09/28/149382.htmlhttp://www.blogjava.net/pdw2009/comments/149382.htmlhttp://www.blogjava.net/pdw2009/archive/2007/09/28/149382.html#Feedback0http://www.blogjava.net/pdw2009/comments/commentRss/149382.htmlhttp://www.blogjava.net/pdw2009/services/trackbacks/149382.html

在Spring中，两个最基本最重要的包是 org.springframework.beans 和 org.springframework.context. 这两个包中的代码为Spring的反向控制 特性（也叫作依赖注射）提供了基础。 BeanFactory提供了一种先进的配置机制来管理任何种类bean(对象)，这种配置机制考虑到任何一种可能的存储方式。 ApplicationContext建立在BeanFactory之上，并增加了其他的功能,比如更容易同Spring AOP特性整合， 消息资源处理（用于国际化），事件传递，以声明的方式创建ApplicationContext， 可选的父上下文和与应用层相关的上下文（比如WebApplicationContext），以及其他方面的增强。

简而言之，BeanFactory提供了配置框架和基本的功能， 而 ApplicationContext为它增加了更强的功能，这些功能中的一些或许更加接近J2EE并且围绕企业级应用。一般来说，ApplicationContext是BeanFactory的完全超集， 任何BeanFactory功能和行为的描述也同样被认为适用于ApplicationContext

用户有时不能确定BeanFactory和ApplicationContext中哪一个在特定场合下更适合。 通常大部分在J2EE环境的应用中，最好选择使用ApplicationContext， 因为它不仅提供了BeanFactory所有的特性以及它自己附加的特性，而且还提供以声明的方式使用一些功能， 这通常是令人满意的。BeanFactory主要是在非常关注内存使用的情况下 （比如在一个每kb都要计算的applet中）使用，而且你也不需要用到ApplicationContext的所有特性。

这一章粗略地分为两部分，第一部分包括对BeanFactory和ApplicationContext都适用的一些基本原则。第二部分包括仅仅适用于ApplicationContext的一些特性


生成BeanFactory的方法
InputStream is = new FileInputStream("beans.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
//或者
ClassPathResource res = new ClassPathResource("beans.xml");
XmlBeanFactory factory = new XmlBeanFactory(res);

生成ApplicationContext方法
ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
        new String[] {"applicationContext.xml", "applicationContext-part2.xml"});


ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext("");

applicationContxt是可以转换成beanFactory的
BeanFactory factory = (BeanFactory) appContext;

Beans被定义为两种部署模式中的一种：singleton或non-singleton。 （后一种也别叫作prototype，尽管这个名词用的不精确因为它并不是非常适合）。 如果一个bean是singleton形态的，那么就只有一个共享的实例存在， 所有和这个bean定义的id符合的bean请求都会返回这个唯一的、特定的实例。

如果bean以non-singleton，prototype模式部署的话，对这个bean的每次请求都会创建一个新的bean实例。这对于例如每个user需要一个独立的user对象这样的情况是非常理想的。

<bean id="exampleBean"
      class="examples.ExampleBean" singleton="false"/>
<bean name="yetAnotherExample"
      class="examples.ExampleBeanTwo" singleton="true"/>


有猫相伴的日子 2007-09-28 23:15 发表评论
]]>Spring Bean 封装机制学习笔记http://www.blogjava.net/pdw2009/archive/2006/11/25/83507.html有猫相伴的日子有猫相伴的日子Sat, 25 Nov 2006 12:30:00 GMThttp://www.blogjava.net/pdw2009/archive/2006/11/25/83507.htmlhttp://www.blogjava.net/pdw2009/comments/83507.htmlhttp://www.blogjava.net/pdw2009/archive/2006/11/25/83507.html#Feedback0http://www.blogjava.net/pdw2009/comments/commentRss/83507.htmlhttp://www.blogjava.net/pdw2009/services/trackbacks/83507.html
1、Bean Wrapper
       这个BeanWrapper类很简单，提供了一套Bean的操作方法，如apache -BeanUtils一样。通过BeanWrapper，我们可以无需在编码时就指定JavaBean的实现类和属性值，通过在配置文件
加以设定，就可以在运行期动态创建对象并设定其属性（依赖关系）。 一个简单的例子：
    public static void testBeanWrapper(){
        try {
            Object obj=Class.forName("com.spring.UpperAction").newInstance();
            BeanWrapper bw=new BeanWrapperImpl(obj);

            bw.setPropertyValue("message","peidw");
            System.out.println(bw.getPropertyValue("message"));
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

2、Bean Factory
      BeanFactory负责根据配置配置文件创建Bean实例，可以配置的项目有：
      1 、Bean属性值及依赖关系
      2、Bean创建模式(是否单态模式)
      3、Bean初始化及销毁
      4、Bean的依赖关系
<beans>
<description>Spring Bean Configuration Sample</description>
<bean
id="TheAction" ⑴
class="net.xiaxin.spring.qs.UpperAction" ⑵
singleton="true" ⑶
init-method="init" ⑷
destroy-method="cleanup" ⑸
depends-on="ActionManager" ⑹
>
<property name="message">
<value>HeLLo</value> ⑺
</property>
<property name="desc">
<null/>
</property>
<property name="dataSource">
<ref local="dataSource"/> ⑻
</property>
</bean>
<bean id="dataSource"
class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>java:comp/env/jdbc/sample</value>
</property>
</bean>
这是一个比较完整的Bean配置，id表示一个类在BeanFactory中的唯一标识
class 是java类名，singleton 为true表示使用单态，init-method初始化方法在BeanFactory创建Bean后执行的初始化方法。destroy-method销毁方法，在bean销毁时执行，一般用于资源释放。depends-on  Bean的依懒关系。<value>节点用于指定一个属性值，ref节点用于引用另一个bean的属性。

       联合上面关于BeanWrapper的内容，我们可以看到，BeanWrapper实现了针对单个Bean的属性设定操作。而BeanFactory则是针对多个Bean的管理容器，根据给定的配置文件，BeanFactory从中读取类名、属性名/值，然后通过Reflection机制进行Bean加载和属性设定。

3、ApplicationContext
BeanFactory提供了针对Java Bean的管理功能，而ApplicationContext提供了一个更为框架化的
实现（从上面的示例中可以看出，BeanFactory的使用方式更加类似一个API，而非Framework style）。
ApplicationContext覆盖了BeanFactory的所有功能，并提供了更多的特性。此外，
ApplicationContext为与现有应用框架相整合，提供了更为开放式的实现（如对于Web应用，我们可以在
web.xml中对ApplicationContext进行配置）。
相对BeanFactory而言，ApplicationContext提供了以下扩展功能：
1． 国际化支持
我们可以在Beans.xml文件中，对程序中的语言信息（如提示信息）进行定义，将程序中的提示
信息抽取到配置文件中加以定义，为我们进行应用的各语言版本转换提供了极大的灵活性。
2． 资源访问
支持对文件和URL的访问。
3． 事件传播
事件传播特性为系统中状态改变时的检测提供了良好支持。
4． 多实例加载
可以在同一个应用中加载多个Context实例。

一个国际化支持例子
public static void testLanguage(){
        ApplicationContext ac=new FileSystemXmlApplicationContext("src/bean.xml");
        Object[] arg=new Object[]{"kkui",Calendar.getInstance().getTime()};
        //以系统默认的Locale加载信息（对winxp而言默认的是zh_CN）

        String zhmsg=ac.getMessage("userinfo",arg, Locale.CHINA);
        String usmsg=ac.getMessage("userinfo",arg, Locale.US);
        System.out.println(zhmsg);
        System.out.println(usmsg);
    }
需要在beans.xml文件配置使用多资源
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basenames">
            <list>
                <value>messages</value>
            </list>
        </property>
    </bean>
这里声明了一个名为messageSource的Bean（注意对于Message定义，Bean ID必须为
messageSource，这是目前Spring的编码规约），对应类为ResourceBundleMessageSource，
目前Spring中提供了两个MessageSource接口的实现，即
ResourceBundleMessageSource和ReloadableResourceBundleMessageSource，后
者提供了无需重启即可重新加载配置信息的特性。
资源文件message_zh.properties
userinfo=登陆用户:[{0}] 登陆时间[{1}]

国际化支持在实际开发中可能是最常用的特性。对于一个需要支持不同语言环境的应用而言，我们所采取的最常用的策略一般是通过一个独立的资源文件（如一个properties文件）完成所有语言信息（如界面上的提示信息）的配置，Spring对这种传统的方式进行了封装，并提供了更加强大的功能.

资源访问例子

Resource rs = ctx.getResource("classpath:config.properties");
File file = rs.getFile();
事件传播机制例子
ApplicationContext基于Observer模式（java.util包中有对应实现），提供了针对Bean的事件传播功能。通过Application. publishEvent方法，我们可以将事件通知系统内所有的ApplicationListener。下面是一个例子:
package com.spring;


import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;

public class LoginAction implements ApplicationContextAware{
    private ApplicationContext ac;
    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        // TODO Auto-generated method stub
        this.ac=arg0;
    }
    public int login(String username,String password){
        ActionEvent ae=new ActionEvent(username);
        this.ac.publishEvent(ae);
        return 0;
    }
    
}
package com.spring;

import org.springframework.context.ApplicationEvent;

public class ActionEvent extends ApplicationEvent {
    public ActionEvent(Object source) {
        super(source);
    }
}
package com.spring;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;

public class ActionListener implements ApplicationListener{

    public void onApplicationEvent(ApplicationEvent event) {
        if(event instanceof ActionEvent){
            System.out.println(event.toString());
        }
        
    }
    
}
需要在beans.xml文件里添加以下配置
<bean id="loginaction" class="net.xiaxin.beans.LoginAction"/>
<bean id="listener" class="net.xiaxin.beans.ActionListener"/>
测试方法：
    public static void testListener(){
        ApplicationContext ac=new FileSystemXmlApplicationContext("src/bean.xml");
        LoginAction la=(LoginAction)ac.getBean("loginaction");
        la.login("peidw", "123456");
    }
Struts in Spring
Struts和Spring是如何整合,为了在struts加加载Spring Context;在struts-config.xml文件中添加以下配置
<struts-config>
<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/applicationContext.xml" />
</plug-in>
</struts-config>
通过plug-in我们实现了Spring Context的加载，不过仅仅加载Context并没有什么实际意义，我们还需要修改配置，将Struts Action交给Spring容器进行管理：


有猫相伴的日子 2006-11-25 20:30 发表评论
]]>