Java 读取jersey'中的另一个参数；s参数转换器

我制作了一个

ParamConverter

，它提供了一个

即时

（日期），当给定一个格式为Instant的本机ISO-8601的字符串时，或者作为自历元起的整数毫秒数。这很好，但我还需要能够支持其他日期格式（客户很挑剔）

为了避免经典的

dd/mm/yyyy

vs

mm/dd/yyyy

歧义，我希望客户在请求中指定他们的首选格式*。e、 g:

GEThttp://api.example.com/filter?since=01/02/2000&dateformat=dd/mm/yyyy

传递给如下所示的方法：

@GET
字符串getFilteredList（final@QueryParam（“自”）即时自）{
...
}

（为清晰起见，省略了时区部分）

因此，我希望我的

ParamConverter

能够读取

dateformat

参数

我已经能够使用过滤器的组合来设置

ContainerRequestContext

属性和

AbstractValueFactoryProvider

来做类似的事情，但这需要参数应用自定义注释，并且不允许它与QueryParam/FormParam/等一起工作，这使得它的用处大大降低

有没有办法从ParamConverter内部获取其他参数或请求对象本身

[*]在现实世界中，这可能是从预先批准的格式中选择的，但现在只需假设它们向

DateTimeFormatter

---

为清楚起见，以下是我的代码：

public class InstantParameterProvider implements ParamConverterProvider {
    private static final ParamConverter<Instant> INSTANT_CONVERTER =
            new ParamConverter<Instant>( ) {
                @Override public final T fromString( final String value ) {
                    // This is where I would like to get the other parameter's value
                    // Is it possible?
                }

                @Override public final String toString( final T value ) {
                    return value.toString( );
                }
            };

    @SuppressWarnings( "unchecked" )
    @Override public <T> ParamConverter<T> getConverter(
            final Class<T> rawType,
            final Type genericType,
            final Annotation[] annotations
    ) {
        if( rawType == Instant.class ) {
            return (ParamConverter<T>) INSTANT_CONVERTER;
        }
        return null;
    }
}

公共类InstantParameterProvider实现ParamConverterProvider{
专用静态最终参数转换器=
新的参数转换器（）{
@重写公共最终T fromString（最终字符串值）{
//这是我想要获取其他参数值的地方
//可能吗？
}
@将公共最终字符串重写为字符串（最终T值）{
返回值.toString（）；
}
};
@抑制警告（“未选中”）
@覆盖公共参数转换器getConverter(
最后一类原始类型，
最终类型genericType，
最终注释[]注释
) {
if（rawType==Instant.class）{
返回（参数转换器）即时转换器；
}
返回null；
}
}

如前所述，关键是注入一些上下文对象，这允许我们惰性地检索对象。由于

ParamConverterProvider

是Jersey管理的组件，我们应该能够注入其他组件

问题是我们需要的组件将在请求范围内。为了解决这个问题，我们将

javax.inject.Provider

注入到提供者中。当我们在

提供程序中实际调用
get（）
以获取
UriInfo
的实际实例时，它将在请求中。这同样适用于需要请求范围的任何其他组件

比如说

public class InstantParamProvider implements ParamConverterProvider {
    
    @Inject
    private javax.inject.Provider<UriInfo> uriInfoProvider;

    @Override
    public <T> ParamConverter<T> getConverter(Class<T> rawType, 
                                              Type genericType, 
                                              Annotation[] annotations) {

        if (rawType != Instant.class) return null; 

        return new ParamConverter<T>() {
            @Override
            public T fromString(String value) {
                UriInfo uriInfo = uriInfoProvider.get();
                String format = uriInfo.getQueryParameters().getFirst("date-format");
                
                if (format == null) {
                     throw new WebApplicationException(Response.status(400)
                             .entity("data-format query parameter required").build());
                } else {
                    try {
                        // parse and return here
                    } catch (Exception ex) {
                        throw new WebApplicationException(
                            Response.status(400).entity("Bad format " + format).build());
                    }
                }
            }

            @Override
            public String toString(T value) {
                return value.toString();
            }  
        };
    }  
}

公共类InstantParamProvider实现ParamConverterProvider{
@注入
私有javax.inject.Provider uriInfoProvider；
@凌驾
公共参数转换器getConverter（类rawType，
类型genericType，
注释[]注释）{
if（rawType！=Instant.class）返回null；
返回新的参数转换器（）{
@凌驾
公共T fromString（字符串值）{
UriInfo UriInfo=uriInfoProvider.get（）；
字符串格式=uriInfo.getQueryParameters（）.getFirst（“日期格式”）；
if（格式==null）{
抛出新的WebApplicationException（Response.status（400）
.entity（“需要数据格式查询参数”）.build（）；
}否则{
试一试{
//解析并返回这里
}捕获（例外情况除外）{
抛出新的WebApplicationException(
Response.status（400）.entity（“格式错误”+format.build（））；
}
}
}
@凌驾
公共字符串到字符串（T值）{
返回值.toString（）；
}  
};
}  
}


更新
下面是一个使用Jersey测试框架的完整示例

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.logging.Logger;

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.QueryParam;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.ext.ParamConverter;
import javax.ws.rs.ext.ParamConverterProvider;

import org.glassfish.jersey.filter.LoggingFilter;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;

import org.junit.Test;
import static org.junit.Assert.*;
import static org.junit.matchers.JUnitMatchers.*;

public class LocalDateTest extends JerseyTest {

    public static class LocalDateParamProvider implements ParamConverterProvider {

        @Inject
        private javax.inject.Provider<UriInfo> uriInfoProvider;

        @Override
        public <T> ParamConverter<T> getConverter(Class<T> rawType,
                Type genericType,
                Annotation[] annotations) {

            if (rawType != LocalDate.class) {
                return null;
            }
            return new ParamConverter<T>() {
                @Override
                public T fromString(String value) {
                    UriInfo uriInfo = uriInfoProvider.get();
                    String format = uriInfo.getQueryParameters().getFirst("date-format");

                    if (format == null) {
                        throw new WebApplicationException(Response.status(400)
                                .entity("date-format query parameter required").build());
                    } else {
                        try {
                            return (T) LocalDate.parse(value, DateTimeFormatter.ofPattern(format));
                            // parse and return here
                        } catch (Exception ex) {
                            throw new WebApplicationException(
                                    Response.status(400).entity("Bad format " + format).build());
                        }
                    }
                }

                @Override
                public String toString(T value) {
                    return value.toString();
                }
            };
        }
    }

    @Path("localdate")
    public static class LocalDateResource {

        @GET
        public String get(@QueryParam("since") LocalDate since) {
            return since.format(DateTimeFormatter.ofPattern("MM/dd/yyyy"));
        }
    }

    @Override
    public ResourceConfig configure() {
        return new ResourceConfig(LocalDateResource.class)
                .register(LocalDateParamProvider.class)
                .register(new LoggingFilter(Logger.getAnonymousLogger(), true));
    }

    @Test
    public void should_return_bad_request_with_bad_format() {
        Response response = target("localdate")
                .queryParam("since", "09/20/2015")
                .queryParam("date-format", "yyyy/MM/dd")
                .request().get();
        assertEquals(400, response.getStatus());
        assertThat(response.readEntity(String.class), containsString("format yyyy/MM/dd"));
        response.close();
    }

    @Test
    public void should_return_bad_request_with_no_date_format() {
        Response response = target("localdate")
                .queryParam("since", "09/20/2015")
                .request().get();
        assertEquals(400, response.getStatus());
        assertThat(response.readEntity(String.class), containsString("query parameter required"));
        response.close();
    }

    @Test
    public void should_succeed_with_correct_format() {
        Response response = target("localdate")
                .queryParam("since", "09/20/2015")
                .queryParam("date-format", "MM/dd/yyyy")
                .request().get();
        assertEquals(200, response.getStatus());
        assertThat(response.readEntity(String.class), containsString("09/20/2015"));
        response.close();
    }
}

import java.lang.annotation.annotation；
导入java.lang.reflect.Type；
导入java.time.LocalDate；
导入java.time.format.DateTimeFormatter；
导入java.util.logging.Logger；
导入javax.inject.inject；
导入javax.ws.rs.GET；
导入javax.ws.rs.Path；
导入javax.ws.rs.QueryParam；
导入javax.ws.rs.WebApplicationException；
导入javax.ws.rs.core.Response；
导入javax.ws.rs.core.UriInfo；
导入javax.ws.rs.ext.ParamConverter；
导入javax.ws.rs.ext.ParamConverterProvider；
导入org.glassfish.jersey.filter.LoggingFilter；
导入org.glassfish.jersey.server.ResourceConfig；
导入org.glassfish.jersey.test.JerseyTest；
导入org.junit.Test；
导入静态org.junit.Assert.*；
导入静态org.junit.matchers.JUnitMatchers.*；
公共类LocalDateTest扩展了JerseyTest{
公共静态类LocalDateParamProvider实现ParamConverterProvider{
@注入
私有javax.inject.Provider uriInfoProvider；
@凌驾
公共参数转换器getConverter（类rawType，
类型genericType，
注释[]注释）{
if（rawType！=LocalDate.class）{
返回null；
}
返回新的参数转换器（）{
@凌驾
公共T fromString（字符串值）{
UriInfo UriInfo=uriInfoProvider.get（）；
<dependency>
    <groupId>org.glassfish.jersey.test-framework.providers</groupId>
    <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
    <version>${jersey2.version}</version>
    <scope>test</scope>
</dependency>