自定义SpringBoot start 自动打印日志

最新推荐文章于 2024-10-04 14:48:21 发布

YXWik6

最新推荐文章于 2024-10-04 14:48:21 发布

阅读量723

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.youkuaiyun.com/YXWik/article/details/118057626

java 专栏收录该内容

27 篇文章

订阅专栏

本文介绍了如何在Spring Boot项目中创建一个名为`TraceLogFilter`的过滤器，用于记录请求的详细日志，包括开始时间、结束时间、请求参数等。同时，还展示了自定义的`RequestUrlFilterAutoConfiguration`自动配置类，使得在应用中启用该过滤器更加方便。通过`@EnableLogFilter`注解，可以便捷地在启动类上启用日志打印功能，或者通过`spring.factories`配置实现自动化。此外，还提供了过滤器的实现细节，包括请求体的读取和包装。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.新建Maven项目
在这里插入图片描述

项目创建成功了
然后添加文件

依赖：

<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>

        <!-- 在编译时会自动收集配置类的条件，写到一个 META-INF/spring-autoconfigure-metadata.properties中-->
        <dependency>
            <groupId> org.springframework.boot </groupId>
            <artifactId> spring-boot-autoconfigure-processor </artifactId>
            <optional> true </optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.53</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 编译时依赖springboot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>compile</scope>
        </dependency>
        <!--常用工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>
        </plugins>
    </build>

1.TraceLogFilter 过滤器

package com.logstart.filter;



import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;

/**
 * @author: YXY
 * @date: 2021/2/5 11:17
 * @Version 1.0
 */


@Component
public class TraceLogFilter implements Filter {


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

    private final String TRACE_ID = "traceId";// 线程追踪ID

    @Override
    public void destroy() {
        MDC.remove(TRACE_ID);
    }

    @Override
    public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2) throws IOException, ServletException {
        String contentType = arg0.getContentType();
        if (!(arg0 instanceof HttpServletRequest) || (contentType != null && contentType.contains("multipart/form-data"))) {
            arg2.doFilter(arg0, arg1);
            return;
        }

        StopWatch sw = new StopWatch();
        String startDate= getTimeSSS();
        sw.start();
        MDC.put(TRACE_ID, UUID.randomUUID().toString().replaceAll("-", ""));
        HttpServletRequest req = (HttpServletRequest) arg0;
        FilterRequestWrapper xrw = new FilterRequestWrapper(req);// 防止流读取一次后，Controller无法获取流数据
        arg2.doFilter(xrw, arg1);
        sw.stop();
        String endDate= getTimeSSS();
        // 汇总请求信息数据
        LOGGER.info("测试---接口地址：[{}] 开始请求时间：[{}]", xrw.getRequestURI(), startDate);
        if(isNotEmpty(xrw.getQueryString())){
            LOGGER.info("测试---接口地址：[{}] 请求query参数：[{}]", xrw.getRequestURI(), xrw.getQueryString().replaceAll("\r\n", ""));
        }
        if(isNotEmpty(xrw.getBody())){
            LOGGER.info("测试---接口地址：[{}] 请求body参数：[{}]", xrw.getRequestURI(), xrw.getBody().replaceAll("\r\n", ""));
        }
        LOGGER.info("测试---接口地址：[{}] 结束请求时间：[{}]", xrw.getRequestURI(), endDate);
        LOGGER.info("测试---接口地址：[{}] 耗费时间：[{}ms]", xrw.getRequestURI(),  sw.getTotalTimeMillis());
    }

    class FilterRequestWrapper extends HttpServletRequestWrapper {
        private String body;

        public FilterRequestWrapper(HttpServletRequest request) throws IOException {
            super(request);

            // 读取数据
            StringBuffer sb = new StringBuffer();
            BufferedReader br = new BufferedReader(new InputStreamReader(request.getInputStream(), "UTF-8"));
            char[] charBuffer = new char[128];
            int bytesRead = -1;
            while ((bytesRead = br.read(charBuffer)) > 0) {
                sb.append(charBuffer, 0, bytesRead);
            }
            body = sb.toString();
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            final ByteArrayInputStream bais = new ByteArrayInputStream(body.getBytes("UTF-8"));
            return new ServletInputStream() {
                @Override
                public int read() throws IOException {
                    return bais.read();
                }

                @Override
                public boolean isFinished() {
                    return false;
                }

                @Override
                public boolean isReady() {
                    return false;
                }

                @Override
                public void setReadListener(ReadListener readListener) {

                }
            };
        }

        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(this.getInputStream(), StandardCharsets.UTF_8));
        }

        public String getBody() {
            return this.body;
        }
    }

    //时间格式处理
    public static final String getTimeSSS()
    {
        return dateTimeNow("yyyy-MM-dd HH:mm:ss.SSS");
    }
    public static final String dateTimeNow(final String format) {
        return parseDateToStr(format, new Date());
    }
    public static final String parseDateToStr(final String format, final Date date) {
        return new SimpleDateFormat(format).format(date);
    }

    /**
     * * 判断一个字符串是否为非空串
     *
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }
    public static boolean isEmpty(String str)
    {
        return isNull(str) || "".equals(str.trim());
    }
    public static boolean isNull(Object object)
    {
        return object == null;
    }
}

2.RequestUrlFilterAutoConfiguration 自定义自动配置类

package com.logstart.configuration;

import com.logstart.filter.TraceLogFilter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author: YXY
 * @date: 2021/6/19 13:40
 * @Version 1.0
 * .自定义自动配置类
 *
 * @ConditionalOnClass(TraceLogFilter.class) 只有类路径下存在TraceLogFilter才加载这个配置类
 * @ConditionalOnMissingBean(TraceLogFilter.class) 只有容器中没有TraceLogFilter Bean的时候才注入
 */
@Configuration
@ConditionalOnClass(TraceLogFilter.class)
public class RequestUrlFilterAutoConfiguration {


    @ConditionalOnMissingBean(TraceLogFilter.class)
    @Bean
    public FilterRegistrationBean<TraceLogFilter> requestUrlFilter() {

        FilterRegistrationBean<TraceLogFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new TraceLogFilter());
        registrationBean.addUrlPatterns("/*");
        registrationBean.setName("traceLogFilter");
        registrationBean.setOrder(1);
        return registrationBean;
    }

}

2.EnableLogFilter 自定义注解，依赖本jar包后，可以在SpringBoot启动类上添加此注解实现日志打印

package com.logstart.annotation;

import com.logstart.configuration.RequestUrlFilterAutoConfiguration;
import org.springframework.context.annotation.Import;

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

/**
 * @author: YXY
 * @date: 2021/6/19 13:44
 * @Version 1.0
 * 使自动配置类 RequestUrlFilterAutoConfiguration 生效的注解
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import(RequestUrlFilterAutoConfiguration.class)
public @interface EnableLogFilter {
}

4 .spring.factories 这个是Springboot 自动扫描、自动装配（可以不用自定义注解就实现自动打印）

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.logstart.configuration.RequestUrlFilterAutoConfiguration

步骤3和4 选一个就行
3是需要添加了依赖后，在用的项目中启动类上添加此注解才可以生效
4是自动化的什么都不需要，只要添加了依赖就行