代理模式
简介
代理模式是一种常用的设计模式，在AOP、RPC等诸多框架中均有它的身影
- 代理对象存在的价值主要用于拦截对真实业务对象的访问；
- 代理对象具有和目标对象(真实业务对象)实现共同的接口或继承于同一个类；
- 代理对象是对目标对象的增强，以便对消息进行预处理和后处理。
定义与结构
定义：为其他对象提供一种代理以控制对这个对象的访问。
代理模式主要包含三个角色，即抽象主题角色(Subject)、委托类角色(被代理角色，Proxied)以及代理类角色(Proxy)，如上图所示
- 抽象主题角色:可以是接口，也可以是抽象类；
- 委托类角色：真实主题角色，业务逻辑的具体执行者；
- 代理类角色：内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。
静态代理实现
静态代理三步走
1. 定义业务接口
public interface HelloService {
String hello(String name);
String hi(String msg);
}
2.实现业务接口
public class HelloServiceImpl implements HelloService{
@Override
public String hello(String name) {
return "Hello " + name;
}
@Override
public String hi(String msg) {
return "Hi, " + msg;
}
}
3.理类并实现业务接口
public class HelloServiceProxy implements HelloService {
private HelloService helloService;
public HelloServiceProxy(HelloService helloService) {
this.helloService = helloService;
}
@Override
public String hello(String name) {
System.out.println("预处理...");
String result = helloService.hello(name);
System.out.println(result);
System.out.println("后处理...");
return result;
}
@Override
public String hi(String msg) {
System.out.println("预处理...");
String result = helloService.hi(msg);
System.out.println(result);
System.out.println("后处理...");
return result;
}
}
最后便可通过客户端进行调用
public class Main {
public static void main(String[] args){
HelloService helloService = new HelloServiceImpl();
HelloServiceProxy helloServiceProxy = new HelloServiceProxy(helloService);
helloServiceProxy.hello("Panda");
helloServiceProxy.hi("Panda");
}
}
JDK 动态代理
动态代理可以很方便地对委托类的相关方法进行统一增强处理，如添加方法调用次数、添加日志功能等等。动态代理主要分为JDK动态代理和cglib动态代理两大类，本文主要对JDK动态代理进行探讨
JDK动态代理使用步骤
- 创建被代理的接口和类
// 抽象主题角色
public interface HelloService {
String hello(String name);
String hi(String msg);
}
// 具体(真实)主题角色
public class HelloServiceImpl implements HelloService{
@Override
public String hello(String name) {
return "Hello " + name;
}
@Override
public String hi(String msg) {
return "Hi, " + msg;
}
}
- 实现InvocationHandler接口
public class MyInvocationHandler implements InvocationHandler{
// 真实业务对象
private Object target;
public MyInvocationHandler(Object target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 增强逻辑
System.out.println("PROXY : " + proxy.getClass().getName());
// 反射调用，目标方法
Object result = method.invoke(target, args);
// 增强逻辑
System.out.println(method.getName() + " : " + result);
return result;
}
}
- 创建代理类并生成相应的代理对象
// 生成代理类的class对象
Class<?> clazz = Proxy.getProxyClass(helloService.getClass().getClassLoader(), helloService
.getClass().getInterfaces());
// 创建InvocationHandler
InvocationHandler myInvocationHandler = new MyInvocationHandler(helloService);
// 获取代理类的构造器对象
Constructor constructor = clazz.getConstructor(new Class[] {InvocationHandler.class});
// 反射创建代理对象
HelloService proxy = (HelloService)constructor.newInstance(myInvocationHandler);
- 使用代理
proxy.hello("rico");
proxy.hi("panda");
个人看点：
- 实现动态代理的关键技术是反射；
- 代理对象是对目标对象的增强，以便对消息进行预处理和后处理；
- InvocationHandler中的invoke()方法是代理类完整逻辑的集中体现，包括要切入的增强逻辑和进行反射执行的真实业务逻辑；
- 使用JDK动态代理机制为某一真实业务对象生成代理，只需要指定目标接口、目标接口的类加载器以及具体的InvocationHandler即可。
- JDK动态代理的典型应用包括但不仅限于AOP、RPC、Struts2、Spring等重要经典框架
