利用过滤器，修改前端请求参数。后面添加了，修改后端返回参数

最新推荐文章于 2024-05-05 16:15:38 发布
最新推荐文章于 2024-05-05 16:15:38 发布
阅读量3.1k 收藏 6
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuno0/article/details/99627605
版权

项目上用的这个过滤器，主要流程是。前端请求所带的参数是全部加密的。我用过滤器截获到请求携带的数据，解密，放行

理论上请求request是不能被修改的。可以继承HttpServletRequestWrapper，重写父类方法，来实现。

启动类



@SpringBootApplication
@ServletComponentScan(basePackages = "com.example.demo")
@ComponentScan(basePackages = {"com.example.demo"})
public class DemoLiumApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoLiumApplication.class, args);
	}

}

 

过滤器

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.codec.Charsets;
import org.springframework.core.annotation.Order;
import org.springframework.util.ReflectionUtils;
import com.example.demo.lium.utils.DataUtil;
@Order(1)
@WebFilter(filterName = "DecodeFilter",urlPatterns = "/*")
public class DecodeFilter implements Filter{

	public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
			throws IOException, ServletException {
		System.out.println("第一过滤器开始");

		
			//拦截到请求
			HttpServletRequest request =(HttpServletRequest) req;
			RequestParameterWrapper requestParameterWrapper = new RequestParameterWrapper(request);
			Map<String, Object> extraParams1=new HashMap<String, Object>();
			extraParams1.put("other", "othervalue");
			requestParameterWrapper.addParameters(extraParams1);

			System.out.println("请求ContentType"+request.getContentType());
			System.out.println("请求"+request.getMethod());
			//获得请求参数
			Map<String,String> requestMap=DataUtil.getRequestMap(request);
			
			for (String key:requestMap.keySet()) {
				String value;
				if (key.indexOf("name")!=-1) {
					 value=requestMap.get(key);
					 //TODO
					 String strAdd=value+":刘宁宁添加的后缀";
					System.out.println("key是"+key);
					System.out.println("value是"+value);
	//				request.setAttribute("name", strAdd);
					Map extraParams=new HashMap();
					extraParams.put(key, strAdd);
					 requestParameterWrapper.addParameters(extraParams);

				}if (key.indexOf("password")!=-1) {
					 value=requestMap.get(key);
					 //TODO
					 String strAdd=value+":刘宁宁添加mima的后缀";
					System.out.println("key是"+key);
					System.out.println("value是"+value);
		//			request.setAttribute("password", strAdd);
					Map extraParams=new HashMap();
					extraParams.put(key, strAdd);
					 requestParameterWrapper.addParameters(extraParams);
				}

				
			}
			
			//获取response内容,未成功
			String ResponseStr=outResponse(resp);
			//TODO

			System.out.println("拦截到的回"+ResponseStr);  
			//放行
			chain.doFilter(requestParameterWrapper, resp);
	
		 
	//	chain.doFilter(new TokenRequestWrapper((HttpServletRequest) req), resp);
	}

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		Filter.super.init(filterConfig);
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		Filter.super.destroy();
	}

	/**获取response的内容，没有成功
	 * @param resp
	 * @return
	 */
	private String outResponse(ServletResponse resp) {

		String out=null;
        try {
            ServletOutputStream os = resp.getOutputStream();
            Field ob= ReflectionUtils.findField(os.getClass(),"ob");
            ob.setAccessible(true);
            Object obValue= ReflectionUtils.getField(ob,os);
            Field bb= ReflectionUtils.findField(obValue.getClass(),"bb");
            bb.setAccessible(true);
            Object bbValue= ReflectionUtils.getField(bb,obValue);
            Field hb= ReflectionUtils.findField(bbValue.getClass(),"hb");
            hb.setAccessible(true);
            Object value= ReflectionUtils.getField(hb,bbValue);
             out= null==value?null:new String((byte[])value, Charsets.UTF_8);
 
        }catch (Exception e){
            out=null;
          //  out="ERROR:"+e.getMessage();
        }
        return out;

	}
}

重写父类方法


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class RequestParameterWrapper extends HttpServletRequestWrapper {

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

    public RequestParameterWrapper(HttpServletRequest request) {
        super(request);
        //将现有parameter传递给params
        this.params.putAll(request.getParameterMap());
    }

    /**
     * 重载构造函数
     * @param request
     * @param extraParams
     */
    public RequestParameterWrapper(HttpServletRequest request, Map<String, Object> extraParams) {
        this(request);
        addParameters(extraParams);
    }

    public void addParameters(Map<String, Object> extraParams) {
        for (Map.Entry<String, Object> entry : extraParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }

    /* 重写父类方法
                 * 自定义参数
     */
    public Enumeration<String> getParameterNames() {
    	
    	Set set=params.keySet();   
       
        if (set.size()>0&set!=null){
        	          
            return Collections.enumeration(set);
        }else {
            return super.getParameterNames();
        }
    }
    
    /**
     * 重写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];
    }

    /**
     * 同上
     * @param name
     * @return
     */
    @Override
    public String[] getParameterValues(String name) {
        return params.get(name);
    }

    /**
     * 添加参数
     * @param name
     * @param value
     */
    public void addParameter(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)});
            }
        }
    }
}

 controller

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DecodeController {
	
	@RequestMapping("/reqTest")
	public String reqTest(@RequestParam("name")String name,@RequestParam("password") String password) {
		String str="名字是："+name+"密码是："+password;
		System.out.println(str);
		return str;
	}
	
}

工具类

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

public class DataUtil {
	public static Map<String, String> getRequestMap(HttpServletRequest request){
		Enumeration<String> enumRequst=request.getParameterNames();
		Map<String, String> requestMap = new HashMap<String,String>();
		while(enumRequst.hasMoreElements()){
			String key = enumRequst.nextElement();
			String values[]=request.getParameterValues(key);
			for(String val:values){
				requestMap.put(key, val);
			}
		}
		return requestMap;
	}
}

 

 

于是我又写了一个过滤器去过滤第一个过滤器。打印请求参数，发现请求参数已经修改成功。

import java.io.IOException;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

import org.springframework.core.annotation.Order;

import com.example.demo.lium.utils.DataUtil;

@Order(2)
@WebFilter(filterName = "DecodeFilterTwo",urlPatterns = "/*")
public class DecodeFilterTwo implements Filter{

	@Override
	public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
			throws IOException, ServletException {
		
		HttpServletRequest request =(HttpServletRequest) req;
       String url=request.getRequestURI();
       System.out.println("第二过滤器开始");
       System.out.println("TWOurl"+url);
		System.out.println("TWO请求ContentType"+request.getContentType());
		System.out.println("TWO请求"+request.getMethod());
		//获得请求参数
		Map<String,String> requestMap=DataUtil.getRequestMap(request);
		
		for (String key:requestMap.keySet()) {
			String value=requestMap.get(key);
		System.out.println("keyTWO:"+key);
		System.out.println("valueTWO:"+value);
	}
		chain.doFilter(request, resp);
}
}

我试了一下 http://127.0.0.1:8080/reqTest?name=liunn&password=123456

返回的数据表示，修改成功了

然后对返回到前端的数据修改

修改过滤器


import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.codec.Charsets;
import org.springframework.core.annotation.Order;
import org.springframework.http.MediaType;
import org.springframework.util.ReflectionUtils;
import com.example.demo.lium.utils.DataUtil;

import io.micrometer.core.instrument.util.StringUtils;

/**过滤器，对请求参数解密，对返回参数加密
 * 
 * @author liunn
 *
 */
@Order(1)
@WebFilter(filterName = "DecodeFilter",urlPatterns = "/*")
public class DecodeFilter implements Filter{

	/* 执行过滤器的方法
	 * 
	 */
	public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
			throws IOException, ServletException {		
			//转换请求
			HttpServletRequest request =(HttpServletRequest) req;
			//自定义请求参数,转换成代理类
			RequestParameterWrapper requestParameterWrapper = new RequestParameterWrapper(request);
			//转换返回
			HttpServletResponse response =(HttpServletResponse) resp;
			//自定义返回参数,转换成代理类
					ResponseWrapper responseWrapper = new ResponseWrapper(response);
					//	ResponesParameterWrapper responseWrapper = new ResponesParameterWrapper(response);
			//自定义参数,测试.在这里添加额外的请求参数
			Map<String, Object> extraParams1=new HashMap<String, Object>();
			extraParams1.put("other", "othervalue");
			requestParameterWrapper.addParameters(extraParams1);
			//获得前端请求参数
			Map<String,String> requestMap=DataUtil.getRequestMap(request);
			//循环取出,对每个参数做修改,其实就是解密。
			for (String key:requestMap.keySet()) {
				String value;
				if (key.indexOf("name")!=-1) {
					value=requestMap.get(key);
					 //TODO,对value解密.这里，我对修改了字符串内容
					String strAdd=value+":刘宁宁添加的后缀";
					Map extraParams=new HashMap();
					extraParams.put(key, strAdd);
					//修改好的参数放到自定义请求里面
					requestParameterWrapper.addParameters(extraParams);

				}if (key.indexOf("password")!=-1) {
					 value=requestMap.get(key);
					//TODO,对value解密.这里，我对修改了字符串内容
					String strAdd=value+":刘宁宁添加mima的后缀";
					Map extraParams=new HashMap();
					extraParams.put(key, strAdd);
					//修改好的参数放到自定义请求里面
					requestParameterWrapper.addParameters(extraParams);
				}

				
			}
				
			//放行
			chain.doFilter(requestParameterWrapper, responseWrapper);
	
		 /**
		  * 返回值
		  *
		  */
			
			
	        byte[] content = responseWrapper.getContent();//获取返回值
	        //判断是否有值
	        if (content.length > 0)
	        {
	 
	            String str = new String(content, "UTF-8");
	            System.out.println("返回值:" + str);
	            String textliunn = null;
	            String str1 =null;
	            try
	            {
	                //TODO 根据需要处理返回值
	 //           	Long date=System.currentTimeMillis();
	            	textliunn="我在后端返回前端数据，这是我修改后端的数据----------";
	            	str1="—修改好的数据："+str;
	            }
	            catch (Exception e)
	            {
	                e.printStackTrace();
	            }
			//把返回值输出到客户端
                resp.getWriter().write(str1);
                /** 
                //显示返回到前端的数据不全，我换成字符流了
	            ServletOutputStream out = response.getOutputStream();
	            out.write(textliunn.getBytes());
	            out.write(str1.getBytes());        
	            out.flush();
	            out.close();
                */
	        }

	}
	 
//TODO
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		Filter.super.init(filterConfig);
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		Filter.super.destroy();
	}
}

重写父类HttpServletResponseWrapper

import java.io.ByteArrayOutputStream;
import java.io.IOException;
 
import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
 
 
public class ResponseWrapper extends HttpServletResponseWrapper
{
 
    private ByteArrayOutputStream buffer;
 
    private ServletOutputStream out;
 
    public ResponseWrapper(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();
    }
 
    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()
        {
 
            // TODO Auto-generated method stub
            return false;
 
        }
 
        @Override
        public void setWriteListener(WriteListener arg0)
        {
 
            // TODO Auto-generated method stub
 
        }
    }
 
}

然后就可以在前端看到修改后的数据

_我要早睡晚起
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
filter对request请求拦截，对请求参数进行修改
10-08
对request请求进行拦截，对请求参数修改。常用于前台提交表单参数关键字的过滤。此工具可以对参数拦截并转义后提交到对应的处理类。 除了添加两个JsFilter.java和GetHttpServletRequestWrapper.java之外，需要在web.xml添加对应的配置。 sqlFilter weixin.idea.waiting.cq.controller.JsFilter sqlFilter /*
过滤器中如何修改请求体重的参数
qq_44464727的博客
10-05 267
过滤器中修改请求参数
Springboot 使用【过滤器】实现在请求到达 Controller 之前修改请求体参数和在结果返回之前修改响应体
最新发布
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
05-05 3256
Springboot 使用【过滤器】实现在请求到达 Controller 之前修改请求体参数和在结果返回之前修改响应体
Java 通过 filter 过滤器对请求参数进行处理并修改
qq_34377273的博客
12-27 1304
通过过滤器，对前端请求过来的参数进行处理（本次是对请求参数进行前后空格的去除），然后用处理后的参数进行数据查询。
自定义 Filter 过滤器 和 HttpServletRequestWrapper 实现 request 参数 修改/验证
liydys的博客
06-06 1145
实现对request中参数去空格功能： 自定义过滤器：实现Filter @Component public class TestFilter implements Filter { public TestFilter() { } @Override public void init(FilterConfig filterConfig) throws ServletException { } ...
java过滤器对所有参数去除前后空格
06-20
对项目中的所有参数去除前后空格...可以基于此过滤器实现过滤跨站脚本攻击，参数的增加，修改！敏感词汇过滤。实现原理为重写HttpServletRequestWrapper，获取参数的方法。include和 Forwarded 内部转发不在过滤之内。
java 请求参数过滤拦截
03-10
java 干货,对接口参数进行中的特殊字符,如insert select * % 等进行判断,进行过滤.
利用SpringMVC过滤器解决vue跨域请求的问题
11-29
之前写过通过注释的方法解决跨域请求的方法，需要每次都在controll类使用注解，这次通过springmvc的拦截器解决： 继承SpringMVC的类HandlerInterceptor重写preHandle方法，这个方法会在到达 controll之前调用，如下 ...
springcloud 中 zuul 修改请求参数信息的方法
08-28
主要介绍了springcloud 中 zuul 修改请求参数信息的方法,需要的朋友可以参考下
前端跨域，后端配置过滤器
08-30
解决前后端跨域，java后端配置过滤器
通过Filter实现修改http请求、响应
赶路人儿
06-08 5185
请求头和请求参数是不能直接修改，在servlet或者Controller中获取参数本质上是通过 getParameter(String name) 或者 public String[] getParameterValues(String name) 方法，但无论是ServletRequest还是HttpServletRequest都没提供修改请求头、请求参数方法（没有setHeader、setParameter方法，只提供了setAttribute方法）； 注：getParameterMap()返回的时一
前端过滤后端传过来的数据（前端获取指定条件的后端数据）
z_yuyu的博客
11-11 1101
之前做过一个后台管理系统，一条表格数据，要求删除是软删除，delFlag删除标识由0变1，但当时返回数据的时候后端没有做判断，直接把所有数据传了过来，当然这样是不合理的，本方法也只是做一个解决思路，后面还是要和后端沟通的。
【前端】Vue通过过滤器filters实现对后端返回的集合对象中的字段进行判断显示对应的值
m0_64210833的博客
04-06 1231
Vue通过过滤器filters实现对后端返回的集合对象中的字段进行判断显示对应的值
java请求参数防修改_Java Filter过滤器中添加或修改request参数值
weixin_35977444的博客
02-24 1587
业务场景在传递数据的过程中, 需要用到加解密, 但是在每个接口中都来调用加解密的话, 整个程序就会变得非常臃肿, 所以当下考虑的解决方法是在统一返回的JsonResult的类中做统一加密, 在Filter中去做统一解密.遇到的问题Filter的doFilter方法中的request只有setAttribute而没有setParameter也没有add方法, 所以是没办法直接添加或修改参数的。只能重...
java修改content type_仅在Java Filter中更改ContentType或CharacterEncoding如果ContentType === JSON...
weixin_29790771的博客
02-28 1017
我正在尝试确保来自基于Jersey的java应用程序的所有JSON响应都在其ContentType标头中附加了UTF-8字符编码参数.因此,如果它是JSON响应,我想要Content-Type的响应头Content-Type: application/json;charset=UTF-8编辑：我知道我可以根据具体情况这样做,但我想全局地这样做,因此它会影响内容类型为“application / j...
java修改content type,仅在Java Filter中更改ContentType或CharacterEncoding如果ContentType === JSON...
weixin_39730284的博客
02-28 337
I'm trying to ensure that all JSON responses from a Jersey based java application have a UTF-8 character encoding parameter appended to their ContentType header.So if it's a JSON response, I would lik...
使用过滤器对前端传来的参数做检测和修改
qq_41930656的博客
08-20 1233
博主在这里分享一个最近帮助朋友开发一个对前端传来的参数做检测，防止SQL注入的功能的经历。 这个经历可谓是一波三折，前后真的是使用了三个方案，项目使用的是经典的SSM框架集合，碰到入参检测这类问题， 第一个应该想到的是使用AOP进行切面编程，使用@Before，在入参前进行拦截，并做检测，但这并不能对参数做修改；所以要使用@Around环绕处理，检测修改完参数，扔去执行；但是后期因为朋友不会使用AOP，他后期还要维护项目，所以这个方案被舍弃了。（想使用该方案的同志们请自行度娘，我在这不过多介绍了） 第
Filter-过虑器应用之1-设置request编码
球球之家
01-09 962
写一个过虑器，对所有url全部过虑，/*.在doFilter方法中，设置request的编码为utf-8。 一般情况下，这个过虑器永远是第一个要执行的过虑器。     最好是通过配置设置编码。… 第一步：实现Filter接口，在doFIlter中接收初始化参数，设置编码 public class CharFilter implements Filter { //声明编码的成员变量 pr
前后端分离项目，过滤器通过请求头参数的方式判断是否登录
06-09
好的，你的第一个问题是关于前后端分离项目中的过滤器如何判断用户是否已登录。在前后端分离的项目中，通常会将前端和后端分别部署在不同的服务器上，因此需要使用一些特殊的方式来进行用户登录状态的维护。其中一种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值