拦截器的实现原理很简单，就是动态代理，实现AOP机制。当外部调用被拦截bean的拦截方法时，可以选择在拦截之前或者之后等条件执行拦截方法之外的逻辑，比如特殊权限验证，参数修正等操作。
但是最近在项目中要在一个事务中跨数据源进行操作。数据库跨源就不在这里说了，可以自行百度。
这里出现的问题就是，如果我们要拦截某个类的多个方法，且在该类的方法中使用this调用要拦截的方法时会导致拦截失败。
原文和作者一起讨论:http://www.cnblogs.com/intsmaze/p/5206584.html
这样说有点抽象，看一个代码：
代码语言：javascript复制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写一个进行切入的类，该类主要就是在执行findDataBaseA和findDataBaseB前执行某些代码来告知后面的查询操作查询数据库的地址。
代码语言：javascript复制@Aspect
public class AuthAspect
{
// 匹配com.intsmaze.before包下AopDemo 类的
// 所有方法的执行作为切入点
@Before("execution(* com.intsmaze.before.AopDemo .*(..))")
public void authority()
{
System.out.println("模拟执行权限检查");
}
}接下来我就以比喻进行说明了，明白我的比喻的前提你要知道动态代理是什么，打个不恰当的比方吧，就是动态生成一个新的**类**(注意不是对象)。
这里我们可以这样看当执行findInforAll的时候，AOP监测到这个方法是要被拦截的，于是生成了一个代理类，就是一个新的类。
代码语言：javascript复制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，这样触发拦截。
看看代码：
代码语言：javascript复制public void method1(){
logger.error("1");
// 如果希望调用的内部方法也被拦截，那么必须用过上下文获取代理对象执行调用，而不能直接内部调用，否则无法拦截
if(null != AopContext.currentProxy()){
((NorQuickNewsDAO)AopContext.currentProxy()).method2();
}else{
method2();
}
}
public void method2(){
logger.error("2");
} 我们显示的调用了AopContext来获取当前代理对象，然后调用其方法，这样做还必须的一个步骤是将当前的代理暴露给线程使用，在配置文件中需要配置一个参数：
代码语言：javascript复制<property name="exposeProxy">
<value>true</value>
</property> 它是ProxyConfig的一个参数，默认是false，如果不设置这个参数，那么上述java代码将无法获取当前线程中的代理对象。
这种方法可以成功触发拦截，但是也带来了其他问题，比如代码的织入，我们的代码将变得复杂而且晦涩，而且严格要求系统针对于当前的bean必须配置拦截器，否则会因为找不到拦截器而抛出异常。
这样做有什么负面影响？对事务的影响，对安全的影响，现在不得而知，还需要逐步去测试以尝试。
