第三章 AOP 面向切面的编程
3.1 增加功能，导致的一些问题
1、源代码中、业务方法中增加的功能
1）源代码改动的比较多
2）重复代码比较多
3）代码难以维护
3.2 AOP概念
3.2.1 什么是AOP
AOP(Aspect Orient Programming):面向切面编程
- Aspect:表示切面，给业务方法增加功能，叫做切面。切面一般都是非业务功能，而且切面功能一般都是可以复用的。例如：日志、事务、权限检查、参数检查、统计信息等
- Orient:面向、对着
- Programming:编程
怎么理解面向切面编程？（以切面为核心，设计开发你的应用） - 设计项目的时候，找出切面的功能。
- 安排切面的执行时间、位置
3.2.2 AOP的作用
1）让切面功能复用
2）让开发人员专注于业务逻辑、提高开发效率
3）实现业务功能和非业务功能解耦合
4）给存在的业务方法增加功能，不用修改原来的代码
3.2.3 AOP中的一些术语
1） Aspect：切面，给业务方法增加的功能
2）JoinPoint:连接点，连接切面的业务方法，在这个业务方法执行时，同时执行这个切面的功能
3）PointCut:是一个或多个连接点的集合，表示这些方法执行时，都能去增加切面的功能。表示切面执行的位置
4）target:目标对象，给哪个对象增加切面方法，这个对象就是目标对象
5）Advice:通知（IT术语：增强），表示切面的执行时间，在目标方法之前执行切面，还是在目标方法之后执行。
AOP中三个重要的要素：
Aspect、PointCut、Advice。这个概念的理解是：在Advice的时间，在PointCut的位置执行Aspect
AOP是一个动态的思想，在程序执行期间，创建代理（ServiceProxy），使用代理执行方法时，增加切面的功能，这个代理对象时存在内存中的
3.2.4 什么时候用AOP
你要给某些方法，增加一些相同的功能，源代码不能改，给业务方法增加非业务功能。
3.2.5 AOP技术思想的实现
使用框架实现AOP，实现AOP的框架很多，比较著名的有两个：
1）Spring:Spring框架实现AOP思想中的部分功能，Spring框架实现AOP的操作比较繁琐、比较重
2）AspectJ:一个独立的框架，专门做AOP的。属于Eclipse基金会的
3.3 使用AspectJ框架实现AOP
Aspectj框架可以使用注解和xml配置文件两种方式实现AOP
3.3.1 通知
Aspectj表示起么的执行时间，用的通知（Advice)。这个通知可以用注解表示.
讲5个注解，表示切面的5个执行时间，这些注解叫做通知注解
@Before:前置通知
@AfterReturning:后置通知
@Aroud:环绕通知
@AfterThrowing:异常通知
@After：最终通知
3.3.2 PointCut 位置
PointCut用来表示切面执行的位置，使用AspectJ中切入点表达式
切入点表达式语法：execution(访问权限 方法的返回值 方法声明（参数） 异常类型)
3.3.3 @Before 前置通知
/**
* 切面类中的通知方法，是可以有参数的
* JointPoint必须是他
* JointPoint：表示正在执行的业务方法，相当于反射中的Method
* 使用要求：必须是参数列表中的第一个
* 作用：获取方法执行时的信息，例如：方法的名称、参数集合（如果想要在切面类中，获取方法的信息，则需要加这个）
*/
@Before(value = "execution(* *..SomeServiceImpl.do*(..) )" )
public void myBefore2(JoinPoint joinPoint){
//获取方法的定义
System.out.println("前置通知中，获取目标方法的定义："+joinPoint);
System.out.println("前置通知中，获取目标方法的名称："+joinPoint.getSignature().getName());
Object args[] = joinPoint.getArgs();
for (Object arg : args) {
System.out.println("获取方法执行时候的参数："+arg);
}
String methodName = joinPoint.getSignature().getName();
if ("doSome".equals(methodName)){
System.out.println("doSome=========");
}else if ("doOther".equals(methodName)){
System.out.println("doOther========");
}
}
3.3.4 后置通知@AfterReturning
@AfterReturning：在 目标方法之后执行
/**
* 后置通知方法的定义：
* 1)方法是public的
* 2）方法是void
* 3)方法名称自定义
* 4）方法有参数，推荐使用object类型
*/
/**
* @AfterReturning:后置通知
* 属性：
* value:切入点表达式
* returning：自定义的变量，表示目标方法的返回值
* 自定义变量名称必须和通知方法的形参名一样
* 特点：
* 1、在目标方法之后执行
* 2、能获取到目标方法的执行结果
* 3、不会影响目标方法的执行
* 方法的参数：
* Object res：表示目标方法的返回值，使用res接收方法的调用结果
*
* 后置通知的执行顺序
* Object res = SomeServiceImpl.doOther(..);
* myAfterReturning(res)
*
* 方法返回的是String、Integer、Long等基本类型，在后置通知中，修改返回，是不会影响目标方法的最后调用结果的
* 如果返回的是对象类型，例如：Student,在后置方法中，修改这个Student对象的属性值，会影响最后的调用结果
*/
@AfterReturning(value = "execution(* *..SomeServiceImpl.do*(..))",returning = "res")
public void myAfterReturning(JoinPoint jp,Object res){
System.out.println("后置通知，在目标方法之后执行的，能拿到执行结果:"+res);
//Object res有什么用，可以根据返回值得不同，做不同的增强功能
if (null != res){
res = "Hello";
}
System.out.println("后置通知，在目标方法之后执行的，拿到执行的结果："+res);
}
3.3.5 @Around环绕通知
@Around(value="切入点表达式")
使用环绕通知时，就是调用我们切面类中的通知方法
package com.wh.ch09aspectaround.handle;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import java.util.Date;
/**
* @Author :wanghui
* @Date 2022/1/2 - 9:35
*/
@Aspect
public class MyAspect {
/**
* 焕荣通知设置：
* 1、方法是public
* 2、方法必须有返回值，推荐使用Object类型
* 3、方法名称自定义
* 4、方法必须有ProceedingJoinPoint参数
*/
/**
* @Around:环绕通知
* 属性：
* value:切入点表达式
* 位置：方法定义的上面
*返回值：Object:表示调用目标方法，期望的执行结果，但是这个结果不一定是目标方法自己的返回值
*参数：ProceedingJoinPoint,相当于反射中的method
* 作用：执行目标方法的，等于Method.invoke()
* 特点：
* 1、在目标方法的前和后，都能增强功能
* 2、控制目标方法是否执行
* 3、可以修改目标方法的执行结果
*
*/
@Around("execution(* *..SomeServiceImpl.doFirst(..))")
public Object myAroud(ProceedingJoinPoint pjp) throws Throwable {
//执行目标方法
Object methodReturn = null;
System.out.println("执行了环绕通知的MyAround方法,在目标方法之前，输出日志时间==="+new Date());
methodReturn = pjp.proceed();//method invoke,表示执行doFirst()方法本身
System.out.println("环绕通知，在目标方法之后，输出日志时间："+new Date());
//返回目标方法的执行结果
return methodReturn;
}
}
能否说一个前置通知+一个后置通知就等于一个环绕呢？
答案是不可以的
环绕可以控制方法的返回值，而前置、后置没法。可以模拟在方法前后加返回值。
3.3.6 @AfterThrowing异常通知
语法：@AafterThrowing(value="切入点表达式",throwing="自定义变量")
package com.wh.ch09aspectaround.handle;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import java.util.Date;
/**
* @Author :wanghui
* @Date 2022/1/2 - 9:35
*/
@Aspect
public class MyAspect{
/**
* 异常通知方法的定义：
* 1、方法是public
* 2、方法是没有返回值的，是void的
* 3、方法名称自定义
* 4、方法有参数是Exception
*/
/**
* @AfterThrowing:是异常通知’
* 属性：value:切入点表达式
* throwing:自定义变量，表示目标方法抛出的异常，变量名必须和通知方法的形参名一样
* 位置：在方法的上面
*
* 特点：
* 1、在目标方法抛出异常后执行的，没有异常不执行
* 2、能够获取目标方法的异常信息
* 3、不是异常处理程序，可以得到发生异常的通知，可以发送邮件、短信等通知开发人员
* 可以看做是目标方法的监控程序
* 异常通知的执行
* try{
* SomeServiceImpl.doSecond(..)
* }catch(Exception e){
* myAfterThrowing(e)
* }
*/
@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing="ex")
public void myAfterThrowing(Exception ex){
System.out.println("异常通知，在目标方法抛出异常时候执行的，异常原因为："+ex.getMessage());
/**
* 异常发生时：
* 1、记录异常发生的时间、位置等信息
* 2、发送邮件、短信等通知开发人员
*/
}
}
3.3.7@After 最终通知
语法：@After（value="切入点表达式"）
package com.wh.ch11after.handle;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import java.util.Date;
/**
* @Author :wanghui
* @Date 2022/1/2 - 9:35
*/
@Aspect
public class MyAspect{
/**
* 最终通知方法的定义：
* 1、方法是public
* 2、方法是没有返回值的，是void的
* 3、方法名称自定义
* 4、方法有参数是Exception
*/
/**
* @After:最终通知
* 属性：value:切入点表达式
* 位置：在方法的上边
*
* 特点：
* 1、在目标方法之后执行的
* 2、总是会被执行
* 3、可用用来做程序最后的收尾工作，例如：清楚临时数据、变量、清理内存
*
* 最终通知
* try{
* 业务方法
* }finally{
* myAfter
* }
*/
@After(value = "execution(* *..SomeServiceImpl.doThird(..))")
public void myAfter(){
System.out.println("最终通知，总是会被执行");
}
}
3.3.8 @Pointcut
定义和管理切入点的注解
@PointCcut(value="切入点表达式")
package com.wh.handle;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import java.util.Date;
/**
* @Author :wanghui
* @Date 2022/1/2 - 9:35
*/
@Aspect
public class MyAspect{
@Before(value = "mypt()")
public void myBefore(){
System.out.println("前置方法=========");
}
@After(value = "mypt()")
public void myAfter(){
System.out.println("最终通知，总是会被执行");
}
/**
* @pointcut:管理和定义切入点的，不是通知注解
* 属性：value,切入点表达式
* 位置，在一个自定义方法的上面，这个方法看做是切入点表达式的别名
* 其他的通知注解中，可以使用方法别名，就表示使用这个切入点表达式了
*/
@Pointcut("execution(* *..SomeServiceImpl.doThird(..))")
public void mypt(){
//无需代码
}
}
3.4 AOP 总结
AOP是一种动态的思想，目的是实现业务功能和非业务功能的解耦合。业务功能是独立的模块，其他功能也是独立的模块。例如事务功能，日志功能等等。让这些事务、日志功能是可以被复用的。
当目标方法需要一些功能时，可以在不修改、不能修改源代码的情况下，使用AOP技术，在程序执行期间，生成代理对象，通过代理执行我们的业务方法，同时增加功能。
