[Spring手撸专栏学习笔记]——FactoryBean的实现和使用

一定会去到彩虹海的麦当

已于 2022-02-07 08:51:16 修改

阅读量646

点赞数 4

分类专栏： Spring 文章标签： spring java 后端

于 2022-02-07 08:13:30 首次发布

本文链接：https://blog.csdn.net/weixin_65349299/article/details/122803967

版权

Spring 专栏收录该内容

14 篇文章 3 订阅

订阅专栏

本文是学习《Spring 手撸专栏》第 10 章笔记，主要记录我的一些debug调试过程，方便后期复习。具体学习，大家可以去看一下这个专栏，强烈推荐。

设计

关于提供一个能让使用者定义复杂的 Bean 对象，功能点非常不错，意义也非常大，因为这样做了之后 Spring 的生态种子孵化箱就此提供了，谁家的框架都可以在此标准上完成自己服务的接入。
但这样的功能逻辑设计上并不复杂，因为整个 Spring 框架在开发的过程中就已经提供了各项扩展能力的接茬，你只需要在合适的位置提供一个接茬的处理接口调用和相应的功能逻辑实现即可，像这里的目标实现就是对外提供一个可以二次从 FactoryBean 的 getObject 方法中获取对象的功能即可，这样所有实现此接口的对象类，就可以扩充自己的对象功能了。MyBatis 就是实现了一个 MapperFactoryBean 类，在 getObject 方法中提供 SqlSession 对执行 CRUD 方法的操作 整体设计结构如下图：
1643682771714-064bc216-2bf0-4540-b3b4-50c5766af6a9

整个的实现过程包括了两部分，一个解决单例还是原型对象，另外一个处理 FactoryBean 类型对象创建过程中关于获取具体调用对象的 getObject 操作。
SCOPE_SINGLETON、SCOPE_PROTOTYPE，对象类型的创建获取方式，主要区分在于 AbstractAutowireCapableBeanFactory#createBean 创建完成对象后是否放入到内存中，如果不放入则每次获取都会重新创建。
createBean 执行对象创建、属性填充、依赖加载、前置后置处理、初始化等操作后，就要开始做执行判断整个对象是否是一个 FactoryBean 对象，如果是这样的对象，就需要再继续执行获取 FactoryBean 具体对象中的 getObject 对象了。整个 getBean 过程中都会新增一个单例类型的判断factory.isSingleton()，用于决定是否使用内存存放对象信息。

起始

  public void test_factory_bean() {
        // 1.初始化 BeanFactory (1)
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
        applicationContext.registerShutdownHook();

        // 2. 调用代理方法 (2)
        UserService userService = applicationContext.getBean("userService", UserService.class);
        System.out.println("测试结果：" + userService.queryUserInfo());
    }

因为我们这里的userService是多例的，所以取bean的时候还要再走一遍这个doGetBean()流程

(1) AbstractApplicationContext

 public void refresh() throws BeansException {
        //1 创建BeanFactory,并加载BeanDefinition
        refreshBeanFactory();//(3)

        //2 获取BeanFactory
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();

        //3 在Bean实例化之前，执行BeanFactoryPostProcessor(调用在上下文中注册为bean的工厂处理器)
        invokeBeanFactoryPostProcessors(beanFactory);

        //4 BeanPostProcessor 需要提前于其他Bean对象实例化之前执行注册操作，会在这里
        //实例化MyBeanPostProcessor
        registerBeanPostProcessors(beanFactory);

        //5 提前实例化单例Bean对象,会在这里调用MyBeanPostProcessor修改新实例化 Bean 对象
        beanFactory.preInstantiateSingletons();//(2)


    }

（2）AbstractBeanFactory
从（1）到（2）还有一些步骤，这里省略不重复说了，具体可以参考第7章。
这里是创建bean的一些集中管理，根据条件调用不同的创建bean的策略

注意这里的存在单例或者不存在，都要调用getObjectForBeanInstance，因为他们都有可能是FactoryBean，都需要进行判断

protected <T> T  doGetBean(final  String name,final Object[] args){
        Object sharedInstance = getSingleton(name);
        //如果是已存在的话（单例会被存放起来）
       if (sharedInstance != null){
            return (T) getObjectForBeanInstance(sharedInstance,name);//(3)
        }
		//如果未存在，则进行创建
        BeanDefinition beanDefinition = getBeanDefinition(name);
        Object bean = creatBean(name, beanDefinition, args);//(9)
        return (T) getObjectForBeanInstance(bean,name);//(3)
    }

(3)AbstractBeanFactory

如果是FactoryBean的话，则需要特别处理
看内存是否存在，存在直接获取，不存在则进行创建
如果不存在则调用 FactoryBeanRegistrySupport#getObjectFromFactoryBean，执行具体的操作。

 private Object getObjectForBeanInstance(Object beanInstance, String beanName) {
        if (!(beanInstance instanceof FactoryBean)) {
            return beanInstance;
        }

       //如果是FactoryBean，则进入
        Object object = getCachedObjectForFactoryBean(beanName);//(5)

        if (object == null) {
            FactoryBean<?> factoryBean = (FactoryBean<?>) beanInstance;
            object = getObjectFromFactoryBean(factoryBean, beanName);//(6)
        }

        return object;
    }

(5)FactoryBeanRegistrySupport

  /**
     * 缓存操作 factoryBeanObjectCache，用于存放单例类型的对象，避免重复创建
     */
    private final Map<String,Object> factoryBeanObjectCache = new ConcurrentHashMap<String,Object>();

 protected Object getCachedObjectForFactoryBean(String beanName){
        Object object = this.factoryBeanObjectCache.get(beanName);
        return (object != NULL_OBJECT ? object : null);
    }

(6)FactoryBeanRegistrySupport
因为既有缓存的处理也有对象的获取，所以额外提供了此方法进行逻辑包装

protected Object getObjectFromFactoryBean(FactoryBean factory,String beanName){
        if (factory.isSingleton()){
            Object object = this.factoryBeanObjectCache.get(beanName);
            if(object == null){
                object = doGetObjectFromFactoryBean(factory, beanName);
                this.factoryBeanObjectCache.put(beanName,(object !=null ? object: NULL_OBJECT));
            }
            return (object != NULL_OBJECT ? object:null);
        }else {
            return doGetObjectFromFactoryBean(factory,beanName);
        }
    }

（7）FactoryBeanRegistrySupport
在这里调用我们实现了FactoryBean接口的bean的getObject方法

private Object doGetObjectFromFactoryBean(final FactoryBean factory,final String beanName){
        try {
            return factory.getObject();//(8)
        }catch (Exception e){
            throw new BeansException("FactoryBean threw exception on object["+beanName+"] creation",e);
        }
    }

(8)ProxyBeanFactory
我们这里使用了代理，代理了IUserDao的功能。

@Override
    public IUserDao getObject() throws Exception {
        InvocationHandler handler = (proxy, method, args) -> {
           Map<String,String> hashMap = new HashMap<>();
           hashMap.put("10001","wcl");
           hashMap.put("10002","啦啦啦");
           hashMap.put("10003","阿毛");
           return "你被代理了 "+method.getName()+":"+hashMap.get(args[0]).toString();
        };
        return (IUserDao) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),new Class[]{IUserDao.class},handler);
    }

（9）AbstractAutowireCapableBeanFactory
在这里会判断bean是否是单例，如果是单例则需要将其添加到DefaultSingletonBeanRegistry中的单例集合中进行注册

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

    private Map<String,Object> singletonObjects = new HashMap<>();
    ...
}

//利用反射进行bean的实例化
    @Override
    protected Object creatBean(String beanName,BeanDefinition beanDefinition,Object[] args) throws BeansException {
       Object bean = null;
       try {
           bean = createBeanInstance(beanDefinition,beanName,args);
           //给Bean填充属性
           applyPropertyValues(beanName,bean,beanDefinition);
           //执行Bean 的初始化方法和BeanPostProcessor的前置和后置处理方法(这些是我们自己额外定义的)
           bean = initializeBean(beanName,bean,beanDefinition);
       } catch (Exception e) {
           throw new BeansException("Instantiation of bean failed",e);
       }

       //注册实现了DisposableBean 接口的Bean对象
        registerDisposableBeanIfNecessary(beanName,bean,beanDefinition);

       //判断SCOPE_SINGLETON、SCOPE+PROTOTYPE  
        if (beanDefinition.isSingleton()){ 
            addSingleton(beanName,bean);
        }

        return bean;
    }