动态代理和静态代理详解

动态代理和静态代理详解

所谓的代理就是在不修改被代理类的情况下，我们去生成一个代理类，然后通过访问代理类，拓展原有的被代理类的功能。

静态代理

静态代理模式的实现步骤：

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;
    }
}

public class SmsProxy implements SmsService {
    
    //注入被代理的角色
    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}


   

实际使用：

public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}


控制台输出：
before method send()
send message:java
after method send()

动态代理

动态代理目前普遍使用两种方式实现：JDK自带的动态代理和CGLIB方式，在springAop中，如果被代理类有接口，那么我们默认使用JDK 自带的方式，如果没有接口，那么我们使用CGLIB方式。

JDK动态代理

在JDK动态代理中，InvocationHandler接口和Proxy类是我们所使用的核心，Proxy.newProxyInstance方法用来实现生成一个代理对象，而InvocationHandler中的invoke方法用来拓展被代理类的方法，也就是我们实际调用的方法。

具体步骤如下：

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

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

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

//自定义 InvocationHandler 并重写invoke方法

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;
    }
}

//获取对象的工厂类
public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}

//实际调用
SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
smsService.send("java");

CGLIB的动态代理

JDK动态代理只能代理实现了接口的类，对于没有实现接口的类，我们通常使用CGLIB来完成动态代理。

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

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

你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法

（和JDK类似）

具体步骤如下：

1.定义一个类；

2.自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；

3.通过 Enhancer 类的 create()创建代理类；

//添加相关依赖，这点和JDK代理不同
<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

//被代理的类
public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

//自定义intercept方法
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;
    }
}

//获取代理类
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();
    }
}

//实际使用
AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");

JDK动态代理和CGLIB动态代理的比较：

效率上：一般而言，JDK动态代理更优秀，并且会随着JDK版本的升级优势也会越明显；

差异上：JDK动态代理只能代理实现了接口的类，而CGLIB动态代理可以代理未实现接口的类。但是CGLIB动态代理是通过生成一个被代理类的子类，然后进行拦截拦截来实现方法的拓展，因此，CGLIB不能代理被final修饰的类，而且CGLIB需要导入相关的依赖。

动态代理和静态代理的对比

灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！

JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

这篇笔记主要借鉴自javaGuide：链接：代理详解！静态代理+JDK/CGLIB 动态代理实战 | JavaGuide