java设计模式——动态代理之原理讲解（4）

Love The Way You Lie 2022-05-14 03:45 170阅读 0赞

# 1.为什么要使用动态代理类 #

我们还是先回到最初的静态代理来看，静态代理的类图如下：

![70][]

其中：Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来真正完成业务服务功能；Proxy角色负责将自身的Request请求，调用realsubject 对应的request功能来实现业务功能，自己不真正做业务

**但是Proxy类通过编译器编译成class文件，当系统运行时，此class已经存在了**。并且由于Proxy和RealSubject的功能 本质上是相同的，Proxy只是起到了中介的作用，这种代理在系统中的存在，导致系统结构比较臃肿和松散。

为了解决这个问题，就有了动态地创建Proxy的想法：在运行状态中，**需要代理的地方，根据Subject 和RealSubject，动态地创建一个Proxy，用完之后，就会销毁，**这样就可以避免了Proxy 角色的class在系统中冗杂的问题了。但是这样“动态”的创建代理类过程还是过于复杂（特别是当代理类的一些业务逻辑过于复杂时）———本质和静态一样，只是在需要的时候再创建一个和静态Proxy类一样的代理类。

# 2. InvocationHandler和Proxy #

其实我们认真思考下代理类的处理逻辑很简单：在调用RealSubject方法时再额外做一些业务。那么，为了构造出具有通用性和简单性的代理类，可以**将所有的触发真实角色动作交给一个触发的管理器，让这个管理器统一地管理触发**。这种管理器就是Invocation Handler。

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

![70 1][]

最重要的一点：**代理Proxy 和RealSubject 应该实现相同的功能！！**

在面向对象的编程之中，如果我们想要约定Proxy 和RealSubject可以实现相同的功能，有两种方式：

1.  一个比较直观的方式，就是定义一个功能接口，然后让Proxy 和RealSubject来实现这个接口**。**
2.  还有比较隐晦的方式，就是通过继承。因为如果Proxy 继承自RealSubject，这样Proxy则拥有了RealSubject的功能，Proxy还可以通过重写RealSubject中的方法，来实现多态。

显然我们根据上面的图可以看出，**JDK中提供创建动态代理的机制就是1方法**（cglib是第二种）

### 2.1 InvocationHandler ###

**InvocationHandler接口**是在java.lang.reflect，唯一的一个方法是invoke如下：

Object invoke(Object proxy, Method method, Object[] args)

这个方法有三个参数，其中第二和第三个参数都比较好理解，一个是被拦截的方法，一个是该方法的参数列表。关键是第一个参数。按照doc文档的解析，proxy - the proxy instance that the method was invoked on也就是说，proxy应该是一个代理实例（动态代理类）。

### 2,2 Proxy ###

**Porxy类**是在java.lang.reflect.Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

Proxy类中的方法

//使用其调用处理程序的指定值从子类（通常为动态代理类）构建新的 Proxy 实例。 
    protected  Proxy(InvocationHandler h) 
    
    //返回指定代理实例的调用处理程序。
    static InvocationHandler getInvocationHandler(Object proxy)  
    
    //返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。 
    static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)
    
    //当且仅当指定的类通过 getProxyClass 方法或 newProxyInstance 方法动态生成为代理类时，返回 true。 
    static boolean isProxyClass(Class<?> cl)
    
    //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
    static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

# 3. jdk中的动态代理 #

比如现在想为RealSubject这个类创建一个动态代理对象，JDK主要会做以下工作：

1.  获取 RealSubject上的所有接口列表；
2.  确定要生成的代理类的类名，默认为：com.sun.proxy.$ProxyXXXX ；
3.  根据需要实现的接口信息，在代码中动态创建 该Proxy类的字节码；
4.  将对应的字节码转换为对应的class 对象；
5.  创建InvocationHandler 实例handler，用来处理Proxy所有方法调用；
6.  Proxy 的class对象 以创建的handler对象为参数，实例化一个proxy对象

其实我们动态代理实际利用的就是反射技术

外界对Proxy角色中的每一个方法的调用，Proxy角色都会交给InvocationHandler来处理，而InvocationHandler则是通过反射调用具体对像的角色方法

接下来我们来看个实例：

public interface Subject
    {
        public void rent();
        
        public void hello(String str);
    }

public class RealSubject implements Subject
    {
        @Override
        public void rent()
        {
            System.out.println("I want to rent my house");
        }
        
        @Override
        public void hello(String str)
        {
            System.out.println("hello: " + str);
        }
    }

public class DynamicProxy implements InvocationHandler
    {
        //　这个就是我们要代理的真实对象
        private Object subject;
        
        //    构造方法，给我们要代理的真实对象赋初值
        public DynamicProxy(Object subject)
        {
            this.subject = subject;
        }
        
        @Override
        public Object invoke(Object object, Method method, Object[] args)
                throws Throwable
        {
            //　　在代理真实对象前我们可以添加一些自己的操作
            System.out.println("before rent house");
            
            System.out.println("Method:" + method);
            
            //    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
            method.invoke(subject, args);
            
            //　　在代理真实对象后我们也可以添加一些自己的操作
            System.out.println("after rent house");
            
            return null;
        }
    
    }

public class Client
    {
        public static void main(String[] args)
        {
            //    我们要代理的真实对象
            Subject realSubject = new RealSubject();
    
            //    我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
            InvocationHandler handler = new DynamicProxy(realSubject);
    
            /*
             * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
             * 第一个参数 realSubject .getClass().getClassLoader() ，我们这里使用realSubject 这个类的ClassLoader对象来加载我们的代理对象
             * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
             * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
             */
            Subject subject = (Subject)Proxy.newProxyInstance(realSubject .getClass().getClassLoader(), realSubject
                    .getClass().getInterfaces(), handler);
            
            System.out.println(subject.getClass().getName());
            subject.rent();
            subject.hello("world");
        }
    }
    
    
    
    
    结果：
    $Proxy0
    
    before rent house
    Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent()
    I want to rent my house
    after rent house
    
    before rent house
    Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)
    hello: world
    after rent house

我们首先来看看** $Proxy0** 这东西，我们看到，这个东西是由 **System.out.println(subject.getClass().getName())**; 这条语句打印出来的，那么为什么我们返回的这个代理对象的类名是这样的呢？

Subject subject = (Subject)Proxy.newProxyInstance(realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);

可能我以为返回的这个代理对象会是Subject类型的对象，或者是InvocationHandler的对象，结果却不是，首先我们解释一下**为什么我们这里可以将其转化为Subject类型的对象？**原因就是在newProxyInstance这个方法的第二个参数上，我们给这个代理对象提供了一组什么接口，那么我这个代理对象就会实现了这组接口，这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，因为这里的接口是Subject类型，所以就可以将其转化为Subject类型了。

**同时我们一定要记住，通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号**。

接着我们来看看这两句

**subject.rent();  
subject.hello("world");**

这里是通过代理对象来调用实现的那种接口中的方法，这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行，而我们的这个 handler 对象又接受了一个 RealSubject类型的参数，表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行：

public Object invoke(Object object, Method method, Object[] args)
                throws Throwable
        {
            //　　在代理真实对象前我们可以添加一些自己的操作
            System.out.println("before rent house");
            
            System.out.println("Method:" + method);
            
            //    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
            method.invoke(subject, args);
            
            //　　在代理真实对象后我们也可以添加一些自己的操作
            System.out.println("after rent house");
            
            return null;
        }

我们看到，在真正通过代理对象来调用真实对象的方法的时候，我们可以在该方法前后添加自己的一些操作，同时我们看到我们的这个 method 对象是这样的：

public abstract void com.xiaoluo.dynamicproxy.Subject.rent()
    
    public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

正好就是我们的Subject接口中的两个方法，这也就证明了当我通过代理对象来调用方法的时候，起实际就是委托由其关联到的 handler 对象的invoke方法中来调用，并不是自己来真实调用，而是通过代理的方式来调用的。

# 4. Proxy的源码解析 #

首先来看看类**Proxy**的代码实现 **Proxy**的主要静态变量

// 映射表：用于维护类装载器对象到其对应的代理类缓存
    private static Map loaderToCache = new WeakHashMap(); 
    
    // 标记：用于标记一个动态代理类正在被创建中
    private static Object pendingGenerationMarker = new Object(); 
    
    // 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断
    private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); 
    
    // 关联的调用处理器引用
    protected InvocationHandler h;

**Proxy**的构造方法

// 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用
    private Proxy() {} 
    
    // 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用
    protected Proxy(InvocationHandler h) {this.h = h;}

**Proxy**静态方法**newProxyInstance**

public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces, InvocationHandler h) throws IllegalArgumentException { 
        // 检查 h 不为空，否则抛异常
        if (h == null) { 
            throw new NullPointerException(); 
        } 
    
        // 获得与指定类装载器和一组接口相关的代理类类型对象
        Class cl = getProxyClass(loader, interfaces); 
    
        // 通过反射获取构造函数对象并生成代理类实例
        try { 
            Constructor cons = cl.getConstructor(constructorParams); 
            return (Object) cons.newInstance(new Object[] { h }); 
        } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); 
        } catch (IllegalAccessException e) { throw new InternalError(e.toString()); 
        } catch (InstantiationException e) { throw new InternalError(e.toString()); 
        } catch (InvocationTargetException e) { throw new InternalError(e.toString()); 
        } 
    }

类**Proxy**的**getProxyClass**方法调用**ProxyGenerator**的 **generateProxyClass**方法产生ProxySubject.class的二进制数据：

反编译后的**ProxySubject.java** **Proxy**静态方法**newProxyInstance**

import java.lang.reflect.*;   
    public final class ProxySubject extends Proxy   
        implements Subject   
    {   
        private static Method m1;   
        private static Method m0;   
        private static Method m3;   
        private static Method m2;   
        public ProxySubject(InvocationHandler invocationhandler)   
        {   
            super(invocationhandler);   
        }   
        public final boolean equals(Object obj)   
        {   
            try  
            {   
                return ((Boolean)super.h.invoke(this, m1, new Object[] {   
                    obj   
                })).booleanValue();   
            }   
            catch(Error _ex) { }   
            catch(Throwable throwable)   
            {   
                throw new UndeclaredThrowableException(throwable);   
            }   
        }   
        public final int hashCode()   
        {   
            try  
            {   
                return ((Integer)super.h.invoke(this, m0, null)).intValue();   
            }   
            catch(Error _ex) { }   
            catch(Throwable throwable)   
            {   
                throw new UndeclaredThrowableException(throwable);   
            }   
        }   
        public final void doSomething()   
        {   
            try  
            {   
                super.h.invoke(this, m3, null);   
                return;   
            }   
            catch(Error _ex) { }   
            catch(Throwable throwable)   
            {   
                throw new UndeclaredThrowableException(throwable);   
            }   
        }   
        public final String toString()   
        {   
            try  
            {   
                return (String)super.h.invoke(this, m2, null);   
            }   
            catch(Error _ex) { }   
            catch(Throwable throwable)   
            {   
                throw new UndeclaredThrowableException(throwable);   
            }   
        }   
        static    
        {   
            try  
            {   
                m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {  Class.forName("java.lang.Object") });   
                m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);   
                m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);   
                m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);   
            }   
            catch(NoSuchMethodException nosuchmethodexception)   
            {   
                throw new NoSuchMethodError(nosuchmethodexception.getMessage());   
            }   
            catch(ClassNotFoundException classnotfoundexception)   
            {   
                throw new NoClassDefFoundError(classnotfoundexception.getMessage());   
            }   
        }   
    }

**仔细观察可以看出生成的动态代理类有以下特点:**

*  继承自 java.lang.reflect.Proxy，实现了Subject接口；
 *  类中的所有方法都是final 的；
 *  所有的方法功能的实现都统一调用了InvocationHandler的invoke()方法。

即调用代理对象方法时，代理对象会触发传入InvocationHandler中的Invoke方法，invoke（）方法通过Method参数来区分是什么方法，进而相应的处理。一般情况下，InvocationHandler的invocke（）方法体内，会调用method.invoke（）方法来调用具体对象对应的method

一个典型的动态代理创建对象过程可分为以下四个步骤：

1.  通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);
2.  通过为Proxy类指定**ClassLoader对象**（需要代理的realSubject的ClassLoader）和**一组interface**（realSubject实现的接口）**创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class\[\]\{...\})**;
3.  通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型Constructor constructor = clazz.getConstructor(new Class\[\]\{InvocationHandler.class\});
4.  通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object\[\] (handler));为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）

诚然，**Proxy**已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持**interface**代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫**Proxy**。Java的继承机制注定了这些动态代理类们无法实现对class的动态代理，原因是多继承在Java中本质上就行不通。

[70]: /images/20220514/34e227b03ab34a189cf390d98b295f48.png
[70 1]: /images/20220514/bbd08f01b7a74ee9a794d8c8abae247f.png