【Spring框架】十一 、面向切面编程AOP

1.AOP的概念

什么是AOP：

百度百科：
    在软件业，AOP为 Aspect OrientedProgramming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
    AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低 ，提高程序的可重用性，同时提高了开发的效率。

   我们常说：“这件事情要从几个方面来看待”，往往意思是：需要从不同的角度来看待同一个事物。
这里的“方面”，指的是事物的外在特性在不同观察角度下的体现。而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。


   可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性，AOP可以说也是这种目标的一种实现。


    在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。
    应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。


主要意图
    将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来.
通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码.


主要功能
    日志记录，性能统计，安全控制，事务处理，异常处理等等。

总结：

• AOP是一种编程范式，从某一个角度（切面）来考虑程序结构。
• AOP为开发人员提供了一种描写叙述横切关注点的机制，并可以自己主动将横切关注点织入到面向对象的软件系统中。从而实现了横切关注点的模块化。
• AOP可以将那些与业务无关，却为业务模块所共同调用的逻辑或责任。比如事务处理、日志管理、权限控制等。封装起来，便于降低系统的反复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
  参考文章

2.spring中的AOP相关术语

Joinpoint( 连接点):

所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的
连接点。

举个栗子: 平时我们写的业务层Service层接口中的方法。

Pointcut( 切入点):

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。即那些被切入的方法，就是我们进行了增强的方法。
并不是所有的连接点都会被增强，即不是所有连接点都是切入点。

Advice( 通知/ 增强):

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知。

Introduction( 引介):
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方
法或 Field。

Target( 目标对象):
代理的目标对象。

Weaving( 织入):
是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

Proxy （代理）:
一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect( 切面):
是切入点和通知（引介）的结合。

3. 学习 spring 中的 AOP要明确的事

a 、开发阶段（我们做的）

• 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
• 把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
• 在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。

b 、运行阶段（Spring 框架完成的）

• Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

关于代理的选择

• 在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

4. 基于XML 的AOP配置

第一步：环境搭建，加入pom依赖。和对应的bean.xml的配置

  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

<?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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

第二步：编写模拟业务类、Logger类（通知类)

业务类

public interface IAccountService {

   void saveAccount();

   void updateAccount(int i);

   int deleteAccount();
    }

public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("执行了保存方法");
      }

    public void updateAccount(int i) {
        System.out.println("执行了更新方法："+i);
      }

    public int deleteAccount() {
        System.out.println("执行了删除方法");
        return 0;
        } 
    }

通知类Logger

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

第三步：在bean.xml中，配置AOP

    <!-- 配置service-->
    <bean id="accountService" class="code.service.impl.AccountServiceImpl"></bean>

    <!-- 配置Logger-->
    <bean id="logger" class="code.utils.Logger"></bean>
    
    <!-- 配置AOP-->
	<aop:config>
	    <aop:aspect id="logAdvice" ref="logger">
	<!--        配置通知的类型，并且建立通知方法和切入点方法的关联-->
	        <aop:before method="beforeprintLog" pointcut="execution(public void code.service.impl.AccountServiceImpl.saveAccount())"></aop:before>
	    </aop:aspect>
	</aop:config>

说明：

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属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

切入点表达式的写法： 关键字：execution(表达式)

表达式规则： 访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)


标准的表达式写法：
     public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
访问修饰符可以省略
      void com.itheima.service.impl.AccountServiceImpl.saveAccount()
返回值可以使用通配符，表示任意返回值
      * com.itheima.service.impl.AccountServiceImpl.saveAccount()
包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
      * ....AccountServiceImpl.saveAccount())
包名可以使用…表示当前包及其子包
      * …AccountServiceImpl.saveAccount()
类名和方法名都可以使用来实现通配
      * ….*()

- 实际开发中切入点表达式的通常写法：

      切到业务层实现类下所有方法：
      * code.service.impl.. (…)

XML中的四种常用通知类型

xml配置

<!--    配置AOP-->
<aop:config>
    <aop:aspect id="logAdvice" ref="logger">
<!--        配置通知的类型，并且建立通知方法和切入点方法的关联-->

<!--        前置通知：在切入点方法执行之前执行-->
        <aop:before method="beforeprintLog" pointcut-ref="pt1" ></aop:before>
<!--        后置通知：在切入点方法正常执行之后-->
        <aop:after-returning method="afterprintLog" pointcut-ref="pt1"></aop:after-returning>
<!--        异常通知：在切入点方法执行产生异常之后执行-->
        <aop:after-throwing method="throwprintLog"  pointcut-ref="pt1"></aop:after-throwing>
<!--        最终通知：无论切入点方法是否正常执行，它都会在后面执行-->
        <aop:after method="finalprintLog"  pointcut-ref="pt1"></aop:after>
<!--        环绕通知-->
        <aop:around method="aroundprintLog" pointcut-ref="pt1"></aop:around>
        
<!--        单独定义切入点表达式-->
<!--    在切面标签内部：只在当前切面使用
        在切面标签外部：对所有切面使用
-->
        <aop:pointcut id="pt1" expression="execution( * code.service.impl.*.*(..))"/>
    </aop:aspect>
</aop:config>

Logger类

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    /**
     *前置通知
     */
    public void beforeprintLog(){
        System.out.println("前置通知。。。");
    }

    /**
     *后置通知
     */
    public void afterprintLog(){
        System.out.println("后置通知。。。");
    }

    /**
     *异常通知
     */
    public void throwprintLog(){
        System.out.println("异常通知。。。");
    }

    /**
     *最终通知
     */
    public void finalprintLog(){
        System.out.println("最终通知。。。");
    }
    /**
     *环绕通知
     * 问题：
     *  当我们配置了环绕通知后，切入点方法没有执行，而通知方法执行了。
     *  分析：
     *  通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用。
     *  解决：
     *      spring框架为我们提供了一个接口，ProceedingJoinPoint。该接口有一个方法Proceed()
     *      此方法就相当于明确了调用切入点方法
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     */
    public Object aroundprintLog(ProceedingJoinPoint pjp){
        Object returnValue=null;
        try {
            Object[] args=pjp.getArgs();//得到切入点方法的参数
            System.out.println("环绕中的前置通知");
            returnValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
            System.out.println("环绕中的后置通知");

        }catch (Throwable t){
            System.out.println("环绕中的异常通知");
        }finally {
            System.out.println("环绕中的最终通知");
        }
        return returnValue;
    }
}

基于注解的AOP配置

改造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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

<!--    配置spring创建容器时要扫描的包-->
<context:component-scan base-package="code"></context:component-scan>
    
<!--    配置spring开启注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

改造Logger类，加上相应的注解

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect//表示当前类是切面类
public class Logger {

    @Pointcut("execution(* code.service.impl.*.*(..)))")
    private void pt1(){

    }

    /**
     *前置通知
     */
  //  @Before("pt1()")
    public void beforeprintLog(){
        System.out.println("前置通知。。。");
    }

    /**
     *后置通知
     */
  //  @AfterReturning("pt1()")
    public void afterprintLog(){
        System.out.println("后置通知。。。");
    }

    /**
     *异常通知
     */
 //   @AfterThrowing("pt1()")
    public void throwprintLog(){
        System.out.println("异常通知。。。");
    }

    /**
     *最终通知
     */
  //  @After("pt1()")
    public void finalprintLog(){
        System.out.println("最终通知。。。");
    }
   
    @Around("pt1()")
    public Object aroundprintLog(ProceedingJoinPoint pjp){
        Object returnValue=null;
        try {
            Object[] args=pjp.getArgs();//得到切入点方法的参数
            System.out.println("环绕中的前置通知");
            returnValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
            System.out.println("环绕中的后置通知");

        }catch (Throwable t){
            System.out.println("环绕中的异常通知");
        }finally {
            System.out.println("环绕中的最终通知");
        }
        return returnValue;
    }
}