本专栏内容参考自：咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》，仅作个人学习记录使用，如有侵权，联系速删。
代理模式
代理模式( Proxy Pattern )是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
先看下代理模式通用类图
代理模式一般包含三种角色︰ 抽象主题角色( Subject ):抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类; 真实主题角色(RealSubject ):该类也被称为被代理类，该类定义了代理所表示的真实对象，是负 责执行系统真正的逻辑业务对象﹔ 代理主题角色( Proxy ) :也被称为代理类，其内部持有RealSubject的引用，因此具备完全的对RealSubject的代理权。客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对 象前后增加一些处理代码。
在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使
调用者无感知。代理模式属于结构型模式，分为静态代理和动态代理。
代理模式的应用场景
生活中的租房中介、售票黄牛、婚介、经纪人、快递、事务代理、非侵入式日志监听等，都是代理 模式的实际体现。当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过也给代理对象 来间接访问。使用代理模式主要有两个目的:一是保护目标对象，二是增强目标对象。
代理模式的通用写法
下面是代理模式的通用代码展示，首先创建代理主题角色lSubject类:
代码语言：javascript复制public interface ISubject {
void request();
}创建真实主题角色RealSubject类∶
代码语言：javascript复制public class RealSubject implements ISubject {
public void request() {
System.out.println("real service is called.");
}
}创建代理主题角色Proxy类∶
代码语言：javascript复制public class Proxy implements ISubject {
private ISubject subject;
public Proxy(ISubject subject){
this.subject = subject;
}
public void request() {
before();
subject.request();
after();
}
public void before(){
System.out.println("called before request().");
}
public void after(){
System.out.println("called after request().");
}
}客户端调用代码∶
代码语言：javascript复制public class Client {
public static void main(String[] args) {
Proxy proxy = new Proxy(new RealSubject());
proxy.request();
}
}从静态代理到动态代理
举个例子，有些人到了适婚年龄，其父母总是迫不及待地希望早点抱孙子。而现在在各种压力之下，很多人都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女自己还着急。下面来看代码实现。 创建顶层接口IPerson的代码如下:
代码语言：javascript复制public interface IPerson {
void findLove();
}儿子张三要找对象，实现ZhangSan类:
代码语言：javascript复制public class ZhangSan implements IPerson {
public void findLove() {
System.out.println("儿子要求：肤白貌美大长腿");
}
}父亲张老三要帮儿子张三相亲，实现Father类:
代码语言：javascript复制public class ZhangLaosan implements IPerson {
private ZhangSan zhangsan;
public ZhangLaosan(ZhangSan zhangsan) {
this.zhangsan = zhangsan;
}
public void findLove() {
System.out.println("张老三开始物色");
zhangsan.findLove();
System.out.println("开始交往");
}
}来看测试代码∶
代码语言：javascript复制public class Test {
public static void main(String[] args) {
ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
zhangLaosan.findLove();
}
}结果如下：
上面的场景有个弊端，就是自己父亲只会给自己的子女去物色对象，别人家的孩子是不会管的。
但社会上这项业务发展成了一个产业，出现了媒婆、婚介所等，还有各种各样的定制套餐。如果还使用静态代理成本就太高了，需要一个更加通用的解决方案，满足任何单身人士找对象的需求。这就是由静态代理升级到了动态代理。采用动态代理基本上只要是人( IPerson )就可以提供相亲服务。 动态代理的底层实现一般不用我们自己亲自去实现，已经有很多现成的API。在Java生态中，目前最普遍使用的是JDK自带的代理和Cglib提供的类库。下面我们首先基于JDK的动态代理支持如来升级一下代码。
首先创建媒婆类 JdkMeipo ：
代码语言：javascript复制public class JdkMeipo implements InvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("双方同意，开始交往");
}
private void before() {
System.out.println("我是媒婆，已经收集到你的需求，开始物色");
}
}然后是我们的主人公赵六：
代码语言：javascript复制public class ZhaoLiu implements IPerson {
public void findLove() {
System.out.println("赵六要求：有车有房学历高");
}
}测试代码：
代码语言：javascript复制public class Test {
public static void main(String[] args) {
JdkMeipo jdkMeipo = new JdkMeipo();
IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());
zhangsan.findLove();
IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
zhaoliu.findLove();
}
}运行结果：
静态模式在业务中的应用：
这里“小伙伴们”可能会觉得还是不知道如何将代理模式应用到业务场景中，我们来看一个实际的 业务场景。在分布式业务场景中，通常会对数据库进行分库分表，分库分表之后使用Java操作时就可 能需要配置多个数据源，我们通过设置数据源路由来动态切换数据源。先创建Order订单类∶
代码语言：javascript复制public class Order {
private Object orderInfo;
//订单创建时间进行按年分库
private Long createTime;
private String id;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Long getCreateTime() {
return createTime;
}
public void setCreateTime(Long createTime) {
this.createTime = createTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}创建OrderDao持久层操作类∶
代码语言：javascript复制public class OrderDao {
public int insert(Order order){
System.out.println("OrderDao创建Order成功!");
return 1;
}
}创建lOrderService接口∶
代码语言：javascript复制public interface IOrderService {
int createOrder(Order order);
}public class OrderService implements IOrderService {
private OrderDao orderDao;
public OrderService(){
//如果使用Spring应该是自动注入的
//我们为了使用方便，在构造方法中将orderDao直接初始化了
orderDao = new OrderDao();
}
public int createOrder(Order order) {
System.out.println("OrderService调用orderDao创建订单");
return orderDao.insert(order);
}
}接下来使用静态代理，主要完成的功能是∶根据订单创建时间自动按年进行分库。根据开闭原则，我们修改原来写好的代码逻辑，通过代理对象来完成。 先创建数据源路由对象，使用ThreadLocal的单例实现 DynamicDataSourceEntry类∶
代码语言：javascript复制public class DynamicDataSourceEntity {
public final static String DEFAULE_SOURCE = null;
private final static ThreadLocal<String> local = new ThreadLocal<String>();
private DynamicDataSourceEntity(){}
public static String get(){return local.get();}
public static void restore(){
local.set(DEFAULE_SOURCE);
}
//DB_2018
//DB_2019
public static void set(String source){local.set(source);}
public static void set(int year){local.set("DB_" year);}
}创建切换数据源的代理类OrderServiceSaticProxy :
代码语言：javascript复制public class OrderServiceStaticProxy implements IOrderService {
private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private IOrderService orderService;
public OrderServiceStaticProxy(IOrderService orderService) {
this.orderService = orderService;
}
public int createOrder(Order order) {
Long time = order.getCreateTime();
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("静态代理类自动分配到【DB_" dbRouter "】数据源处理数据" );
DynamicDataSourceEntity.set(dbRouter);
this.orderService.createOrder(order);
DynamicDataSourceEntity.restore();
return 0;
}
}创建测试代码：
代码语言：javascript复制public class DbRouteProxyTest {
public static void main(String[] args) {
try {
Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2020/03/01");
order.setCreateTime(date.getTime());
IOrderService orderService = (IOrderService)new OrderServiceStaticProxy(new OrderService());
orderService.createOrder(order);
}catch (Exception e){
e.printStackTrace();
}
}
}运行结果如下：
动态代理和静态代理的基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。
动态代理在业务场景中的应用
上面的案例理解了，我们再来看数据源动态路由业务，帮助“小伙伴们”加深对动态代理的印象。 创建动态代理的类OrderServiceDynamicProxy :
代码语言：javascript复制public class OrderServiceDynamicProxy implements GPInvocationHandler {
private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
Object proxyObj;
public Object getInstance(Object proxyObj) {
this.proxyObj = proxyObj;
Class<?> clazz = proxyObj.getClass();
return GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before(args[0]);
Object object = method.invoke(proxyObj,args);
after();
return object;
}
private void after() {
System.out.println("Proxy after method");
//还原成默认的数据源
DynamicDataSourceEntity.restore();
}
//target 应该是订单对象Order
private void before(Object target) {
try {
//进行数据源的切换
System.out.println("Proxy before method");
//约定优于配置
Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("静态代理类自动分配到【DB_" dbRouter "】数据源处理数据");
DynamicDataSourceEntity.set(dbRouter);
}catch (Exception e){
e.printStackTrace();
}
}
}测试代码如下：
代码语言：javascript复制public class DbRouteProxyTest {
public static void main(String[] args) {
try {
Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2020/03/01");
order.setCreateTime(date.getTime());
//与静态代理只有这里不同
IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderService());
orderService.createOrder(order);
}catch (Exception e){
e.printStackTrace();
}
}
}
依然能够达到相同运行效果。但是，使用动态代理实现之后，我们不仅能实现Order的数据源动态 路由，还可以实现其他任何类的数据源路由。当然，有个比较重要的约定，必须实现getCreateTime(方法，因为路由规则是根据时间来运算的。我们可以通过接口规范来达到约束的目的，在此就不再举例。
JDK动态代理实现原理
不仅知其然，还得知其所以然。既然JDK动态代理功能如此强大，那么它是如何实现的呢? 我们都知道JDK动态代理采用字节重组，重新生成对象来替代原始对象，以达到动态代理的目的。 JDK动态代理生成对象的步骤如下∶
(1)获取被代理对象的引用，并且获取它的所有接口，反射获取。 (2)JDK动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口。 (3)动态生成Java代码，新加的业务逻辑方法由一定的逻辑代码调用(在代码中体现)。 (4)编译新生成的Java代码.class文件。 (5)重新加载到JVM中运行。
以上过程就叫字节码重组。JDK中有一个规范，在ClassPath下只要是$开头的.class文件，一般都是自动生成的。
CGLib代理
看完了JDK的代理，让我们再瞅瞅CGLib的代理 还是以刚才的业务举例，创建一个媒婆：
代码语言：javascript复制public class CGlibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
//相当于Proxy，代理的工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("OK的话，准备办事");
}
}创建单身汉儿子：
代码语言：javascript复制public class Customer {
public void findLove(){
System.out.println("儿子要求：肤白貌美大长腿");
}
}有个小细节，CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代 理的。来看测试代码∶
代码语言：javascript复制public class CglibTest {
public static void main(String[] args) {
try {
//System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes");
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
// System.out.println(obj);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
一般的来说，我们会认为这种方式比JDK代理的执行效率要高。 CGLib代理执行代理方法的效率之所以比JDK的高，是因为CGlib采用了FastClass机制，它的原理简单来说就是∶为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index ( int 类型);这个index当作一个入参，FastClass就可以直接定位要调用的方法并直接进行调用，省去了反射调用，所以调用效率比JDK代理通过反射调用高。 **但是！！！**在JDK8以后，反射得到了优化，效率大大提升，现在两种方式哪一种更快还真不好说。
CGLib和JDK动态代理对比
(1)JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象。 (2)DK动态代理和CGLib代理都在运行期生成字节码JDK动态代理直接写Class字节码，CGLib代理使用ASM框架写Class字节码，CGlib代理实现更复杂，生成代理类比JDK动态代理效率低。 (3)JDK动态代理调用代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制直接调用方法的，CGLib 代理的执行效率更高。
在Spring 中的代理模式选择原则
(1)当Bean有实现接口时，Spring就会用JDK动态代理。 (2)当Bean没有实现接口时，Spring 会选择CGLib代理。 (3)Spring可以通过配置强制使用CGLib代理，只需在Spring的配置文件中加入如下代码︰
代码语言：javascript复制<aop:aspectj_autoproxy proxy_target-class="true"/>静态代理和动态代理的本质区别
(1)静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则。 (2)动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。 (3)若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码。
代理模式的优缺点
代理模式具有以下优点︰ (1)代理模式能将代理对象与真实被调用目标对象分离。 (2)在一定程度上降低了系统的耦合性，扩展性好。 (3)可以起到保护目标对象的作用。 (4)可以增强目标对象的功能。 当然，代理模式也有缺点︰ (1)代理模式会造成系统设计中类的数量增加。 (2)在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢。 (3)增加了系统的复杂度。
