【Java】代理模式

代理模式

代理模式是指给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问

代理模式是一种结构型设计模式

背景

如果不采用代理，对一个类的多个方法进行监控时，重复的代码总是重复出现，不但破坏了原方法，如果要实现多个监控，将会对代码造成大量冗余。同时，还导致业务代码，与非业务的监控代码掺杂在一起，不利于扩展和维护。代理类在无限制膨胀，就需要无限的修改业务代码。

而采用代理后，原方法不需要做任何改动，操作的是原方法的代理对象，而原方法不用做任何修改，就实现了被监控。

结构

代理模式的结构比较简单，其核心是代理类，为了让客户端能够一致性地对待真实对象（RealSubject）和代理对象（Proxy），引入了抽象层（Subject）

在这里插入图片描述

代理模式角色：

Subject（抽象主题角色）：定义代理类和真实主题的 公共对外方法，也是代理类代理真实主题的方法
RealSubject（真实主题角色）：真正实现业务逻辑的类
Proxy（代理主题角色）：用来代理和封装真实主题

分类

按使用场景

代理模式按照职责（使用场景）来分类，至少可以分为以下几类：

远程代理
虚拟代理
Copy-on-Write 代理
保护（Protect or Access）代理
Cache代理
防火墙（Firewall）代理
同步化（Synchronization）代理
智能引用（Smart Reference）代理

按字节码的创建时机

如果根据字节码的创建时机来分类，可以分为静态代理和动态代理

静态代理

所谓静态是指在程序运行前就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就已经确定

优点：

实现简单
没有侵入原代码
可以很好的保护实际对象的业务逻辑对外暴露，从而提高安全性

代理对象和实际对象都继承了同一个接口，在代理对象中指向的是实际对象的实例，即对外暴露的是代理对象而真正调用的是 Real Object

缺点：

当需要代理多个类的时候，由于代理对象要实现与目标对象一致的接口，有两种方式：
- 只维护一个代理类，由这个代理类实现多个接口，但是这样就导致代理类过于庞大
- 新建多个代理类，每个目标对象对应一个代理类，但是这样会产生过多的代理类
当接口需要增加、删除、修改方法的时候，目标对象与代理类都要同时修改，不易维护

实例：

通过静态代理对 UserServiceImpl 进行功能增强，在调用select和update之前记录一些日志。

1、编写一个接口 UserService ，以及该接口的一个实现类 UserServiceImpl

public interface UserService {public void select();   public void update();
}public class UserServiceImpl implements UserService {  public void select() {  System.out.println("查询 selectById");}public void update() {System.out.println("更新 update");}
}

2、写一个代理类 UserServiceProxy，代理类需要实现 UserService

public class UserServiceProxy implements UserService {private UserService target; // 被代理的对象public UserServiceProxy(UserService target) {this.target = target;}public void select() {before();target.select();    // 这里才实际调用真实主题角色的方法after();}public void update() {before();target.update();    // 这里才实际调用真实主题角色的方法after();}private void before() {     // 在执行方法之前执行System.out.println(String.format("log start time [%s] ", new Date()));}private void after() {      // 在执行方法之后执行System.out.println(String.format("log end time [%s] ", new Date()));}
}

3、测试

public class Client {public static void main(String[] args) {UserService userServiceImpl = new UserServiceImpl();UserService proxy = new UserServiceProxy(userServiceImpl);proxy.select();proxy.update();}
}

动态代理

动态代理的源码是在程序运行期间由JVM根据反射等机制动态的生成，在运行前并不存在代理类的字节码文件

让代理类动态的生成（动态代理），可以避免静态代理复杂环境下复杂度高及不易维护的缺点

动态代理的优势就是实现无侵入式的代码扩展，实现AOP编程，这是静态代理无法实现的

实现动态代理的两种常见方式：

JDK动态代理：通过实现接口的方式
CGLIB动态代理：通过继承类的方式

Java 动态代理使用 Java 原生的反射 API 进行操作（运行期），在生成类上比较高效；而CGLIB 相比于 JDK 动态代理更加强大，CGLIB使用ASM框架直接对字节码进行操作（编译期），在类的执行过程中比较高效。

CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，JDK方式要更合适

JDK动态代理

Java标准库提供的一种动态代理（Dynamic Proxy）的机制，允许在运行期动态创建某个interface的实例。

jdk动态代理之所以只能代理接口是因为代理类本身已经继承了Proxy，而java是不允许多重继承的，但是允许实现多个接口。

由于 JDK 动态代理限制了只能基于接口设计，而对于没有接口的情况，JDK动态代理方式无法解决；

实现方式：

只需要实现 InvocationHandler 接口，重写 invoke 方法便可以完成代理的实现，jdk的代理是利用反射生成代理类 Proxyxx.class 代理类字节码，并生成对象。

优点：

解决了静态代理中冗余的代理实现类问题。

缺点：

JDK 动态代理是基于接口设计实现的，如果没有接口，会抛异常。

实例：

通过静态代理对 UserServiceImpl 进行功能增强，在调用select和update之前记录一些日志。

1、编写一个接口 UserService ，以及该接口的一个实现类 UserServiceImpl

public interface UserService {public void select();   public void update();
}public class UserServiceImpl implements UserService {  public void select() {  System.out.println("查询 selectById");}public void update() {System.out.println("更新 update");}
}

2、写一个代理类 UserServiceProxy，代理类需要实现 UserService

public class UserServiceProxy {public static Object getObject(final UserService target){Object proxyInstance = Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), new InvocationHandler() {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println(String.format("log start time [%s] ", new Date()));method.invoke(target, args);System.out.println(String.format("log end time [%s] ", new Date()));return null;}});return proxyInstance;}
}

3、测试

public class Client {public static void main(String[] args) {UserService userServiceImpl = new UserServiceImpl();UserService proxy =(UserService) UserServiceProxy.getObject(userServiceImpl);proxy.select();proxy.update();}
}

CGLIB 代理

CGLib 采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑，来完成动态代理的实现。

由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。

实现方式：

实现 MethodInterceptor 接口，重写 intercept 方法，通过 Enhancer 类的回调方法来实现。

优点：

没有接口也能实现动态代理，而且采用字节码增强技术，性能也不错。

缺点：

技术实现相对难理解

实例：

通过静态代理对 UserServiceImpl 进行功能增强，在调用select和update之前记录一些日志。

1、编写一个接口 UserService ，以及该接口的一个实现类 UserServiceImpl

public interface UserService {public void select();   public void update();
}public class UserServiceImpl implements UserService {  public void select() {  System.out.println("查询 selectById");}public void update() {System.out.println("更新 update");}
}

2、写一个代理类 UserServiceProxy，代理类需要实现 UserService

public class UserServiceProxy {public static Object getObject(final UserService target){Object proxyObj = Enhancer.create(obj.getClass(), new MethodInterceptor() {public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println(String.format("log start time [%s] ", new Date()));method.invoke(target, objects);System.out.println(String.format("log end time [%s] ", new Date()));return null;}});return proxyObj;}
}

3、测试

public class Client {public static void main(String[] args) {UserService userServiceImpl = new UserServiceImpl();UserService proxy =(UserService) UserServiceProxy.getObject(userServiceImpl);proxy.select();proxy.update();}
}