代理模式

简介

代理模式是一种常用的设计模式，在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");

个人看点：

1. 实现动态代理的关键技术是反射；
2. 代理对象是对目标对象的增强，以便对消息进行预处理和后处理；
3. InvocationHandler中的invoke()方法是代理类完整逻辑的集中体现，包括要切入的增强逻辑和进行反射执行的真实业务逻辑；
4. 使用JDK动态代理机制为某一真实业务对象生成代理，只需要指定目标接口、目标接口的类加载器以及具体的InvocationHandler即可。
5. JDK动态代理的典型应用包括但不仅限于AOP、RPC、Struts2、Spring等重要经典框架。

本文到此结束，喜欢的朋友点点赞和关注 ，感谢！！