Spring框架之SpringAOP以及Spring注解开发

---

写在前面： 最近学习Spring告一段落了，这文章可以简单的告诉你什么是AOP，AOP相关术语，AOP的xml配置，AOP注解开发 。 作者是一个学生，没有能力写得太深，需要的可以去看看大佬们的手撕Spring源码。
如果对你有帮助可以点赞支持一下^ _ ^
公众号：小白编码

什么是AOP

AOP：全称是Aspect Oriented Programming即：面向切面编程。

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

作用：在程序运行期间，不修改源码对已有方法进行增强。

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

实现方式：使用动态代理技术

AOP相关术语

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

Pointcut(切入点): 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。

Advice(通知/增强): 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

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

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

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

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

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

AOP明确的事

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

编写核心业务代码（开发主线）

把公用代码抽取出来，制作成通知。（开发阶段最后再做）

在配置文件中，声明切入点与通知间的关系，即切面。

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

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

XML的AOP配置

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

切入点表达式的写法：

                关键字：execution(表达式)
                表达式：
                    访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
                标准的表达式写法：
                    public void cn.codewhite.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                    void  cn.codewhite.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    *  cn.codewhite.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示当前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)

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

配置通知：非环绕通知

Service:

public class AccountServiceImpl implements AccountService {
     

    //切入点方法
    @Override
    public void saveAccount() {
     
        System.out.println("执行了保存");
        int i = 1 / 0;
    }
}

Logger:

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方法开始记录日志了。。。");
    }
}

<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">

    
    <bean id="accountService" class="cn.codewhite.service.impl.AccountServiceImpl">bean>

    
    <bean id="logger" class="cn.codewhite.util.Logger">bean>

    
    <aop:config>
        
         
        <aop:pointcut id="pt1" expression="execution(* cn.codewhite.service.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>

配置环绕通知：

<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">

    
    <bean id="accountService" class="cn.codewhite.service.impl.AccountServiceImpl">bean>

    
    <bean id="logger" class="cn.codewhite.util.Logger">bean>

    
    <aop:config>

        
        <aop:pointcut id="pt1" expression="execution(* cn.codewhite.service.impl.*.*(..))"/>

        
        <aop:aspect id="logAdvice" ref="logger">

            
            <aop:around method="aroundPringLog" pointcut-ref="pt1">aop:around>
        aop:aspect>
    aop:config>

beans>

Logger：

 /**
     * 环绕通知
     * 问题：
     * 当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     * 通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     * Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     * 该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     * 

     * spring中的环绕通知：
     * 它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    public Object aroundPringLog(ProceedingJoinPoint pjp) {
     

        Object rtValue = null;
        try {
     

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            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方法开始记录日志了。。。最终");
        }

    }

非环绕通知总结：

就相当于在原有方法中，做了增强。测试方法中只调用了acountService.saveAccount();//切点方法

但是配置了AOP切面后，增加了通知，所以调用saveAccount()的时候会相当于调用下图：

测试代码： 只调用了切入点方法！

所以测试结果： 配置了通知，切入点方法增强！

注解的AOP配置

第一步：准备好依赖：

   <dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.0.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
            <version>1.8.7version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
    dependencies>

第二步：在配置文件中配置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/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">

    
    <context:component-scan base-package="cn.codewhite">context:component-scan>

    
    <aop:aspectj-autoproxy>aop:aspectj-autoproxy>

beans>

Service:

@Service("accountService")
public class AccountServiceImpl implements AccountService {
     

    @Override
    public void saveAccount() {
     
        System.out.println("执行了保存");
        int i = 1 / 0;
    }
}

Logger:

package cn.codewhite.util;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 *
 * @author JUNSHI [email protected]
 * @create 2020-05-25 22:31
 */
@Component("logger")//放入IOC容器
@Aspect//表示当前类是一个切面类
public class Logger {
     

    @Pointcut("execution(* cn.codewhite.service.impl.*.*(..))")//配置切入点表达式
    private void pt1(){
     }

    @Before("pt1()")//前置通知注解，value是引用pt1的切面表达式
    public void beforePrintLog() {
     
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    @AfterReturning("pt1()")//后置通知注解，value是引用pt1的切面表达式
    public void afterReturningPrintLog() {
     
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }

    @AfterThrowing("pt1()")//异常通知注解，value是引用pt1的切面表达式
    public void afterThrowingPrintLog() {
     
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    @After("pt1()")//最终通知注解，value是引用pt1的切面表达式
    public void afterPrintLog() {
     
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

    @Around("pt1()")//配置成环绕通知，value是引用pt1的切面表达式
    public Object aroundPringLog(ProceedingJoinPoint pjp) {
     

        Object rtValue = null;
        try {
     
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            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方法开始记录日志了。。。最终");
        }

    }

}

表明当前类是一个切面类

@Aspect

表明当前类是一个切面类

增强方法配置

@before

作用： 把当前方法看成是前置通知。

属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@AfterReturning

作用： 把当前方法看成是后置通知。

属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用

@AfterThrowing

作用： 把当前方法看成是异常通知。

属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用

@After

作用： 把当前方法看成是最终通知。

属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用

@Around

作用： 把当前方法看成是环绕通知。

属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。

切入点表达式注解

@Pointcut

作用： 指定切入点表达式

属性： value：指定表达式的内容

开启注解AOP支持

不使用XML的配置方式

@EnableAspectJAutoProxy

在配置类中输入此注解，代表开启了注解AOP支持

@Configuration 
@ComponentScan(basePackages="cn.codewhite") 
@EnableAspectJAutoProxy 
public class SpringConfiguration {
     }

写在后边：

写得不好，请见谅，如果需要PDF版的可以找我。