1.什么是代理模式

代理模式是一种比较好理解的设计模式。简单来说就是

我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

2.静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（

比如接口一旦新增加方法，目标对象和代理对象都要进行修改

）且麻烦(

需要对每个目标类都单独写一个代理类

)。

静态代理实现步骤:

定义一个接口及其实现类；
创建一个代理类同样实现这个接口
将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

3.动态代理

3.1. JDK 动态代理机制

3.1.1JDK 动态代理类使用步骤：

定义一个接口及其实现类；
自定义
InvocationHandler
并重写
invoke
方法，在
invoke
方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
通过
Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
方法创建代理对象；

3.1.2代码示例：

1.定义发送短信的接口

public interface SmsService {
    String send(String message);
}

2.实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

3.定义一个 JDK 动态代理类


public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}

invoke()
方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是
invoke()
方法，然后
invoke()
方法代替我们去调用了被代理对象的原生方法。

4

.实际使用

public static void main(String[] args) {
        SmsServiceImpl smsServiceImpl = new SmsServiceImpl();
        SmsService smsService = (SmsService)Proxy.newProxyInstance(
                smsServiceImpl.getClass().getClassLoader(), // 目标类的类加载
                smsServiceImpl.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(smsServiceImpl)   // 代理对象对应的自定义 InvocationHandler
        );
        smsService.send("java");
    }

3.1.3

JDK 动态代理

为什么

只能代理实现了接口的类

：

动态代理实际上是程序在运行中，

根据被代理的接口来动态生成代理类的class文件，
并加载class文件运行的过程，
通过反编译被生成的

$Proxy0.class

文件发现

public final class $Proxy0 extends Proxy implements Interface {
 
    public $Proxy0(InvocationHandler paramInvocationHandler) {
        super(paramInvocationHandler);
    }
 
    // 该方法为被代理接口的业务方法，代理类都会自动生成相应的方法，里面去执行invocationHandler 的invoke方法。
    public final void sayHello(String paramString) {
        try {
            this.h.invoke(this, m3, new Object[] { paramString });
            return;
        }
        catch (Error|RuntimeException localError) {
            throw localError;
        }
        catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }
}

java是单继承
- 动态生成的代理类已经继承了Proxy类的，就不能再继承其他的类，
- 所以只能靠实现被代理类的接口的形式，故JDK的动态代理必须有接口。

3.2. CGLIB 动态代理机制

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB 通过继承方式实现代理，例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中
MethodInterceptor
接口和
Enhancer
类是核心。

你需要自定义
MethodInterceptor
并重写
intercept
方法，
intercept
用于拦截增强被代理类的方法。

3.2.1. CGLIB 动态代理类使用步骤

定义一个类；
自定义
MethodInterceptor
并重写
intercept
方法，
intercept
用于拦截增强被代理类的方法，和 JDK 动态代理中的
invoke
方法类似；
通过
Enhancer
类的
create()
创建代理类；

3.2.2. 代码示例

导入依赖：

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

1.实现一个使用阿里云发送短信的类

public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

2.自定义
MethodInterceptor
（方法拦截器）


public class DebugMethodInterceptor implements MethodInterceptor {

    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }

}

3.获取代理类

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

4.实际使用

AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");

3.3. JDK 动态代理和 CGLIB 动态代理对比

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。

另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

原文链接：https://blog.csdn.net/qq_66912832/article/details/125217868