Spring容器扩展(BeanPostProcessor,BeanFactoryPostProcessor,FactoryBean)—Spring官方文档系列

最新推荐文章于 2023-12-02 14:05:11 发布

爱吃花生酱的猴子

最新推荐文章于 2023-12-02 14:05:11 发布

阅读量346

点赞数

分类专栏： Spring文档阅读笔记

本文链接：https://blog.csdn.net/qq_38165752/article/details/79964280

版权

Spring文档阅读笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、使用BeanPostProcessor定制bean

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

你可以配置多个BeanPostProcessor实例，你可以通过设置order属性来控制这些BeanPostProcessor的执行顺序。只有当BeanPostProcessor实现了“Ordered”接口时，才可以设置此属性;如果你写自己的BeanPostProcessor，你应该考虑实现“Ordered”接口。

BeanPostProcessor操作bean(或对象)实例; 也就是说，Spring IoC容器实例化一个bean实例，然后BeanPostProcessor做他们的工作.BeanPostProcessor的作用域是每个容器。这仅在使用容器层次结构时才会用到这个。如果你在一个容器中定义一个BeanPostProcessor，它将只对该容器中的bean进行后处理。换句话说，在一个容器中定义的bean不会被另一个容器中定义的BeanPostProcessor进行后处理，即使两个容器都是同一层次结构的一部分。

org.springframework.beans.factory.config.BeanPostProcessor接口恰好包含两个回调方法。当这样的类在容器内注册为post-processor，对于由容器创建的每个bean实例，容器创建所有bean,在容器初始化方法(比如InitializingBean的afterProperieSet()方法和其他所有的声明的init方法)和所有bean 初始化回调之前，运行post-processor回调。post-processor可以对bean实例采取任何操作，包括完全忽略回调。 bean post-processor通常检查回调接口或者可以用代理包装bean。一些Spring AOP基础结构类被实现为bean post-processor，以便提供代理包装逻辑。

一个ApplicationContext 自动检测在配置元数据中定义的实现BeanPostProcessor接口的任何bean。 ApplicationContext将这些bean注册为后处理器，以便稍后在创建bean时调用它们。 Bean后处理器可以像任何其他bean一样部署在容器中(直接使用<bean>)。

注意，当在配置类上使用@Bean工厂方法声明BeanPostProcessor时，工厂方法的返回类型应该是实现类本身或至少是org.springframework.beans.factory.config.BeanPostProcessor接口，清楚地表明该bean的后处理器性质。否则，ApplicationContext将不能在完全创建它之前通过类型自动检测它。因为BeanPostProcessor需要尽早的实例化，以便应用于上下文中其他bean的初始化，所以这种尽早的类型检测是至关重要的。

二、使用BeanFactoryPostProcessor定制配置元数据

我们将要看到的下一个扩展点是“org.springframework.beans.factory.config.BeanFactoryPostProcessor”。这个接口的语义类似于BeanPostProcessor，其中一个主要区别是:BeanFactoryPostProcessor对* bean配置元数据*操作;也就是说，Spring IoC容器允许BeanFactoryPostProcessor读取配置元数据，并可能在容器实例化(除BeanFactoryPostProcessor之外的任何)bean之前改变它。

你可以配置多个BeanFactoryPostProcessors，你可以通过设置orderproperty来控制这些BeanFactoryPostProcessor的执行顺序。但是，如果BeanFactoryPostProcessor实现了 Ordered接口，则只能设置此属性。如果你写自己的“BeanFactoryPostProcessor”，你应该考虑实现 Ordered接口。

如果你想改变实际的bean 实例(即从配置元数据创建的对象)，那么你需要使用一个BeanPostProcessor述。虽然在技术上可以使用BeanFactoryPostProcessor(例如，使用BeanFactory.getBean())中的bean实例，这样做会导致提前的bean实例化，违反标准容器生命周期。这可能导致负面的副作用，如绕过bean后处理。此外，BeanFactoryPostProcessors的作用域也是在各自的容器内。这仅在使用容器层次结构时才相关。如果你在一个容器中定义一个BeanFactoryPostProcessor，它只会应用于该容器中的bean定义。一个容器中的Bean定义不会被另一个容器中的BeanFactoryPostProcessor进行后置处理，即使这两个容器都是同一层次结构的一部分。

接下里用代码来看看BeanPostProcessor和BeanFactoryPostProcessor

<!-- ContainnerDevelopment -->
	<!-- 支持Spring注解 -->
    <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />
    <!-- 注册一个BeanPostProcessor -->
    <bean id="postProcessor" class="com.jay.document.containnerDevelop.PostProcessor"/>
    <!-- 注册一个BeanFactoryPostProcessor -->
    <bean id="factoryPostProcessor" class="com.jay.document.containnerDevelop.FactoryPostProcessor"/>
    <!-- 普通bean -->
    <bean id="beanFactoryPostProcessorTest" class="com.jay.document.containnerDevelop.BeanFactoryPostProcessorTest">
           <property name="name" value="张三"/>
           <property name="sex" value="男"/>
     </bean>

上面的postProcessor实现了BeanPostProcessor接口，FactoryPostProcessor实现了BeanFactoryPostProcessor。

postProcessor：

public class PostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		 System.out.println("后置处理器AfterInitialization()方法处理bean=【"+beanName+"】 开始");
	        try {
	            Thread.sleep(1000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
		return bean;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("后置处理器BeforeInitialization()方法处理bean=【"+beanName+"】完毕!");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
		return bean;
	}

}

FactoryPostProcessor：

public class FactoryPostProcessor implements BeanFactoryPostProcessor {

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
		System.out.println("--->调用了BeanFactoryPostProcessor");
        String[] beanStr = configurableListableBeanFactory
                .getBeanDefinitionNames();
        for (String beanName : beanStr) {
        	//这里输出  看看Bean配置的顺序 
        	System.out.println("循环的beanName-->>"+beanName);
        	// 这里只改变beanFactoryPostProcessorTest的属性
            if ("beanFactoryPostProcessorTest".equals(beanName)) {
                BeanDefinition beanDefinition = configurableListableBeanFactory
                        .getBeanDefinition(beanName);
                MutablePropertyValues m = beanDefinition.getPropertyValues();
               System.out.println("--->>>"+m.getPropertyValueList().toString());
                if (m.contains("name")) {
                    m.addPropertyValue("name", "李白");
                    System.out.println("--->修改了name属性初始值了");
                }
            }
        }
    }
}

BeanFactoryPostProcessorTest：

public class BeanFactoryPostProcessorTest implements InitializingBean,DisposableBean,BeanNameAware,BeanFactoryAware{

	private String name;
	private String sex;
	public String getName() {
		return name;
	}
	//getter  setter
	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		 System.out.println("-->调用了BeanFactoryAware的setBeanFactory方法了");
		
	}
	@Override
	public void setBeanName(String arg0) {
		 System.out.println("-->调用了BeanNameAware的setBeanName方法了");
		
	}
	@Override
	public void destroy() throws Exception {
		  System.out.println("-->调用了DisposableBean的destroy方法了");       
		
	}
	@Override
	public void afterPropertiesSet() throws Exception {
		  System.out.println("-->调用了Initailization的afterPropertiesSet方法了");
		
	}
	@Override
	public String toString() {
		return "BeanFactoryPostProcessorTest [name=" + name + ", sex=" + sex + "]";
	}
}

Test：

public static void main(String[] args) {
		
	     System.out.println("-->Spring ApplicationContext容器开始初始化了......");
	     ApplicationContext applicationcontext= new ClassPathXmlApplicationContext("applicationContext.xml");
	     System.out.println("-->Spring ApplicationContext容器初始化完毕了......");
	     //BeanLifecycle beanLifecycle =applicationcontext.getBean("beanLifecycle",BeanLifecycle.class);
	     BeanFactoryPostProcessorTest beanFactoryPostProcessorTest=applicationcontext.getBean(BeanFactoryPostProcessorTest.class);
	     System.out.println(beanFactoryPostProcessorTest.toString());
		
	}

运行结果：

-->Spring ApplicationContext容器开始初始化了......

--->调用了BeanFactoryPostProcessor // 调用了 FactoryPostProcessor的postProcessBeanFactory方法

循环的beanName-->>myAware //这是通过@component注解配置的bean 在读取配置是在第一个
循环的beanName-->>org.springframework.context.annotation.internalConfigurationAnnotationProcessor
循环的beanName-->>org.springframework.context.annotation.internalAutowiredAnnotationProcessor
循环的beanName-->>org.springframework.context.annotation.internalRequiredAnnotationProcessor
循环的beanName-->>org.springframework.context.annotation.internalCommonAnnotationProcessor
循环的beanName-->>container //这是通过xml配置的bean
循环的beanName-->>atList //这是也通过xml配置的bean 顺序是按照配置的顺序
循环的beanName-->>org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#0
循环的beanName-->>postProcessor
循环的beanName-->>factoryPostProcessor
循环的beanName-->>beanFactoryPostProcessorTest // 这里可以看出在bean没有实例化之前，就改变了 bean的属性配置

--->>>[bean property 'name', bean property 'sex'] // BeanFactoryPostProcessor 是对读取每个bean的配置文件都有效

--->修改了name属性初始值了 //

循环的beanName-->>org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor
循环的beanName-->>org.springframework.context.annotation.ConfigurationClassPostProcessor.enhancedConfigurationProcessor
后置处理器BeforeInitialization()方法处理bean=【myAware】完毕 // BeanPostProcessor 同样是对读取每个bean的配置文件都有效
后置处理器AfterInitialization()方法处理bean=【myAware】开始
后置处理器BeforeInitialization()方法处理bean=【atList】完毕!
后置处理器AfterInitialization()方法处理bean=【atList】开始
后置处理器BeforeInitialization()方法处理bean=【container】完毕!
后置处理器AfterInitialization()方法处理bean=【container】开始
-->调用了BeanNameAware的setBeanName方法了
-->调用了BeanFactoryAware的setBeanFactory方法了//这里可以看出 BeanPostProcessor 的BeforeInitialization方法执行 //在 Initailization的afterPropertiesSet方法之前
后置处理器BeforeInitialization()方法处理bean=【beanFactoryPostProcessorTest】完毕!
-->调用了Initailization的afterPropertiesSet方法了
后置处理器AfterInitialization()方法处理bean=【beanFactoryPostProcessorTest】开始
-->Spring ApplicationContext容器初始化完毕了......

BeanFactoryPostProcessorTest [name=李白, sex=男] // 属性已经改变

三、使用FactoryBean定制实例化逻辑

对象实现org.springframework.beans.factory.FactoryBean接口,则成为它本身的工厂。

FactoryBean接口是Spring IoC容器实例化逻辑的扩展点。假如初始化代码非常复杂，此时使用java编码比使用XML配置更容易表达。这种场景中，你可以创建自己的FactoryBean，在该类中编写复杂的初始化程序，然后将你的自定义FactoryBean插入到容器。

FactoryBean接口提供了三种方法:

Object getObject():返回此工厂创建的对象的实例。实例可以共享，这取决于这个工厂是返回单例还是原型。
boolean isSingleton():如果这个“FactoryBean”返回单例，则返回true，否则返回false。
类getObjectType():返回由getObject()方法或null返回的对象类型，如果类型不是预先知道的。

FactoryBean概念和接口在Spring框架中的许多地方使用; Spring内置的有超过50个实现。

当你需要向容器请求一个实际的FactoryBean实例本身而不是它生成的bean时，在调用ApplicationContext的getBean()方法时，用符号(&)作为前缀。所以对于给定的FactoryBean，id为myBean，在容器上调用getBean(“myBean”)会返回FactoryBean所产生的bean;而调用getBean(“＆myBean”)返回FactoryBean实例本身。

FactoryBean的核心就在于通过getObject方法可以获取的是它所生产的对象，所以我们在Proxy创建代理对象的时候就比较方便。还有一些bean，如果通过配置的方式，会显得比较麻烦和复杂，那么这时候适当的采用编码方式在某些场合下还是挺不错的。

给个小例子(来自此博)