• SpringAOP入门

    文章目录

    学习视频来自于：秦疆（遇见狂神说）Bilibili地址
    他的自学网站：kuangstudy

    但行好事，莫问前程

    一、AOP

    1.1 介绍

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

    1.2 AOP在Spring中的作用

    提供声明式事务、如需用户自定义切面。

    • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
    • 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
    • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
    • 目标（Target）：被通知对象。
    • 代理（Proxy）：向目标对象应用通知之后创建的对象。
    • 切入点（PointCut）：切面通知执行的“地点”的定义。
    • 连接点（JointPoint）：与切入点匹配的执行点。

    在这里插入图片描述

    SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
    在这里插入图片描述
    在这里插入图片描述
    即AOP在不改变原有代码的情况下，去增加新的功能。

    1.3 使用Spring实现AOP

    【重点】使用AOP织入，需要导入一个依赖包！

    
<dependency>
    <groupId>org.aspectjgroupId>
    <artifactId>aspectjweaverartifactId>
    <version>1.9.9.1version>
dependency>


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    1.3.1 方式一：使用Spring的API接口【主要是SpringAPI接口实现】

    1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
    public interface UserService {
    void add();
    void delete();
    void update();
    void select();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        System.out.println("增加一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询一个用户");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类
    public class BeforeLog implements MethodBeforeAdvice {
    /**
     *
     * @param method 要执行目标对象方法
     * @param args 参数
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    public class AfterLog implements AfterReturningAdvice {
    /**
     *
     * @param returnValue 返回值
     * @param method
     * @param args
     * @param target
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法，返回结果为:" + returnValue);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    1. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件
    
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <bean id="userService" class="pers.tianyu.service.UserServiceImpl"/>
    <bean id="beforeLog" class="pers.tianyu.log.BeforeLog"/>
    <bean id="afterLog" class="pers.tianyu.log.AfterLog"/>

    
    
    <aop:config>
        
        <aop:pointcut id="pointcut" expression="execution(* pers.tianyu.service.UserServiceImpl.*(..))"/>
        
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    aop:config>
beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    1. 测试
    public class Cline {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //动态代理代理的是接口：注意点
        UserService bean = context.getBean("userService", UserService.class);
        bean.add();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.3.2 方式二：自定义类来实现AOP【主要是切面定义】

    1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
    public interface UserService {
    void add();
    void delete();
    void update();
    void select();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        System.out.println("增加一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询一个用户");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 在log包下，自定义切入类
    public class DiyPointCut {

    public void before(){
        System.out.println("======方法执行前======");
    }
    public void after(){
        System.out.println("======方法执行后======");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    1. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件
    
<bean id="diyPointCut " class="pers.tianyu.log.DiyPointCut"/>
<aop:config>
    
    <aop:aspect ref="diyPointCut ">
        
        <aop:pointcut id="pointcut" expression="execution(* pers.tianyu.service.UserServiceImpl.*(..))"/>
        
        <aop:before method="before" pointcut-ref="pointcut"/>
        <aop:after method="after" pointcut-ref="pointcut"/>
    aop:aspect>
aop:config>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. 测试
    public class Cline {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService bean = context.getBean("userService", UserService.class);
        bean.add();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    1.3.3 方式三：注解

    1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
    public interface UserService {
    void add();
    void delete();
    void update();
    void select();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        System.out.println("增加一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询一个用户");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 自定义切面类
    @Aspect//标注这是一个切面类
public class DiyPointCut {

    @Before("execution(* pers.tianyu.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("======方法执行前======");
    }
    @After("execution(* pers.tianyu.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("======方法执行后======");
    }
    // 扩展：连接点（JointPoint）：与切入点匹配的执行点
    // 虽然没什么用，了解一下执行顺序
    @Around("execution(* pers.tianyu.service.UserServiceImpl.*(..))")
    public void around (ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        // 获得签名，想看可以打印出来
        //Signature signature = jp.getSignature();
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件
    
<bean id="diyPointCut" class="pers.tianyu.log.DiyPointCut"/>

<aop:aspectj-autoproxy/>

    • 1
    • 2
    • 3
    • 4
    1. 测试
    @Test
public void test01(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    5.结果

    在这里插入图片描述

    五大通知执行顺序

    1. Spring4.0
      　　　　正常情况：环绕前置—>@Before—>目标方法执行—>环绕返回—>环绕最终—>@After—>@AfterReturning
      　　　　异常情况：环绕前置—>@Before—>目标方法执行—>环绕异常—>环绕最终—>@After—>@AfterThrowing
    2. Spring5.28
      　　　　正常情况：环绕前置—>@Before—>目标方法执行—>@AfterReturning—>@After—>环绕返回—>环绕最终
      　　　　异常情况：环绕前置—>@Before—>目标方法执行—>@AfterThrowing—>@After—>环绕异常—>环绕最终
  • 相关阅读:
    Qt应用程序连接达梦数据库-飞腾PC麒麟V10
    我也差点“跑路”
    了解冒泡排序
    考虑阶梯式碳交易机制与电制氢的综合能源系统热电优化附Matlab代码
    深度解读UUID：结构、原理以及生成机制
    【系统设计】指标监控和告警系统
    JsonCpp JSON格式处理库的介绍和使用（面向业务编程-文件格式处理）
    软件设计师：数据库
    2022.11.7 英语背诵
    网络协议学习：第一天
  • 原文地址：https://blog.csdn.net/zhao854116434/article/details/126274093