Fork me on GitHub

Spring名词

字数统计: 12.5k字   |   阅读时长≈ 49分

BeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
BeanFactory
      /*
    这是去访问spring bean 容器的一个根接口，也是bean 容器的 一个 基本客户端 视图（view），子接口 例如ListableBeanFactory和ConfigurableBeanFactory都是 为了一些具体的目标而提供的可用接口，用在特定的场景
     这个接口的实现 必须通过有 多个bean definition 的对象才能实现，每一个bean definition唯一的标识就是一个String类型的name属性， 这个 BeanFactory将要么返回一个包含对象的独立实例（prototype类型），或者返回单个共享的实例（singleton类型） 取决于 bean definition对bean的定义，返回哪种对象类型的实例取决于bean工厂配置（spring.xml的配置）：API都是一样的。     spring2.0以后，提供了一些其他的作用域，本来的作用域是两种（singleton，prototype），新提供的例如（request，session这两个是web 环境才能使用的 ），新提供的作用域能不能使用 取决于 一个具体的spring 应用上下文是否支持
     
     【【BeanFactory这种方式的要点在于BeanFactory是一个应用程序组件（bean）的注册中心，也可以对应用程序组件（bean）集中配置（一起配置。例如，单个对象不再需要读取属性文件）】】
     
     使用DI（Dependency Injection）通过setter或者constructor的方式去配置应用程序对象所依赖的属性
比其他的方式都要好，Spring的依赖注入（DI）功能是使用这个BeanFactory接口及其子接口实现的
     
     通常一个BeanFactory将会通过在一个配置源（例如xml文档里面）加载bean definition进行存储，并且使用{@code org.springframework.beans}这个包下的类来对bean进行配置，其实一个简单的实现就是在java代码中直接创建。但是这里没有约束 bean definition的存储方式：LDAP，RDBMS，XML，properties文件都可以，并且实现支持bean之间的引用（依赖注入）。
     
   
    
     {@link HierarchicalBeanFactory}与{@link ListableBeanFactory}中的方法相反，如果这是{@link HierarchicalBeanFactory}，则此接口中的所有操作也将检查父工厂。如果在HierarchicalBeanFactory工厂实例中找不到bean，则会询问直接（通过parent获取父工厂实例）父工厂。同时这个HierarchicalBeanFactory工厂实例中的bean应该重写任何父工厂中同名的bean。
     
     Bean工厂实现应该支持标准的Bean生命周期接口
     Bean工厂整套初始化方法及其标准顺序为：
 * <ol>
 * <li>BeanNameAware's {@code setBeanName}
 * <li>BeanClassLoaderAware's {@code setBeanClassLoader}
 * <li>BeanFactoryAware's {@code setBeanFactory}
 * <li>EnvironmentAware's {@code setEnvironment}
 * <li>EmbeddedValueResolverAware's {@code setEmbeddedValueResolver}
 * <li>ResourceLoaderAware's {@code setResourceLoader}
 * (only applicable when running in an application context)
 * <li>ApplicationEventPublisherAware's {@code setApplicationEventPublisher}
 * (only applicable when running in an application context)
 * <li>MessageSourceAware's {@code setMessageSource}
 * (only applicable when running in an application context)
 * <li>ApplicationContextAware's {@code setApplicationContext}
 * (only applicable when running in an application context)
 * <li>ServletContextAware's {@code setServletContext}
 * (only applicable when running in a web application context)
 * <li>{@code postProcessBeforeInitialization} methods of BeanPostProcessors
 * <li>InitializingBean's {@code afterPropertiesSet}
 * <li>a custom init-method definition
 * <li>{@code postProcessAfterInitialization} methods of BeanPostProcessors
 * </ol>
 
关闭bean工厂时，将应用以下生命周期方法： 
 * <ol>
 * <li>{@code postProcessBeforeDestruction} methods of DestructionAwareBeanPostProcessors
 * <li>DisposableBean's {@code destroy}
 * <li>a custom destroy-method definition
 * </ol>
 
      */
    String FACTORY_BEAN_PREFIX = "&"; Factorybean的一个前缀
    一系列getBean方法  用于获取bean对象  （我们配置需要创建的java对象）
    一系列getBeanProvider方法，获取到一个BeanProvider对象    @since 5.1才出
    还有就是 判断bean 存不存在，是否单例，是否原型（需要才创建，每次都是新对象），判断类型，获取别名等等，对bean做的一系列方法供 使用者调用

ObjectProvider

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
ObjectFactory
/*
这个工厂  在调用时可以返回对象实例（可能是共享(singleton)的或独立(prototype)的）。

此接口通常用于封装一个通用工厂，该工厂在每次调用时返回某个目标对象的新实例（原型）。

这个接口类似于FactoryBean，但FactoryBean的实现通常被定义为{@link BeanFactory}中的SPI实例，这个ObjectFactory类的实现通常作为一个API提供给其他bean（通过注入）。因此，{@code getObject（）}方法具有不同的异常处理行为。
  api:	T getObject() throws BeansException;
*/

    
    
    

ObjectProvider 继承 ObjectFactory 和 Iterable
    /*
    说明该接口具备一个可以进行迭代能力
    {@link objectfactory}的一个变体，是专门为注入点设计，允许编程的可选性和扩展而非唯一的处理。
    从5.1开始，这个接口扩展了{@link iterable}，并提供了{@link stream}支持。因此，它可以用于{@code for}循环，提供{@link#forEach}迭代，并允许集合样式{@link stream（1.8的一大新特性）}方式访问。
    

    
    */

FactoryBean

1
2
3
4
5
FactoryBean
    /*
    由{@link BeanFactory}中使用的对象实现的接口，这些对象本身就是单个对象的工厂。如果一个bean实现了这个接口，它将被用作一个要公开的对象的工厂，而不是直接作为一个将要公开的bean实例。 (意思就是这个FactoryBean对象本身没啥用，只有这个FactoryBean对象提供的bean对象才有用)
    
    */

HierarchicalBeanFactory

1
2
3
4
5
6
7
8
9
HierarchicalBeanFactory  继承 beanFactory
/*
子接口实现通过bean工厂，可以是层次结构的一部分。
相应setParentBeanFactory的bean工厂是允许设置父在一个可配置的方式方法可以在ConfigurableBeanFactory中找到
*/
BeanFactory getParentBeanFactory();

//获取当前bean工厂存在的bean，父级以上包含父级的bean忽略不检查
	boolean containsLocalBean(String name);

ListableBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
ListableBeanFactory 直接继承 beanfactory
/*
源码文档很明确，就是对beanfactory的扩展
enumerate all their bean instances
具有列出所有在此bean工厂的bean实例
{@linkbeanfactory}接口的扩展将由bean工厂实现，这些bean工厂可以枚举它们的所有bean实例，而不是按照客户机的请求逐个尝试按名称查找bean。

预加载所有bean定义的BeanFactory实现（例如基于XML的工厂）可以实现这个接口。也只有这样的接口才能实现他的功能

如果这是{@link HierarchicalBeanFactory}，则返回值将不考虑任何BeanFactory层次结构，而只与当前工厂中定义的bean相关。也可以使用{@link BeanFactoryUtils}工具类来考虑祖先工厂中的bean。


这个接口中的方法只会尊重这个工厂的bean定义。他将忽略任何 通过其他方法例如 ConfigurableBeanFactory的registerSingleton方法这种形式注册的bean，（就是说直接通过registerSingleton这个方法进行注册也可以把一个bean放入bean工厂，但是这个bean可能在bean所有的definition里面，也可以不在，也就是说这个bean的实例整个初始化到实例化到依赖注入的过程，工厂不知道）

{@code getBeanNamesOfType}和{@code getBeansOfType}将检查这些手动注册的单例。
当然，BeanFactory的{@code  getbean}也允许对这种特殊bean的透明访问。

然而，在典型的场景中，所有bean都将由外部bean定义来定义，因此大多数应用程序不需要担心这种区别。

就是一般不要通过 想调用registerSingleton方法去注册bean，也可以，但是不符合规范

注意：除了{@code getBeanDefinitionCount}和{@code containsBeanDefinition}，此接口中的方法不是为频繁调用而设计的。实施可能很慢。
*/

BeanFactoryUtils

1
2
3
4
5
/*
对bean工厂提供方便的操作方法，特别是在ListableBeanFactory接口。
返回bean数、bean名称或bean实例，同时考虑bean工厂的嵌套层次结构（与BeanFactory接口上定义的方法不同，ListableBeanFactory接口上定义的方法没有）。

*/

ConfigurableBeanFactory

1
2
3
4
5
6
7
8
9
10

继承 HierarchicalBeanFactory, SingletonBeanRegistry

/*

配置接口将由大多数bean工厂实现。除了BeanFactory接口中的BeanFactory客户端方法之外，还提供了配置BeanFactory的工具。

这个BeanFactory接口并不打算在普通的应用程序代码中使用：对于典型的需求，请坚持使用BeanFactory或ListableBeanFactory。这个扩展接口只允许框架内部即插即用和对bean工厂配置方法的特殊访问。

*/

AutowireCapableBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
AutowireCapableBeanFactory
/*
BeanFactory接口的扩展，该接口将由能够自动注入的bean工厂实现，前提是它们希望为现有的bean实例公开此功能。

BeanFactory的这个子接口并不打算在普通的应用程序代码中使用：对于典型的用例，请坚持使用BeanFactory或ListableBeanFactory。

其他框架的集成代码可以利用这个接口来连接和填充Spring不控制其生命周期的现有bean实例。例如，这对于WebWork操作和Tapestry页面对象特别有用。

请注意，此接口不是由ApplicationContext facades实现的，因为它几乎从未被应用程序代码使用过。也就是说，它也可以从应用程序上下文中获得，可以通过ApplicationContext的getAutowireCapableBeanFactory（）方法访问。

您还可以实现BeanFactoryAware接口，该接口即使在ApplicationContext中运行时也会公开内部BeanFactory，以访问AutowireCapableBeanFactory：只需将传入的BeanFactory强制转换为AutowireCapableBeanFactory。
*/

注：

对于bean工厂， 除了提供获取此工厂的bean的方法之外，某些还需要获取所有的bean数量，bean信息，bean的id名等，，有些场景工厂需要继承，还有对工厂的bean通过注解进行自动注入，自己能够配置自己，所以有了下面的ListableBeanFactory，HierarchicalBeanFactory，AutowireCapableBeanFactory，ConfigurableBeanFactory这些子接口（单一职责，开闭原则，里氏替换原则）

AbstractBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
继承 FactoryBeanRegistrySupport ConfigurableBeanFactory
/*
BeanFactory实现的抽象基类，提供可配置BeanFactory SPI的全部功能。<i>不</i>是否假定一个可列出的bean factory:因此也可以用作从某些后端资源（bean定义访问是一个昂贵的操作）获取bean定义的bean工厂实现的基类。

此类提供了一个单例缓存（通过其基类DefaultSingletonBeanRegistry、singleton/prototype确定、FactoryBean处理、别名、子bean定义合并和bean销毁（DisposableBean接口、自定义销毁方法）。此外，它还可以通过实现HierarchicalBeanFactory接口来管理bean工厂层次结构（在未知bean的情况下委托给父级）。

子类实现的主要模板方法是{@link#getBeanDefinition}和{@link#createBean}，分别检索给定bean名称的bean定义和为给定的bean定义创建一个bean实例。这些操作的默认实现可以在{@link DefaultListableBeanFactory}和{@link AbstractAutowireCapableBeanFactory}中找到。




*/

AbstractAutowireCapableBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
继承 AbstractBeanFactory  AutowireCapableBeanFactory

/*

实现默认bean创建的抽象bean工厂超类，具有{@link RootBeanDefinition}类指定的全部功能。{autocapableBean除了实现@wireLink之外，还实现了beanfactory的@wireLink方法。

提供bean创建（使用构造函数解析）、属性填充、连接（包括自动连接）和初始化。处理运行时bean引用、解析托管集合、调用初始化方法等。支持自动连接构造函数、按名称的属性和按类型的属性。

子类实现的主模板方法是{@link#resolveDependency（DependencyDescriptor，String，Set，TypeConverter）}，用于按类型自动连接。对于能够搜索其bean定义的工厂，匹配的bean通常通过这样的搜索来实现。对于其他工厂样式，可以实现简化的匹配算法。


请注意，这个类不承担或实现bean定义注册中心功能。请参见{@link DefaultListableBeanFactory}获取ListableBeanFactory和{@link BeanDefinitionRegistry}接口的实现，它们分别表示这样一个工厂的API和SPI视图


*/

DefaultListableBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
继承 AbstractAutowireCapableBeanFactory  ConfigurableListableBeanFactory BeanDefinitionRegistry
/*
Spring的{@link ConfigurableListableBeanFactory}和{@link BeanDefinitionRegistry}接口的默认实现：一个完整的基于bean定义元数据的bean工厂，可通过后处理器进行扩展。

典型的用法是在访问bean之前先注册所有bean定义（可能从bean定义文件中读取）。因此，在本地Bean定义表中，按名称查找Bean是一种廉价的操作，它对预先解析的Bean定义元数据对象进行操作。

请注意，特定bean定义格式的读取器通常是单独实现的，而不是作为bean工厂子类实现的：请参见示例{@link PropertiesBeanDefinitionReader}和XmlBeanDefinitionReader。

对于ListableBeanFactory接口的另一种实现，请查看StaticListableBeanFactory，它管理现有的bean实例，而不是基于bean定义创建新的实例。
*/

    
    
    
/** 从序列化id映射到工厂实例。 */
	private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
			new ConcurrentHashMap<>(8);

	/** 此工厂的可选id，用于序列化目的。 */
	@Nullable
	private String serializationId;

	/** 是否允许重新注册具有相同名称的不同定义。 */
	private boolean allowBeanDefinitionOverriding = true;

	/** 是否允许立即类加载，即使是对于lazy init bean也是如此 */
	private boolean allowEagerClassLoading = true;

	/** 依赖项列表和数组的可选OrderComparator。*/
	@Nullable
	private Comparator<Object> dependencyComparator;

	/** 用于检查bean定义是否为自动连线候选项的解析器。 */
	private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();

	/** 从依赖项类型映射到相应的自动装配值。 */
	private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

	/** 单例和非单例bean名称的映射，按依赖类型键控。 */
	private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

	/** 单例bean名称的映射，由依赖类型键控。 */
	private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

	/**按注册顺序列出bean定义名称。 */
	private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

	/** 按注册顺序列出手动注册单例的名称。 */
	private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

	/** 缓存的bean定义名称数组，以防配置冻结。 */
	@Nullable
	private volatile String[] frozenBeanDefinitionNames;

	/** 是否可以为所有bean缓存bean定义元数据。*/
	private volatile boolean configurationFrozen = false;

SingletonBeanRegistry

1
2
3
4
5
6

/*
为共享bean实例定义注册表的接口。可以通过BeanFactory实现来以统一的方式公开其singleton管理工具。


*/

AliasRegistry

1
2
3
/*
用于管理别名的公共接口。用作BeanDefinitionRegistry的超级接口。
*/

SimpleAliasRegistry

1
2
3
4
继承 AliasRegistry
/*
{@linkaliasregistry}接口的简单实现。<p>用作BeanDefinitionRegistry实现的基类。
*/

DefaultSingletonBeanRegistry

1
2
3
4
5
6
7
8
9
10
11
12
13
继承 SimpleAliasRegistry SingletonBeanRegistry

/*
共享bean实例的通用注册表，实现SingletonBeanRegistry。允许注册应该为注册表的所有调用方共享的单例实例，这些实例将通过bean名称获得。

还支持DisposableBean实例的注册（可能对应于注册的单例实例，也可能不对应于已注册的单例实例），在关闭注册表时销毁。可以注册bean之间的依赖关系以强制执行适当的关闭顺序。

这个类主要作为BeanFactory实现的基类，将单例bean实例的公共管理分解开来。请注意，ConfigurableBeanFactory接口扩展了{@link SingletonBeanRegistry}接口。

注意，这个类既不假设bean定义概念，也不假设bean实例的特定创建过程，与{@link AbstractBeanFactory}和{@link DefaultListableBeanFactory}（它们继承自它）相反。也可以用作要委托给的嵌套助手。


*/

FactoryBeanRegistrySupport

1
2
3
4
5
6
继承 DefaultSingletonBeanRegistry
/*
支持需要处理FactoryBean实例的singleton注册表的基类，与{@link DefaultSingletonBeanRegistry}的singleton管理集成。

用作{@link AbstractBeanFactory}的基类。
*/

BeanDefinitionRegistry

1
2
3
4
5
6
7
8
9
继承 AliasRegistry
/*
接口，用于保存bean定义的注册表，例如RootBeanDefinition和ChildBeanDefinition实例。通常由内部使用AbstractBeanDefinition层次结构的BeanFactory实现。


这是Spring的bean工厂包中唯一封装bean定义的<i>注册</i>的接口。标准BeanFactory接口仅覆盖对完全配置的工厂实例的访问。

Spring的bean定义的读者希望能够处理这个接口的实现。Spring核心中已知的实现者是DefaultListableBeanFactory和GenericApplicationContext。
*/

注：

spring 把 工厂和 bean注册中心分离开，工厂就是提供bean的视图，而bean注册中心就是 在一个bean生成之后需要存储的地方，两者都是相辅相成的： （接口隔离原则）

EnvironmentCapable

1
2
3
4
5
6
7
8
9
10
/*
接口，该接口指示包含并公开{@link Environment}引用。
一个组件

所有Spring应用程序上下文都支持环境，接口主要用于在接受BeanFactory实例的框架方法中执行{@code instanceof}检查，为了方便跟环境进行交互，但这个BeanFactory实例可能是上下文对象也可能不是

如前所述ApplicationContext继承EnvironmentCapable，并暴露了一个getEnvironment（）的方法，然后ConfigurableApplicationContext重新定义了getEnvironment()方法并缩小签名以返回{@link ConfigurableEnvironment}。

其结果是，在从ConfigurableApplicationContext访问环境对象之前，它是“只读”的，访问的时候可以对其进行配置。
*/

MessageSource

1
2
3
4
5
6
7
/*

用于解析消息的策略接口，支持此类消息的参数化和国际化。
Spring为生产提供了两种现成的实现：
	ResourceBundleMessageSource	:构建在标准ResourceBundle(java.util的)之上，共享其局限性。
	ReloadableResourceBundleMessageSource：高度可配置，尤其是在重新加载消息定义方面。		
*/

ResourceLoader

1
2
3
4
5
6
7
8
9
ResourceLoader
/*
加载资源的策略接口（e。。类路径或文件系统资源）。

{@link DefaultResourceLoader}是一个独立的实现，可在ApplicationContext外部使用，也可由{@link resourceditor}使用。

在ApplicationContext中运行时，可以使用特定上下文的资源加载策略从字符串填充类型 Resource和Resource array的Bean属性。
*/
提高获取一个资源的方法

ResourcePatternResolver

1
2
3
4
5
6
7
8
9
10
11
12
13
ResourcePatternResolver
/*
 用于将位置模式（例如，Ant样式的路径模式）解析为资源对象的策略接口。
这是ResourceLoader接口的扩展。可以检查传入的ResourceLoader（例如，在上下文中运行时通过ResourceLoaderware传入的ApplicationContext）是否也实现了此扩展接口。

PathMatchingResourcePatternResolver是一个独立的实现，可在ApplicationContext外部使用，ResourceArrayPropertyEditor也可用于填充资源数组bean属性。

可用于任何类型的位置模式（例如“/WEB-INF/*-上下文.xml“）：输入模式必须与策略实现相匹配。此接口只指定转换方法，而不是指定特定的模式格式。

此接口还为类路径中的所有匹配资源建议一个新的资源前缀“classpath*：”。注意，在这种情况下，资源位置应该是没有占位符的路径（例如/beans.xml“）；JAR文件或类目录可以包含多个同名文件。
*/
    
    提高获取多个资源的方法

Lifecycle

1
2
3
4
5
6
7
8
9
10
11
12
13

/*
一个公共接口 定义了 方法start/stop对生命周期控制
典型的用例是控制异步处理。
注意：这个接口没有对自动启动支持，
请考虑 SmartLisfecyle，这个接口支持自启动

可以由组件（通常是在Spring上下文中定义的springbean）和容器（通常是Spring{@link applicationcontext}本身）来实现。容器将向每个容器中应用的所有组件传播 启动/停止 信号，例如，运行时的停止/重新启动场景。

可用于直接调用或管理操作通过JMX.In后一种情况下，MBeanExporter通常使用InterfaceBasedMBeanInfoAssembler进行定义，从而限制活动控制组件对生命周期接口的可见性。

请注意，目前的{@code Lifecycle}接口仅在<b>顶级单例bean上受支持</b>。在任何其他组件上，生命周期接口都不会被检测到，因此会被忽略。另外，请注意，扩展的{@link SmartLifecycle}接口提供了与应用程序上下文的启动和关闭阶段的复杂集成。
*/

AutoCloseable

1
2
3
4
5
6
7
8
9
10

/*


一个在关闭之前可以保存资源（如文件或套接字句柄）的对象。当退出{@code try}-with-resources块时，{@code AutoCloseable}对象的{@link\#close（）}方法将自动调用，该资源块已在资源规范头中声明了该对象。这种结构确保了及时发布，避免了资源耗尽异常和可能发生的错误。


基类实现AutoCloseable是可能的，事实上也是常见的，即使它的所有子类或实例都包含可发布的资源。对于必须完全通用地操作的代码，或者当已知{@code AutoCloseable}实例需要资源释放时，建议使用{@code try}-和资源构造。但是，当使用{@link之类的工具时java.util.stream.Stream}同时支持基于I/O和非I/O的表单，{@code try}-with resources块在使用非基于I/O的表单时通常是不必要的。

*/

Closeable

1
2
3
4
5
/*

{@code Closeable}是可以关闭的数据源或目标。close方法被调用来释放对象所保存的资源（例如打开的文件）。

*/

ApplicationContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ApplicationContext
    继承 EnvironmentCapable ListableBeanFactory HierarchicalBeanFactory MessageSource ApplicationEventPublisher ResourcePatternResolver
/*
为应用程序提供配置的中央接口。

 当应用程序运行时，这是只读的，但是如果实现支持这样做，则可以重新加载。
 ApplicationContext提供：
 	用于访问应用程序组件的Bean工厂方法。从ListableBeanFactory继承
 	加载文件资源的能力。继承ResourceLoader接口。
 	向注册的侦听器发布事件的能力。从ApplicationEventPublisher接口继承。
 	能够解析消息，支持国际化。从MessageSource接口继承。
 	从父上下文继承。后代上下文中的定义总是优先考虑的。这意味着，例如，单个父上下文可以被整个web应用程序使用，而每个servlet都有自己的子上下文，它独立于任何其他servlet的子上下文。（可以参考DispacherServlet）
 	除了标准的BeanFactory生命周期功能之外，ApplicationContext实现还检测并调用ApplicationContextAware bean以及ResourceLoaderware、ApplicationEventPublisherAware和MessageSourceAware bean。进行对bean生命周期的额外支持
*/

ConfigurableApplicationContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
继承 ApplicationContext Lifecycle Closeable

/*
SPI:服务自动发现
SPI接口将由大多数（如果不是所有）应用程序上下文实现。除了ApplicationContext接口中的应用程序上下文客户端方法外，还提供了配置应用程序上下文的工具。
	
		这里封装了配置和生命周期方法，以避免使它们对ApplicationContext客户端代码显而易见。目前的方法只能由启动和关闭代码使用。
*/
    //任何数量的这些字符都被视为单个字符串值中多个上下文配置路径之间的分隔符。
String CONFIG_LOCATION_DELIMITERS = ",; \t\n";

//工厂中ConversionService bean的名称。如果未提供任何内容，则适用默认转换规则。
String CONVERSION_SERVICE_BEAN_NAME = "conversionService";

//工厂中LoadTimeWeaver bean的名称。如果提供了这样的bean，上下文将使用临时类加载器进行类型匹配，以便LoadTimeWeaver处理所有实际的bean类。
String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";

//工厂中{@link Environment} bean的名称。
String ENVIRONMENT_BEAN_NAME = "environment";

//工厂中系统属性Bean的名称。
String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";

//工厂中系统环境bean的名称。
String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";

//{@linkplain registerShutdownHook（）关闭钩子}线程的{@link Thread#getName（）Name}线程：{@value}。
String SHUTDOWN_HOOK_THREAD_NAME = "SpringContextShutdownHook";

AbstractApplicationContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
继承 DefaultResourceLoader ConfigurableApplicationContext
/*
AbstractApplicationContext

ApplicationContext接口的抽象实现。不强制要求用于配置的存储类型；只是实现公共上下文功能。使用模板方法设计模式，需要具体的子类来实现抽象方法。

与普通的BeanFactory不同，ApplicationContext应该检测在其内部bean工厂中定义的特殊bean：因此，该类自动注册在上下文中定义为bean的BeanFactoryPostProcessor、BeanPostProcessor和ApplicationListeners。


消息源也可以作为上下文中的bean提供，名为“MessageSource”；否则，消息解析委托给父上下文。此外，应用程序事件的multicaster可以在上下文中作为applicationEventMulticaster类型的“applicationEventMulticaster”bean提供；否则，将使用SimpleApplicationEventMulticaster类型的默认multicaster。


通过扩展DefaultResourceLoader实现资源加载。因此，将非URL资源路径视为类路径资源（支持包含包路径的完整类路径资源名称，例如“mypackage/myresource.dat“），除非{@link#getResourceByPath}方法在子类中被重写。
*/
//工厂中MessageSource bean的名称。如果未提供任何消息，则将消息解析委托给父级。
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";

//工厂中LifecycleProcessor bean的名称。如果未提供，则使用DefaultLifecycleProcessor。
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";


//工厂中ApplicationEventMulticaster bean的名称。如果未提供，则使用默认的SimpleApplicationEventMulticaster。
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";

//BeanFactoryPostProcessors应用于refresh方法。
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();


/** Synchronization monitor for the "refresh" and "destroy". */
	private final Object startupShutdownMonitor = new Object();

/** Reference to the JVM shutdown hook, if registered. */
	@Nullable
	private Thread shutdownHook;

//刷新之前已注册本地侦听器。
private Set<ApplicationListener<?>> earlyApplicationListeners;

//在多播程序设置之前发布的ApplicationEvents。
private Set<ApplicationEvent> earlyApplicationEvents;

AbstractRefreshableApplicationContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
继承 AbstractApplicationContext BeanNameAware InitializingBean
/*
ApplicationContext实现的基类，该实现支持对{@link\#refresh（）}的多次调用，每次都创建一个新的内部bean工厂实例。通常（但不一定），这样的上下文将由一组配置位置驱动，以便从中加载bean定义。

子类实现的唯一方法是{@link#loadBeanDefinitions}，它在每次刷新时被调用。一个具体的实现应该将bean定义加载到给定的DefaultListableBeanFactory中，通常委托给一个或多个特定的bean定义读取器。

请注意，WebApplicationContexts有一个类似的基类。</b>AbstractRefreshableWebApplicationContext提供了相同的子类化策略，但还预先实现了web环境的所有上下文功能。还有一种预定义的方法来接收web上下文的配置位置。


这个基类的具体独立子类以特定的bean定义格式读取，它们是{@link ClassPathXmlApplicationContext}和{@link FileSystemXmlApplicationContext}，它们都派生自公共的{@link AbstractXmlApplicationContext}基类；AnnotationConfigApplicationContext支持{@code@Configuration}-注释类作为bean定义的源。

*/

	@Nullable
	private Boolean allowBeanDefinitionOverriding;

	@Nullable
	private Boolean allowCircularReferences;

	/** Bean factory for this context. */
	@Nullable
	private DefaultListableBeanFactory beanFactory;

	/** Synchronization monitor for the internal BeanFactory. */
	private final Object beanFactoryMonitor = new Object();

AbstractXmlApplicationContext

1
2
3
4
5
6
7
8

继承 AbstractRefreshableConfigApplicationContext
    /*
    ApplicationContext实现的方便基类，从包含XmlBeanDefinitionReader理解的bean定义的XML文档中绘制配置。
    
    子类只需实现{@link#getConfigResources}和/或{@link#getConfigLocations}方法。此外，它们还可以重写{@link\#getResourceByPath}钩子以特定于环境的方式解释相对路径，并/或重写{@link}getResourcePatternResolver}以进行扩展模式解析。
    
    */

注：

spring的ApplicationContext ，既然是一个应用程序的上下文，那么这个上下文需要包含程序启动到结束所需要的内容，例如 一个ListableBeanFactory用于获取所有的bean， 可以获取环境，资源解析器，消息源，事件发布

上下文除了 拥有这些东西之外，还要对这些东西可配置，可刷新 （依赖倒置原则 ，里氏替换原则，接口隔离原则）

Aware

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

/*
一个标记超类接口，指示bean有资格通过回调样式的方法由Spring容器通知特定的框架对象。实际的方法签名由各个子接口确定，但通常只包含一个接受单个参数的void返回方法。

注意，仅仅实现{@link-Aware}没有提供默认功能。相反，必须显式地进行处理，例如在BeanPostProcessor中。有关处理特定{@code*Aware}接口回调的示例，请参阅applicationContextawreProcessor。


其实也就是一个bean在初始化之前，一定会调用 这个aware接口来获取applicationContext的内容

*/
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	private void invokeAwareInterfaces(Object bean) {
		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);
		}
	}

主要的意思就是 bean如果是一个aware接口的话，就会被拿出来调用 立马调用 它内部的方法，从而得到spring容器相关的 内容，这对第三方框架有用

BeanNameAware

1
2
3
4
5
6
7
8
9
10
11
12
继承 aware
/*
接口，该接口由希望知道bean工厂中bean名称的bean实现。注意，通常不建议对象依赖于它的bean名称，因为这表示对外部配置的潜在脆弱依赖，以及对springapi可能不必要的依赖。

有关所有bean生命周期方法的列表，请参阅{@link BeanFactory BeanFactory javadocs}。


*/
    //在创建这个bean的bean工厂中设置bean的名称。在填充普通bean属性后调用，但在初始化回调（如{@link initializengbean#afterPropertiesSet（）}）或自定义init方法之前调用。
    //请注意，此名称是工厂中使用的实际bean名称，它可能与最初指定的名称不同：特别是对于内部bean名称，实际的bean名称可能通过附加“#…”后缀而变得唯一。如果需要，可以使用{@linkbeanfactoryutils\originalbename（String）}方法提取原始bean名称（不带后缀）。
    
 	void setBeanName(String name);

InitializingBean

1
2
3
4
5
6
7
8
9
初始化之前处理完成后，调用
/*
接口将由bean实现，这些bean需要在{@link beanfactory}设置其所有属性后作出反应：例如，执行自定义初始化，或者仅仅检查是否设置了所有强制属性。

实现{@code InitializingBean}的另一种方法是指定一个自定义的init方法，例如在xmlbean定义中。有关所有bean生命周期方法的列表，请参阅{@link BeanFactory BeanFactory javadocs}。
*/
//由包含{@code BeanFactory}在设置了所有bean属性并满足{@link BeanFactoryAware}、{@code ApplicationContextAware}等之后调用。
//此方法允许bean实例在设置了所有bean属性后对其总体配置和最终初始化执行验证。
	 void afterPropertiesSet() throws Exception;

BeanDefinitionReader

1
2
3
4
5
6
7
8
9
10
11
12

/*
Bean定义信息读取的简单接口。
使用资源和字符串类型位置参数指定加载方法。

具体的Bean定义信息读取当然可以为bean定义添加额外的load和register方法，具体到bean定义格式。

请注意，Bean定义信息读取不必实现此接口。它只为希望遵循标准命名约定的Bean定义信息读取提供建议。



*/

AbstractBeanDefinitionReader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
实现{@link beandefinitionreader}接口的bean定义读取器的抽象基类。
提供公共属性，如要使用的bean工厂和用于加载bean类的类加载器。

*/

	private final BeanDefinitionRegistry registry;

	@Nullable
	private ResourceLoader resourceLoader;

	@Nullable
	private ClassLoader beanClassLoader;

	private Environment environment;

	private BeanNameGenerator beanNameGenerator = DefaultBeanNameGenerator.INSTANCE;

XmlBeanDefinitionReader

1
2
3
4
5
6
7
8

/*
用于XML Bean定义的Bean定义读取器。将实际的XML文档读取委托给{@link beandefinitiondocumentreader}接口的实现。

通常应用于DefaultListableBeanFactory或GenericApplicationContext。

此类加载DOM文档并将BeanDefinitionDocumentReader应用于该文档。文档阅读器将向给定的bean工厂注册每个bean定义，并与后者的BeanDefinitionRegistry接口的实现进行对话。
*/

PropertiesBeanDefinitionReader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
一个简单属性格式的Bean定义读取器。

为Map/Properties和ResourceBundle提供bean定义注册方法。通常应用于DefaultListableBeanFactory。

 * <pre class="code">
 * employee.(class)=MyClass       // bean is of class MyClass
 * employee.(abstract)=true       // this bean can't be instantiated directly
 * employee.group=Insurance       // real property
 * employee.usesDialUp=false      // real property (potentially overridden)
 *
 * salesrep.(parent)=employee     // derives from "employee" bean definition
 * salesrep.(lazy-init)=true      // lazily initialize this singleton bean
 * salesrep.manager(ref)=tony     // reference to another bean
 * salesrep.department=Sales      // real property
 *
 * techie.(parent)=employee       // derives from "employee" bean definition
 * techie.(scope)=prototype       // bean is a prototype (not a shared instance)
 * techie.manager(ref)=jeff       // reference to another bean
 * techie.department=Engineering  // real property
 * techie.usesDialUp=true         // real property (overriding parent value)
 *
 * ceo.$0(ref)=secretary          // inject 'secretary' bean as 0th constructor arg
 * ceo.$1=1000000                 // inject value '1000000' at 1st constructor arg
 * </pre>
 */

注：

对于bean定义信息的读取，有多种多样，可以时xml，可以是类，还可以是其他，但是一定会有一个获取 bean注册中心的对象的方法，因为最终读取的bean信息会放到 注册中心，也要有环境来支持 bean信息的读取

(开闭原则，单一职责原则，里氏替换原则)

BeanExpressionResolver

1
2
3
4
5
6
/*
策略接口，用于通过将值计算为表达式来解析该值（如果适用）。

原始BeanFactory不包含此策略的默认实现。但是，ApplicationContext实现将提供开箱即用的表达式支持。

*/

PropertyEditorRegistrar

1
2
3
4
5
6
7
8
9


/*
接口，用于在属性编辑器注册表中注册自定义属性编辑器的策略。

当您需要在几种不同的情况下使用同一组属性编辑器时，这尤其有用：编写相应的注册器，并在每种情况下重用它。

*/
	void registerCustomEditors(PropertyEditorRegistry registry);

PropertyEditorRegistry

1
2
3
4
5
/*
封装用于注册JavaBeans PropertyEditor的方法。这是PropertyEditorRegistrar操作的中心接口。

由BeanWrapper扩展；由BeanWrapperImpl和DataBinder实现。
*/

PropertyEditor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/*

PropertyEditor类为希望允许用户编辑给定类型的属性值的gui提供支持。

PropertyEditor支持多种不同的显示和更新属性值的方法。大多数propertyEditor只需要支持这个API中可用的不同选项的子集。

简单的propertyEditor可能只支持getAsText和setAsText方法，不需要支持（比如）paintValue或getCustomEditor。更复杂的类型可能无法支持getAsText和setAsText，而是支持paintValue和getCustomEditor。

每个propertyEditor必须支持三种简单显示样式中的一种或多种。因此，它可以（1）支持isPaintable，或者（2）从getTags（）返回一个非空字符串[]，并从getAsText返回一个非空值；或者（3）从getAsText（）返回一个非空字符串。

当argument对象的类型是与之对应的propertyEditor时，每个属性编辑器都必须支持对setValue的调用。此外，每个属性编辑器必须支持自定义编辑器或支持setAsText。

每个PropertyEditor都应该有一个null构造函数。
*/

BeanFactoryPostProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21


/*
Factory钩子，允许对应用程序上下文的bean定义进行自定义修改，从而调整上下文底层bean工厂的bean属性值。

对于针对系统管理员的自定义配置文件非常有用，系统管理员可以覆盖在应用程序上下文中配置的bean属性。请参阅{@link PropertyResourceConfigurer}及其具体实现，以获得满足此类配置需求的现成解决方案。


{@code beanfactorypostprocessor}可以与bean定义交互并修改bean定义，但决不能与bean实例交互。这样做可能会导致过早的bean实例化，违反容器并导致意外的副作用。如果需要bean实例交互，请考虑实现{@link beanpostprocessor}。


--注册--

{@code ApplicationContext}自动在其bean定义中检测{@code BeanFactoryPostProcessor}bean，并在创建任何其他bean之前应用它们。{@code BeanFactoryPostProcessor}也可以用{@code ConfigurableApplicationContext}以编程方式注册。

---Ordering---

{@code BeanFactoryPostProcessor}在{@code ApplicationContext}中自动检测到的bean将根据PriorityOrdered和ordered语义进行排序。相反，使用{@code-ConfigurableApplicationContext}编程注册的{@CodeBeanFactoryPostProcessor}bean将按注册顺序应用；对于以编程方式注册的后处理器，通过实现{@code PriorityOrdered}或{@code Ordered}接口表示的任何排序语义都将被忽略。而且，{@code beanfactorypostprocessor}bean没有考虑@Order注释。

不是通过bean定义信息来使用的BeanFactoryPostProcessor都不会进行排序
*/

BeanDefinitionRegistryPostProcessor

1
2
3
4
/*
对标准{@link beanfactorypostprocessor}SPI的扩展，允许在常规BeanFactoryPostProcessor检测开始之前注册更多的bean定义。特别是，BeanDefinitionRegistryPostProcessor可以注册更多的bean定义，这些定义反过来定义BeanFactoryPostProcessor实例。

*/

注

spring 在bean工厂上也做了很多文章，在注册后置处理器之前，回调所有的beanfactory的后置处理，可以对bean工厂进行修改，也会调用bean注册的后置处理进行 bean信息注入，无论怎样，这样的设计可以自定义的增强bean工厂，而不是完全由spring控制

（开闭原则）

BeanPostProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

/*

允许自定义修改新bean实例的Factory钩子，例如，检查标记接口或用代理包装bean。

通常，通过标记接口等填充bean的后处理程序将实现#postProcessBeforeInitialization，而使用代理包装bean的后处理器通常会实现#postProcessAfterInitialization。


Registration
{@code ApplicationContext}可以在其bean定义中自动检测{@code BeanPostProcessor}bean，并将这些后处理程序应用于随后创建的 任何业务bean。普通的{@code beanfactory}允许对后处理器进行编程注册，并将它们应用于通过bean工厂创建的所有bean。

Ordering
{@code BeanPostProcessor}在{@code ApplicationContext}中自动检测到的bean将根据PriorityOrdered和ordered语义进行排序。相反，以编程方式注册到{@code beanoptprocessor}bean将按注册顺序应用；通过实现{@code PriorityOrdered}或{@code Ordered}接口表达的任何排序语义对于以编程方式注册的后处理器都将被忽略。此外，{@code beanpostprocessor}bean没有考虑@Order注释。


*/

/**
在任何bean初始化回调（比如initializengbean的{@code afterPropertiesSet}或自定义的init方法）之前,将这个{@code beanptprocessor}应用于给定的新bean实例。这个bean已经被属性填充了价值观返回的bean实例可能是原始bean的包装器。 
	 * @param bean 新bean实例
	 * @param beanName the name of the bean
	 * @return 要使用的bean实例，无论是原始实例还是包装实例；如果{@code null}，则不会调用后续的beanPostProcessor
	 */
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	/**
	 * 在任何bean初始化回调（比如initializengbean的{@code afterPropertiesSet}或自定义init方法）之后，将这个{@codebeanpstprocessor}应用于给定的新bean实例。这个bean已经被属性值填充了。返回的bean实例可能是原始bean的包装器。

	  对于一个FactoryBean，这个回调将同时为FactoryBean实例和由FactoryBean创建的对象调用（从spring2.0开始）。后处理器可以通过相应的{@code beaninstanceoffactorybean}检查来决定是应用于FactoryBean还是已创建的对象，或者两者都应用。
	  
	  此回调也将在{@link instantiationwarebeanpostprocessor\postProcessBeforeInstantiation}方法触发短路后调用，与其他所有{@code BeanPostProcessor}回调不同。
	 @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet 
	 see org.springframework.beans.factory.FactoryBean
	 */
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

InstantiationAwareBeanPostProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
继承 BeanPostProcessor
/*
主要为了生成代理

{@link BeanPostProcessor}的子接口，它添加实例化前的回调和实例化后但在显式属性设置 或自动注入  DI之前的回调。

通常用于抑制特定目标bean的默认实例化，例如创建具有特殊TargetSources（池目标、延迟初始化目标等）的代理，或实现额外的注入策略，如字段注入。


注意：</b>此接口是一个特殊用途的接口，主要用于框架内部。建议尽可能实现普通的{@link BeanPostProcessor}接口，或者从{@link    instantiationwarebeanpostprocessoradapter}派生，以避免扩展到此接口。




*/
//实例化之前
    /*
    
    在目标bean实例化之前应用这个BeanPostProcessor<i>。返回的bean对象可以是一个代理来代替目标bean，从而有效地抑制了目标bean的默认实例化。
    如果此方法返回非空对象，则bean创建过程将被短路。应用的唯一进一步处理是来自配置的{@link beanpostprocessor beanoptprocessors}的{@link#postProcessAfterInitialization}回调。
    在这种情况下，它们的bean定义将与它们的bean类型一起在回调中应用。
    后处理程序可以实现扩展的{@link smartinstantiationwarebeanpostprocessor}接口，以便预测它们将在这里返回的bean对象的类型。

return:要公开的bean对象，而不是目标bean的默认实例，或者{@code null}来继续默认实例化
    */
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}

//实例化之后， di（属性设置和自动注入）之前

/*
在bean被实例化后，通过构造函数或工厂方法执行操作，但在Spring属性填充（来自显式属性或自动连接）之前执行。
这是在Spring的自动连接开始之前，对给定bean实例执行自定义字段注入的理想回调。

return:{@code true}如果应该在bean上设置属性；{@code false}如果应该跳过属性填充。正常的实现应该返回{@code true}。返回{@code false}还将阻止在这个bean实例上调用任何后续的instantiationAwarebeanpostprocessor实例。
*/
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		return true;
	}

/*
在工厂将给定的属性值应用到给定的bean之前对其进行后期处理，而不需要属性描述符。

如果实现提供自定义的{@link#postProcessPropertyValues}实现，则应返回{@code null}（默认值），否则返回{@code pvs}。在这个接口的未来版本中（删除了{@link# postProcessPropertyValues}），默认实现将直接返回给定的{@code pvs}。

pvs：工厂将要应用的属性值（never{@code null}）
bean:已创建bean实例，但尚未设置其属性
beanName:bean的id名
return：要应用于给定bean的实际属性值（可以是传入的PropertyValues实例）或{@code null}，该值继续使用现有属性，但具体地说是继续调用{@link\#postProcessPropertyValues}（需要为当前bean类初始化{@code PropertyDescriptor}s）

*/
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
			throws BeansException {

		return null;
	}


//将被废掉，与上面的方法意思差不多
/*
在工厂将给定的属性值应用于给定的bean之前，对其进行后期处理。允许检查是否满足所有依赖项，例如基于bean属性设置器上的“Required”注释。
 还允许替换要应用的属性值，通常通过基于原始propertyValue创建新的MutablePropertyValues实例，添加或删除特定值。
	默认实现按原样返回给定的{@codepvs}。

*/
default PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

		return pvs;
	}

SmartInstantiationAwareBeanPostProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
继承 InstantiationAwareBeanPostProcessor
/*

{@link instantiationwarebeanpostprocessor}接口的扩展，添加一个回调函数来预测已处理bean的最终类型。


注意：</b>此接口是一个特殊用途的接口，主要用于框架内部。一般来说，应用程序提供的后处理器应该简单地实现{@link BeanPostProcessor}接口，或者从{@link instantiationwarebeanpostprocessoradapter}类派生。新方法可能会被添加到这个接口中，即使在点发布中也是如此。



*/
    

 /*
 预测最终从这个处理器的{@link#postProcessBeforeInstantiation}回调返回的bean的类型。默认实现返回{@code null}。
 */   
default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}    

/*
确定要用于给定bean的候选构造函数。
*/
default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
			throws BeansException {

		return null;
	}


/*
获取对指定bean的早期访问的引用，通常是为了解析循环引用。


这个回调让后处理器有机会尽早公开包装器，也就是说，在目标bean实例完全初始化之前。暴露的对象应该与{@link\#postProcessBeforeInitialization}/{@link#postProcessAfterInitialization}将公开的对象等效。请注意，除非后处理器返回与所述后处理回调不同的包装器，否则此方法返回的对象将用作bean引用。换句话说：这些后处理回调可能最终公开相同的引用，也可能从随后的回调中返回原始bean实例（如果已为调用此方法而构建了受影响bean的包装器，则默认情况下它将作为最终bean引用公开）。

*/
default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		return bean;
	}

MergedBeanDefinitionPostProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


/*
在运行时合并了bean定义的后处理器回调接口。{@link beanpostprocessor}实现可以实现这个子接口，以便对Spring{@code beanfactory}用来创建bean实例的合并bean定义（原始bean定义的已处理副本）进行后处理。

这里也就是为什么 在合并bean定义信息好了之后需要复制一份用来 对bean后续的实例化和初始化处理

例如，{@link# postProcessMergedBeanDefinition}方法可以反省bean定义，以便在对bean的实际实例进行后处理之前准备一些缓存的元数据。它还允许修改bean定义，但是对于实际上用于并发修改的定义属性，它只允许修改。本质上，这只适用于在{@link rootbeandefinition}本身定义的操作，而不适用于其基类的属性。


*/
//对指定bean的给定合并bean定义进行后处理。
//beanDefinition：bean的合并bean定义
//beanType：托管bean实例的实际类型
	void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);


//通知已重置指定名称的bean定义，并且此后处理程序应清除受影响bean的任何元数据。
default void resetBeanDefinition(String beanName) {
	}

AutowiredAnnotationBeanPostProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
自动注入字段、setter方法和任意配置方法的BeanPostProcessor实现。要注入的这些成员是通过注释检测的：默认情况下，Spring的{@link Autowired@Autowired}和{@link Value@Value}注解。

还支持JSR-330的@Inject注释（如果可用），作为Spring自己的{@code@Autowired}的直接替代。

//--Autowired Constructors---
任何给定bean类中只有一个构造函数可以声明此注释，并将“required”属性设置为{@code true}，这表示当用作spring bean时，<i>构造函数将自动连接。此外，如果“required”属性设置为{@code true}，则只有一个构造函数可以用{@code@Autowired}进行注释。如果多个<i>非必需的</i>构造函数声明注释，则它们将被视为自动连接的候选对象。将选择通过在Spring容器中匹配bean来满足的依赖项数量最多的构造函数。如果没有一个候选的满足，那么将使用主/默认构造函数（如果存在）。如果一个类只声明一个构造函数，那么它将始终被使用，即使没有被注释。带注释的构造函数不必是公共的。

<h3>Autowired Fields</h3>
字段是在构建bean之后，在调用任何配置方法之前注入的。这样的配置字段不必是公共的。就是可以是private的

Autowired Methods
Config方法可以有任意名称和任意数量的参数；每个参数都将与Spring容器中的匹配bean自动连接。Bean属性设置器方法实际上只是这种通用配置方法的一个特例。配置方法不必是公共的。

Annotation Config vs. XML Config
默认的{@code AutowiredAnnotationBeanPostProcessor}将由"context:annotation-config" and "context:component-scan"XML标记。如果要指定自定义的{@code AutowiredAnnotationBeanPostProcessor}bean定义，请删除或关闭默认注释配置。

注意：</b>注释注入将在XML注入之前执行；因此，对于通过这两种方法连接的属性，后一种配置将覆盖前者。

Lookup Method
除了上面讨论的常规注入点之外，这个后处理器还处理Spring的{@linklookup @Lookup}注释，它标识在运行时由容器替换的查找方法。这本质上是{@code getbean（Class，args）}和{@code getbean（String，args）}的类型安全版本。有关详细信息，请参见{@linklookup@Lookup's javadoc}。



*/

注

spring的bean处理， 也不能由spring完全控制，因为spring根本不知道客户需要对bean进行这样的处理，所以抽出 后置处理器的接口，让用户来自定义实现对bean的增强

（开闭原则，单一职责原则，接口隔离）

BeanDefinition

1
2
3
4
5
6
7
8
9
10
11
12
13
14

继承AttributeAccessor BeanMetadataElement

AttributeAccessor：接口定义一个通用协定，用于附加和访问任意对象的元数据。

BeanMetadataElement：接口将由携带配置源对象的bean元数据元素实现。返回此元数据元素的配置源{@code Object}（可以是{@code null}）。
    
BeanDefinition
/*
BeanDefinition描述了一个bean实例，它具有属性值、构造函数参数值和具体实现提供的进一步信息。
这只是一个最小的接口：主要目的是允许{@link beanfactorypostprocessor}来检查和修改属性值和其他bean元数据。


*/

AbstractBeanDefinition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
继承 BeanDefinition BeanMetadataAttributeAccessor
    
    
BeanMetadataAttributeAccessor：
    继承 AttributeAccessorSupport BeanMetadataElement
    AttributeAccessorSupport的扩展，将属性保存为{@linkbeanMetadataAttribute}对象，以便跟踪定义源。

AttributeAccessorSupport：
    继承AttributeAccessor 
    {@link AttributeAccessor AttributeAccessors}的支持类，提供所有方法的基本实现。由子类扩展。
    
    
/*
具体的完整的{@link BeanDefinition}类的基类，分解出{@link GenericBeanDefinition}、{@link RootBeanDefinition}和{@link ChildBeanDefinition}的公共属性。

autowire常量与AutowireCapableBeanFactory接口中定义的常量匹配。

*/

RootBeanDefinition

1
2
3
4
5
6
7
8
继承 AbstractBeanDefinition

/*
根bean定义表示在运行时支持springbeanfactory中特定bean的合并bean定义。它可能是从多个相互继承的原始bean定义创建的，通常注册为{@link GenericBeanDefinition GenericBeanDefinitions}。根bean定义本质上是运行时的“统一”bean定义视图。

根bean定义也可以用于在配置阶段注册单个bean定义。然而，从spring2.5开始，以编程方式注册bean定义的首选方法是{@link genericbeandefinition}类。GenericBeanDefinition的优点是允许动态定义父依赖项，而不是将角色“硬编码”为根bean定义。

*/

GenericBeanDefinition

1
2
3
4
5
6
7
继承 AbstractBeanDefinition
/*
GenericBeanDefinition是用于标准bean定义的一站式服务。与任何bean定义一样，它允许指定一个类以及可选的构造函数参数值和属性值。此外，可以通过“parentName”属性灵活地配置从父bean定义派生的内容。

通常，使用这个{@code GenericBeanDefinition}类来注册用户可见bean定义（后处理程序可能会对其进行操作，甚至可能重新配置父名称）。使用{@code RootBeanDefinition}/{@code ChildBeanDefinition}，其中父/子关系恰好是预先确定的。

*/

ChildBeanDefinition

1
2
3
4
5
6
7
8
9
继承 AbstractBeanDefinition
/*
从父级继承设置的Bean的Bean定义。子bean定义与父bean定义有固定的依赖关系。

子bean定义将从父级继承构造函数参数值、属性值和方法重写，并可以选择添加新值。如果指定了init method、destroy method和/或static factory method，它们将重写相应的父设置。其余的设置将始终从子定义中获取：depends-on、autowire-mode、dependency-check、singleton、lazy-init。

注意：</b>从spring2.5开始，以编程方式注册bean定义的首选方法是{@link GenericBeanDefinition}类，它允许通过{@link GenericBeanDefinition}setParentName}方法动态定义父依赖项。对于大多数用例，这有效地取代了ChildBeanDefinition类。

*/

AopInfrastructureBean

1
2
3
4
5
6
7

/*
标记接口，指示作为Spring AOP基础设施一部分的bean。特别是，这意味着任何此类bean都不受自动代理的约束，即使切入点匹配。



*/
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家