java知识点——动态代理

一、动态代理 

在使用 spring 进行开发时，经常会使用到动态代理。当我们要实现某个功能时，我们会编写一个 Service 接口，和一个（或者多个）实现该接口的 ServiceImpl 类。这么做的好处是可以使得避免耦合。我们再需要使用该方法是，并不会去显性的创建一个 ServiceImpl，我们会直接通过 Service.Method() 的方式来调用该方法，在普通的程序里，这样是会报错的，毕竟 Service 并没有真的完成该方法的实现。但是,我们只需要添加几个注解，就能完成 ServiceImpl 和 Service 的绑定，从而使用 ServiceImpl 里实现的方法。

这就是动态代理，Service 是 方法调用者和实现者（Impl）之间的代理商。

那么如何实现这样的功能？

二、JDK 动态代理

java 的 java.lang.reflect.* 给我们提供了一种动态代理的实现方案。它可以帮助我们完成接口和接口实现类之间的绑定。

首先，我们创建一个用于测试的 Service：

package SSMTest.JProxyTest;

public interface ProxyService {
    void HelloWorld();

}

然后是它的实现：

package SSMTest.JProxyTest;
import static MyTools.PrintTools.*;
public class ProxyServiceImpl implements ProxyService {

    @Override
    public void HelloWorld() {
        println("Hello World");
    }

}

如何将这两者绑定在一起，首先，jdk 提供的方法是：

Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), invocationHandler);

第一个参数是 Impl 类的加载器，第二个参数是 Impl 的接口也就是 Service，第三个参数是一个 InvocationHandler 接口，它的 invoke() 方法将提供方法的具体实现。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

该方法的第一个参数是 Proxy 是代理对象，也就是 Proxy.newProxyInstance(...) 方法返回的对象，第二个是当前调度的方法，第三个是调度方法的参数。

package SSMTest.JProxyTest;

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

import static MyTools.PrintTools.*;

public class ProxyJdkExample implements InvocationHandler{

    private Object target = null;
    
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        println("proxy method");
        println("before proxy");
        Object obj = method.invoke(target, args);
        println("after proxy");
        return null;
    }

}

在 invoke 里，我们使用的 method.invoke() 调用了 Impl 的方法。

以下是测试用例：

package SSMTest.JProxyTest;

public class ProxyJdkTest {

    public static void main(String[] args) {
        ProxyJdkExample jdk = new ProxyJdkExample();
        ProxyService proxy = (ProxyService)jdk.bind(new ProxyServiceImpl());
        proxy.HelloWorld();
    }

}
/*output
proxy method
before proxy
Hello World
after proxy*/

如何去理解 jdk 动态代理的实现？

我们假设，A 需要调用 某个方法，这个方法是 接口 B 的方法，而实现这个方法的类是 C？

在程序开始，A（也就是上述的 mian() 方法）定义了一个 B

ProxyService proxy = (ProxyService)jdk.bind(new ProxyServiceImpl());

单从这个语句来看，我们似乎有点多此一举，因为上面以及它背后的大串的代码完全等价于下面这段代码：

ProxyService proxy = new ProxyServiceImpl();

但是我们发现，我们使用动态代理后调用的方法除了实现了方法本身的输出外，还额外输出了我们再 invoke 里的输出，这说明，我们并不是直接调用了 Impl 里 helloWorld() 方法这么简单。而在后面，我们会看到，我们可以在 invoke() 里面多做点文章，然后实现一些特殊的功能。

接着上面的话题，A 首先找到了 B，这个时候我们将 C 和 B 通过 Proxy.newProxyInstance(...) 方法绑定在了一起，然后 B 开始调用它的方法 HelloWorld，但是调用方法的逻辑已经被 invoke() 代理了，也就是说实际上我们并没有真的去执行 ProxyServiceImpl().HelloWorld 这个方法，而是去执行了 invoke() 方法，如果我们愿意，甚至可以让他连 Hello World 都不输出。

这表明，我们甚至可以完全不用去管 Impl 到底是怎么实现 Service 里的方法的，我们可以在 invoke() 里做我们想做的任何事。

换句话来，当 A 在调用 B 的某个方法是，我们可以把这个请求拦截下来，然后进行我们自己的操作。

三、拦截器

既然我们可以将某个方法调用的请求拦截下来，我们不如就去创建一个拦截器。

首先是拦截器的接口：

 

package SSMTest.JProxyTest;

import java.lang.reflect.Method;

public interface Interceptor {
    boolean brfore(Object proxy,Object target,Method method,Object[] args);
    boolean around(Object proxy,Object target,Method method,Object[] args);
    boolean after(Object proxy,Object target,Method method,Object[] args);

}

 

这个拦截器，在拦截下请求之后，会执行 3 个方法的操作。

然后是它的具体实现：

package SSMTest.JProxyTest;

import java.lang.reflect.Method;
import static MyTools.PrintTools.*;

public class MyInterceptor implements Interceptor {

    @Override
    public boolean brfore(Object proxy, Object target, Method method, Object[] args) {
        println("=====================proxy before ============================");
        return false;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        println("=====================proxy aroud ============================");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        println("=====================proxy after ============================");
    }

}

好，现在我们可以利用这个拦截器去拦截一次方法的请求。

package SSMTest.JProxyTest;

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

public class InterceptorJdkProxy implements InvocationHandler {

    private Object target;
    private String interceptorClass = null;
    
    public InterceptorJdkProxy(Object target,String interceptorClass) {
        this.target =  target;
        this.interceptorClass = interceptorClass;
    }
    
    public static Object bind(Object target,String interceptorClass) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), 
                new InterceptorJdkProxy(target,interceptorClass));
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(interceptorClass == null) {
            return method.invoke(target, args);
        }
        Object result = null;
        Interceptor interceptor = (Interceptor)Class.forName(interceptorClass).newInstance();
        if(interceptor.before(proxy,target,method,args)) {
            result = method.invoke(target, args);
        }else {
            interceptor.around(proxy, args, method, args);
        }
        interceptor.after(proxy, args, method, args);
        return result;
    }

}

InterceptorJdkProxy 和 ProxyJdkExample 的区别在于，我们会做一次判断来决定是继续执行原有的 Impl 的方法，还是执行拦截器自己的方法。另外，在执行方法前后都会有一个操作。

现在我们将原来 ProxyJdkTest 代码的 ProxyJdkExample  换成 InterceptorJdkProxy：

package SSMTest.JProxyTest;

public class ProxyJdkTest {

    public static void main(String[] args) {
        ProxyService proxy = (ProxyService) InterceptorJdkProxy.bind(new ProxyServiceImpl(),"SSMTest.JProxyTest.MyInterceptor");
        proxy.HelloWorld();
    }

}
/*output
=====================proxy before ============================
=====================proxy aroud ============================
=====================proxy after ============================
*/

通过代理的方式，我们将原来的简单的 HelloWorld() 方法的调用拦截，并且按照我们的方式进行的新的操作。