springboot通过aop实现日志打印

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

1、通过springboot创建web项目gktjweb ,pom文件如下：
 

<?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 http://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.1.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zr</groupId>
    <artifactId>gktjweb</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gktjweb</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.3</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.7</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.10</version>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.8.3</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupId>net.sf.ezmorph</groupId>
            <artifactId>ezmorph</artifactId>
            <version>1.0.6</version>
        </dependency>

        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20160810</version>
        </dependency>
        <dependency>
            <groupId>de.odysseus.staxon</groupId>
            <artifactId>staxon</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>xom</groupId>
            <artifactId>xom</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.6</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2、引入日志文件：logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
	<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
	<property name="LOG_HOME" value="D:/gktjlog" />
	<!-- 控制台输出 -->
	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
			<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
		</encoder>
	</appender>
	<!-- 按照每天生成日志文件 -->
	<appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<!--日志文件输出的文件名-->
			<FileNamePattern>${LOG_HOME}/gktj.log.%d{yyyy-MM-dd}.log</FileNamePattern>
			<!--日志文件保留天数-->
			<MaxHistory>30</MaxHistory>
		</rollingPolicy>
		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
			<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
		</encoder>
		<!--日志文件最大的大小-->
		<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
			<MaxFileSize>100MB</MaxFileSize>
		</triggeringPolicy>
	</appender>

	<!-- 日志输出级别 -->
	<root level="INFO">
		<appender-ref ref="STDOUT" />
		<appender-ref ref="FILE" />
	</root>
	<!--日志异步到数据库 -->
	<!--<appender name="DB" class="ch.qos.logback.classic.db.DBAppender">-->
	<!--&lt;!&ndash;日志异步到数据库 &ndash;&gt;-->
	<!--<connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">-->
	<!--&lt;!&ndash;连接池 &ndash;&gt;-->
	<!--<dataSource class="com.mchange.v2.c3p0.ComboPooledDataSource">-->
	<!--<driverClass>com.mysql.jdbc.Driver</driverClass>-->
	<!--<url>jdbc:mysql://127.0.0.1:3306/databaseName</url>-->
	<!--<user>root</user>-->
	<!--<password>root</password>-->
	<!--</dataSource>-->
	<!--</connectionSource>-->
	<!--</appender>-->
</configuration>

3、创建controller层

package com.zr.gktjweb.controller;

import com.zr.gktjweb.annotation.Log;
import com.zr.gktjweb.common.HttpClientUtil;
import com.zr.gktjweb.common.ResponseBean;
import com.zr.gktjweb.constant.SysCode;
import com.zr.gktjweb.model.SysUser;
import com.zr.gktjweb.util.MapUtil;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.zr.gktjweb.util.JSONUtils;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;

@RestController
public class LoginController {
    @Value("${baseurl}")
    private String baseurl;
    @Value("${login_url}")
    private String loginUrl;
    private static final Logger LOGGER = LoggerFactory.getLogger(LoginController.class);
    @ApiOperation(value = "登录", notes = "登录验证")
    @ApiImplicitParams({@ApiImplicitParam(name = "username", value = "姓名", required = true, dataType = "String"),
            @ApiImplicitParam(name = "password", value = "密码", required = true, dataType = "String")
    })
    @RequestMapping(value = "/login.do", method = RequestMethod.POST)
    @Log(value = "登录", description = "登录操作")
    public ResponseBean login(HttpSession session, String username, String password) {
        String url = baseurl + loginUrl;
        Map<String, String> map = new HashMap<>();
        map.put("username", username);
        map.put("password", password);
        String result = "";
        //请求服务失败
        try {
            result = HttpClientUtil.doPost(url, map);
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("用户登录",e);
            return new ResponseBean(SysCode.errorCode, "系统异常，请联系管理员", "");
        }
        JSONObject json = JSONObject.fromObject(result);
        //登录验证未通过
        if (!json.getString("code").equals(SysCode.successCode + "")) {
            ResponseBean responseBean = JSONUtils.jsonToObject(ResponseBean.class, result);
            return responseBean;
        }
        //验证通过，在session中设置token
        JSONObject dataJson = (JSONObject) json.get("data");
        String userJson = dataJson.getString("user");
        SysUser sysUser = JSONUtils.jsonToObject(SysUser.class, userJson);
        JSONObject tokenJson = (JSONObject) dataJson.get("token");
        String token = tokenJson.getString("token");
        session.setAttribute("token", token);
        session.setAttribute("user", sysUser);
        String url1 = "/pages/index.html";
        Map<String, Object> resMap = new HashMap<>();
        resMap.put("url", url1);
        return new ResponseBean(SysCode.successCode, "登录成功", resMap);
    }

    /**
     * 注销登录
     *
     * @param request
     * @return
     */
    @GetMapping("/loginout.do")
    public String loginOut(HttpServletRequest request) {
        request.getSession().invalidate();
        return "/";
    }
}

4、创建日志注解Log

package com.zr.gktjweb.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
    String value() default "";
    String description() default "";
}

5、创建切面：aspect

package com.zr.gktjweb.aspect;

import com.zr.gktjweb.model.SysUser;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
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;

/**
 * web请求日志切面类---专门针对控制层，如谁被请求了，花了多少时间，请求发送的参数，返回得值等
 */
@Aspect     // 表示一个切面bean
@Component  // bean容器的组件注解。虽然放在contrller包里，但它不是控制器。如果注入service,但我们又没有放在service包里
@Order(3)   // 有多个日志时，ORDER可以定义切面的执行顺序（数字越大，前置越后执行，后置越前执行）
public class WebLogAspect {
    //定义一个日志记录器
    Logger logger = LoggerFactory.getLogger(this.getClass());
    //定义一个线程本地变量，记录各个线程开始的时间
    ThreadLocal<Long> starttime = new ThreadLocal<Long>();

    /**
     * 定义一个切入点
     */
    @Pointcut("execution(public * com.*.*.controller.*.*(..))")
    public void weblog() {
    }

    @Before("weblog()")
    public void doBefore(JoinPoint joinPoint) {
        starttime.set(System.currentTimeMillis());

        //获取servlet请求对象---因为这不是控制器，这里不能注入HttpServletRequest，但springMVC本身提供ServletRequestAttributes可以拿到
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        SysUser sysUser=(SysUser) request.getSession().getAttribute("user");
        String userName="";
        if(sysUser!=null) {
            userName = sysUser.getUsername();
        }
        StringBuffer beforeInfo = new StringBuffer();
        String log= LogRecord.getOperationLog(joinPoint.getTarget());
        beforeInfo.append(log)
                .append("执行前:\r\n")
                .append("用户："+userName+"\r\n")
                .append("URL:" + request.getRequestURL().toString() + "\r\n")
                .append("Method:" + request.getMethod() + "\r\n")
                .append("CLASS_METHOD:" + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName() + "\r\n")
                .append("ARGS:" + Arrays.toString(joinPoint.getArgs()));
        logger.info(beforeInfo.toString());
    }

    //方法的返回值注入ret
    @AfterReturning(returning = "ret", pointcut = "weblog()")
    public void doafter(Object ret) {
        StringBuffer afterInfo = new StringBuffer();
        afterInfo.append("执行后：\r\n")
                .append("RESPONSE:" + ret + "\r\n")      // 响应的内容---方法的返回值responseEntity
                .append("SPEND:" + (System.currentTimeMillis() - starttime.get()));
        logger.info(afterInfo.toString());
    }

    /**
     * 在方法出现异常时会执行的代码
     * 可以访问到异常对象，可以指定在出现特定异常时在执行通知代码
     */
    @AfterThrowing(pointcut = "weblog()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
        logger.error(methodName, ex);
    }
}

package com.zr.gktjweb.aspect;




import com.zr.gktjweb.annotation.Log;

import java.lang.reflect.Method;

public class LogRecord {
    public static String getOperationLog(Object obj){
        Class<?> clazz=obj.getClass();
        Method[] methods=clazz.getMethods();
        StringBuffer result= new StringBuffer();
        for (int i = 0; i < methods.length; i++) {
            Method method=methods[i];
            Log logAnnotaion=(Log)method.getAnnotation(Log.class);
            if(logAnnotaion!=null){
                result.append("\r\n模块:"+logAnnotaion.value()+"\r\n")
               .append("描述:"+logAnnotaion.description()+"\r\n");
            }

        }
    return result.toString();
    }

}

 

aiyongbo123456
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring aop 实现日志打印
weixin_45301274的博客
07-21 619
spring aop 实现日志打印
springBoot Aop打印日志
weixin_48164819的博客
04-10 1136
springBoot Aop打印日志 1.类上加@Aspect，@Component注解 2.@Pointcut()定义一个切点，里面填写路径，一般是所有controller中的所有方法，所有的参数 3.通知类型： @Before()前置通知，里面填写切点，即在方法执行前执行； @After()后置通知，里面填写切点，即在方法执行后执行； @Around()环绕通知，里面填写切点，即在方法执行前后都执行； import com.alibaba.fastjson.JSONObject; import co
【十一】图解SpringBoot AOP实现原理
最新发布
作者：大头兵（kit）
05-27 1003
经过一段时间的写作之后，经常有一个想法在脑海里盘旋，怎么样写出和其他博主不一样的内容呢？经过反复思考和重新审视了自己之前推出的文章之后，发现之前的文章质量并不太高，于是我想到了图解的方式，就和自己在理解产品需求和做软件设计那样的方式把一项技术讲清楚，所以今后将会通过图解的方式把每一个主题讲清楚。
SpringBoot之采用AOP统一打印日志信息
彼岸舞的博客
01-26 140
SpringBoot之采用AOP统一打印日志信息 添加MAVEN依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency&gt...
spring AOP简单运用：打印日志
星坠竹空
11-01 321
场景说明：在开发调试时，总是需要打断点来看哪个方法错误了，哪些参数传错了，在很多情况下如果直接能从日志中拿到是执行了哪个类的哪个方法，并且知道方法参数情况，可能会大大减少调试时间，一种做法是在相应的方法上加上日志，这样会非常的烦人，重复工作很多，而且为了完全，可能在上线的时候还要去除，在这种场景下使用AOP是非常合适的，AOP可以达到一次配置，到处使用的效果。 1.xml配置方式： applica...
SpringBoot使用AOP统一处理日志
weixin_43890927的博客
06-28 1162
查看数据 http://127.0.0.1:8080//api/logs/list。准备sys_log日志表（mysql）2.2 annotation包。2.4 aspect包（核心）Action 日 志 分 类。Log 实现 Aop 切面类。SysLog（日志模型）2.1 domain包。2.3 common包。
SpringBoot AOP处理请求日志打印功能代码实例
08-19
SpringBoot AOP处理请求日志打印功能代码实例 本资源主要介绍了如何使用SpringBoot中的AOP（Aspect-Oriented Programming）来处理请求日志打印功能。通过示例代码，详细介绍了如何使用AOP来记录操作日志，包括请求...
springboot配置aop切面日志打印过程解析
08-25
本文主要介绍了 Spring Boot 配置 AOP 切面日志打印过程解析，通过示例代码详细讲解了 AOP 的概念、相关概念、AOP 代理、织入等知识点，并提供了实际的代码示例。 一、AOP 说明 AOP（Aspect-Oriented Programming...
SpringBoot中使用AOP打印接口日志的方法
08-27
SpringBoot中使用AOP打印接口日志的方法是指通过Aspect Oriented Programming（面向切面编程）在SpringBoot框架中实现打印接口日志的功能。本篇文章将详细介绍AOP的概念、Spring AOP的实现、AOP在SpringBoot中的应用...
SpringBoot+AOP+TraceID.pdf
01-04
SpringBoot+AOP+TraceID.pdf ...本文档展示了 AOP 在 SpringBoot 中的应用，以及如何使用 AOP 和 TraceID 来实现日志链。AOP 可以使得代码更加灵活和可维护，而 TraceID 可以帮助我们更好地跟踪和分析日志记录。
springboot如何使用AOP做访问请求日志
08-25
SpringBoot 中实现访问请求日志是通过 Aspect-Oriented Programming（AOP）的技术来实现的。AOP 的主要思想是将跨越多个类和对象的功能分离出来，形成一个独立的模块，以便于维护和重用。 在 SpringBoot 中，使用 ...
SpringBoot基于AOP拦截请求打印日志
今天又是充满希望的一天
12-08 5770
一：需求背景.       1.1 现在需要在特定的方法执行前后,做一些日志处理,尽可能不要写重复代码,优雅的完成处理方法日志打印.       1.2 简单实现分析：如果在一些方法里面都打日志,这种方式是最易使用,但是从可维护,可扩展,耦合度来分析确实差的.       1.3 集中处理方式：既然系统中的异常都全局处理,也是用AOP全局集中拦截处理日志,岂不是更好一下呐.定义切面功能,定义...
springboot集成AOP实现日志输出
u012565281的博客
01-19 662
开发接口系统中主要的一环就是日志输出，如果系统出现问题，日志能帮我们去定位问题，最常见的日志是调用方 所调用的IP 接口地址 对应方法 参数值 以及接口方接收到请求 所返回的参数。如果这需要在每一个controller层去写的话代码过于重复，于是就使用AOP定义切面 对其接口调用前后进行拦截日志输出。 1、加入依赖 <dependency> <groupId>org.springframework.boot</groupId>
Spring Boot 2.x 教程系列 | AOP 切面统一打印请求日志
weixin_34290352的博客
02-20 386
文章首发于个人网站 [www.exception.site/springboot/…) 本节中，您将学习如何在 Spring Boot 中使用 AOP 切面统一处理请求日志，打印进出参相关参数。 一、先看看日志输出效果 Spring Boot AOP 打印日志 可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数： URL: 请求接口地址； HTTP Method: 请求的方法...
java 注解结合 spring aop 实现自动输出日志
09-02 472
auto-log auto-log 是一款为 java 设计的自动日志监控框架。 创作目的 经常会写一些工具，有时候手动加一些日志很麻烦，引入 spring 又过于大材小用。 所以希望从从简到繁实现一个工具，便于平时使用。 特性 基于注解+字节码，配置灵活 自动适配常见的日志框架 支持编程式的调用 支持注解式，完美整合 spring 支持整合 spring-boot 支持慢日志阈值指定，耗时，入参，出参，异常信息等常见属性指定 变更日志 核心原理 注解定义 import ja
小程序(二)——wxml中切割字符串
weixin_39592397的博客
07-28 290
package com.example.demo.controller; 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;.
使用 Spring 的 AOP 机制来输出 Log
rainbow702的博客
07-28 5902
使用 Spring 的 AOP 机制来输出 Log
【七】springboot整合AOP实现日志操作
热门推荐
weixin_56995925的博客
09-07 1万+
springboot整合AOP实现日志操作
Spring Boot AOP 扫盲，实现接口访问的统一日志记录
沉默王二
02-22 7087
AOP 是 Spring 体系中非常重要的两个概念之一（另外一个是 IoC），今天这篇文章就来带大家通过实战的方式，在编程猫 SpringBoot 项目中使用 AOP 技术为 controller 层添加一个切面来实现接口访问的统一日志记录。 一、关于 AOP AOP，也就是 Aspect-oriented Programming，译为面向切面编程，是计算机科学中的一个设计思想，旨在通过切面技术为业务主体增加额外的通知（Advice），从而对声明为“切点”（Pointcut）的代码块进行统一管理和装饰。 这
springboot3 aop
10-09
Spring Boot是一个用于创建基于Spring框架的Java应用程序的开源框架，它提供了许多功能，包括AOP（面向切面编程）。要在Spring Boot中使用AOP，可以按照以下...这个切面类会在调用某个service方法之前打印一条日志。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值