设计模式-代理模式
一、什么是代理模式？
代理模式: 给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。（提供了对目标对象另外的访问方式;即通过代理对象访问目标对象，这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。）
二、为什么要用代理模式？
1. 中介隔离作用
在某些情况下，一个客户类不想或者不能直接引用一个目标对象，而代理对象可以在客户类和目标对象之间起到中介的作用，其特征是代理类和目标类实现相同的接口。
eg: 假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决。
2. 开闭原则，增加功能
代理类除了是客户类和目标类的中介之外，我们还可以通过给代理类增加额外的功能来扩展目标类的功能，这样做我们只需要修改代理类而不需要再修改目标类，符合代码设计的开闭原则。代理类主要负责为目标类预处理消息、过滤消息、把消息转发给目标类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用目标类的相关方法，来提供特定的服务。真正的业务功能还是由目标类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的目标类。
所以呀，不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法
三、代理模式种类
1. 静态代理
- 静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和目标类的关系在运行前就确定了。
- 静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
代码示例：
接口:IUserDao.java
/**
* 接口
*/
public interface IUserDao {
void insert();
}
目标对象:UserDao.java
/**
* 接口实现
* 目标对象
*/
public class UserDao implements IUserDao{
@Override
public void insert() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----数据已保存！----");
}
}
代理对象：UserDaoProxy.java
/**
* 代理对象
*/
public class UserDaoProxy implements IUserDao {
private IUserDao target;
//接收保存目标对象
public UserDaoProxy(IUserDao userDao) {
this.target = userDao;
}
/**
* 对目标对象的方法进行拓展：记录方法执行时间
*/
@Override
public void insert() {
long startTime = System.currentTimeMillis();
System.out.println("记录执行开始时间:" + startTime);//拓展功能
target.insert();//执行目标对象的方法
long endTime = System.currentTimeMillis();
System.out.println("记录执行开始时间:" + endTime);//拓展功能
System.out.println("insert 方法执行耗时为：" + (endTime-startTime) + "ms");
}
}
测试类：AppTest.java
/**
* 测试类
*/
public class AppTest {
public static void main(String[] args) {
//目标对象
UserDao target = new UserDao();
//代理对象,把目标对象传给代理对象,建立代理关系
UserDaoProxy proxy = new UserDaoProxy(target);
proxy.insert();//执行的是代理的方法
}
}
测试结果：
记录执行开始时间:1639476255637
----数据已保存！----
记录执行开始时间:1639476256149
insert 方法执行耗时为：512ms
上面代码和我们项目开发中的三层架构(dao、service、controller)比较类似，实际上三层架构使用了静态代理。
总结：
1.可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
2.缺点:
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类，类太多。同时,一旦接口增加方法,目标对象与代理对象都要维护。
如何解决静态代理中的缺点呢?答案是可以使用动态代理方式。
2. 动态代理
2.1 JDK动态代理
动态代理有以下特点:
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理
JDK中生成代理对象的API
代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:
ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
代码示例
接口类IUserDao.java以及接口实现类,目标对象UserDao是一样的,没有做修改。在这个基础上,增加动态处理器类和测试类
动态处理器：JDKProxyHandler.java
/**
* 动态处理器
*/
public class JDKProxyHandler implements InvocationHandler {
//维护一个目标对象
private Object target;
public JDKProxyHandler(Object target){
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTime = System.currentTimeMillis();
System.out.println("记录执行开始时间2:" + startTime);//拓展功能
Object result = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println("记录执行开始时间2:" + endTime);//拓展功能
System.out.println("insert 方法执行耗时为：" + (endTime-startTime) + "ms");
return result;
}
}
测试类：AppTest2.java
public class AppTest2 {
public static void main(String[] args) {
// 目标对象
IUserDao target = new UserDao();
// 【原始的类型 UserDao】
System.out.println(target.getClass());
// 给目标对象，创建代理对象
IUserDao proxy = (IUserDao) Proxy.newProxyInstance(IUserDao.class.getClassLoader(), new
Class[]{IUserDao.class}, new JDKProxyHandler(target));
// class $Proxy0 内存中动态生成的代理对象
System.out.println(proxy.getClass());
// 执行方法 【代理对象】
proxy.insert();
}
}
测试结果
class com.cc.staticProxy.UserDao
class com.sun.proxy.$Proxy0
记录执行开始时间2:1639478236579
----数据已保存！----
记录执行开始时间2:1639478237083
insert 方法执行耗时为：504ms
总结：代理对象不需要实现业务接口,但是目标对象一定要实现业务接口,否则不能用动态代理
2.2 Cglib动态代理
上面的静态代理和JDK动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理。
Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。
- JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
- Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
- Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
- 其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。
- 目标对象的方法如果为final/static,不会被拦截,即不会执行目标对象额外的业务方法.。
- JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。
代码示例
需要导入cglib和asm（因为使用了CGlib的Enhancer类，这个类用于为非接口类型创建一个Java代理，类里面使用了org.objectweb.asm.Type。ASM是一个字节码解析的工具，导入ASM的jar）依赖包：
asm-9.1.jar
cglib-3.3.0.jar
目标对象：UserDao.java
/**
* 目标对象
*/
public class UserDao {
public void insert() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----数据已保存！----");
}
}
Cglib代理工厂:CglibProxyFactory.java
public class CglibProxyFactory implements MethodInterceptor {
//维护目标对象
private Object target;
public CglibProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
long startTime = System.currentTimeMillis();
System.out.println("记录执行开始时间3:" + startTime);//拓展功能
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println("记录执行开始时间3:" + endTime);//拓展功能
System.out.println("insert 方法执行耗时为：" + (endTime-startTime) + "ms");
return returnValue;
}
}
测试类：AppTest3.java
public class AppTest3 {
public static void main(String[] args) {
//目标对象
UserDao target = new UserDao();
//代理对象
UserDao proxy = (UserDao)new CglibProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy.insert();
}
}
测试结果
记录执行开始时间3:1639479569034
----数据已保存！----
记录执行开始时间3:1639479569536
insert 方法执行耗时为：502ms
总结
代理模式优缺点？
优点：
1. 代理模式能将代理对象与真实被调用的目标对象隔离
2. 一定程度上降低了系统的耦合度，扩展性好
3. 可以起到保护目标对象的作用
- 可以对目标对象的功能增强
缺点：
1. 代理模式会造成系统设计中类的数量增加
2. 在客户端与目标对象之间增加一个代理对象，会造成请求处理速度变慢
3. 增加了系统的复杂度
静态代理和动态代理的区别？
- 静态代理只能通过手动完成代理操作，如果被代理类增加新方法，代理类需要同步新增方法，违背开闭原则
- 动态代理采用运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则
- 若动态代理需要对目标类的增强逻辑扩展，结合策略模式，只需新增策略类便可完成，无需修改代理类代码
Cglib和jdk动态代理的区别？
1、Jdk动态代理：利用拦截器（必须实现InvocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理
2、 Cglib动态代理：利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理
什么时候用cglib什么时候用jdk动态代理？
1、目标对象生成了接口 默认用JDK动态代理
2、如果目标对象使用了接口，可以强制使用cglib
3、如果目标对象没有实现接口，必须采用cglib库，Spring会自动在JDK动态代理和cglib之间转换
JDK动态代理和cglib字节码生成的区别？
1、JDK动态代理只能对实现了接口的类生成代理，而不能针对类
2、Cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法的增强，但是因为采用的是继承，所以该类或方法最好不要生成final，对于final类或方法，是无法继承的
Cglib比JDK快？
1、cglib底层是ASM字节码生成框架，但是字节码技术生成代理类，在JDL1.6之前比使用java反射的效率要高
2、在jdk6之后逐步对JDK动态代理进行了优化，在调用次数比较少时效率高于cglib代理效率
3、只有在大量调用的时候cglib的效率高，但是在1.8的时候JDK的效率已高于cglib
4、Cglib不能对声明final的方法进行代理，因为cglib是动态生成代理对象，final关键字修饰的类不可变只能被引用不能被修改
Spring如何选择是用JDK还是cglib？
1、当bean实现接口时，会用JDK代理模式
2、当bean没有实现接口，用cglib实现
3、可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>）
本文来自博客园，作者：houmoney，转载请注明原文链接：https://www.cnblogs.com/houmoney/p/15325255.html
浙公网安备 33010602011771号