springboot集成AOP

已于 2023-01-06 20:07:02 修改
阅读量378 收藏 1
点赞数
文章标签： java spring boot Powered by 金山文档
于 2023-01-06 16:27:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42313997/article/details/128580980
版权

springboot集成aop，需要先集成slf4j.

  1. 导入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <!-- 排除自带的logback依赖 -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>


        <!-- 引入springboot-log4j -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

  1. resource目录下创建log4j.properties配置文件：

###配置日志根Logger
#Log4j 根配置语法
#log4j.rootLogger = [ level ] , appenderName, appenderName, …
#把指定级别以上的日志信息输出到指定的一个或者多个位置
log4j.rootLogger=DEBUG,stdout,file

#ERROR 为严重错误 主要是程序的错误
#WARN 为一般警告，比如session丢失
#INFO 为一般要显示的信息，比如登录登出
#DEBUG 为程序的调试信息

log4j.additivity.org.apache=true 

####################################输出到控制台的配置########################################
###配置日志信息输出目的地Appender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
#org.apache.log4j.ConsoleAppender（控制台）
#org.apache.log4j.FileAppender（文件）
#org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
#org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
#org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
#log4j.appender.error.Target=System.out
###输出INFO级别以上的日志
log4j.appender.stdout.threshold=INFO 
###配置日志信息的格式（布局）
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
#org.apache.log4j.HTMLLayout（以HTML表格形式布局）
#org.apache.log4j.PatternLayout（可以灵活地指定布局模式）
#org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
#org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
###配置日志打印的格式格式化日志信息
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n 


#%m   输出代码中指定的消息
#%p   输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
#%r   输出自应用启动到输出该log信息耗费的毫秒数
#%c   输出所属的类目，通常就是所在类的全名
#%t   输出产生该日志事件的线程名
#%n   输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
#%d   输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}
#%l   输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数
##############################################################################################


####################################输出到文件的配置########################################
#log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.file.layout=org.apache.log4j.PatternLayout 
log4j.appender.file.DatePattern='.'yyyy-MM-dd-HH-mm 
# '.'yyyy-MM：每月滚动一次日志文件，即每月产生一个新的日志文件。当前月的日志文件名为logging.log4j，前一个月的日志文件名logging.log4j.yyyy-MM。
# '.'yyyy-ww：每周
# '.'yyyy-MM-dd：每天
# '.'yyyy-MM-dd-a：每天两次
# '.'yyyy-MM-dd-HH：每小时
# '.'yyyy-MM-dd-HH-mm：每分钟
# 后缀可以是KB, MB 或者GB。在日志文件到达该大小时，将会自动滚动，即将原来的内容移到logging.log4j.1文件中。
#log4j.appender.file.MaxFileSize=1MB
###滚动文件的最大数
# 指定可以产生的滚动文件的最大数，例如，设为2则可以产生logging.log4j.1，logging.log4j.2两个滚动文件#和一个logging.log4j文件。
#log4j.appender.file.MaxBackupIndex=8
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-5p](%-30c{1}) [TxId : %X{PtxId} , SpanId : %X{PspanId}] [ET:%X{ENV_TYPE},AN:%X{APP_NAME},SN:%X{SERVICE_NAME},CN:%X{CONTAINER_NAME},CI:%X{CONTAINER_IP}] %m%n 
log4j.appender.file.Threshold=DEBUG 
###将消息增加到指定文件中,false指将消息覆盖指定的文件内容
log4j.appender.file.append=true 
###日志的保存位置
#log4j.appender.file.File=E:/logs/file-debug-log.log
log4j.appender.file.File=E:/logs/debug-debug.log 
###每天产生一个日志文件
#log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.maxFileSize=100
#log4j.appender.file.maxBackupIndex=5
#log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%-5p](%-30c{1}) [TxId : %X{PtxId} , SpanId : %X{PspanId}] [ET:%X{ENV_TYPE},AN:%X{APP_NAME},SN:%X{SERVICE_NAME},CN:%X{CONTAINER_NAME},CI:%X{CONTAINER_IP}] %m%n
#log4j.appender.file.Threshold=DEBUG
#log4j.appender.file.append=true
#log4j.appender.file.File=E:/logs/debug-log.log

  1. 集成aop，创建WebLogAcpect配置类：

package com.example.demo.config;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;

/**
 * FileName: WebLogAcpect.java
 *
 * @author : wqm
 * @Description: All rights Reserved, Designed By SunyardFX
 * Copyright: Copyright(C) 2020-2022
 * Company  : SunyardFX.hangzhou
 * @Slogan :【提高代码质量】：每日三省吾身：注释、异常、日志
 * Createdate: 2023/1/6
 */
@Aspect
@Component
@Slf4j
public class WebLogAcpect {
    /**
     * 定义切入点，切入点为com.example.demo.management.controller下的所有函数
     */
    @Pointcut("execution(public * com.example.demo.management.controller..*.*(..))")
    public void webLog(){}

    /**
     * 前置通知：在连接点之前执行的通知
     * @param joinPoint
     * @throws Throwable
     */
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 记录下请求内容
        log.info("请求路径 : " + request.getRequestURL().toString());
        log.info("请求方式 : " + request.getMethod());
        log.info("IP : " + request.getRemoteAddr());
        log.info("调用方法 : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        log.info("入参 : " + Arrays.toString(joinPoint.getArgs()));
    }

    /**
     * 后置返回通知，可传递目标方法的返回值，在连接点执行完成后执行，
     * 不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容。 obj 目标方法的返回值
     * @param ret
     * @throws Throwable
     */
    @AfterReturning(returning = "ret",pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        log.info("返回结果 : " + ret);
    }
}

如果log报错，可能是因为idea没有安装lombok插件。

  1. 测试：

package com.example.demo.management.controller;


import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * FileName: UserController.java
 *
 * @author : wqm
 * @Description: All rights Reserved, Designed By SunyardFX
 * Copyright: Copyright(C) 2020-2022
 * Company  : SunyardFX.hangzhou
 * @Slogan :【提高代码质量】：每日三省吾身：注释、异常、日志
 * Createdate: 2022/12/15
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @GetMapping("/hello")
    public String hello(String asa){
        return "hello";
    }
}

访问地址：

http://localhost:8080/user/hello?asa=s

查看控制台打印信息：

项目目录结构：

完成！

超酸的柠檬精
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot整合Aop.zip
03-10
SpringBoot 是一个基于 Spring 框架的高度集成了大量常用功能的轻量级开发框架，它极大地简化了 Spring 的配置过程。本文将深入探讨如何在 SpringBoot 中整合 AOP。 1. **AOP 概念解析** 面向切面编程（AOP）是一...
【精品】SpringBoot 集成AOP
哈
05-31 997
第一步：创建SpringBoot项目，导入Maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot&
SpringBoot整合AOP
HLH_2021的博客
08-08 1515
文章目录1. AOP介绍1.1 什么是AOP1.2 AOP中的名词介绍1.3 注解介绍1.4 切入点表达式2. 测试2.1 简单案例2.2 execution2.3 within2.4 this2.5 target2.6 args2.7 @args2.8 @within2.9 @target2.10 @annotation2.10 bean3. 案例3.1 AOP日志3.2 登录用户参数注入 1. AOP介绍 1.1 什么是AOP aop全称Aspect Oriented Programming，即为面向切
2024年最新SpringBoot项目中集成AOP(1)，线程池原理面试
2301_82241647的博客
05-09 399
本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取//用的最多 通知的签名//代理的是哪一个方法logger.info(“代理的是哪一个方法”+signature.getName());//AOP代理类的名字logger.info(“AOP代理类的名字”+signature.getDeclaringTypeName());//AOP代理类的类（class）信息。
Springboot集成AOP
linの编程之路
03-11 395
maven依赖 <!--引入SpringBoot的Web模块--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!--引入AOP依赖--> <dependency> <gr
Spring Boot 整合 AOP
yy139926的博客
11-17 1091
在 Spring 框架中有一个 AOP 子框架，自己创建了一套独有的表达式语言，通过这些表达式语言，可以轻松控制业务类中某些方法横切或植入新功能，以达到低耦合的效果。Spring AOP 底层用的就是动态代理，不用写动态代理代码。
Springboot项目快速实现Aop功能
凡夫编程
03-19 2133
这篇文章的有几个关键点，第一，关于AOP的一些基础理论知识，在正式使用AOP前需要了解；第二，Springboot项目中怎么快速集成Aop功能的；第三，AOP的一些使用小技巧和注意事项。Springboot引入AOP依赖包后，一般来说是不需要再做其他配置了，在比较低的版本或者有其他配置影响了AOP的相关功能，导致aop功能不生效，可以试试在启动类上增加@EnableAspectJAutoProxy来启用；
springBoot+aop 简单demo
09-16
现在我们来详细探讨Spring Boot集成AOP的基本概念、应用场景以及如何实现一个简单的Before前置通知DEMO。 1. **AOP概述** 面向切面编程是一种编程范式，旨在提高代码的可复用性和模块化。它通过将关注点分离，将横...
SpringBoot 整合 AOP完整源码
02-16
集成AOP的第一步是确保项目已经正确配置了Spring Boot和Maven。在`pom.xml`文件中，我们需要添加Spring Boot的父依赖和Spring AOP的相关依赖。Spring Boot父依赖提供了一组默认的配置和依赖管理，而Spring AOP依赖则...
SpringBoot+AOP日志
04-24
在本项目中，"SpringBoot+AOP日志"是一个基于Spring Boot框架的日志管理系统，它利用了Spring Boot的便利性和AOP（面向切面编程）技术来实现对应用程序日志的高效、统一处理。让我们深入探讨一下这个项目的核心知识...
SpringBoot+aop
09-27
在Spring Boot中集成AOP非常方便。首先，我们需要在项目中引入`spring-boot-starter-aop`依赖，这将为我们的应用开启AOP支持。接下来，我们可以创建一个带有`@Aspect`注解的类，这个类就是我们的切面。在切面类中，...
【Spring Boot】整合 AOP
pcdd's blog
05-10 6272
认识AOP 1.1 什么是AOP 1.2 AOP中的概念 SpringBoot整合AOP代码示例 2.1 使用execution（路径表达式） 2.2 使用annotation（注解） 1 认识Spring AOP 1.1 什么是AOP AOP (Aspect Oiented Programn,面向切面编程)把业务功能分为核心、非核心两部分。 ● 核心业务功能:用户登录、增加数据、删除数据。 ● 非核心业务功能:性能统计、日志、事务管理。 在Spring的面向切面编程( AOP )思想里，非核心业.
【SpringBoot】SpingBoot整合AOP
ykletters的专栏
06-18 211
说起spring，我们知道其最核心的两个功能就是AOP（面向切面）和IOC（控制反转），这边文章来总结一下SpringBoot如何整合使用AOP。 一、示例应用场景：对所有的web请求做切面来记录日志。
Spring Boot 整合AOP（超详细...）
泠青沼
03-11 930
AOP 全称Aspect Oriented Programming，面向切面，AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。通俗点讲就是提供一个为一个业务实现提供切面注入的机制，通过这种方式，在业务运行中将定义好的切面通过切入点绑定到业务中，以实现将一些特殊的逻辑绑定到此业务中。项目中有记录操作日志的需求、或者流程变更是记录变更履历，无非就是插表操作，很简单的一个保存操作，都是一些记录日志或者其他辅助性的代码。
springboot 整合 AOP切面编程
qq_45726327的博客
02-01 1484
==================保存用户业务逻辑=================用户业务....//业务功能-1...但是你想过没有，假设我们又要在删除用户的逻辑中也输出这样的一行内容呢？我们是不是又要在业务逻辑层中又增加这样的一行呢？//业务功能-1......那如果我们的其他模块的功能结构也需要这样这样的功能，那岂不是我们都要去加入这一行，这岂不是很麻烦吗？
SpringBoot使用AOP详解
个人笔记git：https://gitee.com/tlangp/note.git
09-14 7195
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。 利用AOP可对业务逻辑进行增强，在不改变原有逻辑的基础上，在其前后进行处理。降低了耦合性，减少了大量冗余的操作。特别适合用于大量方法都需要进行相同处理的操作。 讲解了切面（Aspect）、切入点（Pointcut）、通知（Advice）、环绕通知
springboot实现Aop
最新发布
qh1112的博客
05-10 1639
面向切面编程（aop）的具体实现及原理应用
springboot实现aop的方式
06-28
### 回答1： Spring Boot实现AOP的方式有以下几种： 1. 基于注解的方式：使用@Aspect注解定义切面类，使用@Pointcut注解定义切点，使用@Before、@After、@Around等注解定义通知方法。 2. 基于XML配置的方式：在XML配置文件中定义切面类、切点和通知方法，使用<aop:aspect>、<aop:pointcut>、<aop:before>、<aop:after>、<aop:around>等标签。 3. 使用AspectJ：AspectJ是一个独立的AOP框架，可以与Spring集成使用。使用AspectJ可以实现更加灵活和强大的AOP功能。 以上是Spring Boot实现AOP的常用方式，具体选择哪种方式，可以根据实际需求和个人喜好来决定。 ### 回答2： Spring Boot是一个开源的、构建于Spring框架之上的快速应用开发框架。它提供了丰富的功能，其中包括了AOP（面向切面编程）。Spring Boot通过在代码中添加注解的方式实现AOP，这种方式也被称为基于注解的AOP。下面让我们来看看Spring Boot实现AOP的方式。 第一步：添加依赖 在pom.xml文件中添加Spring Boot AOP依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 第二步：创建切面类 创建一个用于定义切面行为的类，并在该类上加上@Aspect注解。这个类包含了一个或多个切面方法，其中每个切面方法定义了与Join Point目标方法匹配的Advice（通知），Advice决定了在Join Point目标方法执行前、执行后或者环绕目标方法时所执行的操作。 ``` @Component @Aspect public class LoggingAspect { @Before("execution(public * com.example.demo.service.*.*(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("logging before execution : " + joinPoint.getSignature().getName()); } @After("execution(public * com.example.demo.service.*.*(..))") public void logAfter(JoinPoint joinPoint) { System.out.println("logging after execution : " + joinPoint.getSignature().getName()); } @Around("execution(public * com.example.demo.service.*.*(..))") public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("logging around execution : " + joinPoint.getSignature().getName()); Object result = joinPoint.proceed(); System.out.println("logging around executed: " + joinPoint.getSignature().getName()); return result; } } ``` 在该类中，通过@Before、@After和@Around注解定义了三个通知方法，在这里打印了目标方法的名称。 第三步：配置启动类 在启动类上添加@EnableAspectJAutoProxy注解开启AspectJ的自动代理支持。 ``` @SpringBootApplication @EnableAspectJAutoProxy public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } ``` 现在，我们就成功地使Spring Boot支持AOP了。在上面的例子中，我们使用了@Before、@After和@Around注解分别实现了前置通知、后置通知和环绕通知。这些注解配合AspectJ表达式使用，定义了对哪些方法进行通知。我们也可以创建一个切点，将切点作为参数传递给通知注解，以指定切入的点。在AOP方面，Spring Boot提供了强大的支持，让开发人员更加灵活地控制程序的行为。 ### 回答3： Spring Boot是一个流行的Java框架，可以帮助开发人员更轻松地开发基于Spring的应用程序。Spring Boot的一个重要特性是支持面向方面编程（AOP），允许我们将通用的功能从业务逻辑中分离出来，从而提高代码重用性和可维护性。以下是Spring Boot实现AOP的方式。 1. 基于AspectJ的AOP Spring Boot与AspectJ集成，支持使用AspectJ注解实现面向方面编程。此方法提供了在代码编译期间织入切面的优势，从而提高了应用程序的性能。AspectJ支持切面在代码编译期间或运行时进行织入。 2. 基于Spring AOP的AOP Spring AOP是Spring Framework的一部分，提供了一种声明式的方式来定义切面，并在运行时动态地织入它们。Spring AOP是基于JDK动态代理或CGLIB字节码增强实现的。此方法通常用于纯注解风格的应用程序。 3. AOP联盟的实现 AOP联盟（也称为AOP联盟句柄）是Java EE规范的一部分，提供了一种声明式的方式来定义切面，并在运行时动态地织入它们。此方法通常用于传统的Java EE应用程序。 总之，Spring Boot提供了多种方式来实现AOP，包括基于AspectJ的AOP、基于Spring AOP的AOP和AOP联盟的实现。选择哪种方法取决于应用程序的需求和开发人员的偏好。使用AOP可以增强应用程序的功能和可维护性，可以使代码更具可读性和可重用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值