Spring AOP的一点总结

2016-09-12 本文已影响560人郭寻抚

1. Spring AOP介绍

AOP(Aspect-Oriented Programming)，面向切面的编程，是OOP（面向对象的编程）的重要补充，所谓AOP，就是在执行Java类中的方法前或后加入自定义方法。Spring AOP是Spring的一个重要组成部分，和IoC并称为Spring的两大基础组件。关于Spring Ioc可以访问http://www.jianshu.com/p/6178ba063553。

spring-aop.png

1.1 小明搬砖的故事

小明每天都要上班、搬砖、下班。现在，小明的老婆每天在他上班搬砖之前，检查他是否带了公交卡；小明的儿子每天在搬砖下班之后讨要零花钱。小明只管搬砖挣钱即可，老婆检查公交卡和儿子讨要零花钱对搬砖挣钱这个事不会产生任何影响，该挣多少钱还挣多少钱；只是搬砖回来后，儿子会讨要零花钱，减少小明挣到的工资。

接下来我们使用OOP和AOP的思想来考虑小明搬砖的故事。根据OOP的思想，小明就是一个对象，他具有上班、搬砖、下班等三个行为。根据AOP的思想，小明老婆在小明执行搬砖挣钱前做出门检查，小明儿子在小明执行搬砖挣钱后讨要零花钱，这两者都不会改变小明调用搬砖挣钱的方法，但可能会影响其结果。

1.2 AOP使用的场景

AOP用来封装横切关注点，具体可以在下面的场景中使用。

Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading　懒加载
Debugging　　调试
logging，tracing，profiling and monitoring　记录跟踪　优化　校准
Performance optimization　性能优化
Persistence　　持久化
Resource pooling　资源池
Synchronization　同步
Transactions 事务

1.3 AOP的相关概念

1. 切面（Aspect）：切面是通知和切点的结合。通知和切点共同定义了切面的全部内容———他是什么，在何时和何处完成其功能。

2. 通知（Advice）：在AOP中，切面的工作被称为通知。通知定义了切面“是什么”以及“何时”使用。除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。Spring切面可以应用5种类型的通知：

前置通知（Before）：在目标方法被调用之前调用通知功能
后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么
返回通知（After-returning）：在目标方法成功执行之后调用通知
异常通知（After-throwing）：在目标方法抛出异常后调用通知
环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为

3. 切点（Pointcut）：如果说通知定义了切面“是什么”和“何时”的话，那么切点就定义了“何处”。比如我想把日志引入到某个具体的方法中，这个方法就是所谓的切点。

4. 连接点（Join Point）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。在Spring AOP中，一个连接点总是表示一个方法的执行。

5. 引入（Introduction）：添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知，通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口。

6. 织入（Weaving）：把切面应用到目标对象来创建新的代理对象的过程添加方法或字段到被通知的类。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring AOP，在运行时完成织入。

7. 目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。

8. AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理，本文会在下文讲述这两种动态创建代理的方式。

2. 基于@Aspect的AOP编程实践

本节通过一个简单的例子，说明如何实现基于@Aspect的AOP编程实践。我们将在Controller执行方法的前后，输出一些日志。

2.1 pom.xml中引入AOP

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

2.2 HelloController

这个Controller就是我们选定的目标对象（Target Object），它的hello()方法就是连接点（Join Point）。

@RestController
public class HelloController {

  @RequestMapping(value = "/hello")
  public String hello(@RequestParam(value = "name", required = true) String name) {
    String result = "hello  " + name;
    System.out.println(result);
    return result;
  }

}

2.3 ApiAspect切面

@Component // 注册到Spring容器
@Aspect // 该注解标示该类为切面类，切面是由通知和切点组成的。
public class ApiAspect {
  
  //双引号中间的内容是PointCut（切点）表达式。@Before是前属通知
  @Before("execution(* com.example.controller.HelloController.*(..))")  
  public void before(){
    System.out.println("方法执行前执行.....before");  
  }

  //@Around是环绕通知，下面的通知看注解即可，不再写注释。
  @Around("execution(* com.example.controller.HelloController.*(..))")  
  public String around(ProceedingJoinPoint pjp) {
    System.out.println("方法环绕start....around.");
    String result = null;
    try {
      result = (String) pjp.proceed();
    } catch (Throwable e) {
      e.printStackTrace();
    }
    System.out.println("方法环绕end.....around");  
    return result;
  }
  
  @After("within(com.example.controller.*Controller)")
  public void after(){
    System.out.println("方法之后执行....after.");
  }
  
  @AfterReturning("within(com.example.controller.*Controller)")
  public void afterReturning(){
    System.out.println("方法执行完执行.....afterReturning");  
  }
  
  @AfterThrowing("within(com.example.controller.*Controller)")
  public void afterThrowing(){
    System.out.println("异常出现之后.....afterThrowing");  
  }

}

启动Spring Boot工程，访问http://localhost:8080/hello?name=world ，控制台输出以下结果。

方法环绕start....around.
方法执行前执行.....before
hello  world
方法环绕end.....around
方法之后执行....after.
方法执行完执行.....afterReturning

本节通过一个例子，说明了如果基于@Aspect实现AOP编程，并在过程中体现了AOP概念中切面、切点、通知、连接点和目标对象。AOP的动态织入和AOP的代理将通过下文的两节描述。分别是Java动态代理和cglib动态代理，前者是基于接口动态生成代理类，后者是通过子类生成动态代理类。

3. Java动态代理

代理模式是一种常用的Java设计模式，它的特征是代理类和委托类实现了同样的接口，代理类负责预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类并不实现真正的服务，而是调用委托类的方法来提供特定的服务。

所谓动态代理，就是在程序运行时，运用反射机制动态创建代理类。其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。其中，Proxy类主要用来获取动态代理对象；InvocationHandler接口用来约束调用者实现。

要想使用Java动态代理，委托类、或者说是被代理的对象（target），必须是一个接口的实现类。

3.1 Java动态代理的使用

下面是Java动态代理的一个示例，说明见代码中的注释内容。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Main {

  public static void main(String[] args) {
    // 实例化 target
    IHello hello = new Hello();
    // 实例化InvocationHandler
    DynamicProxyHandler handler = new DynamicProxyHandler(hello);
    // 通过Proxy类生成代理对象
    IHello proxy = (IHello) Proxy.newProxyInstance(hello.getClass().getClassLoader(),
        hello.getClass().getInterfaces(), handler);
    // 调用代理对象的方法
    proxy.sayHello("world");
  }
}


/**
 * JDK动态代理要实现 InvocationHandler 接口。
 */
class DynamicProxyHandler implements InvocationHandler {
  // 目标对象
  private Object target;

  /**
   * 构造方法
   * 
   * @param target 目标对象
   */
  public DynamicProxyHandler(Object target) {
    super();
    this.target = target;
  }

  /**
   * 执行目标对象target的方法
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object result = null;
    try {
      System.out.println(method.getName() + " Method start .");
      result = method.invoke(target, args);
      System.out.println(method.getName() + " Method end .");
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }
  
  /** 
   * 获取目标对象的代理对象 
   * @return 代理对象 
  public Object getProxy() {  
      return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),   
              target.getClass().getInterfaces(), this);  
  } 
  */  

}

/**
 * target实现的接口，用JDK动态代理生成的对象一定要实现一个接口
 */
interface IHello {
  // target method
  public void sayHello(String name);
}

/**
 * 被代理的target
 */
class Hello implements IHello {
  @Override
  public void sayHello(String name) {
    System.out.println("hello," + name);
  }

}

执行结果如下

sayHello Method start .
hello,world
sayHello Method end .

3.2 谁调用了invoke方法

DynamicProxyHandler中实现了InvocationHandler的invoke方法，表面上看不到是谁调用了。事实上，invok方法最终是由生成的动态代理类调用的，下面的代码使用了sun.misc.ProxyGenerator把生成的动态代理类的字节码写到了磁盘上。通过反编译生成的字节码，我们就可以清晰地看到调用InvocationHandler的invoke方法的过程。

sun.misc.ProxyGenerator存在于JDK中，路径是${JAVA_HOME}/jre/lib/rt.jar中; JRE中没有这个类。如果你的工程里无法import该类，请修改JRE System Library到你的JDK目录。

下面的代码，把Hello.class的动态代理字节码写到了d:/logs/HelloProxy.class。

public class ProxyGeneratorUtils {
  
  public static void main(String[] args) {
    // 把Hello.class的动态代理类的字节码保存到d:/logs/HelloProxy.class
    ProxyGeneratorUtils.writeProxyClassToHardDisk("d:/logs/HelloProxy.class");
  }
  
  
  /**
   * 把代理类的字节码写到磁盘
   * 
   * @param path 保存路径
   */
  public static void writeProxyClassToHardDisk(String path) {
    // 获取代理类的字节码
    byte[] classFile = ProxyGenerator.generateProxyClass("HelloProxy",
             Hello.class.getInterfaces());
    FileOutputStream out = null;
    try {
      out = new FileOutputStream(path);
      out.write(classFile);
      out.flush();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        out.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

下面是HelloProxy.class的主要内容，可以看到生成的动态代理类HelloProxy和Hello一样实现了IHello接口。HelloProxy继承了Proxy类，Java不允许类多继承，这也是“JDK动态代理时，委托类必须实现一个接口”的原因。

public final class HelloProxy extends Proxy implements IHello {

  private static Method m3;

  static {
    // 被调用的方法
     m3 = Class.forName("aop.IHello").getMethod("sayHello",
      new Class[] {Class.forName("java.lang.String")});
  }
  // 此处为上述实现的DynamicProxyHandler
  public HelloProxy(InvocationHandler paramInvocationHandler) {
    super(paramInvocationHandler);
  }
  //invoke方法就是在这里被调用的。
  public final void sayHello(String paramString) {
    try {
      this.h.invoke(this, m3, new Object[] {paramString});
      return;
    } catch (Error | RuntimeException localError) {
      throw localError;
    } catch (Throwable localThrowable) {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
｝

3.3 InvocationHandler接口

InvocationHandler仅有一个方法，即invoke方法，它接受三个参数。proxy是代理类的实例；method是委托类被调用的方法；args是传入method的参数。

 public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;

3.4 Proxy类

Proxy类的使命就是为了获取代理对象，在上面的例子中，我们就是使用它的newProxyInstance方法,获取到了代理对象。其主要代码如下。

/**
 *loader： 类加载器
 *interfaces：target实现的接口
 *h：InvocationHandler的实现类 
 */
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,
   InvocationHandler h)throws IllegalArgumentException {

    //查找或者生成动态代理类。动态代理类的生成是在ProxyGenerator中实现的。
    Class<?> cl = getProxyClass0(loader, intfs);

    // 调用代理对象的构造方法
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    // 把InvocationHandler实现类的实例传递到构造方法中
    final InvocationHandler ih = h;
    if (!Modifier.isPublic(cl.getModifiers())) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                cons.setAccessible(true);
                return null;
            }
        });
    }
    // 返回生成的代理类的实例。
    return cons.newInstance(new Object[]{h});
 }

4. cglib动态代理

JDK动态代理使用简单，但存在着委托类必须实现一个或者多个接口；如果委托类没有实现接口，而又要代理它，就可以使用CGLIB包。Spring AOP同时使用JDK动态代理和cglib；默认情况下，实现接口的类使用JDK动态代理；没有实现接口的类，使用cglib。

cglib通过使用字节码处理框架ASM(Java字节码操控框架)，来转换字节码并生成新的类；其原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

下面是使用cglib的例子。

public class CglibMain {
  public static void main(String[] args) {
    // 实例化 target，没有使用接口
    Hello hello = new Hello();
    // 实例化CglibProxy
    MyCglibProxy cglib = new MyCglibProxy();
    // 通过cglib获取代理对象
    Hello proxy = (Hello) cglib.getInstance(hello);
    // 调用代理对象的方法
    proxy.sayHello("world");
  }
}


class MyCglibProxy implements MethodInterceptor {
  // 被代理的对象
  private Object target;

  /**
   * 创建代理对象
   */
  public Object getInstance(Object target) {
    this.target = target;
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(this.target.getClass());
    // 回调方法
    enhancer.setCallback(this);
    // 创建代理对象
    return enhancer.create();
  }

  @Override
  public Object intercept(Object obj, Method method,
      Object[] args, MethodProxy methodProxy) throws Throwable {
    System.out.println(method.getName() + " before-----------");
    // 生成的代理对象是委托类的子类，因此调用了super method
    Object result = methodProxy.invokeSuper(obj, args);
    System.out.println(method.getName() + " after-----------");
    return result;
  }

}

结果输出如下。

sayHello before-----------
Hello, world
sayHello after-----------

5. 总结

以上是对Spring AOP的总结，我们记录AOP的概念、应用场景，编写了一个AOP的小例子，并分析了动态代理的生成过程。动态代理的生成过程对应Spring中源代码分别是JdkDynamicAopProxy和CglibAopProxy，它们的package都是org.springframework.aop.framework，在spring-aop-*.jar中。

http://blog.csdn.net/moreevan/article/details/11977115
http://rejoy.iteye.com/blog/1627405
http://blog.csdn.net/xiaohai0504/article/details/6832990