不学无数——Java动态代理

最新推荐文章于 2024-11-04 19:28:45 发布

不学无数的程序员

最新推荐文章于 2024-11-04 19:28:45 发布

阅读量161

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43133353/article/details/82497320

版权

java 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

动态代理

1. 什么是动态代理

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

2. 为什么要用动态代理

动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。例如我们想计算出每一个方法的执行时间，如果使用静态代理的话，那么就需要在每一个代理类中进行更改，但是如果使用了动态代理可以对类的所有方法进行统一的管理。一处添加，所有方法适用。

3. 动态代理的简单实现

3.1 静态代理的实现

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

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);
}

打印的信息如下：

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

3.2 动态代理的实现

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

DynamicPro类

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", Homeowner.class.getInterfaces());
        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);
    }
}