JAVA代理实现

最新推荐文章于 2024-03-13 00:17:43 发布

我连觉都懒得睡

最新推荐文章于 2024-03-13 00:17:43 发布

阅读量376

点赞数 3

文章目录

前言
一、静态代理
二、动态代理
CGLib动态代理

前言

Java动态代理是我们阅读Spring源码的必备知识，之所以有这篇文章是因为本人准备持续更新spring系列相关文章，如果缺少Java代理的文章会让整个体系出现一个重大的缺口。

一、静态代理

静态代理就是在程序运行之前，代理类字节码.class就已编译好，通常一个静态代理类也只代理一个目标类，代理类和目标类都实现相同的接口。直接看代码吧

定义一个公共的接口，代理类和目标类都需要实现这个接口
```
public interface Animal {
    void call();
}
```

定义目标类，同时实现Anima接口，实现call动作

public class Cat implements Animal {
    @Override
    public void call() {
        System.out.println("喵喵~~");
    }
}

public class Dog implements Animal{
	@Override
    public void call() {
        System.out.println("旺旺~~");
    }
}

定义代理类，同时实现Anima接口，实现代理call动作

public class StaticProxyAnimal implements Animal {
    private Animal animal;
    public StaticProxyAnimal(Animal _animal) {
        this.animal = _animal;
    }
    @Override
    public void call() {
        animal.call();
    }
}

输出结果

public class ProxyMain {

    public static void main(String[] args) {
        Animal animalCat = new StaticProxyAnimal(new Cat());
        animalCat.call();

        Animal animalDog = new StaticProxyAnimal(new Dog());
        animalDog.call();
    }
}

喵喵~~
旺旺~~

从上面这个案例中可以看到代理类中通过持有目标类对象，然后通过调用目标类的方法，实现静态代理。静态代理虽然实现了代理，但是存在明显不足之处：

当我们在 Animal 接口中增加方法，这时不仅实现类 Cat 需要新增该方法的实现，同时，由于代理类实现了 Animal 接口，所以代理类也必须实现 Animal 新增的方法，这对项目规模较大时，在维护上就不太友好了。
代理类实现Animal#call是针对 Cat 目标类的对象进行设置的，如果再需要添加 Dog 目标类的代理，那就必须再针对 Dog 类实现一个对应的代理类，这样就使得代理类的重用型不友好，并且过多的代理类对维护上也是比较繁琐。

二、动态代理

动态代理类与静态代理类最主要不同的是，代理类的字节码不是在程序运行前生成的，而是在程序运行时再虚拟机中程序自动创建的。继续用上面 Cat 类和 Animal 接口实现 JDK 动态代理。

1.实现InvocationHandler 接口

JDK 动态代理类必须实现反射包中的 java.lang.reflect.InvocationHandler 接口，在此接口中只有一个 invoker 方法
在这里插入图片描述

在InvocationHandler#invoker中必须调用目标类被代理的方法，否则无法做到代理的实现。下面为实现 InvocationHandler 的代码。

public class TargetInvoker implements InvocationHandler {
	//代理持有的目标类
    private Object target;
    public TargetInvoker(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("jdk动态代理执行之前------>");
        Object result = method.invoke(target, args);
        log.info("jdk动态代理执行之后------>");
        return result;
    }
}

在实现InvocationHandler#invoker时，该方法里有三个参数：

proxy：代理目标对象的代理对象，它是真实的代理对象。
method：执行目标类的方法
args：执行目标类的方法的参数

2.创建 JDK 动态代理类

创建 JDK 动态代理类实例同样也是使用反射包中的 java.lang.reflect.Proxy 类进行创建。通过调用Proxy#newProxyInstance静态方法进行创建。

public class DynamicProxyAnimal {

    public static Object getProxy(Object target) throws Exception {
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//指定目标类的类加载器
                target.getClass().getInterfaces(),//代理实现的接口，这里可以是多个
                new TargetInvoker(target)//代理对象处理器
        );
        return proxy;
    }
}

Proxy#newProxyInstance中的三个参数（ClassLoader loader、Class<?>[] interfaces、InvocationHandler h）：
在这里插入图片描述

loader：加载代理对象的类加载器
interfaces ：代理对象实现的接口，与目标对象实现同样的接口
h：处理代理对象逻辑的处理器，即上面的 InvocationHandler 实现类。

执行结果：

 public static void main(String[] args) {
        try {
            Animal animal = (Animal) DynamicProxyAnimal.getProxy(new Cat());
            animal.call();
            Animal animalDog = (Animal) DynamicProxyAnimal.getProxy(new Dog());
            animalDog.call();
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
    }


jdk动态代理执行之前
喵喵喵～～
jdk动态代理执行之后
jdk动态代理执行之前
旺旺旺~~
jdk动态代理执行之后

到目前位置我们已经了解到jdk动态代理的创建以及调用类，下面我们对其稍加分析。

剖析

我们直接看Proxy#newProxyInstance的源码

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

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

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

newProxyInstance 方法里面获取到代理类，如果类的作用不能访问，使其能被访问到，最后实例化代理类。这段代码中最为核心的是获取代理类的getProxyClass0方法。

private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    // 实现类的接口不能超过 65535 个
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 获取代理类
    return proxyClassCache.get(loader, interfaces);
}

如果 proxyClassCache 缓存中存在指定的代理类，则从缓存直接获取；如果不存在，则通过 ProxyClassFactory 创建代理类。至于为什么接口最大为 65535，这个是由字节码文件结构和 Java 虚拟机规定的，具体可以通过研究字节码文件了解。

看一下proxyClassCache#get是如何获取代理类的:
在这里插入图片描述
继续往下F7发现先进入了java.lang.reflect.WeakCache.Factory#get

valueFactory.apply()又进入了java.lang.reflect.Proxy.ProxyClassFactory#apply， ProxyClassFactory是Proxy的子类。我们来瞅瞅源码：

    private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 所有代理类名称的前缀
        private static final String proxyClassNamePrefix = "$Proxy";
		//下一个用于生成唯一代理类名称的数字
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
              	校验类加载器是否将此接口的名称解析为相同的class对象
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
	           校验interfaceClass是否是接口
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * 确认此接口没有重复
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
			//代理的包名
            String proxyPkg = null; 
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
			记录非public 修饰符代理的接口包，使生成的代理类与它在同一个包下
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    //获取类名
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // 如果接口类是public 修饰，则使用 com.sun.proxy package 包名
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * 创建代理类的名称
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 生成代理类的字节码文件
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
            //加载字节码生成，指定的代理对象
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

创建字节码的大概流程就是通过检查接口的属性，决定代理类字节码文件生成的包名及名称规则，然后加载字节码获取代理实例。操作生成字节码文件在ProxyGenerator#generateProxyClass中生成具体的字节码文件。生成的字节码文件，我们可以通过保存本地进行反编译查看类信息，保存生成的字节码文件可以通过两种方式：设置jvm参数或将生成 byte[] 写入文件。
例如通过设置jvm参数的方式：
在这里插入图片描述

    private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));

ProxyGenerator#generateProxyClass方法是通过 saveGeneratedFiles 属性值控制。通过 System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”); 我们将代理类的字节码文件保存到本地。如下：

public final class $Proxy0 extends Proxy implements Animal {
    private static Method m1;
    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 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 void call() throws  {
        try {
            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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.bootcode.system.proxy.Animal").getMethod("call");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

从字节码文件中我们可看到代理类继承了Proxy和实现了Anmial接口，调用的call方法是通过Proxy持有的InvocationHandler实现TargetInvoker来执行的。

CGLib动态代理

CGLIB 动态代理的实现机制是生成目标类的子类，通过调用父类（目标类）的方法实现，在调用父类方法时再代理中进行增强。

实现 MethodInterceptor 接口

相比于 JDK 动态代理的实现，CGLIB 动态代理不需要实现与目标类一样的接口，而是通过方法拦截的方式实现代理，代码实现如下，首先方法拦截接口 net.sf.cglib.proxy.MethodInterceptor。

public class TargetInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib调用之前");
        Object result = methodProxy.invokeSuper(o,objects);
        System.out.println("cglib调用之后");
        return result;
    }
}

通过方法拦截接口调用目标类的方法，然后在该被拦截的方法进行增强处理，实现方法拦截器接口的 intercept 方法里面有四个参数：

obj 代理类对象
method 当前被代理拦截的方法
args 拦截方法的参数
proxy 代理类对应目标类的代理方法

创建 CGLIB 动态代理类

创建 CGLIB 动态代理类使用 net.sf.cglib.proxy.Enhancer 类进行创建，它是 CGLIB 动态代理中的核心类，首先创建个简单的代理类：

public class CglibProxy {

    public static Object getProxy(Class<?> clazz){
        Enhancer enhancer = new Enhancer();
        // 设置类加载
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new TargetInterceptor());
        // 创建代理类
        return enhancer.create();
    }

}

设置被代理类的信息和代理类拦截的方法的回调执行逻辑，就可以实现一个代理类。实现 CGLIB 动态代理调用：

public static void main(String[] args) {
        try {
            Dog dog = (Dog) CglibProxy.getProxy(Dog.class);
            dog.call();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

输出结果：

cglib调用之前
旺旺旺~~
cglib调用之后

字节码文件

我们可以通过 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, “D:\work\my_work\boot_code\clazz”);设置字节码文件的输出的位置。
在这里插入图片描述

![·1](https://img-blog.csdnimg.cn/20210515155543934.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTc3Njc4,size_16,color_FFFFFF,t_70)

我连觉都懒得睡

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
4
评论
JAVA代理实现

文章目录前言一、静态代理二、动态代理1.引入库2.读入数据总结前言Java动态代理是我们阅读Spring源码的必备知识，之所以有这篇文章是因为本人准备持续更新spring系列相关文章，如果缺少Java代理的文章会让整个体系出现一个重大的缺口。一、静态代理静态代理就是在程序运行之前，代理类字节码.class就已编译好，通常一个静态代理类也只代理一个目标类，代理类和目标类都实现相同的接口。直接看代码吧定义一个公共的接口，代理类和目标类都需要实现这个接口public interface Ani
复制链接

扫一扫