Spring中Bean的三种配置方式

1.IOC和DI概述
IOC(Inversion of Control)：其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式。
DI(Dependency Injection) — IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接。

2.Bean的配置方式
Bean 的配置方式：通过全类名（反射）、通过工厂方法（静态工厂方法 & 实例工厂方法）、FactoryBean。
2.1 Spring通过全类名（反射）配置Bena的特点
1.基于xml文件的方式
2.通过全类名反射
3.依靠IOC容器
4.依赖注入放入方式：属性注入，构造器注入
基于xml文件的方式配置Bean

<!-- id：Bean的名称，在IOC容器中必须是唯一的-->
<bean id="helloworld" class="com.java.spring.HelloWorld">
  <property name="name" value="DaiHao"></property>
</bean>

2.2 通过工厂方法配置Bean
2.2.1 通过调用静态工厂配置Bean
调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中，当客户端需要对象时，只需要简单的调用静态方法，而不用关心创建对象的细节。
要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 元素为该方法传递方法参数.
Car.java

package com.java.spring.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;
    }
    public Car(String brand, double price) {
        super();
        this.brand = brand;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car [brand=" + brand + ", price=" + price + "]";
    }
}

StaticCarFactory.java

package com.java.spring.factory;
import java.util.HashMap;
import java.util.Map;
public class StaticCarFactory {
    private static Map<String,Car> cars=new HashMap<String,Car>();
    static{
        cars.put("audi",new Car("audi",300000.00));
        cars.put("ford",new Car("ford",400000.00));
    }
   //静态工厂方法
    public static Car getCar(String name){
        return cars.get(name);
    }    
}

在xml中配置

<bean id="car1" class="com.java.spring.factory.StaticCarFactory" factory-method="getCar">
  <constructor-arg value="audi"></constructor-arg>
</bean>

主方法中进行实例化Bean：

package com.java.spring.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 car1=(Car) ctx.getBean("car1");
        System.out.println(car1);
    }
}

运行后输出：

Car [brand=audi, price=300000.0]

静态工厂方法就是直接调用一个类的静态方法就能返回Bena的实例，上面代码中根据静态工厂方法public static Car getCar（String name）来配置Bean实例。
2.2.2 通过调用实例工厂配置Bean
实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节
要声明通过实例工厂方法创建的 Bean：
*
在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean；
*
在 factory-method 属性里指定该工厂方法的名称；
*
使用 construtor-arg 元素为工厂方法传递方法参数；

InstanceCarFactory.java

package com.java.spring.factory;
import java.util.HashMap;
import java.util.Map;
public class InstanceCarFactory {
    private static Map<String,Car> cars=null;
    public InstanceCarFactory() {
        cars=new HashMap<String,Car>();
        cars.put("Audi",new Car("Audi",300000.00));
        cars.put("Ford",new Car("Ford",400000.00));
    }
    public Car getCar(String brand){
        return cars.get(brand);
    }
}

在beans-factory.xml中进行配置：

//配置工厂的实例
<bean id="carFactory" class="com.java.spring.factory.InstanceCarFactory"></bean>
//通过实例工厂方法来配置bean
<bean id="car2" factory-bean="carFactory" factory-method="getCar">
  <constructor-arg value="Ford"></constructor-arg>
</bean>

2.3 实现 FactoryBean 接口在 Spring IOC 容器中配置 Bean
Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean. 工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象。

package com.java.spring.FactoryBean;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean{
    private String brand;
    public void setBrand(String brand){
        this.brand=brand;
    }
    @Override
        //FactoryBean返回的实例
    public Car getObject() throws Exception {
        return new Car(brand,500000.00);
    }
    @Override
        //FactoryBean返回的实例是否为单例
    public boolean isSingleton() {
        return false;
    }
    @Override
        //FactoryBean返回的类型
    public Class getObjectType() {
        return Car.class;
    }
}

在beans-factory.xml中进行配置：

<bean id="car3" class="com.java.spring.FactoryBean.CarFactoryBean">
  <property name="brand" value="BWM"></property>
</bean>

在主方法中实例化：

Object car3= ctx.getBean("car3");

3.获取Bean

Spring提供的最常用的IOC容器实现是ApplicationContext，ApplicationContext的主要实现类ClassPathXmlApplicationContext从类路径下加载配置文件。
创建Spring的IOC对象：

ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");

从IOC容器中获取Bean：调用ApplicationContext的getBean()方法。

HelloWorld helloWorld=(HelloWorld) ctx.getBean("helloworld");