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");