本文由老王出租房子引出——代理设计模式，将从最简略的动态代理实现开始，后延长应用 jdk 实现动静代理，最初扩大到 Cglib 实现动静代理。为了更深刻了解代理模式，咱们会对理论利用中的典型案例进行介绍，包含在 Spring 和 Mybatis 中的利用。
读者能够拉取残缺代码到本地进行学习，实现代码均测试通过后上传到码云。
一、引出问题
上篇文章老王和小王组装电脑尽管完满完结了，然而老王和小王的争吵却并没有完结。老王决定将小王扫地出门，并把小王住的房子出租，租金用来补救游戏本的花销。
老王破费很大的功夫，搞清楚了各种租房平台的规定并公布了房源信息，接着街坊揭示他：房子租出去并不代表躺着收租金了，有一天租客提出一些额定的要求，在合同容许的范畴内，你也要尽量满足他们（为了便于了解，事实当然不存在啦），房子租出去后物业有问题你还要和物业协调。
老王开始思考，如果我直租给租客，会面临两个问题：
①我须要理解租房的全过程，我本人的事和租房的事重大的耦合了。
②租客提出的一些要求我不得不染指到其中，我不得不扭转我本人的行程安顿。
我应该想到一种方法，
第一点，将业务和性能解耦，业务层专一业务，比方网络接口申请，业务层只须要晓得该调哪个接口申请办法，而不须要晓得这个接口申请是如何发动网络申请的。
第二点，创立一个切面，在这个切面中减少一些通用的附加操作，比方注解解析，日志上报等，防止这些通用操作在每个接口办法都要写一遍。
老王灵感一闪：我能够给我的房子找一个一个代理，以管制对这个房子的治理。即通过代理治理房子. 这样做的益处是: 能够在指标实现的根底上, 加强额定的性能操作, 即扩大指标的性能。
这实际上就是动态代理。
二、动态代理
代理模式：为一个对象提供一个替身，以管制对这个对象的拜访。即通过代理对象拜访指标对象. 这样做的益处是: 能够在指标对象实现的根底上, 加强额定的性能操作, 即扩大指标对象的性能。
也即在动态代理中应该有三个角色：
①代理对象，生产端通过它来拜访理论的对象（中介）
②理论被代理的对象（老王房子）
③一组能够被代理的行为的汇合，通常是一个接口（老王和中介之间的约定事件）
老王与中介的约定接口：
/**
* 代理行为的汇合（接口）* @author tcy
* @Date 02-08-2022
*/
public interface HostAgreement {
// 房子出租
void rent();}理论对象类（老王）：
/**
* 指标对象
* @author tcy
* @Date 02-08-2022
*/
public class Host implements HostAgreement {
/**
* 指标对象的原始办法
*/
@Override
public void rent() {System.out.println("这个房子要出租...");
}
}代理类（中介）：
/**
* 理论对象的代理
* @author tcy
* @Date 02-08-2022
*/
public class HostProxy implements HostAgreement {
// 指标对象，通过接口来聚合
private HostAgreement target;
// 结构器
public HostProxy(HostAgreement target) {this.target = target;}
@Override
public void rent() {System.out.println("房子出租前，装修一下....");
target.rent();
System.out.println("房子出租后，与物业协调....");// 办法
}
}客户类：
/**
* @author tcy
* @Date 02-08-2022
*/
public class Client {public static void main(String[] args) {// 创立指标对象 ( 被代理对象)
Host hostTarget = new Host();
// 创立代理对象, 同时将被代理对象传递给代理对象
HostProxy hostProxy = new HostProxy(hostTarget);
// 通过代理对象，调用到被代理对象的办法
hostProxy.rent();}
}这样就很好的解决了老王想到的问题，老王称心如意的看着本人的成绩。
但中介看着老王的计划开始小声的嘀咕了，我一个人管那么多的房子，每一个房东都让我实现一个代理类，那我就会有很多的代理类，这是个问题呀！还有就是，有一天协定变动了，咱们俩都要做许多工作。
最好是不要让我实现咱们之间的协定（接口）了。
老王开始革新他的计划了。
三、动静代理 Jdk
老王忽然想到，应用 jdk 的动静代理能够很好的解决这个问题。
Jdk 代理对象的生成，是利用 JDK 的 API，动静的在内存中构建代理对象动静代理，也叫做：JDK 代理、接口代理。
咱们对代码进行革新。
指标对象和指标对象的协定放弃不变，咱们须要批改也就是中介（代理类）的代码。
代理类：
/**
* 代理类
* @author tcy
* @Date 02-08-2022
*/
public class HostProxy {
// 保护一个指标对象 , Object
private Object target;
// 结构器，对 target 进行初始化
public HostProxy(Object target) {this.target = target;}
// 给指标对象 生成一个代理对象
public Object getProxyInstance() {
// 阐明
/*
* //1. ClassLoader loader：指定以后指标对象应用的类加载器, 获取加载器的办法固定
//2. Class<?>[] interfaces: 指标对象实现的接口类型，应用泛型办法确认类型
//3. InvocationHandler h : 事件解决，执行指标对象的办法时，会触发事件处理器办法, 会把以后执行的指标对象办法作为参数传入
*/
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 该办法会调用指标对象的办法
* @param proxy
* @param method
* @param args
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("房子出租前，装修一下....");
// 反射机制调用指标对象的办法
Object returnVal = method.invoke(target, args);
System.out.println("房子出租后，与物业协调....");
return returnVal;
}
});
}
}客户端：
/**
* @author tcy
* @Date 02-08-2022
*/
public class Client {public static void main(String[] args) {
// 创立指标对象
HostAgreement hostAgreement = new Host();
// 给指标对象，创立代理对象, 能够转成 ITeacherDao
HostAgreement hostProxy = (HostAgreement)new HostProxy(hostAgreement).getProxyInstance();
// proxyInstance=class com.sun.proxy.$Proxy0 内存中动静生成了代理对象
// 通过代理对象，调用指标对象的办法
hostProxy.rent();}
}这样就很好的解决了中介实现协定（接口）的问题，无论房子怎么变动，中介都能很完满的实现代理。
中介想让老王给他讲讲，Proxy.newProxyInstance（）怎么就能完满的解决这个问题了。
老王撸起袖子开始给他讲实现原理。
在咱们用 Proxy.newProxyInstance 实现动静代理的时候，有三个参数，第一个便是 classloader。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
在咱们的代码中 classloader 就是指标对象的类加载器。
第二个参数是 指标对象实现的接口类型，应用泛型办法确认类型，咱们应用 java 的反射 target.getClass().getInterfaces() 获取到了接口类型。
第三个参数是实现 InvocationHandler 接口，并实现它惟一的办法 invoke()，invoke 其实就会执行咱们的指标办法，咱们就能够在 invoke 前后去做一些事。比方，房子出租前，装修一下或者房子出租后，与物业协调。
中介听完称心如意的来到了，老王总感觉哪里不对，中介都从协定中抽出来了，那我为什么还要被协定束缚着呢？我何不也从协定（接口）中抽离进去。
咱们查阅书籍感觉 Cglib 或者能帮到他。
四、动静代理 Cglib
1、概念及实现
CGLIB 是一个弱小的、高性能的代码生成库。采纳十分底层的字节码技术，对指定指标类生成一个子类，并对子类进行加强，其被广泛应用于 AOP 框架（Spring、dynaop）中，用以提供办法拦挡操作。
CGLIB 代理次要通过对字节码的操作，为对象引入间接级别，以管制对象的拜访。咱们晓得 Java 中有一个动静代理也是做这个事件的，那咱们为什么不间接应用 Java 动静代理，而要应用 CGLIB 呢？答案是 CGLIB 相比于 JDK 动静代理更加弱小，JDK 动静代理尽管简略易用，然而其有一个致命缺点是，只能对接口进行代理。如果要代理的类为一个一般类、没有接口，那么 Java 动静代理就没法应用了。
老王感觉这些概念都不说人话，不如老王间接着手革新我的项目。
CGLIB 是一个第三方的类库，首先须要引入依赖。
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
当初只须要两个角色即可，代理类和指标类。
指标类：
/**
* @author tcy
* @Date 02-08-2022
*/
public class Host {
/**
* 租房办法
*/
public void rent() {System.out.println("这个房子要出租...");
}
}代理类：
/**
* 代理类
* @author tcy
* @Date 02-08-2022
*/
public class HostProxy implements MethodInterceptor {
// 保护一个指标对象
private Object target;
// 结构器，传入一个被代理的对象
public HostProxy(Object target) {this.target = target;}
// 返回一个代理对象: 是 target 对象的代理对象
public Object getProxyInstance() {
//1. 创立一个工具类
Enhancer enhancer = new Enhancer();
//2. 设置父类
enhancer.setSuperclass(target.getClass());
//3. 设置回调函数
enhancer.setCallback(this);
//4. 创立子类对象，即代理对象
return enhancer.create();}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {System.out.println("房子出租前，装修一下....");
Object returnVal = method.invoke(target, args);
System.out.println("房子出租后，与物业协调....");
return returnVal;
}
}客户类：
/**
* @author tcy
* @Date 02-08-2022
*/
public class Client {public static void main(String[] args) {
// 创立指标对象
Host HostTarget = new Host();
// 获取到代理对象，并且将指标对象传递给代理对象
Host Hostproxy = (Host)new HostProxy(HostTarget).getProxyInstance();
// 执行代理对象的办法，触发 intecept 办法，从而实现 对指标对象的调用
Hostproxy.rent();}
}当初不仅老王和中介都不须要实现接口了，而且完满的实现了他们之间的性能。
jdk 和 CGLIB 实现动静代理的区别咱们比照一下：
2、JDK 动静代理与 CGLIB 比照
JDK 动静代理：基于 Java 反射机制实现，必须要实现了接口的业务类才生成代理对象。
CGLIB 动静代理：基于 ASM 机制实现，通过生成业务类的子类作为代理类。
JDK Proxy 的劣势：
最小化依赖关系、代码实现简略、简化开发和保护、JDK 原生反对，比 CGLIB 更加牢靠，随 JDK 版本平滑降级。而字节码类库通常须要进行更新以保障在新版 Java 上可能应用。
基于 CGLIB 的劣势：
无需实现接口，达到代理类无侵入，只操作关怀的类，而不用为其余相干类减少工作量。高性能。
动态代理和 JDK 代理模式都要求指标对象是实现一个接口, 然而有时候指标对象只是一个独自的对象, 并没有实现任何的接口, 这个时候可应用指标对象子类来实现代理 - 这就是 Cglib。
为了让代理模式了解的更加粗浅，咱们来看代理模式在两个经典框架 SpringAop 和 Mybtis 中的利用。
五、典型利用
1、在 SpringAop 的使用
动静代理一个显著的作用就是，在不扭转指标对象的前提下，能加强指标对象的性能，这其实就是 AOP 的外围。
AOP（Aspect Oriented Programming）是基于切面编程的，可无侵入的在本来性能的切面层增加自定义代码，个别用于日志收集、权限认证等场景。
SpringAop 同时实现了 Jdk 的动静代理和 Cglib 的动静代理。
使用动静代理间接作用到须要加强的办法下面，而不扭转咱们本来的业务代码。
2、在 MyBatis 的使用
在 Mybitis 实现的是 Jdk 的动静代理。
源码中有一个 MapperProxyFactory 类，其中有一个办法。
// 构建 handler 的过程。protected T newInstance(MapperProxy<T> mapperProxy) {
// 规范的类加载器，接口，以及 invocationHandler 接口实现。return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface}, mapperProxy);
}Proxy.newProxyInstance() 正是咱们在 Jdk 动静代理中的应用。
联合典型利用，认真领会动静代理设计模式，参考软件设计七大准则 在理论利用中更加灵便的应用，不生吞活剥。
为了丝毫退出老王的故事，举荐你看后面的三篇创立型设计模式，以做到丝滑入戏。
一、设计模式之工厂办法和形象工厂
二、设计模式之单例和原型
三、设计模式之建造者模式