介绍
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
意图
为其他对象提供一种代理以控制对这个对象的访问
在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
主要角色
- 委托类：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
- 代理类：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
- 抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
优点
1.职责清晰2.易扩展
缺点
1.由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2.实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
image.png
代码示例
抽象角色:OrderService接口,规范了委托类实现的业务方法
public interface OrderService {
/*
* 创建订单
*/
boolean createOrder();
/*
* 查找订单
*/
List listOrder();
/*
* 删除订单
*/
boolean removeOrder();
}
委托类:OrderServiceImpl类,订单业务实现类
package com.apesource.service.impl;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import com.apesource.service.OrderService;
/*
* 订单业务服务类
*/
public class OrderServiceImpl implements OrderService{
//
@Override
public boolean createOrder() {
System.out.println("A.创建订单业务步骤1");
System.out.println("B.创建订单业务步骤2");
System.out.println("C.创建订单业务步骤3");
System.out.println("D.创建订单业务步骤4");
System.out.println("E.创建订单业务步骤5");
return true;
}
@Override
public List listOrder() {
System.out.println("A.查找订单业务步骤1");
System.out.println("B.查找订单业务步骤2");
System.out.println("C.查找订单业务步骤3");
return Arrays.asList();
}
@Override
public boolean removeOrder() {
System.out.println("A.删除订单业务步骤1");
System.out.println("B.删除订单业务步骤2");
System.out.println("C.删除订单业务步骤3");
return true;
}
}
代理类:添加程序日志,调用委托类中的方法
package com.apesource.service.proxy;
import java.util.List;
import java.util.logging.Logger;
import com.apesource.service.OrderService;
import com.apesource.service.impl.OrderServiceImpl;
/*
* 代理类
*/
public class OrderSercviceImplProxy implements OrderService {
// 添加日志
private static Logger log = Logger.getLogger(OrderServiceImpl.class.getName());
// 关联目标类
private OrderService orderServiceImpl;
public OrderSercviceImplProxy() {
// 实例化目标列对象
orderServiceImpl = new OrderServiceImpl();
}
@Override
public boolean createOrder() {
// 添加日志
log.info("开始执行创建订单业务");
// 调用目标类的方法
boolean bool = orderServiceImpl.createOrder();
// 添加日志
log.info("结束执行创建订单业务");
return bool;
}
@Override
public List listOrder() {
// 添加日志
log.info("开始执行返回订单业务");
List list = orderServiceImpl.listOrder();
// 添加日志
log.info("结束执行返回订单业务");
return list;
}
@Override
public boolean removeOrder() {
// 添加日志
log.info("开始执行删除订单业务");
Boolean bool = orderServiceImpl.removeOrder();
// 添加日志
log.info("结束执行删除订单业务");
return bool;
}
}
JDK自带的动态代理
无论是动态代理还是静态代理都需要三个角色：目标对象，接口，代理类。动态代理主要使用了反射中的知识。
JDK中：
- java.lang.reflect.InvocationHandler（处理器接口）：可以通过invoke方法实现对真实角色的代理访问。
创建一个类并实现InvocationHandler接口，在invoke方法中实现代理类的操作以及调用目标对象的方法。因此要先关联目标对象并通过构造方法注入目标对象
//与目标对象关联
private Object target;
// 通过构造方法得到目标对象
public LogInvocationHander(Object target) {
this.target = target;
}
InvocationHandler接口中的invoke方法：
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
}
Object proxy：Proxy创建的代理对象
Method method: 将执行的方法方法对象
Object[] args:将执行方法的参数列表
- java.lang.reflect.Proxy类，通过newProxyInstance方法生成动态代理类和对象；它的类型是com.sun.proxy.$Proxy
Proxy.newProxyInstance(类加载器，目标对象实现的所有接口，实现InvocationHander接口类的对象)
通过反射方式获取类加载器，目标对象Class获取所有接口对象Class
Proxy.newProxyInstance(
orderServiceTarget.getClass().getClassLoader(), orderServiceTarget.getClass().getInterfaces(),
logInvocationHander1);
代码示例
实现InvocationHandler的 LogInvocationHander类，添加日志并调用目标类中的方法。
package com.apesource.service.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.logging.Logger;
/*
* *代理类的执行过程
* *需要得到目标对象
*/
public class LogInvocationHander implements InvocationHandler {
//与目标对象关联
private Object target;
private static Logger logger = Logger.getLogger(LogInvocationHander.class.getName());
// 通过构造方法得到目标对象
public LogInvocationHander(Object target) {
this.target = target;
}
/*
* *运行时得到代理对象,方法对象
*/
/*
* *参数1:代理的对象 *参数2:运行期要执行的方法的对象,代理和目标的方法名相同 *参数3:该方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//添加日志
logger.info("代理"+proxy.getClass().getName());
logger.info("方法开始");
Object object = method.invoke(target, args);
logger.info("方法结束");
return object;
}
}
主函数中创建LogInvocationHander类的对象，创建Proxy对象。
package com.apesource.test;
import java.lang.reflect.Proxy;
import com.apesource.service.OrderService;
import com.apesource.service.PaymentService;
import com.apesource.service.impl.OrderServiceImpl;
import com.apesource.service.impl.PaymentServiceImpl;
import com.apesource.service.proxy.LogInvocationHander;
public class Test01 {
public static void main(String[] args) {
// 创建目标对象
// 订单的目标对象
OrderService orderServiceTarget = new OrderServiceImpl();
// 支付的目标对象
PaymentService paymentServiceTarget = new PaymentServiceImpl();
// 将目标对象传入LogInvocationHander,LogInvocationHander是代理真正执行的逻辑
LogInvocationHander logInvocationHander1 = new LogInvocationHander(orderServiceTarget);
LogInvocationHander logInvocationHander2 = new LogInvocationHander(paymentServiceTarget);
// 创建代理
/*
* 参数1:类加载器 参数2:代理要实现的所有接口,也就是目标对象实现的接口 参数3:LogInvocationHander,真正执行的逻辑
*/
// 通过传入的类加载器,通过反射的方式，获取目标类接口数组,创建出代理对象,通过类型转换为OrderService
OrderService orderServiceProxy = (OrderService) Proxy.newProxyInstance(
orderServiceTarget.getClass().getClassLoader(), orderServiceTarget.getClass().getInterfaces(),
logInvocationHander1);
//调用的方法,其实调用了invoke方法，logInvocationHander1中的Method对象
orderServiceProxy.createOrder();
PaymentService paymentServiceproxy = (PaymentService) Proxy.newProxyInstance(
paymentServiceTarget.getClass().getClassLoader(), paymentServiceTarget.getClass().getInterfaces(),
logInvocationHander2);
paymentServiceproxy.aliPay();
}
}
