Spring实例化Bean的方式

Spring实例化Bean的方式有如下四种：

1.使用类构造器实现实例化（bean的自身构造器）

实体类Car，属性brand、price，提供get/set方法，有参、无参构造方法，重写toString方法

package com.qcc.beans.factory;

public class Car {

private String brand;
private double price;

public String getBrand() {
    return brand;
}

public void setBrand(String brand) {
    this.brand = brand;
}

public double getPrice() {
    return price;
}

public void setPrice(double price) {
    this.price = price;
}

@Override
public String toString() {
    return "Car [brand=" + brand + ", price=" + price + "]";
}

public Car() {
    super();
    // TODO Auto-generated constructor stub
}

public Car(String brand, double price) {
    super();
    this.brand = brand;
    this.price = price;
}

}

    <!-- 
        使用类的构造器来实例化Bean.
        此处属性使用P命名空间比较简洁的方式注入
     -->
    <bean id="car" class="com.qcc.beans.factory.Car" p:brand="hongQi" p:price="200000"></bean>

2.静态工厂方法（通过静态工厂的静态方法获取Bean实例，不需要获取工厂的实例）

创建静态工厂类，如下：

package com.qcc.beans.factory;

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

public class StaticFactory {

    private static Map<String, Car> cars = new HashMap<>();

    static{
        cars.put("bmw", new Car("bmw",300000));
        cars.put("audi", new Car("audi",400000));
        cars.put("ford", new Car("ford",500000));
    }

    public static Car getCar(String brand){
        return cars.get(brand);
    }
}

Bean的配置如下：

    <!-- 
        使用静态工厂类中的静态方法来获取bean实例，不需要创建静态工厂的实例。
        class：静态工厂的全类名 ，
        factory-method：指定获取Bean实例的静态方法。
        constructor-arg：为静态方法传递参数。
    -->
    <bean id="car1" class="com.qcc.beans.factory.StaticFactory" factory-method="getCar">
        <constructor-arg value="bmw" />
    </bean>

3.实例工厂方法（先获取工厂的实例，然后再获取对应Bean的实例）

创建实例工厂类，代码如下：

package com.qcc.beans.factory;

public class InstanceFactory {

    public Car getCar(){
        return new Car("audi",600000);
    }
}

Spring配置文件中作以下配置：

    <!-- 配置实例工厂的bean -->
    <bean id="factory" class="com.qcc.beans.factory.InstanceFactory"></bean>

    <!-- 
        配置要获取的实例bean，
        factory-bean：指向id为factory的Bean实例工厂；
        factory-method：实例工厂中对应的工厂方法；
     -->
    <bean id="car2" factory-bean="factory" factory-method="getCar"></bean>

4.通过实现Spring提供给我们的FactoryBean接口来获取(不常用)

创建一个类CarFactoryBean 实现 FactoryBean 的接口，传入泛型参数Car，如下：

package com.qcc.beans.factory;

import org.springframework.beans.factory.FactoryBean;

public class CarFactoryBean implements FactoryBean<Car> {

    @Override
    public Car getObject() throws Exception {
        // TODO Auto-generated method stub
        return new Car("ford", 400000);//此处返回要获取的对象
    }

    @Override
    public Class<?> getObjectType() {
        // TODO Auto-generated method stub
        return Car.class;//返回的对象的class类型
    }

    @Override
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return true;//是否是单例模式
    }

}

Spring配置文件内容如下：

    <bean id="car3" class="com.qcc.beans.factory.CarFactoryBean"></bean>

测试代码：

package com.qcc.beans.factory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
        Car car = (Car) ctx.getBean("car");//构造方法获取的Bean
        System.out.println(car);

        Car car1 = (Car) ctx.getBean("car1");//静态工厂方法获取的Bean
        System.out.println(car1);

        Car car2 = (Car) ctx.getBean("car2");//实例工厂方法获取的Bean
        System.out.println(car2);

        Car car3 = (Car) ctx.getBean("car3");//实现FactoryBean接口的方式获取的Bean
        System.out.println(car3);
        Car car4 = (Car) ctx.getBean("car3");//实现FactoryBean接口的方式获取的Bean

        /*
         * CarFactoryBean中isSingleton()方法返回了true，即单例的Bean，
         * 因此多次获取得到的是相同的Bean，所以打印结果是true
         */
        System.out.println(car3==car4);
    }
}

运行结果:

Car [brand=hongQi, price=200000.0]
Car [brand=bmw, price=300000.0]
Car [brand=audi, price=600000.0]
Car [brand=ford, price=400000.0]
true