（未完成）【Spring专题】SringAOP底层原理解析——阶段三（AOP）

前言

前置知识

代理范式

什么是代理模式？代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。
少年可曾听闻【代理范式】？它的伪代码一般如下：（Cglib动态代理采用的方案）

class 被代理类 {
	function 方法A();
}

class 代理类 <<继承>> 被代理类 {
	被代理类 targetObject;
	
	@Override
	function 方法A() {
		// 这里写被加强的逻辑
		targetObject.方法A();
		// 也可以在这里写
	}
}

或者用java代码表示如下：

// 被代理对象
public class ProxyTarget {
    public void run() {
        System.out.println("这是普通对象的run");
    }
}


// 代理对象
public class ProxyModel extends ProxyTarget {
    private ProxyTarget proxyTarget;

    public void setProxyTarget(ProxyTarget proxyTarget) {
        this.proxyTarget = proxyTarget;
    }

    @Override
    public void run() {
        System.out.println("我代理对象可以在这里做加强---1");
        super.run();
        System.out.println("我代理对象也可以在这里做加强---2");
    }
}

但是，代理模式的实现其实还有一种，但前提是被代理的类存在接口。它的代理范式伪代码如下：（JDK动态代理采用的方案）

class 被代理类 <<实现>> 接口A {
	function 实现自接口A的方法();
}

class 代理类 <<实现>> 接口A {
	被代理类 targetObject;
	
	@Override
	function 实现自接口A的方法() {
		// 这里写被加强的逻辑
		targetObject.方法A();
		// 也可以在这里写
	}
}

Spring动态代理的实现

我把它放到【课程内容】里面了，因为我怕大家不重视

课程内容

一、动态代理的实现

我相信有经验的朋友，应该都知道，我们Java里面通常使用的代理方式有两种，分别为：JDK动态代理，以及Cglib动态代理。下面就给大家简单演示一下，这两种动态代理的简单使用示例。
在言是两种代理之前，需要一个基础类。如下：

@Component
public class UserService {

    public void test() {
        System.out.println("这是UserService的一个普通方法");
    }
}

在开始代理之前，再次重申一下为什么需要代理？
代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。
就是，当我们需要增强某个方法的，又不想修改原有代码的时候（遵守设计原则里面的：开闭原则），一般就会考虑使用代理。在Spring里面就使用了下面两种方案来实现这个代理模式。

1.1 Cglib动态代理

在上面的UserService，如果我们new一个UserService对象，然后执行test()方法，结果是显而易见的。如果我们现在想在不修改UserService类的源码前提下，给test()增加额外逻辑，那么就可以使用Cglib动态代理机制来创建UserService对象了，比如：

 public static void main(String[] args) throws IOException {
        UserService target = new UserService();
        target.test();


        System.out.println("下面开始是cglib之后的逻辑了");

        // cglib
        {
            // 使用cglib增强类
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(UserService.class);

            // 定义额外的增强逻辑，增强对象
            enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    System.out.println("before...");
                    Object result = methodProxy.invoke(target, objects);
                    System.out.println("after...");
                    return result;
                }
            }});

            // 动态代理所创建出来的UserService对象
            UserService userService = (UserService) enhancer.create();

            // 执行这个userService的test方法时，就会额外会执行一些其他逻辑
            userService.test();
        }
    }

得到的都是UserService对象，但是执行test()方法时的效果却不一样了，这就是代理所带来的效果。
上面是通过cglib来实现的代理对象的创建，是基于父子类的，被代理类（UserService）是父类，代理类是子类，代理对象就是代理类的实例对象，代理类是由cglib创建的，对于程序员来说不用关心。

1.2 JDK动态代理

除开cglib技术，jdk本身也提供了一种创建代理对象的动态代理机制，但是它只能代理接口，也就是UserService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象，比如：

public interface UserInterface {
    void test();
}

public class UserService implements UserInterface{

    @Override
    public void test() {
        System.out.println("这是UserService的一个普通方法");
    }
}

利用JDK动态代理来生成一个代理对象的示例如下：

 public static void main(String[] args) throws IOException {
        UserService target = new UserService();
        target.test();

        System.out.println("下面开始是cglib之后的逻辑了");

        // jdk代理
        {
            // UserInterface接口的代理对象
            Object proxy = Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]{UserInterface.class}, new InvocationHandler() {

                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("before...");
                    Object result = method.invoke(target, args);
                    System.out.println("after...");
                    return result;
                }
            });

            UserInterface userService = (UserInterface) proxy;
            userService.test();
        }
    }

如果你把new Class[]{UserInterface.class}，替换成new Class[]{UserService.class}，代码会直接报错：（这也证明了JDK采用的是第二种代理范式）

java.lang.IllegalArgumentException: UserService is not an interface

由于这个限制，所以产生的代理对象的类型是UserInterface，而不是UserService，这是需要注意的。

1.3 ProxyFactory：Spring对两种代理的封装

上面我们介绍了两种动态代理技术，那么在Spring中对它们进行了封装，封装出来的类叫做ProxyFactory，表示是创建代理对象的一个工厂，使用起来会比上面的更加方便，比如：

    public static void main(String[] args) throws IOException {
        UserService target = new UserService();

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice(new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...");
                Object result = invocation.proceed();
                System.out.println("after...");
                return result;
            }
        });

        UserInterface userService = (UserInterface) proxyFactory.getProxy();
        userService.test();
    }

通过ProxyFactory，我们可以不再关心到底是用cglib还是jdk动态代理了，ProxyFactory会帮我们去判断，如果UserService实现了接口，那么ProxyFactory底层就会用jdk动态代理；如果没有实现接口，就会用cglib技术，上面的代码，就是由于UserService实现了UserInterface接口，所以最后产生的代理对象是UserInterface类型。

二、AOP基础知识

2.1 AOP基础概念回顾

2.2 SpringAOP实现方式的发展历程

三、底层源码解析

3.1 概念回顾

3.2 核心方法讲解

学习总结