• AOP 实现的几种方法 arthas工具分析

    9) AOP 实现之 ajc 编译器

    代码参考项目 demo6_advanced_aspectj_01

    收获💡

    1. 编译器也能修改 class 实现增强

    2. 编译器增强能突破代理仅能通过方法重写增强的限制：可以对构造方法、静态方法等实现增强

    项目地址：demo6_advanced_aspectj_01https://github.com/LJay997/demo6_advanced_aspectj_01

    查看IDEA 编译的class文件可看出ajc帮我们修改了源码实现了增强静态方法

    10) AOP 实现之 agent 类加载

    代码参考项目 demo6_advanced_aspectj_02

    收获💡

    1. 类加载时可以通过 agent 修改 class 实现增强

    demo6_advanced_aspectj_02https://github.com/LJay997/demo6_advanced_aspectj_02项目地址：git@github.com:LJay997/demo6_advanced_aspectj_02.git

     使用 Alibaba开源的Java诊断工具  Arthashttps://github.com/alibaba/arthas/blob/master/README_CN.md 反编译运行时的文件

            下载arthas-boot.jar，然后用java -jar的方式启动：

    1. curl -O https://arthas.aliyun.com/arthas-boot.jar
    2. java -jar arthas-boot.jar

     运行 A10，选择3

    运行成功后 使用命令 jad （Decompile class 使用 help命令可查看帮助）

    jad  jad com.itheima.service.MyService

     查看运行时编译文件。可见 aop foo（）foo（）内部又调用了自己的 bar（）也可以被增强的。

    Spring Aop失效的情況及解决办法http://t.csdn.cn/aRC6D

    11) AOP 实现之 proxy

    演示1 - jdk 动态代理

    1. interface Foo {
    2.     void foo();
    3.     int bar();
    4. }
    1. class Target implements Foo {
    2.  
    3.     @Override
    4.     public int bar() {
    5.         return 0;
    6.     }
    7.  
    8.     @Override
    9.     public void foo() {
    10.         System.out.println("target foo");
    11.     }
    12. }
    1. public class JdkProxy {
    2.  
    3.     public static void main(String[] args) throws IOException {
    4.         // method.invoke 需要传递 target
    5.         Target target = new Target();
    6.         ClassLoader loader = JdkProxy.class.getClassLoader();
    7.         // Proxy.newProxyInstance  ClassLoader [] Class[]
    8.         // java.lang.reflect 生成的代理对象需要是接口实现的方法 代理与目标是同级关系
    9.         Foo proxy = (Foo) Proxy.newProxyInstance(loader, new Class[]{Foo.class}, (tmpProxy, method, args1) -> {
    10.             System.out.println("before");
    11.             // method.invoke 参数1 需要传递
    12.             return method.invoke(target, args1);
    13.         });
    14.         // 执行代理方法
    15.         proxy.foo();
    16.         // 获取当前代理方法的类
    17.         System.out.println(proxy.getClass());
    18.         // 防止程序自己终止
    19.         System.in.read();
    20.     }
    21. }

    使用arthas工具查看 JdkProxy运行期间动态生成(ASM)生成的代理类的源码。

    1. # 运行 arthas
    2. java -jar .\arthas-boot.jar
    3.  
    4. # 查看到程序的代号输入（回车确认）
    5. 4
    6.  
    7. # jad 命令反编译
    8. jad $Proxy0

     arthas 获取的源码JdkProxy

    1. package a11;
    2.  
    3. import a11.Foo;
    4. import java.lang.reflect.InvocationHandler;
    5. import java.lang.reflect.Method;
    6. import java.lang.reflect.Proxy;
    7. import java.lang.reflect.UndeclaredThrowableException;
    8.  
    9. final class $Proxy0
    10. extends Proxy
    11. implements Foo {
    12.     // 获取接口所有的方法
    13.     private static Method m1;
    14.     private static Method m2;
    15.     private static Method m3;
    16.     private static Method m4;
    17.     private static Method m0;
    18.     
    19.     // 实现构造方法 Proxy
    20.     public $Proxy0(InvocationHandler invocationHandler) {
    21.         super(invocationHandler);
    22.     }
    23.  
    24.     public final boolean equals(Object object) {
    25.         try {
    26.             return (Boolean)this.h.invoke(this, m1, new Object[]{object});
    27.         }
    28.         catch (Error | RuntimeException throwable) {
    29.             throw throwable;
    30.         }
    31.         catch (Throwable throwable) {
    32.             throw new UndeclaredThrowableException(throwable);
    33.         }
    34.     }
    35.  
    36.     public final String toString() {
    37.         try {
    38.             return (String)this.h.invoke(this, m2, null);
    39.         }
    40.         catch (Error | RuntimeException throwable) {
    41.             throw throwable;
    42.         }
    43.         catch (Throwable throwable) {
    44.             throw new UndeclaredThrowableException(throwable);
    45.         }
    46.     }
    47.  
    48.     public final int bar() {
    49.         try {
    50.             return (Integer)this.h.invoke(this, m3, null);
    51.         }
    52.         catch (Error | RuntimeException throwable) {
    53.             throw throwable;
    54.         }
    55.         catch (Throwable throwable) {
    56.             throw new UndeclaredThrowableException(throwable);
    57.         }
    58.     }
    59.  
    60.     public final void foo() {
    61.         try {
    62.             this.h.invoke(this, m4, null);
    63.             return;
    64.         }
    65.         catch (Error | RuntimeException throwable) {
    66.             throw throwable;
    67.         }
    68.         catch (Throwable throwable) {
    69.             throw new UndeclaredThrowableException(throwable);
    70.         }
    71.     }
    72.  
    73.     public final int hashCode() {
    74.         try {
    75.             return (Integer)this.h.invoke(this, m0, null);
    76.         }
    77.         catch (Error | RuntimeException throwable) {
    78.             throw throwable;
    79.         }
    80.         catch (Throwable throwable) {
    81.             throw new UndeclaredThrowableException(throwable);
    82.         }
    83.     }
    84.  
    85.     static {
    86.         try {
    87.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
    88.             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
    89.             m3 = Class.forName("a11.Foo").getMethod("bar", new Class[0]);
    90.             m4 = Class.forName("a11.Foo").getMethod("foo", new Class[0]);
    91.             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
    92.             return;
    93.         }
    94.         catch (NoSuchMethodException noSuchMethodException) {
    95.             throw new NoSuchMethodError(noSuchMethodException.getMessage());
    96.         }
    97.         catch (ClassNotFoundException classNotFoundException) {
    98.             throw new NoClassDefFoundError(classNotFoundException.getMessage());
    99.         }
    100.     }
    101. }

    使用IDEA插件ASM加载字节码文件

     main 方法中补充

    1.  
    2.         byte[] dump = $Proxy0Dump.dump();
    3.  
    4.         ClassLoader classLoader = new ClassLoader() {
    5.             @Override
    6.             protected Class findClass(String name) throws ClassNotFoundException {
    7.                 // 将字节数组转换为Class 类的实例
    8.                 return super.defineClass(name, dump, 0, dump.length);
    9.             }
    10.         };
    11.  
    12.         Class proxy0 = classLoader.loadClass("$Proxy0");
    13.         Constructor constructor = proxy0.getConstructor(InvocationHandler.class);
    14.         Foo proxy = (Foo)constructor.newInstance(new InvocationHandler() {
    15.             @Override
    16.             public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
    17.                 return null;
    18.             }
    19.         });
    20.         
    21.         proxy.foo();
    22.         
    23.         // .....JDK 代理方法
    24.         Target target = new Target();
    25.         // ......

    JDK 代理的优化

    在反射调用第17次时候 代理类变化了 

    16:jdk.internal.reflect.NativeMethodAccessorImpl@cb5822  ->
    17:jdk.internal.reflect.GeneratedMethodAccessor2@26653222

    1. public class TestMethodInvoke {
    2.     public static void main(String[] args) throws Exception {
    3.         Method foo = TestMethodInvoke.class.getMethod("foo", int.class);
    4.         for (int i = 1; i <= 17; i++) {
    5.             show(i, foo);
    6.             foo.invoke(null, i);
    7.         }
    8.         System.in.read();
    9.     }
    10.  
    11.     // 方法反射调用时, 底层 MethodAccessor 的实现类
    12.     private static void show(int i, Method foo) throws Exception {
    13.         Method getMethodAccessor = Method.class.getDeclaredMethod("getMethodAccessor");
    14.         getMethodAccessor.setAccessible(true);
    15.         Object invoke = getMethodAccessor.invoke(foo);
    16.         if (invoke == null) {
    17.             System.out.println(i + ":" + null);
    18.             return;
    19.         }
    20.         Field delegate = Class.forName("jdk.internal.reflect.DelegatingMethodAccessorImpl").getDeclaredField("delegate");
    21.         delegate.setAccessible(true);
    22.         System.out.println(i + ":" + delegate.get(invoke));
    23.     }
    24.  
    25.     public static void foo(int i) {
    26.         System.out.println(i + ":" + "foo");
    27.     }
    28. }

    收获💡

    • jdk 动态代理要求目标必须实现接口，生成的代理类实现相同接口，因此代理与目标之间是平级兄弟关系

    演示2 - cglib 代理

    1. import org.springframework.cglib.proxy.MethodInterceptor;
    2. import org.springframework.cglib.proxy.MethodProxy;
    3.  
    4. import java.io.IOException;
    5. import java.lang.reflect.Method;
    6.  
    7. public class CglibProxy {
    8.     static class Target {
    9.         void foo() {
    10.             System.out.println("target foo");
    11.         }
    12.     }
    13.  
    14.     public static void main(String[] args) throws IOException {
    15.         Target target = new Target();
    16.  
    17.         //  public static Object create(Class type, Callback callback) 第二个参数 使用  MethodInterceptor extends Callback
    18.         // cglib 生产的类型为目标类型的 子类型（方法重写） 目标方法&目标类不能是final类型的
    19.         Target proxy = (Target)Enhancer.create(Target.class, new MethodInterceptor() {
    20.             @Override
    21.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    22.                 System.out.println("before");
    23. //                Object invoke = method.invoke(target, objects); // 用方法反射调用目标
    24.                 Object invoke = methodProxy.invoke(target, objects); // 没有用反射 - 推荐
    25. //                Object invoke = methodProxy.invokeSuper(o, objects); // 没有用反射 需要代理
    26.                 System.out.println("after");
    27.                 return invoke;
    28.             }
    29.         });
    30.  
    31.         proxy.foo();
    32.         System.out.println(proxy.getClass());
    33.         System.in.read();
    34.     }
    35. }

    arthas 获取运行时class

    1. package a11;
    2.  
    3. import a11.CglibProxy;
    4. import java.lang.reflect.Method;
    5. import org.springframework.cglib.core.ReflectUtils;
    6. import org.springframework.cglib.core.Signature;
    7. import org.springframework.cglib.proxy.Callback;
    8. import org.springframework.cglib.proxy.Factory;
    9. import org.springframework.cglib.proxy.MethodInterceptor;
    10. import org.springframework.cglib.proxy.MethodProxy;
    11.  
    12. public class CglibProxy$Target$$EnhancerByCGLIB$$f6222c24
    13. extends CglibProxy.Target
    14. implements Factory {
    15.     // Method MethodProxy 重点
    16.     private boolean CGLIB$BOUND;
    17.     public static Object CGLIB$FACTORY_DATA;
    18.     private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    19.     private static final Callback[] CGLIB$STATIC_CALLBACKS;
    20.     private MethodInterceptor CGLIB$CALLBACK_0;
    21.     private static Object CGLIB$CALLBACK_FILTER;
    22.     private static final Method CGLIB$foo$0$Method;
    23.     private static final MethodProxy CGLIB$foo$0$Proxy;
    24.     private static final Object[] CGLIB$emptyArgs;
    25.     private static final Method CGLIB$equals$1$Method;
    26.     private static final MethodProxy CGLIB$equals$1$Proxy;
    27.     private static final Method CGLIB$toString$2$Method;
    28.     private static final MethodProxy CGLIB$toString$2$Proxy;
    29.     private static final Method CGLIB$hashCode$3$Method;
    30.     private static final MethodProxy CGLIB$hashCode$3$Proxy;
    31.     private static final Method CGLIB$clone$4$Method;
    32.     private static final MethodProxy CGLIB$clone$4$Proxy;
    33.  
    34.     static void CGLIB$STATICHOOK1() {
    35.         CGLIB$THREAD_CALLBACKS = new ThreadLocal();
    36.         CGLIB$emptyArgs = new Object[0];
    37.         Class clazz = Class.forName("a11.CglibProxy$Target$$EnhancerByCGLIB$$f6222c24");
    38.         Class clazz2 = Class.forName("java.lang.Object");
    39.         Method[] methodArray = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, clazz2.getDeclaredMethods());
    40.         CGLIB$equals$1$Method = methodArray[0];
    41.         CGLIB$equals$1$Proxy = MethodProxy.create(clazz2, clazz, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
    42.         CGLIB$toString$2$Method = methodArray[1];
    43.         CGLIB$toString$2$Proxy = MethodProxy.create(clazz2, clazz, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
    44.         CGLIB$hashCode$3$Method = methodArray[2];
    45.         CGLIB$hashCode$3$Proxy = MethodProxy.create(clazz2, clazz, "()I", "hashCode", "CGLIB$hashCode$3");
    46.         CGLIB$clone$4$Method = methodArray[3];
    47.         CGLIB$clone$4$Proxy = MethodProxy.create(clazz2, clazz, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
    48.         clazz2 = Class.forName("a11.CglibProxy$Target");
    49.         CGLIB$foo$0$Method = ReflectUtils.findMethods(new String[]{"foo", "()V"}, clazz2.getDeclaredMethods())[0];
    50.         CGLIB$foo$0$Proxy = MethodProxy.create(clazz2, clazz, "()V", "foo", "CGLIB$foo$0");
    51.     }
    52.     // 带原始功能的方法
    53.     final void CGLIB$foo$0() {
    54.         super.foo();
    55.     }
    56.     // 带增强功能的方法
    57.     @Override
    58.     final void foo() {
    59.         MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
    60.         if (methodInterceptor == null) {
    61.             CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    62.             methodInterceptor = this.CGLIB$CALLBACK_0;
    63.         }
    64.         if (methodInterceptor != null) {
    65.             Object object = methodInterceptor.intercept(this, CGLIB$foo$0$Method, CGLIB$emptyArgs, CGLIB$foo$0$Proxy);
    66.             return;
    67.         }
    68.         super.foo();
    69.     }
    70.  
    71.     final boolean CGLIB$equals$1(Object object) {
    72.         return super.equals(object);
    73.     }
    74.  
    75.     public final boolean equals(Object object) {
    76.         MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
    77.         if (methodInterceptor == null) {
    78.             CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    79.             methodInterceptor = this.CGLIB$CALLBACK_0;
    80.         }
    81.         if (methodInterceptor != null) {
    82.             Object object2 = methodInterceptor.intercept(this, CGLIB$equals$1$Method, new Object[]{object}, CGLIB$equals$1$Proxy);
    83.             return object2 == null ? false : (Boolean)object2;
    84.         }
    85.         return super.equals(object);
    86.     }
    87.  
    88.     final String CGLIB$toString$2() {
    89.         return super.toString();
    90.     }
    91.  
    92.     public final String toString() {
    93.         MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
    94.         if (methodInterceptor == null) {
    95.             CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    96.             methodInterceptor = this.CGLIB$CALLBACK_0;
    97.         }
    98.         if (methodInterceptor != null) {
    99.             return (String)methodInterceptor.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy);
    100.         }
    101.         return super.toString();
    102.     }
    103.  
    104.     final int CGLIB$hashCode$3() {
    105.         return super.hashCode();
    106.     }
    107.  
    108.     public final int hashCode() {
    109.         MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
    110.         if (methodInterceptor == null) {
    111.             CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    112.             methodInterceptor = this.CGLIB$CALLBACK_0;
    113.         }
    114.         if (methodInterceptor != null) {
    115.             Object object = methodInterceptor.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
    116.             return object == null ? 0 : ((Number)object).intValue();
    117.         }
    118.         return super.hashCode();
    119.     }
    120.  
    121.     final Object CGLIB$clone$4() throws CloneNotSupportedException {
    122.         return super.clone();
    123.     }
    124.  
    125.     protected final Object clone() throws CloneNotSupportedException {
    126.         MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
    127.         if (methodInterceptor == null) {
    128.             CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    129.             methodInterceptor = this.CGLIB$CALLBACK_0;
    130.         }
    131.         if (methodInterceptor != null) {
    132.             return methodInterceptor.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy);
    133.         }
    134.         return super.clone();
    135.     }
    136.  
    137.     public static MethodProxy CGLIB$findMethodProxy(Signature signature) {
    138.         String string = ((Object)signature).toString();
    139.         switch (string.hashCode()) {
    140.             case -1268936465: {
    141.                 if (!string.equals("foo()V")) break;
    142.                 return CGLIB$foo$0$Proxy;
    143.             }
    144.             case -508378822: {
    145.                 if (!string.equals("clone()Ljava/lang/Object;")) break;
    146.                 return CGLIB$clone$4$Proxy;
    147.             }
    148.             case 1826985398: {
    149.                 if (!string.equals("equals(Ljava/lang/Object;)Z")) break;
    150.                 return CGLIB$equals$1$Proxy;
    151.             }
    152.             case 1913648695: {
    153.                 if (!string.equals("toString()Ljava/lang/String;")) break;
    154.                 return CGLIB$toString$2$Proxy;
    155.             }
    156.             case 1984935277: {
    157.                 if (!string.equals("hashCode()I")) break;
    158.                 return CGLIB$hashCode$3$Proxy;
    159.             }
    160.         }
    161.         return null;
    162.     }
    163.  
    164.     public CglibProxy$Target$$EnhancerByCGLIB$$f6222c24() {
    165.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = this;
    166.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(cglibProxy$Target$$EnhancerByCGLIB$$f6222c24);
    167.     }
    168.  
    169.     public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] callbackArray) {
    170.         CGLIB$THREAD_CALLBACKS.set(callbackArray);
    171.     }
    172.  
    173.     public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] callbackArray) {
    174.         CGLIB$STATIC_CALLBACKS = callbackArray;
    175.     }
    176.  
    177.     private static final void CGLIB$BIND_CALLBACKS(Object object) {
    178.         block2: {
    179.             Object object2;
    180.             block3: {
    181.                 CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = (CglibProxy$Target$$EnhancerByCGLIB$$f6222c24)object;
    182.                 if (cglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BOUND) break block2;
    183.                 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BOUND = true;
    184.                 object2 = CGLIB$THREAD_CALLBACKS.get();
    185.                 if (object2 != null) break block3;
    186.                 object2 = CGLIB$STATIC_CALLBACKS;
    187.                 if (CGLIB$STATIC_CALLBACKS == null) break block2;
    188.             }
    189.             cglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])object2)[0];
    190.         }
    191.     }
    192.  
    193.     @Override
    194.     public Object newInstance(Callback[] callbackArray) {
    195.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$SET_THREAD_CALLBACKS(callbackArray);
    196.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = new CglibProxy$Target$$EnhancerByCGLIB$$f6222c24();
    197.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$SET_THREAD_CALLBACKS(null);
    198.         return cglibProxy$Target$$EnhancerByCGLIB$$f6222c24;
    199.     }
    200.  
    201.     @Override
    202.     public Object newInstance(Callback callback) {
    203.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$SET_THREAD_CALLBACKS(new Callback[]{callback});
    204.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = new CglibProxy$Target$$EnhancerByCGLIB$$f6222c24();
    205.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$SET_THREAD_CALLBACKS(null);
    206.         return cglibProxy$Target$$EnhancerByCGLIB$$f6222c24;
    207.     }
    208.  
    209.     @Override
    210.     public Object newInstance(Class[] classArray, Object[] objectArray, Callback[] callbackArray) {
    211.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24;
    212.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$SET_THREAD_CALLBACKS(callbackArray);
    213.         Class[] classArray2 = classArray;
    214.         switch (classArray.length) {
    215.             case 0: {
    216.                 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = new CglibProxy$Target$$EnhancerByCGLIB$$f6222c24();
    217.                 break;
    218.             }
    219.             default: {
    220.                 throw new IllegalArgumentException("Constructor not found");
    221.             }
    222.         }
    223.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$SET_THREAD_CALLBACKS(null);
    224.         return cglibProxy$Target$$EnhancerByCGLIB$$f6222c24;
    225.     }
    226.  
    227.     @Override
    228.     public Callback getCallback(int n) {
    229.         MethodInterceptor methodInterceptor;
    230.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    231.         switch (n) {
    232.             case 0: {
    233.                 methodInterceptor = this.CGLIB$CALLBACK_0;
    234.                 break;
    235.             }
    236.             default: {
    237.                 methodInterceptor = null;
    238.             }
    239.         }
    240.         return methodInterceptor;
    241.     }
    242.  
    243.     @Override
    244.     public void setCallback(int n, Callback callback) {
    245.         switch (n) {
    246.             case 0: {
    247.                 this.CGLIB$CALLBACK_0 = (MethodInterceptor)callback;
    248.                 break;
    249.             }
    250.         }
    251.     }
    252.  
    253.     @Override
    254.     public Callback[] getCallbacks() {
    255.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$BIND_CALLBACKS(this);
    256.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = this;
    257.         return new Callback[]{this.CGLIB$CALLBACK_0};
    258.     }
    259.  
    260.     @Override
    261.     public void setCallbacks(Callback[] callbackArray) {
    262.         Callback[] callbackArray2 = callbackArray;
    263.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24 cglibProxy$Target$$EnhancerByCGLIB$$f6222c24 = this;
    264.         this.CGLIB$CALLBACK_0 = (MethodInterceptor)callbackArray[0];
    265.     }
    266.  
    267.     static {
    268.         CglibProxy$Target$$EnhancerByCGLIB$$f6222c24.CGLIB$STATICHOOK1();
    269.     }
    270. }

    15) jdk 和 cglib 在 Spring 中的统一

    AOP名词解释Advice,Pointcut,Advisor,Joinpoint,Advised是什么？

    Spring 中对切点、通知、切面的抽象如下

    • 切点：接口 Pointcut，典型实现 AspectJExpressionPointcut（在哪些地方增强）

    • 通知：Advice 该接口仅仅作为标记使用 没做实质性的方法 典型使用的接口为 MethodInterceptor 所有通知会被统一转换为环绕通知 适配器模式的体现

    MethodInterceptor 中可以间接的获取到 Joinpoint 的方法

    • 切面：Advisor，包含一个 Advice 通知，PointcutAdvisor 包含一个 Advice 通知和一个 Pointcut(哪个人 在哪个地方Pointcut 做什么事情Advice)

    代理相关类图（代理工厂需要 目标类(Target) + 哪个人（Advisor）即可完成 代理者的创建（Proxy） ）

    • AopProxyFactory 根据 proxyTargetClass 等设置选择 AopProxy 实现

    • AopProxy 通过 getProxy 创建代理对象

    • 图中 Proxy 都实现了 Advised 接口，能够获得关联的切面集合与目标（其实是从 ProxyFactory 取得）

    • 调用代理方法时，会借助 ProxyFactory 将通知统一转为环绕通知：MethodInterceptor

    //        1.未setInterfaces              未 setTargetClass CGLIB
    //        2.setInterfaces               未 setTargetClass JDKProxy
    //        3.                                    setTargetClass CGLIB

    AOP名词解释Advice,Pointcut,Advisor,Joinpoint,Advised是什么？http://t.csdn.cn/tPUqD

    1. interface I1 {
    2.         void foo();
    3.  
    4.         void bar();
    5.     }
    6.  
    7.     static class Target1 implements I1 {
    8.         public void foo() {
    9.             System.out.println("target1 foo");
    10.         }
    11.  
    12.         public void bar() {
    13.             System.out.println("target1 bar");
    14.         }
    15.     }
    16.  
    17.     static class Target2 {
    18.         public void foo() {
    19.             System.out.println("target2 foo");
    20.         }
    21.  
    22.         public void bar() {
    23.             System.out.println("target2 bar");
    24.         }
    25.     }
    1. import org.aopalliance.intercept.MethodInterceptor;
    2. import org.springframework.aop.aspectj.AspectJExpressionPointcut;
    3. import org.springframework.aop.framework.ProxyFactory;
    4. import org.springframework.aop.support.DefaultPointcutAdvisor;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) {
    8.         // 1.添加切入点 pointcut
    9.         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    10.         pointcut.setExpression("execution(* foo())");
    11.  
    12.         // 2.添加通知Advice org.aopalliance.intercept.MethodInterceptor
    13.         MethodInterceptor advice = invocation -> {
    14.             System.out.println("before");
    15.             Object proceed = invocation.proceed();  // 调用目标
    16.             System.out.println("after");
    17.             return proceed;
    18.         };
    19.  
    20.         // 3.添加切面 Advisor !! 重要 反向查找就是找一下 advisor 下有 pointcut实现类 的类就可以了！！
    21.         // DefaultPointcutAdvisor 与 AspectJExpressionPointcut 同属于 AbstractGenericPointcutAdvisor
    22.         DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    23.  
    24.         // 4. 创建代理
    25.         A15.Target1 target = new A15.Target1();
    26.         ProxyFactory proxyFactory = new ProxyFactory();
    27.         proxyFactory.setInterfaces(target.getClass().getInterfaces()); // 如果实现了接口必须setInterfaces ProxyFactory不会自动检测
    28. //        proxyFactory.setTargetClass(target.getClass());             // proxyFactory.getProxy使用的 CGLIB 实现 返回类型需要改为 I1 的子类
    29.         proxyFactory.setTarget(target);
    30.         proxyFactory.addAdvisor(advisor);
    31.         A15.I1 proxy = (A15.I1)proxyFactory.getProxy();
    32.  
    33.         proxy.foo();
    34.         System.out.println(proxy.getClass());
    35.         // spring 代理的实现由两种 JDKProxy 与 CGLIB
    36. //        1.未setInterfaces      未 setTargetClass CGLIB
    37. //        2.setInterfaces       未 setTargetClass JDKProxy
    38. //        3.                    setTargetClass CGLIB
    39.  
    40.     }
    41. }

    proxyFactory.setInterfaces(target.getClass().getInterfaces()); proxyFactory.setTargetClass(target.getClass());

    切点匹配

    PointCut 的重要属性 org.springframework.aop.MethodMatcher 检查目标方法是否有资格获得advice

            对使用了注解标注（对整个类型层次结构执行完整搜索，包括超类和实现的接口）的方法进行增强

    1. 	StaticMethodMatcherPointcut pt3 = new StaticMethodMatcherPointcut() {
    2. 		// 执行静态检查给定方法是否匹配
    3. 		@Override
    4. 		public boolean matches(Method method, Class targetClass) {
    5. 			// MergedAnnotations可以从任何 Java AnnotatedElement获得。
    6. 			// 可以使用不同的搜索策略来定位包含要聚合的注释的相关源元素。
    7. 			// 例如， MergedAnnotations.SearchStrategy.TYPE_HIERARCHY将搜索超类和实现的接口。
    8. 			
    9. 			// 检查方法上是否加了 Transactional 注解
    10. 			MergedAnnotations annotations = MergedAnnotations.from(method);
    11. 			if (annotations.isPresent(Transactional.class)) {
    12. 				return true;
    13. 			}
    14. 			//
    15. 			
    16. 			// 查看类上是否加了 Transactional 注解
    17. 			annotations = MergedAnnotations.from(targetClass, MergedAnnotations.SearchStrategy.TYPE_HIERARCHY);
    18. 			if (annotations.isPresent(Transactional.class)) {
    19. 				return true;
    20. 			}
    21. 			return false;
    22. 		}
    23. 	};
    24.  
    25. 	System.out.println(pt3.matches(T1.class.getMethod("foo"), T1.class));

    17) 从 @Aspect 到 Advisor

    代理创建器

    代码参考

    org.springframework.aop.framework.autoproxy 包

    1. package org.springframework.aop.framework.autoproxy;
    2.  
    3. import org.aopalliance.intercept.MethodInterceptor;
    4. import org.aopalliance.intercept.MethodInvocation;
    5. import org.aspectj.lang.JoinPoint;
    6. import org.aspectj.lang.annotation.AfterReturning;
    7. import org.aspectj.lang.annotation.Aspect;
    8. import org.aspectj.lang.annotation.Before;
    9. import org.springframework.aop.Advisor;
    10. import org.springframework.aop.aspectj.AspectJExpressionPointcut;
    11. import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
    12. import org.springframework.aop.support.DefaultPointcutAdvisor;
    13. import org.springframework.context.annotation.Bean;
    14. import org.springframework.context.annotation.Configuration;
    15. import org.springframework.context.annotation.ConfigurationClassPostProcessor;
    16. import org.springframework.context.support.GenericApplicationContext;
    17. import org.springframework.core.annotation.Order;
    18. import org.springframework.lang.NonNull;
    19.  
    20. import java.util.List;
    21.  
    22. public class A17 {
    23.     public static void main(String[] args) {
    24.         GenericApplicationContext context = new GenericApplicationContext();
    25.         context.registerBean("aspect1", Aspect1.class);
    26.         context.registerBean("config", Config.class);
    27.         context.registerBean(ConfigurationClassPostProcessor.class);
    28.         // 属于 BeanPostProcessor  初始化回调前(通过标记接口等填充 bean) 初始化回调后(而使用代理包装 bean)
    29.         context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);
    30.         // BeanPostProcessor
    31.         // 创建 -> (*) 依赖注入 -> 初始化 (*)
    32.  
    33.         context.refresh();
    34. //        for (String name : context.getBeanDefinitionNames()) {
    35. //            System.out.println(name);
    36. //        }
    37.  
    38.         /*
    39.             第一个重要方法 findEligibleAdvisors 找到有【资格】的 Advisors
    40.                 a. 有【资格】的 Advisor 一部分是低级的, 可以由自己编写, 如下例中的 advisor3
    41.                 b. 有【资格】的 Advisor 另一部分是高级的, 由本章的主角解析 @Aspect 后获得
    42.          */
    43.         AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
    44.         List advisors = creator.findEligibleAdvisors(Target2.class, "target2");
    45.         /*for (Advisor advisor : advisors) {
    46.             System.out.println(advisor);
    47.         }*/
    48.  
    49.         /*
    50.             第二个重要方法 wrapIfNecessary
    51.                 a. 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理
    52.          */
    53.         Object o1 = creator.wrapIfNecessary(new Target1(), "target1", "target1");
    54.         System.out.println(o1.getClass());
    55.         Object o2 = creator.wrapIfNecessary(new Target2(), "target2", "target2");
    56.         System.out.println(o2.getClass());
    57.  
    58.         ((Target1) o1).foo(new Target2("ss"));
    59.         /*
    60.             学到了什么
    61.                 a. 自动代理后处理器 AnnotationAwareAspectJAutoProxyCreator 会帮我们创建代理
    62.                 b. 通常代理创建的活在原始对象初始化后执行, 但碰到循环依赖会提前至依赖注入之前执行
    63.                 c. 高级的 @Aspect 切面会转换为低级的 Advisor 切面, 理解原理, 大道至简
    64.          */
    65.     }
    66.  
    67.     static class Target1 {
    68.  
    69.  
    70.         public void foo(Target2 ss) {
    71.             System.out.println("target1 foo");
    72.         }
    73.     }
    74.  
    75.     static class Target2 {
    76.         public Target2() {
    77.         }
    78.         public Target2(String ss) {
    79.             this.ss = ss;
    80.         }
    81.  
    82.         @NonNull
    83.         private String ss;
    84.  
    85.         public String getSs() {
    86.             return ss;
    87.         }
    88.  
    89.         public void setSs(String ss) {
    90.             this.ss = ss;
    91.         }
    92.  
    93.         public void bar() {
    94.             System.out.println("target2 bar");
    95.         }
    96.     }
    97.  
    98.     @Aspect // 高级切面类
    99.     @Order(2)
    100.     static class Aspect1 {
    101.         @AfterReturning("execution(* foo(*))")
    102.         public void before1(JoinPoint joinPoint) {
    103.             System.out.println("aspect1 before1..." + (MethodInvocation)joinPoint);
    104.         }
    105.  
    106.         @Before("execution(* foo())")
    107.         public void before2() {
    108.             System.out.println("aspect1 before2...");
    109.         }
    110.     }
    111.  
    112.     @Configuration
    113.     static class Config {
    114.         @Bean // 低级切面
    115. //        @Order(1) p配置在此地方不生效
    116.         public Advisor advisor3(MethodInterceptor advice3) {
    117.             AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    118.             pointcut.setExpression("execution(* foo())");
    119.             DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice3);
    120.             advisor.setOrder(1);
    121.             return advisor;
    122.         }
    123.         @Bean
    124.         public MethodInterceptor advice3() {
    125.             return invocation -> {
    126.                 System.out.println("advice3 before...");
    127.                 Object result = invocation.proceed();
    128.                 System.out.println("advice3 after...");
    129.                 return result;
    130.             };
    131.         }
    132.     }
    133.  
    134. }

    收获💡

    1. AnnotationAwareAspectJAutoProxyCreator 的作用

      • 将高级 @Aspect 切面统一为低级 Advisor 切面

      • 在合适的时机创建代理

    2. findEligibleAdvisors 找到有【资格】的 Advisors

      • 有【资格】的 Advisor 一部分是低级的, 可以由自己编写, 如本例 A17 中的 advisor3

      • 有【资格】的 Advisor 另一部分是高级的, 由解析 @Aspect 后获得

    3. wrapIfNecessary

      • 它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理

      • 它的调用时机通常在原始对象初始化后执行, 但碰到循环依赖会提前至依赖注入之前执行

    演示2 - 代理创建时机

    代码参考

    org.springframework.aop.framework.autoproxy.A17_1

    1.     static class Bean1 {
    2.         public void foo() {
    3.  
    4.         }
    5.         public Bean1() {
    6.             System.out.println("Bean1()");
    7.         }
    8.         // 取消循环依赖就将该方法注释掉即可
    9.         @Autowired public void setBean2(Bean2 bean2) {
    10.             System.out.println("Bean1 setBean2(bean2) class is: " + bean2.getClass());
    11.         }
    12.         @PostConstruct public void init() {
    13.             System.out.println("Bean1 init()");
    14.         }
    15.     }
    16.  
    17.     static class Bean2 {
    18.         public Bean2() {
    19.             System.out.println("Bean2()");
    20.         }
    21.         @Autowired public void setBean1(Bean1 bean1) {
    22.             System.out.println("Bean2 setBean1(bean1) class is: " + bean1.getClass());
    23.         }
    24.         @PostConstruct public void init() {
    25.             System.out.println("Bean2 init()");
    26.         }
    27.     }

     // 循环依赖演示

    注意 “Creating implicit proxy for bean 'bean1'”意思是增强了.

     // 无循环依赖

    Bean2 setBean1依赖注入Bean1 代理（$Bean1）增强后（$$EnhancerBySpringCGLIB）的对象

     // 工厂方法配置

    1.     @Configuration
    2.     static class Config {
    3.         @Bean // 解析 @Aspect、产生代理
    4.         public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator() {
    5.             return new AnnotationAwareAspectJAutoProxyCreator();
    6.         }
    7.  
    8.         @Bean // 解析 @Autowired
    9.         public AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor() {
    10.             return new AutowiredAnnotationBeanPostProcessor();
    11.         }
    12.  
    13.         @Bean // 解析 @PostConstruct
    14.         public CommonAnnotationBeanPostProcessor commonAnnotationBeanPostProcessor() {
    15.             return new CommonAnnotationBeanPostProcessor();
    16.         }
    17.  
    18.         @Bean
    19.         public Advisor advisor(MethodInterceptor advice) {
    20.             AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    21.             pointcut.setExpression("execution(* foo())");
    22.             return new DefaultPointcutAdvisor(pointcut, advice);
    23.         }
    24.  
    25.         @Bean
    26.         public MethodInterceptor advice() {
    27.             return (MethodInvocation invocation) -> {
    28.                 System.out.println("before...");
    29.                 return invocation.proceed();
    30.             };
    31.         }
    32.  
    33.         @Bean
    34.         public Bean1 bean1() {
    35.             return new Bean1();
    36.         }
    37.  
    38.         @Bean
    39.         public Bean2 bean2() {
    40.             return new Bean2();
    41.         }
    42.     }

    // 主方法调用

    1.     public static void main(String[] args) {
    2.         GenericApplicationContext context = new GenericApplicationContext();
    3.         context.registerBean(ConfigurationClassPostProcessor.class);
    4.         context.registerBean(Config.class);
    5.         context.refresh();
    6.         context.close();
    7.         // 创建 -> (*) 依赖注入 -> 初始化 (*)
    8.         /*
    9.             学到了什么
    10.                 a. 代理的创建时机
    11.                     1. 初始化之后 (无循环依赖时)
    12.                     2. 实例创建后, 依赖注入前 (有循环依赖时), 并暂存于二级缓存
    13.                 b. 依赖注入与初始化不应该被增强, 仍应被施加于原始对象
    14.          */
    15.     }

    收获💡？？

    创建 -> (1.2) 依赖注入 -> 初始化 (1.1)

    1. 代理的创建时机

      • 无循环依赖时：初始化之后 

      • 有循环依赖时：实例创建后, 依赖注入前 , 并暂存于二级缓存

    2. 依赖注入与初始化不应该被增强, 仍 应被施加于原始对象

    @Order 、@Priority 与 org.springframework.core.Ordered

    基础的应用场景是 配置类中（标注了@Aspect注解的多个类 声明了多个切面 默认的执行顺序是Bean注册的顺序），但我想自定义 切面拦截的顺序。

    1.高级切面类的顺序 在@Aspject上标注 @Order注解

            @Order 放在类上可以生效。org.aspectj.lang.annotation类下面的注解不是@Bean的子类。所以不能定义拦截的顺序。

    2.定义@Configuration （低级切面方法）的顺序。

    对于实现了org.springframework.core.Ordered接口的来来说。配置此类的order属性即可。

    18) 静态通知调用

    高级切面转低级切面类 + 通知统一转换为环绕通知 MethodInterceptor + 创建并执行调用链 (环绕通知s + 目标)
    1. import org.aopalliance.intercept.MethodInvocation;
    2. import org.aspectj.lang.ProceedingJoinPoint;
    3. import org.aspectj.lang.annotation.AfterReturning;
    4. import org.aspectj.lang.annotation.AfterThrowing;
    5. import org.aspectj.lang.annotation.Around;
    6. import org.aspectj.lang.annotation.Before;
    7. import org.springframework.aop.Advisor;
    8. import org.springframework.aop.aspectj.*;
    9. import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
    10. import org.springframework.aop.support.DefaultPointcutAdvisor;
    11.  
    12. import java.lang.reflect.Method;
    13. import java.util.ArrayList;
    14. import java.util.List;
    15.  
    16. public class A18 {
    17.  
    18.     static class Aspect {
    19.         @Before("execution(* foo())")
    20.         public void before1() {
    21.             System.out.println("before1");
    22.         }
    23.  
    24.         @Before("execution(* foo())")
    25.         public void before2() {
    26.             System.out.println("before2");
    27.         }
    28.  
    29.         public void after() {
    30.             System.out.println("after");
    31.         }
    32.  
    33.         @AfterReturning("execution(* foo())")
    34.         public void afterReturning() {
    35.             System.out.println("afterReturning");
    36.         }
    37.  
    38.         @AfterThrowing("execution(* foo())")
    39.         public void afterThrowing(Exception e) {
    40.             System.out.println("afterThrowing " + e.getMessage());
    41.         }
    42.  
    43.         @Around("execution(* foo())")
    44.         public Object around(ProceedingJoinPoint pjp) throws Throwable {
    45.             try {
    46.                 System.out.println("around...before");
    47.                 return pjp.proceed();
    48.             } finally {
    49.                 System.out.println("around...after");
    50.             }
    51.         }
    52.     }
    53.  
    54.     static class Target {
    55.         public void foo() {
    56.             System.out.println("target foo");
    57.         }
    58.     }
    59.  
    60.     @SuppressWarnings("all")
    61.     public static void main(String[] args) throws Throwable {
    62.  
    63.         AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());
    64.         // 1. 高级切面转低级切面类
    65.         List list = new ArrayList<>();
    66.         for (Method method : Aspect.class.getDeclaredMethods()) {
    67.             if (method.isAnnotationPresent(Before.class)) {
    68.                 // 解析切点
    69.                 String expression = method.getAnnotation(Before.class).value();
    70.                 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    71.                 pointcut.setExpression(expression);
    72.                 // 通知类
    73.                 AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(method, pointcut, factory);
    74.                 // 切面
    75.                 Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    76.                 list.add(advisor);
    77.             } else if (method.isAnnotationPresent(AfterReturning.class)) {
    78.                 // 解析切点
    79.                 String expression = method.getAnnotation(AfterReturning.class).value();
    80.                 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    81.                 pointcut.setExpression(expression);
    82.                 // 通知类
    83.                 AspectJAfterReturningAdvice advice = new AspectJAfterReturningAdvice(method, pointcut, factory);
    84.                 // 切面
    85.                 Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    86.                 list.add(advisor);
    87.             } else if (method.isAnnotationPresent(Around.class)) {
    88.                 // 解析切点
    89.                 String expression = method.getAnnotation(Around.class).value();
    90.                 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    91.                 pointcut.setExpression(expression);
    92.                 // 通知类
    93.                 AspectJAroundAdvice advice = new AspectJAroundAdvice(method, pointcut, factory);
    94.                 // 切面
    95.                 Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    96.                 list.add(advisor);
    97.             }
    98.         }
    99.         for (Advisor advisor : list) {
    100.             // 还要为低级的切面进行排序
    101.             System.out.println(advisor);
    102.         }
    103.  
    104.         /*
    105.             @Before 前置通知会被转换为下面原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息
    106.                 a. 通知代码从哪儿来
    107.                 b. 切点是什么
    108.                 c. 通知对象如何创建, 本例共用同一个 Aspect 对象
    109.             类似的通知还有
    110.                 1. AspectJAroundAdvice (环绕通知)
    111.                 2. AspectJAfterReturningAdvice
    112.                 3. AspectJAfterThrowingAdvice (环绕通知)
    113.                 4. AspectJAfterAdvice (环绕通知)
    114.          */
    115.  
    116.         // 2. 通知统一转换为环绕通知 MethodInterceptor
    117.         /*
    119.             其实无论 ProxyFactory 基于哪种方式创建代理, 最后干活(调用 advice)的是一个 MethodInvocation 对象
    120.                 a. 因为 advisor 有多个, 且一个套一个调用, 因此需要一个调用链对象, 即 MethodInvocation
    121.                 b. MethodInvocation 要知道 advice 有哪些, 还要知道目标, 调用次序如下
    123.                 !.将 MethodInvocation 放入当前线程
    124.                     |-> before1 ----------------------------------- 从当前线程获取 MethodInvocation
    125.                     |                                             |
    126.                     |   |-> before2 --------------------          | 从当前线程获取 MethodInvocation
    127.                     |   |                              |          |
    128.                     |   |   |-> target ------ 目标   advice2    advice1
    129.                     |   |                              |          |
    130.                     |   |-> after2 ---------------------          |
    131.                     |                                             |
    132.                     |-> after1 ------------------------------------
    133.                 c. 从上图看出, 环绕通知才适合作为 advice, 因此其他 before、afterReturning 都会被转换成环绕通知
    134.                 d. 统一转换为环绕通知, 体现的是设计模式中的适配器模式
    135.                     - 对外是为了方便使用要区分 before、afterReturning
    136.                     - 对内统一都是环绕通知, 统一用 MethodInterceptor 表示
    138.             此步获取所有执行时需要的 advice (静态)
    139.                 a. 即统一转换为 MethodInterceptor 环绕通知, 这体现在方法名中的 Interceptors 上
    140.                 b. 适配如下
    141.                   - MethodBeforeAdviceAdapter 将 @Before AspectJMethodBeforeAdvice 适配为 MethodBeforeAdviceInterceptor
    142.                   - AfterReturningAdviceAdapter 将 @AfterReturning AspectJAfterReturningAdvice 适配为 AfterReturningAdviceInterceptor
    143.          */
    144.         Target target = new Target();
    145.         ProxyFactory proxyFactory = new ProxyFactory();
    146.         proxyFactory.setTarget(target);
    147.  
    148.         // !.准备把 MethodInvocation 放入当前线程,需要放在环绕通知的最外层,用于暴露 MethodInvocation 的一个工具类
    149.         // 是单例的 使用的私有构造
    150.         proxyFactory.addAdvice(ExposeInvocationInterceptor.INSTANCE);
    151.         proxyFactory.addAdvisors(list);
    152.  
    153.         System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    154.         List methodInterceptorList = proxyFactory.getInterceptorsAndDynamicInterceptionAdvice(Target.class.getMethod("foo"), Target.class);
    155.         for (Object o : methodInterceptorList) {
    156.             System.out.println(o);
    157.         }
    158.  
    159.         System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    160.         // 3. 创建并执行调用链 (环绕通知s + 目标)
    161.         MethodInvocation methodInvocation = new ReflectiveMethodInvocation(
    162.                 null, target, Target.class.getMethod("foo"), new Object[0], Target.class, methodInterceptorList
    163.         );
    164.         methodInvocation.proceed();
    165.  
    166.  
    167.  
    168.         /*
    169.             学到了什么
    170.                 a. 无参数绑定的通知如何被调用
    171.                 b. MethodInvocation 编程技巧: 拦截器、过滤器等等实现都与此类似
    172.                 c. 适配器模式在 Spring 中的体现
    173.          */
    174.  
    175.     }
    176. }
      177.  

       

      代理对象调用流程如下（以 JDK 动态代理实现为例）
       

      •  
        从 ProxyFactory 获得 Target 和环绕通知链，根据他俩创建 MethodInvocation，简称 mi
         
      •  
        首次执行 mi.proceed() 发现有下一个环绕通知，调用它的 invoke(mi)
         
      •  
        进入环绕通知1，执行前增强，再次调用 mi.proceed() 发现有下一个环绕通知，调用它的 invoke(mi)
         
      •  
        进入环绕通知2，执行前增强，调用 mi.proceed() 发现没有环绕通知，调用 mi.invokeJoinPoint() 执行目标方法
         
      •  
        目标方法执行结束，将结果返回给环绕通知2，执行环绕通知2 的后增强
         
      •  
        环绕通知2继续将结果返回给环绕通知1，执行环绕通知1 的后增强
         
      •  
        环绕通知1返回最终的结果
         
       

      图中不同颜色对应一次环绕通知或目标的调用起始至终结
       

      ​​​​​​​
       

      模拟 MethodInvocation
       

      1. /*
      2.     模拟调用链过程, 是一个简单的递归过程
      3.         1. proceed() 方法调用链中下一个环绕通知
      4.         2. 每个环绕通知内部继续调用 proceed()
      5.         3. 调用到没有更多通知了, 就调用目标方法
      6.  */
      7. public class A18_1 {
      8.  
      9.     static class Target {
      10.         public void foo() {
      11.             System.out.println("Target.foo()");
      12.         }
      13.     }
      14.  
      15.     static class Advice1 implements MethodInterceptor {
      16.         @Override
      17.         public Object invoke(MethodInvocation invocation) throws Throwable {
      18.             System.out.println("Advice1.before()");
      19.             Object result = invocation.proceed();// 调用下一个通知或目标
      20.             System.out.println("Advice1.after()");
      21.             return result;
      22.         }
      23.     }
      24.  
      25.     static class Advice2 implements MethodInterceptor {
      26.         @Override
      27.         public Object invoke(MethodInvocation invocation) throws Throwable {
      28.             System.out.println("Advice2.before()");
      29.             Object result = invocation.proceed();// 调用下一个通知或目标
      30.             System.out.println("Advice2.after()");
      31.             return result;
      32.         }
      33.     }
      34.  
      35.  
      36.     static class MyInvocation implements MethodInvocation {
      37.         private Object target;  // 1
      38.         private Method method;
      39.         private Object[] args;
      40.         List methodInterceptorList; // 2
      41.         private int count = 1; // 调用次数
      42.  
      43.         public MyInvocation(Object target, Method method, Object[] args, List methodInterceptorList) {
      44.             this.target = target;
      45.             this.method = method;
      46.             this.args = args;
      47.             this.methodInterceptorList = methodInterceptorList;
      48.         }
      49.  
      50.         @Override
      51.         public Method getMethod() {
      52.             return method;
      53.         }
      54.  
      55.         @Override
      56.         public Object[] getArguments() {
      57.             return args;
      58.         }
      59.  
      60.         @Override
      61.         public Object proceed() throws Throwable { // 调用每一个环绕通知, 调用目标
      62.             if (count > methodInterceptorList.size()) {
      63.                 // 调用目标， 返回并结束递归
      64.                 return method.invoke(target, args);
      65.             }
      66.             // 逐一调用通知, count + 1
      67.             MethodInterceptor methodInterceptor = methodInterceptorList.get(count++ - 1);
      68.             return methodInterceptor.invoke(this);
      69.         }
      70.  
      71.         @Override
      72.         public Object getThis() {
      73.             return target;
      74.         }
      75.  
      76.         @Override
      77.         public AccessibleObject getStaticPart() {
      78.             return method;
      79.         }
      80.     }
      81.  
      82.     public static void main(String[] args) throws Throwable {
      83.         Target target = new Target();
      84.         List list = List.of(
      85.                 new Advice1(),
      86.                 new Advice2()
      87.         );
      88.         MyInvocation invocation = new MyInvocation(target, Target.class.getMethod("foo"), new Object[0], list);
      89.         invocation.proceed();
      90.     }
      91. }
       

      ​​​​​​​
       

       

      aspectj.lang.annotation
       

      注解介绍： Spring AOP切点表达式用法总结 - 爱宝贝丶 - 博客园 (cnblogs.com)
       

      切面形参介绍：@Aspect 切面注解使用 - 秃了也变强了 - 博客园 (cnblogs.com)
       

      拦截器执行的顺序：
       

      1. try {
      2.     Object result = null;
      3.     try {
      4.         System.out.println("@Around通知start");
      5.         System.out.println("@Before通知!");
      6.         result = service4.say("路人");
      7.         System.out.println("@Around绕通知end");
      8.         return result;
      9.     } finally {
      10.         System.out.println("@After通知!");
      11.     }
      12.     System.out.println("@AfterReturning通知!");
      13.     return retVal;
      14. } catch (Throwable ex) {
      15.     System.out.println("@AfterThrowing通知!");
      16.     //继续抛出异常
      17.     throw ex;
      18. }
       

      
                
                    
                

                
    177. 

                    相关阅读:
      
                    
mysql是怎么运行的-笔记                            
      
WIN11任务栏出现空白，卡任务栏的解决办法                            
      
【学习笔记】DDD领域驱动设计篇                            
      
做闲鱼如何提升曝光量？                            
      
C程序设计（谭浩强）第五版课后题答案 第一章                            
      
高等数学基础概念的Python开发实现                            
      
Aspose.Words 操作 Word 画 EChart 图                            
      
如何利用IP地址定位保护网络安全？                            
      
C习题002：澡堂洗澡                            
      
【多目标优化算法MOAHA】多目标人工蜂鸟算法（Matlab代码实现）                            
      
                          
                
      178. 
                
    178. 
                    原文地址：https://blog.csdn.net/qq_34922830/article/details/127044190
                
      179.