Spring bean三种创建方式

　　spring共提供了三种实例化bean的方式：构造器实例化(全类名，反射)、工厂方法（静态工厂实例化   动态工厂实例化）和FactoryBean ，下面一一详解：

 

1、构造器实例化

City.java

package com.proc.bean;

public class City {

    private String name;
    private String code;
    
    public City() {
    }

    public City(String name, String code) {
        this.name = name;
        this.code = code;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "City [name=" + name + ", code=" + code + "]";
    }
}

 

通过构造方式配置Bean

<bean id="city" class="com.proc.bean.City">
    <constructor-arg value="北京"/>
    <constructor-arg value="BJ"/>
</bean>

 

测试代码

ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
City city=ctx.getBean("city", City.class);
System.out.println(city);

输出结果

City [name=北京, code=BJ]

 

2、静态工厂实例化

　　先创建一个静态工厂StaticCityFactory

package com.proc.bean;

import java.util.HashMap;
import java.util.Map;

public class StaticCityFactory {
    
    private static Map<String, City> cities;
    
    static{
        cities=new HashMap<String, City>();
        cities.put("BJ", new City("北京", "BJ"));
        cities.put("SH", new City("上海", "SH"));
        cities.put("CD", new City("成都", "CD"));
        cities.put("SZ", new City("深圳", "SZ"));
    }

    public static City getCity(String code){
        return cities.get(code);
    }
}

 

　　配置bean

<!-- 通过静态工厂实例化对象
    class:静态工厂类型
    factory-method:静态工厂静态方法名称
    constructor-arg:为静态工厂方法指定参数
 -->
<bean id="city" class="com.proc.bean.StaticCityFactory" factory-method="getCity">
    <constructor-arg value="BJ"/>
</bean>

 

3、动态工厂实例化

　　先创建一个实例化工厂

package com.proc.bean;

import java.util.HashMap;
import java.util.Map;

public class InstanceCityFactory {
    
    private Map<String, City> cities;
    {
        cities=new HashMap<String, City>();
        cities.put("BJ", new City("北京", "BJ"));
        cities.put("SH", new City("上海", "SH"));
        cities.put("CD", new City("成都", "CD"));
        cities.put("SZ", new City("深圳", "SZ"));
    }
    
    public City getCity(String code){
        return cities.get(code);
    }
}

　　配置

<!-- 配置实例化工厂 -->
<bean id="cityFacotry" class="com.proc.bean.InstanceCityFactory"/>
 
 <!-- 通过实例化工厂获取对象 -->
<bean id="city" factory-bean="cityFacotry" factory-method="getCity">
    <constructor-arg value="SH"/> <!-- 配置参数 -->
</bean>

 

4、FactoryBean

　　

   一般情况下，Spring 通过反射机制利用 <bean> 的 class 属性指定实现类实例化 Bean ，在某些情况下，实例化 Bean 过程比较复杂，如果按照传统的方式，则需要在 <bean> 中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。 Spring 为此提供了一个org.springframework.bean.factory.FactoryBean 的工厂类接口，用户可以通过实现该接口定制实例化 Bean 的逻辑。

　　FactoryBean接口对于 Spring 框架来说占用重要的地位， Spring 自身就提供了 70 多个 FactoryBean 的实现。它们隐藏了实例化一些复杂 Bean 的细节，给上层应用带来了便利。从 Spring 3.0 开始， FactoryBean 开始支持泛型，即接口声明改为 FactoryBean<T> 的形式：

public interface FactoryBean<T> {  
    T getObject() throws Exception;  
    Class<?> getObjectType();  
    boolean isSingleton();  
}

　　在该接口中还定义了以下3 个方法：

　　　　T getObject()：返回由 FactoryBean 创建的 Bean 实例，如果 isSingleton() 返回 true ，则该实例会放到Spring 容器中单实例缓存池中；

　　　　boolean isSingleton()：返回由 FactoryBean 创建的 Bean 实例的作用域是 singleton 还是 prototype ；

　　　　Class<T> getObjectType()：返回 FactoryBean 创建的 Bean 类型。

　　当配置文件中<bean> 的 class 属性配置的实现类是 FactoryBean 时，通过 getBean() 方法返回的不是FactoryBean 本身，而是 FactoryBean#getObject() 方法所返回的对象，相当于 FactoryBean#getObject() 代理了getBean() 方法。

 

　　例：如果使用传统方式配置下面Car 的 <bean> 时， Car 的每个属性分别对应一个 <property> 元素标签。

public class Car {
    private int maxSpeed;
    private String brand;
    private double price;
    public int getMaxSpeed() {
        return this.maxSpeed;
    }
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    public String getBrand() {
        return this.brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public double getPrice() {
        return this.price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
}

　　如果用FactoryBean 的方式实现就灵活点，下例通过逗号分割符的方式一次性的为 Car 的所有属性指定配置值：

public class CarFactoryBean implements FactoryBean<Car> {
    private String carInfo;
    public Car getObject() throws Exception {
        Car car = new Car();
        String[] infos = carInfo.split(",");
        car.setBrand(infos[0]);
        car.setMaxSpeed(Integer.valueOf(infos[1]));
        car.setPrice(Double.valueOf(infos[2]));
        return car;
    }
    public Class<Car> getObjectType() {
        return Car.class;
    }
    public boolean isSingleton() {
        return false;
    }
    public String getCarInfo() {
        return this.carInfo;
    }
    // 接受逗号分割符设置属性信息
    public void setCarInfo(String carInfo) {
        this.carInfo = carInfo;
    }
}

　　有了这个CarFactoryBean 后，就可以在配置文件中使用下面这种自定义的配置方式配置 Car Bean 了：

<bean id="car" class="com.baobaotao.factorybean.CarFactoryBean">
    <property name="carInfo" value="法拉利 ,400,2000000"/>
</bean>

　　当调用getBean("car") 时， Spring 通过反射机制发现 CarFactoryBean 实现了 FactoryBean 的接口，这时Spring 容器就调用接口方法 CarFactoryBean#getObject() 方法返回。如果希望获取 CarFactoryBean 的实例，则需要在使用 getBean(beanName) 方法时在 beanName 前显示的加上 "&" 前缀：如 getBean("&car");