不学无数——Java动态代理

时间 2019-11-11

标签无数 java 动态代理栏目 Java 繁體版

原文原文链接

动态代理

1. 什么是动态代理

在上一章节中，咱们讲的是代理其实都是静态代理，动态代理是在运行阶段动态的建立代理而且动态的处理对所代理方法的调用。在动态代理上所作的全部调用都会被重定向到单一的调用处理器中。在如今很流行的Spring中有一个AOP（面向切面）的其中核心实现技术就是动态代理的技术。html

2. 为何要用动态代理

动态代理的优点在于能够很方便的对代理类的函数进行统一的处理，而不用修改每一个代理类中的方法。例如咱们想计算出每个方法的执行时间，若是使用静态代理的话，那么就须要在每个代理类中进行更改，可是若是使用了动态代理能够对类的全部方法进行统一的管理。一处添加，全部方法适用。java

3. 动态代理的简单实现

3.1 静态代理的实现

咱们先看一下静态代理的是如何实现的，关于静态代理详细的解释能够看不学无数——Java代理模式，这里只贴出关于静态代理的一些代码。git

Homeowner接口以下：编程

interface Homeowner{
    public void LeaseHouse(Home home);
}

RealHomeowner类以下设计模式

class RealHomeowner implements Homeowner{

    @Override
    public void LeaseHouse(Home home) {
        System.out.println("房价是: "+ home.getPrice());
        System.out.println("房子颜色是: "+ home.getColor());
        System.out.println("房子出租成功");
    }
}

代理类HomeProxy的实现数组

class HomeProxy implements Homeowner{

    private Homeowner homeowner;
    public HomeProxy(Homeowner homeowner){
        this.homeowner = homeowner;
    }

    @Override
    public void LeaseHouse(Home home) {
        System.out.println("中介干预");
        homeowner.LeaseHouse(home);
        System.out.println("中介干预完成");
    }
}

在main方法中使用缓存

public static void main(String[] args) {
    Home home = new Home("red",1000);
    RealHomeowner realHomeowner = new RealHomeowner();
    Homeowner homeowner = new HomeProxy(realHomeowner);
    homeowner.LeaseHouse(home);
}

打印的信息以下：ide

中介干预
房价是: 1000
房子颜色是: red
房子出租成功
中介干预完成

3.2 动态代理的实现

在动态代理中是不须要代理类的，就是不须要上面静态代理中的HomeProxy 类，经过实现了InvocationHandler类，全部方法都由该Handler来处理了，意思就是全部被代理的方法都由InvocationHandler接管实际的处理任务。那么看实际的例子函数

DynamicPro类ui

class DynamicPro implements InvocationHandler{

    //真实被代理的实例对象
    private Object object;

    public DynamicPro(Object object){
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("中介干预");
        Object result = method.invoke(object,args);
        System.out.println("中介干预完成");
        return result;
    }
}

在主方法以下的调用

public static void main(String[] args) {
        Home home = new Home("red",1000);
        //建立一个被代理的实例对象
        RealHomeowner realHomeowner = new RealHomeowner();
        //建立一个与被代理对象相关的InvocationHandler
        DynamicPro dynamicPro = new DynamicPro(realHomeowner);
        //建立一个类加载器
        ClassLoader classLoader = realHomeowner.getClass().getClassLoader();
        //被代理类的接口数组,里面的每个方法都会执行InvocationHandler中的invoke方法
        Class<?>[] proxInterface = realHomeowner.getClass().getInterfaces();
        Homeowner homeowner = (Homeowner) Proxy.newProxyInstance(classLoader,proxInterface,dynamicPro);
        homeowner.LeaseHouse(home);
}

打印以下

中介干预
房价是: 1000
房子颜色是: red
房子出租成功
中介干预完成

4. 动态代理和静态代理的区别

上面是关于动态代理的类图，咱们能够和静态代理的类图进行对比一下

能够看到在动态代理中不须要了实际的代理角色类，由于实际的代理角色在动态代理中时动态生成的。在动态代理中增长了InvocationHandler接口类，这个接口中只有一个方法，就是invoke()方法。咱们能够实现InvocationHandler 类而后在invoke()方法中对调用实际方法时的前置或者后置处理。

5. 动态代理原理简单分析

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

经过上面的代码的Debug发现最后是经过下面代码返回一个对象的

//返回构造器生成的实例对象
 return cons.newInstance(new Object[]{h});

而后发现cons是从下面的代码得到的

//得到此代理类的构造器
final Constructor<?> cons = cl.getConstructor(constructorParams);

cl是从下面的代码中得到的

//查找或生成指定的代理类
Class<?> cl = getProxyClass0(loader, intfs);

而intfs是从下面的代码得到

//克隆一个接口类
final Class<?>[] intfs = interfaces.clone();

随后想进去看getProxyClass0 生成的代理类是什么，可是发现进不去。后来查资料知道它因为是动态生成的，类是缓存在java虚拟机中的，能够经过下面的方法将类打印出来。

public static void main(String[] args) {
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", new Class[] {Homeowner.class});
        String path = "/Users/hupengfei/git/Test/src/main/java/Practice/Day06/Homeowner.class";
        try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类class文件写入成功");
        } catch (Exception e) {
            System.out.println("写文件错误");
        }
    }

对生成的class文件进行反编译，在Idea中能直接查看

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import Practice.Day06.Home;
import Practice.Day06.Homeowner;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Homeowner {
    private static Method m1;
    private static Method m4;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void LeaseHouse(Home var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final Homeowner getProxy() throws  {
        try {
            return (Homeowner)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("Practice.Day06.Homeowner").getMethod("LeaseHouse", Class.forName("Practice.Day06.Home"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("Practice.Day06.Homeowner").getMethod("getProxy");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

首先咱们能够先看生成的此类的构造函数

public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    -----调用了父类的构造函数，而它的父类是Proxy类，父类的构造函数以下
    
    protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }
    --在父类中的h的定义以下
    protected InvocationHandler h;

此时咱们就知道为何咱们的动态代理都会执行传入的InvocationHandler 中的invoke()方法了

在下面的静态代码块中咱们发现了LeaseHouse()方法

m4 = Class.forName("Practice.Day06.Homeowner").getMethod("LeaseHouse", Class.forName("Practice.Day06.Home"));

而后在上面会发现有咱们的方法

public final void LeaseHouse(Home var1) throws  {
    try {
        super.h.invoke(this, m4, new Object[]{var1});
    } catch (RuntimeException | Error var3) {
        throw var3;
    } catch (Throwable var4) {
        throw new UndeclaredThrowableException(var4);
    }
}

此时咱们再回想一下在InvocationHandler 类中的invoke()方法中传入的参数有Method方法了，这样就能够将外部对于被代理对象的调用都转化为调用invoke()方法，再由invoke()方法中调用被代理对象的方法。

动态代理类的字节码在程序运行时由Java反射机制动态生成

6. 参考文章

http://www.javashuo.com/article/p-dxfbzmuu-cx.html
设计模式之禅
Java编程思想