1. 代理设计模式

1.1 为什么需要代理设计模式

代理设计模式可以在不改变原始对象的情况下，对其进行扩展、增强或保护。 它是一种结构型设计模式，常用于解决以下问题：

1. 访问控制：代理对象可作为一个安全接口，可以拦截请求并检查请求的参数和权限，以防止恶意代码或非法用户访问原始对象的敏感数据。
2. 单一职责原则（SRP）： 原始对象可能需要完成多项任务，其中某些任务可能与它主要的业务逻辑无关。此时，代理对象可以承担一部分原始对象的工作，将原始对象从这部分工作中解放出来，从而使得各自的职责更加明确。
3. 性能优化： 在某些场景下，原始对象的创建和初始化成本很高且不易扩展。为了避免频繁地创建新的原始对象，使用代理对象可以通过缓存机制和懒加载优化性能，特别是当我们需要对大量的原始对象进行管理时。
4. 透明处理：使用代理模式可以将代码中复杂的流程和算法隔离开来，提高代码的可读性和可维护性。例如，在远程调用和异步调用等场景下，代理对象可以自动处理网络通信和序列化操作相关的细节问题，使得这些复杂的操作对于用户透明不可见。

1.2 代理设计模式

1.2.1 概念

通过代理类，为原始类（⽬标）增加额外的功能

好处：利于原始类(⽬标)的维护

1.2.2 名词解释

1. ⽬标类 原始类 指的是 业务类 (核⼼功能 --> 业务运算 DAO调⽤)
2. ⽬标⽅法，原始⽅法 ⽬标类(原始类)中的⽅法 就是⽬标⽅法(原始⽅法)
3. 额外功能 (附加功能) ⽇志，事务，性能

1.2.3 代理开发的核⼼要素

代理类 = ⽬标类(原始类) + 额外功能 + 原始类(⽬标类)实现相同的接⼝

2. 静态代理

静态代理：为每⼀个原始类，⼿⼯编写⼀个代理类

2.1 编码

2.2 静态代理存在的问题

1. 代码冗余：需要手动创建代理对象和代理方法，这些代码会重复且不容易维护。在需要修改代理行为时，必须要同时修改原始对象和代理对象的代理方法。
2. 耦合度高：由于代理对象与原始对象紧密相连，一旦原始对象的接口发生变化，代理对象就必须进行相应的修改。无论是代理类还是原始类的修改都会对另一个造成影响，从而增加了两个类之间的耦合度。
3. 动态性问题： 静态代理模式只能在编译期创建新的代理类并在运行时调用，不支持运行时动态地生成代理类。如果我们需要动态地增强或扩展原始对象的功能，则可能需要使用其他代理模式，例如动态代理模式或者CGLIB代理模式。
4. 只能代理特定类型的对象：由于代理对象对原始对象方法的调用是以编程方式执行的，因此无法实现像JDK提供的InvocationHandler那样能够动态地代理任何实现了指定接口的类的功能。

3. 动态代理

3.1 Spring动态代理的概念

概念：通过代理类为原始类(⽬标类)增加额外功能

好处：利于原始类(⽬标类)的维护

3.2 动态代理细节分析

1. Spring 创建的动态代理类在哪⾥？

Spring 框架在运⾏时，通过动态字节码技术，在 JVM 创建的，运⾏在 JVM 内部，等程序 结束后，会和 JVM ⼀起消失

什么叫动态字节码技术: 通过第三个动态字节码框架，在 JVM 中创建对应类的字节码，进 ⽽创建对象，当虚拟机结束，动态字节码跟着消失。

结论：动态代理不需要定义类⽂件，都是 JVM 运⾏过程中动态创建的，所以不会造成静态 代理，类⽂件数量过多，影响项⽬管理的问题。

2.动态代理编程简化代理的开发
在额外功能不改变的前提下，创建其他⽬标类（原始类）的代理对象时，只需要指 定原始(⽬标)对象即可。

3.动态代理额外功能的维护性⼤⼤增强

3.3 动态代理的实现

3.3.1 JDK 动态代理

• Proxy.newProxyInstance⽅法参数详解
  
• 返回值就是代理后的对象
  
  
  
• 编码
  原始对象方法

@Service
public class UserServiceImpl implements UserService{
    @Override
    public void add(String name, Integer age) {
        System.out.println("添加 : name= " + name + ", age= " + age);
    }
}

JDK 动态代理

public class TestJDKProxy {
    
    public static void main(String[] args) {
        //  创建原始对象
        UserService userService = new UserServiceImpl();

        //  JDK 创建动态代理
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法运行前....");
                Object invoke = method.invoke(userService, args);
                System.out.println("方法运行后....");
                return invoke;
            }
        };


        UserService userServiceProxy
                = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(), invocationHandler);

        userServiceProxy.add("snow", 100);

    }
}

• 运行结果

3.3.2 CGlib的动态代理

CGlib创建动态代理的原理：⽗⼦继承关系创建代理对象，原始类作为⽗类，代理类作为⼦类， 这样既可以保证2者⽅法⼀致，同时在代理类中提供新的实现(额外功能+原始⽅法)

• 编码

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class TestCglib {
    public static void main(String[] args) {
        //1 创建原始对象
        UserService userService = new UserService();
        /*
         2 通过cglib⽅式创建动态代理对象
         Enhancer.setClassLoader()
         Enhancer.setSuperClass()
         Enhancer.setCallback(); ---> MethodInterceptor(cglib)
         Enhancer.create() ---> 代理
         */
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(TestCglib.class.getClassLoader());
        enhancer.setSuperclass(userService.getClass());
        MethodInterceptor interceptor = new MethodInterceptor() {
            //等同于 InvocationHandler --- invoke
            @Override
            public Object intercept(Object o, Method method,
                                    Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("---cglib log----");
                Object ret = method.invoke(userService, args);
                return ret;
            }
        };
        enhancer.setCallback(interceptor);
        UserService userServiceProxy = (UserService)
            enhancer.create();
        userServiceProxy.login("suns", "123345");
        userServiceProxy.register(new User());
    }
}

4. 总结

1. JDK 动态代理 Proxy.newProxyInstance() 通过接⼝创建代理的实现类
2. Cglib 动态代理 Enhancer 通过继承⽗类创建的代理类