面向切面编程AOP实战

先了解AOP的相关术语:
1.通知(Advice):
通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。
2.连接点(Joinpoint):
程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。
3.切入点(Pointcut)
通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正则表达式来指定
4.切面(Aspect)
通知和切入点共同组成了切面：时间、地点和要发生的“故事”
5.引入(Introduction)
引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）
6.目标(Target)
即被通知的对象，如果没有AOP,那么它的逻辑将要交叉别的事务逻辑，有了AOP之后它可以只关注自己要做的事
7.代理(proxy)
应用通知的对象，详细内容参见设计模式里面的代理模式
8.织入(Weaving)
把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:
(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器
(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码

(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术

有4种切面实现方式，我们这里只讲使用比较方便的注解式

用@Aspect注解方式实现AOP编程：

1. 添加dependency

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>2.5.6</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>2.5.6</version>
</dependency>

2. 在bean注入的XML文件中打开aspect代理，这样spring才支持以@Aspec注解的方式实现切面编程

    <aop:aspectj-autoproxy />
    <context:annotation-config />
    <context:component-scan base-package="galaxy.com.aspect" />

3. 切面类的实现，以@Aspect注解方式

@Aspect
@Component
public class NormalAspect {
    @Before("execution(* *.say())")
    public void turnDown(){
        System.out.println("before speak, drink water...");
    }


    @After("execution(* *.say())")
    public void say(){
        System.out.println("after speak, drink beer...");
        System.out.println("=================");
    }

   //运行所有run()方法的时候做环绕切
    @Around("execution(* *.run())")
    public Object aroundSleep(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();// 拦截的方法
        Class<? extends Object> target = pjp.getTarget().getClass();
        String className = target.getSimpleName();// 拦截的类名
        String methodName = method.getName();// 拦截的方法名


        if ((method.getModifiers() & Modifier.PUBLIC) == 0) {
            return pjp.proceed();
        }


        Long start = System.currentTimeMillis();
        System.out.println("start:"+ start);

        //代理执行run()方法
        Object obj = pjp.proceed();
        Long end = System.currentTimeMillis();
        System.out.println("end:" + end);
        System.out.println("cost time:" + (end - start));
        System.out.println("=================");
        return obj;
    }
}

备注： 关于execution表达式详解请参见

http://blog.csdn.net/somilong/article/details/74568223

4. 接口

public interface Action {
    void say();
    void run();
}

5. 接口实现类

@Component("dog")
public class Dog implements Action {


    @Override
    public void say() {
        System.out.println("dog bark!");
    }


    @Override
    public void run() {
        try {
            System.out.println("dog run!");
            Thread.currentThread().sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6. Junit测试切面

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
    "classpath:/beans/spring-aspect-scan.xml"
})
public class BaseTest {

}

public class ActionAspectTest extends BaseTest{
    @Resource(name = "dog")
    private Action dog;

    @Test
    public void testAction(){
        dog.say();
        dog.run();
    }
}

7.结果展示

before speak, drink water...
dog bark!
after speak, drink beer...
=================
start:1480858905528
dog run!
end:1480858905530
cost time:2
=================