Java：由浅入深揭开 AOP 实现原理

1@Target(AnnotationTarget.FUNCTION)
2//注解作用的范围，这里声明为函数
3@Order(Ordered.HIGHEST_PRECEDENCE)
4//声明注解的优先级为最高，假设有多个注解，先执行这个
5annotation class Hanler(val handler: HandlerType)
6//自定义注解类，HandlerType是一个枚举类型，里面定义的就是学生和老师的增删改操作，在这里就不展示具体内容了

 1@Aspect   //该注解声明这个类为一个切面类
 2@Component
 3class HandlerAspect{
 4
 5 @Autowired
 6 private lateinit var handlerService: HandlerService
 7
 8@AfterReturning("@annotation(handler)") //当有函数注释了注解，将会在函数正常返回后在执行我们定义的方法
 9fun hanler(hanler: Hanler) {
10    handlerService.add(handler.operate.value) //这里是真正执行记录的方法
11}
12}

1/**
2* 删除学生方法
3*/
4@Handler(operate= Handler.STUDENT_DELETE) //当执行到删除学生方法时，切面类就会起作用了,当学生正常删除后就会执行记录方法，我们就可以看到记录方法生成的数据
5fun delete(id：String) {

1/**
2 * 创建person接口
3 */
4public interface Person {
5    //交作业
6    void giveTask();
7}

 1public class Student implements Person {
 2    private String name;
 3    public Student(String name) {
 4        this.name = name;
 5    }
 6
 7    public void giveTask() {
 8        System.out.println(name + "交语文作业");
 9    }
10}

 1/**
 2 * 学生代理类，也实现了Person接口，保存一个学生实体，这样就可以代理学生产生行为
 3 */
 4public class StudentsProxy implements Person{
 5    //被代理的学生
 6    Student stu;
 7
 8    public StudentsProxy(Person stu) {
 9        // 只代理学生对象
10        if(stu.getClass() == Student.class) {
11            this.stu = (Student)stu;
12        }
13    }
14
15    //代理交作业，调用被代理学生的交作业的行为
16    public void giveTask() {
17        stu.giveTask();
18    }
19}

 1public class StaticProxyTest {
 2    public static void main(String[] args) {
 3        //被代理的学生林浅，他的作业上交有代理对象monitor完成
 4        Person linqian = new Student("林浅");
 5
 6        //生成代理对象，并将林浅传给代理对象
 7        Person monitor = new StudentsProxy(linqian);
 8
 9        //班长代理交作业
10        monitor.giveTask();
11    }
12}

1/**
2 * 创建person接口
3 */
4public interface Person {
5    //交作业
6    void giveTask();
7}

 1public class Student implements Person {
 2    private String name;
 3    public Student(String name) {
 4        this.name = name;
 5    }
 6
 7    public void giveTask() {
 8        System.out.println(name + "交语文作业");
 9    }
10}

 1public class StuInvocationHandler<T> implements InvocationHandler {
 2    //invocationHandler持有的被代理对象
 3    T target;
 4
 5    public StuInvocationHandler(T target) {
 6        this.target = target;
 7    }
 8
 9    /**
10     * proxy:代表动态代理对象
11     * method：代表正在执行的方法
12     * args：代表调用目标方法时传入的实参
13     */
14    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
15        System.out.println("代理执行" +method.getName() + "方法");
16        Object result = method.invoke(target, args);
17        return result;
18    }

 1/**
 2 * 代理类
 3 */
 4public class ProxyTest {
 5    public static void main(String[] args) {
 6
 7        //创建一个实例对象，这个对象是被代理的对象
 8        Person linqian = new Student("林浅");
 9
10        //创建一个与代理对象相关联的InvocationHandler
11        InvocationHandler stuHandler = new StuInvocationHandler<Person>(linqian);
12
13        //创建一个代理对象stuProxy来代理linqian，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
14        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);
15
16        //代理执行交作业的方法
17        stuProxy.giveTask();
18    }
19}

 1public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
 2        throws IllegalArgumentException
 3    {
 4        Objects.requireNonNull(h);
 5
 6        final Class<?>[] intfs = interfaces.clone();
 7        final SecurityManager sm = System.getSecurityManager();
 8        if (sm != null) {
 9            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
10        }
11
12        /*
13         * Look up or generate the designated proxy class.
14         */
15        Class<?> cl = getProxyClass0(loader, intfs);
16
17        /*
18         * Invoke its constructor with the designated invocation handler.
19         */
20        try {
21            if (sm != null) {
22                checkNewProxyPermission(Reflection.getCallerClass(), cl);
23            }
24
25            final Constructor<?> cons = cl.getConstructor(constructorParams);
26            final InvocationHandler ih = h;
27            if (!Modifier.isPublic(cl.getModifiers())) {
28                AccessController.doPrivileged(new PrivilegedAction<Void>() {
29                    public Void run() {
30                        cons.setAccessible(true);
31                        return null;
32                    }
33                });
34            }
35            return cons.newInstance(new Object[]{h});
36        } catch (IllegalAccessException|InstantiationException e) {
37            throw new InternalError(e.toString(), e);
38        } catch (InvocationTargetException e) {
39            Throwable t = e.getCause();
40            if (t instanceof RuntimeException) {
41                throw (RuntimeException) t;
42            } else {
43                throw new InternalError(t.toString(), t);
44            }
45        } catch (NoSuchMethodException e) {
46            throw new InternalError(e.toString(), e);
47        }
48  }

 1byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Student.class.getInterfaces());
 2        String path = "/Users/mapei/Desktop/okay/65707.class";
 3
 4        try{
 5            FileOutputStream fos = new FileOutputStream(path);
 6            fos.write(classFile);
 7            fos.flush();
 8            System.out.println("代理类class文件写入成功");
 9        }catch (Exception e) {
10            System.out.println("写文件错误");
11        }

 1import java.lang.reflect.InvocationHandler;
 2import java.lang.reflect.Method;
 3import java.lang.reflect.Proxy;
 4import java.lang.reflect.UndeclaredThrowableException;
 5import proxy.Person;
 6
 7public final class $Proxy0 extends Proxy implements Person
 8{
 9  private static Method m1;
10  private static Method m2;
11  private static Method m3;
12  private static Method m0;
13
14  /**
15  *注意这里是生成代理类的构造方法，方法参数为InvocationHandler类型，看到这，是不是就有点明白
16  *为何代理对象调用方法都是执行InvocationHandler中的invoke方法，而InvocationHandler又持有一个
17  *被代理对象的实例，就可以去调用真正的对象实例。
18  */
19  public $Proxy0(InvocationHandler paramInvocationHandler)
20    throws 
21  {
22    super(paramInvocationHandler);
23  }
24
25  //这个静态块本来是在最后的，我把它拿到前面来，方便描述
26   static
27  {
28    try
29    {
30      //看看这儿静态块儿里面的住giveTask通过反射得到的名字m3，其他的先不管
31      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
32      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
33      m3 = Class.forName("proxy.Person").getMethod("giveTask", new Class[0]);
34      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
35      return;
36    }
37    catch (NoSuchMethodException localNoSuchMethodException)
38    {
39      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
40    }
41    catch (ClassNotFoundException localClassNotFoundException)
42    {
43      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
44    }
45  }
46
47  /**
48  *
49  *这里调用代理对象的giveMoney方法，直接就调用了InvocationHandler中的invoke方法，并把m3传了进去。
50  *this.h.invoke(this, m3, null);我们可以对将InvocationHandler看做一个中介类，中介类持有一个被代理对象，在invoke方法中调用了被代理对象的相应方法。通过聚合方式持有被代理对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。
51  */
52  public final void giveTask()
53    throws 
54  {
55    try
56    {
57      this.h.invoke(this, m3, null);
58      return;
59    }
60    catch (Error|RuntimeException localError)
61    {
62      throw localError;
63    }
64    catch (Throwable localThrowable)
65    {
66      throw new UndeclaredThrowableException(localThrowable);
67    }
68  }
69
70}

 1protected Object createProxy(
 2           Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
 3
 4       if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
 5           AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
 6       }
 7
 8       // 1.创建proxyFactory，proxy的生产主要就是在proxyFactory做的
 9       ProxyFactory proxyFactory = new ProxyFactory();
10       proxyFactory.copyFrom(this);
11
12       if (!proxyFactory.isProxyTargetClass()) {
13           if (shouldProxyTargetClass(beanClass, beanName)) {
14               proxyFactory.setProxyTargetClass(true);
15           }
16           else {
17               evaluateProxyInterfaces(beanClass, proxyFactory);
18           }
19       }
20
21       // 2.将当前bean适合的advice，重新封装下，封装为Advisor类，然后添加到ProxyFactory中
22       Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
23       for (Advisor advisor : advisors) {
24           proxyFactory.addAdvisor(advisor);
25       }
26
27       proxyFactory.setTargetSource(targetSource);
28       customizeProxyFactory(proxyFactory);
29
30       proxyFactory.setFrozen(this.freezeProxy);
31       if (advisorsPreFiltered()) {
32           proxyFactory.setPreFiltered(true);
33       }
34
35       // 3.调用getProxy获取bean对应的proxy
36       return proxyFactory.getProxy(getProxyClassLoader());
37   }

 1protected Object createProxy(
 2           Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
 3
 4       if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
 5           AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
 6       }
 7
 8       // 1.创建proxyFactory，proxy的生产主要就是在proxyFactory做的
 9       ProxyFactory proxyFactory = new ProxyFactory();
10       proxyFactory.copyFrom(this);
11
12       if (!proxyFactory.isProxyTargetClass()) {
13           if (shouldProxyTargetClass(beanClass, beanName)) {
14               proxyFactory.setProxyTargetClass(true);
15           }
16           else {
17               evaluateProxyInterfaces(beanClass, proxyFactory);
18           }
19       }
20
21       // 2.将当前bean适合的advice，重新封装下，封装为Advisor类，然后添加到ProxyFactory中
22       Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
23       for (Advisor advisor : advisors) {
24           proxyFactory.addAdvisor(advisor);
25       }
26
27       proxyFactory.setTargetSource(targetSource);
28       customizeProxyFactory(proxyFactory);
29
30       proxyFactory.setFrozen(this.freezeProxy);
31       if (advisorsPreFiltered()) {
32           proxyFactory.setPreFiltered(true);
33       }
34
35       // 3.调用getProxy获取bean对应的proxy
36       return proxyFactory.getProxy(getProxyClassLoader());
37   }
382,创建何种类型的Proxy？JDKProxy还是CGLIBProxy？
39public Object getProxy(ClassLoader classLoader) {
40        return createAopProxy().getProxy(classLoader);
41    }
42    // createAopProxy()方法就是决定究竟创建何种类型的proxy
43    protected final synchronized AopProxy createAopProxy() {
44        if (!this.active) {
45            activate();
46        }
47        // 关键方法createAopProxy()
48        return getAopProxyFactory().createAopProxy(this);
49    }
50
51    // createAopProxy()
52    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
53        // 1.config.isOptimize()是否使用优化的代理策略，目前使用与CGLIB
54        // config.isProxyTargetClass() 是否目标类本身被代理而不是目标类的接口
55        // hasNoUserSuppliedProxyInterfaces()是否存在代理接口
56        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
57            Class<?> targetClass = config.getTargetClass();
58            if (targetClass == null) {
59                throw new AopConfigException("TargetSource cannot determine target class: " +
60                        "Either an interface or a target is required for proxy creation.");
61            }
62
63            // 2.如果目标类是接口类（目标对象实现了接口），则直接使用JDKproxy
64            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
65                return new JdkDynamicAopProxy(config);
66            }
67
68            // 3.其他情况则使用CGLIBproxy
69            return new ObjenesisCglibAopProxy(config);
70        }
71        else {
72            return new JdkDynamicAopProxy(config);
73        }
74    }

 1final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable// JdkDynamicAopProxy类结构，由此可知，其实现了InvocationHandler，则必定有invoke方法，来被调用，也就是用户调用bean相关方法时，此invoke()被真正调用
 2   // getProxy()
 3   public Object getProxy(ClassLoader classLoader) {
 4       if (logger.isDebugEnabled()) {
 5           logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
 6       }
 7       Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
 8       findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
 9
10       // JDK proxy 动态代理的标准用法
11       return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
12   }

 1//使用了JDK动态代理模式，真正的方法执行在invoke()方法里，看到这里在想一下上面动态代理的例子，是不是就完全明白Spring源码实现动态代理的原理了。
 2            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 3        MethodInvocation invocation;
 4        Object oldProxy = null;
 5        boolean setProxyContext = false;
 6
 7        TargetSource targetSource = this.advised.targetSource;
 8        Class<?> targetClass = null;
 9        Object target = null;
10
11        try {
12            // 1.以下的几个判断，主要是为了判断method是否为equals、hashCode等Object的方法
13            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
14                // The target does not implement the equals(Object) method itself.
15                return equals(args[0]);
16            }
17            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
18                // The target does not implement the hashCode() method itself.
19                return hashCode();
20            }
21            else if (method.getDeclaringClass() == DecoratingProxy.class) {
22                // There is only getDecoratedClass() declared -> dispatch to proxy config.
23                return AopProxyUtils.ultimateTargetClass(this.advised);
24            }
25            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
26                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
27                // Service invocations on ProxyConfig with the proxy config...
28                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
29            }
30
31            Object retVal;
32
33            if (this.advised.exposeProxy) {
34                // Make invocation available if necessary.
35                oldProxy = AopContext.setCurrentProxy(proxy);
36                setProxyContext = true;
37            }
38
39            // May be null. Get as late as possible to minimize the time we "own" the target,
40            // in case it comes from a pool.
41            target = targetSource.getTarget();
42            if (target != null) {
43                targetClass = target.getClass();
44            }
45            // 2.获取当前bean被拦截方法链表
46            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
47
48            // 3.如果为空，则直接调用target的method
49            if (chain.isEmpty()) {
50                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
51                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
52            }
53            // 4.不为空，则逐一调用chain中的每一个拦截方法的proceed，这里的一系列执行的原因以及proceed执行的内容，我 在这里就不详细讲了，大家感兴趣可以自己去研读哈
54            else {
55                // We need to create a method invocation...
56                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
57                // Proceed to the joinpoint through the interceptor chain.
58                retVal = invocation.proceed();
59            }
60
61