Spring 源码梳理(九) AOP与动态代理

女爷i 2022-07-16 08:18 218阅读 0赞

***Spring 源码梳理(九) AOP与动态代理***

SpringAOP的核心是动态代理，就从动态代理开始分析，然后就会谈到静态代理，以及为什么会有代理这个说法，后面逐一分析：

**1.什么是代理，为什么会有代理？**

类甲的代理就是代替甲来完成甲的功能，比如实际上就是有点像房产中介，本身不提供房产，但是可以帮助开发商把房子卖出去，并且在卖的过程中还能做一些操作，赚的利益。那为什么会有代理呢？ 就类甲来说，我们想执行这个类甲的相关方法，但是在执行的前后想做一些其他的操作，由此就想到了一个方法，就是重写一个类乙，把甲的方法都重写一遍，还加上了自己的东西，这就是静态代理。

**2.静态代理，如下图：**

![Center][]

上面是典型的静态的代理模式，我们看一下示例代码：

Subject

package day_20161010;
    
    public interface Subject {
        public int add(int a,int b);  
        public int div(int a,int b);
    }

RealSubject

package day_20161010;
    
    public class RealSubject implements Subject{
    
    	public int add(int a, int b) {
    		return a+b;
    	}
    
    	public int div(int a, int b) {
    		return  a/b;
    	}
    
    }

Proxy

package day_20161010;
    
    public class Proxy implements Subject{
    	private Subject subject;
    	
    	public Proxy(Subject subject){
    		this.subject = subject;
    	}
    	
    	public int add(int a, int b) {
    		System.out.println("add before...");
    		return subject.add(a, b);
    	}
    
    	public int div(int a, int b) {
    		System.out.println("div before...");
    		return subject.div(a, b);
    	}
    }

Main

package day_20161010;
    
    public class Main {
    	public static void main(String[] args) {
    		RealSubject realSubject = new RealSubject();
    		Subject subject = new Proxy(realSubject);
    		subject.add(1, 2);
    		subject.div(3, 1);
    	}
    }

代码很清晰，只是这样的一个代理是一个java类，1）需要重写每一个接口的方法 2）如果我们增加或减少实现的方法，在代理类中也要增加或减少 3）当代理类想改变对每个实现类方法前后的操作时，则要对所有的代理方法进行更改，如何避免这三种情况，下面进行分析。

**3.先看一张图，图的流程已经在这一篇文章中讲述过**[http://blog.csdn.net/Jintao\_Ma/article/details/52710960][http_blog.csdn.net_Jintao_Ma_article_details_52710960]，本篇只看其中的红色部分：

![Center 1][]

我们看到运行期系统有这样一种能力，它能够在运行期间，根据.class的组织结构动态的生成.class文件的字节码,然后再由类加载器进行加载。由于这个能力，我们可以不再使用静态代理，而让代理class类在运行期期间动态生成。【PS：不知道是为了实现动态代理而让运行期系统具备这种能力，还是运行期先有这种能力从而正好实现动态代理，这点就先不用管了】

如何利用这种能力，对类进行动态代理呢？

1）使用ASM和Javassist框架来手动在运行期系统中动态的生成代理class文件。但是使用起来手动创建了很多的业务代码，同样增加了复杂度

2）JDK本身给我们提供了一种较好的实现，如下：

InvocationHandler角色的由来  
仔细思考代理模式中的代理Proxy角色。Proxy角色在执行代理业务的时候，无非是在调用真正业务之前或者之后做一些“额外”业务，如图：

![Center 2][]

由上图可以看出，代理类处理的逻辑很简单：在调用某个方法前及方法后做一些额外的业务。换一种思路就是：在触发（invoke）真实角色的方法之前或者之后做一些额外的业务。那么，为了构造出具有通用性和简单性的代理类，可以将所有的触发真实角色动作交给一个触发的管理器，让这个管理器统一地管理触发。这种管理器就是Invocation Handler。

动态代理模式的结构跟上面的静态代理模式稍微有所不同，多引入了一个InvocationHandler角色，它的作用如下：

在静态代理中，代理Proxy中的方法，都指定了调用了特定的realSubject中的对应的方法，在上面的静态代理模式下，Proxy所做的事情，无非是调用在不同的request时，调用触发realSubject对应的方法，动态代理工作的基本模式就是将自己的方法功能的实现交给 InvocationHandler角色，外界对Proxy角色中的每一个方法的调用，Proxy角色都会交给InvocationHandler来处理，而InvocationHandler则调用具体对象角色的方法。如下图所示：

![Center 3][]

package day_20160928;
    
    public class mathCount implements Count{  
        public int add(int a,int b){  
            return  a+b;  
        }  
        public int div(int a,int b){  
            return  a/b;  
        }  
    }

**4.前面一片文章分析过动态代理**，但是不够深刻[http://blog.csdn.net/Jintao\_Ma/article/details/51107096][http_blog.csdn.net_Jintao_Ma_article_details_51107096]，下面做一个深刻的实例，代码中的注释有详细的解释：

Count

package day_20160928;
    
    public interface Count {
        public int add(int a,int b);  
        public int div(int a,int b);
        public static int a = 1;
    }

mathCount

dyProxy

package day_20160928;
    
    import java.lang.reflect.InvocationHandler;  
    import java.lang.reflect.Method;  
      
    public class dyProxy implements InvocationHandler{  
        private Object subject;  
        public dyProxy(Object subject){  
            this.subject = subject;  
        }  
        /**
         * 当代理对象调用真实对象的方法时，会自动跳转到其关联的handler对象的invoke方法，
         * 就是下面的这个方法
         * @param proxy 就是我们调用哪一个代理类，就会把哪一个代理类传进来，就是Main中的count
         * @param method args  在使用代理类的方法时会传进来方法名和参数
         */  
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        	int b = ((Count)proxy).a;
        	System.out.println("dyProxy.invoke()："+b);
            /*在执行代理对象的方法前，添加自己的操作*/  
            System.out.println("before method：");  
            System.out.println("the method："+method); 
            try {  
                /*以反射的方式调用真实对象中的方法*/  
                method.invoke(subject, args);
            } catch (Exception e) {  
                e.printStackTrace();  
                /*出现异常打印信息*/  
                System.out.println("exception:");   
            }  
            /*在执行代理对象的方法后，添加自己的操作*/  
            System.out.println("after method:");  
              
            return 1;  
        }  
    }

Main

package day_20160928;
    
    import java.lang.reflect.InvocationHandler;  
    import java.lang.reflect.Proxy;  
      
    public class Main {  
        public static void main(String[] args) {  
            /*建立要代理的真实对象*/  
            mathCount realcount = new mathCount();  
            /*我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的*/  
            InvocationHandler invocationHandler = new dyProxy(realcount);  
            
            /**通过Proxy的newProxyInstance来创建我们的代理对象 
             * @param handler.getClass().getClassLoader(), 这里就是在运行期期间动态地生成二进制字节码，
             * 然后重新用类加载器进行加载（就是本篇文章第二张图中讲的动态生成类然后用类加载器加载）。
             * @param realSubject.getClass().getInterfaces()，标识把这些接口与触发器invocationHandler关联起来，
             * 以后代理类执行到这些接口时，就会调用invocationHandler的invoke方法；同时，realcount.getClass().
             * getInterfaces()表示要代理的类必须有实现的接口
             * @param handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
             * @return  count
             * 表示生成的代理类也只能代理接口中的方法，如Count count = (Count)
             */  
            Count count = (Count)Proxy.newProxyInstance(realcount.getClass().getClassLoader(),  
                    realcount.getClass().getInterfaces(), invocationHandler);  
              
            count.add(1, 2);  
            count.div(3, 1);  
        }  
    }

我们分析下动态代理是如何解决静态代理的那三个问题的：

1）首先不需要重写接口的每一个方法，使用method.invoke(subject, args)一句就可以了

2）我们在接口中和实现类中增加方法，在代理类中还是method.invoke(subject, args)就够了

3）在方法的前后进行更改时，也只需要在method.invoke(subject, args)的前后进行更改可以了。

有人说，静态代理当有很多的实现类的时候会产生多个代理类，很明显不对，我们看上面静态代理例子中的Proxy，构造方法可以接受任何实现类，而只需要Proxy就可以了。所以这并不是动态代理相对于静态代理的优点，真正的优点是上面的三点。用一张图来描述：

![Center 4][]

咦？怎么看起来那么像AOP啊。没错，这就是AOP所宣扬的那样面向切面， AOP本来就是依据动态代理来的。

**5.所谓代理，就是要保证代理类和被代理类具有相同的功能；那怎么保证?**

一种是继承同一个的接口，就像上面JDK实现中的动态代理，它使用的是接口的形式； 我们也发现了一个问题，上面JDK动态代理这样一段代码：

Count count = (Count)Proxy.newProxyInstance(realcount.getClass().getClassLoader(),  
                    realcount.getClass().getInterfaces(), invocationHandler);

我们看到realcount.getClass()，这段代码实际上我们是把实现类中的接口信息与触发器invocationHandler绑定，也就是说如果实现类有接口中没有的方法是不能被代理的。总的来说，JDK这种代理1）要保证有接口，2）不能代理接口中没有的方法  
为避免上面的两种缺陷，这就是要说的另一种动态代理实现方式，那就是代理类继承被代理类，不需要接口，这种实现如 Cglib。 实例如下：

realSubject

package day_20161011;
    
    public class realSubject {
    
    	public void add()  
        {  
            System.out.println("realSubject.add()");
        }  
    	
    }

doProxy

package day_20161011;
    
    import java.lang.reflect.Method;
    
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;  
    /* 
     * 实现了方法拦截器接口 
     */  
    public class doProxy implements MethodInterceptor {  
        public Object intercept(Object obj, Method method, Object[] args,  
                MethodProxy proxy) throws Throwable {  
            System.out.println("before method");  
            proxy.invokeSuper(obj, args);  
            System.out.println("after method");  
            return null;  
        }  
    }

Main

package day_20161011;
    
    import org.springframework.cglib.proxy.Enhancer;
    
    public class Main {
    	public static void main(String[] args) {
    		realSubject realsubject = new realSubject();  
    	    doProxy doproxy = new doProxy();  
    	    
    	    //cglib 中加强器，用来创建动态代理  
    	    Enhancer enhancer = new Enhancer();    
    	    //设置要创建动态代理的类  
    	    enhancer.setSuperclass(realsubject.getClass());    
    	    //设置回调，这里相当于是对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实行intercept()方法进行拦截  
    	    enhancer.setCallback(doproxy);  
    	    realSubject proxy =(realSubject)enhancer.create();  
    	    proxy.add();  
    	}
    }

它的流程是这样的：

1).查找A上的所有非final 的public类型的方法定义；  
2).将这些方法的定义转换成字节码；  
3).将组成的字节码转换成相应的代理的class对象；  
4).实现 MethodInterceptor接口，用来处理 对代理类上所有方法的请求（这个接口和JDK动态代理InvocationHandler的功能和角色是一样的）

**6.本篇总结：其实所有AOP带来的好处都是基于一点------"在被代理的方法前后执行一些操作"（^\_^）**

本文参考文章：[http://blog.csdn.net/luanlouis/article/details/24589193][http_blog.csdn.net_luanlouis_article_details_24589193]

[Center]: /images/20220716/08f872643a1c44c08b165933e99a773f.png
[http_blog.csdn.net_Jintao_Ma_article_details_52710960]: http://blog.csdn.net/Jintao_Ma/article/details/52710960
[Center 1]: /images/20220716/4127748a83924eeba81a63757456b03f.png
[Center 2]: /images/20220716/0af2d0e37ea04f6396027cf30a2038ae.png
[Center 3]: /images/20220716/b40e619efe2c43b588a804662b438fda.png
[http_blog.csdn.net_Jintao_Ma_article_details_51107096]: http://blog.csdn.net/Jintao_Ma/article/details/51107096
[Center 4]: /images/20220716/880650d94cfb4942ae6d5bdf378a10b4.png
[http_blog.csdn.net_luanlouis_article_details_24589193]: http://blog.csdn.net/luanlouis/article/details/24589193