你了解Spring BeanFactoryAware嘛

其实再写这篇文章之前呢，我是看Spring IOC源码，可是老师啃不动。那么就从外围开始吧。在Spring生命周期的探索当中，其中网上主流的做法就是让我们的Bean实现一大波接口，到目前为止，这些接口的名称一个也没有记住，Spring的这个名称太长啦。其中有这么一个接口BeanFactoryAware。什么意思呢？

在我之前的文章中为大家介绍过，那就是Spring的Bean是无知觉的。类似于Http请求的无状态一般。Bean是要注入在Spring容器当中的，也就是BeanFactory以及ApplicationContext这两个容器。为了使得Bean存在意识感，那么就要实现一些类Aware接口。而Aware接口也恰好是意识、直觉的意思。

下面的代码是我演示实现了这个接口之后的一些操作：

首先我们看看BeanFactoryAware接口的架构：

public interface BeanFactoryAware extends Aware {


    void setBeanFactory(BeanFactory beanFactory) throws BeansException;

}

这个Aware接口就是意识的意思。BeanFactoryAware就是让我们的Bean在容器中有存在感。知道老子在炼丹炉中一样。看BeanFactoryAware就一个方法，setBeanFactory,传的参数很简单，就是BeanFactory容器。

public class Car implements BeanFactoryAware{
    private String brand;
    private String color;
    private int maxSpeed;

    private BeanFactory beanFactory;

    public String getBrand() {
        return brand;
    }

    public void setBrand(final String brand) {
        System.out.println("调用Car的setBrand属性");
        this.brand = brand;
    }

    @Override
    public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
        System.out.println("调用BeanFactoryAware的setBeanFactory方法--->");
        this.beanFactory=beanFactory;
    }

    @Override public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                ", maxSpeed=" + maxSpeed +
                '}';
    }
}

上述的Bean很简单，就是三个字段，外加一个BeanFactory接口。实现了setBeanFactory方法。其中的brand设置了setter方法。下面是我的xml配置以及单元测试：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="car" class="com.gosaint.domain.Car"/>
</beans>

    @Test
    public void testLife(){
        ApplicationContext applicationContext=
                new ClassPathXmlApplicationContext("classpath:spring/spring-beans.xml");
        Car car = (Car) applicationContext.getBean("car");
        car.setBrand("奔驰");
        System.out.println(car);

    }

获取结果如下：

调用BeanFactoryAware的setBeanFactory方法--->

调用Car的setBrand属性

Car{brand='奔驰', color='null', maxSpeed=0}

可以清楚的看到，在调用brand的setter方法之前，是调用了BeanFactoryAware接口的setBeanFactory()方法的。其实上述的代码也很好理解，可能大家要问，什么时候beanFactory实例化的呢。其实在上述的代码中，在通过ClasspathXmlApplicationContext获取容器的时候，读取配置文件，定位到Bean,实例化对象之后就开始讲BeanFactory注入到Car这个Bean当中啦。

但是我这样做只是用来探究这个接口的实际含义，其实Spring是不推荐这样做的，就是不推荐我们的Bean去实现这个接口。一旦我们的bean实现了这个接口，那么Bean就和Spring框架产生了严重的耦合。

思考一个问题，就是我们在平时使用Spring Bean的时候是怎么使用的？是不是一般就是在xml中配置，然后直接使用@Autowired来使用。实现了该接口我们是不是可以直接从Spring容器中获取相关的对象？

@Service
public class BeanFactoryHelper implements BeanFactoryAware {

    private  BeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    public  Object getBean(String beanName){

　　　　 if(beanFactory == null){
            throw new NullPointerException("BeanFactory is null!");
        }
　　　　 return beanFactory.getBean(beanName); 
　　} 
}

此时是不是可以直接调用getBean("XXX")去获取呢？我再来设想一个场景：假设我有一个Service的接口，恰好实现了这和接口，就如上述的代码所示；比如说我有2个业务处理对象，他们都继承了我的BeanFactoryHelper对象，但是具体处理的时候要哪家业务的对象呢？这个依赖于用户的选择。你可以注入2个BeanFactoryHelper实例，然后用if --else来搞，不过那样太坨了。每增加一个业务你都需要改代码。繁琐的操作如下：

public void testLife2(){
        ApplicationContext applicationContext=
                new ClassPathXmlApplicationContext("classpath:spring/spring-beans.xml");
        BeanFactoryHelper helper =
                (BeanFactoryHelper) applicationContext.getBean("beanFactoryHelper");
        helper=new Demo001();
        handler(helper);
    }
    public void handler(Object obj){
        if(obj instanceof Demo001){
           //TODO 处理001的业务 
        }else if(obj instanceof Demo002){
            //TODO 处理002的业务  
        }
    }

以后若是变动，还要添加代码。如果实现BeanFactoryAware，那么一切都好说，因为Spring实例化之后，我们只需要根据bean的名称获取对象即可。不会去实例化每一个对象。下面的代码是我之前项目中的一个片段：

 1public class ControlServiceImpl implements IControlService, BeanFactoryAware {
 2    private BeanFactory factory;
 3
 4    @Override
 5    public void setBeanFactory(BeanFactory factory) {
 6        this.factory = factory;
 7    }
 8    @Override
 9    public OutputObject execute(InputObject inputObject) {
10        System.out.println("--------------ControlServiceImpl.execute()方法---------");
11
12        OutputObject outputObject = new OutputObject(ControlConstants.RETURN_CODE.IS_OK);
13        try {
14            outputObject.setReturnCode(ControlConstants.RETURN_CODE.IS_OK);
15            if (inputObject != null) {
16                Object object = factory.getBean(inputObject.getService());
17                Method mth = object.getClass().getMethod(inputObject.getMethod(), InputObject.class, OutputObject.class);
18                mth.invoke(object, inputObject, outputObject);
19            } else {
20                throw new Exception("InputObject can't be null !!!");
21            }
22        } catch (Exception e) {
23            // 异常处理
24
25        } finally {
26
27        }
28        return outputObject;
29    }
30}

作为后台service的统一入口：我实现了这个BeanFactoryAware接口。然后通过factory.getBean(Object)去动态的获取每一个Service。然后反射动态调用service中的方法，这样的实现是不是很好！其实我们要根据自身的业务场景去灵活的解决我们的问题。虽然说这样代码耦合度太高，但是现在那个项目离开Spring还能单独存活呢？当然是有的，可是目前主流开发都是离不开Spring的。

总结：1 实现BeanFacoryAware接口，是在Bean实例化后开始调用，在Setter方法之前调用。2 实现了BeanFacoryAware接口，可以使得bean获取到容器的内部信息，从而进行某些定制化的操作。3 实现了实现了BeanFacoryAware接口，可以使得Bean在容器中有意识，这样的目的是2中所说的。

一个人生气蓬勃的时候决不问为什么生活，只是为生活而生活——为了生活是桩美妙的事而生活。 from 《约翰·克里斯朵夫》

你了解Spring BeanFactoryAware嘛

猜你喜欢