Spring的AOP浅析

淡淡的烟草味﹌ 2023-02-20 07:38 127阅读 0赞

Spring一共有两大核心，IOC和AOP。今天我们谈的是后者，AOP。  
AOP的中文含义是面向切面编程。在面向切面编程之前，我们的公共逻辑和业务逻辑是混杂在一起的。这就导致我们需要关注业务逻辑之外的东西。从软件设计层面来说，我们的方法讲究的是单一性，如果一个方法干了多件事，那就要考虑拆分了。  
怎么拆分呢？  
Spring提供了一个非常好的解决方案，就是AOP。  
AOP，我认为有几个重要的概念：  
1).通知  
封装的公共逻辑，比如：记录日志  
2).切点  
用来确定通知将要应用在哪些目标方法上  
3).织入  
将通知应用到目标方法上的具体实现过程  
4).代理  
这个代理，实际上指的是代理设计模式。Spring的AOP底层依赖代理设计模式来完成AOP，进行方法增强。  
整个AOP都是围绕代理设计模式展开。所以，我们在深入了解AOP之前，有必要简单介绍一下代理设计模式。代理设计模式的UML类图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODM5MDc1_size_16_color_FFFFFF_t_70]  
客户端发起对代理对象ProxySubject的request方法的调用，代理对象将请求转发到实际的处理者RealSubject处。通过这种方式，控制客户端对RealSubject对象的访问。  
接下来，我们直奔重点。看一下Spring的AOP是如何对方法进行增强的？  
动态代理一共有两种实现方式，JDK的动态代理以及Cglib动态代理。实际上，两种方式除了生成代理对象的方式不同，其他的差不多。  
我们先介绍JDK的实现。JDK实现动态代理，依靠的是JDK自身的代理模式类Proxy以及InvocationHandler接口。Proxy用来生成代理对象，InvocationHandler接口实现方法增强，增强的方式就是实现invoke方法。  
我们写一个JDK动态代理的小例子。  
根据上面的UML类图。我们把相关类以及接口创建好。  
Subject接口

public interface DynamicInterface { 
        public void realMethod();
    }

被代理类

public class RealSubject1 implements DynamicInterface{ 
        @Override
        public void realMethod() { 
            System.out.println("我是基础类的方法");
        }
    }

动态代理实现类

public class JdkDynamicProxy implements InvocationHandler{ 
        private Object target;
    
        public JdkDynamicProxy(Object target) { 
            this.target = target;
        }
        public Object getProxy(){ 
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                                          target.getClass().getInterfaces(),
                                          this);
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            System.out.println("对方法开始进行增强");
            Object result = method.invoke(target, args);
            System.out.println("对方法增强完毕");
            return result;
        }
    }

细心的读者可能发现，这里面好像没有提代理类的事啊？之所以将这种方式称之为动态代理，代理类肯定不能是静态代码了。所以，真正的代理类是动态生成的。  
代理对象生成的地方就在JdkDynamicProxy类的getProxy方法。也就是这一句

Proxy.newProxyInstance(target.getClass().getClassLoader(),
                           target.getClass().getInterfaces(),
                           this);

其实，我在看这个例子的时候，有两个疑问。  
1).被代理类为什么一定要实现接口？  
2).代理生成的时候，入参为什么会有JdkDynamicProxy对象(this引用)？  
关于第二个疑问，我猜测和实现InvocationHandler接口有关系，但是jdk是如何对invoke方法进行回调的呢?  
要弄明白上面的两个问题，只有一种办法。  
那就是看一下动态代理对象的生成过程。我大概看了一下JDK关于Proxy.newInstance的源码，方法里面的调用栈挺深的，我直接说我们关心的代码吧，有兴趣的读者可以自行查看该方法的全部调用代码。  
我们关心的代码在Proxy类的apply(ClassLoader loader, Class<?>\[\] interfaces)方法中，具体的就是这一行

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);

这行代码的作用，在方法名上就体现出来了。那就是：生成代理类字节码文件。  
我们自己调用一下这行代码，看看生成出来的代理类长什么样子。通过看代理类源码，是不是可以解决我们上面提出的两个疑问呢？我们拭目以待

public void testGeneClass() { 
            String name = "ProxySubject";
            byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{ DynamicInterface.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();
                }
            }
        }

下图的代码，就是我们实际生成的代理类。也就是Spring AOP的根。接下来，我们看看这里面的代码。

import cn.org.bjca.proxy.DynamicInterface;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    
    public final class ProxySubject
      extends Proxy
      implements DynamicInterface
    { 
      private static Method m1;
      private static Method m2;
      private static Method m3;
      private static Method m0;
      
      public ProxySubject(InvocationHandler paramInvocationHandler)
        throws 
      { 
        super(paramInvocationHandler);
      }
      
      public final boolean equals(Object paramObject)
        throws 
      { 
        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()
        throws 
      { 
        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 realMethod()
        throws 
      { 
        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()
        throws 
      { 
        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("cn.org.bjca.proxy.DynamicInterface").getMethod("realMethod", 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());
        }
      }
    }

其实，看到源码。我们的疑问已经就全部得到了回答。下面，我来说一下我的理解。  
首先是第一个疑问，为什么被代理类一定要实现接口呢？  
从代理类的类签名上可以看到，代理类也实现了相同的接口。这样做，客户端调用代理类的时候，和调用被代理类的方式是一样的，客户端无感知。  
第二个疑问，通过Proxy.newInstance方法生成代理类的时候，为什么要将动态代理实现类JdkDynamicProxy对象作为入参传递进去呢？  
代理类的源代码说的已经非常明白了。简单粗暴的直接调用JdkDynamicProxy的invoke方法，同时将被代理类的所有Method对象传递到invoke方法中。然后在invoke方法中，利用反射完成对原方法的执行。此时，我们就可以在方法执行的前后做一些我们需要的操作了。也就是我们所说的AOP中的通知。  
以上就是，AOP底层的JDK动态代理实现。还有一种Cglib的实现方式，我们也来看一下。  
Cglib的方式，不要求被代理类实现接口。  
写一个demo看一下：  
被代理类

public class SayHelloImpl { 
        public void sayHello(){ 
            System.out.println("hello everyone");
        }
    }

Cglib拦截器类：

public class CglibAopProxy implements MethodInterceptor{ 
    
        /** * 获取Cglib代理类 * @param clazz * @return */
        public Object getProxy(Class clazz){ 
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(this);
            return enhancer.create();
        }
    
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 
            System.out.println("执行方法增强前");
            Object result = methodProxy.invokeSuper(obj, args);
            System.out.println("执行方法增强后");
            return result;
        }
    }

测试类：

@Test
        public void testCglibDynamic(){ 
            CglibAopProxy cglibAopProxy = new CglibAopProxy();
            SayHelloImpl proxy = (SayHelloImpl) cglibAopProxy.getProxy(SayHelloImpl.class);
            proxy.sayHello();
        }

Cglib是如何动态生成代理类的呢？  
原理是：Cglib通过ASM框架给被代理类动态生成了一个子类。该子类重写了父类的所有方法。当客户端调用父类的对应方法时，先调用代理子类的方法，之后在子类中触发对拦截器intercept方法的调用。实现了对方法的增强。下图是ASM框架生成的动态子类源码，我们只看我们关心的sayHello方法实现：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODM5MDc1_size_16_color_FFFFFF_t_70 1]  
我们可以看到，当调用子类的sayHello方法时，先调用拦截器中的intercept方法，实现对方法增强，之后调用父类的方法。感觉原理上和InvocationHandler的机制是一样的，都是回调。不过，Cglib相比较JDK的实现来说，代理类的执行效率要高的多。这是为什么呢？  
因为Cglib引入了FastClass机制，可以精准的定位到客户端要调用的方法，不需要和JDK一样反射执行。但是相比较来说，Cglib首次生成代理类的机制比JDK也要复杂，所以生成代理类的速度要慢很多。  
以上是动态代理类的生成方式。也就是实际干活的类，我们已经知道如何产生了。这些方式都是JDK的东西，和Spring没啥关系。说到底，对于Spring来说，这两种生成代理的方式，对于它来说，就是两种工具。Spring是如何使用这两种工具的呢?  
说到这个，就要提一下面试题中非常常见的BeanFactory和FactoryBean了。  
前者是Spring的实例容器。后者是Spring实例容器产生的一种特殊bean，直译过来就是工厂bean。工厂bean，熟悉设计模式的话，会知道设计模式中有一个简单工厂模式。  
我们看一下简单工厂模式的UML类图。  
![在这里插入图片描述][20200625233855130.png]  
说到这里，大家应该也明白了一个道理吧。想学框架，先要学设计模式。否则，你根本get不到作者的设计思路。这里，给大家推荐一本《大话设计模式》，书不错。  
回归正题。简单工厂模式具体为：我们定义一个工厂类，工厂类根据一定的条件给客户端提供相应的实现。服务端对客户端不可见。降低了客户端和服务端的耦合，当服务端发生变化时，客户端无感知。  
设计模式插播结束，我们说回FactoryBean。它和我们本次要讲的AOP有啥关系？  
其实，Spring对方法增强，产生代理类的入口就是一个FactoryBean的实现，它的名字是：ProxyFacotyBean。这个类中有一个getObject方法，这个方法就是调用JDK或者Cglib产生代理类的源头。  
查看getObject方法的源码可以看到代理类的生成过程。如下：

@Override
    	@Nullable
    	public Object getObject() throws BeansException { 
    		initializeAdvisorChain();
    		if (isSingleton()) { 
    			return getSingletonInstance();
    		}
    		else { 
    			if (this.targetName == null) { 
    				logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
    						"Enable prototype proxies by setting the 'targetName' property.");
    			}
    			return newPrototypeInstance();
    		}
    	}

如果是单例bean，会调用getSingletonInstance方法。我们再来看一下getSingletonInstance方法的实现。

private synchronized Object getSingletonInstance() { 
    		if (this.singletonInstance == null) { 
    			this.targetSource = freshTargetSource();
    			if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) { 
    				// Rely on AOP infrastructure to tell us what interfaces to proxy.
    				Class<?> targetClass = getTargetClass();
    				if (targetClass == null) { 
    					throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
    				}
    				setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
    			}
    			// Initialize the shared singleton instance.
    			super.setFrozen(this.freezeProxy);
    			//注意看这一句
    			this.singletonInstance = getProxy(createAopProxy());
    		}
    		return this.singletonInstance;
    	}

我在注释中加上了，注意看这一句，我们的简单工厂模式，就隐藏在createAopProxy中，我们看一下这个方法的源码

protected final synchronized AopProxy createAopProxy() { 
    		if (!this.active) { 
    			activate();
    		}
    		return getAopProxyFactory().createAopProxy(this);
    	}

我们可以看到代码里面，先获取一个AopProxyFactory工厂对象，在源码中，有一个默认的实现，DefaultAopProxyFactory。

this.aopProxyFactory = new DefaultAopProxyFactory();

我们接着看DefaultAopProxyFactory的createAopProxy方法。

@Override
    	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 
    		if (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.");
    			}
    			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { 
    				return new JdkDynamicAopProxy(config);
    			}
    			return new ObjenesisCglibAopProxy(config);
    		}
    		else { 
    			return new JdkDynamicAopProxy(config);
    		}
    	}

以上，就是Spring AOP中简单工厂模式的实现。根据被代理类是否实现了接口来决定产生JdkDynamicAopProxy还是CglibDynamicAopProxy。后面的这两个类，我们在文章的开头已经介绍过了相关的运行机制。读者自行看一下相关源码就可以了，提醒大家注意的一点是：大家可以多看一下Spring的AOP是如何进行方法增强的，也就是如何得到我们配置的通知，并且将通知织入到具体的业务逻辑中的。  
好了，AOP就说这么多吧。下一篇文章介绍IOC，敬请期待。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODM5MDc1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200625170758874.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODM5MDc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODM5MDc1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200626010106158.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODM5MDc1,size_16,color_FFFFFF,t_70
[20200625233855130.png]: https://img-blog.csdnimg.cn/20200625233855130.png