标签：return String 前后 request public new import 日志 拦截

一、使用说明

1.1开发目的

便于前后端针对请求入参、格式做一个直观判断、以及采用的后端Controller接收方式采用RequestBody&RequestParam。

1.2集成方式

1.2.1 Spring项目

1.2.1.1pom引入jar包

<dependency>
    <groupId>com.hecore</groupId>
    <artifactId>common-bdp</artifactId>
    <version>v-1.0</version>
</dependency>

1.2.1.2web.xml

<!--配置请求封装,用于拦截请求日志-->
<filter>
   <filter-name>ServletRequestWrapperFilter</filter-name>
   <filter-class>com.epoch.core.log.request.trans.RequestWrapperFilter</filter-class>
   <init-param>
   <param-name>encoding</param-name>
   <param-value>utf-8</param-value>
   </init-param>
</filter>

<filter-mapping>
   <filter-name>ServletRequestWrapperFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
<!--end-->

1.2.1.3logInterceptor.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc" 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/mvc
      http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.epoch.core.log.impl.ConsoleLogHandler"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

1.2.1.4springMvc.xml

<import resource="logInterceptor.xml"/>

1.2.2Springboot项目

1.2.2.1pom引入jar包

<dependency>
    <groupId>com.hecore</groupId>
    <artifactId>common-bdp</artifactId>
    <version>v-1.0</version>
</dependency>

1.2.2.2配置过滤器

package com.hecore.cbs.config;

import com.epoch.core.log.request.trans.RequestWrapperFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {
 
    @Bean
    public FilterRegistrationBean registFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        // 拦截器处理Post请求
        registration.setFilter(new RequestWrapperFilter());
        registration.addUrlPatterns("/*");
        registration.setName("LogCostFilter");
        registration.setOrder(1);
        return registration;
    }
 
}

1.2.2.3配置拦截器

package com.hecore.cbs.config;

import com.epoch.core.log.impl.ConsoleLogHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new ConsoleLogHandler()).addPathPatterns("/**");
        super.addInterceptors(registry);
    }
}

1.3集成测试

1.3.1 无参请求

url : http://127.0.0.1:9200/api/index

1.3.2 url 有参get请求 http://127.0.0.1:9200/api/index?id=1

1.3.3 url有参post请求

二、核心代码

2.1、默认日志拦截处理

package com.epoch.core.log.impl;

import com.epoch.core.entity.QueryInfoModel;
import com.epoch.core.log.LogHandler;
import com.epoch.core.log.request.wrap.BodyReaderRequestWrapper;
import com.hecore.util.json.JsonUtils;

import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Author: hecore
 * @Date: 2020/3/23 22:14
 * @Description:
 */

public class DefaultLogHandler implements LogHandler {

    @Override
    public QueryInfoModel getQueryInfo(String method, HttpServletRequest request){
        String queryString="error";
        String queryDeal="requestParam";
        Map reqMap = new HashMap();
        if(method.equals("GET")||method.equals("POST")){
            Map ParameterMap =  request.getParameterMap();
            Set<Map.Entry<String,String[]>> entry = ParameterMap.entrySet();
            Iterator<HashMap.Entry<String,String[]>> it = entry.iterator();
            while (it.hasNext()){
                Map.Entry<String,String[]>  me = it.next();
                String key = me.getKey();
                String value = me.getValue()[0];
                reqMap.put(key,value);
            }
            queryString = JsonUtils.toJson(reqMap);
            if(reqMap.size()==0){
                queryDeal="无请求参数,无需设置";
            }
        }
        if(reqMap.size()==0&&method.equals("POST")){
            if(request instanceof BodyReaderRequestWrapper){
                queryString=((BodyReaderRequestWrapper) request).getBodyStr();
                queryDeal="requestBody";
            }
        }
        QueryInfoModel queryInfoModel=new QueryInfoModel();
        queryInfoModel.setQueryDeal(queryDeal);
        queryInfoModel.setQueryString(queryString);
        return queryInfoModel;
    }

    @Override
    public ServletRequest dealRequest(HttpServletRequest request) {
        try {
            return new BodyReaderRequestWrapper(request);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return request;
    }

}

2.2、POST请求体封装

package com.epoch.core.log.request.wrap;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.Map;
import java.util.Vector;

/**
 * @Author: hecore
 * @Date: 2020/1/19 00:19
 * @Description: RequestBody请求封装
 * https://www.cnblogs.com/oushiyang/p/9760827.html
 */


public class BodyReaderRequestWrapper extends HttpServletRequestWrapper {

    public byte[] body;

    private Map<String, String[]> parameterMap; // 所有参数的Map集合

    public String bodyStr;

    public BodyReaderRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        String sessionStream = getBodyString(request);
        body = sessionStream.getBytes(Charset.forName("UTF-8"));
        bodyStr=sessionStream;
        parameterMap = request.getParameterMap();
        if(parameterMap.size()==0){
            this.setMap(bodyStr);
        }
    }

    private void setMap(String bodyStr) {
//        String arr[]=bodyStr.split("=");
//        parameterMap.put(arr[0],);
    }

    /**
         * 获取所有参数名
         *
         * @return 返回所有参数名
         */
        @Override
     public Enumeration<String> getParameterNames() {
            Vector<String> vector = new Vector<String>(parameterMap.keySet());
            return vector.elements();
     }

    /**
       * 获取指定参数名的值，如果有重复的参数名，则返回第一个的值 接收一般变量 ，如text类型
       *
       * @param name 指定参数名
       * @return 指定参数名的值
       */
     @Override
     public String getParameter(String name) {
         String[] results = parameterMap.get(name);
         if (results != null) {
             return results[0];
         } else {
             return null;
         }
     }


    /**
     * 获取指定参数名的所有值的数组，如：checkbox的所有数据
     * 接收数组变量 ，如checkobx类型
     */
     @Override
     public String[] getParameterValues(String name) {
        return parameterMap.get(name);
     }

    public void setParameterMap(Map<String, String[]> parameterMap) {
         this.parameterMap = parameterMap;
     }

    public String getBodyStr() {
        return bodyStr;
    }

    /**
     * 获取请求Body
     *
     * @param request
     * @return
     */
    public String getBodyString(final ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = cloneInputStream(request.getInputStream());//将获取到的请求参数重新塞入request里面去
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }

    /**
     * Description: 复制输入流</br>
     *
     * @param inputStream
     * @return</br>
     */
    public InputStream cloneInputStream(ServletInputStream inputStream) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        try {
            while ((len = inputStream.read(buffer)) > -1) {
                byteArrayOutputStream.write(buffer, 0, len);
            }
            byteArrayOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        InputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        return byteArrayInputStream;
    }

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

    @Override
    public ServletInputStream getInputStream() throws IOException {

        final ByteArrayInputStream bais = new ByteArrayInputStream(body);

        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 String getHeader(String name) {
        return super.getHeader(name);
    }

    @Override
    public Enumeration<String> getHeaderNames() {
        return super.getHeaderNames();
    }

    @Override
    public Enumeration<String> getHeaders(String name) {
        return super.getHeaders(name);
    }
}

2.3、日志处理配置类

package com.epoch.core.log;

import com.epoch.core.log.impl.DefaultLogHandler;
import com.epoch.core.log.request.wrap.BodyReaderRequestWrapper;

import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.IOException;

/**
 * @Author: hecore
 * @Date: 2020/3/23 21:15
 * @Description:
 */

public class LogConfig {

    private static LogHandler configlogHandler=null;

    public static void setHandler(LogHandler logHandler){
        configlogHandler=logHandler;
    }

    public static LogHandler getLogHandler(){
        if(null==configlogHandler){
            return new DefaultLogHandler();
        }
        return configlogHandler;
    }

    public static ServletRequest getRequestWrapper(HttpServletRequest request) {
        if (null==configlogHandler){
            return new DefaultLogHandler().dealRequest(request);
        }
        return configlogHandler.dealRequest(request);
    }

}

标签：return,String,前后,request,public,new,import,日志,拦截
来源： https://blog.csdn.net/qq_24935049/article/details/118890419

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。