Spring基础--AOP

AOP概念

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

AOP优势及作用

作用：

• 在程序运行期间不修改源码，对已有方法进行加强

优势：

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

实现方式：动态代理技术

引例

思考：
我们创建一个连接数据库具有基本增删改查操作的spring项目，基本增删改查同是执行了一个sql语句，但如果在一个操作中执行好几个sql语句，中间发生了异常，就会发现，异常之前的sql语句执行了，而异常之后的sql语句没有执行，这就导致了数据错误。
就比如我们实现银行打钱，查询到打钱人以及收钱人的信息，在打钱过后，即对打钱人的金钱数额减少了对应金额后发生了异常，收钱人的金额没有增加，这种怎么处理呢？
解决方法：
数据库具有事务，你是否会怀疑在执行增删改查时没有开启事务呢，答案是否定的，因为没有开启事务，数据就不会提交成功。在我们执行sql语句的时候他会默认开启一个事务。
而对于我们进行打钱操作，里面有多条sql语句，他就会开启多个事务，而不是将整体规划为一个事务。
解决方法就是我们自己控制事务的开关以及提交回滚操作。
在每次执行sql语句前开启事务，执行后提交事务，如果发生错误就回滚。

进一步优化：
按照以上方式进行操作的话，我们需要把每个SQL语句都进行开启事务，提交事务，会使我们的代码变得臃肿，我们要把这些重复代码给统一处理。解决方式就是使用动态代理，在不改变源码的基础上对这些方法进行加强。
Spring的AOP就是使用了动态代理技术对方法进行加强。

AOP相关术语

Joinpoint(连接点):   
  所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的 连接点。 
Pointcut(切入点):   
  所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。 
Advice(通知/增强):   
  所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。   
通知的类型：
前置通知,后置通知,异常通知,最终通知,环绕通知。 
Introduction(引介):   
  引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方 法或 Field。 
Target(目标对象):   
  代理的目标对象。 
Weaving(织入):   
  是指把增强应用到目标对象来创建新的代理对象的过程。   
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。 
Proxy（代理）:   
  一个类被 AOP 织入增强后，就产生一个结果代理类。 
Aspect(切面):  
   是切入点和通知（引介）的结合。 

基于XMLAOP配置

模拟业务层接口IAccountSerivice.java

public interface IAccountService {
    
    
    void saveAccount();

    void updateAccount(int i);

    int deleteAccount();
}

实现类

public class AccountServiceImpl implements IAccountService {
    
    

    @Override
    public void saveAccount() {
    
    
        System.out.println("保存了用户");
    }

    @Override
    public void updateAccount(int i) {
    
    
        System.out.println("更新了用户 "+ i);
    }

    @Override
    public int deleteAccount() {
    
    
        System.out.println("删除了用户");
        return 0;
    }
}

AOP通知类

public class Logger {
    
    
    private void BeforePrintLogger() {
    
    
        System.out.println("执行了前置通知方法");
    }
    private void AfterReturningPrintLogger() {
    
    
        System.out.println("执行了后置通知方法");
    }
    private void ExThrowPrintLogger() {
    
    
        System.out.println("执行了异常通知方法");
    }
    private void AfterPrintLogger() {
    
    
        System.out.println("执行了最终通知方法");
    }
 /**
     * 环绕通知
     * 问题：
     *      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     *      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     *
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    private Object AroundPrintLogger(ProceedingJoinPoint prj) {
    
    
        Object rtValue = null;
        try {
    
    
            Object[] args = prj.getArgs(); // 得到方法执行所需的参数
            System.out.println("前置通知");
            rtValue = prj.proceed(args); // 明确使用业务层方法（切入点方法）
            System.out.println("后置通知");
            return rtValue;
        } catch (Throwable t) {
    
    
            System.out.println("异常通知");
            throw new RuntimeException(t);
        } finally {
    
    
            System.out.println("最终通知");
        }
    }
}

配置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"
       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">
    <!-- 配置service -->
    <bean id="service" class="org.example.service.impl.AccountServiceImpl"></bean>

    <!-- 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()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)

                实际开发中切入点表达式的通常写法：
                    切到业务层实现类下的所有方法
                        * com.itheima.service.impl.*.*(..)
    -->

    <!-- 配置Logger -->
    <bean id="logger" class="org.example.utils.Logger"></bean>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect id = "logAdvice" ref="logger">
            <!-- 配置切入点信息，提前配置好，后面可以直接使用，让代码简略
            如果写aop:aspect外部，则需要写在其前面，可以供后面各个切面使用
            -->
            <aop:pointcut id="pt" expression="execution(* org.example.service.impl.*.*(..))"/>
            <!-- 配置通知类型,并且建立通知方法和切入点的关联 ，无论切入点方法是否正常执行，它都会执行 -->
            <aop:before method="BeforePrintLogger" pointcut-ref="pt"></aop:before>
            <!-- 后置通知，它和异常通知只能执行一个 -->
            <aop:after-returning method="AfterReturningPrintLogger" pointcut="execution(* org.example.service.impl.*.*(..))"></aop:after-returning>
            <!-- 异常通知,它和后置通知只能执行一个-->
            <aop:after-throwing method="ExThrowPrintLogger" pointcut="execution(* org.example.service.impl.*.*(..))"></aop:after-throwing>
            <!-- 最终通知，无论切入点方法是否正常执行，它都会执行 -->
            <aop:after method="AfterPrintLogger" pointcut="execution(* org.example.service.impl.*.*(..))"></aop:after>
             <!-- 环绕通知,使用环绕通知则不必再使用其他通知 -->
            <aop:around method="AroundPrintLogger" pointcut-ref="pt"></aop:around>
        </aop:aspect>

    </aop:config>
</beans>

测试

  @Test
    public void test() {
    
    
        // 1、获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2、获取对象
        IAccountService as = (IAccountService) ac.getBean("service");
        // 3、执行方法
        as.saveAccount();
//        as.deleteAccount();
    }

输出

参考以下结合AOP实现的事务控制：事务控制的实现