前言
最近写了和内省的文章，就想继续深入再写一篇介绍java的代理模式的文章，因为java的代理模式也会用到反射。
什么是代理模式
代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
其实代理模式是一种和编程语言无关的设计模式，但是二当家的只有java掌握的还行，所以还是限定在java范围吧。
代理模式中的角色
抽象主题角色
抽象主题角色是通过接口或抽象类声明真实主题角色需要实现的业务方法。是客户端仅需要关心的角色。
例子中，我们用笔记本卖家作为抽象主题角色。
package com.secondgod.proxy;
/**
* 笔记本卖家（抽象主题角色）
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public interface INotebookSeller {
/**
* 卖笔记本
*
* @param quantity
*/
void sell(int quantity);
}真实主题角色
真实主题角色就是对抽象主题角色声明的业务方法的真实实现者。
例子中，我们用笔记本工厂作为真实主题角色。
package com.secondgod.proxy;
import java.text.MessageFormat;
/**
* 笔记本工厂（真实主题）
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class NotebookFactory implements INotebookSeller {
/**
* 厂长名
*/
private final String name;
public NotebookFactory(String name) {
this.name = name;
System.out.println(MessageFormat.format("[{0}]的笔记本工厂开业了。", name));
}
@Override
public void sell(int quantity) {
System.out.println(MessageFormat.format("[{0}]卖掉[{1}]个笔记本。", name, quantity));
}
}客户端角色
客户端角色是需要使用抽象主题角色声明的功能的角色。
例子中，我们用买家作为客户端角色。
package com.secondgod.proxy;
import java.text.MessageFormat;
/**
* 打工人
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class Worker {
/**
* 打工人的名字
*/
private final String name;
public Worker(String name) {
this.name = name;
System.out.println(MessageFormat.format("打工人[{0}]，为了得到自己想要的东西拼命赚钱。", name));
}
public void buy(INotebookSeller seller, int quantity) {
System.out.println(MessageFormat.format("打工人[{0}]要买[{1}]个笔记本。", name, quantity));
seller.sell(quantity);
}
private static void newDays() {
System.out.println();
System.out.println("有一天：");
}
public static void main(String[] args) {
// 打工人的故事开始了
newDays();
INotebookSeller seller = new NotebookFactory("大当家的");
Worker worker = new Worker("小明");
worker.buy(seller, 5);
}
}为了减少一个类，我就直接把main方法写在客户端角色了。
一般情况下，这样就已经圆满了。但是好景不长，因为工厂都开在比较偏僻的地方，大家买笔记本太不方便了。于是需求出现了，机会也出现了，然而工厂和打工人都不愿意因此做出改变，那样代价太大了。
静态代理的出现
代理角色作为客户端角色和真实主题角色的中介。
例子中，我们用商店作为代理角色。
package com.secondgod.proxy;
import java.text.MessageFormat;
/**
* 商店（代理主题）
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class Store implements INotebookSeller {
/**
* 名称
*/
private final String name;
/**
* 供应商品的工厂
*/
private final NotebookFactory notebookFactory;
/**
* 合同约定按照固定量的倍数采购
*/
private final int purchaseQuantity;
/**
* 库存
*/
private int stockBalance;
public Store(String name, NotebookFactory notebookFactory, int purchaseQuantity) {
this.name = name;
this.notebookFactory = notebookFactory;
this.purchaseQuantity = purchaseQuantity;
System.out.println(MessageFormat.format("[{0}]的笔记本商店开业了，请笔记本工厂做了自己的供应商，他们约定每次按照[{1}]个的倍数采购。", name, purchaseQuantity));
}
@Override
public void sell(int quantity) {
if (quantity > stockBalance) {
int needPurchaseQuantity = ((quantity - stockBalance) + (purchaseQuantity - 1)) / purchaseQuantity * purchaseQuantity;
System.out.println(MessageFormat.format("商店笔记本库存不足，于是向供应商采购了[{0}]个。", needPurchaseQuantity));
notebookFactory.sell(needPurchaseQuantity);
stockBalance += needPurchaseQuantity;
}
stockBalance -= quantity;
System.out.println(MessageFormat.format("商店卖出了[{0}]个笔记本，库存余[{1}]个。", quantity, stockBalance));
}
}我们还需要对main方法做一点修改来引入代理角色。需要注意的是，我们的客户端角色，抽象主题角色和真实主题角色都不需要做修改。
package com.secondgod.proxy;
import java.text.MessageFormat;
/**
* 打工人
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class Worker {
/**
* 打工人的名字
*/
private final String name;
public Worker(String name) {
this.name = name;
System.out.println(MessageFormat.format("打工人[{0}]，为了得到自己想要的东西拼命赚钱。", name));
}
public void buy(INotebookSeller seller, int quantity) {
System.out.println(MessageFormat.format("打工人[{0}]要买[{1}]个笔记本。", name, quantity));
seller.sell(quantity);
}
private static void newDays() {
System.out.println();
System.out.println("有一天：");
}
public static void main(String[] args) {
// 打工人的故事开始了
newDays();
NotebookFactory notebookFactory = new NotebookFactory("大当家的");
INotebookSeller seller = new Store("二当家的", notebookFactory, 10);
Worker worker = new Worker("小明");
worker.buy(seller, 15);
}
}
商店作为代理，做了库存储备，这样打工人只需要在自己家楼下就能很快买到笔记本了。
但是当抽象主题，真实主题增加时，静态代理就显得不太合理了，因为它要跟着一起改变。
比如，很快又有了钢笔的卖家，和钢笔厂，商店想要代理，就需要做出改变，之后每次要代理卖新的东西，商店都要做出调整，商店不开心了。
动态代理的出现
商店做大做强后，发现其实各种卖家和工厂都有着一些共性，而客户端也有着相似的需求，所以商店决定成立一个平台，想办法统一流程。
引入新的抽象主题，钢笔卖家。
package com.secondgod.proxy;
/**
* 钢笔卖家（抽象主题角色）
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public interface IPenSeller {
/**
* 卖钢笔
*
* @param quantity
*/
void sell(int quantity);
}引入新的真实主题，钢笔工厂。
package com.secondgod.proxy;
import java.text.MessageFormat;
/**
* 钢笔工厂（真实主题）
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class PenFactory implements IPenSeller {
/**
* 厂长名
*/
private final String name;
public PenFactory(String name) {
this.name = name;
System.out.println(MessageFormat.format("[{0}]的钢笔工厂开业了。", name));
}
@Override
public void sell(int quantity) {
System.out.println(MessageFormat.format("[{0}]卖掉[{1}]个钢笔。", name, quantity));
}
}引入新的代理，电商平台，很快我们就可以看到动态代理相对于静态代理的优势。
package com.secondgod.proxy;
import java.lang.reflect.Proxy;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
/**
* 平台
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class Platform {
/**
*
*/
private final String name;
/**
* 平台下的卖家
*/
private final Map<Class<?>, Object> storeMap = new HashMap<>();
public Platform(String name) {
this.name = name;
System.out.println(MessageFormat.format("[{0}]的电商平台开业了。", name));
}
/**
* 供普通卖家注册为平台卖家
*
* @return
*/
public <T> void registerStore(String name, Class<T> clazz, T factory, int purchaseQuantity) {
T seller = (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class<?>[]{clazz}, new PlatformStore(name, this, factory, purchaseQuantity));
storeMap.put(clazz, seller);
}
/**
* 供用户查找
*
* @return
*/
public <T> T findStore(Class<T> clazz) {
return (T) storeMap.get(clazz);
}
}平台化以后，商店也要有所改变。
package com.secondgod.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.text.MessageFormat;
/**
* 平台店
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class PlatformStore implements InvocationHandler {
/**
* 商品名
*/
private final String name;
/**
* 平台
*/
private final Platform platform;
/**
* 背后是真实卖家
*/
private final Object factory;
/**
* 合同约定按照固定量的倍数采购
*/
private final int purchaseQuantity;
/**
* 库存
*/
private int stockBalance;
public PlatformStore(String name, Platform platform, Object factory, int purchaseQuantity) {
this.name = name;
this.platform = platform;
this.factory = factory;
this.purchaseQuantity = purchaseQuantity;
System.out.println(MessageFormat.format("平台的[{0}]商店开业了，请[{1}]工厂做了自己的供应商，他们约定每次按照[{2}]个的倍数采购。", name, name, purchaseQuantity));
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
int quantity = (int) args[0];
if (quantity > stockBalance) {
int needPurchaseQuantity = ((quantity - stockBalance) + (purchaseQuantity - 1)) / purchaseQuantity * purchaseQuantity;
System.out.println(MessageFormat.format("平台[{0}]库存不足，于是向供应商采购了[{1}]个。", name, needPurchaseQuantity));
args[0] = needPurchaseQuantity;
method.invoke(factory, args);
stockBalance += needPurchaseQuantity;
}
stockBalance -= quantity;
System.out.println(MessageFormat.format("平台卖出了[{0}]个[{1}]，库存余[{2}]个。", quantity, name, stockBalance));
return null;
}
}接下来就是我们的买方，他除了想要买笔记本，也想要买钢笔了。main方法将描绘一个新的故事。
package com.secondgod.proxy;
import java.text.MessageFormat;
/**
* 打工人
*
* @author 二当家的白帽子 https://le-yi.blog.csdn.net/
*/
public class Worker {
/**
* 打工人的名字
*/
private final String name;
public Worker(String name) {
this.name = name;
System.out.println(MessageFormat.format("打工人[{0}]，为了得到自己想要的东西拼命赚钱。", name));
}
public void buy(INotebookSeller seller, int quantity) {
System.out.println(MessageFormat.format("打工人[{0}]要买[{1}]个笔记本。", name, quantity));
seller.sell(quantity);
}
public void buy(IPenSeller seller, int quantity) {
System.out.println(MessageFormat.format("打工人[{0}]要买[{1}]个钢笔。", name, quantity));
seller.sell(quantity);
}
private static void newDays() {
System.out.println();
System.out.println("有一天：");
}
public static void main(String[] args) {
// 打工人的故事开始了
newDays();
Platform platform = new Platform("二当家的");
platform.registerStore("笔记本", INotebookSeller.class, new NotebookFactory("大当家的"), 100);
platform.registerStore("钢笔", IPenSeller.class, new PenFactory("大当家的"), 100);
INotebookSeller notebookSeller = platform.findStore(INotebookSeller.class);
IPenSeller penSeller = platform.findStore(IPenSeller.class);
Worker worker = new Worker("小明");
worker.buy(notebookSeller, 10);
worker.buy(penSeller, 10);
}
}
以后，再开别的工厂，买方想再买别的什么东西，平台都不需要修改了。这就是动态代理的魅力，也是平台化的魅力。
回顾动态代理的使用
静态代理是在编码阶段就确定的；而动态代理则是在程序运行时才动态创建。
在程序运行时去动态创建类，显然普通的方式是无法做到的，JDK为我们提供了API，就是在java.lang.reflect包下的Proxy类，我们的例子中使用了他的newProxyInstance静态方法，他的方法签名如下。
- loader是类加载器
- interfaces是动态代理需要实现的接口（我们的例子中就是商品卖家接口）
- h则是动态代理方法被调用时的处理器（我们的例子中就是平台店）
尾声
代理模式的使用非常广泛。像spring，hibernate，mybatis等框架都有使用代理模式来帮助提供非侵入性的，透明的功能。值得一提的是文中没有提cglib代理，一般介绍代理模式的文章都会单独介绍一下它，我觉得cglib也算是动态代理，所以就没有再多讲了，请勿怪罪。
非常感谢你阅读本文~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子：https://developer.aliyun.com/profile/sqd6avc7qgj7y 博客原创~
