目录
动态代理(理解): 基于反射机制。 现在需要知道以下的就行:
使用jdk的反射机制,创建对象的能力, 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。 动态:在程序执行时,调用jdk提供的方法才能创建代理类的对象。
jdk动态代理,必须有接口,目标类必须实现接口, 没有接口时,需要使用cglib动态代理
可以在不改变原来目标方法功能的前提下, 可以在代理中增强自己的功能代码。 程序开发中的意思。 比如:你所在的项目中,有一个功能是其他人(公司的其它部门,其它小组的人)写好的,你可以使用。 GoNong.class , GoNong gn = new GoNong(), gn.print();
你发现这个功能,现在还缺点, 不能完全满足我项目的需要。 我需要在gn.print()执行后,需要自己在增加代码。 用代理实现 gn.print()调用时, 增加自己代码, 而不用去改原来的 GoNong文件
后面会有,mybatis ,spring
代购, 中介,换ip,商家等等
比如有一家美国的大学, 可以对全世界招生。 留学中介(代理)
留学中介(代理): 帮助这家美国的学校招生, 中介是学校的代理, 中介是代替学校完成招生功能。 代理特点: 1. 中介和代理他们要做的事情是一致的: 招生。 2. 中介是学校代理, 学校是目标。 3. 家长---中介(学校介绍,办入学手续)----美国学校。 4. 中介是代理,不能白干活,需要收取费用。 5. 代理不让你访问到目标。
或者是买东西都是商家卖, 商家是某个商品的代理, 你个人买东西, 肯定不会让你接触到厂家的。
在开发中也会有这样的情况, 你有a类, 本来是调用c类的方法, 完成某个功能。 但是c不让a调用。
a -----不能调用 c的方法。 在a 和 c 直接 创建一个 b 代理, c让b访问。 a --访问b---访问c
静态代理和动态代理
静态代理是指,代理类在程序运行前就已经定义好.java 源文件,其与目标类的关系在 程序运行前就已经确立。在程序运行前代理类已经编译为.class 文件。
代理类是自己手工实现的,自己创建一个java类,表示代理类。
同时你所要代理的目标类是确定的。
特点: 实现简单 、容易理解
缺点:
当你的项目中,目标类和代理类很多时候,有以下的缺点:
用户是客户端类
实现步骤:
package com.md.service; /** * @author MD * @create 2020-08-03 9:06 */ // 表示功能,厂家和商家都要完成的功能 public interface UsbSell { // 定义方法,返回值为u盘的价格 float sell(int amount); }
package com.md.factory; import com.md.service.UsbSell; /** * @author MD * @create 2020-08-03 9:11 */ // 目标类。金士顿厂家 public class UsbKingFactory implements UsbSell { @Override public float sell(int amount) { return 50.0f; } }
package com.md.shangjia; import com.md.factory.UsbKingFactory; import com.md.service.UsbSell; import java.lang.reflect.AccessibleObject; /** * @author MD * @create 2020-08-03 9:13 */ // 代理类,这是商家,代理金士顿u盘销售 public class Taobao implements UsbSell { // 访问目标类 // 声明商家代理的厂家是谁 private UsbSell factory = new UsbKingFactory(); // 实现销售u盘的功能 @Override public float sell(int amount) { // 向厂家发送订单,告诉厂家,进行发货,这是进货价格 float price = factory.sell(amount); // 商家加价获得利润,增强功能 price+=50; // 在目标类的方法调用之后,剩下写的其他功能,都是增加功能 System.out.println("淘宝商家给你一个大的优惠卷"); return price; } }
package com.md.shangjia; import com.md.factory.UsbKingFactory; import com.md.service.UsbSell; /** * @author MD * @create 2020-08-03 9:32 */ // 代理类 public class Weishang implements UsbSell { // 代理的也是金士顿 private UsbSell factory = new UsbKingFactory(); @Override public float sell(int amount) { float price = factory.sell(amount); // 增强功能,每个代理根据自己的模式有不同的增强功能 price+=30; System.out.println("微商:亲,要五星好评哟!"); return price; } }
package com.md; import com.md.shangjia.Taobao; import com.md.shangjia.Weishang; /** * @author MD * @create 2020-08-03 9:23 */ public class Shopping { public static void main(String[] args) { // 创建代理的商家对象 Taobao taobao = new Taobao(); float price = taobao.sell(1); System.out.println("通过淘宝购买的u盘:"+price); Weishang weishang = new Weishang(); float sell = weishang.sell(1); System.out.println("通过微商购买的u盘:"+sell); } }
代理类和目标类实现了相同的接口,每个代理都需要实现目标类的方法,这样就出现了大量的代 码重复。如果接口增加一个方法,除了所有目标类需要实现这个方法外,所有代理类也需要实现 此方法。增加了代码维护的复杂度。
代理类只服务于一种类型的目标类,如果要服务多个类型。势必要为每一种目标类都进行代理, 静态代理在程序规模稍大时就无法胜任了,代理类数量过多。
动态代理是指代理类对象在程序运行时由 JVM 根据反射机制动态生成的。动态代理不需要定义代理类的.java 源文件。
动态代理其实就是 jdk 运行期间,动态创建 class 字节码并加载到 JVM。
动态代理的实现方式常用的有两种:
使用 JDK 动态代理,和通过 CGLIB 动态代理。
jdk 动态代理是基于 Java 的反射机制实现的。使用 jdk 中接口和类实现代理对象的动态创建。
Jdk 的动态要求目标对象必须实现接口,这是 java 设计上的要求。
从 jdk1.3 以来,java 语言通过 java.lang.reflect 包提供三个类支持代理模式 Proxy, Method 和 InvocationHandler
InvocationHandler 接口叫做调用处理器,负责完调用目标方法,并增强功能。
通过代理对象执行目标接口中的方法,会把方法的调用分派给调用处理器 (InvocationHandler)的实现类,
执行实现类中的 invoke()方法,我们需要把功能代理写在 invoke ()方法中
在 invoke 方法中可以截取对目标方法的调用。在这里进行功能增强
invoke()方法:
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { } // proxy:代表生成的代理对象 // method:代表目标方法 // args:代表目标方法的参数 //第一个参数 proxy 是 jdk 在运行时赋值的,在方法中直接使用,第二个参数后面介绍, 第三个参数是方法执行的参数, 这三个参数都是 jdk 运行时赋值的,无需程序员给出。
Java 的动态代理是 建立在反射机制之上的。 实现了 InvocationHandler 接口的类用于加强目标类的主业务逻辑。这个接口中有一个 方法 invoke(),具体加强的代码逻辑就是定义在该方法中的, 通过代理对象执行接口中的方法时,会自动调用 invoke()方法,
总结:
InvocationHandler 接口:表示你的代理要干什么,怎么用:
invoke()方法的第二个参数为 Method 类对象,该类有一个方法也叫 invoke(),可以调用目标方法。这两个 invoke()方法,虽然同名,但无关。
这个类的invoke方法
public Object invoke(Object obj , Object...args){ } // obj:表示目标对象 // args:表示目标方法参数,也就是上面invoke方法中的第三个参数
该方法的作用是:
在代码中,一般的写法为 method.invoke(target, args); 其中,method 为上一层 invoke 方法的第二个参数。这样,即可调用了目标类的目标方法。
通过 JDK 的 java.lang.reflect.Proxy 类 实 现 动 态 代 理 ,会 使 用 其 静 态 方 法 newProxyInstance(),依据目标对象、业务接口及调用处理器三者,自动生成一个动态代理对 象
Proxy类:核心的对象,创建代理对象。之前创建对象都是 new 类的构造方法() 现在我们是使用Proxy类的方法,代替new的使用。
方法: 静态方法 newProxyInstance() 作用是: 创建代理对象, 等同于静态代理中的TaoBao taoBao = new TaoBao();
返回值:就是代理对象 public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) // 1. ClassLoader loader 类加载器,负责向内存中加载对象的。 使用反射获取对象的ClassLoader类a , a.getCalss().getClassLoader(), 目标对象的类加载器 // 2. Class<?>[] interfaces: 接口, 目标对象实现的接口,也是反射获取的。 // 3. InvocationHandler h : 我们自己写的,代理类要完成的功能。
和静态代理实现相同的功能
package com.md.service; /** * @author MD * @create 2020-08-03 10:36 */ // 目标接口 public interface UsbSell { float sell(int count); }
package com.md.factory; import com.md.service.UsbSell; /** * @author MD * @create 2020-08-03 10:37 */ // 目标类 public class UsbKingFactory implements UsbSell { // 目标方法 @Override public float sell(int count) { System.out.println("目标类:执行了目标方法"); return 50.0f; } }
package com.md.handler; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * @author MD * @create 2020-08-03 10:43 */ // 必须实现InvocationHandler接口,完成代理类需要的功能 // 1. 调用目标方法 // 2. 增强功能 public class MySellHandler implements InvocationHandler { // private Object target = null; // 动态代理,目标对象不是固定的,需要什么就传入什么,之后通过 new MySellHandler(),就可以把目标对象传进来 public MySellHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 1. 向厂家发送订单,告诉厂家,进行发货,这是进货价格 // float price = factory.sell(amount); // 2. 商家加价获得利润,增强功能 //price+=50; // 3. 在目标类的方法调用之后,剩下写的其他功能,都是增加功能 // System.out.println("淘宝商家给你一个大的优惠卷"); // 1. 执行目标方法,和上面等价,调用目标方法,传入目标对象和相应的参数 Object res = method.invoke(target,args); // 2. 增强功能 if (res != null){ Float price = (Float)res; price+=50; res = price; } // 3. 在目标类的方法调用之后,剩下写的其他功能,都是增加功能 System.out.println("淘宝商家给你一个大的优惠卷"); return res; } }
package com.md; import com.md.factory.UsbKingFactory; import com.md.handler.MySellHandler; import com.md.service.UsbSell; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * @author MD * @create 2020-08-03 10:55 */ public class Shopping { public static void main(String[] args) { // 创建代理对象,使用Proxy // 1. 创建目标对象 UsbSell factory = new UsbKingFactory(); // 2. 创建InvocationHandler对象 InvocationHandler handler = new MySellHandler(factory); // 3. 创建代理对象 UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), handler); // 4. 通过代理执行方法 float price = proxy.sell(1); System.out.println("通过动态代理调用方法:"+price); } }
CGLIB(Code Generation Library)是一个开源项目。是一个强大的,高性能,高质量的 Code 生成类 库,它可以在运行期扩展 Java 类与实现 Java 接口。它广泛的被许多 AOP 的框架使用,例如 Spring AOP。
使用 JDK 的 Proxy 实现代理,要求目标类与代理类实现相同的接口。若目标类不存在 接口,则无法使用该方式实现。
但对于无接口的类,要为其创建动态代理,就要使用 CGLIB 来实现。
CGLIB 代理的生成 原理是生成目标类的子类,而子类是增强过的,这个子类对象就是代理对象。所以,使用 CGLIB 生成动态代理,要求目标类必须能够被继承,即不能是 final 的类。
cglib 经常被应用在框架中,例如 Spring ,Hibernate 等。Cglib 的代理效率高于 Jdk。对 于 cglib 一般的开发中并不使用。做了一个了解就可以。
package com.md.service; /** * @author MD * @create 2020-08-03 20:51 */ public interface Dog { void info(); void run(); }
package com.md.factory; import com.md.service.Dog; /** * @author MD * @create 2020-08-03 20:51 */ public class GunDog implements Dog { @Override public void info() { System.out.println("我是狗"); } @Override public void run() { System.out.println("狗在跑"); } }
package com.md.Util; /** * @author MD * @create 2020-08-03 20:53 */ public class DogUtil { public void method1(){ System.out.println("我是第一个增强方法"); } public void method2(){ System.out.println("我是第二个增强方法"); } }
动态代理的核心环节就是要实现 InvocaitonHandler 接口。每个动态代理类都必须要实现 InvocationHandler 接口,并且每个代理类的实例都关联到了一个 InvocationHandler 接口实现类的实例对象,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由 InvocationHandler 这个接口的 invoke() 方法来进行调用,具体的实现如下:
package com.md.handler; import com.md.Util.DogUtil; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * @author MD * @create 2020-08-03 20:55 */ public class MyHandler implements InvocationHandler { private Object target; // 需要被代理的对象 public void setTarget(Object target) { this.target = target; } // 当我们调用被代理对象的方法时,invvoke方法会取而代之 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { DogUtil dogUtil = new DogUtil(); // 增强方法 dogUtil.method1(); // 用反射调用Dog class中的方法 Object res = method.invoke(target, args); dogUtil.method2(); return res; } }
package com.md; import com.md.factory.GunDog; import com.md.handler.MyHandler; import com.md.service.Dog; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * @author MD * @create 2020-08-03 21:14 */ public class DogTest { public static void main(String[] args) { // 实例化被代理对象 Dog dog = new GunDog(); // 实例化MyHandler对象, MyHandler myHandler = new MyHandler(); myHandler.setTarget(dog); // 用被代理对象产生一个代理对象 Dog proxy = (Dog) Proxy.newProxyInstance(dog.getClass().getClassLoader(), dog.getClass().getInterfaces(), myHandler); // 代理对象调用被代理对象的方法 proxy.info(); System.out.println("-------------------"); proxy.run(); } } // 运行结果 /* 我是第一个增强方法 我是狗 我是第二个增强方法 ------------------- 我是第一个增强方法 狗在跑 我是第二个增强方法 */
还是需要注意newProxyInstance() ,要把返回值转为接口类型,以及注意参数
这个函数是 JDK 为了程序员方便创建代理对象而封装的一个函数,因此你调用newProxyInstance()时直接创建了代理对象 注意:上面的情况是两个方法都增加了功能,若只想在run()里添加增加功能该怎么办?
newProxyInstance()
使用method.getName()获取方法名
package com.md.handler; import com.md.Util.DogUtil; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * @author MD * @create 2020-08-03 20:55 */ public class MyHandler implements InvocationHandler { private Object target; // 需要被代理的对象 public void setTarget(Object target) { this.target = target; } // 当我们调用被代理对象的方法时,invvoke方法会取而代之 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { DogUtil dogUtil = new DogUtil(); Object res = null; // 获取当前调用方法的名字,给指定的方法添加新的功能 String methodName = method.getName(); if("run".equals(methodName)){ dogUtil.method1(); res = method.invoke(target, args); dogUtil.method2(); }else{ res = method.invoke(target, args); } return res; } }
这样就可以给指定的方法添加新功能
原文链接:https://www.cnblogs.com/mengd/p/13429797.html