代理模式（Proxy Pattern）

代理模式定义：

提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。

举个例子：猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。

优点： 1、职责清晰。 2、高扩展性（可以在目标对象实现的基础上，增强额外的功能，即扩展目标对象的功能）。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展方法

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

代码演示：

创建 maven 项目

模拟业务层代码，创建cn.xs.service.UserService 接口

接口代码如下：

 

public interface UserService {
/**
* 添加用户
*/
void add();
}

实现类：

public class UserServiceImpl implements UserService {
/**
* 添加用户
*/
public void add() {
System.out.println("添加用户！");
}
}

创建测试类测试添加方法：

public class ProxyTest {
/**
* 测试方法
*
* @param args
*/
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
userService.add();
}
}

上面是已经写好的代码，现需要添加新的需求，我们不能去在 add 方法中直接添加代码

需求：保存用户之前需要判断是否为离职人员重新入职的情况，如果是，则不需要再将用户添加到数据库，只需要将用户状态由离职改为正式员工即可，在添加员工之后，也需要添加新的业务逻辑，比如给新来的员工发送短信，告诉员工一些信息等

用静态代理完成功能扩展：

新建静态代理类:ProxyStatic

public class ProxyStatic implements UserService {
/* 需要扩展的目标对象 */
private UserService userService;/*** 实例化 UserService 对象** @param userService*/public ProxyStatic(UserService userService) {this.userService = userService;}/*** 扩展功能的方法*/public void add() {System.out.println("在原有方法之前写代码------判断是否是离职人员入职");// 原有功能不修改userService.add();System.out.println("在原有方法之后写代码------发送短信");}
}

测试：

public static void main(String[] args) {// UserService userService = new UserServiceImpl();// userService.add();// 1. 静态代理UserService userService = new UserServiceImpl();ProxyStatic proxy = new ProxyStatic(userService);proxy.add();
}

运行 main 方法：

静态代理：

优点：可以在不修改原有保存逻辑的前提下，对原有保存方法进行扩展

缺点：因为代理对象需要与目标对象实现相同的接口，所以会有很多代理类，类太多，同时，一旦

接口增加方法，目标对象与代理对象都要维护

用动态代理完成功能扩展：

jdk 动态代理：

特点：代理对象，不需要实现接口

代理对象的生成，是利用 jdk 的 api ，动态的在内存中构建代理对象（需要我们指定创建代理

对象/目标对象实现的接口类型）

 新建 jdk 动态代理类：ProxyJdk

public class ProxyJdk {
/* 声明目标对象 */
private Object target;
/**
* 实例化目标对象
*
* @param proxy
*/
public ProxyJdk(Object target) {
this.target = target;
}
/**
* 获取代理对象
*
* @return
*/
public Object getProxy() {// newProxyInstance 的三个参数：// 第一个参数是该类的类加载器// 第二个是需要代理实例的接口列表，因为该原因，所以，实例必须要有接口// 第三个参数不能为空，代理对象的所有方法调用都被委托到 invoke 方法return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), new InvocationHandler() {public Object invoke(Object object, Method method, Object[] args)throws Throwable {System.out.println("在原有方法之前写代码------判断是否是离职人员入职");Object invoke = method.invoke(target, args);System.out.println("在原有方法之后写代码------发送短信");return invoke;}});}
}

测试：

public static void main(String[] args) {// UserService userService = new UserServiceImpl();// userService.add();// 1. 静态代理// UserService userService = new UserServiceImpl();// ProxyStatic proxy = new ProxyStatic(userService);// proxy.add();
// 2. jdk 动态代理UserService userService = new UserServiceImpl();ProxyJdk proxyJdk = new ProxyJdk(userService);// 获取代理对象Object proxy = proxyJdk.getProxy();if (proxy instanceof UserService) {((UserService) proxy).add();}
}

cglib 动态代理 和  静态代理 还有 jdk 动态代理的区别：

静态代理和 jdk 动态代理模式都是要求对象是实现一个接口的目标对象，但是有时候目标对象

只是一个单独的对象，并没有任何的接口，这个时候就可以使用以目标对象子类的方式来实现代理

新建代理类：Proxycglib

引入依赖：

<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.4</version>
</dependency>

代理类实现 MethodInterceptor 接口，代码如下：

public class ProxyCglib implements MethodInterceptor {
/* 声明动态代理对象 */
private Object target;
/**
* 实例化代理对象
*
* @param proxy
*/
public ProxyCglib(Object target) {
this.target = target;
}
/**
* 代理功能扩展
*
* @param o
* @param method
* @param objects
* @param methodProxy
* @return
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable {
System.out.println("在原有方法之前写代码------判断是否是离职人员入职");
Object invoke = method.invoke(target, objects);
System.out.println("在原有方法之后写代码------发送短信");
return invoke;
}
/**
* 获取代理对象
*
* @return
*/
public Object getProxy() {
// Enhancer允许为非接口类型创建一个Java代理。
// Enhancer动态创建了给定类型的子类但是拦截了所有的方法。
// 和Proxy不一样的是，不管是接口还是类他都能正常工作。
Enhancer enhancer = new Enhancer();
// 设置代理类字节码，不需要获取接口
enhancer.setSuperclass(target.getClass());
// 设置回调，需要传递当前对象
enhancer.setCallback(this);
// 创建代理对象并返回
return enhancer.create();
}
}

测试：

/**
* 测试方法
*
* @param args
*/
public static void main(String[] args) {
// UserService userService = new UserServiceImpl();
// userService.add();
// 1. 静态代理
// UserService userService = new UserServiceImpl();
// ProxyStatic proxy = new ProxyStatic(userService);
// proxy.add();
// 2. jdk 动态代理
// UserService userService = new UserServiceImpl();
// ProxyJdk proxyJdk = new ProxyJdk(userService);
// 获取代理对象
// Object proxy = proxyJdk.getProxy();
// if (proxy instanceof UserService) {
// ((UserService) proxy).add();
// }
// 3. cglib 动态代理
UserServiceImpl userService = new UserServiceImpl();
ProxyCglib proxyCglib = new ProxyCglib(userService);
// 获取代理对象
Object proxy = proxyCglib.getProxy();
if (proxy instanceof UserServiceImpl) {
((UserService) proxy).add();
}
}

Enhancer 与 Proxy 的区别：

Enhancer 是 cglib 中的一个类，Proxy 是 jdk 中的

Enhancer 既能代理普通的 class ，也能代理接口。Enhancer 创建一个被代理对象的子类并且拦截 所有的方法调用（包括从 Object 中继承的 toString 和 hashCode 方法）。Enhancer 不能拦截 final方法