修改request的parameter的几种方式总结

public class HttpServletRequestExtend implements HttpServletRequest {
 .......实现代码
}

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.HashMap;
import java.util.Map;
public class ParameterRequestWrapper extends HttpServletRequestWrapper {    
    private Map<String , String[]> params = new HashMap<String, String[]>();  
    @SuppressWarnings("unchecked")
    public ParameterRequestWrapper(HttpServletRequest request) {
        // 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
        super(request);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        this.params.putAll(request.getParameterMap());
    }
    //重载一个构造方法
    public ParameterRequestWrapper(HttpServletRequest request , Map<String , Object> extendParams) {
        this(request);
        addAllParameters(extendObject);//这里将扩展参数写入参数表
    }
    
    @Override
    public String getParameter(String name) {//重写getParameter，代表参数从当前类中的map获取
        String[]values = params.get(name);
        if(values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }
    
    public String[] getParameterValues(String name) {//同上
         return params.get(name);
    }
 
   public void addAllParameters(Map<String , Object>otherParams) {//增加多个参数
        for(Map.Entry<String , Object>entry : otherParams.entrySet()) {
            addParameter(entry.geTKEy() , entry.getValue());
        }
    } 
 
    public 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)});
            }
        }
    }
}

ParameterRequestWrapper requestWrapper = new ParameterRequestWrapper((HttpServletRequest)request);
requestWrapper.addParameter("fff" , "我靠");
filterChain.doFilter(requestWrapper, servletResponse);

request.getClass().getResource("").getPath() 

request.getClass().getResource("/org/apache/catalina/connector/RequestFacade.class").getPath()

protected Request request = null;

org.apache.catalina.connector.Request

protected ParameterMap parameterMap = new ParameterMap();

public final class ParameterMap extends HashMap {
  .....
}

Filed  lockedField = map.getClass().getDeclaredField("locked");
lockedField.setAccessible(true);//打开访问权限，让他裸奔，private类型照样玩他
lockedField.setBoolean(map, false);//将lock参数设置为false了，就是可以修改了
这下子爽了，可以调用map.put了
map.put("newnode" , new String[] {"阿拉拉拉"});
....
调用完了，记得:
lockedField.setBoolean(map, true);

protected org.apache.coyote.Request coyoteRequest;

private Parameters parameters = new Parameters();

public final class Parameters extends MultiMap {
....
}

private Hashtable<String,String[]> paramHashStringArray =
        new Hashtable<String,String[]>();

try {
            Class clazz = request.getClass();
            Field requestField = clazz.getDeclaredField("request");
            requestField.setAccessible(true);
            Object innerRequest = requestField.get(request);//获取到request对象 
 
            //设置尚未初始化 (否则在获取一些参数的时候，可能会导致不一致)
            Field field = innerRequest.getClass().getDeclaredField("parametersParsed");
            field.setAccessible(true);
            field.setBoolean(innerRequest , false); 
 
            Field coyoteRequestField = innerRequest.getClass().getDeclaredField("coyoteRequest");
            coyoteRequestField.setAccessible(true);
            Object coyoteRequestObject = coyoteRequestField.get(innerRequest);//获取到coyoteRequest对象 
 
            Field parametersField = coyoteRequestObject.getClass().getDeclaredField("parameters");
            parametersField.setAccessible(true);
            Object parameterObject = parametersField.get(coyoteRequestObject);//获取到parameter的对象
//获取hashtable来完成对参数变量的修改
            Field hashTabArrField = parameterObject.getClass().getDeclaredField("paramHashStringArray");
            hashTabArrField.setAccessible(true);
            @SuppressWarnings("unchecked")
            Map<String,String[]> map = (Map<String,String[]>)hashTabArrField.get(parameterObject);
            map.put("fuck" , new String[] {"fuck you"});
//也可以通过下面的方法，不过下面的方法只能添加参数，如果有相同的key，会追加参数，即，同一个key的结果集会有多个
//            Method method = parameterObject.getClass().getDeclaredMethod("addParameterValues" , String.class , String[].class);
//            method.invoke(parameterObject , "fuck" , new String[] {"fuck you!" , "sssss"}); 
 
        } catch (Exception e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        System.out.println(request.getParameter("fuck"));

    private static Field requestField;    
    private static Field parametersParsedField;    
    private static Field coyoteRequestField;    
    private static Field parametersField;    
    private static Field hashTabArrField;

try {
            Class clazz = Class.forName("org.apache.catalina.connector.RequestFacade");
            requestField = clazz.getDeclaredField("request");
            requestField.setAccessible(true); 
 
            parametersParsedField = requestField.getType().getDeclaredField("parametersParsed");
            parametersParsedField.setAccessible(true); 
 
            coyoteRequestField = requestField.getType().getDeclaredField("coyoteRequest");
            coyoteRequestField.setAccessible(true); 
 
            parametersField = coyoteRequestField.getType().getDeclaredField("parameters");
            parametersField.setAccessible(true); 
 
            hashTabArrField = parametersField.getType().getDeclaredField("paramHashStringArray");
            hashTabArrField.setAccessible(true);
        } catch (Exception e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }

@SuppressWarnings("unchecked")
    private Map<String , String[]> getRequestMap(ServletRequest request) {
        try {
            Object innerRequest = requestField.get(request);
            parametersParsedField.setBoolean(innerRequest, true);
            Object coyoteRequestObject = coyoteRequestField.get(innerRequest);
            Object parameterObject = parametersField.get(coyoteRequestObject);
            return (Map<String,String[]>)hashTabArrField.get(parameterObject);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return Collections.emptyMap();
        }
    }

Map<String , String[]> map = getRequestMap(request);
        if(map != null) {
            map.put("fuck" , new String[] {"fuck you!"});
        }