版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/SunnyYoona/article/details/50655462
切点用于准确定位应该在什么地方应用切面的通知。切点和通知是切面的最基本元素。
在Spring AOP中，需要使用AspectJ的切点表达式语言来定义切点。关于Spring AOP的AspectJ切点，最重要的一点是Spring仅支持AspectJ切点指示器的一个子集。
| 类型 | 说明 |
|---|---|
| arg() | 限制连接点匹配参数为指定类型的执行方法。 |
| @args() | 限制连接点匹配参数由指定注解标注的执行方法。 |
| execution() | 用于匹配的是连接点的执行方法。 |
| this() | 限制连接点匹配AOP代理的Bean引用为指定类型的类。 |
| target() | 限制连接点匹配目标对象为指定类型的类。 |
| @target() | 限制连接点匹配特定的执行对象，这些对象对应的类具备指定类型的注解。 |
| within() | 限制连接点匹配指定的类型。 |
| @within() | 限制连接点匹配指定注解所标注的类型（当使用Spring AOP时，方法定义再由指定的注解所标注的类里）。 |
| @annotation | 限制匹配带有指定注解连接点。 |
在Spring中尝试使用AspectJ其他指示器时，将会抛出IllegalArgumentException异常。
注意：
只有execution指示器是唯一的执行匹配，而其他的指示器都是用于限制匹配的。这说明execution指示器是我们在编写切点定义时最主要的指示器。在此基础上，我们使用其他指示器来限制所匹配的切点。 |
1. 编写切点
如下图所示的切点表达式表示当Singer的perform()方法执行时会触发通知。我们使用execution()指示器选择Singer的perform()方法。
方法表达式以*号开始，标示了我们不关心返回值的类型。然后，我们
指定了全限定类名和方法名。对于
方法参数列表，我们使用（..）标示切点选择任意的perform()方法，无论该方法的参数是什么。
除此之外，我们还可以对上面的匹配进行限制，可以使用
within()指示器来限制匹配。
我们使用&&操作符把execution()和within()指示器连接在一起形成and关系（切点必须匹配所有的指示器）。
2. 在XML中声明切面
Spring的AOP配置元素简化了基于POJO切面的声明：
| 类型 | 说明 |
|---|---|
| <aop:advisor> | 定义AOP通知器。 |
| <aop:after> | 定义AOP后置通知（不管被通知的方法是否执行成功） |
| <aop:after-returning> | 定义AOP after-returning通知。 |
| <aop:after-throwing> | 定义 AOP after-throwing 通知。 |
| <aop:around> | 定义 AOP 环绕通知。 |
| <aop:aspect> | 定义切面。 |
| <aop:aspectj-autoproxy> | 启用@AspectJ注解驱动的切面。 |
| <aop:before> | 定义 AOP前置通知。 |
| <aop:config> | 顶层的AOP配置元素。大多数的<aop:*>元素必须包含在<aop:config>元素内。 |
| <aop:declare-parents> | 为被通知的对象引入额外的接口，并透明的实现。 |
| <aop:pointcut> | 定义切点。 |
为了阐述Spring AOP，我们创建一个观众类（Audience）类：
package com.sjf.bean;
/**
* 观众类
* @author sjf0115
*
*/
public class Audience {
public void takeSeats(){
System.out.println("the audience is taking their seats...");
}
public void applaud(){
System.out.println("very good, clap clap clap...");
}
public void demandRefund(){
System.out.println("very bad, We want our money back...");
}
}
Audience类并没有任何特别之处，她就是一个有几个方法的简单Java类。我们可以像其他类一样，利用XML把它注册为Spring应用上下文中的一个Bean：
<bean id = "audience" class = "com.sjf.bean.Audience">
</bean>
我们需要Spring AOP就能把它成为一个切面。
2.1 前置声明和后置声明
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<bean id = "singer" class = "com.sjf.bean.Singer">
</bean>
<bean id = "audience" class = "com.sjf.bean.Audience">
</bean>
<aop:config proxy-target-class="true">
<!-- 声明定义一个切面 -->
<aop:aspect ref = "audience">
<!-- 表演之前 -->
<aop:before method="takeSeats" pointcut="execution(* com.sjf.bean.Singer.perform(..))"/>
<!-- 表演之后 -->
<aop:after-returning method="applaud" pointcut="execution(* com.sjf.bean.Singer.perform(..))"/>
<!-- 表演失败之后 -->
<aop:after-throwing method="demandRefund" pointcut="execution(* com.sjf.bean.Singer.perform(..))"/>
</aop:aspect>
</aop:config>
</beans>
大多数的AOP配置元素必须在<aop:config>元素的上下文内使用。这条规则有几种例外场景，但是把Bean声明为一个切面时，我们总是从<aop:config>元素开始配置。
在<aop:config>元素内，我们可以声明一个或者多个通知器，切面或者切点。上述例子中，我们使用
<aop:aspect>元素声明了一个简单的切面。ref元素引用了一个Bean（Audience），该Bean实现了切面的功能。
ref元素应用的Bean提供了在切面上通知所调用的方法。
该切面应用了3个不同的通知。
<aop:before>元素定义了匹配切点的方法执行之前调用前置通知方法，audience Bean 的takeSeats()方法。
<aop:after-returning>元素定义了一个返回后（after-returning）通知，在切点所匹配的方法调用之后在执行applaud()方法。
<aop:after-throwing>元素定义了抛出异常后通知，如果所有匹配的方法执行时抛出任何异常，都将调用demandRefund()方法。
下面展示了通知逻辑如何嵌入到业务逻辑中：
在所有的通知元素中，
pointcut属性定义了通知所应用的切点。pointcut属性的值是使用AspectJ切点表达式语法所定义的切点。
你或许注意到所有通知元素中的pointcut属性的值都是一样的，这是因为所有的通知都是应用到相同的切点上。这似乎违反了DRY（不要重复你自己）原则。我们做一下修改，可以
使用<aop:pointcut>元素定义一个命名切点。
<aop:config proxy-target-class="true">
<!-- 声明定义一个切面 -->
<aop:aspect ref = "audience">
<aop:pointcut id="singerPerfom" expression="execution(* com.sjf.bean.Singer.perform(..))" />
<!-- 表演之前 -->
<aop:before method="takeSeats" pointcut-ref="singerPerfom"/>
<!-- 表演之后 -->
<aop:after-returning method="applaud" pointcut-ref="singerPerfom"/>
<!-- 表演失败之后 -->
<aop:after-throwing method="demandRefund" pointcut-ref="singerPerfom"/>
</aop:aspect>
</aop:config>
<aop:pointcut>元素定义了一个id为singerPerfom的切点，同时修改所有的通知元素，
用pointcut-ref属性来引用这个命名切点。
2.2 声明环绕通知
如果不适用成员变量存储信息，那么在前置通知和后置通知之间共享信息是非常麻烦的。我们希望实现这样一个功能：希望观众一直关注演出，并报告演出的演出时长。使用前置通知和后置通知实现该功能的唯一方式是：在前置通知中记录开始时间，并在某个后置通知中报告演出的时长。但这样的话，我们必须在一个成员变量中保存开始时间。因此我们可以使用环绕通知，只需在一个方法中实现即可。
public void PerformTime(ProceedingJoinPoint joinPoint){
// 演出之前
System.out.println("the audience is taking their seats...");
try {
long start = System.currentTimeMillis();
// 执行演出操作
joinPoint.proceed();
long end = System.currentTimeMillis();
// 演出成功
System.out.println("very good, clap clap clap...");
System.out.println("该演出共需要 "+(end - start) + " milliseconds");
} catch (Throwable e) {
// 演出失败
System.out.println("very bad, We want our money back...");
e.printStackTrace();
}
}
对于这个新的通知方法，我们会注意到它使用了ProceedingJoinPoint作为方法的入参。这个对象非常重要，因为它能
让我们在通知里调用被通知 的方法。如果希望把控制转给被通知的方法时，我们可以调用
ProceedingJoinPoint的proceed()方法。如果忘记调用proceed()方法，通知将会阻止被通知方法的调用。我们还可以在通知里多次调用被通知方法，这样做的一个目的是实现重试逻辑，在被通知的方法执行失败时反复重试。
PerformTime()方法包含了之前3个通知方法的所有逻辑，并且该方法还会负责自身的异常处理。声明环绕通知与声明其他类型的通知并没有太大的区别，只需要<aop:around>元素。
<aop:config proxy-target-class="true">
<!-- 声明定义一个切面 -->
<aop:aspect ref = "audience">
<aop:pointcut id="singerPerfom" expression="execution(* com.sjf.bean.Singer.perform(..))" />
<!-- 声明环绕通知 -->
<aop:around method="performTime" pointcut-ref="singerPerfom"/>
</aop:aspect>
</aop:config>
运行结果：
the audience is taking their seats...
正在上演个人演唱会...
very good, clap clap clap...
该演出共需要 37 milliseconds |
像其他通知的XML一样，<aop:around>指定了一个切点和一个通知方法的名字。
2.3 为通知传递参数
到目前为止，我们的切面很简单，没有任何的参数。但是有时候通知并不是仅仅是对方法进行简单包装，还需要校验传递给方法的参数值，这时候为通知传递参数就非常有用了。
下面是歌手的实体类：
package com.sjf.bean;
/**
* 歌手实体类
* @author sjf0115
*
*/
public class Singer {
public void perform(String songName) {
System.out.println("正在上演个人演唱会，演唱曲目为 " + songName);
}
}
在这我们提供了一个Organizers（主办方）实体类，在歌手演唱之前截获歌手演唱的曲目，然后通知给大家：
package com.sjf.bean;
/**
* 主办方实体类
* @author sjf0115
*
*/
public class Organizers {
public void BeforeSong(String songName){
System.out.println("演唱会马上就开始了，演唱歌曲为 " + songName);
}
public void AfterSong(){
System.out.println("演唱曲目结束，谢谢大家...");
}
}
我们像以前一样使用<aop:aspect>，<aop:before>和<aop:after>元素。但是这次我们
通过配置实现将被通知方法的参数传递给通知。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<bean id = "singer" class = "com.sjf.bean.Singer">
</bean>
<bean id = "Organizers" class = "com.sjf.bean.Organizers">
</bean>
<aop:config>
<!-- 声明定义一个切面 -->
<aop:aspect ref = "Organizers">
<aop:pointcut id="singerPerform" expression="execution(* com.sjf.bean.Singer.perform(String)) and args(song)" />
<aop:pointcut id="singerPerform2" expression="execution(* com.sjf.bean.Singer.perform(..))" />
<aop:before method="BeforeSong" pointcut-ref="singerPerform" arg-names="song"/>
<aop:after-returning method="AfterSong" pointcut-ref="singerPerform2"/>
</aop:aspect>
</aop:config>
</beans>
关键之处在于切点定义和<aop:before>的arg-names属性。切点标示了Singer的perform()方法，指定了String参数。然后在args参数中标示了song作为参数。同样，
<aop:before>元素引用了切点中
song参数，标示该参数必须传递给Organizers的BeforeSong()方法。
运行结果：
演唱会马上就开始了，演唱歌曲为 你是我的眼泪
正在上演个人演唱会，演唱曲目为 你是我的眼泪
演唱曲目结束，谢谢大家... |
来源于：《Spring实战》
