Spring-AOP

记得上小学时候，上课前班长或者学习委员都会带头喊：起立，然后童鞋们起立齐喊：老师好才开始上课，下课同样起立喊老师再见，整节课才算完成。其实这是一种仪式，并不是某一位老师特别教授的技能，但又必须做，而且无论什么课程都需要举行，这种就类似于程序中的非核心业务，不能与核心业务混为一体，只是在需要出现的地方出现，为处理这种矛盾，从而就有了专门处理的方法或理念，叫面向切面编程AOP，Spring支持AOP，下面就以学生上课为例进行示范：

---

JavaConfig：

package com.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages={"com.spring"})
@EnableAspectJAutoProxy
public class CreatureSpingConfig {
}

package com.spring.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect//需要引入aspectjrt-1.*.*.jar,此处版本需要和jdk版本匹配
public class Sophomore implements Student{
/**
* 定义切点，下面的没有方法体的方法只是相当于一个别名
*/
@Pointcut("execution(* com.spring.aop.ChineseTeacher.teach(..))")
public void begin(){}
@Pointcut("execution(* com.spring.aop.ChineseTeacher.classOver(..))")
public void over(){}

@Before("begin()")
public void beforeTest(){
System.out.println("班长：上课！
童鞋们：老师好！");
}
@Around("begin()")
public void aroundTest(ProceedingJoinPoint p){
try {
System.out.println("叮铃铃~");
p.proceed();//继续执行连接点的方法，如果不写表示不调用这个连接点的方法
} catch (Throwable e) {
System.out.println("自习ing");//上课出错则自习
}
}
@Before("over()")
public void ringTest(){
System.out.println("叮铃铃~");
}
@After("over()")
public void afterTest(){
System.out.println("班长：下课！
童鞋们：老师再见！");
}
}

package com.spring.aop;

import org.springframework.stereotype.Component;

@Component
public class ChineseTeacher implements Teacher{
    @Override
    public void teach() {
        System.out.println("同学们好，今天我们来学习一首诗《锄禾》...");
    }
    public void classOver(){
        System.out.println("今天先讲到这里，同学们下课！");
    }
}

package com.spring.test;

import org.junit.Test;
import org.junit.contrib.java.lang.system.StandardOutputStreamLog;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.spring.aop.Teacher;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=com.spring.config.CreatureSpingConfig.class)
public class SpringJunit {
public static StandardOutputStreamLog log=new StandardOutputStreamLog();
@Autowired
private Teacher t;
    @Test
    public void notNull() {
        t.teach();
        System.out.println("45分钟后...");
        t.classOver();
    }
}

---

XML：

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:c="http://www.springframework.org/schema/c"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:conditional="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
    http://www.springframework.org/schema/jdbc 
    http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/jee 
    http://www.springframework.org/schema/jee/spring-jee.xsd
    http://www.springframework.org/schema/conditional 
    http://www.springframework.org/schema/conditional/spring-conditional.xsd">
    <context:annotation-config ></context:annotation-config>
    <bean id="chineseTeacher" class="com.spring.aop.ChineseTeacher"></bean>
    <bean id="sophomore" class="com.spring.aop.Sophomore"></bean>
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <aop:config>
        <aop:aspect ref="sophomore">
            <aop:pointcut expression="execution(* com.spring.aop.ChineseTeacher.teach(..))" id="begin()"/>
            <aop:pointcut expression="execution(* com.spring.aop.ChineseTeacher.classOver(..))" id="over()"/>
            <aop:around method="aroundTest" pointcut-ref="begin()"/>
            <aop:before method="beforeTest()" pointcut-ref="begin()"/>
            <aop:before method="ringTest()" pointcut-ref="over()"/>
            <aop:after method="afterTest()" pointcut-ref="over()"/>
        </aop:aspect>
    </aop:config>
</beans>

配置类：

package com.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages={"com.spring"})
@EnableAspectJAutoProxy
public class SpringConfig {
}

学生实现类：

package com.spring.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
public class Sophomore implements Student{
public void beforeTest(){
System.out.println("班长：上课！
童鞋们：老师好！");
}
public void aroundTest(ProceedingJoinPoint p){
try {
System.out.println("叮铃铃~");
p.proceed();//继续执行连接点的方法，如果不写表示不调用这个连接点的方法
} catch (Throwable e) {
System.out.println("自习ing");//上课出错则自习
}
}
public void ringTest(){
System.out.println("叮铃铃~");
}
public void afterTest(){
System.out.println("班长：下课！
童鞋们：老师再见！");
}
}

教师实现类：

package com.spring.aop;

public class ChineseTeacher implements Teacher{
    public void teach() {
        System.out.println("同学们好，今天我们来学习一首诗《锄禾》...");
    }
    public void classOver(){
        System.out.println("今天先讲到这里，同学们下课！");
    }
}

测试：

package com.spring.aop;

import org.junit.Test;
import org.junit.contrib.java.lang.system.StandardOutputStreamLog;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.spring.aop.Teacher;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="/spring.xml")
public class SpringJunit {
public static StandardOutputStreamLog log=new StandardOutputStreamLog();
@Autowired
private Teacher t;
    @Test
    public void notNull() {
        t.teach();
        System.out.println("45分钟后...");
        t.classOver();
    }
}

结果：

 总结：

1. @Aspect需要导入aspectjrt.jar;
2. 在配置类或xml配置文件中应配置@EnableAspectJAutoProxy或<aop:aspectj-autoproxy/>
3. 需要引入aopaliance.jar，否则会报错：java.lang.ClassNotFoundException: org.aopalliance.intercept.MethodInterceptor
4. 需要引入aspectjweaver.jar，否则会报错：java.lang.ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException
5. 过程中可能出现如下异常:java.lang.IllegalArgumentException: error at ::0 can't find referenced pointcut teach，原因是：aspectjrt.jar版本与jdk版本不一致，解决办法参考：http://www.cnblogs.com/xing901022/p/4267563.html
6. jar包下载地址：http://mavenrepository.com/
7. JavaConfig方式中：before方法的优先级比around低
8. execution(* com.spring.aop.ChineseTeacher.teach(..))扩展

   AOP支持的AspectJ切入点指示符如下：

            execution：用于匹配方法执行的连接点；

            within：用于匹配指定类型内的方法执行；

            this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；

            target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；

            args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；

            @within：用于匹配所以持有指定注解类型内的方法；

            @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；

            @args：用于匹配当前执行的方法传入的参数持有指定注解的执行；

            @annotation：用于匹配当前执行方法持有指定注解的方法；

            bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法；

            reference pointcut：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持。

          AspectJ切入点支持的切入点指示符还有： call、get、set、preinitialization、staticinitialization、initialization、handler、adviceexecution、withincode、cflow、cflowbelow、if、@this、@withincode；但Spring AOP目前不支持这些指示符，使用这些指示符将抛出IllegalArgumentException异常。这些指示符Spring AOP可能会在以后进行扩展。

9. XML方式中，执行顺序是自上而下，与JavaConfig方式不同；
10. XML方式中，在<aop:around>标签中，method方法不需加()，无参方法可以，如果是around方法，必须有ProceedingJoinPoint类的参数，因此会报错：

    Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name '(inner bean)#1d03f44': Initialization of bean failed; nested exception is java.lang.IllegalArgumentException: Unable to locate method [aroundTest()] on bean [sophomore]
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:547)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:475)
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveInnerBean(BeanDefinitionValueResolver.java:276)
    ... 65 more