持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第33天，点击查看活动详情

主要包含了容器的定义以及 bean 的解析。

1.目录结构

1.1.根目录

• 根目录：包含了操作 java bean 的接口和类

  • BeanInfoFactory：创建 java.beans.BeanInfo 实例的策略，定义了方法 BeanInfo getBeanInfo()。

  • ExtendedBeanInfo：BeanInfo 接口的实现类，BeanInfo 接口是在 java.beans 包中的。

  • ExtendedBeanInfoFactory：BeanInfoFactory 接口的实现，用来评估 bean 的 class 是否有不满足 JavaBean 规范的 set 方法，因而是否满足 Spring

    ExtendedBeanInfo 作为内省的候选。

  • BeanWrapper：Spring 底层 JavaBean 公共基础的核心接口。通常不直接使用，而是通过 BeanFactory 间接使用。作用：提供对标准 javabean 的分析和操作方法：单个或者批量获取和设置属性值，获取属性描述符，查询属性的可读性和可写性等。支持属性的嵌套设置，深度没有限制。

  • CachedIntrospectionResults：内部类。在BeanWrapperImpl类中会用到，为这个类的javabean缓存属性描述信息，以提高效率，减小开销。

  • BeanWrapperImpl：BeanWrapper的默认实现。可以根据需求，将集合与数组的值转换到对应目标对象的集合和数组。自定义的属性编辑器通过属性编辑器的setValue，setAsText方法实现上述的转换功能。

  • Mergeable：代表一个对象的值可以和父对象的值进行合并的接口。其主要的子类有：ManagedList、ManagedArray、ManagedMap、ManagedProperties、ManagedSet。这几个类在org.springframework.beans.factory 包中。

  • BeanMetadataElement：传送配置源对象的超级接口。定义了唯一的方法 Object getSource()

  • BeanMetadataAttribute：bean definition定义中的属性-键值对(key-value)容器。

  • BeanMetadataAttributeAccessor：AttributeAccessorSupport的拓展，为了追踪对象定义源。

  • GenericTypeAwarePropertyDescriptor：JavaBeans的PropertyDescriptor类的拓展，重载了getPropertyType函数。

  • PropertyDescriptorUtils：抽象类，PropertyDescriptor内部使用。PropertyDescriptor(属性描述器)在软件包 java.beans中，用来表示JavaBean 通过存储器方法导出的一个属性。

  • PropertyMatches：根据一个可配置的距离计算一个属性的匹配度。可同时用于java bean的成员变量(fields)与属性(properties)。其核心函数calculateStringDistance，利用Levenshtein算法计算两个字符串的相似度。另解析下Java中成员变量(Fields)和属性(Properties)的区别： 成员变量Fields就是定义的字段。根据SUN官方定义，属性是指get或者set方法名去掉get或者set后，把剩余的部分首字母改为小写后，即为这个类的属性。

  • PropertyAccessor：获取和设置属性(例如对象bean的属性，对象的Field)的通用接口，它用来作为BeanWrapper的基础接口。

  • AbstractPropertyAccessor：PropertyAccessor接口的抽象实现。

  • AbstractNestablePropertyAccessor：继承自AbstractPropertyAccessor，也是ConfigurablePropertyAccessor的一种，可以为典型的一些应用场景提供支持。

  • ConfigurablePropertyAccessor：PropertyAccessor配置方法的封装接口。是BeanWrapper的父接口。

  • DirectFieldAccessor：ConfigurablePropertyAccessor接口的实现类，用来直接获取实例的字段(f ield)。

  • PropertyAccessorFactory：获取PropertyAccessor实例简单工厂，特别是BeanWrapper实例(BeanWrapper继承自PropertyAccessor)。

  • PropertyAccessorUtils：PropertyAccessor类获取和设置属性的一些工具方法。

  • PropertyEditorRegistrar：用一个属性编辑器注册器(PropertyEditorRegistry)注册一个自定义的属性编辑器(PropertyEditor)的策略接口。

  • PropertyEditorRegistry：属性编辑器注册器。封装了JavaBean属性编辑器的注册方法。主要函数为void registerCustomEditor()。

  • PropertyEditorRegistrySupport：PropertyEditorRegistry接口的基本实现类。主要作为BeanWrapperImpl父类使用。

  • PropertyValue：一个对象，用来保存一个bean单独属性值信息。用对象来保存PropertyValue(name, value)信息，相对于map保存可以提供更大的灵活性。

  • PropertyValues：包含了一个或者多个PropertyValue对象，通常用作特定的一个目的bean的属性更新。

  • MutablePropertyValues：PropertyValues接口的默认实现，提供了对属性的一些简单操作，比如get、add、set、merge、remove方法等。

  • PropertyValuesEditor：PropertyValues 对象的编辑器。

  • TypeConverter：定义了类型转换方法的接口。将值转换成指定的类型。

  • TypeConverterDelegate：内部用的类，用来将属性值转换为目标类型的值。

  • SimpleTypeConverter：TypeConverter接口的简单实现，它不会针对一个特定的目标进行操作。

  • TypeConverterSupport：TypeConverter接口的基本实现类，使用了代理typeConverterDelegate。这个类主要用作BeanWrapperImpl的基类使用。

  • BeanUtils：JavaBeans的静态工具方法，用来初始化bean，检查bean属性类型，复制bean属性等。

  • BeansException：在beans包和子包中所抛出的所有异常的抽象超类。

  • BeanInstantiationException：bean初始化失败时抛出的异常。

  • FatalBeanException：在 bean 包和子包中遇到的不可恢复问题抛出的异常，例如当引用一个无效的 bean 属性时抛出的 InvalidPropertyException 异常。

  • ConversionNotSupportedException：当一个 bean 的属性没有适合的编辑器或者转换器时所抛出的异常。

  • MethodInvocationException：当一个 bean 属性的 get 和 set 方法抛出异常时抛出该异常，类似于 InvocationTargetException。

  • NullValueInNestedPathException：当获取一个内嵌属性路径的属性时遇到空指针异常时抛出的异常。

  • TypeMismatchException：当试图设置 bean 属性时抛出的类型不匹配异常。

  • InvalidPropertyException：遇到非法的 bean property 时异常类。

  • NotReadablePropertyException：当试图获取一个不可读属性的属性值时抛出的异常，典型场景 bean 属性没有 get 方法。

  • NotWritablePropertyException：当试图向一个不可写属性写入属性值时抛出的异常，典型场景 bean 属性没有 set 方法。.

  • PropertyAccessException：获取属性相关的异常超类，例如类型不匹配或者目标调用异常。

  • PropertyBatchUpdateException 组合异常，由多个的单个 PropertyAccessException 实例组成。

1.2.annotation

• annotation：注解支持包，提供对 Java 5 注解处理 bean 样式的支持。
  • AnnotationBeanUtils：JavaBean 类型注解的通用工具方法。定义了一个静态方法：public static void copyPropertiesToBean()，将指定 Annotation 的属性复制到目标 bean 中。如果属性在 excludeProperties 中定义了，那么就不会被复制

1.3.factory

• factory：实现 spring 轻量级 IOC 容器的核心包。

1.3.1.根目录

• 根目录：

  • Aware：它是一个标签，内部没有任何属性或者方法。它是一个超级接口，实现它的子接口的bean标志着在spring容器中可以被特定框架的对象通知到，通过回调方式的方法来完成这种通知。

  • BeanClassLoaderAware：允许一个获取它的classLoader(即当前bean factory加载bean类使用的class loader)的回调类，实现了void setBeanClassLoader(ClassLoader classLoader)。

  • BeanFactoryAware：实现此接口的bean可以获取到它们自己的Beanfactory。比如，bean可以通过factory寻找一些具有协作关系的beans。

  • BeanNameAware：实现此接口的bean可以在一个bean factory中获取到它们的bean名称。但是需要注意的是，并不推荐一个通过一个bean name去定位bean，在外部配置中，这种对应关系并不严格对应。

  • NamedBean：对应BeanNameAware接口，返回bean的名称。函数String getBeanName()。

  • BeanFactory：获取spring bean容器的根接口。其主要函数有getBean()、getBeanProvider()、containsBean()、isSingleton()、isPrototype()、isTypeMatch()、getType()、getAliases()

  • BeanFactoryUtils：beanFactory上的操作方法工具类，特别是在ListableBeanFactory接口上。包括返回bean的个数，bean的名字，bean实例等，考虑到了一些具有嵌套关系的hierarchy factory，而如果这些方法在ListableBeanFactory中不需要考虑这些。

  • HierarchicalBeanFactory：子接口，实现此接口的bean factory具有层次结构即可以获取父BeanFactory。方法 getParentBeanFactory() 获取父BeanFactory；方法 containsLocalBean() 判断本地bean factory是否含有指定名字的bean，不考虑在父BeanFactory中的情况。

  • ListableBeanFactory：beanFactory接口的实现，实现此接口的beanFactory能遍历他们内部的所有bean实例，而不用根据客户请求通过名字一个一个的去搜索bean。提供的函数如下，有些函数会有重载：

    1. containsBeanDefinition()：判断factory是否包含指定命名的bean definition；
    2. getBeanDefinitionCount()：返回在factory中定义的bean的个数；
    3. getBeanDefinitionNames()：返回该factory中定义的所有bean的名字；
    4. getBeanNamesForType()：返回指定类型的bean的名字；
    5. getBeansOfType()：返回指定类型的bean实例；
    6. getBeanNamesForAnnotation()：返回被指定的标签标注的所有bean的名字；
    7. getBeansWithAnnotation()：返回被指定标签标注的所有bean实例。

  • FactoryBean：实现了此接口的bean不能看做一个通常意义上的bean，一个FactoryBean虽然以bean的形式来定义，但它暴露的对象(getObject())通常是它创建的对象，而不是作为一个bean实例暴露自己。

  • SmartFactoryBean：FactoryBean接口的扩展实现。实现该接口可以表明每次是否返回的都是独立的实例，因为用isSingleton()函数判断为假，表明非单例模式，但这并不足以表明返回的都是独立的实例。

  • ObjectFactory：一个对象工厂，当触发时会返回所有对象的实例(可以是共享的或者独立的)。

  • ObjectProvider：继承自ObjectFactory，ObjectFactory的一个变种，专门用来为注入点服务。

  • InjectionPoint：注入点的简单描述，指向一个方法或者构造函数的参数或者成员变量(field)。

  • InitializingBean：实现此接口的bean在BeanFactory设置为它们的属性时只需要执行一次，例如初始化定制或者仅仅检查必须存在的属性是否已经设置完成等等。

  • SmartInitializingSingleton：回调接口，当一个bean工厂创建时，单例singleton实例化阶段结束时被触发。一些单例模式的bean可以实现此接口，在单例实例做完一些规律性、常做的初始化可以用来做一些初始化工作。以避免突发的Early initialization产生的负面效果。比如ListableBeanFactory中的getBeansOfType函数调用。注：对于单件的初始化有 (Lazy Initialization) 和 (Early initialization) 两种方法。

  • BeanCreationException：beanfactory在试图通过bean definition创建一个bean时遇到错误而抛出的异常。

  • BeanCreationNotAllowedException：若当前不允许创建一个bean时(例如在beanFactory关闭过程中)而试图去获取bean的请求时抛出的异常。

  • BeanCurrentlyInCreationException：一个bean的引用当前正在创建过程中抛出的异常。

  • BeanDefinitionStoreException：beanFactory遇到一个无效的bean definition抛出的异常 。

  • BeanExpressionException：获取一个表达式的值失败时抛出的异常。

  • BeanInitializationException：bean初始化异常时抛出。

  • BeanIsAbstractException：当试图获取一个定义为abstract的bean definition时抛出的异常。

  • BeanIsNotAFactoryException：当一个bean不是工厂，但用户试图通过给定bean名称访问工厂。

  • BeanNotOfRequiredTypeException：当一个bean的类型和期望类型不匹配时抛出的异常。

  • CannotLoadBeanClassException：BeanFactory不能加载指定bean的class类时抛出的异常。

  • FactoryBeanNotInitializedException：工厂bean没有初始化异常。

  • NoSuchBeanDefinitionException：没有该bean definition异常。

  • NoUniqueBeanDefinitionException：返回多个bean definition异常。

  • UnsatisfiedDependencyException：当有依赖检查时，在bean factory定义中，bean的依赖或者属性没有指定时抛出的异常。

1.3.2.annotation

• annotation：配置基于注解驱动的bean的支持包

  • AnnotatedBeanDefinition：BeanDefinition接口的扩展，BeanDefinition在org.springframework. beans.factory.config包中。它暴露了它的bean 类的AnnotationMetadata，不需要加载类。提供了一个getMetadata()方法来获取该bean definition的注解元数据， ClassMetadata定义了一个特定类的抽象元数据，不需要加载此类即可访问，主要方法有：

    1. String getClassName()：返回该类的名称。
    2. boolean isInterface()：返回该类是否是接口。
    3. boolean isAbstract()：返回该类是否为抽象类。
    4. boolean isConcrete()：返回该类是否为具体类。
    5. boolean isFinal()：返回该类是否为final类。
    6. boolean hasSuperClass()：返回该类是否有父类。
    7. String getSuperClassName()：返回父类的名称，没有的话返回null。
    8. String[] getInterfaceNames()：返回继承的接口数组，如果没有，返回空。
    9. String[] getMemberClassNames()：返回引用的类的名称。

  • AnnotatedGenericBeanDefinition：继承自GernericBeanDefinition和AnnotatedBeanDefinition，通过暴露AnnotatedBeanDefinition接口来增加对注解元数据的支持。GernericBeanDefinition在org.springframework.beans.factory.support包中，是一站式的标准bean Definition。

  • RequiredAnnotationBeanPostProcessor(@required注解实现类)：实现了BeanPostProcessor，对配置了Required注解的javaBean属性进行强制检查。

  • AutowiredAnnotationBeanPostProcessor (Autowired注解实现类)：实现了BeanPostProcessor接口，它自动绑定注解的field，setter方法和任意配置方法。AutowiredAnnotationBeanPostProcessor 间接继承了BeanPostProcessor，它自动绑定注解的field，setter方法和任意的配置方法。当检测到5个java注解时这些成员被注入其中。spring默认的注解为@Autowired和@Value。另外：也支持JSR-330的@inject注解，作为@Autowired的替代方案。

  • AnnotationBeanWiringInfoResolver(@configurable注解实现)：继承自BeanWiringInfoResolver，使用configurable的注解来查找哪些类需要自动绑定。设置 @Configurable 注解中的autowire属性就可以让Spring来自动装配：@Configurable(autowire= Autowire.BY_TYPE) 或者 @Configurable(autowire=Autowire.BY_NAME，这样就可以按类型或者按名字自动装配了。

  • QualifierAnnotationAutowireCandidateResolver(@qualifier的注解实现类)：间接实现了AutowireCandidateResolver，对要自动绑定的field或者参数和bean definition根据@qualifier注解进行匹配。同时也支持通过@value注解来绑定表达式的值。AutowireCandidateResolver是一个策略接口，由它来决定特定的bean definition对特定的依赖是否可以作为一个自动绑定的候选项。

  • InitDestroyAnnotationBeanPostProcessor(初始化和销毁方法的注解实现类)：间接继承了BeanPostProcessor，实现了通过注解来初始化init和销毁destroy方法。是spring的InitializingBean和DisposableBean回调接口的注解实现。

  • BeanFactoryAnnotationUtils：关联注解的bean的查询的工具方法，例如spring的@Qualifier注解。

  • CustomAutowireConfigurer：继承了BeanFactoryPostProcessor，它使自定义的自动绑定qualifier类型的注册更便利。.

  • InjectionMetadata：管理注入元数据的内部类。

  • ParameterResolutionDelegate：代理类，用来解析外部构造函数或方法上的自动装配的参数。

  • Autowire：决定自动绑定状态的枚举，即一个bean的依赖是否由spring容器使用setter方式自动注入。这个是spring DI的核心概念。

  • @Required：依赖检查；

  • @Autowired：按类型自动装配，用于替代基于XML配置的自动装配。基于@Autowired的自动装配，默认是根据类型注入，可以用于构造器、字段、方法注入

  • @Value：注入int、float、String等基本数据类型，只能标注在成员变量、setter方法上。

  • @Qualifier：限定描述符，用于细粒度选择候选者。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者。@Qualifier(value = "限定标识符")

  • @Configurable：注解中的 autowire 属性就可以让 Spring 来自动装配。

  • @Lookup：作用在方法上的注解，被其标注的方法会被重写，然后根据其返回值的类型，容器调用BeanFactory的getBean()方法来返回一个bean。如果有一个类C，需要用到类B，如果使用@Autowired注解注入B，那么B每次调用都是同一个对象，即使B不是单例的，现在我希望每次调用B都是不一样的，那么实现方案有2个：方案A : 每次从容器中获取B；方案B: 使用@lookup注解。

1.3.3.config

• config：bean 工厂的 SPI 接口和配置相关的处理类。

  • AbstractFactoryBean：实现了FactoryBean的简单模板超类，它根据singleton标志来决定是创建一个单例还是一个prototype对象。

  • ListFactoryBean：共享一组(list)实例的简单工厂bean。

  • MapFactoryBean：共享一组(map)实例的简单工厂bean。

  • SetFactoryBean：共享set实例的简单工厂bean。

  • MethodInvokingFactoryBean：一个有返回值的工厂bean，它返回触发一个静态或者实例的方法的结果。

  • MethodInvokingBean：一个简单的method invoker bean，和MethodInvokingFactoryBean不同，它并不返回触发一个方法的结果，而是仅仅返回触发一个目标方法。

  • FieldRetrievingFactoryBean：检索静态或者非静态Field的值的工厂bean。

  • PropertyPathFactoryBean：通过给定目标对象计算属性路径的工厂bean。

  • ObjectFactoryCreatingFactoryBean：一个有返回值的工厂bean，它返回ObjectFactory。

  • ProviderCreatingFactoryBean：返回一个JSR-330 Provider的工厂bean，JSR-330 Provider反过来从beanFactory返回一个bean资源。JSR-330 是 Java 的依赖注入标准。

  • ServiceLocatorFactoryBean：继承自FactoryBean，在beanFactory中创建一个动态代理，来代理一个具有一个或者多个服务或者类型的接口。

  • PropertiesFactoryBean：它支持从classpath位置的文件中读取属性实例的工厂bean。

  • YamlMapFactoryBean：为读取YAML源文件的Map的工厂，保持YAML声明的值类型和结构的原样。

  • YamlProcessor：YAML 是专门用来写配置文件的语言，非常简洁和强大，远比 JSON 格式方便。它实质上是一种通用的数据串行化格式。该类作为YAML factories基类。

  • YamlPropertiesFactoryBean：从YAML源文件中读取属性的工厂，用来暴露字符串属性值扁平型组织结构。

  • AutowireCapableBeanFactory：beanFactory的扩展接口，实现了自动绑定功能。这个接口的两个主要方法是：autowire：使用给定的自动绑定策略，来给一个类的新实例进行初始化。autowireBeanProperties使用名称或者类型来自动绑定给定bean实例的属性。

  • ConfigurableBeanFactory：将会被大部分beanFactory实现的配置接口。为对bean factory进行配置提供一些功能服务，包括BeanFactory接口中的一些函数。这个接口并不用于普通的应用代码，而是用于同BeanFactory或 ListableBeanFactory一起出现使用。

  • ConfigurableListableBeanFactory：将会被大部分ListablebeanFactory实现的配置接口。除了ConfigurableBeanFactory，该接口也提供分析和修改bean definitions的功能函数，也能预实例化单例对象。

  • BeanDefinition：一个bean实例的描述，它含有属性值、构造参数值。它的实现子类还提供更多的信息。bean的定义BeanDefinition，包装BeanWrapper是java bean的基础。可以这么说，是spring的基石，再怎么强调它的重要性都不为过。

    BeanDefinition 作用：一个BeanDefinition描述了一个bean的实例，包括属性值，构造方法参数值和继承自它的类的更多信息。BeanDefinition仅仅是一个最简单的接口，主要功能是允许BeanFactoryPostProcessor，例如PropertyPlaceHolderConfigure(PropertyPlaceholderConfigurer是BeanFactoryPostProcessor的一个重要实现)能够检索并修改属性值和别的bean的元数据。

    BeanDefinition的继承关系：(1)父接口：AttributeAccessor、BeanMetadataElement。其中，AttributeAccessor 接口定义了最基本的对任意对象的元数据的修改或者获取，BeanMetadataElement接口提供了一个getResource()方法，用来传输一个可配置的源对象。(2)子接口：AnnotatedBeanDefinition。(3)子类：AbstractBeanDefinition、AnnotatedGenericBeanDefinition、ChildBeanDefinition、GenericBeanDefinition、RootBeanDefinition、ScannedGenericBeanDefinition。

  • BeanDefinitionCustomizer：定制一个给定的bean definition的回调函数，用在Lambda 表达式或者方法引用中。

  • BeanDefinitionHolder：使用名称或者别名来保存BeanDefinition。可以为内部bean作为占位符注册。

  • BeanDefinitionVisitor：遍历BeanDefinition对象的参观者类，特别是也遍历bean中的属性值和构造参数值，解析bean的元数据值。在PlaceholderConfigurerSupport中被使用，用来解析包含在BeanDefinition中所有的字符串值，解析发现的所有占位符。

  • BeanPostProcessor：允许对一个新的 bean 实例进行定制修改的工厂钩子。

  • BeanFactoryPostProcessor：允许对一个 applicationContext 中的 bean definition 进行定制修改的工厂钩子，修改 context 内含的 bean factory 中bean的属性值。

  • DestructionAwareBeanPostProcessor：BeanPostProcessor 的子接口，它增加了一个销毁前回调方法。

  • InstantiationAwareBeanPostProcessor：BeanPostProcessor 的子接口，它增加了一个初始化前回调方法，还有一个在初始化后但显式设置属性或者自动绑定发生前的回调方法。

  • InstantiationAwareBeanPostProcessorAdapter：实现了SmartInstantiationAwareBeanPostProcessor所有方法的适配器，它没有任何操作，不会改变容器对bean进行初始化的处理过程。

  • SmartInstantiationAwareBeanPostProcessor：InstantiationAwareBeanPostProcessor 的扩展接口，它增加了对一个处理过 bean 的最终类型进行预测的回调方法。

  • CustomEditorConfigurer：继承自BeanFactoryPostProcessor，给自定义属性编辑器的注册提供了便利的方法。

  • CustomScopeConfigurer：BeanFactoryPostProcessor 的简单实现，给自定义 Scope 的注册提供了便利的方法，上面提到 ConfigurableBeanFactory 提供了Scope的注册。

  • PreferencesPlaceholderConfigurer：PropertyPlaceholderConfigurer 的子类，支持 JDK1.4 中的 Preferences API (java.util.prefs)

  • PropertyOverrideConfigurer：属性资源配置器，它支持在 applicationContext 中重写一个bean的属性值。

  • PropertyPlaceholderConfigurer：PlaceholderConfigurerSupport 的子类，它解析本地属性或者系统属性或者环境变量定义的占位符(以${}描述)。

  • PropertyResourceConfigurer：支持从一个属性资源中对单个 bean 的属性值进行配置。

  • BeanExpressionContext：计算一个BeanDefinition内部的表达式的容器对象。

  • BeanExpressionResolver：通过计算一个表达式来解析为值的策略接口。

  • EmbeddedValueResolver：StringValueResolver适配器，用于解析ConfigurableBeanFactory占位符和表达式。

  • BeanReference：暴露bean名称的引用接口。这个接口并不需要实际指向一个bean实例，只需要逻辑指向bean的名字。

  • RuntimeBeanNameReference：固定占位符类，当在beanfactory中作为另外一个bean名称的引用时，作为属性值对象，将在运行时进行解析。

  • RuntimeBeanReference：固定占位符类，当在beanfactory中作为另外一个bean的引用时，作为属性值对象，将在运行时进行解析。

  • TypedStringValue：保存一个类型的属性值。

  • ConstructorArgumentValues：保存构造方法的参数值，特别是作为Beandefinition的一部分。

  • DependencyDescriptor：将要注入的特定依赖的描述。

  • DeprecatedBeanWarner：继承自BeanFactoryPostProcessor，记录@Deprecated bean的报警信息。

  • PlaceholderConfigurerSupport：属性资源配置器的抽象基类，它解析BeanDefinition中属性值的占位符。

  • AutowiredPropertyMarker：简单的标记类，用于自动装载属性值，增加到BeanDefinition的getPropertyValues()函数为一个指定的bean 属性。

  • NamedBeanHolder：给定名字的bean实例的简单占位符。

  • SingletonBeanRegistry：定义了共享bean实例的注册接口。

  • Scope：ConfigurableBeanFactory使用的策略接口，代表了bean实例所在的作用域。Bean的作用域就是指Bean实例的生存空间或者有效范围。scope=[singleton, prototype, request, session, global session]

    1. singleton(单实例)：在每个Spring IOC容器中，一个Bean定义对应一个对象实例。这是Spring容器默认的作用域。当一个Bean的作用域为Singleton时，Spring IOC容器中只会存在一个共享的Bean实例，并且所有对Bean的请求，只要id与该Bean定义相匹配，就只会返回Bean的同一个实例。这个单一实例会被存储到单例缓存(Singleton Cache)中，并且所有针对该Bean的后续请求和引用都将返回被缓存的对象实例。单实例模式对于无会话状态的Bean(DAO组件、业务逻辑组件)来说是理想的选择。
    2. prototype(原型模式):一个bean定义对应多个对象实例。prototype作用域的Bean在每次对该Bean请求时都会创建一个新的Bean实例，对需要保持会话状态的Bean(Struts2中充当控制器的Action类)应该使用prototype作用域。spring不能对一个原型模式Bean的整个生命周期负责，容器在初始化、装配好一个原型模式实例后，将它交给客户端，就不再过问了。因此，客户端要负责原型模式实例的生命周期管理。
    3. request：在一次Http请求中，容器会返回该Bean的同一个实例，而对于不同的用户请求，会返回不同的实例。该作用域仅在基于Web的Spring ApplicationContext情形下有效。
    4. session：在一次HttpSession中，容器会返回该Bean的同一个实例。而对于不同的HttpSession请求，会返回不同的实例。该作用域仅在基于Web的Spring ApplicationContext情形下有效。
    5. global session：在全局的HTTPSession中，容器会返回该Bean的同一个实例。仅在使用portlet context时有效。

1.3.4.parsing

• parsing：bean definition 解析的支持基础类。

  • AbstractComponentDefinition：ComponentDefinition接口的基本实现，提供了getDescription()来代理ComponentDefinition.getName()方法。
  • BeanComponentDefinition：基于一个标准BeanDefinition的ComponentDefinition，暴露指定bean的指定beanDefinition，内部BeanDefinition和BeanReference。
  • ComponentDefinition：描述在同一配置的Context中一组BeanDefinition和BeanReference的逻辑视图的接口。
  • CompositeComponentDefinition：保存了一个或者多个内嵌ComponentDefinition实例的ComponentDefinition实现，它把这些ComponentDefinition实例聚合成具有命名的组。
  • AliasDefinition：代表在解析进程中一个别名已经被注册。
  • ImportDefinition：在解析进程中，代表一个import已经被处理。
  • DefaultsDefinition：一个默认definition标识接口，继承了BeanMetadataElement，没有实现任何方法。
  • ConstructorArgumentEntry：代表了构造参数。
  • BeanEntry：代表了一个BeanDefinition。
  • PropertyEntry：代表了一个javaBean的属性。
  • QualifierEntry：代表了一个自动绑定的备选qualifier。
  • EmptyReaderEventListener：ReaderEventListener接口的空实现，所有回调方法都没有提供可执行操作。
  • ReaderEventListener：接受在读取BeanDefinition进程中注册组件、别名、import时的回调接口。
  • FailFastProblemReporter：ProblemReporter接口的简单实现，当遇到错误发生时展示fail-fast行为。
  • ProblemReporter：SPI接口，支持tool或者外部进程处理在beanDefinition解析期间报出的错误或者异常。
  • PassThroughSourceExtractor：SourceExtractor的简单实现，它通过一个attachment来传递备选的源数据类型对象。
  • NullSourceExtractor：SourceExtractor接口的简单实现，返回null作为source元数据。
  • SourceExtractor：简单策略接口，允许工具控制source元数据关联到bean definition元数据。
  • Location：模型接口，一个资源位置的模型。
  • ParseState：在解析进程中作为一个简单的基于栈结构的追踪逻辑位置类。
  • Problem：代表了一个beanDefinition配置问题。
  • ReaderContext：bean definition读取进程中传递的一个Context，封装了所有相关的配置，包括状态。
  • BeanDefinitionParsingException：一个bean definition验证失败时抛出异常的异常类。

1.3.5.serviceloader

• serviceloader：jdk1.6 ServiceLoader 基础类的支持包。

  • AbstractServiceLoaderBasedFactoryBean：FactoryBean的抽象基类，它是操作JDK1.6 ServiceLoader的基础工具。
  • ServiceFactoryBean：暴露指定配置的服务类的基础服务的FactoryBean，通过JDK1.6 serviceLoader基础类来获取这些服务。
  • ServiceListFactoryBean：暴露配置的服务类的所有基础服务的FactoryBean，表现为一组服务对象，可以通过JDK1.6 serviceLoader基础类来获取这些服务。
  • ServiceLoaderFactoryBean：暴露指定配置服务类的JDK1.6 serviceLoader的FactoryBean。

1.3.6.support

• support：org.springframework.beans.factory 包的支持类。

  • DefaultListableBeanFactory：是 beans 包中最核心的一个类，ListableBeanFactory 接口和 BeanDefinitionRegistry 接口的默认实现：基于beanDefinition 对象的一个成熟的 beanFactory。BeanDefinitionRegistry(在此包中)提供了 beanDefinition 的管理。AbstractAutowireCapableBeanFactory(在此包中)实现属性的自动绑定功能。ConfigurableListableBeanFactory(在org.springframework.beans.factory.config包中)提供了对 bean 定义的分析和修改的便利方法，同时也提供了对单例的预实例化。

    Serializable接口是 Java 提供的序列化接口，是一个空接口，为对象提供标准的序列化和反序列化操作。它的源代码是 public interface Serializable{}，即什么都没有，是一个标识接口。在Java中的这个 Serializable 接口是给 JVM 看的，告诉 JVM，开发者不做这个类的序列化了，JVM 帮助开发者做序列化。当我们让实体类实现此接口，其实是告诉 JVM 此类可以被序列化，可被默认的序列化机制序列化。序列化就是将一个对象及其状态转换成字节码，保存起来(可以保存在数据库、内存、文件等)，然后可以在适当的时候再将其状态恢复(也就是反序列化)。有两个应用场景：一是想把内存中的对象状态保存到一个文件或者数据库中，二是想将对象通过网络进行传输的时候。

    DefaultListableBeanFactory 是通过实现上述 4 个特定的功能的接口、抽象类来完成的，是一个成熟的 bean factory。spring IOC 容器的实现，从根源上是 beanfactory，但真正可以作为一个独立使用的 IOC 容器还是 DefaultListableBeanFactory，因此可以说 DefaultListableBeanFactory 是整个 spring IOC 的始祖。它可以作为一个单独的 BeanFactory，也可作为自定义 BeanFactory 的父类。

    1. 类入口处提供了一个静态方法：

       javaxInjectProviderClass=ClassUtils.forName("javax.inject.Provider",DefaultListableBeanFactory.class.getClassLoader());

       ClassUtils(在包org.springframework.util里)提供了对类的实用方法，主要用在框架内部。这个静态方法返回了 javax.inject.Provider 的一个实例。 包 javax.inject 指定了获取对象的一种方法，该方法与构造器、工厂这些传统方法相比可以获得更好的可重用性、可测试性以及可维护性。此方法的处理过程就是大家熟知的依赖注入。javax.inject.Provider其语法：public interface Provider，提供了一个T的实例，通常作为一个依赖注入容器的父接口，可以注入任何类型的T，当然也可以注入Provider，相对于直接注入，有几个好处：检索多个实例，延迟或者选择性的检索一个实例，打破循环依赖，抽象的scope，可以从一个包含scope的更小的scope中检索一个实例。

    2. 继承自 AbstractAutowireCapableBeanFactory 的方法

       提供bean的创建(有construct方法)，属性注值，绑定(包括自动绑定)和初始化。处理运行时bean引用，解析管理的集合，调用初始化方法。最主要的实现的模板方法是：AutowireCapleBeanFactory 类(在包org.springframework.beans. factory.config中，AbstractAutowireCapableBeanFactory 实现此接口)中的方法 resolveDependency(DependencyDescriptor, String, Set, TypeConverter)。这个方法用来实现类型的自动绑定 AbstractAutowireCapableBeanFactory.copyConfigurationFrom(ConfigurableBeanFactory otherFactory)

    3. 继承自 ListableBeanFactory 接口的方法

       ListableBeanFactory(在包org.springframework.beans.factory中)是 beanFactory 接口的扩展接口，它可以枚举所有的 bean 实例，而不是客户端通过名称一个一个的查询得出所有的实例。要预加载所有的 bean 定义的 beanfactory 可以实现这个接口来。该接口定义了访问容器中 Bean 基本信息的若干方法，如查看 Bean 的个数、获取某一类型Bean的配置名、查看容器中是否包括某一Bean等方法；

       继承自该接口的方法有：containsBeanDefinition()、findAnnotationOnBean() 、getBeanDefinitionCount() 、getBeanDefinitionNames()、getBeanNamesForType() 、getBeansOfType() 、getBeansWithAnnotation() 。

    4. 继承自 ConfigurableListableBeanFactory 接口的方法

       ConfigurableListableBeanFactory(在包org.springframework.beans.factory.config中)同时继承了ListableBeanFactory，AutowireCapableBeanFactory和ConfigurableBeanFactory，提供了对bean定义的分析和修改的便利方法，同时也提供了对单例的预实例化。

       继承该接口的方法有：freezeConfiguration() 、getBeanDefinition()、ignoreDependencyInterface() 、ignoreDependencyType() 、isAutowireCandidate() 、isConfigurationFrozen() 、preInstantiateSingletons()、registerResolvableDependency() 。

    5. 继承自 BeanDefinitionRegistry 接口的方法

       BeanDefinitionRegistry：Spring配置文件中每一个节点元素在Spring容器里都通过一个BeanDefinition对象表示，它描述了Bean的配置信息。而BeanDefinition Registry接口提供了向容器手工注册BeanDefinition对象的方法。

       继承该接口的方法有：containsBeanDefinition() 、getBeanDefinition()、getBeanDefinitionCount()、getBeanDefinitionNames() 、isBeanNameInUse() 、registerBeanDefinition() 、removeBeanDefinition() 。

    6. 序列化支持

       private void writeObject(java.io.ObjectOutputStream out)；

       private void readObject(java.io.ObjectInputStream in)；

       private void readObjectNoData()。

  • StaticListableBeanFactory：静态 BeanFactory 的实现，用来编程实现注册已经存在的单例实例。

  • AbstractBeanFactory：BeanFactory 的抽象基类实现，提供 ConfigurableBeanFactory SPI 的全部功能。

    SPI 全称 Service Provider Interface，一种服务发现机制。是 Java 提供的一套用来被第三方实现或者扩展的接口，它可以用来启用框架扩展和替换组件。SPI 的作用就是为这些被扩展的 API 寻找服务实现。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。可以在运行时，动态为接口替换实现类。可以很容易的通过 SPI 机制为程序提供拓展功能。

  • AbstractAutowireCapableBeanFactory：抽象 beanFactory 的超类，它使用指定的 RootBeanDefinition 类的所有方法实现创建默认 bean。

  • AbstractBeanDefinition：具体、成熟 BeanDefinition 类的基类，构造出 RootBeanDefinition 和 ChildBeanDefinition 的通用属性。

  • RootBeanDefinition：根 BeanDefinition，表示在运行时期的 spring BeanFactory 中一个合并的 BeanDefinition。

  • ChildBeanDefinition：从父类继承各种设置的 bean 的 beanDefinition。

  • GenericBeanDefinition：通用 BeanDefinition 是一站式的标准 bean Definition。

  • BeanDefinitionReader：bean definition 解析器的简单接口。

  • BeanDefinitionReaderUtils：BeanDefinitionReader 实现使用的工具方法类。

  • AbstractBeanDefinitionReader：实现了 BeanDefinitionReader 接口，是 beanDefinitionReader 的抽象基类。

  • PropertiesBeanDefinitionReader：简单属性格式的 BeanDefinitionReader。

  • BeanDefinitionDefaults：简单保持 BeanDefinition 的默认属性类。

  • BeanDefinitionBuilder：使用建造者模式构建 BeanDefinition 的编程方法。

  • BeanDefinitionRegistry：持有 beanDefinition 的注册接口，例如 RootBeanDefinition 和 ChildBeanDefinition 实例。

  • SimpleBeanDefinitionRegistry：BeanDefinitionRegistry接口的简单实现。

  • BeanDefinitionRegistryPostProcessor：标准BeanFactoryPostProcessor SPI的扩展接口，允许在常规BeanFactoryPostProcessor检查之前注册更多bean definition。

  • BeanDefinitionResource：继承自AbstractResource，描述BeanDefinition的资源。在此介绍一下Spring使用的一种设计模式：装饰器模式。装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构。装饰者可以在所委托被装饰者的行为之前或之后加上自己的行为，以达到特定的目的(如：功能的增强)。

  • BeanDefinitionValueResolver：主要用在bean工厂实施中，解析bean definition对象中的value，根据目标bean实例转换成真正的值。

  • BeanDefinitionValidationException：验证一个bean definition时出错抛出的异常。

  • BeanDefinitionOverrideException：BeanDefinitionStoreException一个子类，显示一个在尝试一个非法的重载。比如为同一个bean name注册一个新的definition，但是DefaultListableBeanFactory的isAllowBeanDefinitionOverriding却为false的时候。

  • ManagedArray：集合类，用来保存它所管理的array元素，它可以包含运行时期的bean引用(将被解析为bean对象)。

  • ManagedList：集合类，用来保存它所管理的List元素，它可以包含运行时期的bean引用(将被解析为bean对象)。

  • ManagedMap：集合类，用来保存它所管理的array值，它可以包含运行时期的bean引用(将被解析为bean对象) 。

  • ManagedSet：集合类，用来保存它所管理的set值，它可以包含运行时期的bean引用(将被解析为bean对象) 。

  • ManagedProperties：表示一个spring管理的属性实例，它支持父/子 definition的合并。

  • AutowireCandidateQualifier：解析自动绑定备选项Qualifier。

  • AutowireCandidateResolver：策略接口，对特定的依赖，这个接口决定一个特定的bean definition是否满足作为自动绑定的备选项。

  • SimpleAutowireCandidateResolver：继承自AutowireCandidateResolver，当出现不支持的注解时使用。

  • GenericTypeAwareAutowireCandidateResolver：继承自SimpleAutowireCandidateResolver，一个通用的AutowireCandidateResolver

  • AutowireUtils：工具类，为具有自动装载能力的bean工厂提供一些有用的方法。

  • LookupOverride：表示可以重写一个在同一个IOC上下文中查找对象的方法。

  • MethodOverride：表示重写对象，它针对IOC容器所管理对象的方法的重写。

  • MethodOverrides：一组方法重写，决定了在运行时期对spring IOC容器管理对象的重写方法(如果存在的话)。

  • ReplaceOverride：MethodOverride的扩展，表示一个IOC容器方法的任意重写。

  • InstantiationStrategy：负责根据相应的根bean definition创建实例的接口。

  • SimpleInstantiationStrategy：BeanFactory中简单对象的初始化策略。

  • CglibSubclassingInstantiationStrategy：BeanFactory默认对象初始化策略。

  • BeanNameGenerator：对beanDefinition产生bean名称的策略接口。

  • DefaultBeanNameGenerator：BeanNameGenerator接口的默认实现，代理BeanDefinitionReaderUtils.generateBeanName(BeanDefinition, BeanDefinitionRegistry)方法。

  • SecurityContextProvider：运行在beanFactory中的安全Context的提供者。

  • SimpleSecurityContextProvider：SecurityContextProvider的简单扩展。

  • DefaultSingletonBeanRegistry：共享bean实例的通用注册，实现了SingletonBeanRegistry。

  • FactoryBeanRegistrySupport：一个支持单例注册(需要处理FactoryBean实例)的基类，集合了DefaultSingletonBeanRegistry对单例的管理功能。

  • ConstructorResolver：解析构造函数和工程方法的代理。对构造函数的解析主要通过参数匹配来实现。

  • DisposableBeanAdapter：对一个给定的bean实例进行销毁bean及进行销毁的相关工作的适配器。

  • MethodReplacer：一个可以重新定义IOC容器对象的所有方法的接口：方法注入是依赖注入的一种形式。

  • MergedBeanDefinitionPostProcessor：后处理回调接口，在运行时合并bean definition。

  • NullBean：一个空 bean 的内部表示，比如调用 FactoryBean 的 getObect() 或者其他的工厂方法返回的是 null 值。

  • ImplicitlyAppearedSingletonException：继承自 IllegalStateException，一个内部使用的异常类，在 ConstructorResolver 引发，传递给初始化DefaultSingletonBeanRegistry。

• wiring：一种决定一个 bean 实例的元数据的机制。

  • BeanConfigurerSupport：配置bean的便利基类，它可以对对象进行依赖注入。典型应用就是作为切面的子类使用。
  • BeanWiringInfo：保存特定类的bean的绑定元数据信息。在对注解和切面进行连接时使用。
  • BeanWiringInfoResolver：策略接口，能够根据给定的一个新初始化的bean对象解析bean的名称信息。在此简单介绍下策略模式：用意是针对一组算法，将每一个算法封装到具有共同接口的独立类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。通俗的讲就是遇到一种问题有多种解法的时候，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。
  • ClassNameBeanWiringInfoResolver：BeanWiringInfoResolver 的简单默认实现，查找一个和全限定名同名的bean的名称。

• xml：包含了一个基于 xml 的 beanFactory 实现，也包含一个标准的 spring-beans 的 dtd。

  • AbstractBeanDefinitionParser：BeanDefinitionParser的抽象实现，提供了许多便利方法和模板方法，模板方法需要在子类进行重写来提供具体的逻辑实现。

  • AbstractSimpleBeanDefinitionParser：AbstractBeanDefinitionParser 的简单实现，当将要解析元素的属性名和配置类的属性名一一对应的时候，可以用到该类。

  • AbstractSingleBeanDefinitionParser：BeanDefinitionParser 的基类，需要解析和定义单独的BeanDefinition。

  • BeanDefinitionDecorator：DefaultBeanDefinitionDocumentReader 用来处理自定义的，内嵌的标签的接口 。

  • BeanDefinitionDocumentReader：解析包含 spring BeanDefinition 的 xml 文件的 SPI。

  • DefaultBeanDefinitionDocumentReader：BeanDefinitionDocumentReader 接口的默认实现。

  • BeanDefinitionParser：DefaultBeanDefinitionDocumentReader 用来处理自定义的，高层的标签的接口 。

  • BeanDefinitionParserDelegate：状态代理类，用来解析xml BeanDefinition。

  • BeansDtdResolver：spring bean dtd解析器 EntityResolver 的实现，用来从 classpath 或者 jar 文件加载dtd。

    DTD(Documnet Type Definition)即文档类型定义，是一种 XML 约束模式语言，是XML文件的验证机制，属于XML文件组成的一部分。DTD 是一种保证XML文档格式正确的有效方法，可以通过比较XML文档和DTD文件来看文档是否符合规范，元素和标签使用是否正确。

    XSD(XML Schemas Definition)XML Schema语言也就是XSD。XML Schema描述了XML文档的结构。可以用一个指定的XML Schema来验证某个XML文档，以检查该XML文档是否符合其要求。文档设计者可以通过XML Schema指定一个XML文档所允许的结构和内容，并可据此检查一个XML文档是否是有效的。XML Schema本身是一个XML文档，它符合XML语法结构。可以用通用的XML解析器解析它。

    XSD和DTD相比：DTD是使用非XML语法编写的，不可扩展，不支持命名空间，只提供非常有限的数据类型。XSD可跟据将来的条件可扩展，比DTD丰富和有用，用XML书写，支持数据类型，支持命名空间。

  • DefaultNamespaceHandlerResolver：NamespaceHandlerResolver接口的默认实现。

  • DelegatingEntityResolver：EntityResolver的实现，分别代理了dtd的BeansDtdResolver和xml schemas的 PluggableSchemaResolver

  • NamespaceHandlerResolver：DefaultBeanDefinitionDocumentReader用来定位NamespaceHandler的接口。

  • PluggableSchemaResolver：继承自EntityResolver，使用一系列map文件将 schema url 解析到本地 classpath 资源。

  • ResourceEntityResolver：继承自EntityResolver，通过 ResourceLoader 来解析实体的引用。

  • XmlBeanDefinitionReader：Bean definition reader for XML bean definitions。

  • XmlBeanDefinitionStoreException：继承自BeanDefinitionStoreException。

  • XmlBeanFactory：过期，从spring 3.2 后推荐使用DefaultListableBeanFactory和XmlBeanDefinitionReader来代替它。

  • XmlReaderContext：ReaderContext的扩展，一般和XmlBeanDefinitionReader一起使用。

  • NamespaceHandler：实现了特定的URI命名空间。

  • NamespaceHandlerSupport：支持实现自定义的NamespaceHandler。

  • SimpleConstructorNamespaceHandler：单NamespaceHandler实现，它将自定义属性直接映射到bean属性。

  • SimplePropertyNamespaceHandler：简单NamespaceHandler实现，它将自定义属性直接映射到bean属性。

  • UtilNamespaceHandler：工具命名空间的NamespaceHandler。

  • DocumentDefaultsDefinition：简单的javaBean，它保存标准的spring xml文件中级别的属性，如：default-lazy-init，default-autowire等等。

  • DocumentLoader：加载xml文件的策略接口。

  • DefaultDocumentLoader：spring 的DocumentLoader默认实现。

  • ParserContext：传递一个beanDefinition 解析进程到此上下文，封装了所有的相关配置也包括状态。

• propertyeditors：属性编辑器，用来将 string 类型的值转换成 object 类型的。他们都继承自 PropertyEditorSupport，这个类可以用于自定义的类型转换，继承后重写了public void setAsText()，public String getAsText() 两个方法。注意 PropertyEditor 和 PropertyEditorSupport 都是java自己定义的，不是 Spring 的。包含了诸多 *Editor 类。

• support：org.springframework.beans 的支持包，如一组 bean 的排序和保持工具类等。

  • ArgumentConvertingMethodInvoker：MethodInvoker 的子类，通过 TypeConverter 将真实目标方法的指定参数进行转换。
  • MutableSortDefinition：SortDefinition 接口的可变实现。支持在对同一个属性值进行设置的时候可以利用升序排列的值进行切换。
  • PagedListHolder：一个简单的状态保持，它处理一组对象，将它们分页。分页的起始页从0开始。主要用在 web 网站的用户界面上。
  • PropertyComparator：对两个 bean 进行比较，通过 BeanWrapper 来比较指定 bean 的属性。
  • ResourceEditorRegistrar：继承了 PropertyEditorRegistrar，使用资源编辑器来填充指定的 PropertyEditorRegistry。
  • SortDefinition：根据一个指定的属性对一组 bean 实例进行排序的定义类。isAscending 为 True 时进行升序排列，为 False 进行降序排列。

注释：FactoryBean 和 BeanFactory 的区别：

• FactoryBean：Spring 中有两种类型的Bean，一种是普通Bean，另一种是工厂Bean 即 FactoryBean。FactoryBean跟普通Bean不同，其返回的对象不是指定类的一个实例，而是该FactoryBean的getObject方法所返回的对象。创建出来的对象是否属于单例由isSingleton中的返回决定。Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂Bean的细节，给上层应用带来了便利。FactoryBean 通常是用来创建比较复杂的bean，一般的bean 直接用xml配置即可，但如果一个bean的创建过程中涉及到很多其他的bean 和复杂的逻辑，用xml配置比较困难，这时可以考虑用FactoryBean。
• BeanFactory：以Factory结尾，表示它是一个工厂类(接口)， 是负责生产和管理bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等。