网站导航
> 文档中心 > spring refresh()方法详解，阿里腾讯大厂必问面试考点（启动spring,创建bean的过程）

spring refresh()方法详解，阿里腾讯大厂必问面试考点（启动spring,创建bean的过程）

网友: 文档中心 2022-03-16 14:13:17

spring refresh 详解

文章目录

  • spring refresh 详解
    • 1.prepareRefresh
    • 2.obtainFreshBeanFactory
    • 3.prepareBeanFactory
    • 4.postProcessBeanFactory
    • 5.invokeBeanFactoryPostProcessors(beanFactory) 执行 beanFactory 后置处理器的方法
    • 6.registerBeanPostProcessors(beanFactory) 注册 bean 的后置处理器
    • 7.initMessageSource() 初始化 MessageSource 组件
      • 8.initApplicationEventMulticaster() 初始化事件派发器,多播器
    • 9.onRefresh() 用来初始化子容器中的bean,默认是空方法
    • 10.registerListeners() 注册监听器
    • 11. finishBeanFactoryInitialization(beanFactory) 初始化所有剩下的单实例 bean
    • 12.finishRefresh() 完成ben的创建初始化工作,完成 IOC 容器的创建
    • 总结

refres十二个步骤

refresh十二个步骤

1.prepareRefresh

做好准备工作

protected void prepareRefresh() {//记录时间 this.startupDate = System.currentTimeMillis(); //设置当前容器未关闭 this.closed.set(false); //设置当前容器已激活 this.active.set(true); if (this.logger.isInfoEnabled()) { //打印容器刷新日志     this.logger.info("Refreshing " + this); }//初始化一下属性(该方法默认是空的,是提供给子类来实现的,//假设我们有些工作需要在初始化bean以前就要加载设置等,可以通过重写这个方法来完成) this.initPropertySources(); //校验设置的属性是否合法 this.getEnvironment().validateRequiredProperties(); //初始化一个集合属性,提供用来保存后面创建的事件,如果有事件发生会放入这个集合中 this.earlyApplicationEvents = new LinkedHashSet();    }

2.obtainFreshBeanFactory

创建或获取BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {//刷新bean工厂,创建一个 DefaultListableBeanFactory类型的 bean工厂//赋值给 beanFactory 属性,对创建的这个 beanFactory 设置一个序列号 this.refreshBeanFactory(); //获取beanFactory,就上将上一步设置好序列号的的beanFactory返回回来 ConfigurableListableBeanFactory beanFactory = this.getBeanFactory(); //打印日志 if (this.logger.isDebugEnabled()) {     this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory); }//将创建好的 beanFactory 返回 return beanFactory;    }

3.prepareBeanFactory

准备BeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {//设置类加载器 beanFactory.setBeanClassLoader(this.getClassLoader()); //设置表达式语言解析器.... beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment())); //设置添加一个 tApplicationContextAwareProcessor 后置处理器 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));  //设置忽略的自动装配的接口,就是设置这些接口的实现类不能通过这些接口实现自动注入 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);//注册可以解析的自动装配,假设想要使用@Autowired 注解将Spring提供的 BeanFactory //装配到自己,创建的某个类的属性上,就要在此处设置 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this);//设置添加一个ApplicationListenerDetector后置处理器 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));//添加编译时支持AspectJ if (beanFactory.containsBean("loadTimeWeaver")) {     beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));     beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); }//向beanFactory中注册组件 if (!beanFactory.containsLocalBean("environment")) { //注册了一个 Environment,该对象中存了一下我们默认的属性     beanFactory.registerSingleton("environment", this.getEnvironment()); } if (!beanFactory.containsLocalBean("systemProperties")) { //向beanFactory中注册了系统属性属性(一个Map集合)     beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean("systemEnvironment")) { //向beanFactory中注册环境变量等相关信息(一个Map集合)     beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment()); }    }

4.postProcessBeanFactory

子类扩展BeanFactory,该方法默认是空的,为子类通过的,假设后续开发中,在 beanFactory 创建并且有准备完成后需要执行某些操作,可以提供子类重写这个方法来实现
以上可以看为beanFactory 的创建及预准备工作

5.invokeBeanFactoryPostProcessors(beanFactory) 执行 beanFactory 后置处理器的方法

执行实现了 BeanFactoryPostProcessors 接口的beanFactory后置处理器中方法,也就是beanFactory初始化完成后要执行的方法
注意 beanFactory 后置处理器 BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor的不同

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {//执行beanFactory后置处理器中的方法,该方法中获取所有BeanFactoryPostProcessor,遍历判断//对不同的BeanFactoryPostProcessor进行排序,因为先后执行的顺序不同,//PriorityOrdered>BeanDefinitionRegistryPostProcessor>BeanFactoryPostProcessor//然后执行后置处理器中定义的初始化 beanFactory 后要执行的方法 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors()); if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {     beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));     beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); }    }

6.registerBeanPostProcessors(beanFactory) 注册 bean 的后置处理器

注意不同的 BeanPostProcessors,该接口下的子接口: 不同接口的执行时机不同

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {//根据类型获取 beanFactory 中所有的 BeanPostProcessor 名字 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; //添加了一个后置处理器,通过添加的这个后置处理器检查 前获取的这些后置处理器 BeanPostProcessorChecker 是一个内部类,继承了BeanPostProcessor接口 beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); //创建两个集合用来存放不同的BeanPostProcessor,通过这两个集合对不同的BeanPostProcessor 进行排序 List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList(); List<BeanPostProcessor> internalPostProcessors = new ArrayList(); List<String> orderedPostProcessorNames = new ArrayList(); List<String> nonOrderedPostProcessorNames = new ArrayList(); String[] var8 = postProcessorNames; int var9 = postProcessorNames.length; String ppName; BeanPostProcessor pp;//遍历获取 BeanPostProcessor, 判断不同的 BeanPostProcessor 放入不同的集合中//实现了 PriorityOrdered 的放入priorityOrderedPostProcessors集合中//实现了PriorityOrdered 并且是MergedBeanDefinitionPostProcessor类型的放入internalPostProcessors//实现了 Ordered 的放入 orderedPostProcessorNames 集合中//否则放入 nonOrderedPostProcessorNames 集合中 for(int var10 = 0; var10 < var9; ++var10) {     ppName = var8[var10];     if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {  pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);  priorityOrderedPostProcessors.add(pp);  if (pp instanceof MergedBeanDefinitionPostProcessor) {      internalPostProcessors.add(pp);  }     } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {  orderedPostProcessorNames.add(ppName);     } else {  nonOrderedPostProcessorNames.add(ppName);     } }//首先对 priorityOrderedPostProcessors 中的进行排序 sortPostProcessors(beanFactory, priorityOrderedPostProcessors); //注册,也就是创建BeanPostProcessor设置到beanFactory中 registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors); List<BeanPostProcessor> orderedPostProcessors = new ArrayList(); Iterator var14 = orderedPostProcessorNames.iterator();//遍历orderedPostProcessorNames集合中的BeanPostProcessor 如果有//MergedBeanDefinitionPostProcessor类型的,将这个类型的后置处理器放入internalPostProcessors集合 while(var14.hasNext()) {     String ppName = (String)var14.next();     BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);     orderedPostProcessors.add(pp);     if (pp instanceof MergedBeanDefinitionPostProcessor) {  internalPostProcessors.add(pp);     } }//对orderedPostProcessors集合中的后置处理器排序 sortPostProcessors(beanFactory, orderedPostProcessors); //注册 registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors); List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList(); Iterator var17 = nonOrderedPostProcessorNames.iterator();//继续排序,分类 while(var17.hasNext()) {     ppName = (String)var17.next();     pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);     nonOrderedPostProcessors.add(pp);     if (pp instanceof MergedBeanDefinitionPostProcessor) {  internalPostProcessors.add(pp);     } }//注册nonOrderedPostProcessors集合中的后置处理器 registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors); //对internalPostProcessors集合中的后置处理器进行排序 sortPostProcessors(beanFactory, internalPostProcessors); //注册internalPostProcessors集合中的后置处理器 registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);  //又添加了一个后置处理器ApplicationListenerDetector,//该后置处理器用来判断是否是某个监听器,如果是添加到容器中 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));    }

7.initMessageSource() 初始化 MessageSource 组件

为ApplicationContext提供国际化功能

protected void initMessageSource() {//获取beanFactory ConfigurableListableBeanFactory beanFactory = this.getBeanFactory(); //判断beanFactory中是否有一个id为"messageSource" 的 bean if (beanFactory.containsLocalBean("messageSource")) { //如果有通过id获取这个bean,赋值给 messageSource  属性     this.messageSource = (MessageSource)beanFactory.getBean("messageSource", MessageSource.class);     if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {  HierarchicalMessageSource hms = (HierarchicalMessageSource)this.messageSource;  if (hms.getParentMessageSource() == null) {      hms.setParentMessageSource(this.getInternalParentMessageSource());  }     }     if (this.logger.isDebugEnabled()) {  this.logger.debug("Using MessageSource [" + this.messageSource + "]");     } } else { //如果没有创建一个MessageSource组件     DelegatingMessageSource dms = new DelegatingMessageSource();     //将这个组件注册到容器中(以后获取国际化配置文件的相关信息,可以通过@Autowired在Spring     //容器中直接获取装配到自己的类的属性上,然后调用MessageSource的方法)     dms.setParentMessageSource(this.getInternalParentMessageSource());     this.messageSource = dms;     beanFactory.registerSingleton("messageSource", this.messageSource);     if (this.logger.isDebugEnabled()) {  this.logger.debug("Unable to locate MessageSource with name 'messageSource': using default [" + this.messageSource + "]");     } }    }

8.initApplicationEventMulticaster() 初始化事件派发器,多播器

protected void initApplicationEventMulticaster() {//获取beanFactory ConfigurableListableBeanFactory beanFactory = this.getBeanFactory(); //1.获取beanFactory中id为"applicationEventMulticaster"的事件派发器 if (beanFactory.containsLocalBean("applicationEventMulticaster")) {     this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);     if (this.logger.isDebugEnabled()) {  this.logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");     } } else { //如果没有创建一个 SimpleApplicationEventMulticaster 事件派发器,     this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);     //注册到 Spring 容器中     beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);     if (this.logger.isDebugEnabled()) {  this.logger.debug("Unable to locate ApplicationEventMulticaster with name 'applicationEventMulticaster': using default [" + this.applicationEventMulticaster + "]");     } }    }

9.onRefresh() 用来初始化子容器中的bean,默认是空方法

留给子类扩展

10.registerListeners() 注册监听器

protected void registerListeners() { Iterator var1 = this.getApplicationListeners().iterator(); while(var1.hasNext()) {     ApplicationListener<?> listener = (ApplicationListener)var1.next();     this.getApplicationEventMulticaster().addApplicationListener(listener); }//在容器中拿到所有的监听器的名字 String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false); String[] var7 = listenerBeanNames; int var3 = listenerBeanNames.length;//遍历,将每个监听器添加到事件派发器中 for(int var4 = 0; var4 < var3; ++var4) {     String listenerBeanName = var7[var4];     this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); }//获取早期设置的事件(派发之前的事件) Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; this.earlyApplicationEvents = null; //如果有 if (earlyEventsToProcess != null) {     Iterator var9 = earlyEventsToProcess.iterator();     while(var9.hasNext()) {  ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();  //将早期的事件派发出去  this.getApplicationEventMulticaster().multicastEvent(earlyEvent);     } }    }

11. finishBeanFactoryInitialization(beanFactory) 初始化所有剩下的单实例 bean

执行Bean后处理器扩展

12.finishRefresh() 完成ben的创建初始化工作,完成 IOC 容器的创建

protected void finishRefresh() {//初始化跟生命周期有关的后置处理器,在容器中获取LifecycleProcessor//类型的后置处理器接口,在容器刷新完成以及关闭时执行的方法,此处是注册//如果没有会注册一个默认的生命周期组件 this.initLifecycleProcessor(); //拿到生命周期处理器,回调onRefresh()容器刷新完成方法, this.getLifecycleProcessor().onRefresh(); //发布容器刷新完成事件 this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this))); LiveBeansView.registerApplicationContext(this);    }

总结

  1. Spring 启动容器时,首先开启激活容器,

  2. 创建初始化 beanFactory ,扫描保存所有注入的bean的定义信息

  3. Spring 创建bean 首先创建实现了 BeanPostProcessors 接口的后置处理器,创建组件相关的bean,例如,国际化的MessageSource 组件, EventMulticaster事件派发器,Listeners 注册监听器等

  4. 然后创建其他剩下的单实例bean,在其它单实例bean被创建时,会被后置处理器监控到,执行创建前后,或初始化前后,定义在后置处理器中的方法: 例如

     AutowiredAnnotationBeanPostProcessor : 通过该后置处理器完成注解自动注入的功能AnnotationAwareAspectJAutoProxyCreator: 通过该后置处理器设置AOP时,对指定目标方法所在类生成动态代理类AsyncAnnotationBeanPostProcessor : 设置异步的后置处理器还有设置定时任务的…
网络标签：

相关问题