JDK动态代理
因为要学习AOP，所以提前了解什么是代理
首先思考两个问题：
-
什么是动态代理？
使用jdk的反射机制，创建对象的能力，创建的是代理类的对象。而不用你创建类文件。
动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。 -
动态代理能做什么？
可以在不改变原来目标方法功能的前提下，可以在代理中增强自己的功能代码。
程序开发中的意思：
比如，你所在的项目中，有一个功能是其他人（公司的其他部门，其他小组的人）写好的，你可以使用。
GoNong.class , GoNong gn = new GoNong() , gn.print()
你发现这个功能，不能完全满足自己的项目需求，需要在gn.print()执行后，需要自己在增加代码。
用代理实现gn.print()调用时，增加自己代码，而不用去改变原来的GoNong文件。
代理模式，就是通过代理方来操作目标对象，而不是自己直接调用
代理分为静态代理和动态代理两种：
静态代理：就如同字面上的意思一样，是写死的，针对每个被代理对象写一个代理类，操作不够优雅 动态代理：可以根据接口动态的生成代理类，这动态生成的类不需要自己书写，jdk帮你完成了
代理模式的作用
功能增强:在你原有的功能上,增加了额外的功能.新增加的功能,叫做功能增强 控制访问:代理类不让你访问目标,例如商家不让用户访问厂家
静态代理
1)代理类是自己手工实现的,自己创建一个java类,表示代理类
2)同时你所要代理的目标
特点：1）实现简单2）容易理解。
模拟一个用户购买u盘的行为。
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。
三者的关系：用户（客户端）-—-商家（代理）-—-厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。
实现步骤
创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情 创建厂家类,实现1步骤的接口 创建商家,就是代理,也需要实现1步骤中的接口 创建客户端类,调用商家的方法买一个u盘
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情
package com.rango.service;
public interface usbSell {
/**
* 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
* 返回值表示一个u盘的价格
* @param amount
* @return
*/
float sell(int amount);
}
2.创建厂家类,实现1步骤的接口
package com.rango.factory;
import com.rango.service.usbSell;
//目标类:金士顿厂家,不接受用户的单独购买
public class UsbKingFactory implements usbSell {
/**
* 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
* 返回值表示一个u盘的价格
*
* @param amount
* @return
*/
@Override
//一个128G的U盘是85元.
// 后期根据amount,可以实现不同的价格,例如10000个,单击是80,50000个75
public float sell(int amount) {
return 85.0f*amount;
}
}
3.创建商家,就是代理,也需要实现1步骤中的接口
package com.rango.business;
import com.rango.factory.UsbKingFactory;
import com.rango.service.usbSell;
//淘宝是一个商家,代理金士顿U盘的销售
public class TaoBao implements usbSell {
// 声明 商家代理的厂家具体是谁
private UsbKingFactory factory =new UsbKingFactory();
@Override
// 实现销售U盘功能
public float sell(int amount) {
// 向厂家发送订单,告诉厂家,我买了U盘,厂家发货
// 发送给工厂,我需要的订单,返回报价
float price = factory.sell(amount);
// 商家需要加价也就是代理要增加价格
price = price + 25;
//在目标类的方法调用后,你做的其他功能,都是增强的意思
System.out.println("淘宝再给你返回一个优惠券,或者红包");
// 增加的价格
return price;
}
}
4.创建客户端类,调用商家的方法买一个u盘
import com.rango.business.TaoBao;
public class shopMain {
public static void main(String[] args){
// 创建代理的商家淘宝对象
TaoBao taoBao = new TaoBao();
// 我只向淘宝买一件产品,得到报价
float price = taoBao.sell(2);
System.out.println("购买一件产品.淘宝的报价为: "+price);
}
}
总结一下代理类完成的功能:
目标类中方法的调用 功能增强
静态代理的优缺点
优点：
实现简单
容易理解
缺点：
当目标类增加了,代理类可能也需要成倍的增加
当你的接口中功能在增加了,或者修改了,会影响众多的实现类,厂家类,代理都需要修改,影响比较多.
动态代理
什么是动态代理？
使用jdk的反射机制,创建对象的能力,创建的是代理类的的对象.而不用我们创建类文件,不用写java文件
什么叫动态?
在程序执行时,调用jdk提供的方法才能创建代理类的对象
什么时候用动态代理？
在静态代理中目标很多的时候,可以使用动态代理,避免静态代理的缺点
动态代理的优点
代理类数量可以很少,
当你修改了接口中的方法时,不会影响代理类。
动态代理:在程序执行过程中,使用jdk的反射机制,创建代理类对象,并动态的指定要代理目标类。
换句话说:动态代理是一种创建java对象的能力,让你不用创建 TaoBao类就能创建代理类对象,除去了中间商
Java中创建对象
创建类文件,java 文件编译为class
使用构造方法,创建类的对象
动态代理介绍
- 动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的，java源文件。
- 动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。
- 动态代理的实现方式常用的有两种：使用JDK动态代理，或CGLlB动态代理。
动态代理的实现
- jdk动态代理(理解):使用java反射包中的类和接口实现动态代理的功能,反射包java.lang.reflect,里面有三个类:InvocationHandler,Method,Proxy
- cglib动态代理(了解): cglib是第三方的工具库,创建代理对象
1. cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，实现功能的修改。
2. 因为cglib是继承，重写方法，所以要求目标类不能是fina1的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，比如mybatis，spring框架中都有使用。
HelloService
package com.rango.service;
public interface HelloService {
// 跟 name 打招呼
public void sayHello(String name);
}
HelloServiceImpl
package com.rango.service.Impl;
import com.rango.service.HelloService;
public class HelloServiceImpl implements HelloService {
@Override
public void sayHello(String name){
System.out.println("你好：" + name);
}
}
TestApp
package Test;
import com.rango.Impl.HelloServiceImpl;
import com.rango.service.HelloService;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestApp {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
// HelloService service = new HelloServiceImpl();
// service.sayhello("张三");
// 以上是常规方法执行sayhello
// 使用反射机制进行创建sayhello方法,核心Method(类中的方法)
HelloServiceImpl target = new HelloServiceImpl();
// 获取sayhello这个名称对应的Method类对象
// public Method getMethod(String name, Class<?>... parameterTypes)
// HelloService.class反射获取类
// HelloService.class.getMethod获取类中的方法
// 返回的是名称（"sayhello"）所对应的方法对象
// 加入该方法的参数有多个该怎么办?
// parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。
Method method = HelloService.class.getMethod("sayhello", String.class);
// 通过Metho可以执行sayhello方法的调用
/*
* public Object invoke(Object obj, Object... args)
* 表示执行方法的调用
* 参数:
* 1.Object,表示对象,要执行这个对象的方法
* 2.Object...args,方法执行时的参数值
* 返回值:
* Object:方法执行后的返回值
* */
// 表达的意思是，执行target对象sayHello，参数是李四
Object ret = method.invoke(target, "李四");
}
}
JDK动态代理
- 反射，Method类，表示方法，类中的方法，通过Method可以执行某个方法
- jdk动态代理的实现
反射包 java.lang.reflect，里面有三个类 ： InvocationHandler，Method ，Proxy
1). InvocationHandler接口（调用处理器）：就一个方法invoke()
invoke()：表示代理对象要执行的功能代码。你的代理类要完成的功能就卸载invoke()里面。
代理类完成的功能：
调用目标方法，执行目标方法的功能
功能增强，在目标方法调用时，增加功能
方法原型：
public Object invoke(Object proxy, Method method, Object[] args)
参数：
Object proxy: jdk创建的代理对象，无需赋值
Method method: 目标类中的方法，jdk提供method对象的
Object[] args：目标类中方法的参数，jdk提供的
InvocationHandler接口：表示你的代理要干什么
怎么用：
创建类实现接口InvocationHandler
重写invoke()方法，把原来静态代理中代理类要完成的功能，写在这
2). Method类:表示方法的,确切的说就是目标类中的方法。
作用
通过 Method可以执行某个目标类的方法, Method. invoke();
method. invoke(目标对象,方法的参数)
object ret= method. invoke(service22,"李四");
说明
method.invoke()就是为了用来执行目标方法的,等同于静态代理中的
// 向厂家发送订单,告诉厂家,我买了U盘,厂家发货
float price = factory.sell(amount);
3). proxy类：核心的对象，创建代理对象。之前创建对象都是new类的构造方法（）
现在我们是使用proxy类的方法，代替new的使用。
方法：静态方法 newProxyInstance(）
作用是：创建代理对象，等同于静态代理中的TaoBao taoBao=new TaoBao()
public static Object newProxyInstance( ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
参数:
ClassLoader loader 类加载器,负责向内存中加载对象的,使用反射机制获取对象的classLoader Class<?>[]
interfaces: 接口,目标对象实现的接口,也是反射获取的 InvocationHandler h :
我们自己写的,代理类要完成的功能
返回值：就是代理对象
实现动态代理
- 创建接口,定义目标类要完成的功能
- 创建目标类实现接口
- 创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能
1. 调用目标方法
2. 增强功能 - 使用Proxy类的静态方法,创建代理对象,并把返回值转换成接口类型
第一步：创建接口，定义目标所需功能
public interface UsbSell {
float sell(int amount);
}
第二步:创建目标类实现接口
public class UsbKingFactory implements UsbSell {
@Override
public float sell(int amount) {
System.out.println("目标类中,执行了sell目标方法");
return 85.02f;
}
}
我们写了接口类,定义了功能,写了代理类,实现了接口功能,按照以前的操作,现在就需要写一个真正的代理类,创建对象.
第三步: 创建Invocationhandler实现类.在invoke()方法中完成代理类的对象
1.调用目标的方法
2.增强功能
public class MyHandle implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
我们就在以前代理类的实现方法上进行修改
//之前的代理类
public class TaoBao implements usbSell {
// 声明 商家代理的厂家具体是谁
private UsbKingFactory factory =new UsbKingFactory();
@Override
// 实现销售U盘功能
public float sell(int amount) {
// 向厂家发送订单,告诉厂家,我买了U盘,厂家发货
// 发送给工厂,我需要的订单,返回报价
float price = factory.sell(amount);
// 商家需要加价也就是代理要增加价格
price = price + 25;
//在目标类的方法调用后,你做的其他功能,都是增强的意思
System.out.println("淘宝再给你返回一个优惠券,或者红包");
// 增加的价格
return price;
}
}
调用目标的方法
//传入是谁的对象,就给谁创建代理
public MyHandle(Object target) {
this.target = target;
}
invoke里面的设置
Object res =null;
// 向厂家发送订单,告诉厂家,我买了U盘,厂家发货
// 发送给工厂,我需要的订单,返回报价
// float price = factory.sell(amount);
res = method.invoke(target,args); //待执行目标方法,执行后返回值
第四步: 使用Proxy类的静态方法,创建代理对象,并把返回值转换成接口类型
创建一个MainShop类
public class MainShop {
public static void main(String[] args){
// 1.创建对象,使用Proxy
// 2.创建目标对象
UsbSell factory = new UsbKingFactory();
// 3.创建Invocationhandler对象
InvocationHandler myHandle = new MyHandle(factory);
// 4.创建代理对象
UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
factory.getClass().getInterfaces(),
myHandle);
// 通过代理执行方法
float price = proxy.sell(1);
System.out.println("通过动态代理对象,调用方法:" +price);
}
}
JDK动态代理执行流程
我们先复习一下,Proxy类,实现动态代理的流程,使用返回指定接口的代理类实例,
我们此时debug一下程序,在invok实现类中打一个断点
此时我们再观察,代理对象MyHandler里面的invoke方法的参数
静态代理项目中的应用
我们需要知道代理能做什么?
在不改变原来目标方法功能的前提下,可以在代理中增强自己的功能代码,程序开发中的意思,
比如:你所在的项目,有一个功能是其他人(公司其他部门,其他小组的人)写好的,你可以使用
//比如,同事开发一个GoNong类
GoNong.class ,
GoNong gn=new GoNong()
//我们需要增加一个print方法
我们发现这个功能现在还不能完全满足我项目的需要,我需要在print()执行过后,需要自己再增加代理,使用什么方法那,肯定是代理,因为别人不会让我们看源文件
执行步骤：
- 我们先建立一个接口功能,很简单的一个功能
public interface HelloService {
/**
* 打印报表,报表
* @param name
* @return
*/
int print (String name);
}
- 我们再加个接口实现类
public class GoNeng implements HelloService {
@Override
public int print(String name) {
System.out.println("其他人写好的这个方法!");
return 2;
}
}
- 我们如果相对上述功能进行修改,我们不可能直接去在原方法上进行修改
设置一个类来使用这个接口
public class MyApp {
public static void main(String[] args){
GoNeng gn = new GoNeng();
int i = gn.print("nihao1");
System.out.println("num" +i);
}
}
问题是如果我们想修改这个功能改怎么办?在不修改源代码的基础上,我们可以创建一个代理类,来增强这个类方法,
- 设置一个代理类实现功能的增强和代理
public class MyInvocationHandler implements InvocationHandler {
private Object target=null;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 调用目标方法,执行print()得到2
Object res = method.invoke(target,args); //返回为2的结果
//我们可以把结果再乘以2
if (res!=null)
{
Integer num = (Integer) res;
res = num*2;
}
return null;
}
}
- 主方法测试
public class MyApp {
public static void main(String[] args){
// GoNeng gn = new GoNeng();
// int i = gn.print("nihao1");
// System.out.println("num" +i);
GoNeng goNeng = new GoNeng();
InvocationHandler handler = new MyInvocationHandler(goNeng);
HelloService proxy = (HelloService) Proxy.newProxyInstance(goNeng.getClass().getClassLoader(), goNeng.getClass().getInterfaces(),
handler);
int num = proxy.print("市场");
System.out.println("我们期望得到的 num =="+num);
}
}
测试System.out.println(“动态代理类参数接口”+goNeng.getClass().getInterfaces()[0].getName());
动态代理类参数接口com.rango.service.HelloService
其他人写好的这个方法!
我们期望得到的 num ==4
如果没有接口
JDK动态代理,必须要有接口出现,如果没有,我们可以使用cglib实现
574
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
