AOP (Aspect Orient Programming)，一般称为面向切面编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP 实现的关键在于 AOP 框架自动创建的 AOP 代理，AOP 代理主要分为静态代理和动态代理。静态代理的代表为Aspectj，动态代理则以 Spring AOP 为代表。静态代理是编译期实现的，动态代理是运行期实现的。

静态代理-Aspectj

1、在 pom 文件中添加 aspectj 的核心依赖包

<dependency>
    <groupId>aspectj</groupId>
    <artifactId>aspectjtools</artifactId>
    <version>1.8.10</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.6.12</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.7.4</version>
</dependency>

2、新建文件处创建aspectJ文件，然后就可以像运行java文件一样，操作aspect文件了

3、编写一个HelloWord的类，然后利用AspectJ技术切入该类的执行过程

public class HelloWord {

    public void sayHello(){
        System.out.println("hello world !");
    }
    
    public static void main(String args[]){
        HelloWord helloWord =new HelloWord();
        helloWord.sayHello();
    }

}

4、编写AspectJ类，注意关键字为aspect(MyAspectJDemo.aj,其中aj为AspectJ的后缀)，含义与class相同，即定义一个AspectJ的类

/**
 * 切面类
 */
public aspect MyAspectJDemo {
    /**
     * 定义切点,日志记录切点
     */
    pointcut recordLog():call(* HelloWord.sayHello(..));

    /**
     * 定义切点,权限验证(实际开发中日志和权限一般会放在不同的切面中,这里仅为方便演示)
     */
    pointcut authCheck():call(* HelloWord.sayHello(..));

    /**
     * 定义前置通知!
     */
    before():authCheck(){
        System.out.println("sayHello方法执行前验证权限");
    }

    /**
     * 定义后置通知
     */
    after():recordLog(){
        System.out.println("sayHello方法执行后记录日志");
    }
}

5、运行 HelloWorld 的 main 函数：

对于结果不必太惊讶，完全是意料之中。我们发现，明明只运行了main函数，却在 sayHello 函数运行前后分别进行了权限验证和日志记录，事实上这就是AspectJ的功劳。

Aspectj 主要采用的是编译期织入，在这个期间使用 Aspectj 的 acj 编译器（类似javac）把 aspect 类编译成 class 字节码后，在 java 目标类编译时织入，即先编译 aspect 类再编译目标类。

动态代理-Spring AOP

Spring AOP 中的动态代理主要有两种方式，JDK 动态代理和 CGLIB 动态代理。JDK 动态代理通过反射来接受被代理的类，并且要求被代理的类必须实现一个接口。JDK 动态代理的核心是 InvocationHandler 接口和 Proxy 类。
如果目标没有实现接口，那么Spring AOP 会选择使用 CGLIB 来动态代理目标类。CGLIB（Code Generration Library）是一个代码生成的类库，可以在运行时动态的生成某个类的子类，注意，CGLIB 是通过继承的方式做的动态代理，因此如果某个类被标记为 finnal，那么它是无法使用 CGLIB 做动态代理的，诸如 private 方法也是不可以作为切面的。

• 直接使用 Spring AOP
  1、首先定义需要切入的接口和实现。为了简单起见，定义一个
  Speakable 接口和一个具体的实现类，只有两个方法sayHi()和sayBye()；

public interface Speakable {
    void sayHi();
    void sayBye();
}

@Service
public class PersonSpring implements Speakable {

    @Override
    public void sayHi() {
        try {
            Thread.currentThread().sleep(30);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("Hi!!");
    }

    @Override
    public void sayBye() {
        try {
            Thread.currentThread().sleep(10);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("Bye!!");
    }
}

2、接下来我们希望实现一个记录 sayHi() 和 sayBye() 执行时间的功能；
定义一个 MethodMonotor 类用来记录 Method 执行时间

public class MethodMonitor {

    private long start;
    private String method;

    public MethodMonitor(String method) {
        this.method = method;
        System.out.println("begin monitor..");
        this.start = System.currentTimeMillis();
    }

    public void log() {
        long elapsedTime = System.currentTimeMillis() - start;
        System.out.println("end monitor..");
        System.out.println("Method: " + method + ", execution time: " + elapsedTime + " milliseconds.");
    }
}

光有这个类还是不够的，希望有个静态方法用起来更顺手，像这样:

MonitorSession.begin();
doWork();
MonitorSession.end();

定义一个 MonitorSession:

public class MonitorSession {

    private static ThreadLocal<MethodMonitor> monitorThreadLocal = new ThreadLocal<>();

    public static void begin(String method) {
        MethodMonitor logger = new MethodMonitor(method);
        monitorThreadLocal.set(logger);
    }

    public static void end() {
        MethodMonitor logger = monitorThreadLocal.get();
        logger.log();
    }
}

3、万事俱备，接下来只需要我们做好切面的编码；

@Aspect
@Component
public class MonitorAdvice {

    @Pointcut("execution (* com.deanwangpro.aop.service.Speakable.*(..))")
    public void pointcut() {
    }

    @Around("pointcut()")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        MonitorSession.begin(pjp.getSignature().getName());
        pjp.proceed();
        MonitorSession.end();
    }
}

4、如何使用呢？我用了spring boot 写一个启动函数；

@SpringBootApplication
public class Application {

    @Autowired
    private Speakable personSpring;
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
        return args -> {
            // spring aop
            System.out.println("******** spring aop ******** ");
            personSpring.sayHi();
            personSpring.sayBye();
            System.exit(0);
        };
    }
}

运行后输出：

******** jdk dynamic proxy ******** 

begin monitor..

Hi!!
end monitor..
Method: sayHi, execution time: 32 milliseconds.
begin monitor..
Bye!!
end monitor..

Method: sayBye, execution time: 22 milliseconds.

• 使用 JDK 动态代理
  刚刚的例子其实内部实现机制就是 JDK 动态代理，因为 Person 实现了一个接口。
  为了不和第一个例子冲突，我们再定义一个 Person 来实现 Speakable，这个实现不带 Spring Annotation，所以他不会被Spring 管理。

public class PersonImpl implements Speakable {

    @Override
    public void sayHi() {
        try {
            Thread.currentThread().sleep(30);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("Hi!!");
    }

    @Override
    public void sayBye() {
        try {
            Thread.currentThread().sleep(10);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("Bye!!");
    }
}

重头戏来了，我们需要利用 InvocationHandler 实现一个代理，让它去包含 Person 这个对象，那么在运行期实际上是执行这个代理的方法，然后代理再去执行真正的方法。所以我们得以在执行真正方法的前后做一些手脚。JDK 动态代理是利用反射实现的，直接看代码。

public class DynamicProxy implements InvocationHandler {

    // 被代理对象
    private Object target;

    public DynamicProxy(Object object) {
        this.target = object;
    }
    
     /**
      *  被代理对象 target 调用其自身方法时执行 invoke
      */
    @Override
    public Object invoke(Object arg0, Method arg1, Object[] arg2)
            throws Throwable {
        MonitorSession.begin(arg1.getName());
        Object obj = arg1.invoke(target, arg2);
        MonitorSession.end();
        return obj;
    }

    /**
     * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数：
     * 1、target.getClass.getClassLoader()，我们这里使用 target 这个类的ClassLoader对象来加载我们的代理对象
     * 2、target.getClass().getInterfaces()，我们这里为真实对象所实现的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
     * 3、InvocationHandler，动态代理类
     *
     *  由于第二个参数只接受接口，所以这就是 JDK 动态代理的局限性，只支持接口。
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }
}

通过 getProxy 可以得到这个代理对象，invoke 就是具体的执行方法，并且被代理对象 target 调用其自身方法时都会执行 invoke，于是我们可以在执行每个真正的方法前后做一些手脚，如 Monitor。
具体使用：

// jdk dynamic proxy
System.out.println("******** jdk dynamic proxy ******** ");
DynamicProxy dynamicProxy = new DynamicProxy(new PersonImpl());
Speakable jdkProxy = dynamicProxy.getProxy();
jdkProxy.sayHi();
jdkProxy.sayBye();

输出结果：

******** jdk dynamic proxy ******** 

begin monitor..
Hi!!
end monitor..
Method: sayHi, execution time: 32 milliseconds.
begin monitor..
Bye!!
end monitor..
Method: sayBye, execution time: 22 milliseconds.

• 使用 CGLIB 动态代理
  我们新建一个 Person 类，这次不实现任何接口。

public class Person {

    public void sayHi() {
        try {
            Thread.currentThread().sleep(30);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("Hi!!");
    }

    public void sayBye() {
        try {
           Thread.currentThread().sleep(10);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("Bye!!");
    }
}

如果Spring 识别到所代理的类没有实现 Interface，那么就会使用 CGLib 来创建动态代理，原理实际上是成为被代理类的子类，这时候代理类必须实现一个接口 MethodInterceptor；

public class CGLibProxy implements MethodInterceptor {
    private static CGLibProxy instance = new CGLibProxy();
    private Enhancer enhancer = new Enhancer();

    private CGLibProxy() {
    }

    public static CGLibProxy getInstance() {
        return instance;
    }
   
    /**
     * 根据传进来的 Class，获取其代理类，该代理类继承 Class
     * @param clazz
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public  <T> T getProxy(Class<T> clazz) {
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return (T) enhancer.create();
    }

    /**
     * 类似于 JDK 动态代理的 {@link InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])}
     * @param arg0
     * @param arg1
     * @param arg2
     * @param arg3
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2,
                            MethodProxy arg3) throws Throwable {
        MonitorSession.begin(arg1.getName());
        Object obj = arg3.invokeSuper(arg0, arg2);
        MonitorSession.end();
        return obj;
    }
}

类似的，通过 getProxy 可以得到这个代理对象，intercept 就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了 Monitor。
具体使用：

        // cglib dynamic proxy
        System.out.println("******** cglib proxy ******** ");
        CGLibProxy cgLibProxy = CGLibProxy.getInstance();
        Person proxy = cgLibProxy.getProxy(Person.class);
        proxy.sayHi();
        proxy.sayBye();

输出结果：

begin monitor..
Hi!!
end monitor..
Method: sayHi, execution time: 53 milliseconds.
begin monitor..
Bye!!
end monitor..
Method: sayBye, execution time: 14 milliseconds.

小结

对比 JDK 动态代理和 CGLib 代理，在实际使用中发现 CGLib 在创建对象时所花的时间比 JDK 动态代理要长，实测数据：

Method: newJdkProxy, execution time: 5 milliseconds.
Method: newCglibProxy, execution time: 18 milliseconds.

所以 CGLib 更适合代理不需要频繁实例化的类。同时，JDK 动态代理就是 Java 设计模式中代理模式的一个实现。