Java动态代理机制 代码示例demo

JDK动态代理代码实现示例

1.定义发送短信的接口

package dynamic_proxy;

/**
 * 定义发送短信的接口
 */
public interface SmsService {
    void send(String message);
}

2.实现发送短信的接口

package dynamic_proxy;

/**
 * 实现发送短信的接口 的类
 */
public class SmsServiceImpl implements SmsService{

    @Override
    public void send(String message) {
        System.out.println("send message:" + message);
    }
}

这是一个 之后被代理的类。

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

package dynamic_proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 定义一个JDK动态代理类
 */
public class DebugInvocationHandler implements InvocationHandler {
    private final Object target;

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

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

这个动态代理类将可以代理上面的 SmsServiceImpl 对象。

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

4.获取代理对象的工厂类

package dynamic_proxy;

import java.lang.reflect.Proxy;

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new DebugInvocationHandler(target)
        );
    }
}

使用该定义的静态方法可以声明一个代理对象。

这里使用了工厂模式。

工厂模式（Factory Pattern）是最常用的设计模式之一，它属于创建类型的设计模式。它提供了一种创建对象的最佳方式，在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过一个共同的接口来指向新创建的对象。

5.实际使用

package dynamic_proxy;

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

运行结果为

before method send
send message:java
after method send

这里 SmsService 是一个接口名，众所周知，接口不能实例化。实际上，我们不能直接实例化一个接口，但可以通过实例化实现了接口的类来达到相同的效果。

如果我们打印出来System.out.println(JdkProxyFactory.getProxy(new SmsServiceImpl()).getClass());，会得到class com.sun.proxy.$Proxy0。

JDK 动态代理只能代理实现了接口的类

具体来说，JDK动态代理是通过实现目标接口的方式来创建代理类的，代理类会实现目标接口中定义的所有方法，并在代理类中通过反射调用目标对象的方法，从而完成代理的功能。因此，如果目标对象没有实现任何接口，那么JDK动态代理就无法生成代理类。
如果要对一个没有实现任何接口的类进行代理，可以使用其他的代理技术，比如CGLIB，它可以生成一个子类来作为代理类，从而实现对目标对象的代理。

CGLIB动态代理代码实现示例

首先创建一个 maven 项目，添加依赖：

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

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

package cglib_dynamic_proxy;

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

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

package cglib_dynamic_proxy;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 自定义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.获取代理类

package cglib_dynamic_proxy;

import net.sf.cglib.proxy.Enhancer;

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.实际使用

package cglib_dynamic_proxy;

public class Main {
    public static void main(String[] args) {
        AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
        aliSmsService.send("java");
    }
}

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

1. JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
2. 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

参考资料

https://javaguide.cn/java/basis/proxy.html#_3-%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86
面试官：为什么jdk动态代理只能代理接口实现类？
基于Jdk的动态代理为什么只能基于接口？