通过filter过滤器对请求参数进行处理

其他 2018-07-21 05:10:04 阅读次数: 0

遇见的问题：前台把参数通过报文或者使用表单、ajax提交到后台，如果我们的请求参数是加密的，那么我们在controller里面的每一个方法里都需要进行解密处理。如果方法太多，那就太麻烦了。
设计方案：在一个Filter中将 HttpServletRequest 里的所有参数都取出来分别进行过滤然后再放回到该HttpServletRequest 中行不行呢？通过测试后发现是不行的，因为HttpServletRequest 只提供了getParameter ，而没有提供setParameter；所以，我们只能自己写一个HttpServletRequest 方法继承HttpServletRequestWrapper，然后覆盖里面的方法，并且增加我们自己的setParameters方法，这样我们就可以为所欲为了，最后再在filter中调用该类的方法对参数进行处理（获取、修改、存储等等）。

解决方案：在请求参数到达controller之前，在filter里面进行解密；这样，通过简单的过滤器处理，把需要处理的请求都在过滤器里进行解密操作，这样就等于实现了自动化处理。
这里我们针对两种不同的请求方式进行讲解：1.普通的表单、ajax请求；2.json格式的报文请求。（三步搞定）

1.普通的表单、ajax请求；

第一步：新建一个类

这个类继承自HttpServletRequestWrapper

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
 * 重写 HttpServletRequestWrapper
 * 处理表单、ajax请求
 * @author zhaoheng
 *
 */
public class MyHttpServletRequestWrapper1 extends HttpServletRequestWrapper{  

     // 用于存储请求参数
     private Map<String , String[]> params = new HashMap<String, String[]>();  
     // 构造方法
     public MyHttpServletRequestWrapper1(HttpServletRequest request) throws IOException {    
         super(request);
         // 把请求参数添加到我们自己的map当中
         this.params.putAll(request.getParameterMap()); 
     }    


     /**
      * 添加参数到map中
      * @param extraParams
      */
     public void (Map<String, Object> extraParams) {
         for (Map.Entry<String, Object> entry : extraParams.entrySet()) {
             setParameter(entry.getKey(), entry.getValue());
         }
     }

     /**
      * 添加参数到map中
      * @param name 
      * @param value
      */
     public void setParameter(String name, Object value) {
         if (value != null) {
             System.out.println(value);
             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)});
             }
         }
     }

     /**
      * 重写getParameter，代表参数从当前类中的map获取
      * @param name
      * @return
      */
     @Override
     public String getParameter(String name) {
         String[]values = params.get(name);
         if(values == null || values.length == 0) {
             return null;
         }
         return values[0];
     }

     /**
      * 重写getParameterValues方法，从当前类的 map中取值
      * @param name
      * @return
      */
     @Override
     public String[] getParameterValues(String name) {
         return params.get(name);
     }
}

通过建立这个类我们就能完成向request对象添加我们处理之后的参数了。

第二步：通过实现filter接口建一个过滤器

package com.zhh.filter;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;

import com.zhh.util.request.MyHttpServletRequestWrapper1;

/**
 * 参数处理验过滤器（针对ajax、表单等请求） 1.获取请求参数； 2.对获取到的请求参数进行处理（解密、字符串替、请求参数分类截取等等）； 3.把处理后的参数放回到请求列表里面
 * 
 * @author zhaoheng
 *
 */
public class ValidatorFilter1 implements Filter {

    private static final Logger log = Logger.getLogger(ValidatorFilter1.class);

    /**
     * 需要过滤的地址
     */
    private static List<String> urlList = Arrays.asList("/pastOrder/filterCsF");

    /**
     * 是否不需要过滤
     * 
     * @param requestUrl
     *            请求的url
     * @return
     */
    public boolean isPast(String requestUrl) {
        for (String url : urlList) {
            if (requestUrl.equals(url)) {
                return true;
            }
        }

        return false;
    }

    @Override
    public void destroy() {
    }

    @SuppressWarnings("unchecked")
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        log.info("过滤器2执行开始");
        String url = ((HttpServletRequest) request).getRequestURI().substring(((HttpServletRequest)request).getContextPath().length());

        //通过地址对特定的请求进行处理，如果不需要可以不用，如果不用，就会对使用的请求进行过滤
        if (isPast(url)) {
            MyHttpServletRequestWrapper1 requestWrapper1 = new MyHttpServletRequestWrapper1(
                    (HttpServletRequest) request);
            // 1.获取需要处理的参数
            String email = requestWrapper1.getParameter("email");
            // 2.把处理后的参数放回去（这里是大小转小写处理）
            requestWrapper1.setParameter("email", email.toLowerCase());
            // 3.放行，把我们的requestWrapper1放到方法当中
            chain.doFilter(requestWrapper1, response);
        } else {
            chain.doFilter(request, response);
        }
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
    }
}

第三步：在web.xml文件里面进行简单的配置

把我们的过滤器在该文件中注册

 <!--  配置过滤器  -->
      <filter>  
        <filter-name>ValidatorFilter1</filter-name>  
        <!--  我们写的过滤的地址   -->
        <filter-class>com.zhh.filter.ValidatorFilter1</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>ValidatorFilter1</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>

controller 接收参数代码：

    /**
     * 过滤方法测试
     */
    @RequestMapping("/filterCsF2")
    public void filterCs22(String email,String userName){
        System.out.println("处理后的参数："+userName+"  "+email);
    }

请求示例代码：

扫描二维码关注公众号，回复： 2279989 查看本文章 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>请求demo</title>
</head>

<body>

 <form id="userForm" action="#" method="post">
        username：<input type="text" id ="userName" name="userName" value="21088888"/><br/><br>
        email：<input type="text" id ="email" name="email" value="[email protected]"/><br/><br/>
         age：<input type="text" id ="age" name="age" value="18"/><br/><br/>

        <input type="reset" value="重置"/>&nbsp;&nbsp;
        <input type="button" id ="sub" value="提交">
    </form>

</body>
    <script src="jquery.min.js"></script>
<script type="text/javascript">

            $("#sub").click(
    function(){
        var userName = $("#userName").val();   
          var email = $("#email").val(); 
            var age = $("#age").val(); 
         $.ajax({
            type : "POST",
            url:'http://127.0.0.1:8080/merchant_wap/pastOrder/filterCsF2',
            dataType : "json",
            data : {
                    "userName":userName,
                    "age":age,
                    "email":email
            },
            success : function(data) {
            alert("33");
            },
            error : function(data) {
            alert("cccc"+data.email);
            }
        });
        }
            );
</script>
</html>

处理结果：

处理后的参数：21088888  zhaoheng@163.com

从结果可以看出，我们成功的通过过滤器对请求的email进行大写转小写处理

2.json格式的报文请求；

第一步：新建一个类

这个类继承自HttpServletRequestWrapper

package com.zhh.util.request;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import jodd.io.StreamUtil;

/**
 * 重写 HttpServletRequestWrapper
 * 处理json报文请求
 * @author zhaoheng
 *
 */
public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper{  

     private  byte[] body; //用于保存读取body中数据   

     public MyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {    
         super(request);
         //读取请求的数据保存到本类当中
         body = StreamUtil.readBytes(request.getReader(), "UTF-8");    
     }
     //覆盖（重写）父类的方法
     @Override    
     public BufferedReader getReader() throws IOException {    
         return new BufferedReader(new InputStreamReader(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();    
             } 
         };    
     }

     /**
      * 获取body中的数据
      * @return
      */
    public byte[] getBody() {
        return body;
    }
    /**
     * 把处理后的参数放到body里面
     * @param body
     */
    public void setBody(byte[] body) {
        this.body = body;
    }
}

通过建立这个类我们就能完成向request对象添加我们处理之后的参数了。

第二步：通过实现filter接口建一个过滤器

package com.zhh.filter;

import java.io.BufferedReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zhh.util.request.MyHttpServletRequestWrapper;

/**
 * 参数校验过滤器（针对json报文请求） 1.获取请求参数； 2.对获取到的请求参数进行处理（解密、字符串替、请求参数分类截取等等）； 3.把处理后的参数放回到请求列表里面
 * 
 * @author zhaoheng
 *
 */
public class ValidatorFilter implements Filter {

    private static final Logger log = Logger.getLogger(ValidatorFilter.class);

    /**
     * 需要过滤的地址
     */
    private static List<String> urlList = Arrays.asList("/pastOrder/filterCs");
    /**
     * 是否需要过滤
     * 
     * @param requestUrl
     *            请求的url
     * @return
     */
    public boolean isPast(String requestUrl) {
        for (String url : urlList) {
            if (requestUrl.equals(url)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void destroy() {
        log.info("过滤器执行结束");
    }

    @SuppressWarnings("unchecked")
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        log.info("过滤器1执行开始");
        String url0 = ((HttpServletRequest) request).getRequestURI();
        String url1 = ((HttpServletRequest) request).getContextPath();
        System.out.println("完整地址："+url0);
        System.out.println("返回当前页面所在的应用的名字："+url1);
        System.out.println("返回当前页面所在的应用的名字长度："+url1.length());

        // 获取请求地址
        String url = ((HttpServletRequest) request).getRequestURI().substring(((HttpServletRequest)request).getContextPath().length());
        System.out.println("截取后的地址："+url);

        if (isPast(url)) {
            //处理json报文请求
            MyHttpServletRequestWrapper requestWrapper = new MyHttpServletRequestWrapper(
                    (HttpServletRequest) request);
            // 读取请求内容
            BufferedReader br;
            br = requestWrapper.getReader();
            String line = null;
            StringBuilder sb = new StringBuilder();
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            // 将json字符串转换为json对象
            JSONObject jsonObject = JSONObject.parseObject(sb.toString());

            Map<String, Object> map = new HashMap<String, Object>();
            // 把json对象转换为Map集合
            map = JSON.toJavaObject(jsonObject, Map.class);
            for (Entry<String, Object> entry : map.entrySet()) {
                // 把邮箱地址转换为小写
                if (entry.getKey().equals("email")) {
                    map.put(entry.getKey(), entry.getValue().toString()
                            .toLowerCase());
                }
            }

            // 把参数转换之后放到我们的body里面
            String json = JSON.toJSONString(map);
            requestWrapper.setBody(json.getBytes("UTF-8"));
            // 放行 
            chain.doFilter(requestWrapper, response);
        } else {
            chain.doFilter(request, response);
        }
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {

    }

}

第三步：在web.xml文件里面进行简单的配置

把我们的过滤器在该文件中注册

 <!--  配置过滤器  -->
      <filter>  
        <filter-name>ValidatorFilter</filter-name> 
         <!--  我们写的过滤的地址   --> 
        <filter-class>com.zhh.filter.ValidatorFilter</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>ValidatorFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>

controller 接收参数代码：

/**
     * 过滤方法测试
     * @RequestBody User user 该注解用于接收json请求的参数
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/filterCs")
    public User filterCs(@RequestBody User user){
        System.out.println(user.toString());
        return user;
    }

请求报文示例：
我这里使用的是postman工具进行json参数请求

{
    "email": "[email protected]",
    "userName":"20181100",
    "age":"18"
}

返回结果：

{
    "email": "[email protected]",
    "userName":"20181100",
    "age":"18"
}

通过该过滤器，把email转换从小写成功。
通过以上操作，我们就成功的创建了一个过滤器。

猜你喜欢

转载自blog.csdn.net/muscleheng/article/details/80067772
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022