Spring专题（2）——Spring容器的基本应用

Spring容器的基本应用

2.1如何将一个Bean组件交给Spring容器

1）Bean组件其实就是个普通的Java类！

2）方法：在applicationContext.xml中添加以下定义，见2.6案例中step4。

             <bean id="标识符" class="Bean组件类型"></bean>

2.2如何获取Spring容器对象和Bean对象

1. 实例化容器：

ApplicationContext ac=new ClassPathXmlApplicationContext("/applicationContext.xml");

//FileSystemXmlApplicationContext("");//去指定的磁盘目录找，上面的为去Class路径找

2）利用getBean("标识符")方法获取容器中的Bean对象。见2.6案例中step5。

2.3如何控制对象创建的模式

Spring支持singleton（单例）和prototype（原型，非单例）两种模式。

默认是singleton模式，可以通过<bean>的scope属性修改为prototype模式。以后在Web程序中，通过扩展可以使用request、session等值。见2.6案例中step4、step7。

例如：<bean id="标识符" scope="prototype" class="Bean组件类型"></bean>

1. 注意事项：对于NetCTOSS项目，一个请求创建一个Action，所以用Spring时必须指明prototype，否则默认使用singleton会出问题。而DAO则可用singleton模式。

2.4 Bean对象创建的时机

1）singleton模式的Bean组件是在容器实例化时创建。

2）prototype模式是在调用getBean()方法时创建。

3）singleton模式可以使用<bean>元素的lazy-init="true"属性将对象的创建时机推迟到调用getBean()方法。也可以在<beans>（根元素）中使用default-lazy-init="false"推迟所有单例Bean组件的创建时机。见2.6案例中step3、step4。

例如：<bean id="标识符" scope="singleton" lazy-init="true" class="Bean组件类型"></bean>

       <beans ...... default-lazy-init="false"></beans>

2.5为Bean对象执行初始化和销毁方法

1）初始化：①可以利用<bean>元素的init-method="方法名"属性指定初始化方法。

②指定的初始化方法是在构造方法调用后自动执行。若非单例模式，则每创建一个对象，则执行一次初始化方法（单例、非单例模式都可）。见2.6案例中step3、step4。

1. 注意事项：

1. 初始化的三种方式：写构造方法中；或写{ }中（代码块）；Spring框架中<bean>元素写init-method="方法名"属性。
2. 初始化不能用static{ }，它是类加载调用，比创建对象要早。

1. 销毁：①可以利用<bean>元素的destroy-method="方法名"属性执行销毁方法。

②指定的销毁方法是在容器关闭时触发，而且只适用于singleton模式的组件（只能为单例模式）。见2.6案例中step3、step4、step6。

2.6案例：Spring框架的使用以及2.1节-2.5节整合测试

step1：导入Spring开发包：spring.jar、commons-logging.jar和配置文件：applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:jee="http://www.springframework.org/schema/jee"

       xsi:schemaLocation="http://www.springframework.org/schema/tx                                                           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

                    http://www.springframework.org/schema/aop                                                                           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

                     http://www.springframework.org/schema/beans                                                                        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

                     http://www.springframework.org/schema/context                                                                             http://www.springframework.org/schema/context/spring-context-2.5.xsd

                     http://www.springframework.org/schema/jee                                                                           http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">

</beans>

step2：在org.tarena.dao包下，创建接口CostDAO，添加两个方法

             public void delete();              public void save();

step3：在org.tarena.dao包下，创建JdbcCostDAO类，并实现CostDAO接口

public JdbcCostDAO(){        System.out.println("创建CostDAO对象");                      }

public void myinit(){            System.out.println("初始化CostDAO对象");                   }

public void mydestroy(){      System.out.println("销毁CostDAO对象");                  }

public void delete() {     System.out.println("利用JDBC技术实现删除资费记录");       }

public void save() {       System.out.println("利用JDBC技术实现保存资费记录");       }

step4：在applicationContext.xml配置文件中，将Bean组件（Java类）交给Spring容器

<bean id="jdbcCostDAO" scope="singleton" lazy-init="true" init-method="myinit"

      destroy-method="mydestroy" class="org.tarena.dao.JdbcCostDAO">

</bean>

step5：在org.tarena.test包下，创建TestApplicationContext类，获取Spring容器对象，并测试

@Test

public void test1(){        String conf="/applicationContext.xml";

       ApplicationContext ac=new ClassPathXmlApplicationContext(conf);//实例化容器

       CostDAO costDAO=(CostDAO)ac.getBean("jdbcCostDAO");//获取Bean对象

       costDAO.save();            costDAO.delete();                                                          }

step6：在TestApplicationContext类中添加方法，测试销毁对象

@Test

/**关闭容器才会触发销毁，但关闭容器方法封装在AbstractApplicationContext类中 */

public void test2(){        String conf="/applicationContext.xml";

       ApplicationContext ac=new ClassPathXmlApplicationContext(conf);

       AbstractApplicationContext ac=new ClassPathXmlApplicationContext(conf);

       CostDAO costDAO=(CostDAO)ac.getBean("jdbcCostDAO");          ac.close();       }

step7：在TestApplicationContext类中添加方法，测试单例

       @Test

       public void test3(){        String conf="/applicationContext.xml";

              ApplicationContext ac=  new ClassPathXmlApplicationContext(conf);

              CostDAO costDAO1=(CostDAO)ac.getBean("jdbcCostDAO");

              CostDAO costDAO2=(CostDAO)ac.getBean("jdbcCostDAO");

              System.out.println(costDAO1==costDAO2);//true，所以Spring默认为单例模式  }