Spring AOP 面向切面编程

已于 2022-08-08 10:54:59 修改
阅读量292 收藏 1
点赞数
分类专栏： SSM 文章标签： spring java 后端
于 2022-08-05 16:14:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s17856147699/article/details/126175420
版权

文章目录

Spring AOP 面向切面编程

一、概述

1、简介

  • AOP是一个面向切面编程的思想，它补充了面向对象的不足
  • 简化代码把方法中非核心功能且重复的代码抽取出来
  • 增强代码把特定的功能封装到切面类中，哪里需要就往上套，被套用的方法被切面增强了
  • 对方法的增强，本质上就是在执行方法的前后添加功能
  • 把一些与业务逻辑层无关的代码分离出来

2、核心概念

  1. 切面：类是对物体特征的抽象，切面就是对横切关注点的抽象
  2. 通知：指拦截到连接点之后要执行的代码，分为前置、后置、异常、返回后、环绕通知五类
  3. 横切关注点：对哪些方法进行拦截，拦截后怎么处理，为横切关注点
  4. 连接点：被拦截到的点，被抽取的方法
  5. 目标：被代理的目标对象
  6. 代理：向目标对象应用通知之后创建的代理对象
  7. 切入点：对连接点进行拦截的定义

3、应用场景

  • 记录日志
  • 监控性能
  • 权限控制
  • 事务管理
  • 缓存

二、AOP注解

  1. @Aspect：切面类
  2. @PointCut：切点
  3. @Before：前置通知
  4. @After：后置通知
  5. @AfterReturning：返回后通知
  6. @AfterThrowing：异常通知
  7. @Around：环绕通知
  8. @Order：优先级，value指越小优先级越高

三、基于XML的AOP

1、导入jar包pom.xml

  <!--配置jar包-->
    <dependencies>
        <!--spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.21</version>
        </dependency>
        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
        <!--AOP依赖包 Spring Boot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
                <version>2.7.0</version>
            </dependency>
    </dependencies>

2、创建Calculator接口

package com.sgz.aop;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 12:20
 * 需求：
 */
public interface Calculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

3、创建CalculatorImpl实现类

package com.sgz.aop;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 12:20
 * 需求：目标对象，专门用来实现核心代码
 */
public class CalculatorImpl implements Calculator{
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部，result：" + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部，result：" + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部，result：" + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部，result：" + result);
        return result;
    }
}

4、创建LoggerAspect类

package com.sgz.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.springframework.stereotype.Component;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 14:11
 * 需求：
 */
@Component
public class LoggerAspect {

    // 前置通知
    public void beforeAdviceMethod(JoinPoint joinPoint) {
        // 获取连接点所对应方法的方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->前置通知" + signature.getName());
    }

    // 后置通知
    public void afterAdviceMethod(JoinPoint joinPoint) {
        // 获取连接点所对应方法的方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->后置通知" + signature.getName());
    }

    // 返回通知
    public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result) {
        // 获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->返回通知" + signature.getName() + "，结果：" + result);
    }

    // 异常通知
    public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable ex) {
        // 获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->异常通知" + signature.getName() + "，异常通知" + ex);
    }

    // 环绕通知
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint) {
        Object result = null;
        try {
            System.out.println("环绕通知-->前置通知");
            // 表示目标对象方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        } finally {
            System.out.println("环绕通知-->后置通知");
        }
        return result;
    }

}

5、创建ValidateAspect类

package com.sgz.aop;

import org.springframework.stereotype.Component;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 15:40
 * 需求：
 */
@Component
public class ValidateAspect {
    private void beforeMethod(){
        System.out.println("ValidateAspect-->前置通知");
    }
}

6、配置applicationContext.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:context="http://www.springframework.org/schema/context"
       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/context 
       https://www.springframework.org/schema/context/spring-context.xsd 
       http://www.springframework.org/schema/aop 
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--扫描组件-->
    <context:component-scan base-package="com.sgz.aop"></context:component-scan>

    <aop:config>
        <!--设置一个公共的切入点表达式-->
        <aop:pointcut id="pointCut" expression="execution(* com.sgz.aop.CalculatorImpl.*(..))"/>
        <!--将IOC容器中的某个bean设置为切面-->
        <aop:aspect ref="loggerAspect">
            <aop:before method="beforeAdviceMethod" pointcut-ref="pointCut"></aop:before>
            <aop:after method="afterAdviceMethod" pointcut-ref="pointCut"></aop:after>
            <aop:after-returning method="afterReturningAdviceMethod" returning="result" pointcut-ref="pointCut"></aop:after-returning>
            <aop:after-throwing method="afterThrowingAdviceMethod" throwing="ex" pointcut-ref="pointCut"></aop:after-throwing>
            <aop:around method="aroundAdviceMethod" pointcut-ref="pointCut"></aop:around>
        </aop:aspect>
        <!--越小优先级越高-->
        <aop:aspect ref="validateAspect" order="1">
            <aop:before method="beforeMethod" pointcut-ref="pointCut"></aop:before>
        </aop:aspect>
    </aop:config>

</beans>

7、创建TestAopXML测试类

package com.sgz.aop.test;

import com.sgz.aop.Calculator;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 15:42
 * 需求：
 */
public class TestAopXML {
    @Test
    public void test(){
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.add(1,1);
    }

}

四、基于注解的AOP

1、导入jar包pom.xml

  <!--配置jar包-->
    <dependencies>
        <!--spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.21</version>
        </dependency>
        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
        <!--AOP依赖包 Spring Boot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
                <version>2.7.0</version>
            </dependency>
    </dependencies>

2、创建Calculator接口

package com.sgz.aop;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 12:20
 * 需求：
 */
public interface Calculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

3、创建CalculatorImpl实现类

package com.sgz.aop;
import org.springframework.stereotype.Component;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 12:20
 * 需求：目标对象，专门用来实现核心代码
 */
@Component
public class CalculatorImpl implements Calculator{
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部，result：" + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部，result：" + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部，result：" + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部，result：" + result);
        return result;
    }
}

4、创建LoggerAspect类

package com.sgz.aop;

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


/**
 * 作者：沈公子
 * 日期：2022/8/3 - 19:38
 * 需求：切面，日志切面
 * 在切面中，需要通过指定的注解将方法标识为通知方法
 *
 * @Before：前置通知，在目标对象方法执行之前执行
 * @After：后置通知，在目标对象方法的finally字句中执行
 * @AfterReturning：返回通知，在目标对象方法返回值之后执行 切入点表示式：设置在标识通知的注解的value属性中
 * @AfterThrowing：异常通知，在目标对象方法的catch字句中执行
 * @Before("execution(public int com.sgz.aop.annotation.CalculatorImpl.add(int,int))")
 * @Before("execution(* com.sgz.aop.annotation.CalculatorImpl.*(..))")
 * 第一个 * 表示任意的访问修饰符和返回值类型
 * 第二个 * 表示类中任意的方法
 * .. 表示任意的参数列表
 * 类的地方也可以使用 *，表示包下所有的类
 * <p>
 * <p>
 * 重用切入点表达式
 * 声明一个公共的切入点表达式
 * @Pointcut("execution(* com.sgz.aop.annotation.CalculatorImpl.*(..))")
 * public void pointCut(){
 * }
 *
 * <p>
 * 3、获取连接点的信息
 * 在通知方法的参数位置，设置 JoinPoint 类型的参数，就可以获取连接点所对应方法的信息
 * // 获取连接点所对应方法的方法名
 * Signature signature = joinPoint.getSignature();
 * // 获取连接点所对应方法的参数
 * Object[] args = joinPoint.getArgs();
 *
 * 切面的优先级
 * 可以通过 @Order 注解的 value 属性设置优先级，默认值 Integer 的最大值
 * @Order 注解的 value值越小优先级越高
 */
@Component
@Aspect // 标识为切面
public class LoggerAspect {

    // 切入点
    @Pointcut("execution(* com.sgz.aop.CalculatorImpl.*(..))")
    public void pointCut() {
    }

    // 前置通知
    // @Before("execution(public int com.sgz.aop.CalculatorImpl.add(int,int))")  // 通过方法
    // @Before("execution(* com.sgz.aop.CalculatorImpl.*(..))")  // 通过类
    @Before("pointCut()")   // 通过切入点
    public void beforeAdviceMethod(JoinPoint joinPoint) {
        // 获取连接点所对应方法的方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->前置通知" + signature.getName());
    }

    // 后置通知
    @After("pointCut()")
    public void afterAdviceMethod(JoinPoint joinPoint) {
        // 获取连接点所对应方法的方法名
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->后置通知" + signature.getName());
    }

    // 返回后通知
    // 在返回通知中若要获取目标对象方法的返回值，
    // 只需要通过 @AfterReturning 注解的 returning 属性，
    // 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
    @AfterReturning(value = "pointCut()", returning = "result")
    public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result) {
        // 获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->返回通知" + signature.getName() + "，结果：" + result);
    }

    // 异常通知
    // 在异常通知中若要获取目标对象方法的异常，
    // 只需要通过 @AfterThrowing 注解的 throwing 属性，
    // 就可以将通知方法的某个参数指定为接收目标对象方法的异常的参数
    @AfterThrowing(value = "pointCut()", throwing = "ex")
    public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable ex) {
        // 获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect-->异常通知" + signature.getName() + "，异常通知" + ex);
    }

    // 环绕通知
    @Around("pointCut()")
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint) {
        Object result = null;
        try {
            System.out.println("环绕通知-->前置通知");
            // 表示目标对象方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        } finally {
            System.out.println("环绕通知-->后置通知");
        }
        return result;
    }

}

5、创建ValidateAspect类

package com.sgz.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 15:40
 * 需求：
 */
@Component
@Aspect
@Order(1)    // 优先级设置，越小优先级越高
public class ValidateAspect {

    @Before("com.sgz.aop.LoggerAspect.pointCut()")
    private void beforeMethod() {
        System.out.println("ValidateAspect-->前置通知");
    }
    
}

6、配置applicationContext.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:context="http://www.springframework.org/schema/context"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
        AOP的注意事项：
        切面类和目标类都需要交给IOC容器管理
        切面类必须通过 @Aspect 注解标识为一个切面
        在 Spring 的配置文件中设置  <aop:aspectj-autoproxy/> 开启基于注解的AOP功能
    -->
    <!--扫描组件-->
    <context:component-scan base-package="com.sgz.aop"></context:component-scan>
    
    <!--开启基于注解的AOP功能-->
    <aop:aspectj-autoproxy/>

</beans>

7、创建TestAop测试类

package com.sgz.aop.test;

import com.sgz.aop.Calculator;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 作者：沈公子
 * 日期：2022/8/5 - 15:42
 * 需求：
 */
public class TestAop{
    @Test
    public void test(){
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.add(1,1);
    }

}
Shen-Childe
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
aop面向切面需要的jar包
08-16
在使用spring的aop功能时，这两个jar是必须的，否则会报错，如下： Caused by: java.lang.ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException at java.net.URLClassLoader$1.run(URLClassLoader.java:200) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) ... 38 more
spring_AOP配置相关的jar包
Sky_for_me的博客
01-18 4197
spring_AOP配置相关的jar包
spring aop 切入依赖的jar包内的方法_使用AOP排查接口性能问题
weixin_39997173的博客
12-01 955
前言：spring 官方文档 中有一个 Core 章节，章节介绍里说：“参考文档的这一部分涵盖了对Spring框架不可或缺的所有技术。” 在阅读 AOP 部分的时候，发现很大篇幅是在讲 AspectJ ，因为不了解 AspectJ ，所以按照文档的链接，查看了AspectJ 官方文档，这个文档简短很多。里边举了一个很有意思的例子：Tracing 。 之前提到 AOP 首...
spring aop 切入依赖的jar包内的方法_springIOC与Aop简介
weixin_39585886的博客
12-01 1468
Spring框架IOC(控制反转)/DI(依赖注入)概念:IOC：将对象的创建过程转移给spring容器去完成，分离关注点DI:创建对象实例时，同时给此对象注入所依赖的属性，将组件的构建和使用分开所需jar文件:​​限制版本配置方式:​spring配置对象:<bean id=”” class=”” scope=”” lazy-init=”” init-method=”” destroy=””...
spring aop 切入依赖的jar包内的方法_Java修行第070天--AspectJ的Aop的实现
weixin_39608116的博客
12-04 1732
今天重点在事务AspectJ对AOP的实现 对于AOP这种编程思想，很多框架都进行了实现。Spring就是其中之一，可 以完成面向切面编程。然而，AspectJ也实现了AOP的功能，且其实现方式更为简捷， 使用更为方便，而且还支持注解式开发。所以，Spring又将AspectJ的对于AOP的实 现也引入到了自己的框架中。 在Spring中使用AOP开发时，一般使用AspectJ的实现方式。Aspe...
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
16.2 Spring框架-AOP面向切面编程
04-12
16.2 Spring框架-AOP面向切面编程
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
SpringBoot整合aop面向切面编程过程解析
08-24
主要介绍了SpringBoot整合aop面向切面编程过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springAOP所依赖的jar包
10-22
springAOP所依赖的jar包：aopalliance-1.0，aspectj-1.7.3，aspectjweaver-1.7.4，cglib-nodep-2.1_3
spring aop jar 包
07-26
spring aop jar 包
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和com.springsource.org.aspectj.weaver-1.7.2.RELEASE.jar。需要的欢迎来拿
Spring-Aop面向切面编程
小凯的博客
11-09 690
Spring-AOP面向切面编程学习笔记
详细：Spring需要哪些JAR包
qq_63858106的博客
11-12 2975
spring的jar包
Java回顾：springAOP、声明式事务
m0_56678122的博客
11-30 282
Java回顾：springAOP、声明式事务
切面功能添加日志
wadeltf的博客
02-20 680
1、自定义注解 @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface LogTarget { String operationDesc() default "";//操作详情operationDesc String operationType() default ...
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
最新发布
阿里巴巴云原生的博客
04-29 744
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值