代理模式（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 方法