BeanFactory是Spring中比较初始的一个Factory，XMLBeanFactory是一种典型的BeanFactory。原始的BeanFactory无法支持Spring中许多插件，AOP，WEB应用无法支持。
1.BeanFactory和FactoryBean的区别
BeanFactory是接口，他是IOC容器的最基本容器，提供了IOC的规范。
FactoryBean也是接口，他为容器中的Bean实现提供了更灵活的方式，FactoryBean在IOC容器的基础上给Bean的实现上提供了工厂模式和装饰模式，我们可以在getObject（）中灵活的配置。Spring的源码中有很多FactoryBean的实现类。
区别：
- BeanFactory是个Factory，也就是容器或者对象的工厂，
- FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFacotry（IOC容器）管理的。但对FacotryBean而言，这个Bean不是简单的Bean，主要的功能就是生产和装饰对象生产的工厂Bean，他的设计理念就是上文的工厂模式和装配模式
2.BeanFactory
它负责生产和管理Bean的工厂，它是IOC容器的核心接口，他的职责包括：实例化、定位、配置应用程序中的对象以及建立这些对象之间的依赖。它只是一个接口，并不是IOC容器的具体体现，但是Spring给出了它的很多具体实现。DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext，三者都是实现了BeanFacotry并在基础之上提供了附加的功能，XMLBeanFactory就是常用的一个，将Bean与XML之间绑定来描述类于类之间的关系。
2.1.ApplicaitonContext
BeanFactory和ApplicaitonContext就是Spring中两个IOC容器，现在一般使用ApplicaitonContext，它包括BeanFactory的作用，并在其上拥有更多扩展。
ApplicaitonContext更以一种面向框架的方式以及对上下文进行分层和实现继承，ApplicationContext提供了一下更多的功能。
- MessageSource：国际化信息
- 资源的访问：如URL和文件
- 事件传播
- 载入多个有上下文（继承关系），使得每个上下文都专注于一个特定的层次，比如WEB层
没有Spring框架的出现时，我们都是在Service层中new了一个Dao层，出现了很多问题，比如类于类之间的依赖问题。
出现之后，我们只需要注入xml文件，交给spring进行管理。注入XML之后，接着使用getBean（）；通过这样的方式获得bean的实例，beanFactory提供的方法都很简单，包括一下六种
- boolean containBean（String BeanName）用来判断容器中是否含有指定的bean。
- Object getBean（String BeanName） 返回给定名称的注册bean实例。根据bean的配置情况，单例的话返回共享的实例，如果是多例的情况下，则返回一个新的实例，如果没有这个bean，就抛出异常。
- Object getBean（String BeanName ， Class clazz）返回一个指定的bean，并转换为给定的class对象。
- Class getType（String name）返回给定class名称的bean，如果没有则抛出NoSuchBeanDefinitionException。
- boolean Signleton（String name）判断给定的bean是否为单例
- String[] getAliases（String name）获取给定bean的所有别名
package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}
3.FactoryBean
一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化bean，在一些情况下，实例化bean比较复杂，如果按照传统方式，则需要在<bean>中提供大量的配置信息，配置的灵活方式受限制，所以Spring提供了一个FactoryBean的工厂类接口，用户可以该接口定制实力化bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。他们都隐藏了一些实例化一些复杂的细节，给上层应用带来了便利。从Spring3开始，FactoryBean开始支持泛型，即接口名声改为FactoryBean<T>形式
它以Bean结尾，表示他是一个Bean，不同于Bean的是：它是实现了FactoryBean泛型接口的bean，通过Bean的ID从BeanFactory中实际获取的是FactoryBean中getObject方法（），并不是Factory本身，如果要获取FactoryBean对象，在ID前面加上一个符号&获取。
4.例如自己实现一个FactoryBean
功能描述： 用来代理对象，对该对象的所有方法做一个拦截，在调用的前后都输出一行Log，模仿PorxyFactoryBean的作用
public class MyFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {
private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);
private String interfaceName;
private Object target;
private Object proxyObj;
@Override
public void destroy() throws Exception {
logger.debug("destroy......");
}
@Override
public void afterPropertiesSet() throws Exception {
proxyObj = Proxy.newProxyInstance(
this.getClass().getClassLoader(),
new Class[] { Class.forName(interfaceName) },
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
logger.debug("invoke method......" + method.getName());
logger.debug("invoke method before......" + System.currentTimeMillis());
Object result = method.invoke(target, args);
logger.debug("invoke method after......" + System.currentTimeMillis());
return result; }
});
logger.debug("afterPropertiesSet......");
}
@Override
public Object getObject() throws Exception {
logger.debug("getObject......");
return proxyObj;
}
@Override
public Class<?> getObjectType() {
return proxyObj == null ? Object.class : proxyObj.getClass();
}
@Override
public boolean isSingleton() {
return true;
}
public String getInterfaceName() {
return interfaceName;
}
public void setInterfaceName(String interfaceName) {
this.interfaceName = interfaceName;
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
public Object getProxyObj() {
return proxyObj;
}
public void setProxyObj(Object proxyObj) {
this.proxyObj = proxyObj;
}
}
<bean id="fbHelloWorldService" class="com.ebao.xxx.MyFactoryBean">
<property name="interfaceName" value="com.ebao.xxx.HelloWorldService" />
<property name="target" ref="helloWorldService" />
</bean>
@RunWith(JUnit4ClassRunner.class)
@ContextConfiguration(classes = { MyFactoryBeanConfig.class })
public class MyFactoryBeanTest {
@Autowired
private ApplicationContext context;
/**
* 测试验证FactoryBean原理，代理一个servcie在调用其方法的前后，打印日志亦可作其他处理
* 从ApplicationContext中获取自定义的FactoryBean
* context.getBean(String beanName) ---> 最终获取到的Object是FactoryBean.getObejct(),
* 使用Proxy.newInstance生成service的代理类
*/
@Test
public void testFactoryBean() {
HelloWorldService helloWorldService = (HelloWorldService) context.getBean("fbHelloWorldService");
helloWorldService.getBeanName();
helloWorldService.sayHello();
}
}
FactoryBean是一个接口，在IOC容器中的Bean实现了FactoryBean后，通过getBean（String BeanName）获取到的对象并不是FactoryBean实现类对象，而是这个实现类中的getObject（）方法返回的对象。想获取FactoryBean的实现类，就要getBean（&BeanName）
package org.springframework.beans.factory;
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<?> getObjectType();
boolean isSingleton();
}
- T getObject():返回由FactoryBean创建的Bean的实例，如果isSingleton（）返回的是true，则会放入单例池中；
- 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的所有属性指定配置值：
import org.springframework.beans.factory.FactoryBean;
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后，就可以在配置文件中使用下面这种自定义的配置方式配置CarBean了：
<bean d="car"class="com.baobaotao.factorybean.CarFactoryBean"
P:carInfo="法拉利,400,2000000"/>
当调用getBean("car")时，Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口，这时Spring容器就调用接口方法CarFactoryBean#getObject()方法返回。如果希望获取CarFactoryBean的实例，则需要在使用getBean(beanName)方法时在beanName前显示的加上"&"前缀：如getBean("&car")。
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<bean id="student" class="com.spring.bean.Student">
<property name="name" value="zhangsan" />
</bean>
<bean id="school" class="com.spring.bean.School">
</bean>
<bean id="factoryBeanPojo" class="com.spring.bean.FactoryBeanPojo">
<property name="type" value="student" />
</bean>
</beans>
import org.springframework.beans.factory.FactoryBean;
public class FactoryBeanPojo implements FactoryBean{
private String type;
@Override
public Object getObject() throws Exception {
if("student".equals(type)){
return new Student();
}else{
return new School();
}
}
@Override
public Class getObjectType() {
return School.class;
}
@Override
public boolean isSingleton() {
return true;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
public class School {
private String schoolName;
private String address;
private int studentNumber;
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getStudentNumber() {
return studentNumber;
}
public void setStudentNumber(int studentNumber) {
this.studentNumber = studentNumber;
}
@Override
public String toString() {
return "School [schoolName=" + schoolName + ", address=" + address
+ ", studentNumber=" + studentNumber + "]";
}
}
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring.bean.FactoryBeanPojo;
public class FactoryBeanTest {
public static void main(String[] args){
String url = "com/spring/config/BeanConfig.xml";
ClassPathXmlApplicationContext cpxa = new ClassPathXmlApplicationContext(url);
Object school= cpxa.getBean("factoryBeanPojo");
FactoryBeanPojo factoryBeanPojo= (FactoryBeanPojo) cpxa.getBean("&factoryBeanPojo");
System.out.println(school.getClass().getName());
System.out.println(factoryBeanPojo.getClass().getName());
}
}
从结果上可以看到当从IOC容器中获取FactoryBeanPojo对象的时候，用getBean(String BeanName)获取的确是Student对象，可以看到在FactoryBeanPojo中的type属性设置为student的时候，会在getObject()方法中返回Student对象。所以说从IOC容器获取实现了FactoryBean的实现类时，返回的却是实现类中的getObject方法返回的对象，要想获取FactoryBean的实现类，得在getBean(String BeanName)中的BeanName之前加上&,写成getBean(String &BeanName)。
