转载

Spring AOP不拦截从对象内部调用的方法

拦截器的实现原理很简单,就是动态代理,实现AOP机制。当外部调用被拦截bean的拦截方法时,可以选择在拦截之前或者之后等条件执行拦截方法之外的逻辑,比如特殊权限验证,参数修正等操作。

但是最近在项目中要在一个事务中跨数据源进行操作。数据库跨源就不在这里说了,可以自行百度。

这里出现的问题就是,如果我们要拦截某个类的多个方法,且在该类的方法中使用this调用要拦截的方法时会导致拦截失败。

这样说有点抽象,看一个代码:

package com.intsmaze.before;

public class AopDemo
{

/**
     * controller层调用的逻辑service方法,该方法内部调用分别访问不同数据库的service方法
     */
public void findInforAll ()
{
this.findDataBaseA();
this.findDataBaseB();
}
   /**
     * 这里我们就查询A数据库的某张表好了
     */
public void findDataBaseA ()
{

}
    /**
     *  这里我们就查询B数据库的某张表好了
     */
public void findDataBaseB ()
{

}

}

然后我们使用spring的aop写一个进行切入的类,该类主要就是在执行 findDataBaseAfindDataBaseB前执行某些代码来告知后面的查询操作查询数据库的地址。

@Aspect
public class AuthAspect
{
    // 匹配 com.intsmaze.before 包下 AopDemo 类的
    // 所有方法的执行作为切入点
    @Before("execution(* com.intsmaze.before. AopDemo .*(..))")
public void authority ()
{
System.out.println("模拟执行权限检查");
}
}

接下来我就以比喻进行说明了,明白我的比喻的前提你要知道动态代理是什么,打个不恰当的比方吧,就是动态生成一个新的**类**(注意不是对象)。

这里我们可以这样看当执行 findInforAll 的时候,AOP监测到这个方法是要被拦截的,于是生成了一个代理类,就是一个新的类。

public class AopDemo+其他名称
{

/**
     * controller层调用的逻辑service方法,该方法内部调用分别访问不同数据库的service方法
     */
public void findInforAll ()
{

//---------------------------------------------------

System.out.println("模拟执行权限检查");

//---------------------------------------------------
this.findDataBaseA();
this.findDataBaseB();
}
    /**
     * 这里我们就查询A数据库的某张表好了
     */
public void findDataBaseA ()
{   
}
   /**
     *  这里我们就查询B数据库的某张表好了
     */
public void findDataBaseB ()
{      
}

}

这里我们可以看到,其实生成一个新的类,该类在 findInforAll 方法中第一行加上了AOP指定执行的方法。我们系统中调用的就是这个代理类的 findInforAll 方法,而该方法中的  this.findDataBaseA();this.findDataBaseB();是不会被AOP拦截的,因为AOP拦截的包名和类名很明显和代理类的不一样,所以这就是为什么内部调用的方法无法拦截的原因。不知道这样说,大家懂了没有。关于如何用JDK写动态代理,我会在放假时回顾以前笔记,在写出来。

如何解决呢?我们开始想的时避免AOP切入的类中使用this内部调用,但是发现这样增加了代码结构的复杂度,本来只需要一个类,最后要使用两个类进行管理。太麻烦。

然后考虑项目的进度,就使用把逻辑代码封装成工具方法进行调用。

在网上查资料有方法可以解决,没有测试。

http://blog.csdn.net/quzishen/article/details/5803721下面是主要思路。

在spring的源代码中通过一个增强对象的检查,控制了当前的内部调用是否使用代理来执行,这让人感到无奈。spring的作者们很隐晦的提出避免内部调用的方法。

我们可能会想,在外部调用两次beanA,第一次调用method1,第二次调用method2,这样做可以解决问题,但是这样的直接后果是我们的逻辑代码将变得紊乱,并非所有的场景下都可以通过这样的设计来完成。虽然这是spring官方推荐的避免内部调用的idea。

查看了相关资料,得到了一种方法,即在method1的内部,通过直接获取当前代理对象的方式然后通过代理对象调用method2,这样触发拦截。

看看代码:

public void method1(){           logger.error("1");                      // 如果希望调用的内部方法也被拦截,那么必须用过上下文获取代理对象执行调用,而不能直接内部调用,否则无法拦截           if(null != AopContext.currentProxy()){               ((NorQuickNewsDAO)AopContext.currentProxy()).method2();           }else{               method2();           }              }              public void method2(){           logger.error("2");       }   

我们显示的调用了AopContext来获取当前代理对象,然后调用其方法,这样做还必须的一个步骤是将当前的代理暴露给线程使用,在配置文件中需要配置一个参数:

<property name="exposeProxy">               <value>true</value>           </property>   

它是ProxyConfig的一个参数,默认是false,如果不设置这个参数,那么上述java代码将无法获取当前线程中的代理对象。

这种方法可以成功触发拦截,但是也带来了其他问题,比如代码的织入,我们的代码将变得复杂而且晦涩,而且严格要求系统针对于当前的bean必须配置拦截器,否则会因为找不到拦截器而抛出异常。

这样做有什么负面影响?对事务的影响,对安全的影响,现在不得而知,还需要逐步去测试以尝试。

原文  http://www.cnblogs.com/intsmaze/p/5204133.html
正文到此结束
Loading...