Java配置日志切面

最新推荐文章于 2024-05-20 11:22:17 发布
最新推荐文章于 2024-05-20 11:22:17 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： java 文章标签： aop spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39684784/article/details/113725944
版权

日志切面配置

什么是切面

面向切面编程(Aspect-oriented Programming 简称AOPAOP) ,是相对面向对象编程(Object-oriented Programming 简称OOP)的框架,作为OOP的一种功能补充. OOP主要的模块单元是类(class)。而AOP则是切面（aspect）。切面会将诸如事务管理这样跨越多个类型和对象的关注点模块化（在AOP的语义中，这类关注点被称为横切关注点（crosscutting））

切面能干什么

事务管理、权限控制、缓存控制、日志打印

使用切面的好处

  • 集中处理某一关注点/横切逻辑
  • 可以很方便的添加/删除关注点
  • 侵入性少，增强代码可读性及可维护性 因此当想打印请求日志时很容* 易想到切面，对控制层代码0侵入

切面的使用（基于注解）

  • @Aspect 声明该类为一个注解类
  • @Pointcut 声明为切点
  • @Before 在切点之前执行代码
  • @After 在切点之后执行代码
  • @AfterReturning 切点返回内容后执行代码，可以对切点的返回值进行封装
  • @AfterThrowing 切点抛出异常后执行
  • @Around 环绕，在切点前后执行代码

配置日志切面

1.指定切点

      /**
     *.AOP切入点表达式
     *
     *execution  * com.bonc.service..*.*(..)
     * execution 为切点修饰符
     *      第一个位 为访问修饰符可以不写
     *      第二个 *  方法返回值
     *      第三位为 报名 *代表所有 ..代表所欲子包
     *      第四位为 方法名
     *      第五位  （..）代表任意参数
     *      日志的入口一般为controller层所以切点为所有的controller
     *
     * */
    @Pointcut("execution(* com.bonc..controller..*(..))")
    public void logPointCut() {
    }

2.构建访问日志实体

@Data
public class RequestInfo {

    private String ip;
    private String url;
    private String httpMethod;
    private String classMethod;
    private Object requestParams;
    private Object result;
    private Long timeCost;
    private RuntimeException exception;

}

3.用@Around注解 并且拼装参数

@Around("logPointCut()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        RequestInfo requestInfo = new RequestInfo();
        requestInfo.setIp(request.getRemoteAddr());
        requestInfo.setUrl(request.getRequestURL().toString());
        requestInfo.setHttpMethod(request.getMethod());
        requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                proceedingJoinPoint.getSignature().getName()));
        requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));

        Object result =null;
        try {
           result = proceedingJoinPoint.proceed();

        }catch ( RuntimeException e){
            requestInfo.setException(e);
        }
        requestInfo.setResult(result);
        requestInfo.setTimeCost(System.currentTimeMillis() - start);
        LOGGER.info("Request Info      : {}", JSON.toJSONString(requestInfo));
        return  result;
    }



    /**
     * 获取入参
     * @param proceedingJoinPoint
     *
     * @return
     * */
    private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) {
        //参数名
        String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();
        //参数值
        Object[] paramValues = proceedingJoinPoint.getArgs();

        return buildRequestParam(paramNames, paramValues);
    }


    private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) {
        Map<String, Object> requestParams = new HashMap<>();
        for (int i = 0; i < paramNames.length; i++) {
            Object value = paramValues[i];
            if (! (value instanceof Serializable)) {
                continue;
            }
            //如果是文件对象
            if (value instanceof MultipartFile) {
                MultipartFile file = (MultipartFile) value;
                value = file.getOriginalFilename();  //获取文件名
            }

            requestParams.put(paramNames[i], value);
        }

        return requestParams;
    }


## 4. 将该类声明为界面 并且将放置到spring容器中

```java
@Component
@Aspect

5.检查是否开启了自动注解

  • 如果是springboot 项目可以跳过这一步
  • 如果是使用sping mvc项目中需要在xml 检查是否有
<aop:aspectj-autoproxy/>
  • 如果是使用JavaConfig 形式的项目中需要在主javaConfig文件中添加
    @EnableAspectJAutoProxy 注解来开启切面

6. 启动项目，本地测试一下

正常结果如下

{
	"classMethod": "*******",
	"httpMethod": "GET",
	"ip": "127.0.0.1",
	"requestParams": {
		"pageSize": 10,
		"pageNum": 1
	},
	"result": {
		"code": 200,
		"msg": "成功"
	},
	"timeCost": 84,
	"url": "http://127.0.0.1:8090/*****"
}

异常结果

{
	"classMethod": "**",
	"exception": {
		"@type": "java.lang.ArithmeticException",
		"localizedMessage": "/ by zero",
		"message": "/ by zero",
		"stackTrace": [
			{
				"className": "com.bonc.huanghai.api.controller.oa.AnnouncementController",
				"fileName": "AnnouncementController.java",
				"lineNumber": 70,
				"methodName": "getAnnouncementList",
				"nativeMethod": false
			}
		]
	},
	"httpMethod": "GET",
	"ip": "127.0.0.1",
	"requestParams": {
		"pageSize": 10,
		"pageNum": 1
	},
	"timeCost": 96,
	"url": "http://127.0.0.1:8090/**"
}

代码

最后贴上所有的代码

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * @author sz
 * @version V1.0
 * @Description: 请求切面(用一句话描述该文件做什么)
 * @date 2021/2/6
 */
@Component
@Aspect
public class RequestLogAspect {

    private final static Logger LOGGER = LoggerFactory.getLogger(RequestLogAspect.class);



    /**
     *.AOP切入点表达式
     *
     *execution  * com.bonc.service..*.*(..)
     * execution 为切点修饰符
     *      第一个位 为访问修饰符可以不写
     *      第二个 *  方法返回值
     *      第三位为 报名 *代表所有 ..代表所欲子包
     *      第四位为 方法名
     *      第五位  （..）代表任意参数
     *      日志的入口一般为controller层所以切点为所有的controller
     *
     * */
    @Pointcut("execution(* com.bonc..controller..*(..))")
    public void logPointCut() {
    }

    @Around("logPointCut()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        RequestInfo requestInfo = new RequestInfo();
        requestInfo.setIp(request.getRemoteAddr());
        requestInfo.setUrl(request.getRequestURL().toString());
        requestInfo.setHttpMethod(request.getMethod());
        requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                proceedingJoinPoint.getSignature().getName()));
        requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));

        Object result =null;
        try {
           result = proceedingJoinPoint.proceed();

        }catch ( RuntimeException e){
            requestInfo.setException(e);
        }
        requestInfo.setResult(result);
        requestInfo.setTimeCost(System.currentTimeMillis() - start);
        LOGGER.info("Request Info      : {}", JSON.toJSONString(requestInfo));
        return  result;
    }



    /**
     * 获取入参
     * @param proceedingJoinPoint
     *
     * @return
     * */
    private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) {
        //参数名
        String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();
        //参数值
        Object[] paramValues = proceedingJoinPoint.getArgs();

        return buildRequestParam(paramNames, paramValues);
    }


    private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) {
        Map<String, Object> requestParams = new HashMap<>();
        for (int i = 0; i < paramNames.length; i++) {
            Object value = paramValues[i];
            if (! (value instanceof Serializable)) {
                continue;
            }
            //如果是文件对象
            if (value instanceof MultipartFile) {
                MultipartFile file = (MultipartFile) value;
                value = file.getOriginalFilename();  //获取文件名
            }

            requestParams.put(paramNames[i], value);
        }

        return requestParams;
    }

}


@Data
public class RequestInfo {

    private String ip;
    private String url;
    private String httpMethod;
    private String classMethod;
    private Object requestParams;
    private Object result;
    private Long timeCost;
    private RuntimeException exception;

}
踏雪江南
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java项目 日志框架+切面，完美记录
cat_book_milk的博客
07-22 1226
Java Spring Boot项目搭建日志框架，创建日志切面，方便追溯
SpringBoot项目中使用Aspect实现日志切面
白羊座的橙子
10-27 284
前言 仔代码检视时，讨论到在controller层手动添加日志太麻烦，于是想要注解和切面实现日志的自动输出，简化代码、简练程序 利用Aspect实现日志切面 1、添加aop依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </depen.
java项目增加统一切面日志输出，对于项目调试问题排查还是很有必要的
qq_40393739的博客
04-11 754
java项目增加统一切面日志输出，对于项目调试问题排查还是很有必要的。
Java利用Aop切面记录操作日志（注解方式）
m0_73774439的博客
05-20 1300
⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的 集中处理。⽽ AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。@Mapping/*** 操作具体某个功能的描述* @return*//*** 操作类型* @return*/@Aspect@Component@Autowired@Autowired@Autowired@Autowired// 获取request对象。
Java AOP切面日志处理
qq_36636312的博客
12-06 3198
1，引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2，配置日志切面 @Aspect @Component @Slf4j @Order(1) public class LogOperatio
java 日志切面_自定义注解+面向切面整合的日志记录模块（一）
weixin_32589387的博客
02-16 379
java中的常见注解jdk的自带注解@Override：告诉编译器我重写了接口方法@Deprecated：告诉编译器这个方法过时了，不建议使用，Ide会在方法上划横线@SuppressWarnings("deprecation"):关闭方法中出现的警告元注解元注解的作用就是注解其他注解，一般我们使用自定义注解时，就需要用元注解来标注我们自己的注解，一共有以下四个元注解1.@Target：说明了An...
springboot配置aop切面日志打印过程解析
08-25
Spring Boot 配置 AOP 切面日志打印过程解析 本文主要介绍了 Spring Boot 配置 AOP 切面日志打印过程解析，通过示例代码详细讲解了 AOP 的概念、相关概念、AOP 代理、织入等知识点，并提供了实际的代码示例。 一、...
应用市场中Java拦截器和切面的使用实例详解
08-28
例如，我们可以创建一个简单的日志切面： ```java @Aspect @Component public class LoggingAspect { @Before("execution(* com.example.myapp.controller.*.*(..))") public void logBefore(JoinPoint joinPoint...
面向切面编程PPT（Java语言）
12-22
面向切面编程（Aspect-Oriented Programming，AOP）是一种编程范式，旨在将横切关注点（如日志、事务管理和安全性）从核心业务逻辑中分离出来，以提高代码的可读性和可维护性。Java语言中的AOP是通过Spring框架等库...
JAVA简单AOP切面编程；依赖注入；代码配置Bean源码
10-07
AOP在Spring框架中得到了广泛的应用，允许开发者定义“切面”，这些切面可以包含业务逻辑的各个部分，如日志、事务管理或安全控制。 1. **AOP概念** - **切面（Aspect）**：是AOP的核心，它封装了横切关注点，比如...
spring aop 切面添加日志
06-22
在Java配置类中，我们可以使用`@EnableAspectJAutoProxy`注解来启用AOP支持。 ```java @Configuration @EnableAspectJAutoProxy public class AppConfig { // ... } ``` 接下来，我们需要创建一个切面类，它将...
java_切面日志
weixin_30797027的博客
08-17 135
切面日志举例 package com.keyba1; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** ...
Java定义日志切面
shyの个人笔记
07-14 278
Java定义日志切面, 打印每个接口的入参和出参
Java使用AOP操作日志，傻瓜版
Likeslowsongs的博客
06-02 686
面向切面的操作日志
java通过自定义注解实现切面记录操作日志
AcmenTT的博客
05-21 1245
java通过自定义注解实现切面记录操作日志自定义注解java.lang.annotation为开发者提供的元注解日志自定义注解实例日志切面实现在业务逻辑中使用自定义注解记录操作日志 自定义注解 java.lang.annotation为开发者提供的元注解 @Documented – 注解是否将包含在JavaDoc中 @Retention – 定义该注解的生命周期 @Target – 注解用于什么地方 @Inherited – 是否允许子类继承该注解 1.）@Retention – 定义该注解的生命周期 ●
Java实现AOP切面记录日志实例
熟人介绍的的博客
01-19 4536
注：一个可以直接拿去用的aop切面保存系统操作日志的实例，应用框架为SpringMVC。 需求描述： 管理员要在系统中能看到每个账户的操作记录、时间、账户名称、ip。 实现步骤： 1、实现自定义注解MethodLog 2、建日志实体Bean 3、实现监听注解，调用切面实现类 4、配置启动对@AspectJ注解的支持及监听类 5、业务Controller引用 具体实现： 1、建一个接口类，内容如下 ...
操作日志统一处理（切面）
qq_32627651的博客
03-02 1203
1，简介： 日志切面可以通过在方法上加注解，记录操作日志入库 具体参考：https://www.cnblogs.com/inspred/p/10385005.html 2，上代码 org.springframework.boot spring-boot-starter-aop <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver&l
面向切面编程：操作日志
qq_49005459的博客
09-17 547
在项目中，操作日志至关重要，操作日志记录的是：谁干了什么事； 我们可以利用面向切面编程实现操作日志的打印与记录： 1.首先，添加依赖： <!--spring aop 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifact
java 记录日志切面工具类
caibi_A的博客
11-18 380
快速编写一个日志打印工具
java spring aop切面demo
最新发布
06-21
Java Spring AOP (Aspect Oriented Programming) 是一种编程范式，它通过将应用的业务逻辑和系统关注点（如日志、事务管理等）分离，提高了代码的可维护性和复用性。下面是一个简单的Spring AOP切面（Aspect）的Demo示例： 首先，你需要在Spring配置文件中启用AOP支持，并定义一个切面（Aspect）： ```xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:aspectj="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/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 启用AOP --> <aop:aspectj-autoproxy/> <!-- 定义切面 --> <bean id="myAspect" class="com.example.MyAspect"> <!-- 配置通知（advice） --> <property name="beforeAdvice" ref="beforeAdvice"/> </bean> <!-- 定义通知 --> <bean id="beforeAdvice" class="com.example.BeforeAdvice"/> </beans> ``` 然后，创建一个`MyAspect`切面类，通常包含通知（advice），例如前置通知（BeforeAdvice）： ```java import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; @Aspect public class MyAspect { @Before("execution(* com.example.service.*.*(..))") public void beforeAdvice(JoinPoint joinPoint) { // 在方法执行前添加的操作，如日志记录 System.out.println("Method " + joinPoint.getSignature() + " is about to execute."); } } ``` 在这个例子中，`@Before`注解定义了一个前置通知，它将在`com.example.service`包下的所有方法执行前执行。 接下来，创建`BeforeAdvice`类，这是一个具体的通知实现： ```java public class BeforeAdvice { // 可能包含一些自定义逻辑，比如参数检查或资源获取 } ``` 相关问题--: 1. Spring AOP中的通知有哪些类型？ 2. `@Aspect`注解在Spring AOP中的作用是什么？ 3. 如何在Spring中配置切点（execution表达式）？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值