SpringAOP从配置文件到注解简化全过程

已于 2024-01-08 21:49:24 修改
阅读量1k 收藏 21
点赞数 26
文章标签： java 开发语言 spring
于 2024-01-04 22:00:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_64280569/article/details/135397098
版权

SpringAOP

AOP简介

在这里插入图片描述

AOP的全称是Aspect Oriented Programming，即面向切面编程。是实现功能统一维护的一种技术，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

作用：在不修改源码的基础上，对已有方法进行增强。

AOP相关术语

在这里插入图片描述

为了更好地理解AOP，就需要对AOP的相关术语有一些了解。

名称说明
Joinpoint（连接点）指能被拦截到的点，在Spring中只有方法能被拦截。
Pointcut（切点）指要对哪些连接点进行拦截，即被增强的方法。
Advice（通知）指拦截后要做的事情，即切点被拦截后执行的方法。
Aspect（切面）切点+通知称为切面

接下来我们写一个AOP入门案例：dao层的每个方法结束后都可以打印一条日志：

①引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
    <scope>runtime</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

②编写连接点

package com.example._20240104modelattribute.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
    public void add(){
        System.out.println("用户新增");
    }
    public void delete(){
        System.out.println("用户删除");
    }
    public void update(){
        System.out.println("用户修改");
    }
}

③编写通知类

package com.example._20240104modelattribute.advice;

public class MyAspectJAdvice {
    // 后置通知
    public void myAfterReturning() {
        System.out.println("打印日志...");
    }
}

④配置切面

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.example._20240104modelattribute"></context:component-scan>

    <!-- 通知对象 -->
    <bean id="myAspectJAdvice" class="com.example._20240104modelattribute.advice.MyAspectJAdvice"></bean>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect ref="myAspectJAdvice">
            <!-- 配置切点 -->
            <aop:pointcut id="myPointcut" expression="execution(* com.example._20240104modelattribute.dao.UserDao.*(..))"/>
            <!-- 配置通知 -->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

【我一直在想，这里为什么要使用包扫描呢，我给出的答案是：之前我们都在运行类中执行程序，而该类默认扫描的范围是同级包及其子包下的类，而现在我们需要在测试类中去执行程序，因此需要配置包扫描。】

⑤测试

package com.example._20240104modelattribute;

import com.example._20240104modelattribute.dao.UserDao;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@SpringBootTest
class ApplicationTests {

    @Test
    public void testAdd(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao)ac.getBean("userDao");
        userDao.add();
    }

    @Test
    public void testDelete() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.delete();
    }

    @Test
    public void testUpdate(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.update();
    }
}

⑥执行结果

用户修改
打印日志...

AOP_通知类型

在这里插入图片描述

AOP有以下几种常用的通知类型：

通知类型描述
前置通知在方法执行前添加功能
后置通知在方法正常执行后添加功能
异常通知在方法抛出异常后添加功能
最终通知无论方法是否抛出异常，都会执行该通知
环绕通知在方法执行前后添加功能

①编写通知方法

package com.example._20240104modelattribute.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

public class MyAspectJAdvice {
    // 后置通知
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("切点方法名：" + joinPoint.getSignature().getName());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
    }

    // 前置通知
    public void myBefore() {
        System.out.println("前置通知...");
    }

    // 异常通知
    public void myAfterThrowing(Exception ex) {
        System.out.println("异常通知...");
        System.err.println(ex.getMessage());
    }

    // 最终通知
    public void myAfter() {
        System.out.println("最终通知");
    }

    // 环绕通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        Object obj = proceedingJoinPoint.proceed(); // 执行方法
        System.out.println("环绕后");
        return obj;
    }
}

②配置切面

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.example._20240104modelattribute"></context:component-scan>

    <!-- 通知对象 -->
    <bean id="myAspectJAdvice" class="com.example._20240104modelattribute.advice.MyAspectJAdvice"></bean>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect ref="myAspectJAdvice">
            <!-- 配置切点 -->
            <aop:pointcut id="myPointcut" expression="execution(* com.example._20240104modelattribute.dao.UserDao.*(..))"/>
            <!-- 前置通知 -->
            <aop:before method="myBefore" pointcut-ref="myPointcut"></aop:before>
            <!-- 后置通知 -->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut"/>
            <!-- 异常通知 -->
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointcut" throwing="ex"/>
            <!-- 最终通知 -->
            <aop:after method="myAfter" pointcut-ref="myPointcut"></aop:after>
            <!-- 环绕通知 -->
            <aop:around method="myAround" pointcut-ref="myPointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

运行结果

前置通知...
环绕前
用户修改
环绕后
最终通知
切点方法名：update
目标对象：com.example._20240104modelattribute.dao.UserDao@427ae189
打印日志update方法被执行了！

【这里提出疑问，AOP每次执行的顺序一样嘛？】

注解配置AOP

Spring可以使用注解代替配置文件配置切面：

①在xml中开启AOP注解支持

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.example._20240104modelattribute"></context:component-scan>

    <!-- 开启注解配置Aop -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

②在通知类上方加入注解@Aspect@Component

③在通知方法上方加入注解

package com.example._20240104modelattribute.advice;

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

@Aspect
@Component
public class MyAspectJAdvice {
    // 后置通知
    @AfterReturning("execution(* com.example._20240104modelattribute.dao.UserDao.*(..))")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("切点方法名：" + joinPoint.getSignature().getName());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
    }

    // 前置通知
    @Before("execution(* com.example._20240104modelattribute.dao.UserDao.*(..))")
    public void myBefore() {
        System.out.println("前置通知...");
    }

    // 异常通知
    @AfterThrowing(value = "execution(* com.example._20240104modelattribute.dao.UserDao.*(..))", throwing = "ex")
    public void myAfterThrowing(Exception ex) {
        System.out.println("异常通知...");
        System.err.println(ex.getMessage());
    }

    // 最终通知
    @After("execution(* com.example._20240104modelattribute.dao.UserDao.*(..))")
    public void myAfter() {
        System.out.println("最终通知");
    }

    // 环绕通知
    @Around("execution(* com.example._20240104modelattribute.dao.UserDao.*(..))")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        Object obj = proceedingJoinPoint.proceed(); // 执行方法
        System.out.println("环绕后");
        return obj;
    }
}

④测试：

package com.example._20240104modelattribute;

import com.example._20240104modelattribute.dao.UserDao;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@SpringBootTest
class ApplicationTests {

    @Test
    void contextLoads() {
    }
    @Test
    public void testAdd(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
        UserDao userDao = (UserDao)ac.getBean("userDao");
        userDao.add();
    }

    @Test
    public void testDelete() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.delete();
    }

    @Test
    public void testUpdate(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.update();
    }
}

执行结果

环绕前
前置通知...
用户修改
切点方法名：update
目标对象：com.example._20240104modelattribute.dao.UserDao@7d78f3d5
打印日志update方法被执行了！
最终通知
环绕后

如何为一个类下的所有方法统一配置切点：

①在通知类中添加方法配置切点

    @Pointcut("execution(* com.example._20240104modelattribute.dao.UserDao.*(..))")
    public void pointCut(){}

②在通知方法上使用定义好的切点

	// 后置通知
    @AfterReturning("pointCut()")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("切点方法名：" + joinPoint.getSignature().getName());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");
    }

    // 前置通知
    @Before("pointCut()")
    public void myBefore() {
        System.out.println("前置通知...");
    }

执行顺序

通知类

package com.example.demo.Advice;

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

@Component
@Aspect
public class LogAopAspect {
    @Pointcut("execution(* *..BookHandler.*(..))")
    public void pointCut(){}

    @Before("pointCut()")
    public void dealAddBeforeLog(JoinPoint joinPoint) {
        System.out.println("@Before开始添加");
    }

    @After("pointCut()")
    public void dealAddAfterLog(JoinPoint joinPoint) {
        System.out.println("@After添加结束");
    }

    @Around("pointCut()")
    public void dealAddAroundLog(ProceedingJoinPoint pjb) {
        System.out.println("@Around环绕前");
        try {
            pjb.proceed();
        } catch (Throwable e) {
            System.out.println("发现异常");
        }
        System.out.println("@Around环绕后");
    }

    @AfterReturning("pointCut()")
    public void dealAddAfterReturningLog(JoinPoint joinPoint) {
        System.out.println("@AfterReturning方法返回成功");
    }

    @AfterThrowing("pointCut()")
    public void dealAddAfterThrowingLog(JoinPoint joinPoint) {
        System.out.println("@AfterThrowing抛出异常");
    }
}

要被增强的方法

package com.example.demo.entity;

import org.springframework.stereotype.Component;

@Component
public class BookHandler {
    public void addBook(){
        System.out.println("添加book");
    }
}

配置文件

<?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 https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试类

@Test
public void textAop() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    BookHandler bookHandler = (BookHandler)applicationContext.getBean("bookHandler");
    bookHandler.addBook();
}

执行结果

在这里插入图片描述
这应该是Spring的执行结果，如果对执行顺序存在问题，请点击这里

笨小孩※
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值