Groovy探索之MOP 十三 Interceptor 三（2）
Groovy探索之MOP 十三 Interceptor 三（2）
其实，阻止拦截的使用像在《Groovy探索之MOP 十三 Interceptor 三（1）》中的最后一个例子那像的使用并不多，更多的是在使用拦截器的客户那里决定是否使用拦截器。还是上一篇的那个例子：
class Hello {
def hello(name)
{
"hello,$name"
}
}
我们现在明确的把类中所有的方法进行拦截，拦截器如下：
class AllInterceptor implements Interceptor{
Object beforeInvoke(Object object, String methodName, Object[] arguments){
println "the function-$methodName is intercepted"
}
boolean doInvoke(){ true }
Object afterInvoke(Object object, String methodName, Object[] arguments,
Object result){
result
}
}
在上面的拦截器中，我们在“beforeInvoke”方法中拦截了被拦截对象中的所有方法，打印出哪个方法被拦截的提示出来。
比如，我们做如下的测试代码：
def proxy= ProxyMetaClass.getInstance( Hello )
proxy.interceptor= new AllInterceptor()
proxy.use{
def hello = new Hello()
hello.hello('World')
}
运行结果为：
the function-ctor is intercepted
the function-hello is intercepted
表示已经有了两个方法被拦截。现在，我们的客户端不想拦截“hello”方法，在这里我们就可以使用阻止拦截了：
def proxy= ProxyMetaClass.getInstance( Hello )
proxy.interceptor= new AllInterceptor()
proxy.use{
def hello = new Hello()
hello.&hello('World')
}
运行结果为：
the function-ctor is intercepted
这样就没有对“hello”方法进行拦截。
我们还是需要回忆一下上一篇中遇到的嵌套拦截的问题，即在拦截器中又调用了需要被拦截的那个方法，形成了嵌套拦截的问题。我们在上一篇中的解决方法是使用“&”标识符进行阻止拦截。使用“&”标识符毕竟只能阻止少量的方法进行嵌套拦截，在实际的使用中不是很方便，为了解决这个问题，我们也有一个一劳永逸的解决办法。即我们可以创建一个阻止嵌套拦截器类，让继承它的所有拦截器具备有阻止嵌套拦截的能力。
这个基类如下：
abstract class UninterceptedInterceptor implements Interceptor{
def proxy= null
abstract Object doBefore( Object object, String methodName,
Object[] arguments )
public Object beforeInvoke( Object object, String methodName,
Object[] arguments ){
proxy.interceptor= null
def result
try{
result= doBefore(object, methodName, arguments)
}catch(Exception e){
throw e
}finally{
proxy.interceptor= this
}
result
}
abstract boolean doInvoke()
abstract Object doAfter( Object object, String methodName, Object[] arguments,
Object result )
public Object afterInvoke( Object object, String methodName,
Object[] arguments, Object result ){
proxy.interceptor= null
try{
result= doAfter(object, methodName, arguments, result)
}catch(Exception e){
throw e
}finally{
proxy.interceptor= this
}
result
}
}
这个基类很简单，可以放到我们的工具包里去。我们只看“beforeInvoke”方法，思想就是，我们的拦截动作都放在“doBefore”方法里，同时，在执行“doBefore”方法的时候，我们使用如下的语句将拦截器去掉：
proxy.interceptor= null
当“doBefore”方法完了以后，我们再把拦截器加上，使用下面的语句：
proxy.interceptor= this
这样，我们需要进行嵌套拦截的类就继承该类，如下：
class MyInterceptor extends UninterceptedInterceptor{
Object doBefore( Object object, String methodName,
Object[] arguments )
{
}
boolean doInvoke()
{
true
}
Object doAfter( Object object, String methodName, Object[] arguments,
Object result )
{
if(methodName == 'hello')
{
result = new Hello().hello('log')+'\n'+result
}
result
}
}
这个类就更简单了，在它里面进行了拦截方法的嵌套调用，形如下面的语句：
if(methodName == 'hello')
{
result = new Hello().hello('log')+'\n'+result
}
拦截了“hello”方法，却在里面又进行“hello”方法的调用，一个很明显的嵌套调用。
最后，我们来写点代码测试这个阻止拦截的拦截器：
def proxy= ProxyMetaClass.getInstance( Hello )
proxy.interceptor = new MyInterceptor()
proxy.interceptor.proxy = proxy
proxy.use{
def hello = new Hello()
println hello.hello('World')
}
这也和其他的测试代码大致相似，唯一不同的是下面的语句：
proxy.interceptor.proxy = proxy
它需要我们给Interceptor对象的“proxy”属性赋值，这在其他的测试代码里是没有的。运行结果为：
hello,log
hello,World
的确起到了阻止拦截的效果。