SpringCloud中使用Filter进行记录获取用户请求行为日志

不念不忘少年蓝@ 2022-09-02 04:24 73阅读 0赞

以下代码放在公共部分里，然后用其他模块去引用这个模块！！！

由于里面用到了数据库，在权限校验的情况下，不能进行验证，所以使用了原生jdbc的方式。

common-log：

maven：

<dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>4.0.1</version>
            </dependency>

HttpRequestLogFilter：

package cn.com.yusys.aiops.filter;
    
    import cn.com.yusys.aiops.common.core.constant.CommonConstants;
    import cn.com.yusys.aiops.jdbc.JdbcUtils;
    import cn.com.yusys.aiops.upms.api.entity.HttpRequestLog;
    import com.alibaba.fastjson.JSON;
    import lombok.RequiredArgsConstructor;
    import org.springframework.core.Ordered;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.text.SimpleDateFormat;
    import java.util.TimeZone;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2021, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2021/7/28 11:06
     * @Version: 1.0
     * @Description:
     */
    @WebFilter(filterName="httpRequestLogFilter", urlPatterns="/*")
    @RequiredArgsConstructor
    public class HttpRequestLogFilter implements Filter, Ordered {
    
        private final JdbcUtils jdbcUtils;
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            try {
                ReWriteHttpServletRequestWrapper httpServletRequest = new ReWriteHttpServletRequestWrapper((HttpServletRequest) servletRequest);
                ReWriteHttpServletResponseWrapper httpServletResponse = new ReWriteHttpServletResponseWrapper((HttpServletResponse) servletResponse);
                filterChain.doFilter(httpServletRequest, httpServletResponse);
    
                if (!CommonConstants.REQUEST_LOG_SELF_URL_PATH.equalsIgnoreCase(httpServletRequest.getServletPath())){
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                    simpleDateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
                    HttpRequestLog httpRequestLog = HttpRequestLog
                            .builder()
                            .ip(httpServletRequest.getRemoteAddr())
                            .module(httpServletRequest.getServletPath().split("/")[1])
                            .role(httpServletRequest.getRemoteUser())
                            .hostname(httpServletRequest.getRemoteHost())
                            .requestMethod(httpServletRequest.getMethod())
                            .queryParams(JSON.toJSONString(httpServletRequest.getParameterMap()))
                            .postBody(httpServletRequest.getBody())
                            .requestFullPath(httpServletRequest.getServletPath())
                            .httpRequestPath(httpServletRequest.getPathInfo())
                            .httpStatus(String.valueOf(httpServletResponse.getStatus()))
                            .responseBody(new String(httpServletResponse.getContent(), StandardCharsets.UTF_8))
                            .createDate(simpleDateFormat.format(System.currentTimeMillis()))
                            .build();
    
                    //处理插入数据库
                    Connection connection = jdbcUtils.getConnection();
                    try {
                        PreparedStatement preparedStatement = connection.prepareStatement("insert into `http_request_log`(" +
                                "ip,module,role,hostname,request_method,query_params,post_body,request_full_path,http_request_path,http_status,response_body,create_date)  " +
                                " values (?,?,?,?,?,?,?,?,?,?,?,?)");
    
                        int index = 0;
                        preparedStatement.setString(++index,httpRequestLog.getIp());
                        preparedStatement.setString(++index,httpRequestLog.getModule());
                        preparedStatement.setString(++index,httpRequestLog.getRole());
                        preparedStatement.setString(++index,httpRequestLog.getHostname());
                        preparedStatement.setString(++index,httpRequestLog.getRequestMethod());
                        preparedStatement.setString(++index,httpRequestLog.getQueryParams());
                        preparedStatement.setString(++index,httpRequestLog.getPostBody());
                        preparedStatement.setString(++index,httpRequestLog.getRequestFullPath());
                        preparedStatement.setString(++index,httpRequestLog.getHttpRequestPath());
                        preparedStatement.setString(++index,httpRequestLog.getHttpStatus());
                        preparedStatement.setString(++index,httpRequestLog.getResponseBody());
                        preparedStatement.setString(++index,httpRequestLog.getCreateDate());
    
                        preparedStatement.execute();
                    }
                    catch (Exception exception){
                        throw exception;
                    }
                    finally {
                        jdbcUtils.closeConnection(connection);
                    }
                }
    
                servletResponse.getOutputStream().write(httpServletResponse.getContent());
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    
        @Override
        public int getOrder() {
            return 520;
        }
    }

ReWriteHttpServletRequestWrapper：

package cn.com.yusys.aiops.filter;
    
    import lombok.Data;
    
    import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    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;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2021, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2021/7/28 14:54
     * @Version: 1.0
     * @Description:
     */
    public class ReWriteHttpServletRequestWrapper extends HttpServletRequestWrapper {
        private String body;
        public ReWriteHttpServletRequestWrapper(HttpServletRequest request) {
            super(request);
            try {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(request.getInputStream()));
                String line = null;
                StringBuilder bodyBuilder = new StringBuilder();
                while ((line = bufferedReader.readLine())!= null){
                    bodyBuilder.append(line);
                }
                body = bodyBuilder.toString();
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException {
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8));
    
            return new ServletInputStream() {
                @Override
                public int read() throws IOException {
                    return byteArrayInputStream.read();
                }
    
                @Override
                public boolean isFinished() {
                    return byteArrayInputStream.read() == -1;
                }
    
                @Override
                public boolean isReady() {
                    return false;
                }
    
                @Override
                public void setReadListener(ReadListener readListener) {
    
                }
            };
        }
    
        public String getBody() {
            return body;
        }
    }

ReWriteHttpServletResponseWrapper ：

package cn.com.yusys.aiops.filter;
    
    import javax.servlet.ServletOutputStream;
    import javax.servlet.WriteListener;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpServletResponseWrapper;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    
    public class ReWriteHttpServletResponseWrapper extends HttpServletResponseWrapper {
        private ByteArrayOutputStream buffer;
        private ServletOutputStream out;
    
        public ReWriteHttpServletResponseWrapper(HttpServletResponse httpServletResponse) {
            super(httpServletResponse);
            buffer = new ByteArrayOutputStream();
            out = new WrapperOutputStream(buffer);
        }
    
        @Override
        public ServletOutputStream getOutputStream() throws IOException {
            return out;
        }
    
        @Override
        public void flushBuffer() throws IOException {
            if (out != null) {
                out.flush();
            }
        }
    
        public byte[] getContent() throws IOException {
            flushBuffer();
            return buffer.toByteArray();
        }
    
        public static class WrapperOutputStream extends ServletOutputStream {
            private ByteArrayOutputStream bos;
    
            public WrapperOutputStream(ByteArrayOutputStream bos) {
                this.bos = bos;
            }
    
            @Override
            public void write(int b) throws IOException {
                bos.write(b);
            }
    
            @Override
            public boolean isReady() {
                return false;
            }
    
            @Override
            public void setWriteListener(WriteListener arg0) {
    
            }
        }
    
    }

JdbcEntityConfiguration：

package cn.com.yusys.aiops.jdbc;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2021, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2021/7/30 10:04
     * @Version: 1.0
     * @Description:
     */
    @Data
    @Configuration
    @ConfigurationProperties(prefix = "spring.datasource")
    public class JdbcEntityConfiguration {
        private String url;
        private String username;
        private String password;
    }

JdbcUtils ：

package cn.com.yusys.aiops.jdbc;
    
    import cn.com.yusys.aiops.common.core.util.StringUtils;
    import lombok.RequiredArgsConstructor;
    import org.springframework.stereotype.Component;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.util.Arrays;
    import java.util.stream.Stream;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2021, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2021/7/30 10:03
     * @Version: 1.0
     * @Description:
     */
    @Component
    @RequiredArgsConstructor
    public class JdbcUtils {
    
        private final JdbcEntityConfiguration jdbcEntityConfiguration;
    
        public Connection getConnection() {
            String url = jdbcEntityConfiguration.getUrl();
            String[] splitArray = url.split("\\?");
            String[] splitSchemeArray = splitArray[0].split("/");
            StringBuilder schemeStringBuilder = new StringBuilder();
            for (int i=0;i<splitSchemeArray.length - 1;i++){
                schemeStringBuilder.append(splitSchemeArray[i]).append("/");
            }
    
            url = schemeStringBuilder.toString() + "yusys_aiops_upms" + "?" + splitArray[1];
            Connection connection = null;
            try {
                connection = DriverManager.getConnection(
                        url,
                        jdbcEntityConfiguration.getUsername(),
                        jdbcEntityConfiguration.getPassword());
            }
            catch (Exception e){
                throw new RuntimeException("连接数据库异常.");
            }
    
            return connection;
        }
    
        public void closeConnection(Connection connection) {
            if (null != connection){
                try {
                    connection.close();
                }
                catch (Exception e){
                    throw new RuntimeException("数据库连接池关闭异常.");
                }
            }
        }
    }