Spring Bean加载过程
1、找准入口，应用ClassPathXmlApplicationContext的构造方法加载配置文件，用于加载classPath下的配置文件
//第一行，执行实现之后就实现了spring配置文件的加载，刷新spring上下文ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext( "classpath:spring-mvc.xml");//获取实例BeanPerson person=context.getBean("person",Person.class);2、ClassPathXmlApplicationContext构造方法源码如下：
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException { //设置父级的ApplicationContext，null super(parent); //1.设置配置文件的门路， 2. 将门路中的占位符${placeholder}应用零碎的变量替换 setConfigLocations(configLocations); if (refresh) { refresh(); } }3、次要办法为setConfigLocation(configLocation),这个办法调用其父类AbstractRefreshableConfigApplicationContext中的办法
//locations : 配置文件门路public void setConfigLocations(String[] locations) { if (locations != null) { //断言 Assert.noNullElements(locations, "Config locations must not be null"); //存储配置文件门路的数组，存储去掉占位符后的文件门路数组 this.configLocations = new String[locations.length]; //遍历locations，解析占位符 for (int i = 0; i < locations.length; i++) { //调用resolvePath解析占位符 this.configLocations[i] = resolvePath(locations[i]).trim(); } } else { this.configLocations = null; } }4、进入resovePath的源码，实际上执行的是AbstractPropertyResolver的doResolverPlaceholders办法
/*** text : 须要解析的门路* PropertyPlaceholderHelper ： 这个是解析零碎占位符的辅助类，次要用来将占位符替换成零碎的环境变量*/private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) { //调用PropertyPlaceholderHelper类中的replacePlaceholders办法 return helper.replacePlaceholders(text, new PropertyPlaceholderHelper.PlaceholderResolver() { public String resolvePlaceholder(String placeholderName) { return getPropertyAsRawString(placeholderName); } }); }5、进入PropertyHelper的replacePlaceholder办法，实际上调用PropertyPlaceholderHelper的parseStringValue解析占位符
public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) { Assert.notNull(value, "Argument 'value' must not be null."); //调用的是parseStringValue办法 return parseStringValue(value, placeholderResolver, new HashSet<String>()); } /*** strVal ： 须要解析的字符串，就是配置文件的门路* placeholderResolver ： 策略接口，占位符解析器* visitedPlaceholders ： 存储曾经拜访过的占位符**/protected String parseStringValue( String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) { //将strval转换成StringBuilder，便于后续到操作 StringBuilder buf = new StringBuilder(strVal); //this.placeholderPrefix这个是占位符的前缀 ${,在创立PropertyHelper的时候就曾经指定了占位符的placeholderPrefix="${" ,placeholderSuffix="}",valueSeparator=":" //获取前缀在这个配置文件门路中的开始索引 int startIndex = strVal.indexOf(this.placeholderPrefix); while (startIndex != -1) { //占位符前缀在门路中的完结索引 int endIndex = findPlaceholderEndIndex(buf, startIndex); //如果完结索引存在 if (endIndex != -1) { //此时取出${plcaeholder}中的占位符内容placeholder String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex); //保留取出来的占位符内容placeholder String originalPlaceholder = placeholder; //如果占位符中的内容曾经被拜访过了，抛出出异样返回，递归完结的条件 if (!visitedPlaceholders.add(originalPlaceholder)) { throw new IllegalArgumentException( "Circular placeholder reference '" + originalPlaceholder + "' in property definitions"); } //递归解析曾经取出的占位符中的内容 palceholder placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders); //这个最重要的一步，将解析占位符内容placeholder的值，比方将java.version转换成1.8.0_60 String propVal = placeholderResolver.resolvePlaceholder(placeholder); if (propVal == null && this.valueSeparator != null) { int separatorIndex = placeholder.indexOf(this.valueSeparator); if (separatorIndex != -1) { String actualPlaceholder = placeholder.substring(0, separatorIndex); String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length()); propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder); if (propVal == null) { propVal = defaultValue; } } } //如果解析进去的占位符不为空，比方${java.version}将被解析成 1.8.0_60 if (propVal != null) { //此时持续递归解析出1.8.0_60中的占位符 propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders); //将门路中的占位符替换成零碎变量的值，比方将${java.version} 替换成 1.8.0_60 buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal); if (logger.isTraceEnabled()) { logger.trace("Resolved placeholder '" + placeholder + "'"); } //持续在门路字符串中残余的子串中查找占位符，如果有占位符，那么还会持续解析占位符 startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length()); } else if (this.ignoreUnresolvablePlaceholders) { // Proceed with unprocessed value. startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length()); } else { throw new IllegalArgumentException("Could not resolve placeholder '" + placeholder + "'" + " in string value \"" + strVal + "\""); } //将已转换胜利的占位符从以拜访的汇合中移除即可 visitedPlaceholders.remove(originalPlaceholder); } else { startIndex = -1; } } return buf.toString(); //将解析实现之后的配置文件返回 }6、而后是ClassPathXmlApplicationContext中的refresh办法，实际上调用的是父类AbstractApplicationContext的办法
//刷新spring上下文public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //在刷新之前设置一些参数，比方设置开始工夫戳，上下文是否激活的标记，输入刷新上下文的信息，验证一些必要的属性 prepareRefresh(); //须要创立beanFactory，如果曾经存在beanFactory，那么敞开，具体其请看 10 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 筹备上下文工厂，详情见12 prepareBeanFactory(beanFactory); try { //容许子类向后置处理器增加组件 postProcessBeanFactory(beanFactory); // 调用BeanFactoryPostProcessor和BeanDefintionRegistoryPostProcessor这两个后置处理器 invokeBeanFactoryPostProcessors(beanFactory); // 注册BeanPostProcessor,用来拦挡bean的创立，详情见 14 registerBeanPostProcessors(beanFactory); //初始化音讯源 initMessageSource(); // 初始化应用程序事件播送器，用户能够自定义一个事件播送器，如果用户没有定义，那么应用默认的事件播送器SimpleApplicationEventMulticaster initApplicationEventMulticaster(); // 在其余子类中初始化bean onRefresh(); // 检测事件监听器 registerListeners(); //实现实例化残余的单例(non-lazy-init) finishBeanFactoryInitialization(beanFactory); // 实现刷新，初始化生命周期处理器...... finishRefresh(); } catch (BeansException ex) { // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } } }7、进入obtainFreshBeanFactory办法
//AbastractApplicationContext的办法protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { //理论刷新上下文的办法，这个办法就是理论的刷新上下文办法，其中会调用loadBeanDefinitions(beanFactory);加载配置文件中的内容到BeanDefiniton中 refreshBeanFactory(); ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (logger.isDebugEnabled()) { logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory); } return beanFactory; } //org.springframework.context.support.AbstractRefreshableApplicationContext中的办法 //AbstractApplicationContext的子类中的办法 @Override protected final void refreshBeanFactory() throws BeansException { //如果其中有beanfactory，那么销毁 if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { //从新创立一个beanFactory DefaultListableBeanFactory beanFactory = createBeanFactory(); //设置序列化id beanFactory.setSerializationId(getId()); //定制beanFactory，设置相干属性，包含是否容许笼罩名称的不同定义的对象及循环依赖以及 //设置@Autowired和@Qualifier，注解解析器QualifierAnnotationAutowireCandidateResolver customizeBeanFactory(beanFactory); //加载BeanDefine 详情见 11 loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }8、进入loadBeanDefinitions(beanFactory)办法
//这个是org.springframework.context.support.AbstractXmlApplicationContext类中的办法 protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { //创立要给beanDefinitionReader，用于读取BeanDefinition XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); //配置XmlBeanDefinitionReader beanDefinitionReader.setEnvironment(this.getEnvironment()); beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); initBeanDefinitionReader(beanDefinitionReader); //加载BeanDefiniton，次要的性能从配置文件中读取BeanDefiniton注册到注册表中 loadBeanDefinitions(beanDefinitionReader); }9、prepareBeanFactory:筹备BeanFactory
//筹备BeanFactory，设置一些参数，比方后置处理器，protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { //设置类加载器 beanFactory.setBeanClassLoader(getClassLoader()); //设置表达式解析器，用来解析BeanDefiniton中的带有表达式的值 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // 配置后置处理器，次要的作用就是在spring实例化bean的前后做一些操作 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); //疏忽主动拆卸的类，这些类都不能应用@Resource或者@Autowired主动拆卸获取对象 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); //注册可解析的主动拆卸类 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); //在增加一个应用程序监听器 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); //查看这些类是否被 if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } // 将上面这些类注册到容器中，应用registerSingleton办法注册，咱们能够间接从容器中获取这些类的对象应用 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } }10、调用BeanFactory的后置处理器，次要的性能就是调用注册在容器中的BeanFactoryPostProcessor和BeanDefinitionRegistoryPostProcessor
//实例化和调用BeanFactory后置处理器，必须在单例实例化之前调用protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { //调用后置处理器注册委托类的办法调用，getBeanFactoryPostProcessors用于获取注册的全副的BeanFactoryPostProcessor PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); } //理论的调用办法，PostProcessorRegistrationDelegate中的办法public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { // Invoke BeanDefinitionRegistryPostProcessors first, if any. Set<String> processedBeans = new HashSet<String>(); //如果beanFactory是BeanDefinitionRegistry的子类，BeanDefinitionRegistry应用来向注册表中注册Bean的元信息的(BeanDefintion) if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; //寄存BeanFactoryPostProcessor List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>(); //寄存BeanDefinitionRegistryPostProcessor List<BeanDefinitionRegistryPostProcessor> registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>(); //遍历。判断是否是BeanDefinitionRegistryPostProcessor实例 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryPostProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; //调用BeanDefinitionRegistryPostProcessor registryPostProcessor.postProcessBeanDefinitionRegistry(registry); //增加 registryPostProcessors.add(registryPostProcessor); } else { //示意这个是BeanFactoryPostProcessor实例，增加进汇合 regularPostProcessors.add(postProcessor); } } //--- 依据类型类型获取beanFactory中注册的BeanDefinitionRegistryPostProcessor的bean的所有名称数组 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); // ---- 首先调用的是BeanDefinitionRegistryPostProcessor类型的后置处理器 //寄存实现PriorityOrdered这个接口的BeanDefinitionRegistryPostProcessor List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>(); //遍历，如果实现了PriorityOrdered这个接口就保留下来 for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } //依照优先级排序 OrderComparator.sort(priorityOrderedPostProcessors); //增加进入汇合 registryPostProcessors.addAll(priorityOrderedPostProcessors); //首先调用实现PriorityOrdered这个接口的BeanDefinitionRegistryPostProcessor invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry); // ---- 上面是调用实现Orderd这个接口的BeanDefinitionRegistryPostProcessor postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>(); for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } OrderComparator.sort(orderedPostProcessors); registryPostProcessors.addAll(orderedPostProcessors); invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry); // ---- 最终调用残余全副的BeanDefinitionRegistryPostProcessor boolean reiterate = true; while (reiterate) { reiterate = false; postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName)) { BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class); registryPostProcessors.add(pp); processedBeans.add(ppName); pp.postProcessBeanDefinitionRegistry(registry); reiterate = true; } } } // 调用BeanFactoryPostProcessor接口中的办法，因为BeanDefitionRegistory继承了这个接口 invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { // Invoke factory processors registered with the context instance. invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } //--- 上面是调用实现BeanFactoryPostProcessor接口的类，和下面的流程一样 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, // Ordered, and the rest. List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>(); List<String> orderedPostProcessorNames = new ArrayList<String>(); List<String> nonOrderedPostProcessorNames = new ArrayList<String>(); for (String ppName : postProcessorNames) { if (processedBeans.contains(ppName)) { // skip - already processed in first phase above } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered. OrderComparator.sort(priorityOrderedPostProcessors); invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); // Next, invoke the BeanFactoryPostProcessors that implement Ordered. List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>(); for (String postProcessorName : orderedPostProcessorNames) { orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } OrderComparator.sort(orderedPostProcessors); invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); // Finally, invoke all other BeanFactoryPostProcessors. List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>(); for (String postProcessorName : nonOrderedPostProcessorNames) { nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); }11、注册BeanPostProcessor，用来拦挡Bean的创立，这个接口能够实现在Bean初始化和初始化之后执行相干的操作
//仍然这里仍然调用的PostProcessorRegistrationDelegate，其中蕴含了注册后置处理器和调用后置处理器的办法，相当于一个代理人protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this); } //PostProcessorRegistrationDelegate中的注册BeanPostProcessors的办法//其中beanFactory这个新创建的beanFactory，其中的BeanPostProcessor都没有注册，applicationContext这个是之前创立的，其中的处理器曾经注册过了public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { //依据类型新加载全副的BeanFactoryProcessor的类， String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); //创立BeanPostProcessor检测器 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); // Separate between BeanPostProcessors that implement PriorityOrdered, // Ordered, and the rest. List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>(); List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>(); List<String> orderedPostProcessorNames = new ArrayList<String>(); List<String> nonOrderedPostProcessorNames = new ArrayList<String>(); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { BeanPostProcessor pp = 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); } } // First, register the BeanPostProcessors that implement PriorityOrdered. OrderComparator.sort(priorityOrderedPostProcessors); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // Next, register the BeanPostProcessors that implement Ordered. List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>(); for (String ppName : orderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); orderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } OrderComparator.sort(orderedPostProcessors); registerBeanPostProcessors(beanFactory, orderedPostProcessors); // Now, register all regular BeanPostProcessors. List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>(); for (String ppName : nonOrderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); // Finally, re-register all internal BeanPostProcessors. OrderComparator.sort(internalPostProcessors); registerBeanPostProcessors(beanFactory, internalPostProcessors); beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }