关于Java：如何在HttpServletRequest中设置参数？

How to set a parameter in a HttpServletRequest?

我正在使用javax.servlet.http.HttpServletRequest来实现Web应用程序。

我可以使用getParameter方法获取请求的参数。但是我不知道如何在我的请求中设置参数。

您不能，不使用标准API。 HttpServletRequest表示服务器接收到的请求，因此添加新参数不是有效的选项(就API而言)。

原则上，您可以实现HttpServletRequestWrapper的子类，该子类包装原始请求，并拦截getParameter()方法，并在转发时传递包装的请求。

如果使用此路线，则应使用Filter用HttpServletRequestWrapper替换HttpServletRequest：

1
2
3
4
5
6
7
8
9
10
11
12

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
if (servletRequest instanceof HttpServletRequest) {
HttpServletRequest request = (HttpServletRequest) servletRequest;
// Check wether the current request needs to be able to support the body to be read multiple times
if (MULTI_READ_HTTP_METHODS.contains(request.getMethod())) {
// Override current HttpServletRequest with custom implementation
filterChain.doFilter(new HttpServletRequestWrapper(request), servletResponse);
return;
}
}
filterChain.doFilter(servletRequest, servletResponse);
}

相关讨论

如果您确实要执行此操作，请创建一个HttpServletRequestWrapper。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class AddableHttpRequest extends HttpServletRequestWrapper {

private HashMap params = new HashMap();

public AddableingHttpRequest(HttpServletRequest request) {
super(request);
}

public String getParameter(String name) {
// if we added one, return that one
if ( params.get( name ) != null ) {
return params.get( name );
}
// otherwise return what's in the original request
HttpServletRequest req = (HttpServletRequest) super.getRequest();
return validate( name, req.getParameter( name ) );
}

public void addParameter( String name, String value ) {
params.put( name, value );
}

}

相关讨论

从您的问题来看，我认为您想要做的是使用RequestDispatcher()存储一些东西(一个对象，一个字符串...)以将其转发给另一个servlet。
为此，您不需要设置参数，而是使用

1	void setAttribute(String name, Object o);

然后

1	Object getAttribute(String name);

相关讨论

如先前的文章所述，使用HttpServletReqiestWrapper是必经之路，但是这些文章中遗漏的部分是，除了覆盖方法getParameter()之外，还应该覆盖其他与参数相关的方法以产生一致的响应。例如由自定义请求包装器添加的参数值也应该包含在方法getParameterMap()返回的参数映射中。这是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

public class AddableHttpRequest extends HttpServletRequestWrapper {

/** A map containing additional request params this wrapper adds to the wrapped request */
private final Map<String, String> params = new HashMap<>();

/**
* Constructs a request object wrapping the given request.
* @throws java.lang.IllegalArgumentException if the request is null
*/
AddableHttpRequest(final HttpServletRequest request) {
super(request)
}

@Override
public String getParameter(final String name) {
// if we added one with the given name, return that one
if ( params.get( name ) != null ) {
return params.get( name );
} else {
// otherwise return what's in the original request
return super.getParameter(name);
}
}

/**
* *** OVERRIDE THE METHODS BELOW TO REFLECT PARAMETERS ADDED BY THIS WRAPPER ****
*/

@Override
public Map<String, String> getParameterMap() {
// defaulf impl, should be overridden for an approprivate map of request params
return super.getParameterMap();
}

@Override
public Enumeration<String> getParameterNames() {
// defaulf impl, should be overridden for an approprivate map of request params names
return super.getParameterNames();
}

@Override
public String[] getParameterValues(final String name) {
// defaulf impl, should be overridden for an approprivate map of request params values
return super.getParameterValues(name);
}
}

最受支持的解决方案通常可以使用，但是对于Spring和/或Spring Boot，除非您专门实现了getParameterValues()，否则这些值将不会连接到以@RequestParam注释的控制器方法中的参数。我在这里和本博客中结合了解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import java.util.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

public class MutableHttpRequest extends HttpServletRequestWrapper {

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

public MutableHttpRequest(final HttpServletRequest request) {
super(request);
}

public MutableHttpRequest addParameter(String name, String value) {
if (value != null)
mutableParams.put(name, new String[] { value });

return this;
}

@Override
public String getParameter(final String name) {
String[] values = getParameterMap().get(name);

return Arrays.stream(values)
.findFirst()
.orElse(super.getParameter(name));
}

@Override
public Map<String, String[]> getParameterMap() {
Map<String, String[]> allParameters = new HashMap<>();
allParameters.putAll(super.getParameterMap());
allParameters.putAll(mutableParams);

return Collections.unmodifiableMap(allParameters);
}

@Override
public Enumeration<String> getParameterNames() {
return Collections.enumeration(getParameterMap().keySet());
}

@Override
public String[] getParameterValues(final String name) {
return getParameterMap().get(name);
}
}

请注意，此代码不是超级优化的，但是可以工作。

缺少的getParameterMap覆盖最终对我来说是一个真正的问题。这就是我最终得到的结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

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

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

/***
* Request wrapper enabling the update of a request-parameter.
*
* @author E.K. de Lang
*
*/
final class HttpServletRequestReplaceParameterWrapper
extends HttpServletRequestWrapper
{

private final Map<String, String[]> keyValues;

@SuppressWarnings("unchecked")
HttpServletRequestReplaceParameterWrapper(HttpServletRequest request, String key, String value)
{
super(request);

keyValues = new HashMap<String, String[]>();
keyValues.putAll(request.getParameterMap());
// Can override the values in the request
keyValues.put(key, new String[] { value });

}

@SuppressWarnings("unchecked")
HttpServletRequestReplaceParameterWrapper(HttpServletRequest request, Map<String, String> additionalRequestParameters)
{
super(request);
keyValues = new HashMap<String, String[]>();
keyValues.putAll(request.getParameterMap());
for (Map.Entry<String, String> entry : additionalRequestParameters.entrySet()) {
keyValues.put(entry.getKey(), new String[] { entry.getValue() });
}

}

@Override
public String getParameter(String name)
{
if (keyValues.containsKey(name)) {
String[] strings = keyValues.get(name);
if (strings == null || strings.length == 0) {
return null;
}
else {
return strings[0];
}
}
else {
// Just in case the request has some tricks of it's own.
return super.getParameter(name);
}
}

@Override
public String[] getParameterValues(String name)
{
String[] value = this.keyValues.get(name);
if (value == null) {
// Just in case the request has some tricks of it's own.
return super.getParameterValues(name);
}
else {
return value;
}
}

@Override
public Map<String, String[]> getParameterMap()
{
return this.keyValues;
}

}

抱歉，为什么不使用以下结构：

1	request.getParameterMap().put(parameterName, new String[] {parameterValue});

相关讨论