如何在 Jersey 中处理 POST 请求中的重复参数

Question

我正在使用 Jersey 2.22.1 来实现 REST API。

我想知道如何处理 POST 请求中的重复参数。

这是我的资源类：

public class MyResource
{
    @NotNull(message = "Missing parameter 'param1'")
    @FormParam("param1")
    private String m_param1;

    @NotNull(message = "Missing parameter 'param2'")
    @FormParam("param2")
    private String m_param2;

    @POST
    @Produces(MediaType.TEXT_PLAIN)
    @Consumes("application/x-www-form-urlencoded")
    public Response test(String body)
    {
        // at this point...
        // the value of `body` is the full request body
        // the value of `m_param1` is the 1st value of param1 in the request body
        // the value of `m_param2` is the value of param2 in the request body
        ...
    }
}

例如如果我发送带有以下正文的 POST 请求：

param1=00000001&param2=00000002&param1=00000003

那么m_param1的值为00000001。

Jersey 框架能否检测到请求正文中是否存在重复参数？还是我需要添加代码来解析请求正文以查找重复项？

Answer 1

您可以使用filter 检查参数以确保没有重复。如果有，只需发送 400 状态即可。

public class DuplicateFormParamsFilter implements ContainerRequestFilter {

    @Override
    public void filter(ContainerRequestContext requestContext) throws IOException {
        ContainerRequest cr = (ContainerRequest) requestContext;
        cr.bufferEntity();
        Form form = cr.readEntity(Form.class);
        MultivaluedMap<String, String> asMap = form.asMap();
        for (String key: asMap.keySet()) {
            if (asMap.get(key).size() > 1) {
                throw new BadRequestException("Duplicate param: " + key);
            }
        }
    }
}

这里你正在读取请求实体，但首先缓冲它，以便 Jersey 可以重新读取它。

这是一个完整的例子，使用Jersey Test Framework。

import java.io.IOException;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.ws.rs.BadRequestException;
import javax.ws.rs.Consumes;
import javax.ws.rs.FormParam;
import javax.ws.rs.NameBinding;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.client.Entity;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.core.Form;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;

import org.glassfish.jersey.server.ContainerRequest;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.glassfish.jersey.test.TestProperties;
import org.junit.Test;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

/**
 * @author Paul Samsotha
 */
public class DuplicateFormParamsTest extends JerseyTest {
    
    @Path("test")
    public static class TestResource {
        
        @POST
        @NoDuplicateParams
        @Consumes("application/x-www-form-urlencoded")
        public String post(@FormParam("param") String param) {
            return param;
        }
    }
    
    @NoDuplicateParams
    public static class DuplicateFormParamsFilter implements ContainerRequestFilter {

        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException {
            ContainerRequest cr = (ContainerRequest) requestContext;
            cr.bufferEntity();
            Form form = cr.readEntity(Form.class);
            MultivaluedMap<String, String> asMap = form.asMap();
            for (String key: asMap.keySet()) {
                if (asMap.get(key).size() > 1) {
                    throw new BadRequestException("Duplicate param: " + key);
                }
            }
        }
    }
    
    @NameBinding
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public static @interface NoDuplicateParams {
    }
    
    @Override
    public ResourceConfig configure() {
        enable(TestProperties.DUMP_ENTITY);
        enable(TestProperties.LOG_TRAFFIC);
        return new ResourceConfig(TestResource.class)
                .register(DuplicateFormParamsFilter.class);
    }
    
    @Test
    public void sdhoul_get_400_with_dup() {
        final Form form = new Form()
                .param("param", "value1")
                .param("param", "value2");
        final Response response = target("test").request().post(Entity.form(form));
        assertThat(response.getStatus(), is(400));
    }
    
    @Test
    public void sdhoul_get_200_with_single() {
        final Form form = new Form()
                .param("param", "value1");
        final Response response = target("test").request().post(Entity.form(form));
        assertThat(response.getStatus(), is(200));
        assertThat(response.readEntity(String.class), is("value1"));
    }
}

该示例使用了Name Binding，因此只有带有@NoDuplicateParams 注释的方法才会通过过滤器。或者您可以忘记名称绑定，让所有请求都通过过滤器，只需检查过滤器中的 Content-Type 是否为application/x-www-form-urlencoded。这样你就不需要到处注释了。

---

更新

我应该提到的一件事是，我想我记得有一个案例不起作用（尝试像上面那样提取表单）。我完全忘记了这种情况，但它与 servlet 环境有关，并且之前读取的表单参数，所以上面的尝试读取将不起作用。

我要做的是使用 Jersey 内部属性，其中Jersey stores the parameters。所以你需要以这种方式检索表单

Form form = (Form) requestContext.getProperty(
        InternalServerProperties.FORM_DECODED_PROPERTY);