spring源码学习之容器的扩展（一）

 public ClassPathXmlApplicationContext(String configLocation) throws BeansException {

     this(new String[] {configLocation}, true, null);

 }

 // 所有的构造方法都会调用下面这个方法

 public ClassPathXmlApplicationContext(

         String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)

         throws BeansException {

     super(parent);

     setConfigLocations(configLocations);

     if (refresh) {

         refresh();

     }

 }

 public void setConfigLocations(@Nullable String... locations) {

     if (locations != null) {

         Assert.noNullElements(locations, "Config locations must not be null");

         this.configLocations = new String[locations.length];

         for (int i = 0; i < locations.length; i++) {

             // 循环解析给定的路径

             this.configLocations[i] = resolvePath(locations[i]).trim();

         }

     }

     else {

         this.configLocations = null;

     }

 }

 @Override

 public void refresh() throws BeansException, IllegalStateException {

     synchronized (this.startupShutdownMonitor) {

         // Prepare this context for refreshing.

         // 准备刷新新的上下文

         prepareRefresh();

         // Tell the subclass to refresh the internal bean factory.

         // 初始化BeanFactory，进行XML文件读取

         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

         // Prepare the bean factory for use in this context.

         // 对BeanFactory进行各种功能填充

         prepareBeanFactory(beanFactory);

         try {

             // Allows post-processing of the bean factory in context subclasses.

             // 子类覆盖方法，做额外的处理

             postProcessBeanFactory(beanFactory);

             // Invoke factory processors registered as beans in the context.

             // 激活各种BeanFactory处理器

             invokeBeanFactoryPostProcessors(beanFactory);

             // Register bean processors that intercept bean creation.

             // 注册拦截bean创建的bean处理器，这里只是注册，真正的调用是在getBean的时候

             registerBeanPostProcessors(beanFactory);

             // Initialize message source for this context.

             // 为上下文初始化Message源，即不同语言的消息体，即国际化处理

             initMessageSource();

             // Initialize event multicaster for this context.

             // 初始化应用消息广播器，并放入"applicationEventMulticaster"bean中

             initApplicationEventMulticaster();

             // Initialize other special beans in specific context subclasses.

             // 留给子类来初始化其他bean

             onRefresh();

             // Check for listener beans and register them.

             // 在所有注册的bean中查找Listener bean，注册到消息广播器中

             registerListeners();

             // Instantiate all remaining (non-lazy-init) singletons.

             // 初始化剩下的单实例（非惰性的）

             finishBeanFactoryInitialization(beanFactory);

             // Last step: publish corresponding event.

             // 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人

             finishRefresh();

         }

         catch (BeansException ex) {

             if (logger.isWarnEnabled()) {

                 logger.warn("Exception encountered during context initialization - " +

                         "cancelling refresh attempt: " + ex);

             }

             // Destroy already created singletons to avoid dangling resources.

             destroyBeans();

             // Reset 'active' flag.

             cancelRefresh(ex);

             // Propagate exception to caller.

             throw ex;

         }

         finally {

             // Reset common introspection caches in Spring's core, since we

             // might not ever need metadata for singleton beans anymore...

             resetCommonCaches();

         }

     }

 }

 protected void prepareRefresh() {

     // Switch to active.

     this.startupDate = System.currentTimeMillis();

     this.closed.set(false);

     this.active.set(true);

     if (logger.isInfoEnabled()) {

         logger.info("Refreshing " + this);

     }

     // Initialize any placeholder property sources in the context environment.

     // 留给子类覆盖

     initPropertySources();

     // Validate that all properties marked as required are resolvable:

     // see ConfigurablePropertyResolver#setRequiredProperties

     // 验证需要的属性文件是否都放入环境中

     getEnvironment().validateRequiredProperties();

     // Store pre-refresh ApplicationListeners...

     if (this.earlyApplicationListeners == null) {

         this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);

     }

     else {

         // Reset local application listeners to pre-refresh state.

         this.applicationListeners.clear();

         this.applicationListeners.addAll(this.earlyApplicationListeners);

     }

     // Allow for the collection of early ApplicationEvents,

     // to be published once the multicaster is available...

     this.earlyApplicationEvents = new LinkedHashSet<>();

 }

 public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext{

     public MyClassPathXmlApplicationContext(String... configLocations){

         super(configLocations);

     }

     protected void initPropertySources(){

         getEnvironment().setRequiredProperties("VAR");

     }

 }

 org.springframework.context.support包下AbstractApplicationContext类中

 protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

     // 初始化BeanFactory，并进行XML文件读取，并将得到的BeanFactory记录到当前实体的属性中

     refreshBeanFactory();

     // 返回当前实体的beanFactory属性

     ConfigurableListableBeanFactory beanFactory = getBeanFactory();

     if (logger.isDebugEnabled()) {

         logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

     }

     return beanFactory;

 }

 @Override

 protected final void refreshBeanFactory() throws BeansException {

     if (hasBeanFactory()) {

         destroyBeans();

         closeBeanFactory();

     }

     try {

         // 创建DefaultListableBeanFactory

         DefaultListableBeanFactory beanFactory = createBeanFactory();

         // 为了序列化指定id，如果需要的话，让这个BeanFactory从id反序列化到BeanFactory对象

         beanFactory.setSerializationId(getId());

         // 定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖以及设置

         // @Autowired @Qualifier注解解析器QualifierAnnotationAutowireCandidateResolver

         customizeBeanFactory(beanFactory);

         // 初始化DodumentReader，并进行XML读取和解析

         loadBeanDefinitions(beanFactory);

         synchronized (this.beanFactoryMonitor) {

             this.beanFactory = beanFactory;

         }

     }

     catch (IOException ex) {

         throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

     }

 }

 protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {

     // 如果allowBeanDefinitionOverriding不为空，设置beanFactory相关属性，此属性的含义是允许覆盖同名称的不同定义的对象

     if (this.allowBeanDefinitionOverriding != null) {

         beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

     }

     // allowCircularReferences不为空，设置beanFactory相关属性，此属性的含义是否允许bean之间存在循环依赖

     if (this.allowCircularReferences != null) {

         beanFactory.setAllowCircularReferences(this.allowCircularReferences);

     }

 }

 public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext{

     。。。

     protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {

         beanFactory.setAllowBeanDefinitionOverriding(false);

         beanFactory.setAllowCircularReferences(false);

         super.customizeBeanFactory(beanFactory);

     }

 }

 @Override

 @Nullable

 public Object getSuggestedValue(DependencyDescriptor descriptor) {

     Object value = findValue(descriptor.getAnnotations());

     if (value == null) {

         MethodParameter methodParam = descriptor.getMethodParameter();

         if (methodParam != null) {

             value = findValue(methodParam.getMethodAnnotations());

         }

     }

     return value;

 }

 @Override

 protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

     // Create a new XmlBeanDefinitionReader for the given BeanFactory.

     // 为指定的BeanFactory创建XmlBeanDefinitionReader

     XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

     // Configure the bean definition reader with this context's

     // resource loading environment.

     // 对beanDefinitionReader进行环境变量的设置

     beanDefinitionReader.setEnvironment(this.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.

     // 对BeanDefinitionReader进行设置，可以覆盖

     initBeanDefinitionReader(beanDefinitionReader);

     // 配置文件的读取

     loadBeanDefinitions(beanDefinitionReader);

 }

 // 与上一个方法在同一个类中

 protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

     Resource[] configResources = getConfigResources();

     if (configResources != null) {

         reader.loadBeanDefinitions(configResources);

     }

     String[] configLocations = getConfigLocations();

     if (configLocations != null) {

         reader.loadBeanDefinitions(configLocations);

     }

 }

 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

     // Tell the internal bean factory to use the context's class loader etc.

     // 设置beanFactory的classLoader为当前context的classLoader

     beanFactory.setBeanClassLoader(getClassLoader());

     // 设置beanFactory的表达式语言处理器，spring3增加了表达式语言的支持

     // 默认使用#{bean.xxx}的形式来调用相关属性值

     beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

     // 为beanFactory增加了一个默认的propertyEditor，这个主要是对bean属性等设置管理的一个工具

     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

     // Configure the bean factory with context callbacks.

     // 添加BeanPostProcessor

     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);

     // BeanFactory interface not registered as resolvable type in a plain factory.

     // MessageSource registered (and found for autowiring) as a bean.

     // 设置了几个自动装备的特殊规则

     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

     beanFactory.registerResolvableDependency(ResourceLoader.class, this);

     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

     beanFactory.registerResolvableDependency(ApplicationContext.class, this);

     // Register early post-processor for detecting inner beans as ApplicationListeners.

     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

     // Detect a LoadTimeWeaver and prepare for weaving, if found.

     // 增加对AspectJ的支持

     if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

         // Set a temporary ClassLoader for type matching.

         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

     }

     // Register default environment beans.

     // 添加默认的系统环境bean

     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());

     }

 }

 <bean id="saxophone" value="com.xxx.xxx.xxx" />

 <bean>

     <property name="instrument" value="#{saxophone}"></property>

 </bean>

 // 相当于：

 <bean id="saxophone" value="com.xxx.xxx.xxx" />

 <bean>

     <property name="instrument" ref="saxophone"></property>

 </bean>

 @Nullable

 protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) {

     if (this.beanExpressionResolver == null) {

         return value;

     }

     Scope scope = null;

     if (beanDefinition != null) {

         String scopeName = beanDefinition.getScope();

         if (scopeName != null) {

             scope = getRegisteredScope(scopeName);

         }

     }

     return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));

 }

public class UserManager {

    private Date dateValue;

    public Date getDateValue(){

        return dateValue;

    }

    public void setDateValue(Date dateValue){

        this.dateValue = dateValue;

    }

    public String toString(){

        return "dateValue:" + dateValue;

    }

}

// 上面代码中，需要对日期型属性进行注入：

<bean id="userManager" class="com.test.UserManager">

    <property name="dateValue">

        <value>2019-7-23</value>

    </property>

</bean>

// 测试代码：

@Test

public void testDate(){

    ApplicationContext = ctx = new ClassPathXmlApplicationContext("beans.xml");

    UserManager userManager = (UserManager) ctx.getBean("userManager");

    System.out.println(userManager);

}

 public class DatePropertyEditor extends PropertyEditorSupport{

     private String format = "yyyy-MM-dd";

     public void setFormat(String format){

         this.format = format;

     }

     public void setAsText(String arg0) throws IllegalStateException {

         System.out.println("arg0:" + arg0);

         SimpleDateFormat sdf = new SimpleDateFormat(format);

         try{

             Date d = sdf.parse(arg0);

             this.setFormat(d);

         }catch(Exception e){

             e.printStakeTrace();

         }

     }

 }

 <!--自定义属性编辑器-->

 <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">

     <property name="customEditors">

         <map>

             <entry key="java.util,Date" />

             <bean class="com.test.DatePropertyEditor">

                 <property name="format" value="yyyy-MM-dd"/>

             </bean>

         </map>

     </property>

 </bean>

 （1）定义属性编辑器

 public class DatePropertyEditorRegistrar implements PropertyEditorRegistrar{

     public void registerCustomEditors(PropertyEditorRegistry registry){

         registry.registerCustomEditors(Date.Class,new CustomEditor(new SimpleDateFormat("yyyy-MM-dd"),true));

     }

 }

 （2）注册到spring中

 <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">

     <property name=""propertyEditorRegistrars>

         <list>

             <bean class="com.test.DatePropertyEditorRegistrar"></bean>

         </list>

     </property>

 </bean>

 @Override

 public void registerCustomEditors(PropertyEditorRegistry registry) {

     ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader, this.propertyResolver);

     doRegisterEditor(registry, Resource.class, baseEditor);

     doRegisterEditor(registry, ContextResource.class, baseEditor);

     doRegisterEditor(registry, InputStream.class, new InputStreamEditor(baseEditor));

     doRegisterEditor(registry, InputSource.class, new InputSourceEditor(baseEditor));

     doRegisterEditor(registry, File.class, new FileEditor(baseEditor));

     doRegisterEditor(registry, Path.class, new PathEditor(baseEditor));

     doRegisterEditor(registry, Reader.class, new ReaderEditor(baseEditor));

     doRegisterEditor(registry, URL.class, new URLEditor(baseEditor));

     ClassLoader classLoader = this.resourceLoader.getClassLoader();

     doRegisterEditor(registry, URI.class, new URIEditor(classLoader));

     doRegisterEditor(registry, Class.class, new ClassEditor(classLoader));

     doRegisterEditor(registry, Class[].class, new ClassArrayEditor(classLoader));

     if (this.resourceLoader instanceof ResourcePatternResolver) {

         doRegisterEditor(registry, Resource[].class,

                 new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver));

     }

 }

 private void doRegisterEditor(PropertyEditorRegistry registry, Class<?> requiredType, PropertyEditor editor) {

     if (registry instanceof PropertyEditorRegistrySupport) {

         ((PropertyEditorRegistrySupport) registry).overrideDefaultEditor(requiredType, editor);

     }

     else {

         registry.registerCustomEditor(requiredType, editor);

     }

 }

 private void createDefaultEditors() {

     this.defaultEditors = new HashMap<>(64);

     // Simple editors, without parameterization capabilities.

     // The JDK does not contain a default editor for any of these target types.

     this.defaultEditors.put(Charset.class, new CharsetEditor());

     this.defaultEditors.put(Class.class, new ClassEditor());

     this.defaultEditors.put(Class[].class, new ClassArrayEditor());

     this.defaultEditors.put(Currency.class, new CurrencyEditor());

     this.defaultEditors.put(File.class, new FileEditor());

     this.defaultEditors.put(InputStream.class, new InputStreamEditor());

     this.defaultEditors.put(InputSource.class, new InputSourceEditor());

     this.defaultEditors.put(Locale.class, new LocaleEditor());

     this.defaultEditors.put(Path.class, new PathEditor());

     this.defaultEditors.put(Pattern.class, new PatternEditor());

     this.defaultEditors.put(Properties.class, new PropertiesEditor());

     this.defaultEditors.put(Reader.class, new ReaderEditor());

     this.defaultEditors.put(Resource[].class, new ResourceArrayPropertyEditor());

     this.defaultEditors.put(TimeZone.class, new TimeZoneEditor());

     this.defaultEditors.put(URI.class, new URIEditor());

     this.defaultEditors.put(URL.class, new URLEditor());

     this.defaultEditors.put(UUID.class, new UUIDEditor());

     this.defaultEditors.put(ZoneId.class, new ZoneIdEditor());

     // Default instances of collection editors.

     // Can be overridden by registering custom instances of those as custom editors.

     this.defaultEditors.put(Collection.class, new CustomCollectionEditor(Collection.class));

     this.defaultEditors.put(Set.class, new CustomCollectionEditor(Set.class));

     this.defaultEditors.put(SortedSet.class, new CustomCollectionEditor(SortedSet.class));

     this.defaultEditors.put(List.class, new CustomCollectionEditor(List.class));

     this.defaultEditors.put(SortedMap.class, new CustomMapEditor(SortedMap.class));

     // Default editors for primitive arrays.

     this.defaultEditors.put(byte[].class, new ByteArrayPropertyEditor());

     this.defaultEditors.put(char[].class, new CharArrayPropertyEditor());

     // The JDK does not contain a default editor for char!

     this.defaultEditors.put(char.class, new CharacterEditor(false));

     this.defaultEditors.put(Character.class, new CharacterEditor(true));

     // Spring's CustomBooleanEditor accepts more flag values than the JDK's default editor.

     this.defaultEditors.put(boolean.class, new CustomBooleanEditor(false));

     this.defaultEditors.put(Boolean.class, new CustomBooleanEditor(true));

     // The JDK does not contain default editors for number wrapper types!

     // Override JDK primitive number editors with our own CustomNumberEditor.

     this.defaultEditors.put(byte.class, new CustomNumberEditor(Byte.class, false));

     this.defaultEditors.put(Byte.class, new CustomNumberEditor(Byte.class, true));

     this.defaultEditors.put(short.class, new CustomNumberEditor(Short.class, false));

     this.defaultEditors.put(Short.class, new CustomNumberEditor(Short.class, true));

     this.defaultEditors.put(int.class, new CustomNumberEditor(Integer.class, false));

     this.defaultEditors.put(Integer.class, new CustomNumberEditor(Integer.class, true));

     this.defaultEditors.put(long.class, new CustomNumberEditor(Long.class, false));

     this.defaultEditors.put(Long.class, new CustomNumberEditor(Long.class, true));

     this.defaultEditors.put(float.class, new CustomNumberEditor(Float.class, false));

     this.defaultEditors.put(Float.class, new CustomNumberEditor(Float.class, true));

     this.defaultEditors.put(double.class, new CustomNumberEditor(Double.class, false));

     this.defaultEditors.put(Double.class, new CustomNumberEditor(Double.class, true));

     this.defaultEditors.put(BigDecimal.class, new CustomNumberEditor(BigDecimal.class, true));

     this.defaultEditors.put(BigInteger.class, new CustomNumberEditor(BigInteger.class, true));

     // Only register config value editors if explicitly requested.

     if (this.configValueEditorsActive) {

         StringArrayPropertyEditor sae = new StringArrayPropertyEditor();

         this.defaultEditors.put(String[].class, sae);

         this.defaultEditors.put(short[].class, sae);

         this.defaultEditors.put(int[].class, sae);

         this.defaultEditors.put(long[].class, sae);

     }

 }

 // 在postProcessAfterInitialization方法中没有做任何处理

 @Override

 public Object postProcessAfterInitialization(Object bean, String beanName) {

     return bean;

 }

 // 重点看一下postProcessBeforeInitialization方法

 @Override

 @Nullable

 public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {

     AccessControlContext acc = null;

     if (System.getSecurityManager() != null &&

             (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||

                     bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||

                     bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {

         acc = this.applicationContext.getBeanFactory().getAccessControlContext();

     }

     if (acc != null) {

         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {

             invokeAwareInterfaces(bean);

             return null;

         }, acc);

     }

     else {

         invokeAwareInterfaces(bean);

     }

     return bean;

 }

 // 最终会调用invokeAwareInterfaces方法，这个在同一个类中

 private void invokeAwareInterfaces(Object bean) {

     if (bean instanceof Aware) {

         if (bean instanceof EnvironmentAware) {

             ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());

         }

         if (bean instanceof EmbeddedValueResolverAware) {

             ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);

         }

         if (bean instanceof ResourceLoaderAware) {

             ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);

         }

         if (bean instanceof ApplicationEventPublisherAware) {

             ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);

         }

         if (bean instanceof MessageSourceAware) {

             ((MessageSourceAware) bean).setMessageSource(this.applicationContext);

         }

         if (bean instanceof ApplicationContextAware) {

             ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);

         }

     }

 }