回顾SpringAOP的实现原理

逃离我推掉我的手 2022-10-27 05:24 211阅读 0赞

## 一 概述 ##

**面向切面编程的织入时机**

**1. 编译期织入（AspectJ）**

**2. 类加载加载织入（AspectJ 5+）**

**3. 运行时（Spring AOP）**

## **二 运行时织入的实现逻辑** ##

**代理对象的交互图**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70][]

如图，客户端是通过代理对象间接的同目标对象进行交互，换言之，目标对象委托了代理对象同客户端进行交互。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70 1][]

根据类图可知，客户端通过接口来对目标对象或代理对象进行引用，这里就涉及了一个很重要的原则，面向接口编程，这时候就涉及到两个重要的结论：

1. 因为客户端调用的真正对象的方法，代理类都要有。所以代理对象和调用对象都要作为该接口的实现类。

2. 代理对象会将方法委托给真正的对象进行执行，而代理类就执行一些额外的逻辑，即AOP织入的逻辑。

**运行时织入是通过代理对象，代理可以分为了两种：**静态代理和动态代理。

**其中动态代理又分为基于接口代理和基于继承代理实现，这两类的代表为JDK代理与CGlib代理。**

## **三 运行时织入之静态代理的实现** ##

**接口类**

public interface IA {
    
        void getName();
    }

**接口实际实现类**

public class RealIA implements IA{
    
        @Override
        public void getName() {
            System.out.println("真正对象实现请求!");
        }
    }

**接口代理类**

public class ProxyIA implements IA{
    
        //代理对象需要委托真正对象去完成一些逻辑
        private RealIA realIA;
    
        //强制
        public ProxyIA(RealIA realIA) {
            this.realIA = realIA;
        }
    
        //代理对象不会实现真是的逻辑
        @Override
        public void getName() {
    
            //类似于AOP的before,after,around
            //代理对象完成其他逻辑
            System.out.println("before代理逻辑");
    
            //代理对象委托真正的对象来完成客户端逻辑
            try {
                realIA.getName();
            } catch (Exception e) {
                System.out.println("ex:" + e.getMessage());
                throw e;
            } finally {
                System.out.println("after代理逻辑");
            }
        }
    }

**由上述静态代理的实现可知，当接口中方法越多，需要实现的代理方法越多时，重复的逻辑就越多。**

## **四 运行时织入之JDK动态代理** ##

1. JDK代理需要通过java.lang.reflect.Proxy类来动态生成代理类

2. 代理类需要实现织入逻辑需要实现接口InvocationHandler

3. JDK动态代理只能基于**接口**进行动态代理

**JDK动态代理代码实现**

**JDK动态代理类**

public class JdkProxySubject implements InvocationHandler {
    
        private RealIA realIA;
    
        public JdkProxySubject(RealIA realIA) {
            this.realIA = realIA;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //织入的逻辑
            System.out.println("before代理");
    
            Object result = null;
            try{
                //通过invoke方法执行动态代理的逻辑
                //Method通过应用反射机制,来动态反射方法
                result = method.invoke(realIA,args);
            }catch (Exception e){
    
            }finally {
                //织入的逻辑
                System.out.println("after代理");
            }
            return result;
        }
    }

**JDK动态代理客户端**

public class JdkClient {
    
        public static void main(String[] args) {
            IA ia = (IA) Proxy.newProxyInstance(JdkClient.class.getClassLoader(),
                    new Class[]{IA.class},new JdkProxySubject(new RealIA()));
            ia.getName();
        }
    }

**结合上面的IA接口和RealIA实现类，就完成了JDK动态代理的实例。**

## **五 运行时织入之JDK动态代理底层逻辑** ##

根据实例代码可知JDK动态代理的代码生成，先通过Proxy.newProxyInstance方法，接着调用一次通过方法getProxyClass0，ProxyClassFactory，ProxyGenerator方法实现动态代理的代码的生成 ，这个过程生成的代码时字节码，最后通过Java的反射机制new出实例代码。

**newProxyInstance方法源码**

@CallerSensitive
        public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
    
            //寻找或者生成指定代理类
            /*
             * Look up or generate the designated proxy class.
             */
            Class<?> cl = getProxyClass0(loader, intfs);
    }

**getProxyClass0方法源码**

private static Class<?> getProxyClass0(ClassLoader loader,
                                               Class<?>... interfaces) {
            if (interfaces.length > 65535) {
                throw new IllegalArgumentException("interface limit exceeded");
            }
    
            //如果缓存中存在代码，则getProxyClass0方法先从缓存中获取代码，如果没有就会通过ProxyClassFactory进行创建并放入缓存
            // If the proxy class defined by the given loader implementing
            // the given interfaces exists, this will simply return the cached copy;
            // otherwise, it will create the proxy class via the ProxyClassFactory
            return proxyClassCache.get(loader, interfaces);
        }

**缓存源码**

proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

**ProxyClassFactory方法源码**

private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>
        {
            // prefix for all proxy class names
            private static final String proxyClassNamePrefix = "$Proxy";
    
            // next number to use for generation of unique proxy class names
            private static final AtomicLong nextUniqueNumber = new AtomicLong();
    
            @Override
            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");
                    }
    }

**代理类名称格式**

/*
        * Choose a name for the proxy class to generate.
        */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

**根据源码可知，代理类的最后名称中包含long类型的数字字符。**

## **六 运行时织入之CGlib动态代理** ##

**Cglib动态代理类**

public class IAInterceptor implements MethodInterceptor {
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("before in cglib");
                Object result = null;
                try{
                    result = methodProxy.invokeSuper(o,objects);
                }catch (Exception e){
                    System.out.println(e.getMessage());
                }finally {
                    System.out.println("after in cglib");
                }
                return result;
        }
    }

**Cglib动态代理客户端类**

public class CglibClient {
    
        public static void main(String[] args) {
            //Cglib的增强对象
            Enhancer enhancer = new Enhancer();
            //设置增强类型，增强真是对象
            enhancer.setSuperclass(RealIA.class);
            enhancer.setCallback(new IAInterceptor());
            IA ia = (IA) enhancer.create();
            ia.getName();
        }
    }

基于静态代理的接口IA真正实现类RealIA来实现的代码实例 。

## 七 JDK动态代理和Cglib动态代理之间的区别 ##

1. JDK动态代理时基于接口实现的动态代理，对接口中的方法进行代理织入代码。

2. Cglib动态代理是基于继承实现的动态代理，所以实现Static和final类进行代理。

3. 同因为Cglib动态代理是基于继承实现的动态代理，所以无法完成Static和private方法的代理。

4. 因为接口中方法不可以是private方法，所以JDK动态代理也无法完成private方法的代理。

## 八 Spring创建代理bean的方法 ##

**对于动态代理而言，同时存在JDK动态代理和Cglib动态代理两种。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70 2][]

**根据Spring创建代理类的时序图可得，先由AbstractAutoProxyCreator类调用createProxy方法返回代理类。**

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
    		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {	
        protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
    			@Nullable Object[] specificInterceptors, TargetSource targetSource) {
    
    		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
    			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    		}
    
    		ProxyFactory proxyFactory = new ProxyFactory();
    		proxyFactory.copyFrom(this);
    
    		if (!proxyFactory.isProxyTargetClass()) {
    			if (shouldProxyTargetClass(beanClass, beanName)) {
    				proxyFactory.setProxyTargetClass(true);
    			}
    			else {
    				evaluateProxyInterfaces(beanClass, proxyFactory);
    			}
    		}
    
    		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    		proxyFactory.addAdvisors(advisors);
    		proxyFactory.setTargetSource(targetSource);
    		customizeProxyFactory(proxyFactory);
    
    		proxyFactory.setFrozen(this.freezeProxy);
    		if (advisorsPreFiltered()) {
    			proxyFactory.setPreFiltered(true);
    		}
    
    		return proxyFactory.getProxy(getProxyClassLoader());
    	}
    }

**而createProxy方法又是调用ProxyFactory来生成的，然而createProxy方法又是委托给ProxyCreatorSupport类来生成。**

public class ProxyCreatorSupport extends AdvisedSupport {
        protected final synchronized AopProxy createAopProxy() {
    		if (!this.active) {
    			activate();
    		}
    		return getAopProxyFactory().createAopProxy(this);
    	}
    }

**最后ProxyCreatorSupport又是通过DefaultAopProxyFactory来实现的。**

public class ProxyCreatorSupport extends AdvisedSupport {
        public ProxyCreatorSupport() {
    		this.aopProxyFactory = new DefaultAopProxyFactory();
    	}
    }

**DefaultAopProxyFactory实现createAopProxy生成代理类的方法。**

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    
    	/**
    	 * Whether this environment lives within a native image.
    	 * Exposed as a private static field rather than in a {@code NativeImageDetector.inNativeImage()} static method due to https://github.com/oracle/graal/issues/2594.
    	 * @see <a href="https://github.com/oracle/graal/blob/master/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/ImageInfo.java">ImageInfo.java</a>
    	 */
    	private static final boolean IN_NATIVE_IMAGE = (System.getProperty("org.graalvm.nativeimage.imagecode") != null);
    
    	@Override
    	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    		if (!IN_NATIVE_IMAGE &&
    				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
    			Class<?> targetClass = config.getTargetClass();
    			if (targetClass == null) {
    				throw new AopConfigException("TargetSource cannot determine target class: " +
    						"Either an interface or a target is required for proxy creation.");
    			}
                //使用JDK动态代理
    			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    				return new JdkDynamicAopProxy(config);
    			}
                //Cglib动态代理
    			return new ObjenesisCglibAopProxy(config);
    		}
    		else {
                //使用JDK动态代理
    			return new JdkDynamicAopProxy(config);
    		}
    	}
    }

根据源码可知，Spring中只有两种情况使用JDK动态代理，其他的情况都是使用Cglib动态代理。

根据上述源码可知，当目标对象实现了接口的情况下，默认使用的JDK动态代理，而没有实现接口的情况下，则使用的是Cglib动态代理，当然在目标对象实现了接口的情况下，但是强制使用Cglib动态代理的情况下，还是会通过Cglib动态代理。

## 九 SpringBoot中强制使用CGlib动态代理的方法 ##

@SpringBootApplication
    //强制使用Cglib动态代理
    public class SpringaopApplication {
    
        public static void main(String[] args) { SpringApplication.run(SpringaopApplication.class, args); }
    }

根据实例代码可知通过注解@EnableAspectJAutoProxy(proxyTargetClass = true)可以强制使用Cglib动态代理。

**这样做的原理的使得if (!IN\_NATIVE\_IMAGE && (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)))判断条件中的config.isProxyTargetClass()为true。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70]: /images/20221024/79e244b8787e40ff9b0eeea13c8f793b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70 1]: /images/20221024/b1c1ee01803b489699fd0bc7ff2615cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70 2]: /images/20221024/315e1d245c124429b4d1da1afd70ab1f.png