1、AspectJ对AOP的实现
AspectJ 是一个优秀面向切面的框架，它扩展了Java语言，提供了强大的切面实现、实现了AOP的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以、在Spring中使用AOP开发时，一般使用AspectJ的实现方式。
2、AspectJ的通知类型
- 常用的有五种类型：
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知
3、AspectJ的切入点表达式
- AspectJ 定义了专门的表达式用于指定切入点。表达式的原型是：
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
- 解释：
- modifiers-pattern 访问权限类型
- ret-type-pattern 返回值类型
- declaring-type-pattern 包名类名
- name-pattern(param-pattern) 方法名(参数类型和参数个数)
- throws-pattern 抛出异常类型
- ？表示可选的部分
- 以上表达式共 4 个部分。
execution(访问权限 方法返回值 方法声明(参数) 异常类型)
切入点表达式要匹配的对象就是目标方法的方法名。所以，execution 表达式中明显就是方法的签名。注意，表达式中黑色文字表示可省略部分，各部分间用空格分开。在其中可以使用以下符号：
- *：0至多个任意字符
- ..：用在方法参数中、表示任意参数。用在包名后表示当前包及其子包路径。
- +：用在类名后、表示当前类及其子类。用在接口后、表示当前接口以及实现类。
- 举例：
execution(public * *(..))
指定切入点为：任意公共方法。
execution(* set*(..))
指定切入点为：任何一个以“set”开始的方法。
execution(* com.rg.service.*.*(..))
指定切入点为：定义在 service 包里的任意类的任意方法。
execution(* com.rg.service..*.*(..))
指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“..”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类。
execution(* *..service.*.*(..))
指定所有包下的 serivce 子包下所有类（接口）中所有方法为切入点
........................
4、AspectJ的开发环境
- 添加maven依赖：
<!-- 依赖 -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
</dependencies>
<!-- 插件 -->
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
5、AspectJ基于注解的AOP实现
5.1、前置通知@Before -- 目标方法执行之前执行
- 在dao层定义接口和实现类、如下：
//定义接口
public interface SomeService
{
void doSome();
}
//实现类
public class SomeServiceImpl implements SomeService
{
@Override
public void doSome()
{
System.out.println("...........执行了doSome()方法............");
}
}
- 定义切面类、添加前置通知增强方法、如下：
/**
* @Aspect：AspectJ框架的注解、表示当前类是切面类
*/
@Aspect
public class MyAspect
{
/**
* @Before：前置通知、也就是在被切入方法之前执行
* value：表示切入位置、这里的表达式指：任何返回值类型和任何包下的doSome()方法，参数类型和个数也是任意。
* 位置：方法上边
*/
@Before(value = "execution(* *..doSome(..))")
public void before()
{
System.out.println("前置通知、在方法前执行........");
}
}
- 声明目标类对象和切面类对象、如下：
<!--目标类对象、接口实现类、因为在测试方法中需要调用该类中的业务方法-->
<bean id="someService" class="com.rg.dao.impl.SomeServiceImpl"/>
<!--切面类对象-->
<bean id="myAspect" class="com.rg.aspect.MyAspect"/>
- 注册 AspectJ的自动代理、如下：
<!--
定义好切面Aspect后，需要通知Spring容器，让容器生成“目标类+切面”的代理
对象。代理是由容器自动生成的。只需要在 Spring 配置文件中注册一个基于 aspectj 的
自动代理生成器，其就会自动扫描到@Aspect注解，并按通知类型与切入点，将其织入，并
生成代理。
其工作原理是，<aop:aspectj-autoproxy/>通过扫描找到@Aspect 定义的切面类，再由切
面类根据切入点找到目标类的目标方法，再由通知类型找到切入的时间点。
-->
<aop:aspectj-autoproxy/>
- 测试方法：
public class MyTest
{
@Test
public void test01()
{
//指定spring配置文件
String config = "applicationContext.xml";
//创建spring容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//从spring容器中获取对象、使用id
SomeService someService = (SomeService) ctx.getBean("someService");
//执行对象的业务方法
someService.doSome();
}
}
- 控制台输出：
前置通知、在方法前执行........
...........执行了doSome()方法............
5.2、JoinPoint参数
所有的通知方法均可包含一个JoinPoint类型的参数、该类型的对象本身就是切入点表达式。通过该参数，可获取切入点表达式、方法签名、目标对象等。
- 对上边接口和测试方法稍作修改：
//添加两个参数
void doSome(String name,int age);
- 切面方法中通过JoinPoint获取参数信息：
/**
* @Before：前置通知、也就是在被切入方法之前执行 value：表示切入位置、这里的表达式指：任何返回值类型和任何包下的doSome()方法，参数类型和个数也是任意。
* 位置：方法上边
*/
@Before(value = "execution(* *..doSome(..))")
public void before(JoinPoint jp)
{
System.out.println("被织入方法签名：" + jp.getSignature());
System.out.println("被织入方法中的参数数量：" + jp.getArgs().length);
Object argList[] = jp.getArgs();
for (Object arg : argList)
{
System.out.println(arg);
}
System.out.println("前置通知、在方法前执行........");
}
- 测试方法调用业务方法：
@Test
public void test01()
{
//指定spring配置文件
String config = "applicationContext.xml";
//创建spring容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//从spring容器中获取对象、使用id
SomeService someService = (SomeService) ctx.getBean("someService");
//执行对象的业务方法
someService.doSome("Jack",18);
}
- 控制台输出：
被织入方法签名：void com.rg.dao.SomeService.doSome(String,int)
被织入方法中的参数数量：2
Jack
18
前置通知、在方法前执行........
...........执行了doSome()方法............
5.3、后置通知@AfterReturning -- 目标方法执行之后执行
因为在方法后执行，所以可以获取方法的返回值信息、该注解有一个returning属性、就是用于指定接收方法返回值的变量名的、也就是说、在增强方法的参数列表中、除了可以包含JoinPoint参数外，还可以包含用于接收返回值的变量。该变量最好为Object类型，因为目标方法的返回值可能是任何类型。
- 在接口中添加方法、如下：
public interface SomeService
{
void doSome(String name,int age);
String getName();
}
//实现类中实现该方法
@Override
public String getName()
{
System.out.println("...........执行了getName()方法............");
return "大卫";
}
- 在切面类中添加后置通知增强方法、如下：
/**
* 后置通知
* @param name：目标方法返回值
*/
@AfterReturning(value = "execution(* *..getName(..))", returning = "name")
public void after(Object name)
{
System.out.println("后置通知、在目标方法执行后执行、目标方法返回值是:" + name);
}
- 测试方法：
@Test
public void test01()
{
//指定spring配置文件
String config = "applicationContext.xml";
//创建spring容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//从spring容器中获取对象、使用id
SomeService someService = (SomeService) ctx.getBean("someService");
//执行对象的业务方法
someService.getName();
}
- 控制台输出：
...........执行了getName()方法............
后置通知、在目标方法执行后执行、目标方法返回值是:大卫
5.4、环绕通知@Around -- 目标方法执行之前之后执行
环绕通知、就是将目标方法拿到切面方法中、在增强方法中获取到的目标方法上边和下边加上需要的内容。方法有一个 ProceedingJoinPoint类型的参数、调用proceed()方法，也就是执行目标方法、若目标方法有返回值，则该方法的返回值就是目标方法的返回值。
- 在接口中添加方法、如下：
public interface SomeService
{
void doSome(String name,int age);
String getName();
String getAddress();
}
@Override
public String getAddress()
{
System.out.println("...........执行了getAddress()方法............");
return "中国上海";
}
- 在切面类中添加环绕通知增强方法：
@Around(value = "execution(* *..getAddress(..))")
public Object around(ProceedingJoinPoint pj) throws Throwable
{
Object res = null;
System.out.println("前置功能.....");
//proceed()：目标方法、并接收目标方法的返回值
res = pj.proceed();
System.out.println("后置功能.....");
return res;
}
- 测试方法：
@Test
public void test01()
{
//指定spring配置文件
String config = "applicationContext.xml";
//创建spring容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//从spring容器中获取对象、使用id
SomeService someService = (SomeService) ctx.getBean("someService");
//执行对象的业务方法
Object res = someService.getAddress();
System.out.println(res);
}
- 控制台输出：
前置功能.....
...........执行了getAddress()方法............
后置功能.....
中国上海
5.5、@Pointcut定义切入点
如果一个execution切入点表达式可以被多个通知增强方法使用、就可以使用AspectJ提供@Pointcut注解，用于定义execution 切入点表达式、实现代码复用。
其用法是、将@Pointcut注解在一个方法之上，那么所有的 execution的value属性值均可使用该方法名作为切入点。这个使用@Pointcut注解的方法一般使用private，里边也不写代码、没用实际作用。
- 对环绕通知的切面类中代码稍作修改、如下：
/**
* myCut():下边的方法名就是myCut()
* @param pj
* @return
* @throws Throwable
*/
@Around(value = "myCut()")
public Object around(ProceedingJoinPoint pj) throws Throwable
{
Object res = null;
System.out.println("前置功能.....");
//proceed()：目标方法、并接收目标方法的返回值
res = pj.proceed();
System.out.println("后置功能.....");
return res;
}
@Pointcut(value = "execution(* *..getAddress(..))")
private void myCut()
{
//不写代码
}
- 测试方法同上、输出结果、如下：
前置功能.....
...........执行了getAddress()方法............
后置功能.....
中国上海
当然、不光有前置、后置、环绕、还有异常通知、最终通知，但是都不常用，了解就行。