spring中Bean的xml方式配置学习笔记

　spring是一个开源框架，其最终目标是：全方位简化Java开发。spring采用了四种关键策略：

　　1、基于POJO的轻量级和最小侵入性编程

　　2、通过依赖注入和面向接口实现松耦合

　　3、基于切面和惯例进行声明式编程

　　4、通过切面和模板减少样式代码

spring的命名空间有：

　　aop 为声明切面以及将@AspectJ注解的类代理为spring切面提供了配置元素

　　beans 支持声明bean和装配bean，是spring最核心也是最原始的命名空间

　　context 为配置spring应用上下文提供了配置元素，包括自动检测和自动装配bean、注入非spring直接管理的对象

　　jee 提供了与Java EE API的集成例如JNDI和EJB

　　jms 为声明消息驱动的POJO提供了配置元素

　　lang 支持配置由Groovy、JRuby或BeanShell等脚本实现的Bean

　　mvc 启动spring mvc的能力，例如面向注解的控制器、视图控制器和拦截器

　　oxm 支持spring的对象到xml映射的配置

　　tx 提供声明式事务配置

　　util 提供各种各样的工具类元素，包含把集合配置为bean、支持属性占位符元素

1、创建bean的方式：

　　spring中bean的创建是在xml中声明就可以了，创建本身不需要我们去关心，通过这种声明式编程，让我们不需要直接在代码中使用new创建对象，而使用接口注入的方式编写程序，从而使类与类之间松耦合了。创建bean时，需要参数都通过constructor-arg来传递

bean对象的作用域

　　创建bean对象时，scope参数表示bean的作用域,其值可以为：

　　　　

　　singleton　默认值,在每一个spring容器中，一个bean定义只有一个实例

　　prototype　每次调用创建一个实例

　　request　每次http请求对应一个实例,仅在Spring MVC上下文有效

　　session,每个session对应一个实例,仅在Spring MVC上下文有效

　　global-session,每个全局session对应一个实例,仅在Portlet上下文有效

1.1 直接使用构造函数（默认情况都是使用构造函数创建）

<bean id="stu001" class="com.myspring.domain.Student"  />

1.2 使用工厂方法

a） 静态工厂方法

　　使用静态工厂方法创建实例，最典型的就是单例了，只是简单的实现了哈

public class Manager {
/**
* 其余代码省略
*/

private Manager() {
if( InnerClass.Instatnce != null ) {
throw new RuntimeException("the manager is singleton");
}
}

static class InnerClass {
public static Manager Instatnce = new Manager();
}
public static Manager getInstance() {
return InnerClass.Instatnce;
}
}

bean的配置

<bean id="manager" class="com.myspring.domain.Manager" factory-method="getInstance"/>

b） 实例工厂方法

public class InstanceFactory {
private static List<Student> stuList = new ArrayList<Student>();
/**
* 其余代码省略
*/

public Student newInstance() {
Student stu = new Student();
stuList.add(stu);
stu.setName("stu" + stuList.size());
return stu;
}
}

bean的配置

<!-- 配置工厂的实例 -->
<bean id="stuFactory" class="com.myspring.factory.InstanceFactory" />
<bean id="newInstance" factory-bean="stuFactory" factory-method="newInstance"></bean>

c）实现FactoryBean接口

　　这种方式也可以实现工厂化创建bean对象，通过Factorybean类来配置bean的实例，但实际返回的实例却是getObject方法的实例，而不是工厂实例。其缺点是：通过实现FactoryBean接口，bean对象就和spring产生了耦合。

public class FactoryBeanInstance implements FactoryBean<Student>{

private String flag;

public void setFlag(String flag) {
this.flag = flag;
}

public String getFlag() {
return this.flag;
}

@Override
public Student getObject() throws Exception {
return new Student();
}

@Override
public Class<Student> getObjectType() {
return Student.class;
}

@Override
public boolean isSingleton() {
return false;
}
}

bean的配置

<bean id="student" class="com.myspring.factory.FactoryBeanInstance">
<property name="flag">this is a factory</property>
</bean>

2.bean对象的初始化和销毁

2.1 在配置bean的时候，通过init-method和destory-method设置对象的初始化和销毁方法，同时，在beans节点上，可以通过设置default-init-method和default-destory-method属性，对beans节点的所有子节点设置默认的初始化和销毁方法。

public class Student {

/**
* 其余代码省略
*
*/
// 初始化方法
public void init() {
System.out.println("the init is run");
}

//销毁方法
public void destroy() {
System.out.println("the destory is run");
}
}

配置文件如下:

<bean id="stu001" class="com.myspring.domain.Student" init-method="init" destroy-method="destroy"/>

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi=
cebe
"http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" default-init-method="init" default-destroy-method="destroy" >

　　初始化方法会在bean初始化时执行，如果bean的scope是prototype，那么会在每一次bean初始化时都会执行init，如果是singleton，那么只在第一次初始化时执行。而scope为singleton的bean的destroy方法则是在容器关闭时执行，而scope为prototype的bean是不会执行destroy方法的，这是spring设计使然，要特别注意。

2.2 通过实现InitializingBean,DisposableBean接口来实现对象的初始化和销毁。这样同样使我们的代码与spring耦合了。这种方式不需要配置其他参数，bean对象创建的时候，会自动调用相应方法。

public class Student implements InitializingBean,DisposableBean{

/**
* 其余代码省略
*/

@Override
public void destroy() {
System.out.println("the destory is run");
}

@Override
public void afterPropertiesSet() throws Exception {
System.out.println("the init is run");
}
}

3、参数传入的方式

3.1 通过构造注入：

　　ａ）根据索引赋值，索引都是以0开头的：

<bean id="city" class="com.myspring.domain.City">
<constructor-arg index="0" value="37" />
<constructor-arg index="1" value="成都" />
</bean>

　　ｂ）根据参数的名字传值：（推荐用法）

　　在这几种方法里我感觉这种方法是最实用的，他是根据名字来传值的，所以基本上只要名字对了，这个值就可以获取到

<bean id="city" class="com.myspring.domain.City">
<constructor-arg name="id" value="37" />
<constructor-arg name="name" value="成都" />
</bean>

　　ｃ）直接传值

　　直接给参数赋值，这种方法也是根据顺序排的，所以一旦调换位置的话，就会出现bug，这种方法已经很原始了

<bean id="city" class="com.myspring.domain.City">
<constructor-arg value="37" />
<constructor-arg value="成都" />
</bean>

3.2 通过Setter注入

　　setter注入是通过property属性设置的，使用命名空间p可以简化书写，并且格式更加简洁

<bean id="personDao" class="cn.glzaction.service.impl.PersonDaoBean">
<property name="name" type="java.lang.String" value="walker"/>
<property name="id" type="java.lang.Integer" value="1"/>
<property name="list" type="java.util.List">
<list>
<value>130</value>
<value>143</value>
<value>110</value>
</list>
</property>

<property name="map" type="java.util.Map">
<map>
<entry key="key1" value="value1"></entry>
<entry key="key2" value="value2"></entry>
</map>
</property>
</bean>

使用p命名空间：

<util:list id="scoreList" list-class="java.util.ArrayList">
<value>130</value>
<value>143</value>
<value>110</value>
</util:list>
<util:map id="map" map-class="java.util.HashMap">
<entry key="key1" value="value1"></entry>
<entry key="key2" value="value2"></entry>
</util:map>

<bean id="personDao" class="cn.glzaction.service.impl.PersonDaoBean"
p:name="walker" p:id="1" p:list-ref="scoreList" p:map-ref="map" />

3.3 内部Bean

　　如果想bean的引用属性只能在bean的内部使用，不能在bean对象以外使用的时候，可以使用内部bean，内部bean和其他bean的声明方式一样，区别在于内部bean声明在一个bean的property中，且其id属性是无效的。

<bean id="people" class="com.myspring.domain.people">
<property name="car" >
<bean class="com.myspring.domain.City">
</property>
</bean>