java动态代理（jdk和cglib）
分类：软件编程
阅读：7022
作者：majingjing
发布：2016-11-02 11:29

在TMBlog的系统程序中,使用了大量的代理.
并非是代理在程序中非得使用,而是在这个系统中将所涉及到的知识都应用在了TMBlog中.
其中典型的实现就是hessian的接口服务发布.
学习过hessian的客官都知道,发布hessian服务必须要使用接口和实现类.(具体请参见这篇文章)
尤其是在和spring做集成的时候,spring的暴露服务校验更是相当的全面.原因也是因为hessian在安全方面做得确实不是很强,安全机制都要求自己去实现.

下面介绍下两种代理的示例
1. jdk代理
MyInvocationHandler.java

  1. //这里我们使用了泛型，假设我们有很多的类都需要进行性能监控，就可以通过在创建本类对象时在泛型标识处改成对应需要监控的类即可。
  2. //注意需要实现JDK反射包中的InvocationHandler接口
  3. public class MyInvocationHandler<E> implements InvocationHandler {
  4.     //需要被代理的对象
  5.     private E target;
  7.     public MyInvocationHandler(E target){
  8.         this.target = target;
  9.     }
  10.     /**
  11.      * @param：
  12.     *  proxy : 在其上调用方法的代理实例
  13.     *  method : 对应于在目标对象调用的方法。
  14.     *  args : 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null
  15.     *           基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。 
  16.     *  @return  从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，
  17. *              则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。
  18.     *          如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException
  19.     *          否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。 
  20.     *  @throws  Throwable - 从代理实例上的方法调用抛出的异常。
  21.     *           该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型
  22.     *           或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。
  23.     *              如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型.
  24.     *            代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。
  25.     */
  26.     @Override
  27.     public Object invoke(Object proxy, Method method, Object[] args)
  28.             throws Throwable {
  29.         Long beginTime = System.currentTimeMillis();//记录开始时间
  30.         //调用目标对象的方法，同时获取该方法的返回值，作为我们本代理方法(invoke)的返回值
  31.         Object returnValue = method.invoke(target, args);//target为我们方法所在的目标类，args为方法参数
  32.         System.out.println("方法" + method.getName() + "调用结束，耗时"+ (System.currentTimeMillis() - beginTime));
  33.         return returnValue;
  34.     }
  36. }

MyProxy.java

  1. public interface MyProxy {
  3.     void method1() throws InterruptedException;
  4.     void method2() throws InterruptedException;
  5.     void method3() throws InterruptedException;
  6. }

OldClass.java

  1. public class OldClass implements MyProxy {
  2.     @Override
  3.     public void method1() throws InterruptedException{
  4.         System.out.println("正在处理业务逻辑1");
  5.         Thread.sleep(100);//模拟处理业务逻辑4过程
  6.         System.out.println("业务逻辑1处理完成");
  7.     }
  8.     @Override
  9.     public void method2() throws InterruptedException{
  10.         System.out.println("正在处理业务逻辑2");
  11.         Thread.sleep(200);//模拟处理业务逻辑2过程
  12.         System.out.println("业务逻辑2处理完成");
  13.     }
  14.     @Override
  15.     public void method3() throws InterruptedException{
  16.         System.out.println("正在处理业务逻辑3");
  17.         Thread.sleep(300);//模拟处理业务逻辑3过程
  18.         System.out.println("业务逻辑3处理完成");
  19.     }
  20.     //下面还有很多很多。。
  21. }

测试代码 MainTest.java

  1. public class MainTest {
  2.     public static void main(String args[]) throws InterruptedException{
  3.         OldClass oldClass = new OldClass();
  4.         InvocationHandler handler = new MyInvocationHandler<OldClass>(oldClass);
  5.         MyProxy myProxy = (MyProxy)Proxy.newProxyInstance(MyProxy.class.getClassLoader(),new Class[]{MyProxy.class},handler);
  6.         myProxy.method1();
  7.         myProxy.method2();
  8.         myProxy.method3();
  9.     }
  10. }

控制台输出

正在处理业务逻辑1
业务逻辑1处理完成
方法method1调用结束，耗时100
正在处理业务逻辑2
业务逻辑2处理完成
方法method2调用结束，耗时200
正在处理业务逻辑3
业务逻辑3处理完成
方法method3调用结束，耗时300

2. cglib代理

ProxyFactory.java

  1. public class ProxyFactory {
  3.     private Enhancer enhancer = new Enhancer();// 动态的类生成器
  5.     public Object createSubObject(Class<?> clazz) {
  6.         enhancer.setSuperclass(clazz);// 设置需要创建的类，这个类的父类是clazz类
  7.         // 当通过enhancer创建的类中的方法被调用时，该方法会被CallBack指定的对象拦截。
  8.         enhancer.setCallbacks(new Callback[] { new MyTimeInterceptor(), new MyRecordInterceptor() });
  9.         enhancer.setCallbackFilter(new MyCallBackFilter());// 设置我们自定义的过滤器
  10.         return enhancer.create();// 通过字节码技术动态创建子类实例
  11.     }
  12. }

MyTimeInterceptor.java

  1. public class MyTimeInterceptor implements MethodInterceptor {
  3.     @Override
  4.     public Object intercept(Object target, Method method, Object[] args,
  5.             MethodProxy proxy) throws Throwable {//拦截所有父类方法的调用
  6.         Long beginTime = System.currentTimeMillis();//记录开始时间
  7.         //调用目标对象的方法，同时获取该方法的返回值，作为我们本代理方法(invoke)的返回值
  8.         Object returnValue = proxy.invokeSuper(target, args);//target为我们方法所在的目标类，args为方法参数
  9.         System.out.println("方法" + method.getName() + "调用结束，耗时"+ (System.currentTimeMillis() - beginTime));
  10.         return returnValue;
  11.     }
  13. }

MyRecordInterceptor.java

  1. public class MyRecordInterceptor implements MethodInterceptor {
  3.     @Override
  4.     public Object intercept(Object target, Method method, Object[] args,
  5.             MethodProxy proxy) throws Throwable {// 拦截所有父类方法的调用
  6.         System.out.println(args[0] + "在"
  7.                 + new SimpleDateFormat("yyyy-MM-dd HH-mm").format(new Date())
  8.                 + "调用了方法" + method.getName());
  9.         Object returnValue = proxy.invokeSuper(target, args);// target为我们方法所在的目标类，args为方法参数
  10.         return returnValue;
  11.     }
  13. }

MyCallBackFilter.java

  1. public class MyCallBackFilter implements CallbackFilter{//需要实现特定接口
  3.     @Override
  4.     public int accept(Method method) {
  5.         if("method3" .equals(method.getName())){//如果被拦截的方法名满足特定条件
  6.             //这里的序号对应于enhancer.setCallbacks(new Callback[]{new MyTimeInterceptor(),new MyRecordInterceptor()})中的Callback数组的拦截器索引
  7.             return 1;
  8.         }else{
  9.             return 0;
  10.         }
  11.     }
  13. }

OldClass.java

  1. public class OldClass {
  2.     public void method1() throws InterruptedException{
  3.         System.out.println("正在处理业务逻辑1");
  4.         Thread.sleep(100);//模拟处理业务逻辑4过程
  5.         System.out.println("业务逻辑1处理完成");
  6.     }
  7.     public void method2() throws InterruptedException{
  8.         System.out.println("正在处理业务逻辑2");
  9.         Thread.sleep(200);//模拟处理业务逻辑2过程
  10.         System.out.println("业务逻辑2处理完成");
  11.     }
  12.     public void method3(String userName) throws InterruptedException{
  13.         System.out.println("正在处理业务逻辑3");
  14.         Thread.sleep(300);//模拟处理业务逻辑3过程
  15.         System.out.println("业务逻辑3处理完成");
  16.     }
  17.     //下面还有很多很多。。
  18. }

MainTest.java

  1. public class MainTest {
  2.     public static void main(String args[]) throws InterruptedException{
  3.         ProxyFactory cgLibProxy = new ProxyFactory();//创建我们的代理类
  4.         //通过enhancer创建我们的子类
  5.         //因为oldClass是我们子类的父类，所以这里向上转型成功
  6.         OldClass oldClass = (OldClass) cgLibProxy.createSubObject(OldClass.class);
  7.         oldClass.method1();//调用方法
  8.         oldClass.method2();//调用方法
  9.         oldClass.method3("cglib");//调用方法
  10.     }
  11. }

控制台输出:

正在处理业务逻辑1
业务逻辑1处理完成
方法method1调用结束，耗时117
正在处理业务逻辑2
业务逻辑2处理完成
方法method2调用结束，耗时200
cglib在2016-11-02 14-05调用了方法method3
正在处理业务逻辑3
业务逻辑3处理完成

上面介绍了两种方式的简单实践,在程序中自己可以发挥其锋利的作用.

附示例代码: java动态代理(jdk和cglib).tar.gz

转载请标明出处：
出自：TMBlog技术文章分享
文章：java动态代理（jdk和cglib）
链接：https://www.majingjing.cn/tmblog/web/blog/22197cc7411e5728b8cd59ac3db99041.html
上一篇：html视频播放器
下一篇：Sublime Text 3 安装和使用

对你有用打赏打赏下吧