基于JDK动态代理的自定义拦截器

由于JDK动态代理比较难以理解，程序设计者会设计一个拦截器接口供开发者使用，开发者只需要知道拦截器接口的方法和含义以及作用即可使用，无需知道动态代理是如何实现的。本文介绍基于JDK动态代理实现一个简单的拦截器。

第一步：定义拦截器接口

package com.lemon.designmode.interfaces;

import java.lang.reflect.Method;

/**
 * @author lemon
 * @date 2018/2/12 上午10:35
 */
public interface Interceptor {

    boolean before(Object proxy, Object target, Method method, Object[] args);

    void around(Object proxy, Object target, Method method, Object[] args);

    void after(Object proxy, Object target, Method method, Object[] args);

}

接口中定义了三个方法，分别是：前置方法、后置方法和环绕方法（此叫法类似Spring AOP中的前置通知、后置通知以及环绕通知）。三个方法拥有相同的参数：第一个参数是动态代理对象，第二个是真实服务对象，第三个是方法对象，第四个是方法需要的参数集合。

• before方法返回boolean值，它在真实对象调用前调用，当返回true时，则反射真实对象的方法，当返回false时，则调用around方法。
• 当before方法返回false时，则调用around方法。
• 在反射真实对象方法或者around方法执行之后，调用after方法。

第二步：实现拦截器接口

package com.lemon.designmode.bean;

import com.lemon.designmode.interfaces.Interceptor;

import java.lang.reflect.Method;

/**
 * @author lemon
 * @date 2018/2/12 上午10:41
 */
public class MyInterceptor implements Interceptor {

    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法前逻辑...");
        return false;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("取代了被代理对象的方法...");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法后逻辑...");
    }
}

上面的代码实现了拦截器所有方法，使用JDK动态代理就可以去实现这些方法在适当时候调用的逻辑了。

第三步：在JDK动态代理中使用拦截器

package com.lemon.designmode.proxy;

import com.lemon.designmode.interfaces.Interceptor;
import lombok.Data;

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

/**
 * @author lemon
 * @date 2018/2/12 上午11:08
 */
@Data
public class InterceptorJdkProxy implements InvocationHandler {

    private Object target;
    private String interceptorClass;

    private 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)) {
            // 判断为true则反射原有方法
            result = method.invoke(target, args);
        } else {
            // 判断为false则使用拦截器方法
            interceptor.around(proxy, target, method, args);
        }
        // 调用后置放啊
        interceptor.after(proxy, target, method, args);
        return result;
    }
}

这里的@Data注解是lombok的注解，主要作用是动态生成JavaBean的Getter和Setter方法。上面的代码主要是JDK动态代理的知识，不懂的可以去参考一下之前的博客。

第四步：测试MyInterceptor拦截器

定义一个真实服务类用于测试。由于采用的是JDK动态代理，这个真实服务类必须实现一个接口。代码如下：

package com.lemon.designmode.interfaces;

/**
 * @author lemon
 * @date 2018/2/11 上午10:25
 */
public interface HelloWorld {

    void sayHello();

    void sayHi();
}

实现类是：

package com.lemon.designmode.bean;

import com.lemon.designmode.interfaces.HelloWorld;

/**
 * @author lemon
 * @date 2018/2/11 上午10:23
 */
public class HelloWorldImpl implements HelloWorld {

    @Override
    public void sayHello() {
        System.out.println("向Java世界问好...");
    }

    @Override
    public void sayHi() {
        System.out.println("向JDK动态代理问好...");
    }
}

测试类为：

package com.lemon.designmode.test;

import com.lemon.designmode.bean.HelloWorldImpl;
import com.lemon.designmode.interfaces.HelloWorld;
import com.lemon.designmode.proxy.InterceptorJdkProxy;

/**
 * @author lemon
 * @date 2018/2/12 下午12:07
 */
public class InterceptorJdkProxyTest {

    public static void main(String[] args) {
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),
                "com.lemon.designmode.bean.MyInterceptor");
        proxy.sayHello();
    }
}

运行结果如下：

反射方法前逻辑...
取代了被代理对象的方法...
反射方法后逻辑...

由于我人为是before方法返回的是false，所以真实的服务方法被替代了。

请移步参考JDK动态代理和CGLIB动态代理。