AOP：Aspect Oriented Program（面向切面）

我们再回顾一下AOP的一些术语：

• 通知（Advice）
  　　就是你想要的功能，也就是的安全、事物、日志等。先定义好，然后在想用的地方用一下。

• 连接点（JoinPoint）
  　　就是spring允许你使用通知的地方，基本每个方法的前、后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

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

• 切面（Aspect）
  　　切面是通知和切入点的结合。通知说明了干什么和什么时候干（什么时候通过方法名中的before、after、around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

• 引入（introduction）
  　　允许我们向现有的类添加新方法属性。

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

• 代理(proxy)
  　　怎么实现整套aop机制的，都是通过代理。

• 织入(weaving)
  　　把切面应用到目标对象来创建新的代理对象的过程。

上述内容引用于：https://blog.csdn.net/qukaiwei/article/details/50367761

理解：

简单的说就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，在我们想要使用的地方上来调用它。

作用：

为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，这些其他的事情包括：安全，事物，日志等。

优势：

减少重复代码、提高开发效率、维护方便

spring中基于XML的AOP配置步骤

1. 把通知Bean也交给spring来管理
2. 使用aop:config标签表明开始AOP的配置
3. 使用aop:aspect标签表明配置切面
   id属性：是给切面提供一个唯一标识
   ref属性：是指定通知类bean的id
4. 在aop:aspect标签的内部使用对应标签来配置通知的类型
   我们的示例是让printLog方法在切入点方法执行之前之前：所以是前置通知
   aop:before：表示配置前置通知
   method属性：用于指定Logger类中哪个方法是前置通知
   pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

例：

<?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:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置srping的Ioc,把service对象配置进来--><bean id="accountService" class="com.serrvice.impl.AccountServiceImpl"></bean><!-- 配置Logger类（日志类） --><bean id="logger" class="com.utils.Logger"></bean><!--配置AOP--><aop:config><!--配置切面 --><aop:aspect id="logAdvice" ref="logger"><!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--><aop:before method="printLog" pointcut="execution(public void com.serrvice.impl.AccountServiceImpl.saveAccount())"></aop:before></aop:aspect></aop:config>
</beans>

关键字：execution(表达式)
表达式：访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)
切入表达式可以有各种花里胡哨的写法，如下：

• 标准的表达式写法：

public void com.service.impl.AccountServiceImpl.saveAccount()

• 访问修饰符可以省略

void com.service.impl.AccountServiceImpl.saveAccount()

• 返回值可以使用通配符，表示任意返回值

* com.service.impl.AccountServiceImpl.saveAccount()

• 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.

* *.*.*.*.AccountServiceImpl.saveAccount())

• 包名可以使用…表示当前包及其子包

* *..AccountServiceImpl.saveAccount()

• 类名和方法名都可以使用*来实现通配

* *..*.*()

• 关于参数

1. 可以直接写数据类型
   基本类型直接写名称：int
   引用类型写包名.类名的方式：java.lang.String
2. 可以使用通配符表示任意类型，但是必须有参数
3. 可以使用…表示有无参数均可，有参数可以是任意类型

实际开发中切入点表达式的通常写法：
切到业务层实现类下的所有方法

 * com.itheima.service.impl.*.*(..)

业务层接口

package com.serrvice;/*** 账户的业务层接口*/
public interface AccountService {/*** 模拟保存账户*/void saveAccount();/*** 模拟更新账户* @param i*/void updateAccount(int i);/*** 删除账户* @return*/int  deleteAccount();
}

业务层实体类

package com.serrvice.impl;import com.serrvice.AccountService;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements AccountService {@Overridepublic void saveAccount() {System.out.println("执行了保存");}@Overridepublic void updateAccount(int i) {System.out.println("执行了更新"+i);}@Overridepublic int deleteAccount() {System.out.println("执行了删除");return 0;}
}

工具类

package com.utils;/*** 用于记录日志的工具类，它里面提供了公共的代码*/
public class Logger {/*** 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）*/public  void printLog(){System.out.println("Logger类中的pringLog方法开始记录日志了。。。");}
}

测试类

package com;import com.serrvice.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** 测试AOP的配置*/
public class AOPTest {public static void main(String[] args) {//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.获取对象AccountService as = (AccountService) ac.getBean("accountService");//3.执行方法as.saveAccount();as.updateAccount(1);as.deleteAccount();}
}

结果：

四种常用的通知类型

• 前置通知：在切入点方法执行之前执行
• 后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个
• 异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
• 最终通知：无论切入点方法是否正常执行它都会在其后面执行

将bean.xml文件进行修改

<?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:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置srping的Ioc,把service对象配置进来--><bean id="accountService" class="com.serrvice.impl.AccountServiceImpl"></bean><!-- 配置Logger类（日志类） --><bean id="logger" class="com.utils.Logger"></bean><!--配置AOP--><aop:config><!--配置切面 --><aop:aspect id="logAdvice" ref="logger"><!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--><!-- 配置前置通知：在切入点方法执行之前执行--><aop:before method="beforePrintLog" pointcut="execution(public void com.serrvice.impl.*.*(..))"></aop:before><!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个--><aop:after-returning method="afterReturningPrintLog" pointcut="execution(* com.serrvice.impl.*.*(..))"></aop:after-returning><!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个--><aop:after-throwing method="afterThrowingPrintLog" pointcut="execution(* com.serrvice.impl.*.*(..))"></aop:after-throwing><!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行--><aop:after method="afterPrintLog" pointcut="execution(* com.serrvice.impl.*.*(..))"></aop:after></aop:aspect></aop:config>
</beans>

将工具类进行修改

package com.utils;/*** 用于记录日志的工具类，它里面提供了公共的代码*/
public class Logger {/*** 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）*/public  void beforePrintLog(){System.out.println("Logger类中的beforePrintLog方法开始记录日志了。。。");}/*** 后置通知*/public  void afterReturningPrintLog(){System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");}/*** 异常通知*/public  void afterThrowingPrintLog(){System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");}/*** 最终通知*/public  void afterPrintLog(){System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");}
}

运行结果：

我们可以看到，还有一个异常通知没有出现，我们可以修改业务层实体类来测试一下，如下：

package com.serrvice.impl;import com.serrvice.AccountService;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements AccountService {@Overridepublic void saveAccount() {System.out.println("执行了保存");int i=1/0;          //此处为异常}@Overridepublic void updateAccount(int i) {System.out.println("执行了更新"+i);}@Overridepublic int deleteAccount() {System.out.println("执行了删除");return 0;}
}

运行结果：

切入点表达式的通用化

我们注意到上面每写一次通知都要写一遍切入点表达式，为了减少需要重复书写的代码，我们可以进行如下操作：

• aop:pointcut标签
  属性：
  id：用于指定表达式的唯一标识。
  expression：用于指定表达式内容
  此标签写在aop:aspect标签内部只能在当前切面使用；写在aop:aspect外面，就变成了所有切面可用。

例：

<?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:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置srping的Ioc,把service对象配置进来--><bean id="accountService" class="com.serrvice.impl.AccountServiceImpl"></bean><!-- 配置Logger类（日志类） --><bean id="logger" class="com.utils.Logger"></bean><!--配置AOP--><aop:config><!--配置切入点表达式--><aop:pointcut id="pt1" expression="execution(public void com.serrvice.impl.*.*(..))"/><!--配置切面 --><aop:aspect id="logAdvice" ref="logger"><!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--><!-- 配置前置通知：在切入点方法执行之前执行--><aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before><!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个--><aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning><!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个--><aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing><!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行--><aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after></aop:aspect></aop:config>
</beans>

环绕通知

spring中的环绕通知，它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式，相当于拦截所有的方法并自定义代理增强的内容
Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。

例：
修改工具类

package com.utils;import org.aspectj.lang.ProceedingJoinPoint;/*** 用于记录日志的工具类，它里面提供了公共的代码*/
public class Logger {/*** 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）*/public  void beforePrintLog(){System.out.println("Logger类中的beforePrintLog方法开始记录日志了。。。");}/*** 后置通知*/public  void afterReturningPrintLog(){System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");}/*** 异常通知*/public  void afterThrowingPrintLog(){System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");}/*** 最终通知*/public  void afterPrintLog(){System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");}/*** 环绕通知*/public Object aroundPringLog(ProceedingJoinPoint pjp){Object rtValue = null;try{Object[] args = pjp.getArgs();//得到方法执行所需的参数System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");return rtValue;}catch (Throwable t){System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");throw new RuntimeException(t);}finally {System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");}}
}

修改xml文件

<?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:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 配置srping的Ioc,把service对象配置进来--><bean id="accountService" class="com.serrvice.impl.AccountServiceImpl"></bean><!-- 配置Logger类（日志类） --><bean id="logger" class="com.utils.Logger"></bean><!--配置AOP--><aop:config><!-- 配置切入点表达式--><aop:pointcut id="pt1" expression="execution(public void com.serrvice.impl.*.*(..))"/><!--配置切面 --><aop:aspect id="logAdvice" ref="logger"><!-- 配置环绕通知--><aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around></aop:aspect></aop:config>
</beans>

运行结果：

基于注解的AOP配置

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 配置spring创建容器时要扫描的包--><context:component-scan base-package="com"></context:component-scan><!-- 配置spring开启注解AOP的支持 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

业务层实体类注解创建Bean对象

package com.service.impl;import com.service.AccountService;
import org.springframework.stereotype.Service;/*** 账户的业务层实现类*/
@Service("accountService")
public class AccountServiceImpl implements AccountService {@Overridepublic void saveAccount() {System.out.println("执行了保存");
//        int i=1/0;          //此处为异常}@Overridepublic void updateAccount(int i) {System.out.println("执行了更新"+i);}@Overridepublic int deleteAccount() {System.out.println("执行了删除");return 0;}
}

工具类

package com.utils;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;/*** 用于记录日志的工具类，它里面提供了公共的代码*/
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {@Pointcut("execution(* com.service.impl.*.*(..))")private void pt1(){}//    /**
//     * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
//     */
//    @Before("pt1()")
//    public  void beforePrintLog(){
//        System.out.println("Logger类中的beforePrintLog方法开始记录日志了。。。");
//    }
//
//    /**
//     * 后置通知
//     */
//    @AfterReturning("pt1()")
//    public  void afterReturningPrintLog(){
//        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
//    }
//
//    /**
//     * 异常通知
//     */
//    @AfterThrowing("pt1()")
//    public  void afterThrowingPrintLog(){
//        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
//    }
//
//    /**
//     * 最终通知
//     */
//    @After("pt1()")
//    public  void afterPrintLog(){
//        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
//    }@Around("pt1()")public Object aroundPringLog(ProceedingJoinPoint pjp){Object rtValue = null;try{Object[] args = pjp.getArgs();//得到方法执行所需的参数System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");return rtValue;}catch (Throwable t){System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");throw new RuntimeException(t);}finally {System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");}}
}

运行结果：