Spring温故而知新 – AOP代理

柔光的暖阳◎ 2022-05-25 09:54 186阅读 0赞

https://www.cnblogs.com/ashleyboy/p/9027072.html

### AOP的概念 ###

AOP：Aspect-Oriented Programming（面向切面编程），维基百科的解释如下：Aspect是一种新的模块化机制，用来描述分散在对象、类或者函数中的横切关注点，从关注点中分离出横切关注点是面向切面的程序设计的核心概念。分离关注点使解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不在含有针对特定领域问题的代码的调用，业务逻辑同特定领域问题的关系通过切面来封装、维护，这样原本分散在整个应用程序中的变动就可以很好地管理起来。从AOP的角度，应用可以分为横切关注点和业务逻辑代码，实际开发中，这些横切关注点往往会直接嵌入到业务逻辑代码中，面向切面编程就是要解决把横切关注点与业务逻辑相分离

实现方式：

Spring默认使用 JDK 动态代理作为AOP的代理，缺陷是目标类的类必须实现接口，否则不能使用JDK动态代理。如果需要代理的是类而不是接口，那么Spring会默认使用CGLIB代理，关于两者的区别：jdk动态代理是通过java的反射机制来实现的,目标类必须要实现接口，cglib是针对类来实现代理的，他的原理是动态的为指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

### JDK动态代理 ###

Jdk动态代理是在程序运行过程中，根据目标类实现的接口来动态生成代理类的class文件,使用主要涉及两个类：

InvocationHandler接口： 它提供了一个invoke(Object obj,Method method, Object\[\] args)方法供实现者提供相应的代理逻辑的实现。可以对实际的实现进行一些特殊的处理其中参数

Object obj ：被代理的目标类

Method method： 需要执行的目标类的方法

Object\[\] args ：目标方法的参数

Proxy类：提供一个方法newProxyInstance (ClassLoader loader, Class\[\] interfaces, InvocationHandler h)来获得动态代理类

示例代码：

public interface OrderService {
    
        public void createOrder(); 
    }

![复制代码][copycode.gif]

public class OrderServiceImpl implements OrderService {
        
        @Override
        public void createOrder() {
            System.out.println("creating order");
        }
    }

![复制代码][copycode.gif]

public class OrderLogger {
        
        public void beforeCreateOrder(){
            System.out.println("before create order");
        }
    
        public void afterCreateOrder(){
            System.out.println("after create order");
        }
    }

![复制代码][copycode.gif]

package com.sl.aop;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class ServiceProxy implements InvocationHandler {
        private Object targetClass;
        private OrderLogger orderLogger;
    
        public ServiceProxy(Object targetClass,OrderLogger orderLogger) {
            this.targetClass = targetClass;
            this.orderLogger = orderLogger;
        }
        
        //获取代理
        public Object GetDynamicProxy()
        {
            return Proxy.newProxyInstance(targetClass.getClass().getClassLoader(), //通过这个ClassLoader生成代理对象
                    targetClass.getClass().getInterfaces(),//代理类已实现的接口
                    this);  //动态代理调用方法是关联的InvocationHandler,最终通过此InvocationHandler的invoke方法执行真正的方法
        }
        
        //实现相应的代理逻辑
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            this.orderLogger.beforeCreateOrder();
            Object result= method.invoke(targetClass, args);
            this.orderLogger.afterCreateOrder();
            
            return result;
        }
    
    }

![复制代码][copycode.gif]

测试类：

![复制代码][copycode.gif]

package com.sl.aop;
    import org.junit.Test;
    public class AopTest {
        @Test
        public void Testdynamicproxy() {
    
            OrderServiceImpl serviceImpl = new OrderServiceImpl();
            OrderLogger logger = new OrderLogger();
            OrderService service = (OrderService) new ServiceProxy(serviceImpl, logger).GetDynamicProxy();
            service.createOrder();
        }
    }

![复制代码][copycode.gif]

运行结果：

![577318-20180511233345910-707141223.png][]

到这个其实还是有点困惑，Proxy.newProxyInstance（）这个返回的是什么？ Invoke方法在哪里调用的？我们看一下JDK源码：看看DK动态代理的过程是什么样的：

根据源码内部的函数调用Proxy.newProxyInstance()->Proxy.getProxyClass0()->WeakCache.get() ，先定位到

WeakCache.class:

![复制代码][copycode.gif]

public V get(K key, P parameter) {
            Objects.requireNonNull(parameter);
    
            expungeStaleEntries();
    
            Object cacheKey = CacheKey.valueOf(key, refQueue);
    
            // lazily install the 2nd level valuesMap for the particular cacheKey
            ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
            if (valuesMap == null) {
                ConcurrentMap<Object, Supplier<V>> oldValuesMap
                    = map.putIfAbsent(cacheKey,
                                      valuesMap = new ConcurrentHashMap<>());
                if (oldValuesMap != null) {
                    valuesMap = oldValuesMap;
                }
            }
    
            // create subKey and retrieve the possible Supplier<V> stored by that
            // subKey from valuesMap
            Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
            Supplier<V> supplier = valuesMap.get(subKey);
            Factory factory = null;
    
            while (true) {
                if (supplier != null) {
                    // supplier might be a Factory or a CacheValue<V> instance
                    V value = supplier.get();
                    if (value != null) {
                        return value;
                    }
                }
                // else no supplier in cache
                // or a supplier that returned null (could be a cleared CacheValue
                // or a Factory that wasn't successful in installing the CacheValue)
    
                // lazily construct a Factory
                if (factory == null) {
                    factory = new Factory(key, parameter, subKey, valuesMap);
                }
    
                if (supplier == null) {
                    supplier = valuesMap.putIfAbsent(subKey, factory);
                    if (supplier == null) {
                        // successfully installed Factory
                        supplier = factory;
                    }
                    // else retry with winning supplier
                } else {
                    if (valuesMap.replace(subKey, supplier, factory)) {
                        // successfully replaced
                        // cleared CacheEntry / unsuccessful Factory
                        // with our Factory
                        supplier = factory;
                    } else {
                        // retry with current supplier
                        supplier = valuesMap.get(subKey);
                    }
                }
            }
        }

![复制代码][copycode.gif]

可以看到函数return value;  而 V value = supplier.get();   继续往下读可以发现 supper=factory,实际上是一个Factory对象,那么继续查看Factory.get()方法

![复制代码][copycode.gif]

public synchronized V get() { // serialize access
                // re-check
                Supplier<V> supplier = valuesMap.get(subKey);
                if (supplier != this) {
                    // something changed while we were waiting:
                    // might be that we were replaced by a CacheValue
                    // or were removed because of failure ->
                    // return null to signal WeakCache.get() to retry
                    // the loop
                    return null;
                }
                // else still us (supplier == this)
    
                // create new value
                V value = null;
                try {
                    value = Objects.requireNonNull(valueFactory.apply(key, parameter));
                } finally {
                    if (value == null) { // remove us on failure
                        valuesMap.remove(subKey, this);
                    }
                }
                // the only path to reach here is with non-null value
                assert value != null;
    
                // wrap value with CacheValue (WeakReference)
                CacheValue<V> cacheValue = new CacheValue<>(value);
    
                // try replacing us with CacheValue (this should always succeed)
                if (valuesMap.replace(subKey, this, cacheValue)) {
                    // put also in reverseMap
                    reverseMap.put(cacheValue, Boolean.TRUE);
                } else {
                    throw new AssertionError("Should not reach here");
                }
    
                // successfully replaced us with new CacheValue -> return the value
                // wrapped by it
                return value;
            }

![复制代码][copycode.gif]

Return value；那么直接查看赋值语句：value = Objects.requireNonNull(valueFactory.apply(key, parameter)); valueFactory又什么鬼？

![复制代码][copycode.gif]

public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                         BiFunction<K, P, V> valueFactory) {
            this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
            this.valueFactory = Objects.requireNonNull(valueFactory);
        }
    
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>  proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

![复制代码][copycode.gif]

可以知道valueFactory是ProxyClassFactory类型对象，直接查看ProxyClassFactory. Apply()方法

![复制代码][copycode.gif]

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    
                Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
                for (Class<?> intf : interfaces) {
                    /*
                     * Verify that the class loader resolves the name of this
                     * interface to the same Class object.
                     */
                    Class<?> interfaceClass = null;
                    try {
                        interfaceClass = Class.forName(intf.getName(), false, loader);
                    } catch (ClassNotFoundException e) {
                    }
                    if (interfaceClass != intf) {
                        throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                    }
                    /*
                     * Verify that the Class object actually represents an
                     * interface.
                     */
                    if (!interfaceClass.isInterface()) {
                        throw new IllegalArgumentException(
                            interfaceClass.getName() + " is not an interface");
                    }
                    /*
                     * Verify that this interface is not a duplicate.
                     */
                    if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                        throw new IllegalArgumentException(
                            "repeated interface: " + interfaceClass.getName());
                    }
                }
    
                String proxyPkg = null;     // package to define proxy class in
                int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
    
                /*
                 * Record the package of a non-public proxy interface so that the
                 * proxy class will be defined in the same package.  Verify that
                 * all non-public proxy interfaces are in the same package.
                 */
                for (Class<?> intf : interfaces) {
                    int flags = intf.getModifiers();
                    if (!Modifier.isPublic(flags)) {
                        accessFlags = Modifier.FINAL;
                        String name = intf.getName();
                        int n = name.lastIndexOf('.');
                        String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                        if (proxyPkg == null) {
                            proxyPkg = pkg;
                        } else if (!pkg.equals(proxyPkg)) {
                            throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                        }
                    }
                }
    
                if (proxyPkg == null) {
                    // if no non-public proxy interfaces, use com.sun.proxy package
                    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
                }
    
                /*
                 * Choose a name for the proxy class to generate.
                 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
    
                /*
                 * Generate the specified proxy class.
                 */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
                try {
                    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    /*
                     * A ClassFormatError here means that (barring bugs in the
                     * proxy class generation code) there was some other
                     * invalid aspect of the arguments supplied to the proxy
                     * class creation (such as virtual machine limitations
                     * exceeded).
                     */
                    throw new IllegalArgumentException(e.toString());
                }
            }
    }

![复制代码][copycode.gif]

直接画重点：

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
    
    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);

调用ProxyGenerator.generateProxyClass最终动态生成一个代理类，但是似乎并未找到何处调用了invoke方法；参考CSDN: [https://blog.csdn.net/jiankunking/article/details/52143504][https_blog.csdn.net_jiankunking_article_details_52143504]这边文章，尝试将这个动态生成的二进制字节码输出到本地，并反编译出来一看究竟，测试代码如下：

![复制代码][copycode.gif]

public class AopTest {
        @Test
        public void Testdynamicproxy() {
    
            OrderServiceImpl serviceImpl = new OrderServiceImpl();
            OrderLogger logger = new OrderLogger();
            OrderService service = (OrderService) new ServiceProxy(serviceImpl, logger).GetDynamicProxy();
            service.createOrder();
            //输出动态代理类字节码
            createProxyClassFile();
        }
    
        private static void createProxyClassFile(){  
            String name = "ProxyObject";  
            byte[] data = ProxyGenerator.generateProxyClass(name,new Class[]{OrderService.class});  
            FileOutputStream out =null;  
            try {  
                out = new FileOutputStream(name+".class");  
                System.out.println((new File("hello")).getAbsolutePath());  
                out.write(data);  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }finally {  
                if(null!=out) try {  
                    out.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        } 
    }

![复制代码][copycode.gif]

使用java Decompiler工具将这个二进制class文件反编译查看：

![577318-20180511234023310-926742201.png][]

具体动态代理类ProxyObject.java：

![复制代码][copycode.gif]

import com.sl.aop.OrderService;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    
    public final class ProxyObject
      extends Proxy
      implements OrderService
    {
      private static Method m1;
      private static Method m2;
      private static Method m3;
      private static Method m0;
      
      public ProxyObject(InvocationHandler paramInvocationHandler)
      {
        super(paramInvocationHandler);
      }
      
      public final boolean equals(Object paramObject)
      {
        try
        {
          return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final String toString()
      {
        try
        {
          return (String)this.h.invoke(this, m2, null);
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final void createOrder()
      {
        try
        {
          this.h.invoke(this, m3, null);
          return;
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      public final int hashCode()
      {
        try
        {
          return ((Integer)this.h.invoke(this, m0, null)).intValue();
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      
      static
      {
        try
        {
          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
          m3 = Class.forName("com.sl.aop.OrderService").getMethod("createOrder", new Class[0]);
          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
          return;
        }
        catch (NoSuchMethodException localNoSuchMethodException)
        {
          throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException localClassNotFoundException)
        {
          throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
      }

![复制代码][copycode.gif]

终于看到关于invoke的部分了：

![复制代码][copycode.gif]

public final void createOrder()
      {
        try
        {
          this.h.invoke(this, m3, null);
          return;
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }

![复制代码][copycode.gif]

实际上动态代理类继承自Proxy，并且实现了目标类继承的接口，在createOrder方法中调用了invoke方法，实现了切面逻辑的植入，这里也回答了一个问题，为什么JDK动态代理的目标类必须是实现接口的，因为代理类其实是针对接口代理，而不是针对类来代理的，动态代理类自己继承自Proxy,Java也不允许多重继承。动态代理类和目标类其实是各自实现了接口，代理类通过InvocationHandler.invoke实现对目标类方法的调用。

### CGLIB动态代理 ###

CGLIB代理是通过使用一个字节码处理框架ASM，来转换字节码并生成新的类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，实现织如如横切逻辑 ，效率上比使用反射技术的JDK动态代理要高，但是由于CGLIB的原理是动态为目标类生成子类代理类，所以不能为声明为final的方法进行代理。其使用主要涉及两个类：

MethodInterceptor接口：该接口提供一个方法intercept(Object arg0, Method arg1, Object\[\] arg2, MethodProxy arg3)主要用于拦截目标类方法的调用

Object arg0, ：被代理的目标类

Method arg1, 委托方法

Object\[\] arg2, 方法参数

MethodProxy arg3 ：代理方法的MethodProxy对象

Enhancer类：用于创建代理类

示例：

实现MethodInterceptor接口

![复制代码][copycode.gif]

package com.sl.aop;
    import java.lang.reflect.Method;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    public class CglibServiceProxy implements MethodInterceptor {
    
        private Object targetClass;
        private OrderLogger orderLogger;
        
        
        public CglibServiceProxy(Object targetClass,OrderLogger orderLogger) {
            this.targetClass = targetClass;
            this.orderLogger = orderLogger;
        }
        /** 
         * 创建代理对象 
         *
         */  
        public Object getInstance() { 
            Enhancer enhancer = new Enhancer();  
            
            //设置目标类（需要被代理的类）  
            enhancer.setSuperclass(this.targetClass.getClass());
            
            // 回调方法  
            enhancer.setCallback(this);
            
            // 创建代理对象  
            return enhancer.create();  
        }  
      
        /** 
         * 拦截所有目标类方法的调用 
         *
         */
        @Override
        public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
            orderLogger.beforeCreateOrder();  
            
            Object o1 = arg3.invokeSuper(arg0, arg2);
            
            orderLogger.afterCreateOrder();  
            return o1;  
        }
    }

![复制代码][copycode.gif]

测试方法：

![复制代码][copycode.gif]

public void Testdynamicproxy() {
            System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\class");
            OrderServiceImpl serviceImpl = new OrderServiceImpl();
            OrderLogger logger = new OrderLogger();
            CglibServiceProxy proxy = new CglibServiceProxy(serviceImpl,logger);  
              //通过生成子类的方式创建代理类  
            OrderServiceImpl proxyImp = (OrderServiceImpl)proxy.getInstance();
            proxyImp.createOrder();
            
        }

![复制代码][copycode.gif]

结果：

![577318-20180511234652906-687667373.png][]

最后两种代理对比一下：

JDK动态代理：代理类与委托类实现同一接口，主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的，在invoke方法中将对方法进行增强处理  优点：不需要硬编码接口，代码复用率高，缺点：只能够代理实现了接口的委托类

CGLIB动态代理：

代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法。在代理方法中，它会判断是否存在实现了MethodInterceptor接口的对象，若存在则将调用intercept方法对委托方法进行代理  优点：可以在运行时对类或者是接口进行增强操作，且委托类无需实现接口，缺点：不能对final类以及final方法进行代理

[copycode.gif]: /images/20220525/a45ec02a93c540539e44d4efc9476500.png
[577318-20180511233345910-707141223.png]: /images/20220525/349f3490548b4b9ea100f58b2ac680bb.png
[https_blog.csdn.net_jiankunking_article_details_52143504]: https://blog.csdn.net/jiankunking/article/details/52143504
[577318-20180511234023310-926742201.png]: /images/20220525/1abe119c26564489bdabd2a2eb7e77ec.png
[577318-20180511234652906-687667373.png]: /images/20220525/44da99ff43894caba4a3184a52f09961.png