代理模式
1. 理解代理模式
定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用.
组成：
| 角色 | 功能 |
|---|---|
| 抽象角色 | 通过接口或者抽象类声明真实角色实现的业务方法 |
| 代理角色 | 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作 |
| 真实角色 | 实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用 |
作用：
-
职责清晰
真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理对功能进行优化
-
保护目标对象
代理对象可以在客户端和目标对象之间起到中介的作用，这样可以对目标对象进行保护
-
高扩展性
分类：动态代理与静态代理
2.静态代理
2.1 基本步骤
- 创建抽象角色：创建一个接口或者抽象类
- 创建真实角色：创建一个类实现接口，或者继承抽象类，对方法进行重写
- 创建代理对象：创建一个类实现接口，或者继承抽象类，对真实角色实现的方法进行扩展
2.2静态代理示例
2.2.1 抽象角色定义
//抽象角色：书
public interface Book {
//定义方法：计算书本的成交价
//参数account：书的数量
public double sell(int account);
}
2.2.2 真实角色定义
//真实角色：出版商 负责确定图书的初始价格
//消费者无法直接从出版社手中购买图书
public class Publisher implements Book{
@Override
public double sell(int account) {
//默认图书单价为20元
double price = 20*account;
System.out.println("图书已经出版，价格总计为:"+price);
return price;
}
}
2.2.3 代理角色定义
//代理角色：DangDang是一个商家，代理图书的销售
public class DangDang implements Book{
//声明图书的出版商具体是谁
private Publisher publisher=new Publisher();
//实现销售功能
@Override
public double sell(int account) {
//向出版社发送订单，告诉出版社用户下单了图书，出版社发货
double sell = publisher.sell(account);//出版社的价格
//恰逢双十一，推出图书九五折优惠
sell*=0.95;//增强功能，代理角色在完成目标类方法调用以后，对功能进行了加强
System.out.println("恰逢双十一，推出图书九五折优惠");
return sell;
}
}
2.2.4 测试
public class BookTest {
public static void main(String[] args) {
//创建代理类DangDang对象
DangDang dangDang = new DangDang();
//通过代理类，实现购买图书，实现打折功能
double sell = dangDang.sell(3);
System.out.println("最终成交价为："+sell);
}
}
2.3 静态代理优缺点
优点：
- 代理使用户不需要知道中间流程是什么，只需要通过代理对象即可完成任务
- 方便功能的扩展，对业务逻辑进行拓展
缺点:
- 代理类中出现大量冗余代码，不利于后期维护和拓展
- 如果抽象角色增加一个方法，那么所有实现该接口的类都需要对新方法进行实现，所有的代理类也需要对新方法进行实现，增加了代码维护的复杂性
3. 动态代理
3.1 动态代理的实现方法
基于JDK的动态代理与基于cdlib的动态代理
3.1.1 基于JDK的动态代理
所谓基于JDK的动态代理就是使用Java反射包（java.lang.reflect）中的类和接口实现动态代理的功能，其中包括三个类：InvocationHandler,Method和Proxy
3.1.2 基于cdlib的动态代理
所谓cdlib动态代理是通过继承抽象角色，在子类中重写父类中的方法，实现功能的修改或增强
3.2 通过反射实现动态代理
接口与实现类的执行逻辑为
接口：
public interface Hello {
//向str说Hello
public void sayHello(String str);
}
实现类：
public class HelloImpl implements Hello{
@Override
public void sayHello(String str) {
System.out.println("Say Hello to "+str);
}
}
测试类：
public class HelloTest {
public static void main(String[] args) {
Hello hello = new HelloImpl();
hello.sayHello("World");
}
}
通过反射机制执行该方法的流程为：
1. 获取目标类的class对象，通过该对象的getMethod方法，获取调用方法对应的method对象
1. 调用method类中的invoke方法，返回一个object，invoke方法需要抛出异常
getMethod(方法名,返回类型.class);
invoke(对象,方法执行的参数);
public class HelloDynamicTest {
public static void main(String[] args) throws Exception {
Hello hello = new HelloImpl();
Method method = hello.getClass().getMethod("sayHello", String.class);
method.invoke(hello, "Mark");
}
}
3.3 原理分析
反射包( java.lang.reflect)包含了三个类： InvocationHandler , Method, Proxy
3.3.1 InvocationHandler 接口
InvocationHandler（调用处理器）接口中仅包含一个invoke方法，表示代理对象要执行的代理类方法。
使用时，创建实现InvocationHandler接口的实现类，将静态代理中的拓展功能添加到重写的invoke方法中。
public Object invoke(Object proxy, Method method, Object[] args)
// 参数：Object proxy：JDK中创建的代理对象，无须赋值
// Method method:目标类中的方法
// Object[] args：目标类方法的参数
3.3.2 Method类
用来表示目标类中需要调用方法的对象，通过调用该类中的invoke方法实现通过反射调用目标方法
public native Object invoke(Object receiver, Object... args)
//参数：Object receiver 该方法所属的对象
// Object... args 该方法对应的参数
//例如：
method.invoke(hello, "Mark");
//等同于
hello.sayHello("Mark");
3.3.3 Proxy类
Proxy类表示需要代理的对象。通过类中的静态方法newProxyInstance()创建代理对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
/*
参数：
ClassLoader loader 类加载器：主要作用是将目标对象加载进内存之中。通过反射获取对象的ClassLoader
Class<?>[] interfaces 接口：表示目标对象实现的接口。可以通过反射技术获取对象的接口
InvocationHandler h: 实现InvocationHandler接口的类，完成对被代理对象功能的实现和扩展
返回值：Object 返回被代理类的对象
*/
3.4 基本步骤
- 创建抽象角色，通过接口或者抽象类的方法定义抽象类
- 创建真实角色，通过实现接口或者继承抽象类，重写方法
- 创建代理角色，该对象实现InvocationHandler接口，重写invoke方法，对目标方法进行调用，并在此基础上进行增强
- 使用Proxy类的静态方法newProxyInstance()创建代理对象，并将返回值转为接口类型
3.5 动态代理示例
3.5.1 创建抽象角色（接口）
//抽象角色：书
public interface Book {
//定义方法：计算书本的成交价
//参数account：书的数量
public double sell(int account);
}
3.5.2 创建真实角色（实现类）
//真实角色：出版商
//负责确定图书的批发价格
//消费者无法直接从出版社手中购买图书
public class Publisher implements Book{
@Override
public double sell(int account) {
//默认图书单价为20元
double price = 20*account;
System.out.println("图书已经出版，价格总计为:"+price);
return price;
}
}
3.5.3 创建代理角色（实现Invocation）
//实现InvocationHandler接口，完成代理类要做的功能
public class MyInvocation implements InvocationHandler {
private Object target;
public MyInvocation(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object res = null;
//向出版社发送订单，告诉出版社用户下单了图书，出版社发货
res=method.invoke(target,args);//出版社的价格
if (res!=null){
//恰逢双十一，推出图书九五折优惠
Double price = (Double) res*0.95;//增强功能，代理角色在完成目标类方法调用以后，对功能进行了加
res = price;
}
System.out.println("恰逢双十一，推出图书九五折优惠");
return res;
}
}
3.5.4 测试类
/*
1. 创建目标对象 接口类 接口对象 =new 接口实现类();
2. 创建InvocationHandler对象InvocationHandler myInvocation = new MyInvocation(接口类对象);
3. 创建代理对象接口类
proxy = (接口类) Proxy.newProxyInstance(接口对象.getClass().getClassLoader(),
接口对象.getClass().getInterfaces(),
myInvocation);
4. 通过代理执行方法proxy.方法();
*/
public class BookDynamic {
public static void main(String[] args) {
//1.创建目标对象
//Publisher publisher = new Publisher();
Book book = new Publisher();
//2.创建InvocationHandler对象
InvocationHandler myInvocation = new MyInvocation(book);
//3.创建代理对象
Proxy proxy = (Book) Proxy.newProxyInstance(book.getClass().getClassLoader(),
book.getClass().getInterfaces(),
myInvocation);
System.out.println("books = " + books.getClass().getName());//books = com.sun.proxy.$Proxy0为jdk动态代理创建的对象类型
//4.通过代理对象执行方法
double price = books.sell(3);
System.out.println("通过动态代理调用对象，计算价格为"+price);
}
}
3.6 执行流程
- 通过proxy对象调用方法(eg:proxy.sell(3)😉，执行InvocationHandler接口实现类中的invoke方法，其中proxy为默认对象，method对应代理类调用的方法(eg：sell),args对应方法参数（eg：3）
- 通过反射，method.invoke执行真实角色（目标对象，eg：publisher）的方法（eg：sell方法）。其中receiver对应真实角色，args对应方法的参数（eg：3），
- 调用重写的sell方法，得到返回值后对其进行进一步的拓展。
423
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
