目录
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 {@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {RootBeanDefinition beanDefinition = new RootBeanDefinition();//设置全路径beanDefinition.setBeanClassName("com.zmt.dao.impl.PersonDaoImpl");//添加到Map中beanDefinitionRegistry.registerBeanDefinition("personDao",beanDefinition);}//该方式是父接口中的方法,我们可以不编写业务代码@Overridepublic 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 {@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {System.out.println("执行MyBeanFactoryRegistryProcessor中的postProcessBeanDefinitionRegistry方法");}@Overridepublic 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 {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println(beanName+":Bean后处理器初始化前方法");return bean;}@Overridepublic 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方法");}@Overridepublic 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;}@Overridepublic 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对象初始化赋值*/@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if (bean instanceof UserService){((UserSerivce) bean).setName("张三");}return bean;}/*** 后处理器后处理方法。作用时间为bean添加到单例池之前,主要作用是对bean对象做增强*/@Overridepublic 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处理器执行流程如下