Version:1.0 StartHTML:000000209 EndHTML:000018054 StartFragment:000001737 EndFragment:000017968 StartSelection:000001737 EndSelection:000017964 SourceURL:https://www.cnblogs.com/homejim/p/9581294.html <title>静态代理和动态代理 - 阿进的写字台 - 博客园</title><link href="/bundles/blog-common.css?v=D7Le-lOZiZVAXQkZQuNwdTWqjabXaVBE_2YAWzY_YZs1" rel="stylesheet" type="text/css"><link id="MainCss" href="/skins/elf/bundle-elf.css?v=JHcmlukWR_bF1f6wNjCxPO-MfAKMYz5QllMp4s2snCY1" rel="stylesheet" type="text/css"><link id="mobile-style" href="/skins/elf/bundle-elf-mobile.css?v=v8T2RoJv5U8rbtl0h61BpmWAB6lL95ijRUoDdO22L_o1" rel="stylesheet" type="text/css" media="only screen and (max-width: 767px)"><link title="RSS" href="https://www.cnblogs.com/homejim/rss" rel="alternate" type="application/rss+xml"><link title="RSD" href="https://www.cnblogs.com/homejim/rsd.xml" rel="EditURI" type="application/rsd+xml"><link href="https://www.cnblogs.com/homejim/wlwmanifest.xml" rel="wlwmanifest" type="application/wlwmanifest+xml"> <script type="text/javascript">var currentBlogApp = 'homejim', cb_enable_mathjax=false;var isLogined=true;</script>
代理模式（静态代理）
代理模式是为其他对象提供一种代理以控制对这个对象的访问。
定义上也不算好理解， 上一个 《大话设计模式》 的图。
[图片上传失败...(image-fe545f-1535983799547)]
Subject 类（一般是抽象类或接口）， 定义了一个方法。
RealSubject 类实现了这个接口， 正常的情况我们只需要 new 出这个类的实例对象， 然后调用这个方法就可以了。
但是， 如果我们有需求说想要在这个方法的前面和后面进行一些操作， 那么，原始的方法已经无法满足了。
以租房子打比方：
房东李老板有一套房子， 他打算出租， 但是带人看了几次房子以后， 发现自己没有那么多时间。 于是他把房子委托给了中介公司小王， 小王帮他带人看房子，然后收取中介费。
在该例子中， 房子是李老板的， 他（RealSubject）将租房子这个权限委托给了小王（Proxy）。
抽象
首先， 抽象出房东这个接口， 而李老板是它的具体实现。
public interface Landlord {
boolean rental();
}
具体对象
房东是一个抽象意义上的概念， 而李老板， 是一个具有意义上的房东， 我们称之为是房东的一个实现。
public class LandlordImpl implements Landlord {
public boolean rental() {
System.out.println("李老板的房子出租啦");
return true;
}
}
代理对象
代理代表真实对象的功能以及在此基础上添加访问控制。
那就是中介小王， 他获得了李老板的授权， 可以带人去看房子， 但李老板明确了自己的条件， 房租至少5000， 如果是美女可以考虑降一点（小王就代表李老板进行一些过滤（访问控制））。
如果租客满意了， 打算租房子就跟小王说。 小王当然想租客租给租客， 有佣金嘛。但是， 具体的房子租不租还是要看房东。
我们就可以定义中介小王是房东的代理对象。他代表租房子以及访问控制。
public class LandlordProxy implements Landlord{
private final Landlord landlord;
public LandlordProxy(Landlord landlord) {
this.landlord = landlord;
}
public boolean rental() {
beforeRental();
if (landlord.rental()) {
afterRental();
}
return false;
}
private void afterRental() {
System.out.println("收取佣金");
}
private void beforeRental() {
System.out.println("带人看房子");
}
}
如果有一天， 李老板觉得一天最多接受 5 次看房。
那显然， 这是需要在小王那进行控制的。那么我们的类就可以这么改
public class LandlordProxy implements Landlord{
private final Landlord landlord;
private static final int NUM_ALLOWED = 5;
private int numPersons = 1;
public LandlordProxy(Landlord landlord) {
this.landlord = landlord;
}
public boolean rental() {
if (numPersons < NUM_ALLOWED) {
System.out.println("今天李老板不接客了");
} else {
beforeRental();
numPersons++;
if (landlord.rental()) {
afterRental();
}
}
return false;
}
private void afterRental() {
System.out.println("收取佣金");
}
private void beforeRental() {
System.out.println("带人看房子");
}
}
代理对象的特征是
- 和被代理对象实现了同一个接口；
- 内部含有一个被代理对象的示例；
优点
- 真实对象可以专注于自己的业务逻辑控制；
- 非业务逻辑相关的部分， 可以通过代理类来处理；
- 隐藏了真实的对象， 对外只暴露代理对象。
- 扩展性：由于实现了相同的接口， 因此被代理对象的逻辑不管如何变化， 代理对象都不需要更改。
使用场合
- 控制对真实对象的访问；
- 实现日志记录；
- 统计对象的访问数量；
- 等等。
一些思考
在代理对象内部， 真实对象是什么时候被初始化的， 以及初始化的对象是由谁产生的？
在我看过的代码和书籍中， 有如下几种， 对此我也是很困惑， 以下是我的一些见解
不推荐
- 将真实对象在代理对象构造函数内部初始化出来。
public LandlordProxy() {
landlord = new LandlordImpl();
}
- 构造函数不做改变， 在使用方法时
public boolean rental() {
if(landlord==null){
landlord = new LandlordImpl();
}
if (numPersons < NUM_ALLOWED) {
System.out.println("今天李老板不接客了");
} else {
beforeRental();
numPersons++;
if (landlord.rental()) {
afterRental();
}
}
return false;
}
以上两种的思想都是在代理对象内部对真实对象进行初始化， 我个人不是很赞同这种做法。
如果我们代理对象代理的不仅仅是李老板， 又代理了王老板， 那么怎么办？要写两个基本一模一样的代理类？
推荐做法
就是我们使用的， 在构造函数中传入
public LandlordProxy(Landlord landlord) {
this.landlord = landlord;
}
将真实对象的初始化交给调用者来进行。
这样， 不管是什么老板， 他们可以自己管理自己的租房方法， 但是相同的工作由代理来做， 而只需要一个代理类。实现了代码的复用。
动态代理
如果是一两个方法需要进行代理， 我们使用静态代理那挺好。
但如果我们的接口中有 20 个方法， 每个方法都需要在前后加上前后的逻辑， 比如说记录一下日志。那么， 我们就一直需要做一些重复性的工作， 相同的代码需要写很多遍， 不单单是写的时候痛苦， 后面维护起来也很难受。
基于此， 动态代理诞生了。
在程序运行时运用反射机制动态创建代理类
在 Java 中， 实现动态代理很简单
定义一个实现InvocationHandler的类
如下所示
public class DynamicProxy implements InvocationHandler {
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(System.currentTimeMillis() + " 进入了方法");
// 中间是这个方法
Object result = method.invoke(target, args);
System.out.println(System.currentTimeMillis() + " 方法执行完毕");
return result;
}
}
target 是我们需要代理的真实对象， 该参数一样建议在构造函数中传入。
实现 invoke 方法，方法内部在前后实现我们需要的逻辑， 中间就是
Object result = method.invoke(target, args);
最后返回 result 即可。
调用定义的类
public static void main(String[] args) {
Landlord landlord = new LandloadImpl();
DynamicProxy dynamicProxy = new DynamicProxy(landlord);
// 这一步是关键
Landlord landlordProxy = (Landlord) Proxy.newProxyInstance(
landlord.getClass().getClassLoader(),
landlord.getClass().getInterfaces(),
dynamicProxy
);
landlordProxy.rental();
}
其实我们就是要使用 JDK 给我们提供的 newProxyInstance 函数， 该函数返回对应代理的对象的接口， 我们调用相应的方法即可。
优化
newProxyInstance 方法需要传入的参数可以进一步进行优化。
我们在 DynamicProxy方法中， 可以加入该函数。
@SuppressWarnings("unchecked")
public <T> T getProxy() {
return (T)Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this
);
}
这样在我们获得代理对象时候就简单很多，main 函数可以改写成这样
public static void main(String[] args) {
Landlord landlord = new LandloadImpl();
DynamicProxy dynamicProxy = new DynamicProxy(landlord);
Landlord landlordProxy = dynamicProxy.getProxy();
landlordProxy.rental();
}
动态代理为我们带来了方便， 但是呢， JDK 所提供的动态代理， 我们通过 newProxyInstance 函数可以知道， 被代理的对象必须要实现某个接口。
如果我们要代理的对象没有接口怎么办？
后续文章打算讲一下 CGLIB 和 Sping Aop 是怎么为我们打开一个新的世界的。
代理之故事的结局
最后中介小王和李老板的故事结局是怎么样的呢？
程序员小H租了房子， 李老板和小王按规定各付中介费1750， 最后小王、李老板和小H商量了一下， 不走公司的流程， 各付1000元就好了。
