1、代理
代理就好比我们现实生活中的中介,我们平时买房租房都是找中介,并不是直接找的房东或业主,因为中介手中的资源比较多。简而言之,代理体现的是一种中间商赚差价的味道。
2、代理模式
代理模式是面向对象编程中比较常见的设计模式。
- 用户只关心接口功能,而不在乎谁提供了功能
- 接口真正实现者是上图的 RealSubject,但是它不与客户直接接触,而是通过代理。
- 代理就是上图中的 Proxy,由于它实现了 Subject 接口,所以它能够直接与用户接触。
- 客户调用 Proxy 的时候,Proxy 内部调用了 RealSubject。所以,Proxy 是中介者。
3、静态代理
由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。
现在用代码模拟现实生活中找中介出租房屋的实例。
- 首先得创建一个包含出租房子方法的接口Rent,代表有出租房子的能力。
package com.wust.test;
public interface Rent {
void rent();
}
- 接着,房东是拥有出租权力的角色,是真正出租房子的角色,需要实现Rent接口。
package com.wust.test;
//包租婆
public class LandLaydy implements Rent{
public void rent() {
System.out.println("包租婆出租房子!!!");
}
}
- 接着需要创建一个中介,代理出租婆出租房子,中介不仅能出租房子,还能干其它的一些事情,比如收中介费,签合同,带人看房子等。
package com.wust.test;
public class Intermediary implements Rent {
private Rent rent;
public Intermediary(Rent rent){
this.rent = rent;
}
public void rent() {
seeHouse();
signContract();
rent.rent();
getFare();
}
public void seeHouse(){
System.out.println("带客户看房子!!!");
}
public void signContract(){
System.out.println("签租赁合同!!!");
}
public void getFare(){
System.out.println("收中介费!!!");
}
}
- 最后创建一个客户类,模拟找中介租房子的过程。
package com.wust.demo;
public class Client {
public static void main(String[] args) {
LandLaydy laydy = new LandLaydy();
Intermediary intermediary = new Intermediary(laydy);
intermediary.rent();
}
}
- 最后结果。
带客户看房子!!!
签租赁合同!!!
包租婆出租房子!!!
收中介费!!!
- 优点:业务类只需要关注业务逻辑本身,保证了业务类的重用性。这是代理的共有优点。
- 缺点:
1)代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理,静态代理在程序规模稍大时就无法胜任了。
2)如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度
4、动态代理
既然是代理,那么它与静态代理的功能与目的是没有区别的,唯一有区别的就是动态与静态的差别。上一节代码中 Intermediary类是代理,我们需要手动编写代码让 Intermediary 实现Rent接口,而在动态代理中,我们可以让程序在运行的时候自动在内存中创建一个实现 Rent接口的代理,而不需要去定义 Intermediary 这个类。这就是它被称为动态的原因。
另外动态代理需要使用java反射包里的两个类,Proxy代理类以及InvocationHandler类,下面同样用上面的例子用动态代理进行代码模拟。
- 首先同样需要创建Rent接口以及实现Rent接口的LandLaydy类
- 接着创建ProxyHandler类实现InvacationHandler类
package com.wust.demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyHandler implements InvocationHandler {
private Object rent;
public ProxyHandler(Object rent){
this.rent = rent;
}
public Object getProxy(){
return Proxy.newProxyInstance(rent.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
signContract();
Object res = method.invoke(rent,args);
getFare();
return res;
}
public void seeHouse(){
System.out.println("带客户看房子!!!");
}
public void signContract(){
System.out.println("签租赁合同!!!");
}
public void getFare(){
System.out.println("收中介费!!!");
}
}
- 最后创建Client2类模拟租房过程
package com.wust.demo;
import java.lang.reflect.Proxy;
public class Client2 {
public static void main(String[] args) {
LandLaydy laydy = new LandLaydy();
ProxyHandler handler = new ProxyHandler(laydy);
//动态生成代理
Rent rent = (Rent) handler.getProxy();
rent.rent();
}
}
综合上面的两个例子,动态代理和静态代理最直接的区别是:静态代理的代理类需要程序编译运行前就写好,而动态代理事先不需要写具体的代理类,只需要创建实现InvocationHandler 的类,最后通过反射机制在程序运行期间动态地创建代理