Two post processors
Bean post-processor: This post-processor will post-process the Bean in the container and make additional enhancements to the Bean. Container post-processor: This post-processor performs post-processing on the IoC container to enhance the function of the container.
Bean post processor
Bean post processor is a special kind of Bean. Its main function is to perform post-processing on other Beans. After the Bean instance is created, it will further enhance management. It must implement the BeanPostProcessor interface.
Instance
Directory structure
interface Axe
package service;
public interface Axe {
public String chop();
}
Person
package service;
public interface Person {
public void useAxe();
}
Chinese
package service.impl;
import org.springframework.beans.factory.InitializingBean;
import service.Axe;
import service.Person;
public class Chinese
implements Person, InitializingBean
{
private Axe axe;
private String name;
public Chinese()
{
System.out.println("Spring实例化主调bean：Chinese实例...");
}
public void setAxe(Axe axe)
{
this.axe = axe;
}
public void setName(String name)
{
System.out.println("Spring执行setName()方法注入依赖关系...");
this.name = name;
}
public void useAxe()
{
System.out.println(name + axe.chop());
}
// 下面是两个生命周期方法
public void init()
{
System.out.println("正在执行初始化方法 init...");
}
public void afterPropertiesSet() throws Exception
{
System.out.println("正在执行初始化方法 afterPropertiesSet...");
}
}
SteelAxe
package service.impl;
import service.Axe;
public class SteelAxe
implements Axe
{
public SteelAxe()
{
System.out.println("Spring实例化依赖bean：SteelAxe实例...");
}
public String chop()
{
return "钢斧砍柴真快";
}
}
MyBeanPostProcessor
package util;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import service.impl.Chinese;
public class MyBeanPostProcessor
implements BeanPostProcessor
{
/**
* 对容器中的Bean实例进行后处理
* @param bean 需要进行后处理的原Bean实例
* @param beanName 需要进行后处理的Bean的配置id
* @return 返回后处理完成后的Bean
*/
public Object postProcessBeforeInitialization
(Object bean , String beanName)
{
System.out.println("Bean后处理器在初始化之前对"
+ beanName + "进行增强处理...");
// 返回的处理后的Bean实例，该实例就是容器中实际使用的Bean
// 该Bean实例甚至可与原Bean截然不同
return bean;
}
public Object postProcessAfterInitialization
(Object bean , String beanName)
{
System.out.println("Bean后处理器在初始化之后对"
+ beanName + "进行增强处理...");
// 如果该Bean是Chinese类的实例
if (bean instanceof Chinese)
{
// 修改其name成员变量
Chinese c = (Chinese)bean;
c.setName("疯狂iOS讲义");
}
return bean;
}
}
BeanTest
package test;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import service.Person;
public class BeanTest {
public static void main(String[] args)throws Exception
{
// 以类加载路径下的beans.xml文件来创建Spring容器
// ApplicationContext ctx = new
// ClassPathXmlApplicationContext("beans.xml");
// Person p = (Person)ctx.getBean("chinese");
// 搜索类加载路径下的beans.xml文件创建Resource对象
Resource isr = new ClassPathResource("spring-config.xml");
// 创建默认的BeanFactory容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 让默认的BeanFactory容器加载isr对应的XML配置文件
new XmlBeanDefinitionReader(beanFactory).loadBeanDefinitions(isr);
// 获取容器中的Bean后处理器
BeanPostProcessor bp = (BeanPostProcessor)beanFactory.getBean("bp");
// 注册Bean后处理器
beanFactory.addBeanPostProcessor(bp);
Person p = (Person)beanFactory.getBean("chinese");
p.useAxe();
}
}
spring-config.xml
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 配置2个普通Bean实例 -->
<bean id="steelAxe" class="service.impl.SteelAxe"/>
<bean id="chinese" class="service.impl.Chinese"
init-method="init" p:axe-ref="steelAxe" p:name="依赖注入的值"/>
<!-- 配置Bean后处理器，可以无需指定id属性 -->
<bean id="bp" class="util.MyBeanPostProcessor"/>
</beans>
operation result
Code interpretation
postProcessBeforeInitialization
(Object bean , String beanName)
Object postProcessAfterInitialization
(Object bean , String beanName)
These two methods are methods BeanPostProcessordefined by the interface. The first method will be called back before the Bean is initialized, and the second method will be called back after the Bean is initialized. Their parameters: the first parameter is the Bean instance that is about to be post-processed. The second parameter is the configuration Id of the Bean.
Container post processor
The container post-processor is responsible for the container itself. It must implement the BeanFactoryPostProcessor interface
example
Directory structure
The code in the red line has not changed!
MyBeanFactoryPostProcessor
package org.util;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
public class MyBeanFactoryPostProcessor
implements BeanFactoryPostProcessor
{
/**
* 重写该方法，对Spring容器进行后处理
* @param beanFactory Spring容器本身
*/
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory)
throws BeansException
{
System.out.println("程序对Spring所做的BeanFactory初始化没有改变...");
System.out.println("Spring容器是：" + beanFactory);
}
}
BeanTest
package gao;
import org.service.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanTest
{
public static void main(String[] args)
{
ApplicationContext ctx = new
ClassPathXmlApplicationContext("beans.xml");
Person p = (Person)ctx.getBean("chinese");
p.useAxe();
}
}
beans.xml
<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<!-- 配置两个简单Bean实例 -->
<bean id="steelAxe" class="org.service.impl.SteelAxe"/>
<bean id="chinese" class="org.service.impl.Chinese"
init-method="init" p:name="孙悟空" p:axe-ref="steelAxe"/>
<!-- 配置容器后处理器 -->
<bean id="beanFactoryPostProcessor"
class="org.util.MyBeanFactoryPostProcessor"/>
</beans>
operation result
