Spring文档之容器扩展点

转载

mb5fed73533dfa9 2021-10-11 03:08:00

2.8.1. 通过使用BeanPostProcessor自定义 Bean
- 示例：Hello World, BeanPostProcessor-style
- 示例： AutowiredAnnotationBeanPostProcessor
2.8.2. 自定义BeanFactoryPostProcessor配置元数据
- 示例：类名替换 PropertySourcesPlaceholderConfigurer
- 示例： PropertyOverrideConfigurer
2.8.3. 使用FactoryBean定制实例化逻辑

通常，应用程序开发人员不需要对ApplicationContext 实现类进行子类化。相反，可以通过插入特殊集成接口的实现来扩展 Spring IoC 容器。接下来的几节将描述这些集成接口。

2.8.1. 通过使用`BeanPostProcessor`自定义 Bean

BeanPostProcessor接口定义了回调方法，您可以实现这些回调方法来提供您自己的(或覆盖容器的默认)实例化逻辑、依赖项解析逻辑等等。
如果希望在Spring容器完成bean的实例化、配置和初始化之后实现一些自定义逻辑，可以插入一个或多个自定义BeanPostProcessor实现。

您可以配置多个BeanPostProcessor实例，并且可以通过设置order属性来控制这些BeanPostProcessor实例运行的顺序。
只有当BeanPostProcessor实现了Ordered接口时，才能设置此属性。
如果您编写自己的BeanPostProcessor，也应该考虑实现Ordered接口。
有关详细信息，请参阅BeanPostProcessor和Ordered接口的javadoc。
请参见关于BeanPostProcessor实例的编程注册的说明。

注意：

BeanPostProcessor实例对bean(或对象)实例进行操作。也就是说，Spring IoC容器实例化一个bean实例，然后BeanPostProcessor实例执行它们的工作。

BeanPostProcessor实例的作用域为每个容器。只有当您使用容器层次结构时，这才相关。
如果在一个容器中定义BeanPostProcessor，则它只对该容器中的bean进行后处理。
换句话说，在一个容器中定义的bean不会被另一个容器中定义的BeanPostProcessor进行后处理，即使这两个容器属于相同的层次结构。

要更改实际的bean定义(即定义bean的蓝图)，您需要使用BeanFactoryPostProcessor，如使用BeanFactoryPostProcessor定制配置元数据中所述。

beanpostprocessor接口由两个回调方法组成。当这样一个类注册为后处理器的容器,每个容器创建bean实例,后处理器从容器之前得到一个回调容器初始化方法(如InitializingBean.afterPropertiesSet()或任何宣布init方法),以及在任何bean初始化回调之后。
后处理器可以对bean实例采取任何操作，包括完全忽略回调。bean后处理器通常检查回调接口，或者用代理包装bean。为了提供代理包装逻辑，一些Spring AOP基础结构类被实现为bean后处理器。

ApplicationContext自动检测在实现BeanPostProcessor接口的配置元数据中定义的任何bean。ApplicationContext将这些bean注册为后处理器，以便在稍后创建bean时调用它们。Bean后处理器可以以与任何其他Bean相同的方式部署在容器中。

注意,当宣布BeanPostProcessor @ bean配置类工厂方法,使用一个工厂方法的返回类型必须实现类本身或者至少org.springframework.beans.factory.config.BeanPostProcessor接口,明确指示后处理器的特性,bean。否则，在完全创建它之前，ApplicationContext无法按类型自动检测它。由于BeanPostProcessor需要早期实例化，以便应用于上下文中的其他bean的初始化，因此这种早期类型检测非常关键。

注意：

以编程方式注册BeanPostProcessor实例
虽然BeanPostProcessor的推荐注册方法是通过ApplicationContext自动检测(如前所述)，但您可以通过使用addBeanPostProcessor方法以编程方式对ConfigurableBeanFactory注册它们。当您需要在注册前计算条件逻辑时，或者在层次结构中跨上下文复制bean post处理器时，这是非常有用的。
但是请注意，以编程方式添加的BeanPostProcessor实例不尊重Ordered接口。在这里，注册的顺序决定了执行的顺序。还请注意，通过编程注册的BeanPostProcessor实例总是在通过自动检测注册的实例之前被处理，无论任何显式的顺序。

BeanPostProcessor实例和AOP自动代理
实现BeanPostProcessor接口的类是特殊的，容器对它们的处理是不同的。所有BeanPostProcessor实例和它们直接引用的bean都是在启动时实例化的，作为ApplicationContext特殊启动阶段的一部分。接下来，将以排序方式注册所有BeanPostProcessor实例，并将其应用到容器中的所有其他bean。因为AOP的自动代理是作为BeanPostProcessor本身实现的，所以无论是BeanPostProcessor实例还是它们直接引用的bean都不符合自动代理的条件，因此没有将方面编织到它们之中。

对于任何这样的bean，您都应该看到一条信息日志消息:bean someBean不符合由所有BeanPostProcessor接口处理的条件(例如:不符合自动代理的条件)。

如果通过使用autotowiring或@Resource(可能会退回到autotowiring)将bean连接到BeanPostProcessor中，那么Spring在搜索类型匹配依赖项候选项时可能会访问意外的bean，从而使它们不适合自动代理或其他类型的bean后处理。例如，如果您有一个用@Resource注释的依赖项，其中字段或setter名称与声明的bean名称不直接对应，并且没有使用name属性，那么Spring将访问其他bean以按类型匹配它们。

下面的示例演示如何在ApplicationContext中编写、注册和使用BeanPostProcessor实例。

示例：Hello World, `BeanPostProcessor`-style

第一个例子说明了基本用法。该示例显示了一个自定义BeanPostProcessor实现，该实现在容器创建每个bean时调用toString()方法，并将生成的字符串打印到系统控制台。

package scripting;

import org.springframework.beans.factory.config.BeanPostProcessor;

public class InstantiationTracingBeanPostProcessor implements BeanPostProcessor {

    // simply return the instantiated bean as-is
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean; // we could potentially return any object reference here...
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("Bean '" + beanName + "' created : " + bean.toString());
        return bean;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:lang="http://www.springframework.org/schema/lang"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang
        https://www.springframework.org/schema/lang/spring-lang.xsd">

    <lang:groovy id="messenger"
            script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy">
        <lang:property name="message" value="Fiona Apple Is Just So Dreamy."/>
    </lang:groovy>

    <!--
    when the above bean (messenger) is instantiated, this custom
    BeanPostProcessor implementation will output the fact to the system console
    -->
    <bean class="scripting.InstantiationTracingBeanPostProcessor"/>

</beans>

注意InstantiationTracingBeanPostProcessor是如何定义的。
它甚至没有名称，而且因为它是一个bean，所以可以像其他bean一样进行依赖注入。
(前面的配置还定义了一个由Groovy脚本支持的bean。
Spring的动态语言支持在“动态语言支持”一章中有详细介绍。)

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scripting.Messenger;

public final class Boot {

    public static void main(final String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("scripting/beans.xml");
        Messenger messenger = ctx.getBean("messenger", Messenger.class);
        System.out.println(messenger);
    }

}

Bean 'messenger' created : org.springframework.scripting.groovy.GroovyMessenger@272961
org.springframework.scripting.groovy.GroovyMessenger@272961

示例： `AutowiredAnnotationBeanPostProcessor`

将回调接口或注释与自定义BeanPostProcessor实现结合使用是扩展Spring IoC容器的常用方法。
一个例子是Spring的AutowiredAnnotationBeanPostProcessor——一个与Spring发行版一起发布的BeanPostProcessor实现，它自动连接带注释的字段、setter方法和任意配置方法。

2.8.2. 自定义`BeanFactoryPostProcessor`配置元数据

我们查看的下一个扩展点是org.springframework.beans.factory.config.BeanFactoryPostProcessor。
此接口的语义与BeanPostProcessor的语义相似，但有一个主要区别:BeanFactoryPostProcessor对bean配置元数据进行操作。也就是说，Spring IoC容器允许BeanFactoryPostProcessor读取配置元数据，并在容器实例化除BeanFactoryPostProcessor实例之外的任何bean之前可能更改它。

您可以配置多个BeanFactoryPostProcessor实例，并且可以通过设置order属性来控制这些BeanFactoryPostProcessor实例运行的顺序。但是，只有在BeanFactoryPostProcessor实现了Ordered接口时，才能设置此属性。如果您编写自己的BeanFactoryPostProcessor，也应该考虑实现Ordered接口。有关更多细节，请参阅BeanFactoryPostProcessor和Ordered接口的javadoc。

注意：

如果想要更改实际的bean实例(即从配置元数据创建的对象)，则需要使用BeanPostProcessor(前面通过使用BeanPostProcessor定制bean)。虽然在BeanFactoryPostProcessor中使用bean实例在技术上是可能的(例如，通过使用BeanFactory.getBean())，但这样做会导致bean过早实例化，违反标准容器生命周期。这可能会导致负面的副作用，例如绕过bean的后处理。

此外，BeanFactoryPostProcessor实例的作用域是每个容器的。这只有在使用容器层次结构时才有用。如果在一个容器中定义BeanFactoryPostProcessor，则它只应用于该容器中的bean定义。一个容器中的Bean定义不会由另一个容器中的BeanFactoryPostProcessor实例进行后处理，即使这两个容器属于相同的层次结构。

当在ApplicationContext中声明bean工厂后处理器时，它会自动运行，以便对定义容器的配置元数据应用更改。Spring包括许多预定义的bean工厂后处理器，如PropertyOverrideConfigurer和PropertySourcesPlaceholderConfigurer。您还可以使用自定义BeanFactoryPostProcessor—例如，注册自定义属性编辑器。

ApplicationContext自动检测部署到其中并实现BeanFactoryPostProcessor接口的任何bean。
它在适当的时候将这些bean用作bean工厂的后处理器。您可以像部署任何其他bean一样部署这些后处理器bean。

注意：

与BeanPostProcessors一样，通常不希望将BeanFactoryPostProcessors配置为惰性初始化。如果没有其他bean引用bean(工厂)PostProcessor，则根本不会实例化该后处理器。因此，将它标记为惰性初始化将被忽略，即使您在元素的声明中将default-lazy-init属性设置为true, Bean(Factory)PostProcessor也将被立即实例化。

示例：类名替换 `PropertySourcesPlaceholderConfigurer`

您可以使用PropertySourcesPlaceholderConfigurer，通过使用标准的Java Properties格式，将bean定义中的属性值外部化到单独的文件中。这样做使部署应用程序的人员能够定制特定于环境的属性，如数据库url和密码，而无需修改容器的主XML定义文件或文件的复杂性或风险。

考虑以下基于xml的配置元数据片段，其中定义了一个带有占位符值的数据源:

<bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
    <property name="locations" value="classpath:com/something/jdbc.properties"/>
</bean>

<bean id="dataSource" destroy-method="close"
        class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="${jdbc.driverClassName}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

该示例显示了从外部properties文件配置的属性。在运行时，PropertySourcesPlaceholderConfigurer被应用到元数据中，替换数据源的一些属性。要替换的值被指定为表单${property-name}的占位符，该表单遵循Ant、log4j和JSP EL风格。

实际值来自另一个标准Java Properties格式的文件:

jdbc.driverClassName=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:hsql://production:9002
jdbc.username=sa
jdbc.password=root

因此,$ {jdbc.Username}字符串在运行时被替换为值'sa'，这同样适用于属性文件中匹配键的其他占位符值。PropertySourcesPlaceholderConfigurer检查bean定义的大多数属性和属性中的占位符。
此外，您可以自定义占位符前缀和后缀。

使用Spring 2.5中引入的上下文名称空间，您可以使用专用的配置元素配置属性占位符。您可以在location属性中以逗号分隔的列表形式提供一个或多个位置，如下面的示例所示:

<context:property-placeholder location="classpath:com/something/jdbc.properties"/>

PropertySourcesPlaceholderConfigurer不仅在您指定的properties文件中寻找属性。
默认情况下，如果在指定的属性文件中找不到属性，它将检查Spring Environment属性和常规Java System属性。

您可以使用PropertySourcesPlaceholderConfigurer来替换类名，当您必须在运行时选择一个特定的实现类时，这有时很有用。下面的例子展示了如何做到这一点:

<bean class="org.springframework.beans.factory.config.PropertySourcesPlaceholderConfigurer">
    <property name="locations">
        <value>classpath:com/something/strategy.properties</value>
    </property>
    <property name="properties">
        <value>custom.strategy.class=com.something.DefaultStrategy</value>
    </property>
</bean>

<bean id="serviceStrategy" class="${custom.strategy.class}"/>

如果在运行时不能将类解析为有效的类，则在准备创建bean时，对非惰性init bean的ApplicationContext的preinstantiatesingleton()阶段，bean的解析会失败。

示例： `PropertyOverrideConfigurer`

另一个bean工厂后处理器PropertyOverrideConfigurer类似于PropertySourcesPlaceholderConfigurer，但与后者不同的是，对于bean属性，原始定义可以有默认值，也可以完全没有值。如果覆盖的Properties文件没有特定bean属性的条目，则使用默认上下文定义。

注意，bean定义没有意识到被覆盖，因此从XML定义文件中不能立即看出正在使用覆盖配置器。如果多个PropertyOverrideConfigurer实例为同一个bean属性定义了不同的值，那么最后一个实例会胜出，这是由于覆盖机制。

属性文件配置行采用以下格式:

beanName.property=value

下面的列表显示了该格式的示例:

dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql:mydb

这个示例文件可以与包含名为dataSource的bean的容器定义一起使用，该bean具有驱动程序和url属性。

复合属性名也被支持，只要路径的每个组件(除了被覆盖的final属性)已经是非空(大概是由构造函数初始化的)。在下面的示例中，tom bean的fred属性的bob属性的sammy属性被设置为标量值123:

tom.fred.bob.sammy=123

注意：指定的覆盖值总是文字值。它们不会被转换为bean引用。当XML bean定义中的原始值指定bean引用时，此约定也适用。

使用Spring 2.5中引入的上下文名称空间，可以使用专用的配置元素配置属性覆盖，如下面的示例所示:

<context:property-override location="classpath:override.properties"/>

2.8.3. 使用FactoryBean定制实例化逻辑

您可以为本身就是工厂的对象实现org.springframework.beans.factory.FactoryBean接口。

FactoryBean接口是可插入Spring IoC容器实例化逻辑的点。如果您有复杂的初始化代码，用Java更好地表达，而不是(可能)冗长的XML，那么您可以创建自己的FactoryBean，在该类中编写复杂的初始化，然后将自定义的FactoryBean插入容器中。

FactoryBean接口提供了三个方法:

T getObject()：返回此工厂创建的对象的实例。实例可能会被共享，这取决于这个工厂是返回单例还是原型。
boolean isSingleton():true如果FactoryBean返回单例或false其他情况，则返回。此方法的默认实现返回true.
Class<?> getObjectType(): 返回getObject()方法返回的对象类型或者null如果类型事先未知。

FactoryBean的概念和接口在Spring框架中的许多地方被使用。Spring本身附带了超过50个FactoryBean接口的实现。

当您需要向容器请求实际的FactoryBean实例本身而不是它生成的bean时，在调用ApplicationContext的getBean()方法时，在bean的id前面加上&符号。因此，对于一个id为myBean的给定FactoryBean，调用容器上的getBean(“myBean”)将返回FactoryBean的产品，而调用getBean(“&myBean”)将返回FactoryBean实例本身。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。