Spring学习笔记（二）后处理器与AOP

1.后处理器

后处理器是对IOC容器功能的扩展。按我的理解，扩展的原理是在某动作结束后再次调用指定的方法进行扩展处理。有点类似于AOP。

后处理器分两种：Bean后处理器和容器后处理器。

1.1 Bean后处理器

Bean后处理器会在Bean实例化结束后（注意，该实例化是指Bean类的实例化，还没有进行Spring中的注入等操作，并不是Spring最终返回的Bean），对其进行近一步的增强处理，例如返回一个Bean的代理类。

Bean后处理器需要实现BeanPostProcessor接口，该接口包含的postProcessBeforeInitialization，postProcessAfterInitialization分别在Bean初始化之前和之后回调。

如上图，增强处理与init-method，InitializingBean，destory-method，DisposableBean的执行顺序，增强处理永远在最外围的。

实现InitializingBean接口的afterPropertiesSet方法、配置<bean init-method="method">都是在Bean的全部属性设置成功后执行的方法。而Bean后处理器是在属性注入之前和之后执行的方法。

下面给出Bean后处理器的Demo：

• 首先实现创建一个实现BeanPostProcessor的后处理器类

/**
 * Bean后处理器Demo类,该处理类会对容器里面的所有Bean进行后处理
 * @author wangsz
 */
public class BeanPostProc implements BeanPostProcessor{
    /**
     * 在Bean初始化后，对容器中的bean进行后处理，返回处理后的bean
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean后处理器在["+beanName+"]初始化后对其进行增强处理");
        if(bean instanceof Person){
            ((Person) bean).setName("akq");
        }
        //该bean可以与旧bean截然不同,如返回一个该Bean的代理类
        return bean;
    }
    /**
     * 在Bean初始化前，对容器中的bean进行后处理，返回处理后的bean
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean后处理器在["+beanName+"]初始化前对其进行增强处理");
        //该bean可以与旧bean截然不同
        return bean;
    }

}

• 然后在Spring配置文件中加上这个Bean。这样，该后处理类就会对容器里面的所有Bean进行后处理。

<!--bean后处理器-->
    <bean id="beanproc" class="test.wsz.spring.postprocessor.BeanPostProc"  />

1.2 容器后处理器

Bean后处理器是对Bean实例化后进行后处理的，而容器后处理器，顾名思义，就是对Spring容器进行后处理，通常用于Spring容器实例化Bean之前，读取配置文件元数据，对其进行修改。

容器后处理器需要实现BeanFactoryPostProcessor接口，重写该接口包含的postProcessBeanFactory方法。

Spring中已提供了几个常用的容器后处理器：

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

下面给出容器后处理器的Demo：

• 首先实现创建一个实现BeanFactoryPostProcessor的容器后处理器类

/**
 * 容器后处理器Demo类，在容器实例化bean之前，读取配置文件的元数据，并修改
 * @author wangsz
 */
public class BeanFactoryProc implements BeanFactoryPostProcessor{

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("Spring的容器是："+beanFactory);
        System.out.println("容器后处理器并没有对BeanFactory的初始化做修改");
    }

}

• 然后在Spring配置文件中加上这个Bean。

<!--容器后处理器-->
    <bean id="beanfactoryproc" class="test.wsz.spring.postprocessor.BeanFactoryProc"  />

2.AOP

Aspect Orient Pragramming：面向切面编程。

2.1 AOP的概念

这个术语不太好理解，下面我们用图来一步步阐述它演变的过程。

现在有三个方法，我要在里面添加同一段代码，比较low的方式，是将同一段代码复制粘贴三遍：

改进的方式是，我把这段代码抽离到一个方法中，然后在三个方法中手动调用这个抽离方法：

但是上面的方法仍然有些不方便。如果不是三个方法，是十个，二十个，那一个个的在里面写方法的调用很麻烦。而且，如果增加需求，例如再次为方法一、二、三增加日志打印，再次为方法一、二、三增加参数检验，那么每次都得加个抽离方法，然后在方法一二三里面加调用。

AOP就是针对这些不便的进一步优化。我们将方法一二三看成一个切面，然后在这个切面上进行增强处理。不需要方法一二三手动调用抽离方法，抽离方法“自动”进行了调用：

通过上面的图我们可以进行一个总结：AOP其实就是代理模式的一种体现，将程序运行过程看成一个切面，在切面上进行公共的处理。

2.2 AOP的应用

现在版本的Spring的AOP一般都是整合的AspectJ实现的。AspectJ框架是最早，功能比较强大的AOP实现之一，Spring中只是用到了它部分的功能，有兴趣的朋友可以百度了解一下。

值得注意的是，AspectJ和Spring的实现方式的不同，AspectJ是编译时对目标类进行增强（反编译目标类可发现多了内容），而Spring是生成一个代理类进行增强。

2.2.1 AOP的几种注解配置

下面我们开始在Spring中配置AOP
- 首先在Maven中增加AspectJ的支持jar包，注意版本要和jdk符合，我之前用的jar包过老，导致aop测试时莫名出现一系列找不到包的异常。

<!--aop支持jar包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.9</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>

• 在Spring的配置文件中增加内容：

<!--beans中增加如下三个配置-->
<beans  xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <!--aspect配置
    如果proxy-target-class 属性值被设置为true，那么基于类的代理将起作用（这时需要cglib库）。
    如果proxy-target-class属值被设置为false或者这个属性被省略，那么标准的JDK 基于接口的代理将起作用-->
    <aop:aspectj-autoproxy proxy-target-class="true"/> 
    <!--Aspect Demo类-->
    <bean class="test.wsz.spring.aop.AspectDemo"  />
 </beans>

如果不采用Spring的XML Schema的方法，也可以去除<beans ……>对应配置，增加：

<!--启动AspectJ支持-->
    <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"  />

• 然后我们创建一个Aspect的测试Demo类：

@Aspect //声明该类为切面类，在spring配置中加入该类的bean，ApplicationContext会自动加载，将该Bean作为切面处理
public class AspectDemo {
    /**
     * 在方法执行前进行调用,value指定切入点
     */
    @Before(value = "execution(* test.wsz.spring.bean..StoneAxe.useAxe(..))")
    public void beforeTest() {
        System.out.println("-----before stoneAxe.useAxe()-----");
    }

    /**
     * 在方法正常执行完成后进行调用,value指定切入点，也可用pointcut。returning指定返回形参
     */
    @AfterReturning(returning = "returnValue", pointcut = "execution(* test.wsz.spring.bean..StoneAxe.useAxeTest(..))")
    public void afterReturnTest(Object returnValue) {
        System.out.println("-----after stoneAxe.useAxe()-----");
        System.out.println("返回值是：" + returnValue);
    }

    /**
     * 无论方法是否正常结束，只要完成后调用该方法
     */
    @After(value = "execution(* test.wsz.spring.bean..StoneAxe.useAxeTest(..))")
    public void afterTest() {
        System.out.println("方法执行完成，无论是正常完成还是异常终止执行");
    }

    /**
     * 在方法异常后调用，但并不能像catch一样捕获异常，异常仍然会抛给上级进行处理
     * 
     * @param e
     *            方法中抛出的异常
     */
    @AfterThrowing(throwing = "e", pointcut = "execution(* test.wsz.spring.bean..StoneAxe.useAxeTest(..))")
    public void afterThrowingTest(Throwable e) {
        System.out.println("方法抛出异常：" + e.getMessage());
    }

    /**
     * 功能较强的增强方法，类似before和afterReturning的集合
     * @param pjp 方法信息对象
     * @return
     * @throws Throwable
     */
    @Around("execution(* test.wsz.spring.bean..StoneAxe.useAxeTest(..))")
    public Object aroundTest(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("-----around-------");
        System.out.println("方法执行前");
        Object object = pjp.proceed();
        System.out.println("方法执行后");
        return object;
    }
}

这个Demo类中演示了几种切面的注解方法。xml的配置方法就不贴出来了，可自行百度。

为了方便，我们还可设定一个切点，然后进行引用：

// 定义一个切入点，该切入点方法体中的代码无效
    @Pointcut("execution(* test.wsz.spring.bean..IronAxe.useAxe(..))") // 方法体中的代码无效
    public void mypointcut() {
        System.out.println("-----pointcout-----");
    }

    /**
     * 在方法执行前进行调用
     */
    @Before(value = "mypointcut()")
    public void before() {
        System.out.println("-----before-----");
    }

注意，几种切面方法的执行顺序如下：

2.2.2 execution的规则

补充下切面execution的规则：

execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)

举一个例子说明：

2.2.3 AOP要注意的问题

使用Spring AOP拦截时要注意：内部方法调用是无法被拦截的。
例如，方法A中调用了方法B，此时方法B就算加了拦截配置也是无法被拦截的。

原理跟Spring的代理类有关。Spring拦截类的方法时，其实都是拦截的Spring经过增强后处理的代理类的方法。：

proxybean:

before

invoke(bean,A)

after

在invoke(bean,A)中调用方法B时，此时是原类进行的调用，Spring无法拦截。

查了资料，目前解决方案有三：

1.修改代码，手动调用代理类运行方法B：

if (null != AopContext.currentProxy()) {
            rs=((Bean)AopContext.currentProxy()).method(...);
        } else {
            rs=method(...);
        }

在配置文件加入如下配置，使代理类暴露给线程。注意该配置要spring3.0以上：

<aop:aspectj-autoproxy expose-proxy="true"/>

2. 将内部调用的方法放入其他类

3. 使用aspectj拦截

---

本文总结于
《疯狂JavaEE》的第八章《深入使用Spring》