Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失？请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

Spring加载流程源码分析03【refresh】

ゞ .邓澎波 2019-02-23 12:21:00 阅读数:191 评论数:0 点赞数:0 收藏数:0

前面两篇文章分析了super(this)和setConfigLocations(configLocations)的源代码，本文来分析下refresh的源码，***[Spring加载流程源码分析01【super】](https://blog.csdn.net/qq_38526573/article/details/87870315)Spring加载流程源码分析02【setConfigLocations】***先来看下ClassPathXmlApplicationContext类的初始化过程：public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException { super(parent); setConfigLocations(configLocations); if (refresh) { refresh(); } }

refresh介绍

refresh方法的具体实现是在AbstractApplicationContext类中如下:@Override public void refresh() throws BeansException, IllegalStateException { //startupShutdownMonitor对象在spring环境刷新和销毁的时候都会用到，确保刷新和销毁不会同时执行 synchronized (this.startupShutdownMonitor) { // 准备工作，例如记录事件，设置标志，检查环境变量等，并有留给子类扩展的位置，用来将属性加入到applicationContext中 prepareRefresh(); // 创建beanFactory，这个对象作为applicationContext的成员变量，可以被applicationContext拿来用, // 并且解析资源（例如xml文件），取得bean的定义，放在beanFactory中 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 对beanFactory做一些设置，例如类加载器、SPEL解析器、指定bean的某些类型的成员变量对应某些对象. prepareBeanFactory(beanFactory); try { // 子类扩展用，可以设置bean的后置处理器（bean在实例化之后这些后置处理器会执行） postProcessBeanFactory(beanFactory); // 执行beanFactory后置处理器（有别于bean后置处理器处理bean实例，beanFactory后置处理器处理bean定义） invokeBeanFactoryPostProcessors(beanFactory); // 将所有的bean的后置处理器排好序，但不会马上用，bean实例化之后会用到 registerBeanPostProcessors(beanFactory); // 初始化国际化服务 initMessageSource(); // 创建事件广播器 initApplicationEventMulticaster(); // 空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作 onRefresh(); // 注册一部分特殊的事件监听器，剩下的只是准备好名字，留待bean实例化完成后再注册 registerListeners(); // 单例模式的bean的实例化、成员变量注入、初始化等工作都在此完成 finishBeanFactoryInitialization(beanFactory); // applicationContext刷新完成后的处理，例如生命周期监听器的回调，广播通知等 finishRefresh(); } catch (BeansException ex) { logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex); // 刷新失败后的处理，主要是将一些保存环境信息的集合做清理 destroyBeans(); // applicationContext是否已经激活的标志，设置为false cancelRefresh(ex); // Propagate exception to caller. throw ex; } } }

接下来一一介绍下

1.prepareRefresh介绍

protected void prepareRefresh() { // 设置初始化开始的时间 this.startupDate = System.currentTimeMillis(); // 设置context的关闭状态为false this.closed.set(false); // 设置context的活动状态是true this.active.set(true); if (logger.isInfoEnabled()) { logger.info("Refreshing " + this); } // Initialize any placeholder property sources in the context environment // 留个子类自己实现的空方法 initPropertySources(); // 验证对应的key在环境变量中是否存在，如果不存在就抛异常 getEnvironment().validateRequiredProperties(); // earlyApplicationEvents存放早起的一些事件。 this.earlyApplicationEvents = new LinkedHashSet(); }

initPropertySources() 留给子类实现的方法

protected void initPropertySources() { // For subclasses: do nothing by default. }

2.obtainFreshBeanFactory()介绍

创建了一个BeanFactory对象/// / Tell the subclass to refresh the internal bean factory. / 子类实现 / @return the fresh BeanFactory instance / @see /#refreshBeanFactory() / @see /#getBeanFactory() // protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { // 子类(AbstractRefreshableApplicationContext)创建一个ConfigurableListableBeanFactory 对象 refreshBeanFactory(); // 获取refreshBeanFactory()实现类中创建的BeanFactory对象 ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (logger.isDebugEnabled()) { logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory); } return beanFactory; }

refreshBeanFactory()

该方法是子类实现的方法，在AbstractRefreshableApplicationContext类中该方法创建了ConfigurableListableBeanFactory 对象并且完成了，并赋值给了beanFactory@Override protected final void refreshBeanFactory() throws BeansException { // 如果BeanFactory存在就销毁 if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { DefaultListableBeanFactory beanFactory = createBeanFactory(); // BeanFactory的初始化操作 beanFactory.setSerializationId(getId()); customizeBeanFactory(beanFactory); // 在次方法中完成了application.xml文件的解析 loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { // 创建的对象赋值给了成员变量beanFactory this.beanFactory = beanFactory; } } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }

进入loadBeanDefinitions(beanFactory)方法查看

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // Create a new XmlBeanDefinitionReader for the given BeanFactory. XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context's // resource loading environment. beanDefinitionReader.setEnvironment(getEnvironment()); beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // Allow a subclass to provide custom initialization of the reader, // then proceed with actually loading the bean definitions. initBeanDefinitionReader(beanDefinitionReader); // 进入该方法查看 loadBeanDefinitions(beanDefinitionReader); }

loadBeanDefinitions(beanDefinitionReader);

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException { String[] configLocations = getConfigLocations(); if (configLocations != null) { for (String configLocation : configLocations) { //继续进入 configLocation 是applicationContext.xml reader.loadBeanDefinitions(configLocation); } } }

进入跟踪

public int loadBeanDefinitions(String location, Set actualResources) throws BeanDefinitionStoreException { //这是我们在前面文章中初始的ResourceLoader对象 ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException( "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available"); } if (resourceLoader instanceof ResourcePatternResolver) { // Resource pattern matching available. try { Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); // 此处进入 int loadCount = loadBeanDefinitions(resources); if (actualResources != null) { for (Resource resource : resources) { actualResources.add(resource); } } if (logger.isDebugEnabled()) { logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]"); } return loadCount; } catch (IOException ex) { throw new BeanDefinitionStoreException( "Could not resolve bean definition resource pattern [" + location + "]", ex); } } else { // Can only load single resources by absolute URL. Resource resource = resourceLoader.getResource(location); int loadCount = loadBeanDefinitions(resource); if (actualResources != null) { actualResources.add(resource); } if (logger.isDebugEnabled()) { logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]"); } return loadCount; } }

继续跟踪

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { Assert.notNull(encodedResource, "EncodedResource must not be null"); if (logger.isInfoEnabled()) { logger.info("Loading XML bean definitions from " + encodedResource.getResource()); } Set currentResources = this.resourcesCurrentlyBeingLoaded.get(); if (currentResources == null) { currentResources = new HashSet(4); this.resourcesCurrentlyBeingLoaded.set(currentResources); } if (!currentResources.add(encodedResource)) { throw new BeanDefinitionStoreException( "Detected cyclic loading of " + encodedResource + " - check your import definitions!"); } try { // 获取applicationContext.xml对应的字节输入流 InputStream inputStream = encodedResource.getResource().getInputStream(); try { InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } // 将配置文件中的信息加载到定义的bean中 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { inputStream.close(); } } catch (IOException ex) { throw new BeanDefinitionStoreException( "IOException parsing XML document from " + encodedResource.getResource(), ex); } finally { currentResources.remove(encodedResource); if (currentResources.isEmpty()) { this.resourcesCurrentlyBeingLoaded.remove(); } } }

跟踪到如下代码

try { Document doc = doLoadDocument(inputSource, resource); return registerBeanDefinitions(doc, resource); }

在这里插入图片描述上面是加载bean定义的关键代码：先制作Document对象，再调用registerBeanDefinitions方法，最终会将每个bean的定义放入DefaultListableBeanFactory的beanDefinitionMap中。

getBeanFactory()

获取refreshBeanFactory()实现类中创建的BeanFactory对象@Override public final ConfigurableListableBeanFactory getBeanFactory() { synchronized (this.beanFactoryMonitor) { if (this.beanFactory == null) { throw new IllegalStateException("BeanFactory not initialized or already closed - " + "call 'refresh' before accessing beans via the ApplicationContext"); } return this.beanFactory; } }

3.prepareBeanFactory

BeanFactory的预准备工作protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 1）、设置BeanFactory的类加载器 beanFactory.setBeanClassLoader(getClassLoader()); // 1）、设置支持表达式解析器 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); ​ // 2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); // 3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx； // 这些接口的实现类不能通过类型来自动注入 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); ​ // 4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入： //BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext // 其他组件中可以通过下面方式直接注册使用 @autowired BeanFactory beanFactory // beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); ​ // 5）、添加BeanPostProcessor【ApplicationListenerDetector】后置处理器，在bean初始化前后的一些工作 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); ​ // 6）、添加编译时的AspectJ； if (beanFactory.containsBean(LOADTIMEWEAVERBEANNAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // Set a temporary ClassLoader for type matching. beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } ​ // 7）、给BeanFactory中注册一些能用的组件； if (!beanFactory.containsLocalBean(ENVIRONMENTBEANNAME)) { // 环境信息ConfigurableEnvironment beanFactory.registerSingleton(ENVIRONMENTBEANNAME, getEnvironment()); } //系统属性，systemProperties【Map】 if (!beanFactory.containsLocalBean(SYSTEMPROPERTIESBEANNAME)) { beanFactory.registerSingleton(SYSTEMPROPERTIESBEANNAME, getEnvironment().getSystemProperties()); } //系统环境变量systemEnvironment【Map】 if (!beanFactory.containsLocalBean(SYSTEMENVIRONMENTBEANNAME)) { beanFactory.registerSingleton(SYSTEMENVIRONMENTBEANNAME, getEnvironment().getSystemEnvironment()); } }

prepareBeanFactory方法就是为beanFactory做一些设置工作，传入一些后面会用到的参数和工具类，再在spring容器中创建一些bean；

4.postProcessBeanFactory

postProcessBeanFactory方法是留给子类扩展的，可以在bean实例初始化之前注册后置处理器（类似prepareBeanFactory方法中的beanFactory.addBeanPostProcessor），以子类AbstractRefreshableWebApplicationContext为例，其postProcessBeanFactory方法protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig)); beanFactory.ignoreDependencyInterface(ServletContextAware.class); beanFactory.ignoreDependencyInterface(ServletConfigAware.class); WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext); WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig); }

除了WebApplicationContextUtils类的工作之外，其余的都是和prepareBeanFactory方法中类似的处理

5.invokeBeanFactoryPostProcessors

nvokeBeanFactoryPostProcessors方法用来执行BeanFactory实例的后置处理器BeanFactoryPostProcessor的postProcessBeanFactory方法，这个后置处理器除了原生的，我们也可以自己扩展，用来对Bean的定义做一些修改，由于此时bean还没有实例化，所以不要在自己扩展的BeanFactoryPostProcessor中调用那些会触发bean实例化的方法（例如BeanFactory的getBeanNamesForType方法），源码的文档中有相关说明，不要触发bean的实例化，如果要处理bean实例请在BeanPostProcessor中进行；在这里插入图片描述protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor) if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOADTIMEWEAVERBEANNAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } }

6.registerBeanPostProcessors

registerBeanPostProcessors方法的代码略多，就不在此贴出来了，简单的说，就是找出所有的bean的后置处理器(注意，是bean的后置处理器，不是beanFactory的后置处理器，bean后置处理器处理的是bean实例，beanfactory后置处理器处理的是bean的定义)，然后将这些bean的后置处理器分为三类：

  1. 实现了顺序接口Ordered.class的，先放入orderedPostProcessors集合，排序后顺序加入beanFactory的bean后处理集合中；
  2. 既没有实现Ordered.class，也没有实现PriorityOrdered.class的后置处理器，也加入到beanFactory的bean后处理集合中；
  3. 最后是实现了优先级接口PriorityOrdered.class的，排序后顺序加入beanFactory的bean后处理集合中；

registerBeanPostProcessors方法执行完毕后，beanFactory中已经保存了有序的bean后置处理器，在bean实例化之后，会依次使用这些后置处理器对bean实例来做对应的处理；在这里插入图片描述

7.initMessageSource

initMessageSource方法用来准备国际化资源相关的，将实现了MessageSource接口的bean存放在ApplicationContext的成员变量中，先看是否有配置，如果有就实例化，否则就创建一个DelegatingMessageSource实例的bean

8.initApplicationEventMulticaster

spring中有事件、事件广播器、事件监听器等组成事件体系，在initApplicationEventMulticaster方法中对事件广播器做初始化，如果找不到此bean的配置，就创建一个SimpleApplicationEventMulticaster实例作为事件广播器的bean，并且保存为applicationContext的成员变量applicationEventMulticaster/// / Initialize the ApplicationEventMulticaster. / Uses SimpleApplicationEventMulticaster if none defined in the context. / @see org.springframework.context.event.SimpleApplicationEventMulticaster // protected void initApplicationEventMulticaster() { //获取BeanFactory ConfigurableListableBeanFactory beanFactory = getBeanFactory(); // 判断是否存在 if (beanFactory.containsLocalBean(APPLICATIONEVENTMULTICASTERBEANNAME)) { // 从容器中获取ApplicationEventMulticaster对象 this.applicationEventMulticaster = beanFactory.getBean(APPLICATIONEVENTMULTICASTERBEANNAME, ApplicationEventMulticaster.class); if (logger.isDebugEnabled()) { logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]"); } } else { // 初始一个SimpleApplicationEventMulticaster对象 this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); // 创建的对象注册到BeanFactory中 beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster); if (logger.isDebugEnabled()) { logger.debug("Unable to locate ApplicationEventMulticaster with name '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "': using default [" + this.applicationEventMulticaster + "]"); } } }

9.onRefresh

onRefresh是个空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作，以子类AbstractRefreshableWebApplicationContext为例，看看它的onRefresh方法/// / Initialize the theme capability. // @Override protected void onRefresh() { this.themeSource = UiApplicationContextUtils.initThemeSource(this); }

10.registerListeners

方法名为registerListeners，看名字像是将监听器注册在事件广播器中，但实际情况并非如此，只有一些特殊的监听器被注册了，那些在bean配置文件中实现了ApplicationListener接口的类还没有实例化，所以此处只是将其name保存在广播器中，将这些监听器注册在广播器的操作是在bean的后置处理器中完成的，那时候bean已经实例化完成了，我们看代码protected void registerListeners() { // 注册的都是特殊的事件监听器，而并非配置中的bean for (ApplicationListener listener : getApplicationListeners()) { getApplicationEventMulticaster().addApplicationListener(listener); } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! // 根据接口类型找出所有监听器的名称 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); for (String listenerBeanName : listenerBeanNames) { // 这里只是把监听器的名称保存在广播器中，并没有将这些监听器实例化！！！ getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } }

11.finishBeanFactoryInitialization

finishBeanFactoryInitialization方法做了两件事：

  1. beanFactory对象的初始化；
  2. 我们在bean配置文件中配置的那些单例的bean，都是在finishBeanFactoryInitialization方法中实例化的；
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // Initialize conversion service for this context. // 实例化类型转换的bean，并保存在ApplicationContext中 if (beanFactory.containsBean(CONVERSIONSERVICEBEANNAME) && beanFactory.isTypeMatch(CONVERSIONSERVICEBEANNAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSIONSERVICEBEAN_NAME, ConversionService.class)); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. // 实例化LoadTimeWeaverAware接口的bean，用于ApsectJ的类加载期织入的处理 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. // 确保临时的classLoader为空，临时classLoader一般被用来做类型匹配的 beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. // 将一个标志设置为true，表示applicationContext已经缓存了所有bean的定义，这些bean的name都被保存在applicationContext的frozenBeanDefinitionNames成员变量中，相当于一个快照，记录了当前那些bean的定义已经拿到了 beanFactory.freezeConfiguration(); // 实例化所有还未实例化的单例bean beanFactory.preInstantiateSingletons(); }

preInstantiateSingletons方法

public void preInstantiateSingletons() throws BeansException { if (this.logger.isDebugEnabled()) { this.logger.debug("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List beanNames = new ArrayList(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { // 获取bean的定义，该定义已经和父类定义做了合并 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 非抽象类、是单例、非懒加载 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //FactoryBean的处理 if (isFactoryBean(beanName)) { final FactoryBean factory = (FactoryBean) getBean(FACTORYBEANPREFIX + beanName); boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged(new PrivilegedAction() { @Override public Boolean run() { return ((SmartFactoryBean) factory).isEagerInit(); } }, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } else { //非FactoryBean的实例化、初始化 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... // 单例实例化完成后，如果实现了SmartInitializingSingleton接口，afterSingletonsInstantiated就会被调用，此处用到了特权控制逻辑AccessController.doPrivileged for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction() { @Override public Object run() { smartSingleton.afterSingletonsInstantiated(); return null; } }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }

在这里插入图片描述doGetBean

protected T doGetBean( final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException { ​ final String beanName = transformedBeanName(name); Object bean; ​ //*/* 2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来） 从private final Map singletonObjects = new ConcurrentHashMap(256);获取的 /*/*/ Object sharedInstance = getSingleton(beanName); //如果没有获取到创建bean if (sharedInstance != null && args == null) { if (logger.isDebugEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } ​ else {//3、缓存中获取不到，开始Bean的创建对象流程； // Fail if we're already creating this bean instance: // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } ​ // 获取父beanFatory 检查这个bean是否创建了 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (args != null) { return (T) parentBeanFactory.getBean(nameToLookup, args); } else { return parentBeanFactory.getBean(nameToLookup, requiredType); } } ​ // 4、标记当前bean已经被创建 if (!typeCheckOnly) { markBeanAsCreated(beanName); } ​ try { // 5、获取Bean的定义信息； final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); ​ // 6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); getBean(dep); //先创建依赖的bean } } ​ // 启动单实例的bean的创建流程 if (mbd.isSingleton()) { //获取到单实例bean后，添加到缓存中 singletonObjects（） //Map singletonObjects = new ConcurrentHashMap(256); sharedInstance = getSingleton(beanName, new ObjectFactory() { @Override public Object getObject() throws BeansException { try { //创建Bean return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } // 下面部分不重要了 else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } ​ else { String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, new ObjectFactory() { @Override public Object getObject() throws BeansException { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } ​ // Check if required type matches the type of the actual bean instance. if (requiredType != null && bean != null && !requiredType.isInstance(bean)) { try { return getTypeConverter().convertIfNecessary(bean, requiredType); } catch (TypeMismatchException ex) { if (logger.isDebugEnabled()) { logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }

doCreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException { ​ // bean的包装 BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // 1）、【创建Bean实例】利用工厂方法或者对象的构造器创建出Bean实例； instanceWrapper = createBeanInstance(beanName, mbd, args); } final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null); Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null); mbd.resolvedTargetType = beanType; ​ // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { //调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName); //判断是否为：MergedBeanDefinitionPostProcessor 类型的，如果是，调用方法 //MergedBeanDefinitionPostProcessor 后置处理器是在bean实例换之后调用的 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } ​ //判断bean 是否为单实例的，如果是单实例的添加到缓存中 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isDebugEnabled()) { logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } //添加bean到缓存中 addSingletonFactory(beanName, new ObjectFactory() { @Override public Object getObject() throws BeansException { return getEarlyBeanReference(beanName, mbd, bean); } }); } ​ // Initialize the bean instance. Object exposedObject = bean; try { //为bean 赋值 populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) { // 4）、【Bean初始化】 exposedObject = initializeBean(beanName, exposedObject, mbd); } } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } ​ if (earlySingletonExposure) { //获取单实例bean,此时已经创建好了 Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set actualDependentBeans = new LinkedHashSet(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); } } } } ​ // 5）、注册实现了DisposableBean 接口Bean的销毁方法；只是注册没有去执行，容器关闭之后才去调用的 try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } ​ return exposedObject; }

populateBean()创建bean后属性赋值

//populateBean():1204, AbstractAutowireCapableBeanFactory protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { PropertyValues pvs = mbd.getPropertyValues(); ​ if (bw == null) { if (!pvs.isEmpty()) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } else { // Skip property population phase for null instance. return; } } ​ // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the // state of the bean before properties are set. This can be used, for example, // to support styles of field injection. boolean continueWithPropertyPopulation = true; ​ //赋值之前： // 1）、拿到InstantiationAwareBeanPostProcessor后置处理器； 执行处理器的postProcessAfterInstantiation()； 方法// if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; //执行 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } } ​ if (!continueWithPropertyPopulation) { return; } ​ if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIREBYNAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIREBYTYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); ​ // autowire 按name注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIREBYNAME) { autowireByName(beanName, mbd, bw, newPvs); } ​ // autowire 按类型注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIREBYTYPE) { autowireByType(beanName, mbd, bw, newPvs); } ​ pvs = newPvs; } ​ boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCYCHECKNONE); //2）、拿到InstantiationAwareBeanPostProcessor后置处理器； 执行 postProcessPropertyValues()； 获取到属性的值，此时还未赋值// if (hasInstAwareBpps || needsDepCheck) { PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { return; } } } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); } } //=====赋值之前：=== //3）、应用Bean属性的值；为属性利用setter方法等进行赋值； applyPropertyValues(beanName, mbd, bw, pvs); }

Bean初始化 initializeBean

//初始化 protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction() { @Override public Object run() { invokeAwareMethods(beanName, bean); return null; } }, getAccessControlContext()); } else { //1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法 //判断是否实现了 BeanNameAwareBeanClassLoaderAwareBeanFactoryAware 这些接口的bean，如果是执行相应的方法 invokeAwareMethods(beanName, bean); } ​ Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { //2）、【执行后置处理器BeanPostProcessor初始化之前】 执行所有的 BeanPostProcessor.postProcessBeforeInitialization（）; wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } ​ try { //3）、【执行初始化方法】 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } //4）、【执行后置处理器初始化之后】 执行所有的beanProcessor.postProcessAfterInitialization(result, beanName);方法 if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }

执行bean的初始化方法init1）是否是InitializingBean接口的实现；执行接口规定的初始化；2）是否自定义初始化方法；通过注解的方式添加了initMethod方法的，

​ 例如： @Bean(initMethod="init",destroyMethod="detory")//invokeInitMethods():1667, AbstractAutowireCapableBeanFactory protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable { //1）、是否是InitializingBean接口的实现；执行接口规定的初始化 ,执行afterPropertiesSet()这个方法； boolean isInitializingBean = (bean instanceof InitializingBean); if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { if (logger.isDebugEnabled()) { logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); } if (System.getSecurityManager() != null) { try { AccessController.doPrivileged(new PrivilegedExceptionAction() { @Override public Object run() throws Exception { ((InitializingBean) bean).afterPropertiesSet(); return null; } }, getAccessControlContext()); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { //执行实现InitializingBean的afterPropertiesSet方法 ((InitializingBean) bean).afterPropertiesSet(); } } ​ if (mbd != null) { //执行通过注解自定义的initMethod 方法 String initMethodName = mbd.getInitMethodName(); if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) { invokeCustomInitMethod(beanName, bean, mbd); } } }

12.finishRefresh

最后一个方法是finishRefresh，这是在bean的实例化、初始化等完成后的一些操作，例如生命周期变更的回调，发送applicationContext刷新完成的广播等，展开看看protected void finishRefresh() { // 检查是否已经配置了生命周期处理器，如果没有就new一个DefaultLifecycleProcessor initLifecycleProcessor(); // 找到所有实现了Lifecycle接口的bean，按照每个bean设置的生命周期阶段进行分组，再依次调用每个分组中每个bean的start方法，完成生命周期监听的通知 getLifecycleProcessor().onRefresh(); // 创建一条代表applicationContext刷新完成的事件，交给广播器去广播 publishEvent(new ContextRefreshedEvent(this)); // 如果配置了MBeanServer，就完成在MBeanServer上的注册 LiveBeansView.registerApplicationContext(this); }

Spring启动流程总结

  1. Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
    1.1 xml注册bean；
    1.2 注解注册Bean；@Service、@Component、@Bean、xxx
  2. Spring容器会合适的时机创建这些Bean
    2.1用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
    2.2统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
  3. 后置处理器；BeanPostProcessor
    每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
    AutowiredAnnotationBeanPostProcessor:处理自动注入
    AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
  4. 事件驱动模型；
    ApplicationListener；事件监听；
    ApplicationEventMulticaster；事件派发：
版权声明
本文为[ゞ .邓澎波]所创，转载请带上原文链接，感谢
https://www.cnblogs.com/dengpengbo/p/10422237.html