Spring AOP概念术语的通俗理解

AOP详细全面的知乎讲解
1.我所知道的aop
　　初看aop,上来就是一大堆术语，而且还有个拉风的名字，面向切面编程，都说是OOP的一种有益补充等等。一下子让你不知所措，心想着：怪不得很多人都和我说aop多难多难。当我看进去以后，我才发现：它就是一些java基础上的朴实无华的应用，包括ioc，包括许许多多这样的名词，都是万变不离其宗而已。

2.为什么用aop
　　1)就是为了方便，看一个国外很有名的大师说，编程的人都是“懒人”，因为他把自己做的事情都让程序做了。用了aop能让你少写很多代码，这点就够充分了吧
　　2)就是为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，这些其他的事情包括：安全，事物，日志等。

3.那些aop的术语
　　初看这么多术语，一下子都不好接受，慢慢来，很快就会搞懂。

1.通知（Advice）

就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。

2.连接点（JoinPoint）

这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

3.切入点（Pointcut）

上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

4.切面（Aspect）

切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

5.引入（introduction）
允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

6.目标（target）

引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

7.代理(proxy)

怎么实现整套aop机制的，都是通过代理，这个一会给细说。

8.织入(weaving)

把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。

关键就是：切点定义了哪些连接点会得到通知

4.我所理解的aop原理
　　spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。

现在可以自己想一想，怎么搞出来这个伪装类，才不会被调用者发现（过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。
　　1.实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事物等）。

这就好比，一个人让你办件事，每次这个时候，你弟弟就会先出来，当然他分不出来了，以为是你，你这个弟弟虽然办不了这事，但是他知道你能办，所以就答应下来了，并且收了点礼物（写日志），收完礼物了，给把事给人家办了啊，所以你弟弟又找你这个哥哥来了，最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了，你只是专心把这件事情做好。

顺着这个思路想，要是本身这个类就没实现一个接口呢，你怎么伪装我，我就压根没有机会让你搞出这个双胞胎的弟弟，那么就用第2种代理方式，创建一个目标类的子类，生个儿子，让儿子伪装我
　　2.生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，我继承的吗，当然查不出来了，子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）。

这次的对比就是，儿子先从爸爸那把本事都学会了，所有人都找儿子办事情，但是儿子每次办和爸爸同样的事之前，都要收点小礼物（写日志），然后才去办真正的事。当然爸爸是不知道儿子这么干的了。这里就有件事情要说，某些本事是爸爸独有的(final的)，儿子学不了，学不了就办不了这件事，办不了这个事情，自然就不能收人家礼了。

前一种兄弟模式，spring会使用JDK的java.lang.reflect.Proxy类，它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。

后一种父子模式，spring使用CGLIB库生成目标类的一个子类，在创建这个子类的时候，spring织入通知，并且把对这个子类的调用委托到目标类。

相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。

简单例子：
　　　　可能直接说会很模糊，这里我先做了一个小例子：直接上代码
　　　　
//描述切面类
@Aspect
@Configuration
public class TestAop {

/*
 * 定义一个切入点
 */
// @Pointcut("execution (* findById*(..))")
@Pointcut("execution(* com.test.service.CacheDemoService.find*(..))")
public void excudeService(){}
/*
 * 通过连接点切入
 */
@Before("execution(* findById*(..)) &&" + "args(id,..)")
public void twiceAsOld1(Long id){
    System.err.println ("切面before执行了。。。。id==" + id);

}

@Around("excudeService()")
public Object twiceAsOld(ProceedingJoinPoint thisJoinPoint){
    System.err.println ("切面执行了。。。。");
    try {
        Thing thing = (Thing) thisJoinPoint.proceed ();
        thing.setName (thing.getName () + "=========");
        return thing;
    } catch (Throwable e) {
        e.printStackTrace ();
    }
    return null;
}

}

看上面的例子就是实现了一个切面，其中有一些特殊的东西，下面一一解释：

6.使用的注解：
　　@Aspect:描述一个切面类，定义切面类的时候需要打上这个注解

@Configuration：spring-boot配置类
　　 1. @Pointcut：声明一个切入点，切入点决定了连接点关注的内容，使得我们可以控制通知什么时候执行。Spring AOP只支持Spring bean的方法执行连接点。所以你可以把切入点看做是Spring bean上方法执行的匹配。一个切入点声明有两个部分：一个包含名字和任意参数的签名，还有一个切入点表达式，该表达式决定了我们关注那个方法的执行。
　　 注：作为切入点签名的方法必须返回void 类型
　　 Spring AOP支持在切入点表达式中使用如下的切入点指示符:
　　 execution - 匹配方法执行的连接点，这是你将会用到的Spring的最主要的切入点指示符。
　　 within - 限定匹配特定类型的连接点（在使用Spring AOP的时候，在匹配的类型中定义的方法的执行）。
　　 this - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中bean reference（Spring AOP 代理）是指定类型的实例。
　　 target - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中目标对象（被代理的应用对象）是指定类型的实例。
　　 args - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中参数是指定类型的实例。
　　 @target - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中正执行对象的类持有指定类型的注解。
　　 @args - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中实际传入参数的运行时类型持有指定类型的注解。
　　 @within - 限定匹配特定的连接点，其中连接点所在类型已指定注解（在使用Spring AOP的时候，所执行的方法所在类型已指定注解）。
　　 @annotation - 限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中连接点的主题持有指定的注解。

     其中execution使用最频繁，即某方法执行时进行切入。定义切入点中有一个重要的知识，即切入点表达式，我们一会在解释怎么写切入点表达式。

切入点意思就是在什么时候切入什么方法，定义一个切入点就相当于定义了一个“变量”，具体什么时间使用这个变量就需要一个通知。

即将切面与目标对象连接起来。

如例子中所示，通知均可以通过注解进行定义，注解中的参数为切入点。

spring aop支持的通知：
　　@Before：前置通知：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
　　@AfterReturning ：后置通知：在某连接点正常完成后执行的通知，通常在一个匹配的方法返回的时候执行。
　　可以在后置通知中绑定返回值，如：　　　　　　　　
　　
@AfterReturning（
pointcut=com.test.service.CacheDemoService.findById(…))",
returning=“retVal”）
public void doFindByIdCheck（Object retVal） {
// …
}
@AfterThrowing:异常通知：在方法抛出异常退出时执行的通知。　　　　　　　
@After 最终通知。当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
@Around：环绕通知：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。
环绕通知最麻烦，也最强大，其是一个对方法的环绕，具体方法会通过代理传递到切面中去，切面中可选择执行方法与否，执行方法几次等。

环绕通知使用一个代理ProceedingJoinPoint类型的对象来管理目标对象，所以此通知的第一个参数必须是ProceedingJoinPoint类型，在通知体内，调用ProceedingJoinPoint的proceed()方法会导致后台的连接点方法执行。proceed 方法也可能会被调用并且传入一个Object[]对象-该数组中的值将被作为方法执行时的参数。

7.通知参数
　　任何通知方法可以将第一个参数定义为org.aspectj.lang.JoinPoint类型（环绕通知需要定义第一个参数为ProceedingJoinPoint类型，它是 JoinPoint 的一个子类）。JoinPoint接口提供了一系列有用的方法，比如 getArgs()（返回方法参数）、getThis()（返回代理对象）、getTarget()（返回目标）、getSignature()（返回正在被通知的方法相关信息）和 toString()（打印出正在被通知的方法的有用信息）

有时候我们定义切面的时候，切面中需要使用到目标对象的某个参数，如何使切面能得到目标对象的参数。

从例子中可以看出一个方法：

使用args来绑定。如果在一个args表达式中应该使用类型名字的地方 使用一个参数名字，那么当通知执行的时候对应的参数值将会被传递进来。

@Before(“execution(* findById*(…)) &&” + “args(id,…)”)
public void twiceAsOld1(Long id){
System.err.println (“切面before执行了。。。。id==” + id);

}

复制代码
@Around（“execution（List find*（…）） &&” +
"com.xyz.myapp.SystemArchitecture.inDataAccessLayer（） && " +
“args（accountHolderNamePattern）”）
public Object preProcessQueryPattern（ProceedingJoinPoint pjp, String accountHolderNamePattern）
throws Throwable {
String newPattern = preProcess（accountHolderNamePattern）;
return pjp.proceed（new Object[] {newPattern}）;
}
复制代码

8.切入点表达式
　　现在我们介绍一下最重要的切入点表达式：

如上文所说，定义切入点时需要一个包含名字和任意参数的签名，还有一个切入点表达式，就是* findById*(…)这一部分。

切入点表达式的格式：execution([可见性] 返回类型 [声明类型].方法名(参数) [异常])

其中【】中的为可选，其他的还支持通配符的使用:

*：匹配所有字符
…：一般用于匹配多个包，多个参数
+：表示类及其子类

运算符有：&&、||、!

切入点表达式关键词：

1）execution：用于匹配子表达式。

        //匹配com.cjm.model包及其子包中所有类中的所有方法，返回类型任意，方法参数任意
        @Pointcut("execution(* com.cjm.model..*.*(..))")

        public void before(){}



  2）within：用于匹配连接点所在的Java类或者包。

        //匹配Person类中的所有方法
        @Pointcut("within(com.cjm.model.Person)")
        public void before(){}



        //匹配com.cjm包及其子包中所有类中的所有方法

        @Pointcut("within(com.cjm..*)")
        public void before(){}



 3） this：用于向通知方法中传入代理对象的引用。
        @Before("before() && this(proxy)")
        public void beforeAdvide(JoinPoint point, Object proxy){
              //处理逻辑
        }



  4）target：用于向通知方法中传入目标对象的引用。
        @Before("before() && target(target)
        public void beforeAdvide(JoinPoint point, Object proxy){
              //处理逻辑
        }



  5）args：用于将参数传入到通知方法中。
        @Before("before() && args(age,username)")
        public void beforeAdvide(JoinPoint point, int age, String username){
              //处理逻辑
        }

  6）@within ：用于匹配在类一级使用了参数确定的注解的类，其所有方法都将被匹配。 

        @Pointcut("@within(com.cjm.annotation.AdviceAnnotation)") － 所有被@AdviceAnnotation标注的类都将匹配
        public void before(){}

  7）@target ：和@within的功能类似，但必须要指定注解接口的保留策略为RUNTIME。
        @Pointcut("@target(com.cjm.annotation.AdviceAnnotation)")
        public void before(){}



  8）@args ：传入连接点的对象对应的Java类必须被@args指定的Annotation注解标注。
        @Before("@args(com.cjm.annotation.AdviceAnnotation)")
        public void beforeAdvide(JoinPoint point){
              //处理逻辑
        }

  9）@annotation ：匹配连接点被它参数指定的Annotation注解的方法。也就是说，所有被指定注解标注的方法都将匹配。
        @Pointcut("@annotation(com.cjm.annotation.AdviceAnnotation)")
        public void before(){}

  10）bean：通过受管Bean的名字来限定连接点所在的Bean。该关键词是Spring2.5新增的。
        @Pointcut("bean(person)")
        public void before(){}