springboot mvc 前端+filter+controller

最新推荐文章于 2024-06-03 12:43:39 发布

原创最新推荐文章于 2024-06-03 12:43:39 发布 · 219 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#前端 #spring boot #mvc

文章讲述了如何在Java后端使用过滤器处理前端的POST和GET请求。对于POST请求，通过获取并操作请求体，然后用BodyRequestWrapper封装新的请求。GET请求则是通过设置请求属性并在过滤器中传递。同时，介绍了ParameterRequestWrapper用于添加额外的请求参数。

前端访问类型：

Content-Type: application/x-www-form-urlencoded; charset=UTF-8

Accept: application/json, text/plain, */*

对应filter

//获取request的body参数

String postContent =getBody(request);

 //获取Request的body数据
    private String getBody(ServletRequest request) {
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        InputStream inputStream = null;
        try {
            inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {

        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return stringBuilder.toString();
    }

获取body后操作完成然后封装request,然后传递chain。

     Map<String, Object> param = new HashMap<>(); //自定义参数
                    param.put("city", "1");
                    param.put("name","2");
                    ParameterRequestWrapper pr = new ParameterRequestWrapper(request, param);
                    filterChain.doFilter(pr, servletResponse);

ParameterRequestWrapper

package com.pj.filter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
public class ParameterRequestWrapper extends HttpServletRequestWrapper {

    private Map<String, String[]> params = new HashMap<>();

    public ParameterRequestWrapper(HttpServletRequest request) {
        super(request);
        this.params.putAll(request.getParameterMap());
    }

    public ParameterRequestWrapper(HttpServletRequest request, Map<String, Object> extendParams) {
        this(request);
        //这里将扩展参数写入参数表
        addAllParameters(extendParams);
    }

    @Override
    public Enumeration<String> getParameterNames() {
        return new Vector(params.keySet()).elements();
    }

    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values;
    }

    private void addAllParameters(Map<String, Object> otherParams) {
        for (Map.Entry<String, Object> entry : otherParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }

    private void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
}

然后后端获取数据是

public ResponseEntity getPowerConsumption(@RequestParam(value = "city") String city1,

@RequestParam(value = "name") String name

){

System.out.println(name)}

前端是get

filter很简单。

request.setAttribute("city", "cc");

filterChain.doFilter(request, servletResponse);

后端获取也很简单

@GetMapping("getCity")

public void getCity(HttpServletRequest request) {

//从request中获取到东西。然后再用接口获取到文件

String s=(String) request.getAttribute("city");

前端是

Content-Type: application/json;

Accept: application/json, text/plain, */*

后端filter是

String postContent = getBody(request);

 //获取Request的body数据
    private String getBody(ServletRequest request) {
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        InputStream inputStream = null;
        try {
            inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {

        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return stringBuilder.toString();
    }

获取数据之后封装request

JSONObject jsStr = JSONObject.parseObject(postContent);
                jsStr.put("city", "city");
  postContent = jsStr.toJSONString();
                //将修改后参数放入重写的方法中
                request = new BodyRequestWrapper(request, postContent);
  filterChain.doFilter(request, servletResponse);

BodyRequestWrapper

package com.pj.filter;


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;

//更改body中的值
public class BodyRequestWrapper extends HttpServletRequestWrapper {

    // 存放JSON数据主体
    private String body;

    public BodyRequestWrapper(HttpServletRequest request, String context) {
        super(request);
        body = context;
    }

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

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

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

            @Override
            public void setReadListener(ReadListener listener) {

            }
        };
        return servletInputStream;
    }

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

controller是

@PostMapping("getCity")
    public void getTotalFlowIndex(@RequestBody ConditionDto conditionDto) {

}