spring源碼核心:DefaultListableBeanFactory

本文轉自：https://my.oschina.net/u/2246410/blog/1801293/

核心創建方式

Class<?> ob = Class.forName("com.fxl.spring.test.SayServiceImpl");
    //ob.getDeclaredConstructor(); 檢測構造器是否是公有
    SayService say = (SayService) ob.newInstance();
    say.getMessage();

結構圖

 

 

 

接口：

• AliasRegistry：注冊別名和具體的名稱接口
• SingletonBeanRegistry：注冊bean的接口
• BeanFactory：bean的實際調用接口
• HierarchicalBeanFactory：beanfactory的強化接口
• ConfigurableBeanFactory：beanfactory的調用接口
• AutowireCapableBeanFactory：beanfactory的強化接口
• ListableBeanFactory：beanfactory的強化接口，批量處理bean
• BeanDefinitionRegistry：bean的調用接口，包括接口別名
• ConfigurableListableBeanFactory：除了可配置beanfactory之外，它還提供了用於分析和修改bean定義的工具，以及預實例化單例

實現類

• SimpleAliasRegistry：存放別名和實際

• public class SimpleAliasRegistry implements AliasRegistry {
  
      /** Map from alias to canonical name */
      private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);
  }

  DefaultSingletonBeanRegistry：存放具體的bean

  • singletonObjects： 存放bean的名稱及實例
  • singletonFactories： 存放bean的名稱及實例創建工廠

  • public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    
        /**
         * Internal marker for a null singleton object:
         * used as marker value for concurrent Maps (which don't support null values).
         */
        protected static final Object NULL_OBJECT = new Object();
    
    
        /** Logger available to subclasses */
        protected final Log logger = LogFactory.getLog(getClass());
    
        /** Cache of singleton objects: bean name --> bean instance */
        // bean的名稱和實例
        private final Map<String, Object> 'singletonObjects' = new ConcurrentHashMap<String, Object>(64);
    
        /** Cache of singleton factories: bean name --> ObjectFactory */
        // bean名稱和產生的工廠
        private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
    
        /** Cache of early singleton objects: bean name --> bean instance */
        // 早期存放bean的名稱和實例
        private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
    
        /** Set of registered singletons, containing the bean names in registration order */
        // bean的名稱
        private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);
    
        /** Names of beans that are currently in creation */
        // 創建的類
        private final Set<String> singletonsCurrentlyInCreation =
                Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
    
        /** Names of beans currently excluded from in creation checks */
        // 當前創建時需要排除的名稱
        private final Set<String> inCreationCheckExclusions =
                Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
    
        /** List of suppressed Exceptions, available for associating related causes */
        // 拋出的錯誤
        private Set<Exception> suppressedExceptions;
    
        /** Flag that indicates whether we're currently within destroySingletons */
        // 銷毀時的狀態
        private boolean singletonsCurrentlyInDestruction = false;
    
        /** Disposable bean instances: bean name --> disposable instance */
        // bean名稱
        private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();
    
        /** Map between containing bean names: bean name --> Set of bean names that the bean contains */
        // 名稱
        private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);
    
        /** Map between dependent bean names: bean name --> Set of dependent bean names */
        // 依賴的名稱
        private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
    
        /** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
        // 依賴的名稱
        private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
    }

    • FactoryBeanRegistrySupport：bean緩存

    • public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
      
          /** Cache of singleton objects created by FactoryBeans: FactoryBean name --> object */
          // 由FactoryBean創建的單例對象的緩存:FactoryBean名稱—對象
          private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);
      }

      • AbstractBeanFactory：

      • public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
        
            /** Parent bean factory, for bean inheritance support */
            // 父類 bean factory
            private BeanFactory parentBeanFactory;
        
            /** ClassLoader to resolve bean class names with, if necessary */
            // 類加載器
            private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
        
            /** ClassLoader to temporarily resolve bean class names with, if necessary */
            // 類加載器在必要時臨時解析bean類名
            private ClassLoader tempClassLoader;
        
            /** Whether to cache bean metadata or rather reobtain it for every access */
            // 是否緩存bean元數據，或者是否為每個訪問重新獲取它
            private boolean cacheBeanMetadata = true;
        
            /** Resolution strategy for expressions in bean definition values */
            //  bean定義值的表達式的解析策略
            private BeanExpressionResolver beanExpressionResolver;
        
            /** Spring ConversionService to use instead of PropertyEditors */
            // 使用Spring ConversionService來代替屬性編輯器
            private ConversionService conversionService;
        
            /** Custom PropertyEditorRegistrars to apply to the beans of this factory */
            // 自定義propertyeditorregistry應用到該工廠的bean
            private final Set<PropertyEditorRegistrar> propertyEditorRegistrars =
                    new LinkedHashSet<PropertyEditorRegistrar>(4);
        
            /** A custom TypeConverter to use, overriding the default PropertyEditor mechanism */
            // 用於使用的自定義類型轉換，覆蓋默認的PropertyEditor機制
            private TypeConverter typeConverter;
        
            /** Custom PropertyEditors to apply to the beans of this factory */
            // 自定義屬性編輯器應用到該工廠的bean
            private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors =
                    new HashMap<Class<?>, Class<? extends PropertyEditor>>(4);
        
            /** String resolvers to apply e.g. to annotation attribute values */
            // 將字符串解析器應用於注釋屬性值
            private final List<StringValueResolver> embeddedValueResolvers = new LinkedList<StringValueResolver>();
        
            /** BeanPostProcessors to apply in createBean */
            // 用於在createBean中應用的beanpost處理器
            private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();
        
            /** Indicates whether any InstantiationAwareBeanPostProcessors have been registered */
            // 表明InstantiationAwareBeanPostProcessors是否已經注冊
            private boolean hasInstantiationAwareBeanPostProcessors;
        
            /** Indicates whether any DestructionAwareBeanPostProcessors have been registered */
            // 表明DestructionAwareBeanPostProcessors是否已經注冊
            private boolean hasDestructionAwareBeanPostProcessors;
        
            /** Map from scope identifier String to corresponding Scope */
            // 從范圍標識符字符串映射到對應的范圍
            private final Map<String, Scope> scopes = new HashMap<String, Scope>(8);
        
            /** Security context used when running with a SecurityManager */
            // 與安全管理器一起運行時使用的安全上下文
            private SecurityContextProvider securityContextProvider;
        
            /** Map from bean name to merged RootBeanDefinition */
            // 從bean名稱映射到合並的RootBeanDefinition
            private final Map<String, RootBeanDefinition> mergedBeanDefinitions =
                    new ConcurrentHashMap<String, RootBeanDefinition>(64);
        
            /** Names of beans that have already been created at least once */
            // 已經至少創建過一次的bean的名稱
            private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(64));
        
            /** Names of beans that are currently in creation */
            // 當前正在創建的bean的名稱
            private final ThreadLocal<Object> prototypesCurrentlyInCreation =
                    new NamedThreadLocal<Object>("Prototype beans currently in creation");
        }

        AbstractAutowireCapableBeanFactory：抽象bean工廠超類，實現了默認bean的創建，具有由RootBeanDefinition類指定的全部功能

        • 提供bean創建(使用構造函數解析)、屬性填充、連接(包括自動連接)和初始化。處理運行時bean引用、解析托管集合、調用初始化方法等。支持自動裝配構造函數、屬性名和屬性

        • public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
                  implements AutowireCapableBeanFactory {
          
              /** Strategy for creating bean instances */
              // 創建bean實例的策略
              private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
          
              /** Resolver strategy for method parameter names */
              // 方法參數名的解析器策略
              private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
          
              /** Whether to automatically try to resolve circular references between beans */
              // 是否自動嘗試解析bean之間的循環引用
              private boolean allowCircularReferences = true;
          
              /**
               * Whether to resort to injecting a raw bean instance in case of circular reference, even if the injected bean eventually got wrapped.
               */
              // 是否在循環引用的情況下使用原始bean實例，即使注入的bean最終被包裝了
              private boolean allowRawInjectionDespiteWrapping = false;
          
              /**
               * Dependency types to ignore on dependency check and autowire, as Set of Class objects: for example, String. Default is none.
               */
               // 依賴類型忽略依賴檢查和自動連接，這是類對象的集合:例如，String。默認是沒有的。
              private final Set<Class<?>> ignoredDependencyTypes = new HashSet<Class<?>>();
          
              /**
               * Dependency interfaces to ignore on dependency check and autowire, as Set of  Class objects. By default, only the BeanFactory interface is ignored.
               */
               // 依賴接口忽略依賴檢查和自動連接，這是類對象的集合。默認情況下，只會忽略BeanFactory接口。
              private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<Class<?>>();
          
              /** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
              // 未完成的FactoryBean實例的緩存:FactoryBean的名稱—bean包裝器
              private final Map<String, BeanWrapper> factoryBeanInstanceCache =
                      new ConcurrentHashMap<String, BeanWrapper>(16);
          
              /** Cache of filtered PropertyDescriptors: bean Class -> PropertyDescriptor array */
              // 過濾的屬性描述符的緩存:bean類-屬性描述符數組
              private final Map<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
                      new ConcurrentHashMap<Class<?>, PropertyDescriptor[]>(64);
          }

          • DefaultListableBeanFactory：在訪問bean之前，典型的用法是先注冊所有的bean定義(可能是從bean定義文件中讀取)。因此，Bean定義查找在本地Bean定義表中是一種廉價的操作，在預先構建的Bean定義元數據對象上運行。

          • public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
                    implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
            
                private static Class<?> javaxInjectProviderClass = null;
            
                /** Map from serialized id to factory instance */
                // 序列化的工程id
                private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
                        new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(8);
            
                /** Optional id for this factory, for serialization purposes */
                //這個工廠的可選id，用於序列化
                private String serializationId;
            
                /** Whether to allow re-registration of a different definition with the same name */
                // 是否允許用相同的名稱重新注冊一個不同的定義
                private boolean allowBeanDefinitionOverriding = true;
            
                /** Whether to allow eager class loading even for lazy-init beans */
                // 是否允許熱加載即使是 懶加載設置
                private boolean allowEagerClassLoading = true;
            
                /** Optional OrderComparator for dependency Lists and arrays */
                // 用於依賴列表和數組的可選的OrderComparator
                private Comparator<Object> dependencyComparator;
            
                /** Resolver to use for checking if a bean definition is an autowire candidate */
                // 解析器用於檢查bean定義是否為自動連接的候選
                private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
            
                /** Map from dependency type to corresponding autowired value */
                // 從依賴類型映射到對應的自動連接值
                private final Map<Class<?>, Object> resolvableDependencies = new HashMap<Class<?>, Object>(16);
            
                /** Map of bean definition objects, keyed by bean name */
                // bean定義對象的映射，以bean名稱為鍵
                private final Map<String, BeanDefinition> 'beanDefinitionMap' = new ConcurrentHashMap<String, BeanDefinition>(64);
            
                /** Map of singleton and non-singleton bean names keyed by dependency type */
                // 單例和非單例bean的映射，依賴於依賴類型
                private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);
            
                /** Map of singleton-only bean names keyed by dependency type */
                // 依賴類型的名稱
                private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);
            
                /** List of bean definition names, in registration order */
                // 默認的名稱列表
                private final List<String> beanDefinitionNames = new ArrayList<String>();
            
                /** Whether bean definition metadata may be cached for all beans */
                // 是否為所有bean緩存bean定義元數據
                private boolean configurationFrozen = false;
            
                /** Cached array of bean definition names in case of frozen configuration */
                // 在凍結配置的情況下，緩存的bean定義名稱
                private String[] frozenBeanDefinitionNames;
            }

            beanfactory：bean的創建工廠

            • 流程：
              • 從AbstractApplicationContext->refresh()->finishBeanFactoryInitialization()：實例化bean的時候，會調用beanFactory.preInstantiateSingletons()
              • 接着在 DefaultListableBeanFactory->preInstantiateSingletons() 實例化bean的時候，調用AbstractBeanFactory->getBean()
              • 接着在AbstractBeanFactory->doGetBean()中使用getSingleton()回調一個beanfactory
              • 最后調用 SimpleInstantiationStrategy->instantiate()的來實例化bean

              • 1. DefaultListableBeanFactory->preInstantiateSingletons()：
                public void preInstantiateSingletons() throws BeansException {
                
                    List<String> beanNames;
                    synchronized (this.beanDefinitionMap) {
                        beanNames = new ArrayList<String>(this.beanDefinitionNames);
                    }
                    for (String beanName : beanNames) {
                        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                                getBean(beanName);
                        }
                    }
                }
                2. AbstractBeanFactory->getBean(String beanName);
                public Object getBean(String name) throws BeansException {
                    return doGetBean(name, null, null, false);
                }
                3.AbstractBeanFactory->doGetBean(String beanName);一個回調用來生成 bean
                protected <T> T doGetBean(
                        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
                        throws BeansException {
                    final String beanName = transformedBeanName(name);
                    Object bean;
                    ...
                    ...
                    'getSingleton回調一個ObjectFactory'
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                return createBean(beanName, mbd, args);
                            }catch (BeansException ex) {
                                destroySingleton(beanName);
                            }
                        }
                    });
                    ...
                    ...
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                    return (T) bean;
                }
                4. DefaultSingletonBeanRegistry.class->getSingleton：調用singletonFactory的回調來實現bean的創建
                public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
                    synchronized (this.singletonObjects) {
                        Object singletonObject = this.singletonObjects.get(beanName);
                        if (singletonObject  null) {
                            ...
                            ...
                            try {
                                singletonObject = singletonFactory.getObject();
                            }
                            ...
                            ...
                        return (singletonObject != NULL_OBJECT ? singletonObject : null);
                    }
                }
                5. SimpleInstantiationStrategy->instantiate()

                BeanDefinition: spring的bean默認映射對象

                • 創建流程：
                  • 從AbstractApplicationContext->refresh()：刷新context的信息。
                  • obtainFreshBeanFactory()：創建beanfactory，並將xml里面的bean解析成BeanDefinition,存放到beanDefinitionMap中。
                    • 先從XmlReaderContext中讀取配置，然后在根據配置BeanDefinitionDocumentReader 將BeanDefinition加載進去
                • 分析bean

                • private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
                      if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
                          importBeanDefinitionResource(ele);
                      }
                      else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
                          processAliasRegistration(ele);
                      }
                      else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
                          processBeanDefinition(ele, delegate);   //加載bean
                      }
                      else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
                          // recurse
                          doRegisterBeanDefinitions(ele);
                      }
                  }

                  BeanDefinitionReaderUtils工具類中的createBeanDefin

                • public static AbstractBeanDefinition createBeanDefinition(
                              String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
                  
                          GenericBeanDefinition bd = new GenericBeanDefinition();
                          bd.setParentName(parentName);
                          if (className != null) {
                              if (classLoader != null) {
                                  bd.setBeanClass(ClassUtils.forName(className, classLoader));
                              }
                              else {
                                  bd.setBeanClassName(className);
                              }
                          }
                          return bd;
                      }

                  • BeanDefinition的創建組成：

                  • 1. '屬性'
                    public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
                    
                        /** Map with String keys and Object values */
                        private final Map<String, Object> attributes = new LinkedHashMap<String, Object>(0);
                    }
                    2. '資源'
                    public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {
                    
                        private Object source;
                    }
                    
                    3. '對象信息'
                    public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
                            implements BeanDefinition, Cloneable {
                    
                        public static final String SCOPE_DEFAULT = "";
                        public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
                        public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
                        public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
                        public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
                    
                        public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;
                    
                        public static final int DEPENDENCY_CHECK_NONE = 0;
                        public static final int DEPENDENCY_CHECK_OBJECTS = 1;
                        public static final int DEPENDENCY_CHECK_SIMPLE = 2;
                        public static final int DEPENDENCY_CHECK_ALL = 3;
                    
                        public static final String INFER_METHOD = "(inferred)";
                    
                    
                        private volatile Object beanClass;
                    
                        private String scope = SCOPE_DEFAULT;
                    
                        private boolean abstractFlag = false;
                    
                        private boolean lazyInit = false;
                    
                        private int autowireMode = AUTOWIRE_NO;
                    
                        private int dependencyCheck = DEPENDENCY_CHECK_NONE;
                    
                        private String[] dependsOn;
                    
                        private boolean autowireCandidate = true;
                    
                        private boolean primary = false;
                    
                        private final Map<String, AutowireCandidateQualifier> qualifiers =
                                new LinkedHashMap<String, AutowireCandidateQualifier>(0);
                    
                        private boolean nonPublicAccessAllowed = true;
                    
                        private boolean lenientConstructorResolution = true;
                    
                        private ConstructorArgumentValues constructorArgumentValues;
                    
                        private MutablePropertyValues propertyValues;
                    
                        private MethodOverrides methodOverrides = new MethodOverrides();
                    
                        private String factoryBeanName;
                    
                        private String factoryMethodName;
                    
                        private String initMethodName;
                    
                        private String destroyMethodName;
                    
                        private boolean enforceInitMethod = true;
                    
                        private boolean enforceDestroyMethod = true;
                    
                        private boolean synthetic = false;
                    
                        private int role = BeanDefinition.ROLE_APPLICATION;
                    
                        private String description;
                    
                        private Resource resource;
                    }
                    4. 創建:bean創建的信息
                    public class GenericBeanDefinition extends AbstractBeanDefinition {
                    
                        private String parentName;
                    }

                    BeanDefinition的使用

                    • 通過SimpleInstantiationStrategy的instantiate，來創建bean對象。

                    • public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
                          if (beanDefinition.getMethodOverrides().isEmpty()) {
                              Constructor<?> constructorToUse;
                              synchronized (beanDefinition.constructorArgumentLock) {
                                  constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
                                  if (constructorToUse  null) {
                                      final Class<?> clazz = beanDefinition.getBeanClass();
                                      if (clazz.isInterface()) {
                                          throw new BeanInstantiationException(clazz, "Specified class is an interface");
                                      }
                                      try {
                                          if (System.getSecurityManager() != null) {
                                              constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                                                  @Override
                                                  public Constructor<?> run() throws Exception {
                                                      return clazz.getDeclaredConstructor((Class[]) null);
                                                  }
                                              });
                                          }
                                          else {
                                          '獲取構造器'
                                              constructorToUse =    clazz.getDeclaredConstructor((Class[]) null);
                                          }
                                          beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
                                      }
                                      catch (Exception ex) {
                                          throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                                      }
                                  }
                              }
                              '實例化對象'
                              return BeanUtils.instantiateClass(constructorToUse);
                          }
                          else {
                              // Must generate CGLIB subclass.
                              return instantiateWithMethodInjection(beanDefinition, beanName, owner);
                          }
                      }
                      
                      2. 'BeanUtils.instantiateClass(constructorToUse)'：用構造器實例化
                      public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
                          Assert.notNull(ctor, "Constructor must not be null");
                          try {
                              ReflectionUtils.makeAccessible(ctor);
                              return ctor.newInstance(args);
                          }
                          ....
                      }

核心創建方式

    Class<?> ob = Class.forName("com.fxl.spring.test.SayServiceImpl");
    //ob.getDeclaredConstructor(); 檢測構造器是否是公有
    SayService say = (SayService) ob.newInstance();
    say.getMessage();

結構圖

接口：

• AliasRegistry：注冊別名和具體的名稱接口
• SingletonBeanRegistry：注冊bean的接口
• BeanFactory：bean的實際調用接口
• HierarchicalBeanFactory：beanfactory的強化接口
• ConfigurableBeanFactory：beanfactory的調用接口
• AutowireCapableBeanFactory：beanfactory的強化接口
• ListableBeanFactory：beanfactory的強化接口，批量處理bean
• BeanDefinitionRegistry：bean的調用接口，包括接口別名
• ConfigurableListableBeanFactory：除了可配置beanfactory之外，它還提供了用於分析和修改bean定義的工具，以及預實例化單例

實現類

• SimpleAliasRegistry：存放別名和實際

public class SimpleAliasRegistry implements AliasRegistry {

	/** Map from alias to canonical name */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);
}

• DefaultSingletonBeanRegistry：存放具體的bean
  • singletonObjects： 存放bean的名稱及實例
  • singletonFactories： 存放bean的名稱及實例創建工廠

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	/** * Internal marker for a null singleton object: * used as marker value for concurrent Maps (which don't support null values). */
	protected static final Object NULL_OBJECT = new Object();


	/** Logger available to subclasses */
	protected final Log logger = LogFactory.getLog(getClass());

	/** Cache of singleton objects: bean name --> bean instance */
	// bean的名稱和實例
	private final Map<String, Object> 'singletonObjects' = new ConcurrentHashMap<String, Object>(64);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	// bean名稱和產生的工廠
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	// 早期存放bean的名稱和實例
	private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

	/** Set of registered singletons, containing the bean names in registration order */
	// bean的名稱
	private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);

	/** Names of beans that are currently in creation */
	// 創建的類
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

	/** Names of beans currently excluded from in creation checks */
	// 當前創建時需要排除的名稱
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

	/** List of suppressed Exceptions, available for associating related causes */
	// 拋出的錯誤
	private Set<Exception> suppressedExceptions;

	/** Flag that indicates whether we're currently within destroySingletons */
	// 銷毀時的狀態
	private boolean singletonsCurrentlyInDestruction = false;

	/** Disposable bean instances: bean name --> disposable instance */
	// bean名稱
	private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();

	/** Map between containing bean names: bean name --> Set of bean names that the bean contains */
	// 名稱
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);

	/** Map between dependent bean names: bean name --> Set of dependent bean names */
	// 依賴的名稱
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

	/** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
	// 依賴的名稱
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
}

• FactoryBeanRegistrySupport：bean緩存

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

	/** Cache of singleton objects created by FactoryBeans: FactoryBean name --> object */
	// 由FactoryBean創建的單例對象的緩存:FactoryBean名稱—對象
	private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);
}

• AbstractBeanFactory：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

	/** Parent bean factory, for bean inheritance support */
	// 父類 bean factory
	private BeanFactory parentBeanFactory;

	/** ClassLoader to resolve bean class names with, if necessary */
	// 類加載器
	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

	/** ClassLoader to temporarily resolve bean class names with, if necessary */
	// 類加載器在必要時臨時解析bean類名
	private ClassLoader tempClassLoader;

	/** Whether to cache bean metadata or rather reobtain it for every access */
	// 是否緩存bean元數據，或者是否為每個訪問重新獲取它
	private boolean cacheBeanMetadata = true;

	/** Resolution strategy for expressions in bean definition values */
	// bean定義值的表達式的解析策略
	private BeanExpressionResolver beanExpressionResolver;

	/** Spring ConversionService to use instead of PropertyEditors */
	// 使用Spring ConversionService來代替屬性編輯器
	private ConversionService conversionService;

	/** Custom PropertyEditorRegistrars to apply to the beans of this factory */
	// 自定義propertyeditorregistry應用到該工廠的bean
	private final Set<PropertyEditorRegistrar> propertyEditorRegistrars =
			new LinkedHashSet<PropertyEditorRegistrar>(4);

	/** A custom TypeConverter to use, overriding the default PropertyEditor mechanism */
	// 用於使用的自定義類型轉換，覆蓋默認的PropertyEditor機制
	private TypeConverter typeConverter;

	/** Custom PropertyEditors to apply to the beans of this factory */
	// 自定義屬性編輯器應用到該工廠的bean
	private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors =
			new HashMap<Class<?>, Class<? extends PropertyEditor>>(4);

	/** String resolvers to apply e.g. to annotation attribute values */
	// 將字符串解析器應用於注釋屬性值
	private final List<StringValueResolver> embeddedValueResolvers = new LinkedList<StringValueResolver>();

	/** BeanPostProcessors to apply in createBean */
	// 用於在createBean中應用的beanpost處理器
	private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();

	/** Indicates whether any InstantiationAwareBeanPostProcessors have been registered */
	// 表明InstantiationAwareBeanPostProcessors是否已經注冊
	private boolean hasInstantiationAwareBeanPostProcessors;

	/** Indicates whether any DestructionAwareBeanPostProcessors have been registered */
	// 表明DestructionAwareBeanPostProcessors是否已經注冊
	private boolean hasDestructionAwareBeanPostProcessors;

	/** Map from scope identifier String to corresponding Scope */
	// 從范圍標識符字符串映射到對應的范圍
	private final Map<String, Scope> scopes = new HashMap<String, Scope>(8);

	/** Security context used when running with a SecurityManager */
	// 與安全管理器一起運行時使用的安全上下文
	private SecurityContextProvider securityContextProvider;

	/** Map from bean name to merged RootBeanDefinition */
	// 從bean名稱映射到合並的RootBeanDefinition
	private final Map<String, RootBeanDefinition> mergedBeanDefinitions =
			new ConcurrentHashMap<String, RootBeanDefinition>(64);

	/** Names of beans that have already been created at least once */
	// 已經至少創建過一次的bean的名稱
	private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(64));

	/** Names of beans that are currently in creation */
	// 當前正在創建的bean的名稱
	private final ThreadLocal<Object> prototypesCurrentlyInCreation =
			new NamedThreadLocal<Object>("Prototype beans currently in creation");
}

• AbstractAutowireCapableBeanFactory：抽象bean工廠超類，實現了默認bean的創建，具有由RootBeanDefinition類指定的全部功能
  • 提供bean創建(使用構造函數解析)、屬性填充、連接(包括自動連接)和初始化。處理運行時bean引用、解析托管集合、調用初始化方法等。支持自動裝配構造函數、屬性名和屬性

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {

	/** Strategy for creating bean instances */
	// 創建bean實例的策略
	private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

	/** Resolver strategy for method parameter names */
	// 方法參數名的解析器策略
	private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

	/** Whether to automatically try to resolve circular references between beans */
	// 是否自動嘗試解析bean之間的循環引用
	private boolean allowCircularReferences = true;

	/** * Whether to resort to injecting a raw bean instance in case of circular reference, even if the injected bean eventually got wrapped. */
	// 是否在循環引用的情況下使用原始bean實例，即使注入的bean最終被包裝了
	private boolean allowRawInjectionDespiteWrapping = false;

	/** * Dependency types to ignore on dependency check and autowire, as Set of Class objects: for example, String. Default is none. */
	 // 依賴類型忽略依賴檢查和自動連接，這是類對象的集合:例如，String。默認是沒有的。
	private final Set<Class<?>> ignoredDependencyTypes = new HashSet<Class<?>>();

	/** * Dependency interfaces to ignore on dependency check and autowire, as Set of Class objects. By default, only the BeanFactory interface is ignored. */
	 // 依賴接口忽略依賴檢查和自動連接，這是類對象的集合。默認情況下，只會忽略BeanFactory接口。
	private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<Class<?>>();

	/** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
	// 未完成的FactoryBean實例的緩存:FactoryBean的名稱—bean包裝器
	private final Map<String, BeanWrapper> factoryBeanInstanceCache =
			new ConcurrentHashMap<String, BeanWrapper>(16);

	/** Cache of filtered PropertyDescriptors: bean Class -> PropertyDescriptor array */
	// 過濾的屬性描述符的緩存:bean類-屬性描述符數組
	private final Map<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
			new ConcurrentHashMap<Class<?>, PropertyDescriptor[]>(64);
}

• DefaultListableBeanFactory：在訪問bean之前，典型的用法是先注冊所有的bean定義(可能是從bean定義文件中讀取)。因此，Bean定義查找在本地Bean定義表中是一種廉價的操作，在預先構建的Bean定義元數據對象上運行。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

	private static Class<?> javaxInjectProviderClass = null;

	/** Map from serialized id to factory instance */
	// 序列化的工程id
	private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
			new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(8);

	/** Optional id for this factory, for serialization purposes */
	//這個工廠的可選id，用於序列化
	private String serializationId;

	/** Whether to allow re-registration of a different definition with the same name */
	// 是否允許用相同的名稱重新注冊一個不同的定義
	private boolean allowBeanDefinitionOverriding = true;

	/** Whether to allow eager class loading even for lazy-init beans */
	// 是否允許熱加載即使是 懶加載設置
	private boolean allowEagerClassLoading = true;

	/** Optional OrderComparator for dependency Lists and arrays */
	// 用於依賴列表和數組的可選的OrderComparator
	private Comparator<Object> dependencyComparator;

	/** Resolver to use for checking if a bean definition is an autowire candidate */
	// 解析器用於檢查bean定義是否為自動連接的候選
	private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();

	/** Map from dependency type to corresponding autowired value */
	// 從依賴類型映射到對應的自動連接值
	private final Map<Class<?>, Object> resolvableDependencies = new HashMap<Class<?>, Object>(16);

	/** Map of bean definition objects, keyed by bean name */
	// bean定義對象的映射，以bean名稱為鍵
	private final Map<String, BeanDefinition> 'beanDefinitionMap' = new ConcurrentHashMap<String, BeanDefinition>(64);

	/** Map of singleton and non-singleton bean names keyed by dependency type */
	// 單例和非單例bean的映射，依賴於依賴類型
	private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);

	/** Map of singleton-only bean names keyed by dependency type */
	// 依賴類型的名稱
	private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);

	/** List of bean definition names, in registration order */
	// 默認的名稱列表
	private final List<String> beanDefinitionNames = new ArrayList<String>();

	/** Whether bean definition metadata may be cached for all beans */
	// 是否為所有bean緩存bean定義元數據
	private boolean configurationFrozen = false;

	/** Cached array of bean definition names in case of frozen configuration */
	// 在凍結配置的情況下，緩存的bean定義名稱
	private String[] frozenBeanDefinitionNames;
}

beanfactory：bean的創建工廠

• 流程：
  • 從AbstractApplicationContext->refresh()->finishBeanFactoryInitialization()：實例化bean的時候，會調用beanFactory.preInstantiateSingletons()
  • 接着在 DefaultListableBeanFactory->preInstantiateSingletons() 實例化bean的時候，調用AbstractBeanFactory->getBean()
  • 接着在AbstractBeanFactory->doGetBean()中使用getSingleton()回調一個beanfactory
  • 最后調用 SimpleInstantiationStrategy->instantiate()的來實例化bean

1. DefaultListableBeanFactory->preInstantiateSingletons()：
public void preInstantiateSingletons() throws BeansException {

	List<String> beanNames;
	synchronized (this.beanDefinitionMap) {
		beanNames = new ArrayList<String>(this.beanDefinitionNames);
	}
	for (String beanName : beanNames) {
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				getBean(beanName);
		}
	}
}
2. AbstractBeanFactory->getBean(String beanName);
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}
3.AbstractBeanFactory->doGetBean(String beanName);一個回調用來生成 bean
protected <T> T doGetBean(
		final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
		throws BeansException {
	final String beanName = transformedBeanName(name);
	Object bean;
	...
	...
	'getSingleton回調一個ObjectFactory'
	sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
		@Override
		public Object getObject() throws BeansException {
			try {
				return createBean(beanName, mbd, args);
			}catch (BeansException ex) {
				destroySingleton(beanName);
			}
		}
	});
	...
	...
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	return (T) bean;
}
4. DefaultSingletonBeanRegistry.class->getSingleton：調用singletonFactory的回調來實現bean的創建
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	synchronized (this.singletonObjects) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject  null) {
			...
			...
			try {
				singletonObject = singletonFactory.getObject();
			}
			...
			...
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}
}
5. SimpleInstantiationStrategy->instantiate()

BeanDefinition: spring的bean默認映射對象

• 創建流程：
  • 從AbstractApplicationContext->refresh()：刷新context的信息。
  • obtainFreshBeanFactory()：創建beanfactory，並將xml里面的bean解析成BeanDefinition,存放到beanDefinitionMap中。
    • 先從XmlReaderContext中讀取配置，然后在根據配置BeanDefinitionDocumentReader 將BeanDefinition加載進去
• 分析bean

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);   //加載bean
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// recurse
		doRegisterBeanDefinitions(ele);
	}
}

• BeanDefinitionReaderUtils工具類中的createBeanDefinition創建bean

	public static AbstractBeanDefinition createBeanDefinition( String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}

• BeanDefinition的創建組成：

1. '屬性'
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {

	/** Map with String keys and Object values */
	private final Map<String, Object> attributes = new LinkedHashMap<String, Object>(0);
}
2. '資源'
public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {

	private Object source;
}

3. '對象信息'
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {

	public static final String SCOPE_DEFAULT = "";
	public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
	public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
	public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
	public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;

	public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;

	public static final int DEPENDENCY_CHECK_NONE = 0;
	public static final int DEPENDENCY_CHECK_OBJECTS = 1;
	public static final int DEPENDENCY_CHECK_SIMPLE = 2;
	public static final int DEPENDENCY_CHECK_ALL = 3;

	public static final String INFER_METHOD = "(inferred)";


	private volatile Object beanClass;

	private String scope = SCOPE_DEFAULT;

	private boolean abstractFlag = false;

	private boolean lazyInit = false;

	private int autowireMode = AUTOWIRE_NO;

	private int dependencyCheck = DEPENDENCY_CHECK_NONE;

	private String[] dependsOn;

	private boolean autowireCandidate = true;

	private boolean primary = false;

	private final Map<String, AutowireCandidateQualifier> qualifiers =
			new LinkedHashMap<String, AutowireCandidateQualifier>(0);

	private boolean nonPublicAccessAllowed = true;

	private boolean lenientConstructorResolution = true;

	private ConstructorArgumentValues constructorArgumentValues;

	private MutablePropertyValues propertyValues;

	private MethodOverrides methodOverrides = new MethodOverrides();

	private String factoryBeanName;

	private String factoryMethodName;

	private String initMethodName;

	private String destroyMethodName;

	private boolean enforceInitMethod = true;

	private boolean enforceDestroyMethod = true;

	private boolean synthetic = false;

	private int role = BeanDefinition.ROLE_APPLICATION;

	private String description;

	private Resource resource;
}
4. 創建:bean創建的信息
public class GenericBeanDefinition extends AbstractBeanDefinition {

	private String parentName;
}

• BeanDefinition的使用
  • 通過SimpleInstantiationStrategy的instantiate，來創建bean對象。

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
	if (beanDefinition.getMethodOverrides().isEmpty()) {
		Constructor<?> constructorToUse;
		synchronized (beanDefinition.constructorArgumentLock) {
			constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
			if (constructorToUse  null) {
				final Class<?> clazz = beanDefinition.getBeanClass();
				if (clazz.isInterface()) {
					throw new BeanInstantiationException(clazz, "Specified class is an interface");
				}
				try {
					if (System.getSecurityManager() != null) {
						constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
							@Override
							public Constructor<?> run() throws Exception {
								return clazz.getDeclaredConstructor((Class[]) null);
							}
						});
					}
					else {
					'獲取構造器'
						constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
					}
					beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
				}
				catch (Exception ex) {
					throw new BeanInstantiationException(clazz, "No default constructor found", ex);
				}
			}
		}
		'實例化對象'
		return BeanUtils.instantiateClass(constructorToUse);
	}
	else {
		// Must generate CGLIB subclass.
		return instantiateWithMethodInjection(beanDefinition, beanName, owner);
	}
}

2. 'BeanUtils.instantiateClass(constructorToUse)'：用構造器實例化
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
	Assert.notNull(ctor, "Constructor must not be null");
	try {
		ReflectionUtils.makeAccessible(ctor);
		return ctor.newInstance(args);
	}
    ....
}