教你清楚了解JAVA动态代理

• 代理在生活中很常见，好比说婚介网站，其实就是找对象的代理；还有社保代理、人事代理；还有找黄牛抢票，其实也是一种代理；而这些代理，在JAVA中也是有对应实现的。

一、为何要动态代理

动态代理的做用其实就是在不修改原代码的前提下，对已有的方法进行加强。

关键点：

• 不修改原来已有的代码（知足设计模式的要求）
• 对已有方法进行加强

二、举个栗子

咱们用一个很简单的例子来讲明： Hello 类，有一个 introduction 方法。

如今咱们的需求就是不修改 Hello 类的 introduction 方法，在 introduction 以前先 sayHello ，在 introduction 以后再 sayGoodBye

三、实现方式

JAVA中，实现动态代理有两种方式，一种是JDK提供的，一种是第三方库 CgLib 提供的。特色以下：

CgLib

3.一、JDK动态代理

JDK动态代理须要实现接口，而后经过对接口方法的加强来实现动态代理

因此要使用JDK动态代理的话，咱们首先要建立一个接口，而且被代理的方法要在这个接口里面

3.1.一、建立一个接口

咱们建立一个接口以下：

Personal.java

public interface Personal { /** * 被代理的方法 */ void introduction(); }

3.1.二、实现接口

建立接口实现类，而且完成 introduction 方法

PersonalImpl.java

public class PersonalImpl implements Personal { @Override public void introduction() { System.out.println("我是程序员！"); } }

3.1.三、建立代理类

JDK代理的关键就是这个代理类了，须要实现 InvocationHandler

在代理类中，全部方法的调用都好分发到 invoke 方法中。咱们在 invoke 方法完成对方法的加强便可

JDKProxyFactory.java

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class JDKProxyFactory<T> implements InvocationHandler { /** * 目标对象 */ private T target; /** * 构造函数传入目标对象 * * @param target 目标对象 */ public JDKProxyFactory(T target) { this.target = target; } /** * 获取代理对象 * * @return 获取代理 */ public T getProxy() { return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 对方法加强 System.out.println("你们好！"); // 调用原方法 Object result = method.invoke(target, args); // 方法加强 System.out.println("再见！"); return result; } }

就这样，JDK动态代理的代码就完成了，接下来写一份测试代码

3.1.四、编写测试代码

为了方便测试，咱们编写一个 test 方法

同时为了查看class文件，还添加了一个 generatorClass 方法，这个方法能够将动态代理生成的 .class 输出到文件

ProxyTest.java

import org.junit.Test; import sun.misc.ProxyGenerator; import java.io.FileOutputStream; import java.io.IOException; public class ProxyTest { @Test public void testJdkProxy() { // 生成目标对象 Personal personal = new PersonalImpl(); // 获取代理对象 JDKProxyFactory<Personal> proxyFactory = new JDKProxyFactory<>(personal); Personal proxy = proxyFactory.getProxy(); // 将proxy的class字节码输出到文件 generatorClass(proxy); // 调用代理对象 proxy.introduction(); } /** * 将对象的class字节码输出到文件 * * @param proxy 代理类 */ private void generatorClass(Object proxy) { FileOutputStream out = null; try { byte[] generateProxyClass = ProxyGenerator.generateProxyClass(proxy.getClass().getSimpleName(), new Class[]{proxy.getClass()}); out = new FileOutputStream(proxy.getClass().getSimpleName() + ".class"); out.write(generateProxyClass); } catch (Exception e) { e.printStackTrace(); } finally { if (out != null) { try { out.close(); } catch (IOException e) { // TODO Auto-generated catch block } } } } }

3.1.五、查看运行结果

能够看到，运行 test 方法以后，控制台打印出以下：

你们好！ 我是程序员！ 再见！

咱们在 introduction 方法前和后都成功增长了功能，让这个程序员的自我介绍瞬间变得更加有礼貌了。

3.1.六、探探动态代理的秘密

动态代理的代码并很少，那么JDK底层是怎么帮咱们实现的呢？

在测试的时候咱们将动态生成的代理类的 class 字节码输出到了文件，咱们能够反编译看看。

结果有点长，就不所有贴出来了，不过咱们能够看到，里面有一个 introduction 方法以下：

/** * the invocation handler for this proxy instance. * @serial */ protected InvocationHandler h; protected Proxy(InvocationHandler h) { Objects.requireNonNull(h); this.h = h; } public final void introduction() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } }

原来，生成的代理对象里面，引用了咱们的 InvocationHandler ，而后在将 introduction 方法里面调用了 InvocationHandler 的 introduction ，而 InvocationHandler 是由咱们编写的代理类，在这里咱们增长了 sayHello 和 sayGoodBye 操做，而后还调用了原对象的 introduction 方法，就这样完成了动态代理。

3.二、CgLib动态代理

CgLib 动态

3.2.一、建立被代理对象

因为 CgLib 不须要实现接口，因此咱们不须要建立接口文件了（固然，你要有接口也没有问题）

直接建立目标类，实现 introduction 方法

PersonalImpl.java

public class PersonalImpl { public void introduction() { System.out.println("我是程序员！"); } }

3.2.二、建立代理类

一样，咱们也须要建立代理类，而且在这里实现加强的逻辑，此次咱们不是实现 InvocationHandler 接口了，而是实现 CgLib 提供的接口 MethodInterceptor ，都是相似的， MethodInterceptor 中，所有方法调用都会交给 intercept 处理，咱们在 intercept 添加处理逻辑便可。

CgLibProxyFactory.java

import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class CgLibProxyFactory<T> implements MethodInterceptor { /** * 获取代理对象 * * @param tClass 被代理的目标对象 * @return 代理对象 */ public T getProxyByCgLib(Class<T> tClass) { // 建立加强器 Enhancer enhancer = new Enhancer(); // 设置须要加强的类的类对象 enhancer.setSuperclass(tClass); // 设置回调函数 enhancer.setCallback(this); // 获取加强以后的代理对象 return (T) enhancer.create(); } /** * 代理类方法调用回调 * * @param obj 这是代理对象，也就是[目标对象]的子类 * @param method [目标对象]的方法 * @param args 参数 * @param proxy 代理对象的方法 * @return 返回结果，返回给调用者 * @throws Throwable */ @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("你们好！"); Object result = proxy.invokeSuper(obj, args); System.out.println("再见！"); return result; } }

3.2.三、编写测试代码

在刚才的测试方法中，咱们添加一个 cglib 的测试方法：

@Test public void testCgLibProxy() { // 生成被代理的目标对象 PersonalImpl personal = new PersonalImpl(); // 获取代理类 CgLibProxyFactory<PersonalImpl> proxyFactory = new CgLibProxyFactory<>(); PersonalImpl proxy = proxyFactory.getProxyByCgLib((Class<PersonalImpl>) personal.getClass()); // 将proxy的class字节码输出到文件 generatorClass(proxy); // 调用代理对象 proxy.introduction(); }

3.2.四、查看运行结果

运行测试用例，能够看到跟JDK的实现同样的效果

你们好！ 我是程序员！ 再见！

3.2.五、探探动态代理的秘密

跟JDK的测试同样，咱们也来看看生成的 class 文件

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

能够发现，与JDK的动态代理并无区别。

四、如何选择

既然有两种实现方式，那么到底应该怎么选择呢？

就两个原则：

• 目标类有接口实现的， JDK 和 CgLib 均可以选择，你开心就好
• 目标类没有实现任何接口，那只能用 CgLib 了

分享一些知识点给你们但愿能帮助到你们，或者从中启发。

加入Q君羊：821169538 都是java爱好泽，你们能够一块儿讨论交流学习

原文

http://fengqiangboy.com/15377761043880.html