对Spring源码的学习：Bean实例化流程

目录

SpringBean实例化流程

Spring的后处理器

Bean工厂后处理器

Bean后处理器

---

SpringBean实例化流程

Spring容器在进行初始化时，会将xml配置的<bean>的信息封装成一个BeanDefinition对象，所有的BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为sinaletonObiects的Map集合中，当调用getBean方法时则最终从该Map集合中取出Bean实例对象返回

对该方法进行断点观察

因此我们可以总结如下流程图

Spring的后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器：

• BeanFactoryPostProcessor：Bean工厂后外理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行。
• BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行。

Bean工厂后处理器

我们需要实现BeanFactoryPostProcessor接口，然后重写其方法，该方法中的参数实际上就是Spring容器，我们可以通过该容器获取BeanDefinition信息，然后对这些信息进行修改，在下面代码中，我们修改了UserService的全路径，这会导致在实例化Bean时通过反射拿到的实际上时UserDao类。

public class MyBeanFactoryProcessor implements BeanFactoryPostProcessor {
    @Override
    //在Map加载完成后执行
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //beanFactory无法一次获取全部的Map信息，只能通过key获取
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
        System.out.println("当前的Bean的全路径"+beanDefinition.getBeanClassName());
        beanDefinition.setBeanClassName("com.zmt.dao.impl.UserDaoImpl");
    }
}

配置完成不代表生效，我们需要将该类交给Spring管理，然后由Spring来回调该方法，因此需要修改xml文件

<beans>
  <bean id="userService" class="com.zmt.service.impl.UserServiceImpl"></bean>

  <bean id="userDao" class="com.zmt.dao.impl.UserDaoImpl"></bean>
  <!-- 添加为Bean对象 -->
  <bean class="com.zmt.processor.MyBeanFactoryProcessor"></bean>
</beans>

测试代码如下

public class ApplicationContextTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Object userService =  context.getBean("userService");
        System.out.println(userService);
    }
}

运行结果如下

当前的Bean的全路径com.zmt.service.impl.UserServiceImpl

com.zmt.dao.impl.UserDaoImpl@5649fd9b

如果我们需要向Map中添加BeanDefinition数据，在创建完BeanDefinition之后无法将其注册到Map中，需要实现该接口的子接口BeanDefinitionRegistryPostProcessor。下面我们创建一个PersonDao接口以及实现类，但是不在xml文件中定义，通过Bean工厂后处理器添加在Map当中，测试能否getBean时获取到对应类

<beans>
  <bean id="userService" class="com.zmt.service.impl.UserServiceImpl"></bean>

  <bean id="userDao" class="com.zmt.dao.impl.UserDaoImpl"></bean>

  <bean class="com.zmt.processor.MyBeanFactoryRegistryProcessor"></bean>
</beans>

public class MyBeanFactoryRegistryProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        RootBeanDefinition beanDefinition = new RootBeanDefinition();
        //设置全路径
        beanDefinition.setBeanClassName("com.zmt.dao.impl.PersonDaoImpl");
        //添加到Map中
        beanDefinitionRegistry.registerBeanDefinition("personDao",beanDefinition);
    }

    //该方式是父接口中的方法，我们可以不编写业务代码
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

测试代码

public class ApplicationContextTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        PersonDaoImpl personDao = context.getBean(PersonDaoImpl.class);
        System.out.println(personDao);
    }
}
/**
* 运行结果如下
* com.zmt.dao.impl.PersonDaoImpl@64bfbc86
*/

此时，我们可能存在一个疑惑，那就是如果配置了多个Bean工厂后处理器，那么执行顺序应该是什么？接下来我们对其进行测试

public class MyBeanFactoryProcessor implements BeanFactoryPostProcessor {
    @Override
    //在Map加载完成后执行
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //beanFactory无法一次获取全部的Map信息，只能通过key获取
        System.out.println("执行MyBeanFactoryProcessor中的postProcessBeanFactory方法");
    }
}

public class MyBeanFactoryRegistryProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("执行MyBeanFactoryRegistryProcessor中的postProcessBeanDefinitionRegistry方法");
    }


    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("执行MyBeanFactoryRegistryProcessor中的postProcessBeanFactory方法");

    }
}

执行结果如下

执行MyBeanFactoryRegistryProcessor中的postProcessBeanDefinitionRegistry方法

执行MyBeanFactoryRegistryProcessor中的postProcessBeanFactory方法

执行MyBeanFactoryProcessor中的postProcessBeanFactory方法

由此我们可以得出结论，优先执行BeanFactoryProcessor的子类独有方法，再执行子类中继承来的父类方法，最后执行BeanFactory中的方法。

因此，我们可以总结Bean工厂后处理器的执行时机在Spring启动流程中如下

Bean后处理器

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如: 属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。

Bean后处理器中有两个方法分别为

要实现Bean后处理器，需要实现BeanPostProcessor接口，重写需要要实现的方法。接下来编写Bean后处理器来测试Bean后处理器两个方法的执行时机

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+":Bean后处理器初始化前方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+":Bean后处理器初始化后方法");
        return bean;
    }
}

public class UserServiceImpl implements UserService , InitializingBean {
    public UserServiceImpl() {
        System.out.println("userService调用无参构造器");
    }

    private void init(){
        System.out.println("userService执行init方法");
    }

    //该方法由beanFactory来调用，set注入
    public void setUserDao(UserDao userDao){
        System.out.println("由bean工厂调用该set方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("userService执行属性注入后方法");
    }
}

<beans>
  
  <bean id="userService" class="com.zmt.service.impl.UserServiceImpl" init-method="init">
    <property name="userDao" ref="userDao"></property>
  </bean>

  <bean id="userDao" class="com.zmt.dao.impl.UserDaoImpl"></bean>

  <bean class="com.zmt.processor.MyBeanFactoryProcessor"></bean>

  <bean class="com.zmt.processor.MyBeanPostProcessor"></bean>

</beans>

运行结果如下

执行MyBeanFactoryProcessor中的postProcessBeanFactory方法
userService调用无参构造器
userDao:Bean后处理器初始化前方法
userDao:Bean后处理器初始化后方法
由bean工厂调用该set方法
userService:Bean后处理器初始化前方法
userService执行属性注入后方法
userService执行init方法
userService:Bean后处理器初始化后方法

在Spring中，大量采用Bean后处理器对Bean对象进行加强处理，通常会对bean对象做代理，下面就是一个对userService类对象进行进行加强，在执行方法时统计该方法执行时间

public class UserServiceImpl implements UserService {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void print() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法print开始执行");
        System.out.println("name："+name);
    }
}

public class MyTimeLogBeanPostProcessor implements BeanPostProcessor {

    /**
     * 后处理器前初始化方法。作用时间为bean实例化完成之后，可以对bean对象初始化赋值
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof UserService){
            ((UserSerivce) bean).setName("张三");
        }
        return bean;
    }

    /**
     * 后处理器后处理方法。作用时间为bean添加到单例池之前，主要作用是对bean对象做增强
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Object proxyInstance = Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    System.out.println("记录时间" + new Date());
                    Object invoke = method.invoke(bean, args);
                    System.out.println("记录停止" + new Date());
                    return invoke;
                });
        return proxyInstance;
    }
}

执行结果如下

方法print开始执行Fri Dec 08 17:52:46 CST 2023
方法print开始执行
name：张三
方法print执行结束Fri Dec 08 17:52:49 CST 2023

被加强后的bean会被加载到单例池中，并且无论去执行哪些方法都会执行时间日志输出。

总结Bean处理器执行流程如下