一、两种后处理器

2017-03-05 本文已影响16人数独题

Bean后处理器：

Bean后处理器会在Bean实例创建成功之后，对Bean实例进行进一步的增强处理。
Bean后处理器必须实现BeanPOSTProcessor接口，BeanPOSTProcessor接口包含如下两种方法：

Object postProcessorBeforeInitialization(Object bean,String name)：该方法的第一个参数是系统即将进行后台处理的Bean实例，第二个参数是改Bean的配置Id。
Object postProcessorAfterInitialization(Object bean,String name)：该方法的第一个参数是系统即将进行后台处理的Bean实例，第二个参数是改Bean的配置Id。

当Spring容器实例化Bean实例之后，就会依次调用Bean后处理器的两个方法对Bean实例进行增强处理。

MyBeanProcessor.java

package entity;

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

public class MyBeanProcessor implements BeanPostProcessor {

    
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("Bean后处理器在初始化之后对"+beanName+"进行增强处理！");
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("Bean后处理器在初始化之前对"+beanName+"进行增强处理！");
        //如果该Bean是Chinese类的实例
        if(bean instanceof Chinese)
        {
            Chinese c=(Chinese)bean;
            c.setName("是的");
        }
        return bean;
    }

}

Chinese.java

package entity;

import org.springframework.beans.factory.InitializingBean;

import inter.Axe;
import inter.Persion;



public class Chinese implements Persion,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;
    }

    
    @Override
    public void useAxe() {
        // TODO Auto-generated method stub
        System.out.println(name+axe.chop());
    }

    //生命周期方法
    public void init()
    {
        System.out.println("正在执行初始化方法init...");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("正在执行初始化方法afterPropertiesSet");
        
    }

    
}

beans.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"
    
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
        
      <bean id="steelAxe" class="entity.SteelAxe"/>
      <bean id="chinese" class="entity.Chinese" init-method="init" p:axe-ref="steelAxe" p:name="依赖注入的值"/>
      
      <!-- 配置Bean后处理器，可以无需指定id属性 -->
      <bean class="entity.MyBeanProcessor"/>
</beans>

BeanTest.java

package test;

import inter.Persion;

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");
        Persion p=ctx.getBean("chinese", Persion.class);
        p.useAxe();
    }
    
}

输出

Bean后处理器在初始化之前对steelAxe进行增强处理！
Bean后处理器在初始化之后对steelAxe进行增强处理！
Spring实例化主调Bean：Chinese实例。。。
Spring为setName()方法注入依赖关系。。。
Bean后处理器在初始化之前对chinese进行增强处理！
Spring为setName()方法注入依赖关系。。。
正在执行初始化方法afterPropertiesSet
正在执行初始化方法init...
Bean后处理器在初始化之后对chinese进行增强处理！
是的钢斧砍柴真快！

虽然配置文件中指定chinese Bean的name为"依赖注入的值"，但这并没有放生任何作用，该chinese Bean的name成员变量的值被重新设定为"是的"-----这就是Bean后处理器的作用。

实现BeanPostProcessor接口的Bean后处理器可对Bean进行任何操作。

Spring提供的两个常用后处理器：

BeanNameAutoProxyCreator：根据Bean实例的name属性，创建Bean实例的代理。
DefaultAdvisorAutoProxyCreator：根据提供的Advisor对容器中的所有Bean实例创建代理。

容器后处理器：

Bean后处理器负责处理容器中所有的Bean实例，容器后处理器负责处理容器本身。
容器后处理器必须实现BeanFactoryPostProcessor接口，必须实现如下一个方法：

postProcessorBeanFactory(ConfigurableListableBeanFactory beanFactory)

ApplicationContext可自动检测容器中的容器后处理器，并且自动注册容器后处理器。但若使用BeanFactory作为容器后处理器，则必须手动调用该容器后处理器来处理BeanFactory容器。

MyBeanFactoryPostProcessor.java

package entity;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        System.out.println("程序对Spring所做的BeanFactory的初始化没有改变...");
        System.out.println("Spring容器是："+beanFactory);
        
    }

}

beans.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"
    
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
        
      <bean id="steelAxe" class="entity.SteelAxe"/>
      <bean id="chinese" class="entity.Chinese" init-method="init" p:axe-ref="steelAxe" p:name="依赖注入的值"/>
      
      <!-- 配置Bean后处理器，可以无需指定id属性 -->
      <bean class="entity.MyBeanProcessor"/>
      
      <!-- 配置容器后处理器 -->
      <bean class="entity.MyBeanFactoryPostProcessor"/>
</beans>

BeanTest.java

package test;

import inter.Persion;

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");
        Persion p=ctx.getBean("chinese", Persion.class);
        p.useAxe();
    }
    
}

输出

程序对Spring所做的BeanFactory的初始化没有改变...
Spring容器是：org.springframework.beans.factory.support.DefaultListableBeanFactory@29482a89: defining beans [steelAxe,chinese,entity.MyBeanProcessor#0,entity.MyBeanFactoryPostProcessor#0]; root of factory hierarchy
Bean后处理器在初始化之前对steelAxe进行增强处理！
Bean后处理器在初始化之后对steelAxe进行增强处理！
Spring实例化主调Bean：Chinese实例。。。
Spring为setName()方法注入依赖关系。。。
Bean后处理器在初始化之前对chinese进行增强处理！
Spring为setName()方法注入依赖关系。。。
正在执行初始化方法afterPropertiesSet
正在执行初始化方法init...
Bean后处理器在初始化之后对chinese进行增强处理！
是的钢斧砍柴真快！

Spring提供如下几个常用的容器后处理器：

PropertyPlaceholderConfigurer：属性占位符配置器。
PropertyOverrideConfigurer：重写占位符配置器。
CustomAutowireConfigurer：自定义自动装配配置器。
CustomScopeConfigurer：自定义作用域的配置器。

Spring没有提供ApplicationContextPostProcessor，对于ApplicationContext容器，一样使用BeanFactoryPostProcessor作为容器后处理器。容器后处理器的作用域范围是容器级，它只对容器本身进行处理，而不对容器中的Bean进行处理。

一、两种后处理器

Bean后处理器：

容器后处理器：

猜你喜欢

热点阅读