Proxy动态代理

最新推荐文章于 2023-07-21 14:45:58 发布
最新推荐文章于 2023-07-21 14:45:58 发布
阅读量647 收藏 1
点赞数
文章标签： spring

1.  核心类&接口

       在Java的java.lang.reflect包下提供一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口可以生成jdk动态代理类或动态代理对象。

       Proxy是所有动态代理类的父类，它提供了两个静态方法来创建动态代理类和动态代理对象，如下：

　　Ø static Class<?>getProxyClass(ClassLoader loader,Class<?>... interfaces)

　　Ø static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

　　getProxyClass返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。newProxyInstance返回一个指定接口的代理类实例，该接口可以将方法调用转发到指定的调用处理程序，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的Invoke方法。实际上，即使采用第一种方式获取了一个动态代理类之后，当程序需要通过该代理类来创建对象时一样需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

　　从上面的两个方法的参数可以看出，只有给我一个（或多个）接口，我们就可以生成实现了这个（或多个）接口的代理类和代理对象。


2.    两种方式生成代理对象

       下面我们就用上面提到两种方式，分别来生成一个接口（Person）的代理对象。

　　2.1  接口Person

[java]  view plain  copy
  1. package com.tgb.reflect;  
  2.   
  3. /** 
  4.  * 目标接口 
  5.  *  
  6.  * @author wangzhipeng 
  7.  *  
  8.  */  
  9. public interface Person {  
  10.   
  11.     public void walk();  
  12.   
  13.     public void sayHello();  
  14.   
  15. }  

　　2.2  构造一个InvocationHandler类

[java]  view plain  copy
  1. package com.tgb.reflect;  
  2.   
  3. import java.lang.reflect.InvocationHandler;  
  4. import java.lang.reflect.Method;  
  5.   
  6. public class MyInvocationHandler implements InvocationHandler {  
  7.     /** 
  8.      * 执行代理对象的所有方法时都会被替换成执行如下的invoke方法 
  9.      *  
  10.      * proxy ：代表动态代理对象； method：代表正在执行的方法 ；args :代表执行代理对象方法时传入的实参 
  11.      */  
  12.     @Override  
  13.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  14.         // TODO Auto-generated method stub  
  15.         System.out.println("正在执行方法：" + method.getName());  
  16.         if (args != null) {  
  17.             System.out.println("下面是执行方法时传入的实参：");  
  18.             for (Object object : args) {  
  19.                 System.out.println(object);  
  20.             }  
  21.         } else {  
  22.             System.out.println("该方法调用无实参！");  
  23.         }  
  24.         return null;  
  25.     }  
  26.   
  27. }  

　　2.3  方式一：利用getProxyClass生成代理对象

[java]  view plain  copy
  1. package com.tgb.reflect;  
  2.   
  3. import java.lang.reflect.Constructor;  
  4. import java.lang.reflect.InvocationHandler;  
  5. import java.lang.reflect.Proxy;  
  6.   
  7. /** 
  8.  * 利用getProxyClass生成代理对象 
  9.  *  
  10.  * @author wangzhipeng 
  11.  *  
  12.  */  
  13. public class TestReflectProxy {  
  14.   
  15.     @SuppressWarnings("unchecked")  
  16.     public static void main(String[] args) throws Exception {  
  17.         // 1、创建一个InvocationHandler对象  
  18.         InvocationHandler myInvocationHandler = new MyInvocationHandler();  
  19.         // 2、创建Person接口的一个代理类（获取代理类的字节码）  
  20.         Class proxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class[] { Person.class });  
  21.         // 3、根据代理类的字节码拿到它的参数为InvocationHandler类型的构造器  
  22.         Constructor constructor = proxyClass.getConstructor(new Class[] { InvocationHandler.class });  
  23.         // 4、根据构造器创建代理对象  
  24.         Person person = (Person) constructor.newInstance(myInvocationHandler);  
  25.         // 5、调用代理对象的方法  
  26.         person.walk();  
  27.         person.sayHello();  
  28.         /** 
  29.          * 输出结果如下： 
  30.          *  
  31.          * 正在执行方法：walk 该方法调用无实参！ 
  32.          *  
  33.          * 正在执行方法：sayHello 该方法调用无实参！ 
  34.          */  
  35.     }  
  36.   
  37. }  

　　2.4  方式二：利用newProxyInstance生成代理对象

[java]  view plain  copy
  1. package com.tgb.reflect;  
  2.   
  3. import java.lang.reflect.InvocationHandler;  
  4. import java.lang.reflect.Proxy;  
  5.   
  6. /** 
  7.  * 利用newProxyInstance生成代理对象 
  8.  *  
  9.  * @author wangzhipeng 
  10.  *  
  11.  */  
  12. public class TestReflectProxy2 {  
  13.   
  14.     public static void main(String[] args) {  
  15.         // 1、创建一个InvocationHandler对象  
  16.         InvocationHandler myInvocationHandler = new MyInvocationHandler();  
  17.         // 2、利用Proxy类的静态方法newProxyInstance直接生成Person接口的代理对象  
  18.         Person person = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[] { Person.class }, myInvocationHandler);  
  19.         // 3、调用代理对象的方法  
  20.         person.walk();  
  21.         person.sayHello();  
  22.         /** 
  23.          * 输出结果如下： 
  24.          *  
  25.          * 正在执行方法：walk 该方法调用无实参！ 
  26.          *  
  27.          * 正在执行方法：sayHello 该方法调用无实参！ 
  28.          */  
  29.     }  
  30.   
  31. }  


3.    动态代理与aop

　　下面我们在上面例子的基础上再扩展一小步，模拟以下aop思想原理。其实，非常简单，上面已经提到了，执行代理对象的每个方法时都被替换执行InvocationHandler对象的Invoke方法。所以我们只需要在Invoke方法中的“反射执行目标方法（method.invoke(target,args)）“的前后加入我们增强的方法即可。实例代码如下：

　　3.1   目标接口Person

[java]  view plain  copy
  1. package com.tgb.reflect.aop;  
  2.   
  3. /** 
  4.  * 目标接口 
  5.  *  
  6.  * @author wangzhipeng 
  7.  *  
  8.  */  
  9. public interface Person {  
  10.   
  11.     public void walk();  
  12.   
  13.     public void sayHello();  
  14.   
  15. }  

　　3.2   目标类ZhanSan

[java]  view plain  copy
  1. package com.tgb.reflect.aop;  
  2.   
  3. /** 
  4.  * 目标类（实现了Person接口） 
  5.  *  
  6.  * @author wangzhipeng 
  7.  *  
  8.  */  
  9. public class ZhanSan implements Person {  
  10.   
  11.     @Override  
  12.     public void sayHello() {  
  13.         System.out.println("我是张三---->sayHello");  
  14.     }  
  15.   
  16.     @Override  
  17.     public void walk() {  
  18.         System.out.println("我是张三---->walk");  
  19.     }  
  20.   
  21. }  

　　3.3   增强类Extend

[java]  view plain  copy
  1. package com.tgb.reflect.aop;  
  2.   
  3. /** 
  4.  * 增强类 
  5.  *  
  6.  * @author wangzhipeng 
  7.  *  
  8.  */  
  9. public class Extend {  
  10.     /** 
  11.      * 增强方法1 
  12.      */  
  13.     public void ExtendMethod1() {  
  14.         System.out.println("我是增强方法一");  
  15.     }  
  16.   
  17.     /** 
  18.      * 增强方法2 
  19.      */  
  20.     public void ExtendMethod2() {  
  21.         System.out.println("我是增强方法二");  
  22.     }  
  23. }  

　　3.4   InvocationHandler类MyInvocationHandler

[java]  view plain  copy
  1. package com.tgb.reflect.aop;  
  2.   
  3. import java.lang.reflect.InvocationHandler;  
  4. import java.lang.reflect.Method;  
  5.   
  6. public class MyInvocationHandler implements InvocationHandler {  
  7.     // 目标对象（需要被代理的对象）  
  8.     private Object target;  
  9.   
  10.     public void setTarget(Object target) {  
  11.         this.target = target;  
  12.     }  
  13.   
  14.     /** 
  15.      * 执行代理对象的所有方法时都会被替换成执行如下的invoke方法 
  16.      */  
  17.     @Override  
  18.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  19.         // 实例化一个增强类  
  20.         Extend extend = new Extend();  
  21.         // 执行增强方法1（模拟spring前置增强）  
  22.         extend.ExtendMethod1();  
  23.         Object result = method.invoke(target, args);// 【执行目标方法】  
  24.         // 执行增强方法2（模拟spring后置增强）  
  25.         extend.ExtendMethod2();  
  26.         return result;  
  27.     }  
  28.   
  29. }  

　　3.5   代理生成工厂MyProxyFactory

[java]  view plain  copy
  1. package com.tgb.reflect.aop;  
  2.   
  3. import java.lang.reflect.Proxy;  
  4.   
  5. /** 
  6.  * 生成代理的工厂 
  7.  *  
  8.  * @author wangzhipeng 
  9.  *  
  10.  */  
  11. public class MyProxyFactory {  
  12.     /* 
  13.      * 获取一个目标对象（目标类必须实现接口）的代理对象 
  14.      */  
  15.     public static Object getProxy(Object target) {  
  16.         // 实例化一个InvocationHandler类，并传入目标对象  
  17.         MyInvocationHandler myInvocationHandler = new MyInvocationHandler();  
  18.         myInvocationHandler.setTarget(target);  
  19.         // 生成代理对象  
  20.         Object proxyObject = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), myInvocationHandler);  
  21.         return proxyObject;  
  22.   
  23.     }  
  24. }  

　　3.6   测试类Test

[java]  view plain  copy
  1. package com.tgb.reflect.aop;  
  2.   
  3. /** 
  4.  * 测试类 
  5.  *  
  6.  * @author wangzhipeng 
  7.  *  
  8.  */  
  9. public class Test {  
  10.   
  11.     public static void main(String[] args) {  
  12.         // 创建一个原始的ZhanSan（实现了Person接口）对象作为Target  
  13.         Person zhanSan = new ZhanSan();  
  14.         // 利用代理工厂生成zhansan对象（Target）的代理对象  
  15.         Person proxyZhanSan = (Person) MyProxyFactory.getProxy(zhanSan);  
  16.         // 执行代理对象的方法（会执行织入的增强类（Extend）的两个增强方法）  
  17.         proxyZhanSan.walk();  
  18.         proxyZhanSan.sayHello();  
  19.     }  
  20.   
  21. }  

　　3.7   结果如下


4.    总结

　　Proxy类主要方法有四个（如下图），jdk动态代理主要是利用Proxy类的getProxyClass和newProxyInstance方法生成接口的动态代理对象，并将执行代理对象的每个方法时都被替换执行InvocationHandler对象的Invoke方法。这为Spring的aop打好了基础。此外，实际应用中，我们一般不会单纯直接生成一个（或多个）接口的代理对象，而是生成某个接口实现类（目标类）的代理对象。




　　实际上普通的java编程中我们很少用到动态代理，它最大的魅力在于编写框架或底层基础代码。最后，代理的架构图如下：


java_zc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java Proxy 动态代理
04-18
NULL 博文链接：https://sunlibao123.iteye.com/blog/1837500
Spring如何基于Proxy及cglib实现动态代理
08-19
主要介绍了Spring如何基于Proxy及cglib实现动态代理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java中如何使用反射实现动态代理？
仙草不加料的博客
07-27 1575
了解反射之前，先来了解Java中的两个概念编译期和运行期。编译期是指把源码交给编译器编译成计算机可以执行的文件的过程。在Java中也就是把Java代码编成class文件的过程。编译期只是做了一些翻译功能，并没有把代码放在内存中运行起来，而只是把代码当成文本进行操作。比如检查语法错误。运行期是把编译后的文件交给计算机执行，直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。是Java程序开发语言的特征之一，它允许1.在运行时获取任意一个对象所属的类。...
使用反射生成 JDK 动态代理
韡韡的博客
10-28 442
使用反射生成JDK动态代理
jdk动态代理使用详解
热门推荐
congge
06-18 2万+
jdk动态代理和cglib静态代理使用详解
Java中的反射与JDK动态代理
桐花思雨
09-17 2236
目录反射的概述反射的概念反射的前提 反射的概述 反射的概念 Java 反射机制是在 运行状态 中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制 反射之中包含了一个「反」字，所以想要解释反射就必须先从「正」开始解释。一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作 Apple apple = new Ap
Java动态代理语法Proxy类原理详解
08-19
主要介绍了Java动态代理语法Proxy类原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
httpProxy 代理服务器源码
04-23
httpProxy，http/https代理服务器的源码，VC编译测试通过
JDK动态代理proxy
10-30
JDK动态代理proxy的基本工作原理代码！！
Proxy-动态代理
汤键的博客
09-19 329
Proxy-动态代理
设计模式——Proxy静态代理与动态代理
最新发布
欢迎来到我的博客
07-21 125
Override。
动态代理（Proxy实现）
weixin_56289362的博客
03-15 997
上次的静态代理增强方法全是自己手动写出来的，如果有许多方法，都需要自己一个一个写，显然太麻烦了，这时就可以用到动态代理，这次先用proxy实现 除了静态代理类方法别的都一样，
Java进阶 | Proxy动态代理机制详解
【积累】，是一个长期持续的过程。
06-28 3149
在说Java动态代理之前，还是要说一下Jvm加载对象的过程，这个依旧是理解动态代理的基础性原理Java类即源代码程序.java类型文件，经过编译器编译之后就被转换成字节代码.class类型文件，类加载器负责读取字节代码，并转换成java.lang.Class对象，描述类在元数据空间的数据结构，类被实例化时，堆中存储实例化的对象信息，并且通过对象类型数据的指针找到类。所以通过New创建对象，独断其背后很多实现细节，理解上述过程之后，再了解一个常用的设计模式，即代理模式。...
Android Java反射与Proxy动态代理详解与使用基础篇(一)
11-23 2413
Java Reflection功能非常强大，并且非常有用，比如：获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等获取任意对象的属性，并且能改变对象的属性调用任意对象的方法判断任意一个对象所属的类实例化任意一个类的对象通过反射我们可以实现动态装配，降低代码的耦合度,动态代理等。在JDK中，主要由以下类来实现Java反射机制，这些类（除了第一个）都位于java.lang.reflect包中Class类：代表一个类，位于java.lang包下。
Proxy - 什么是动态代理，案例举例方便记忆
weixin_44610169的博客
07-18 188
因为附近没有卖电脑的厂商，所以如果想买电脑都要去东京的厂商去购买，但如果有代理商在上海开了一家代理销售公司，我就可以在上海买这台电脑而不用去东京了。但是上海的厂家只有从东京调货才能实现这个功能，因为上海代理商是自己不制造电脑的，所以本质上相当于代理商替我去东京拿货转手出售给我，让我使用这个功能。总体来说，核心就是通过类加载器和接口来创建，利用反射技术拿到类中定义的方法与里面传递的参数，然后在执行过程中进行一些功能的强化。买了一台电脑，花了80000.0元。用一个买电脑的例子来说明一下动态代理的作用。...
代理模式Proxy（静态代理和动态代理）
m0_51661220的博客
03-19 142
代理设计就是为其他对象提供一种代理以控制对这个对象的访问 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原 始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原 始对象上 应用场景： 安全代理：屏蔽对真实角色的直接访问。 远程代理：通过代理类处理远程方法调用（RMI） 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，.
动态代理Proxy
m0_37329981的博客
10-31 272
动态代理Proxy
动态代理（Proxy）
m0_62317022的博客
11-11 229
**动态代理** 代理就是被代理者没有能力或者不愿意去完成的某件事情，需要找个人代替自己完成这件事事。 关键步骤 1.必须有接口，接口类要实现（代理通常是基于接口来实现的）。 2.创建一个实现类的对象，该对象为业务对象，为业务对象左一个代理对象。
如何实现一个简单的Proxy动态代理程序？
06-06
实现一个简单的Proxy动态代理程序，可以使用Java中的`Proxy`类和`InvocationHandler`接口。 首先，定义一个接口，该接口是需要被代理的实现类的公共接口。 ```java public interface Hello { void sayHello(String name); } ``` 然后，实现该接口的实现类。 ```java public class HelloImpl implements Hello { @Override public void sayHello(String name) { System.out.println("Hello, " + name); } } ``` 接着，定义一个实现`InvocationHandler`接口的代理类。 ```java public class HelloProxy implements InvocationHandler { private Object target; public HelloProxy(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before method " + method.getName()); Object result = method.invoke(target, args); System.out.println("After method " + method.getName()); return result; } } ``` 最后，通过`Proxy`类创建代理对象。 ```java Hello hello = new HelloImpl(); HelloProxy proxy = new HelloProxy(hello); Hello helloProxy = (Hello) Proxy.newProxyInstance( hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), proxy ); helloProxy.sayHello("World"); ``` 运行结果： ``` Before method sayHello Hello, World After method sayHello ``` 这样就实现了一个简单的Proxy动态代理程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值