Java - 动态代理实现方式

前言

Java中的动态代理，一共有两种实现方式：

• JDK动态代理。
• Cglib代理。

我们先来讲一下如何使用他们，再来讲一下他们俩之间的区别和注意事项。

一. JDK动态代理案例

如果使用JDK动态代理，就是使用Proxy+InvocationHandler的组合来完成。期间，被代理类需要实现一个接口。

1.设计一个接口UserService，以及对应的实现类。

public interface UserService {
    void hello();
}

public class UserServiceImpl implements UserService{
    @Override
    public void hello() {
        System.out.println("****************hello*******************");
    }
}

2.定义一个InvocationHandler，构造函数中需要传入被代理的对象：

public class MyInvocationHandler implements InvocationHandler {
    // 目标对象
    private Object target;

    public MyInvocationHandler(Object target) {
        super();
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("==========before===========");
        // 执行目标方法
        Object res = method.invoke(target, args);
        System.out.println("==========after===========");
        return res;
    }

    // 获取目标对象的代理对象
    public Object getProxy() {
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this);
    }
}

Proxy.newProxyInstance这个函数有三个参数：

/**
* loader： 类加载器
* interfaces： 被代理类实现的接口
* h： 用于代理对象的处理器
*/
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

3.Test类测试：

public static void main(String[] args) {
    UserServiceImpl userService = new UserServiceImpl();
    MyInvocationHandler handler = new MyInvocationHandler(userService);
    // 代理对象
    UserService proxy = (UserService) handler.getProxy();
    // 通过代理对象执行对应函数
    proxy.hello();
}

结果如下：

二. Cglib代理案例

与JDK动态代理不同的是，Cglib代理主要通过Enhancer + Callback来完成，主要原理就是生成被代理类的一个子类，重写代理方法罢了。

1.自定义一个拦截器，需要实现MethodInterceptor（继承了Callback接口）：

public class MethodInterceptorImpl implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("==========before===========");
        Object res = methodProxy.invokeSuper(obj, args);
        System.out.println("==========after===========");
        return res;
    }
}

2.自定义一个类UserProcess

public class UserProcess {
    public void hello(){
        System.out.println("****************hello*******************");
    }
}

3.Test类测试：

public class Test {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserProcess.class);
        enhancer.setCallback(new MethodInterceptorImpl());

        UserProcess o = (UserProcess) enhancer.create();
        o.hello();
        System.out.println(o);
    }
}

结果如下：

三. 若干注意事项

3.1 JDK动态代理和Cglib代理的区别

• JDK动态代理：只能对实现了接口的类生成代理，不能针对类。 主要通过Proxy+InvocationHandler的组合来实现。
• Cglib代理：针对类进行代理。对指定的类生成一个子类，覆盖其中的方法。（注意对应的方法不要声明为final，否则无法重写）主要通过Enhancer+ Callback来实现。

3.2 为什么第二节中的Cglib案例有三段输出？

Enhancer生成的代理类，会拦截所有非final的方法。而上述代码中用到了这段代码：

System.out.println(o);

这个函数在执行的时候，需要用到对象的两个方法：

• toString。
• hashCode。

这两个函数是存在于Object中的，所有的类都是Object类的子类，而这两个函数又没有被final修饰。因此当执行的时候，会多输出两段信息。

我们在过滤器中，稍微改下代码，输出下执行的方法名称就可以验证了：

输出结果如下：

3.3 为什么JDK动态代理只能代理有接口实现的类？

首先我们来测试一下，我们用本文的UserProcess类，尝试下动态代理：

UserProcess userProcess = new UserProcess();
MyInvocationHandler handler = new MyInvocationHandler(userProcess);
// 代理对象
UserProcess proxy = (UserProcess) handler.getProxy();
// 通过代理对象执行对应函数
proxy.hello();

运行结果如下：出现转换异常
可见，被代理对象如果没有实现接口，是不能通过JDK动态代理的。

1. 因为JDK动态代理的时候，需要根据被代理对象实现的接口，来生成对应的字节码文件。
2. 而字节码文件中，代理类会自动生成对应的方法，然后执行 InvocationHandler 中的invoke函数。
3. 同时生成的代理类从字节码文件中可以发现，它继承了Proxy类，而Java是单继承，因此不能再继承其他的类。因此动态代理只能通过实现接口的方式去完成。

详细源码可以看Java - JDK动态代理原理。