springboot 拦截器统一处理post get 以及文件上传

1.思想

核心思想，在拦截器中将前端的参数封装到map中，然后将map放入HttpServletRequest中，如果是文件上传，那直接在拦截器将文件内容处理好，放入HttpServletRequest中，。这样的话后端接口获取参数，直接从HttpServletRequest  取出map  ，当然也可以直接取出文件内容。
因为HttpServletRequest中包含了拦截其中放入其中的参数  和 文件内容。

 

package com.ay.voipwork.interceptor;
//import org.springframework.data.redis.connection.lettuce;
import com.ay.voipwork.until.CommontMethod;
import com.ay.voipwork.until.RestUtil;
import com.ay.voipwork.until.SystemCode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

@Component
public class RequestParamInterceptor implements HandlerInterceptor {
    private static Logger log = LoggerFactory.getLogger( RequestParamInterceptor.class );
    @Autowired
    ObjectMapper objectMapper;


   private List<String> parseMutipartFile(MultipartFile multipartFile){

       InputStream inputStream = null;
       List<String> fileContentList=new ArrayList<>(  );
       try {
           inputStream = multipartFile.getInputStream();
           BufferedReader bufferedReader = new BufferedReader( new InputStreamReader( inputStream ) );
           String s="";
           while ((s=bufferedReader.readLine())!=null){
              fileContentList.add( s );

           }
       } catch (IOException e) {
           e.printStackTrace();
       }
     return fileContentList;
   }



    /*
  * @author pg
  * @date  2019-11-21 13:56
  * 无论是 post 还是 get请求统一获取参数封装成 map发给control 让controller获取参数更加的方便
 */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       
        Map<String, Object> paramMap = new HashMap<>();
        String method = request.getMethod();//获取请求方式
        ServletInputStream servletInputStream = request.getInputStream();


        if ("POST".equals( method ) || "PUT".equals( method )) {
           //若是普通http请求
            if (!(request instanceof MultipartHttpServletRequest)){
                String jsonStr = inputStreamToString( servletInputStream );//json字符串
                if (!isJson( jsonStr ) || jsonStr.length() < 1) {//判断是否是json
                    if (!isJson( jsonStr ) || jsonStr.length() < 1) {//判断是否是json
                        RestUtil.response( response, SystemCode.ParameterValidError.getCode(), SystemCode.ParameterValidError.getMessage() + "不是正常的json参数" );
                        return false;
                    }
                }
                paramMap = CommontMethod.stringToJson( jsonStr );//传入的参数
                log.info( "POST:  paraMap:  " + paramMap );
            }
            //若是文件上传请求
            if (request instanceof MultipartHttpServletRequest){

                MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest)request;
                System.out.println("type:  "+multipartHttpServletRequest.getContentType());
                MultipartFile multipartFile = multipartHttpServletRequest.getFile( "file" );
                List<String> phoneList =  parseMutipartFile( multipartFile );
                Enumeration enu = request.getParameterNames();
                while (enu.hasMoreElements()) {
                    String paraName = (String) enu.nextElement();
                    paramMap.put( paraName, request.getParameter( paraName ) );
                }
                request.setAttribute( "param_json",paramMap );
                request.setAttribute( "phoneList",phoneList );
//后端获取   request.getAttribute("param_json") ; request.getAttribute("phoneList")

                log.info( "POST:  paraMap:  " + paramMap );
                log.info( "正在请求电话号码请求接口！" );
                log.info( "phonesList :"+phoneList );
            }




        } else if ("GET".equals( method )) {
            Enumeration enu = request.getParameterNames();
            while (enu.hasMoreElements()) {
                String paraName = (String) enu.nextElement();
                paramMap.put( paraName, request.getParameter( paraName ) );
            }
            log.info( "GET:  paraMap:  " + paramMap );
        }
        request.setAttribute( "param_json", paramMap );
        return true;
    }

    /**
     * 判断是否是json结构
     */
    private boolean isJson(String jsonInString) {
        try {
            final ObjectMapper mapper = new ObjectMapper();
            mapper.readTree( jsonInString );
            return true;
        } catch (IOException e) {
            return false;
        }
    }


    private String inputStreamToString(InputStream is) {
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int length;
        String str = "";
        try {
            while ((length = is.read( buffer )) != -1) {
                result.write( buffer, 0, length );
            }
            str = result.toString( StandardCharsets.UTF_8.name() );
            return str;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

2.注册拦截器

 

package com.ay.voipwork.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class RequestParamInterceptorConf implements WebMvcConfigurer {
    @Autowired
    RequestParamInterceptor requestParamInterceptor;
    @Autowired
    RequestFrequenceInterceptor frequenceInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry){
        // 多个拦截器组成一个拦截器链
        // addPathPatterns 用于添加拦截规则
        // excludePathPatterns 用户排除拦截
        // TokenInterceptor()为自己定义的拦截器
        registry.addInterceptor(requestParamInterceptor).addPathPatterns("/**").excludePathPatterns("/error");
    }
}

 

总结：如果你有什么好的处理方式，不妨评论。