java动态代理

最新推荐文章于 2024-03-21 22:09:05 发布
最新推荐文章于 2024-03-21 22:09:05 发布
阅读量370 收藏
点赞数
分类专栏： JAVA

http://www.importnew.com/26166.html


为了使代理类和被代理类对第三方有相同的函数，代理类和被代理类一般实现一个公共的interface，该interface定义如下

1
2
3
4
public interface Calculator {
     public Integer add(Integer num1, Integer num2);
     public Integer minus(Integer num1, Integer num2);
}

被代理类定义如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class CalculatorImpl implements Calculator {
 
     @Override
     public Integer add(Integer num1, Integer num2) {
         int ret = num1 + num2;
         System.out.println( "in calculatorImpl, res: " + ret);
         return ret;
     }
     
     @Override
     public Integer minus(Integer num1, Integer num2) {
         int ret = num1 - num2;
         System.out.println( "int calculatorImpl, res: " + ret);
         return ret;
     }
 
}

代理需求：在add函数和minus函数调用前后分别输出before invocation和after invocation字样

静态代理解决方案

代码如下：简单直接，无需赘言，如果calculator里边不仅有add和minus，还有divide，product,log,sin…呢，呵呵哒

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class StaticCalculatorProxy implements Calculator {
     Calculator obj;
     
     public StaticCalculatorProxy(Calculator obj) {
         this .obj = obj;
     }
 
     @Override
     public Integer add(Integer num1, Integer num2) {
         System.out.println( "in StaticCalculatorProxy, before invocation" );
         Integer ret = obj.add(num1, num2);
         System.out.println( "in StaticCalculatorProxy, after invocation" );
         return ret;
     }
 
     @Override
     public Integer minus(Integer num1, Integer num2) {
         System.out.println( "in StaticCalculatorProxy, before invocation" );
         Integer ret = obj.minus(num1, num2);
         System.out.println( "in StaticCalculatorProxy, after invocation" );
         return ret;
     }
 
}

动态代理解决方案

首先编写实现InvocationHandler接口的类，用于请求转发，实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class CalculatorHandler implements InvocationHandler {
     
     private Object obj; //被代理类
     
     public CalculatorHandler(Object obj) {
         this .obj = obj;
     }
 
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println( "in calculatorhandler, before invocation" );
         
         Object ret = method.invoke(obj, args);  //执行被代理类方法
         
         System.out.println( "in calculationhandler, after invocation" );
         return ret;
     }
 
}

生成动态代理

1
2
3
4
5
CalculatorImpl calculatorImpl = new CalculatorImpl(); //被代理类
CalculatorHandler calculatorHandler = new CalculatorHandler(calculatorImpl);
Calculator calculator = (Calculator) Proxy.newProxyInstance(calculatorImpl.getClass().getClassLoader(), calculatorImpl.getClass().getInterfaces(), calculatorHandler);
System.out.println(calculator.add( 1 , 2 ));
System.out.println(calculator.minus( 1 , 2 ));

无论calculator中包含多少函数，动态代理只需实现一次，实际工程中，System.out.println(“in calculatorhandler, before invocation”)可能是加缓存，打日志等操作

动态代理如何工作的

为了搞清楚动态代理如何工作，首先看看生成的动态代理的代码是什么，借助[1]中ProxyUtil代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class ProxyUtils {
 
     /**
      * Save proxy class to path
      *
      * @param path path to save proxy class
      * @param proxyClassName name of proxy class
      * @param interfaces interfaces of proxy class
      * @return
      */
     public static boolean saveProxyClass(String path, String proxyClassName, Class[] interfaces) {
         if (proxyClassName == null || path == null ) {
             return false ;
         }
 
         // get byte of proxy class
         byte [] classFile = ProxyGenerator.generateProxyClass(proxyClassName, interfaces);
         FileOutputStream out = null ;
         try {
             out = new FileOutputStream(path);
             out.write(classFile);
             out.flush();
             return true ;
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 out.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return false ;
     }
}

得到了生成的动态代理代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
public final class $Proxy0 extends Proxy
     implements Calculator
{
 
     public $Proxy0(InvocationHandler invocationhandler)
     {
         super (invocationhandler);
     }
 
     public final boolean equals(Object obj)
     {
         try
         {
             return ((Boolean) super .h.invoke( this , m1, new Object[] {
                 obj
             })).booleanValue();
         }
         catch (Error _ex) { }
         catch (Throwable throwable)
         {
             throw new UndeclaredThrowableException(throwable);
         }
     }
 
     public final String toString()
     {
         try
         {
             return (String) super .h.invoke( this , m2, null );
         }
         catch (Error _ex) { }
         catch (Throwable throwable)
         {
             throw new UndeclaredThrowableException(throwable);
         }
     }
 
     public final Integer minus(Integer integer, Integer integer1)
     {
         try
         {
             return (Integer) super .h.invoke( this , m4, new Object[] {
                 integer, integer1
             });
         }
         catch (Error _ex) { }
         catch (Throwable throwable)
         {
             throw new UndeclaredThrowableException(throwable);
         }
     }
 
     public final Integer add(Integer integer, Integer integer1)
     {
         try
         {
             return (Integer) super .h.invoke( this , m3, new Object[] {
                 integer, integer1
             });
         }
         catch (Error _ex) { }
         catch (Throwable throwable)
         {
             throw new UndeclaredThrowableException(throwable);
         }
     }
 
     public final int hashCode()
     {
         try
         {
             return ((Integer) super .h.invoke( this , m0, null )).intValue();
         }
         catch (Error _ex) { }
         catch (Throwable throwable)
         {
             throw new UndeclaredThrowableException(throwable);
         }
     }
 
     private static Method m1;
     private static Method m2;
     private static Method m4;
     private static Method m3;
     private static Method m0;
 
     static
     {
         try
         {
             m1 = Class.forName( "java.lang.Object" ).getMethod( "equals" , new Class[] {
                 Class.forName( "java.lang.Object" )
             });
             m2 = Class.forName( "java.lang.Object" ).getMethod( "toString" , new Class[ 0 ]);
             m4 = Class.forName( "com.langrx.mq.Calculator" ).getMethod( "minus" , new Class[] {
                 Class.forName( "java.lang.Integer" ), Class.forName( "java.lang.Integer" )
             });
             m3 = Class.forName( "com.langrx.mq.Calculator" ).getMethod( "add" , new Class[] {
                 Class.forName( "java.lang.Integer" ), Class.forName( "java.lang.Integer" )
             });
             m0 = Class.forName( "java.lang.Object" ).getMethod( "hashCode" , new Class[ 0 ]);
         }
         catch (NoSuchMethodException nosuchmethodexception)
         {
             throw new NoSuchMethodError(nosuchmethodexception.getMessage());
         }
         catch (ClassNotFoundException classnotfoundexception)
         {
             throw new NoClassDefFoundError(classnotfoundexception.getMessage());
         }
     }
}

有点长，按照初始化顺序慢慢来分析，首先分析静态代码块：

1
2
3
4
5
6
7
8
9
10
11
m1 = Class.forName( "java.lang.Object" ).getMethod( "equals" , new Class[] {
                     Class.forName( "java.lang.Object" )
                 });
m2 = Class.forName( "java.lang.Object" ).getMethod( "toString" , new Class[ 0 ]);
m4 = Class.forName( "com.langrx.mq.Calculator" ).getMethod( "minus" , new Class[] {
                     Class.forName( "java.lang.Integer" ), Class.forName( "java.lang.Integer" )
                 });
m3 = Class.forName( "com.langrx.mq.Calculator" ).getMethod( "add" , new Class[] {
                     Class.forName( "java.lang.Integer" ), Class.forName( "java.lang.Integer" )
                 });
m0 = Class.forName( "java.lang.Object" ).getMethod( "hashCode" , new Class[ 0 ]);

得到公共interface中的add函数和minus函数对应的Method方法，同事也得到了equals，toString，hashCode三个函数的Method，所以调用代理类的equals，toString，hashCode也是要执行被代理类的方法的，知道这点很有必要

构造函数

1
2
3
4
public $Proxy0(InvocationHandler invocationhandler)
{
         super (invocationhandler);
}

初始化了内部的InvocationHandler变量，也就是下文的super.h

以add为例看一下请求的转发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public final Integer add(Integer integer, Integer integer1)
{
     try
     {
         return (Integer) super .h.invoke( this , m3, new Object[] {
             integer, integer1
         });
     }
     catch (Error _ex) { }
     catch (Throwable throwable)
     {
         throw new UndeclaredThrowableException(throwable);
     }
}

super.h.invoke就是invocationhandler.invoke就是传入的CalculatorHandler中实现的

1
2
3
4
5
6
7
8
9
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     System.out.println( "in calculatorhandler, before invocation" );
     
     Object ret = method.invoke(obj, args);  //执行被代理类方法
     
     System.out.println( "in calculationhandler, after invocation" );
     return ret;
}

最终执行的就是CalculatorHandler对应的invoke函数

总结

1
Calculator calculator = (Calculator) Proxy.newProxyInstance(calculatorImpl.getClass().getClassLoader(), calculatorImpl.getClass().getInterfaces(), calculatorHandler);

生成动态代理的过程步骤如下[2]：

1
2
3
4
5
6
7
8
9
10
11
12
// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..);
  
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface. class , ... });
  
// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor( new Class[] { InvocationHandler. class });
  
// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance( new Object[] { handler });

Proxy.newProxyInstance帮我们做了2，3，4步，直接返回给我们一个动态代理对象，代理对象最终执行InvocationHandler中invoke函数。顺便强推文章[2]


「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的静态绑定和动态绑定
lyglostangel的专栏
01-06 845
Java中的静态绑定和动态绑定 DEC 28TH, 2014 一个Java程序的执行要经过编译和执行（解释）这两个步骤，同时Java又是面向对象的编程语言。当子类和父类存在同一个方法，子类重写了父类的方法，程序在运行时调用方法是调用父类的方法还是子类的重写方法呢，这应该是我们在初学Java时遇到的问题。这里首先我们将确定这种调用何种方法实现或者变量的操作叫做绑定。 在Java
JAVA静态&动态代理
weixin_30492601的博客
08-16 52
具体场景 为了使代理类和被代理类对第三方有相同的函数，代理类和被代理类一般实现一个公共的interface，该interface定义如下 public interface Calculator { public Integer add(Integer num1, Integer num2); public Integer minus(Integer num1, In...
Java动态代理
最新发布
CVPR收割机的博客
03-21 1232
代理类代理目标类（代理）目标类是实现目标功能的类（杨超越）
java 动态代理
08-29
Java动态代理是Java编程中一个非常重要的特性，它允许我们在运行时创建代理对象，这些代理对象可以代替原对象执行某些额外的操作，例如日志记录、性能监控、事务管理等。在Java中，动态代理主要通过两个接口来实现：...
java动态代理demo
03-15
Java动态代理是Java编程中一个重要的特性，它允许我们在运行时创建代理对象，这些代理对象可以代表并增强原对象的功能。动态代理在很多场景下都非常有用，比如日志记录、性能监控、事务管理等。本示例将带你深入理解...
一文带你搞懂Java动态代理
01-21
在说动态代理之前，先来简单看下代理模式。代理是最基本的设计模式之一。它能够插入一个用来替代“实际”对象的“代理”对象，来提供额外的或不同的操作。这些操作通常涉及与“实际”对象的通信，因此“代理”对象...
java动态代理和反射
10-09
java动态代理 public class HireProxy implements InvocationHandler { //被代理的真实角色 private Object obj; public HireProxy(Object obj) { super(); this.obj = obj; } //第二个参数method,被...
Java 动态代理详解（学习资料）
06-17
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象，而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
Java动态代理语法Proxy类原理详解
08-19
"Java动态代理语法Proxy类原理详解" Java动态代理语法Proxy类原理详解是Java语言中的一种非常重要的语法机制，它可以动态地生成代理对象，从而对目标对象进行增强和修改。本文将详细介绍Java动态代理语法Proxy类...
Java 动态代理 Demo
10-03
Java Jdk 和 Cglib 动态代理 Demo 1.通过 JDK 反射形式创建动态代理 2.通过CGLIB基于ASM字节码技术创建动态代理 3.Java 反射原理演示 4.CGLib 依赖如下： <groupId>cglib <artifactId>cglib <version>3.3.0 ...
Java动态代理两种实现方式
04-27
Java动态代理技术是Java编程中一个非常重要的特性，它允许我们在运行时动态创建具有特定行为的对象。这种技术常用于AOP（面向切面编程）和框架中，如Spring AOP，用于实现方法拦截、事务管理等功能。Java提供了两种...
Java动态代理1
08-08
Java动态代理是Java提供的一种在运行时创建代理对象的技术，它允许我们为已经存在的接口创建代理类，从而在不修改原有代码的情况下，增加新的功能或对原有行为进行增强。动态代理在很多场景下都有广泛的应用，如日志...
java动态代理1
08-08
Java动态代理机制是一种在运行时创建代理类的技术，它允许我们为已有接口创建代理对象，以便在不修改原代码的情况下，扩展或增强原有对象的功能。动态代理主要涉及到两个核心概念：`InvocationHandler` 和 `Proxy`。...
Java动态代理简单应用
12-22
　Java动态代理比代理的思想更进一步，因为它可以动态地创建代理并动态地处理对代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器(InvocationHandler)上，调用处理器的工作是揭示调用的...
Java 动态代理.md
08-11
Java 动态代理 - Java 动态代理 - 代理模式 - 静态代理 - 动态代理 - JDK 动态代理 - CGLIB 动态代理 - Javassist 代理 - ASM 代理 这篇文章我们来聊一下 Java 中的动态代理。 动态代理在 Java 中有着广泛...
详细分析java 动态代理
08-19
Java 动态代理是Java反射机制的一个重要应用，它允许我们在程序运行时动态地创建代理对象，以便在不修改原始代码的基础上对已有对象的行为进行扩展或增强。这在设计模式中被称为代理模式，尤其适用于AOP（面向切面...
Java动态代理深入解析
动态代理是一种在Java编程中实现的一种设计模式，它允许我们在不修改原始类代码的情况下，对类的方法进行增强或扩展。这种模式的核心思想是通过代理对象来调用目标对象的方法，同时在调用前后添加额外的操作。动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值