【Spring】：Java 中的代理

1、什么是代理

在学习完 IOC 容器之后，我们要学习 Spring 的另外一个特点 AOP。在学习 AOP 之前，我们需要去了解一点 Java 代理的知识，因为AOP 是以动态代理为底层实现。

代理是一种设计模式，提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。可以不修改目标对象，对目标对象功能进行拓展

在了解代理之前，我们先思考一个问题：如果 Student 类继承了接口 Students，且实现接口 Students 的四个方法。假设，在完成之后突然需要给每个方法添加一个相同的功能，那么我们应该如何完成？？

按照以往的编程习惯，有以下几种方式：

1. 在 Student 类的每一个方法中将新功能的代码写一遍
2. 在 Students 接口中定义一个新方法，然后再 Student 类中将该方法实现，然后 add 等方法中引用新定义的方法。这种方式是将第一种方式的重复代码进行抽取，然后封装，最后在引用。

虽然上述两种方式都可以实现给所有方法实现新功能，但是这些都要去修改 Student 类，而使用代理的方式可以不修改 Student 类完成添加。代理可以分为静态和动态两种代理方式。

代理模式的好处：

1. 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
2. 公共也就是交给我们的代理角色！实现了业务的分工！
3. 公共业务发生扩展的时候，方便集中管理！

2、 静态代理

想要实现静态代理，需要重新创一个代理对象，也就是一个新的类（通常被称代理码类）。在代理类中进行相关操作。而静态代理就是在代理类中完成原有功能和新功能的结合。具体使用如下：

//定义 Student 类继承 Students 接口
public class Student implements Students {

    @Override
    public void add(){
        System.out.println("add running....");
    }

    @Override
    public void update() {
        System.out.println("update running....");
    }

    @Override
    public void select() {
        System.out.println("select running....");
    }

    @Override
    public void del() {
        System.out.println("del running....");
    }
}

//定义代理类，然后继承 Students 接口
//然后定义新添加的功能
//然后将实现 Students 接口中定义的方法
//在实现过程中，现在执行新增方法，然后只执行  Student 类中的功能
public class Proxys implements Students {

    private Student student;

    public void setUserService(Student student) {
        this.student = student;
    }

    @Override
    public void add() {
        this.news();
        student.add();
    }

    @Override
    public void update() {
        this.news();
        student.update();
    }

    @Override
    public void select() {
        this.news();
        student.select();
    }

    @Override
    public void del() {
        this.news();
        student.del();
    }
    
    public void news() {
        System.out.println("news fun...");
    }
}

上述方式就是静态代理的过程，静态代理的组成：

1. 代理目标接口：定义代理类和目标实现类的基本模板，代理类和目标实现类都要实现这个接口

2. 目标对象： 实现代理目标接口的实现类

3. 代理类： 持有目标对象，根据不同的策略选择不同的方法调用目标对象的方法。

静态代理的优缺点：

1. 优点： 做到不修改目标对象的功能前提下，对目标功能扩展

2. 缺点： 因为代理对象需要与目标对象实现同样的接口，所以会有很多代理类，目标类，同时修改接口，目标类和代理类都要维护。

3、动态代理

动态代理有JDK代理和cglib代理两种实现方法，动态代理与静态代理的区别是，静态代理在代理类中已经规定了目标对象，想要修改只能修改代码。而动态代理将代理类中则没有规定，从而达到动态的效果。

3.1、JDK代理

JDK代理必须要使用接口InvocationHandler，即代理类需要继承InvocationHandler接口，还要使用Proxy类完成代码。JDK代理组成部分：

1. 目标接口类
2. 目标实现类：既接口的实现类
3. Proxy类：Java.lang.reflect.Proxy包下的Proxy类，
4. 代理类：实现调用目标类的扩展逻辑
5. 新增功能实现类：可以将具体的新增功能存放在该了类中（该部分可省略）

在案例中，Students 就是目标接口类，Student 就是目标实现类，ProxyInvocationHandler 类就是代理类，具体使用如下：

//创建动态代码类
public class ProxyInvocationHandler implements InvocationHandler {
    //目标接口
    private Object target;

    //目标接口实例化
    public void setRent(Object target) {
        this.target = target;
    }

    //实现代理
    public Object getProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this::invoke);
    }

    //将新功能与之前的功能进行耦合
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.news();
        Object reuslt = method.invoke(target, args);
        return reuslt;
    }

    //新功能
    public void news(){
        System.out.println("news running...");
    }
}

//具体使用方法如下：
//1.创建目标对象
Student student = new Student();
//2.实例化代理对象
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//3.告诉代理对象，需要修改的类
pih.setRent(student);
//4.动态生成代理类
Students proxy = (Students) pih.getProxy();

上述方法是在代理类中实现了代理过程，我们可以将定义代理和实现代理的过程进行简化结合，如下所示：

//这种方法是直接在使用的时候实现了代理过程，省略了代理类。
//1.创建目标对象
Student student = new Student();
//2.创建新增功能实现类(既将需要增加的方法使用新增类存放)
//......
//3.创建动态生成代理类
Students proxy = (Students) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                //这里可以写前置增强
                //在这里调用 第二步中实例化类中的方法，这个方法就是增强方法
                Object reuslt = method.invoke(student,args);
                //这里可以写后置增强
                return reuslt;
            }
        });

JDK动态代理的优缺点：

1. 优点：动态实现了新功功能增加，但没有改变目标对象逻辑的扩展

2. 缺点：目标必须实现接口，不然无法实现动态代理

这里需要注意的时：使用 JDK 代理创建代理类时，必须要实现接口，既需要实例化接口。

3.2、cglib代理

cglib代理和JDK代理的区别是：JDK代理必须要实现接口，而cglib代理可以省略接口，直接对目标实现类进行处理。

cglib代理中必须要使用到MethodInterceptor接口和Enhancer类，具体的组成部分：

1. 实现类：实现具体目标的逻辑
2. 代理类：实现MethodInterceptor接口，扩展逻辑实现
3. Enhancer 设置代理类，并且生成代理对象，

public class cglib implements MethodInterceptor {

    //目标实现类
    private Object target;

    //通过有参构造的当时完成目标实现类的实例化
    public cglib(Object target) {
        this.target = target;
    }

    //创建增强器
    public Object getInstance(){
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        return en.create();
    }

    //设置父类，既设置目标对象
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        this.news();
        Object reuslt = method.invoke(target, objects);
        return reuslt;
    }

    //新增功能
    public void news(){
        System.out.println("news running...");
    }
}

//具体的使用方法如下；
//实例化一个父类
Student target = new Student();
//创建代理对象
Student proxy = (Student) new cglib(target).getInstance();
//调用方法
proxy.update();

将创建过程和使用过程进行简化：

//创建父类
Student target_ = new Student();
//创建增强器
Enhancer enhancer = new Enhancer();
//设置父类
enhancer.setSuperclass(Student.class);
//将新增功能与父类耦合
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
   //这里可以写前置增强
   Object reuslt = method.invoke(target_, args);
   //这里可以写前置增强
   return reuslt;
  }
});
//创建代理对象
Student proxy = (Student) enhancer.create();
//新增功能之后执行方法
proxy.update();

两种代理的区别：