由于
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，所以真实的服务方法被替代了。
