Java动态代理之拦截器的应用
由于动态代理一般都比较难理解，程序设计者会设计一个拦截器接口供开发者使用，开发者只要知道拦截器接口的方法、含义和作用即可，无须知道动态代理是怎么实现的。用JDK动态代理来实现一个拦截器的逻辑，为此先定义拦截器接口Interceptor，如下所示：
/**
*@Auther:haozz
*@Date:2018/5/2722:15
*@Description:拦截器接口
**/
publicinterfaceInterceptor{
booleanbefore(Objectproxy,Objecttarget,Methodmethod,Object[]args);
voidaround(Objectproxy,Objecttarget,Methodmethod,Object[]args);
voidafter(Objectproxy,Objecttarget,Methodmethod,Object[]args);
}
这里定义了3个方法，before、around、after方法，分别给予这些方法如下逻辑定义：
- 3个方法的参数为：proxy代理对象、target真实对象、method方法、args运行方法参数；
- before方法返回boolean值，它在真实对象前调用。当返回为true时，则反射真实对象的方法；当返回为false时，则调用around方法；
- 在before方法返回为false的情况下，调用around方法
- 在反射真实对象方法或者around方法执行之后，调用after方法
实现这个Interceptor的实现类——MyInterceptor，如下：
/**
*@Auther:haozz
*@Date:2018/5/2722:48
*@Description:MyInterceptor
**/
publicclassMyInterceptorimplementsInterceptor{
@Override
publicbooleanbefore(Objectproxy,Objecttarget,Methodmethod,Object[]args){
System.out.println("反射方法前逻辑");
returnfalse;//不反射被代理对象原有方法
}
@Override
publicvoidaround(Objectproxy,Objecttarget,Methodmethod,Object[]args){
System.out.println("取代了被代理对象的方法");
}
@Override
publicvoidafter(Objectproxy,Objecttarget,Methodmethod,Object[]args){
System.out.println("反射方法后逻辑");
}
}
它实现了所有Interceptor接口的方法，使用JDK动态代理，就可以去实现这些方法在适当时的调用逻辑了。以上一篇（Java设计模式之动态代理）中的接口和实现类为例，在JDK动态代理中使用拦截器，如下所示：
/**
*@Auther:haozz
*@Date:2018/5/2722:30
*@Description:
**/
publicclassInterceptorJdkProxyimplementsInvocationHandler{
privateObjecttarget;//真实对象
privateStringinterceptorClass=null;//拦截器全限定名
publicInterceptorJdkProxy(Objecttarget,StringinterceptorClass){
this.target=target;
this.interceptorClass=interceptorClass;
}
publicstaticObjectbind(Objecttarget,StringinterceptorClass){
//取得代理对象
returnProxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
newInterceptorJdkProxy(target,interceptorClass));
}
@Override
/**
*Description:通过代理对象调用方法，首先进入这个方法
*@auther:haozz
*@param:proxy代理对象
*@param:method被调用方法
*@param:args方法的参数
*@return:java.lang.Object
*@date:2018/5/2723:00
**/
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
if(interceptorClass==null){
//没有设置拦截器则直接反射原有方法
returnmethod.invoke(target,args);
}
Objectresult=null;
//通过反射生成拦截器
Interceptorinterceptor=(Interceptor)Class.forName(interceptorClass).newInstance();
//调用前置方法
if(interceptor.before(proxy,target,method,args)){
//反射原有对象方法
result=method.invoke(target,args);
}else{//返回false执行around方法
interceptor.around(proxy,target,method,args);
}
//调用后置方法
interceptor.after(proxy,target,method,args);
returnresult;
}
}
这里有两个属性，一个是target，它是真实对象；另一个是字符串interceptorClass，它是一个拦截器的全限定名。解释以下这段代码的执行步骤：
第1步，在bind方法中用JDK动态代理绑定了一个对象，然后返回代理对象；
第2步，如果没有设置拦截器，则直接反射真实对象的方法，然后结束，否则进行第3步；
第3步，通过反射生成拦截器，并准备使用它；
第4步，调用拦截器的before方法，如果返回为true，反射原来的方法；否则运行拦截器的around方法；
第5步，调用拦截器的after方法；
第6步，返回结果。
- 开发者只要知道拦截器的作用就可以编写拦截器了，编写完后可以设置拦截器，这样就完成了任务，所以对于开发者而言相对简单了
- 设计者可能是精通Java的开发人员，他来完成动态代理的逻辑
- 设计者只会把拦截器接口暴露给开发者使用，让动态代理的逻辑在开发者的视野中“消失”
拦截器可以进一步简化动态代理的使用方法，使程序变得更简单，用如下的测试类测试一下：
publicclassMytest{
publicstaticvoidmain(String[]args){
HelloWorldproxy1=(HelloWorld)InterceptorJdkProxy.bind(newHelloWorldImpl(),"com.csdn.blog.interceptor.MyInterceptor");
proxy1.sayHelloWorld();
}
}
运行这段代码，得到以下结果：
反射方法前逻辑
取代了被代理对象的方法
反射方法后逻辑
显然，拦截器已经生效。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对毛票票的支持。如果你想了解更多相关内容请查看下面相关链接