代理模式是一种非常重要的设计模式,在java语言中有着广泛的应用,包括Spring AOP的核心设计思想,都和代理模式有着密切关系。
1、代理模式概念机分类
2、代理模式应用场景
3、掌握静态代理、动态代理运用
4、理解JDK动态代理实现原理
代理模式定义:
为其他对象提供一种代理,以控制这个对象的访问,代理对象其实是起到了一个中介的作用,可以去掉一些功能服务,添加一些额外的功能服务。
常见的几种代理模式:
1:远程代理:类似于客户端服务器这种模式,列一个为不同地理对象提供局域网代表对象。(类似于客户端和服务器端)
2:保护代理:控制对象的访问权限。(发帖功能)
3:智能代理:提供对目标对象额外的服务。(火车站)
4:虚拟代理:根据需要将资源消耗很大的对象进行延迟,真正需要的时候进行创建。(网页中图片的加载,先用一张虚拟的图片进行显示,等图片加载完成后再进行显示)
代理模式实现—静态代理
静态代理:代理和被代理对象在代理之前是确定的,他们都实现相同的接口或者继承相同的抽象类。
继承代理:子类继承实现方法(move方法)的父类,当子类要去实现相同方法时,调用父类的方法实现自己想要做的事(super.move()),完成代理
聚合代理:将代理的类作为属性,通过构造方法等方法将它的实例化对象传入后,再调用代理类的方法作为自己当前类完成要做的事。
代理模式就是一个类可以代替实现另一个类的功能,同时功能可以扩展或者缩减。静态代理有两种实现方法,一种是继承被代理类,然后在代理类中调用被代理类的方法,同时在逻辑前后可以扩展方法。另一种是聚合的方法,代理类中存入一个被代理类的引用,构造方法中初始化这个引用,然后调用这个引用的方法,也就是被代理类的方法。
注意:聚合比继承更合适代理模式
使用聚合的方式实现静态代理是合适的更好的方法,也就是代理类和被代理类同样实现同一个接口,然后代理类中存入一个被代理类的成员变量,真正调用的是这个成员变量的方法,这样可以实现多种功能的叠加,而且调整功能的顺序操作也会很简单,只需要客户端调整调用功能的顺序即可,如果采用继承的方式,就必须要实现多个功能顺序不同的代理类,这样代理类的数量会越来越多,不利于后面的维护工作。
案例–代理类功能的叠加
1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加,我们的代理类会无限的膨胀下去。
2. 聚合的方式:
由于代理类和被代理类都实现了相同的接口,那么代理类的构造参数就可以传入该相同的接口,这样在后面功能叠加的时候就可以传入其他功能的代理类,因为他们都实现了相同的父接口。从而达到功能叠加的作用。
eg:汽车类,先记录日志再记录时间
Car car = new Car();
CarTimeProxy ctp = new CarTimeProxy(car);
CarLogProxy clp = new CarLogProxy(ctp);
clp.move();
先记录时间再记录日志
Car car = new Car();
CarLogProxy clp = new CarLogProxy(car);
CarTimeProxy ctp = new CarTimeProxy(clp);
ctp.move();
聚合的方式比继承的方式灵活很多,通过聚合的方式,代理之间也是可以相互传递的,
相互组合。
注意:聚合代理优于继承代理,因为实现功能叠加的情况下,聚合代理通过互相代理可以实现功能重用,而继承代理必须写多个类来实现多功能叠加。
注意:静态代理只能代理一种类型的被代理类,换个类型deep就不行了,这时就需要用到动态代理
JDK动态代理(动态产生代理,实现对不同类,不同方法的代理)
动态的代理:在代理类和被代理类之间加入一个加入一个事务处理器(InvocationHandler类),java动态代理类位于java.long.reflect包下,一般涉及两个类
(1),Interface InvocationHandler:该接口中仅定义了一个方法public Object invoke(Object obj,Method method,Object[] args)在使用时,第一个参数obj一般指被代理类对象,method是被代理类的方法,args为该方法的参数数组。这个抽象方法在代理类中实现。
(2)Proxy是产生动态代理的一个类,我们通过static Object newProxyInstance(ClassLoader,Class[] interfaces,InvoactionHandler h):就可以动态地产生一个代理类,该函数返回代理类的一个实例,返回后的代理类可以当做被代理类使用(可使用被代理类在接口中声明过的方法)
动态代理的实现步骤
1:创建一个实现接口InvocationHandler的类,它必须实现invoke方法
2:创建被代理的类以及接口
3:调用Proxy的静态方法,创建一个代理类
newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)
4:通过代理调用方法
JDK动态代理newProxyInstance(类加载器,类实现的接口,InvocatioinHandle)
Proxy.newProxyInstance(cls.getClassLoader,cls.getInterface(),实现InvocatioinHandle的处理器)
作业:时间、日志的叠加
public static void main(String[] args) throws Throwable {
Car car = new Car();
InvocationHandler timehandler =new TimeHandler(car);
Class<?> cls = car.getClass();
/**
* loader 类加载器
* interfaces 实现接口
* h InvocationHandler
*/
Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), timehandler);
InvocationHandler logHandler= new LogHandler(m);
Class<?> clsm =m.getClass();
Moveable m2 = (Moveable) Proxy.newProxyInstance(clsm.getClassLoader(), clsm.getInterfaces(), logHandler);
m2.move();
}
使用cglib动态产生代理
**注意:**JDK动态代理只能代理实现了接口的类,若没有实现接口的类不能实现JDK的动态代理。
JDK实现动态代理,即可以为任何对象增加功能
示例:代理类的实现
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
*使用jdk提供的invocationHandler接口实现动态代理
* 实现对任何类(不仅限于Moveable)的记录时间操作。
*/
public class TimeHandler implements InvocationHandler
{
private Object target; //定义一个Object,代表被代理的对象
public TimeHandler(Object target)
{
this.target=target;
}
/**
* 1. 实现InvocationHandler接口,并重写invoke方法
* @param proxyObj 生成的代理对象。
* @param method 要代理的方法
* @param args 代理方法的参数
* @return 代理方法返回的返回值
*/
@Override
public Object invoke(Object proxyObj, Method method, Object[] args) throws Throwable
{
long start = System.currentTimeMillis();
System.out.println("小车开始行驶。。。");
Object returnObj= method.invoke(target); //执行原有方法。如果方法有参数,作为invoke第二参数传入
long end=System.currentTimeMillis();
System.out.println("小车结束行驶。。。时间"+(end-start));
return returnObj; //将被代理方法的返回值返回。
}
}
CGLIB动态代理针对类来实现代理的,对指定目标类产生一个子类,通过方法拦截技术拦截所有父类方法的调用。
相关代码——(下):
@CglibProxy.java
public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer=new Enhancer();
public Object getProxy(Class cls){
//设置创建子类的类
enhancer.setSuperclass(cls);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 参数:object:拦截所有目标类方法的调用,method:目标方法的反射对象,args:方法的参数,methodproxy:代理类的实例。
*/
public Object intercept(Object object, Method method, Object[] args,
MethodProxy methodproxy) throws Throwable {
syso("日志开始...");
methodproxy.invokeSuper(object, args);
syso("日志结束...");
return null;
}
}
模拟JDK动态实现代理类的步骤
动态代理思路
1.声明一段源码(动态产生代理)
2.编译源码(JDK Compiler API),产生新的类(代理类)
3.将这个类load到内存当中,产生一个新的对象(代理对象)
4.return 代理对象
代理模式-动态代理 : JDK的动态代理模式
在不改变原有类及方法的基础上,增加一些额外的业务逻辑, 这种方式叫做AOP(面向切面编程)
代理模式这种机制可以叫做AOP,在不改变原有代码的基础上,添加或者删除某些方法
例如:
要调用某个jar包中某个类的方法,但是不能改变源码,我们可以采用JDK的动态代理模式,在该方法的前后添加业务逻辑,如记录日志,权限控制等。
完善动态代理实现
首先得到系统编译器,通过编译器得到文件管理者,以获取文件,然后编译器执行编译任务,完成编译之后,将class文件加载到类加载器中,通过构造方法得到实例,然后调用newInstance()接收一个对象的实例并返回。
(1)拿到编译器 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
(2)文件管理者 StandardJavaFileManager fileMgr = Compiler.getStandardFileManager(null,null,null);
(3)获取文件 Iterable units = fileMgr.getJavaFileObjects(filename);
(4)编译任务 CompilationTask t =compiler.getTask(null,fileMgr,null,null,null,units);
(5)load到内存
ClassLoader cl = ClassLoader.getSystemClassLoader();
Class c = cl.loadClass(”com.imooc.proxy.$Proxy0”);
(6)通过代理对象的构造器构造实例,并返回代理对象
Constructor ctr = c.getConstructor(infce);
return ctr.newInstance(new Car());
代码实例:
//需要编译的java文件
String filename = System.getProperty("user.dir")+"/bin/com/imooc/proxy/$Proxy0.java";
//编译
//拿到编译器
JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
//文件管理者
StandardJavaFileManager fileMgr =
complier.getStandardFileManager(null, null, null);
//获取文件
Iterable units = fileMgr.getJavaFileObjects(filename);
//编译任务
CompilationTask t = complier.getTask(null, fileMgr, null, null, null, units);
//进行编译
t.call();
fileMgr.close();
//load 到内存
ClassLoader cl = ClassLoader.getSystemClassLoader();
//从内存中获取要处理的类
Class c = cl.loadClass("com.imooc.proxy.$Proxy0");
//给此类的构造方法传入参数
Constructor ctr = c.getConstructor(InvocationHandler.class);
//调用对象的方法
return ctr.newInstance(h);
如何实现真正的动态代理,动态的指定业务逻辑呢?
1.需要创建一个事务处理器,首先创建一个接口也就是InvocationHandler,为了模拟JDK,这里把接口的名字和JDK事务处理器名称一样,同样写一个方法叫做invoke(),用来表示对某个对象的某个方法进行业务处理,所以需要把某个对象以及对象的方法作为invoke()方法的参数传递进来,invoke(Object obj,Method method),方法作为参数使用到了java反射,需要把此包引入。这样InvocationHandler接口就完成了。
2.创建事务处理实现类比如说时间代理TimerProxy,实现了InvocationHandler接口,这样结构就成了
public class TimerProxy implements InvocationHandler{
@Override
public void invoke(Object o, Method m) {
//业务逻辑
method.invoke(目标对象,参数);
//业务逻辑
}
需要将目标对象传入,没有参数可以不写参数,创建代理对象的构造方法,初始化目标对象
3.在Proxy类的newProxyInstance()方法中,除了要把目标Class接口作为参数外,还需要把事务处理器InvocationHandler 传进去,然后更改创建实例对象中硬编码的部分用事务处理器方法替代即可。难点在于字符串的拼接。
1、声明一段源码,源码动态产生动态代理
2、源码产生java文件,对java文件进行编译
3、得到编译文件 调用编译任务 生产class文件
4、把class文件load到内存之中,产生代理类对象返回
jdk代理整体思路:
1. InvocationHandler对象聚合了原始的父类对象, 并抽取了公共的代理控制逻辑。
2. Proxy聚合了handler对象,并生成新的class;在新的class定义中对接口中的每个方法调用handler对象的对应方法。