有什么方法可以知道在 Jersey @__Param fromString 处理程序中正在解析哪个参数？

Question

与我合作的 API 决定接受 UUID 作为 Base32 编码字符串，而不是 UUID.fromString() 期望的标准十六进制、破折号分隔格式。这意味着我不能简单地将 @QueryParam UUID myUuid 写为方法参数，因为转换会失败。

我正在通过编写一个带有不同 fromString 转换器的自定义对象来解决这个问题，以便与 Jersey @QueryString 和 @FormParam 注释一起使用。我希望能够在 fromString 方法中访问转换的上下文，以便我可以提供更好的错误消息。现在，我所能做的就是：

public static Base32UUID fromString(String uuidString) {
    final UUID uuid = UUIDUtils.fromBase32(uuidString, false);
    if (null == uuid) {
        throw new InvalidParametersException(ImmutableList.of("Invalid uuid: " + uuidString));
    }
    return new Base32UUID(uuid);
}

我希望能够公开哪个参数具有无效的 UUID，因此我记录的异常和返回的用户错误是 crystal 清楚的。理想情况下，我的转换方法会有一个额外的详细信息参数，如下所示：

public static Base32UUID fromString(
    String uuidString,
    String parameterName // New parameter?
) {
    final UUID uuid = UUIDUtils.fromBase32(uuidString, false);
    if (null == uuid) {
        throw new InvalidParametersException(ImmutableList.of("Invalid uuid: " + uuidString
            + " for parameter " + parameterName));
    }
    return new Base32UUID(uuid);
}

但这会破坏 by-convention means that Jersey finds a parsing method :

Have a static method named valueOf or fromString that accepts a single String argument (see, for example, Integer.valueOf(String) and java.util.UUID.fromString(String));

我也看过 ParamConverterProvider 也可以注册以提供转换，但它似乎也没有添加足够的上下文。它提供的最接近的是注释数组，但据我所知，您不能从那里回溯以确定注释在哪个变量或方法上。我找到了 this and this 个示例，但它们没有有效地使用 Annotations[] 参数或公开我可以看到的任何转换上下文。

有什么办法可以得到这些信息吗？或者我是否需要回退到端点方法中的显式转换调用？

如果有所不同，我使用的是 Dropwizard 0.8.0，它使用的是 Jersey 2.16 和 Jetty 9.2.9.v20150224。

Answer 1

所以这个可以用一个ParamConverter/ParamConverterProvider. We just need to inject a ResourceInfo来完成。从那里我们可以获得资源 Method，并进行一些反思。下面是一个我已经测试过并且大部分都有效的示例实现。

import java.lang.reflect.Type;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.annotation.Annotation;

import java.util.Set;
import java.util.HashSet;
import java.util.Collections;

import javax.ws.rs.FormParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.ext.Provider;
import javax.ws.rs.container.ResourceInfo;
import javax.ws.rs.ext.ParamConverter;
import javax.ws.rs.ext.ParamConverterProvider;
import javax.ws.rs.BadRequestException;
import javax.ws.rs.InternalServerErrorException;

@Provider
public class Base32UUIDParamConverter implements ParamConverterProvider {

    @Context
    private javax.inject.Provider<ResourceInfo> resourceInfo;

    private static final Set<Class<? extends Annotation>> ANNOTATIONS;

    static {
        Set<Class<? extends Annotation>> annots = new HashSet<>();
        annots.add(QueryParam.class);
        annots.add(FormParam.class);
        ANNOTATIONS = Collections.<Class<? extends Annotation>>unmodifiableSet(annots);
    }

    @Override
    public <T> ParamConverter<T> getConverter(Class<T> type, 
                                              Type type1,
                                              Annotation[] annots) {

        // Check if it is @FormParam or @QueryParam
        for (Annotation annotation : annots) {
            if (!ANNOTATIONS.contains(annotation.annotationType())) {
                return null;
            }
        }

        if (Base32UUID.class == type) {
            return new ParamConverter<T>() {

                @Override
                public T fromString(String value) {
                    try {
                        Method method = resourceInfo.get().getResourceMethod();

                        Parameter[] parameters = method.getParameters();
                        Parameter actualParam = null;

                        // Find the actual matching parameter from the method.
                        for (Parameter param : parameters) {
                            Annotation[] annotations = param.getAnnotations();
                            if (matchingAnnotationValues(annotations, annots)) {
                                actualParam = param;
                            }
                        }

                        // null warning, but assuming my logic is correct, 
                        // null shouldn't be possible. Maybe check anyway :-)
                        String paramName = actualParam.getName();
                        System.out.println("Param name : " + paramName);

                        Base32UUID uuid = new Base32UUID(value, paramName);
                        return type.cast(uuid);
                    } catch (Base32UUIDException ex) {
                        throw new BadRequestException(ex.getMessage());
                    } catch (Exception ex) {
                        throw new InternalServerErrorException(ex);
                    }
                }

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

        return null;
    }

    private boolean matchingAnnotationValues(Annotation[] annots1, 
                                             Annotation[] annots2) throws Exception {

        for (Class<? extends Annotation> annotType : ANNOTATIONS) {
            if (isMatch(annots1, annots2, annotType)) {
                return true;
            }
        }
        return false;
    }

    private <T extends Annotation> boolean isMatch(Annotation[] a1, 
                                                   Annotation[] a2, 
                                                   Class<T> aType) throws Exception {
        T p1 = getParamAnnotation(a1, aType);
        T p2 = getParamAnnotation(a2, aType);
        if (p1 != null && p2 != null) {
            String value1 = (String) p1.annotationType().getMethod("value").invoke(p1);
            String value2 = (String) p2.annotationType().getMethod("value").invoke(p2);
            if (value1.equals(value2)) {
                return true;
            }
        }

        return false;
    }

    private <T extends Annotation> T getParamAnnotation(Annotation[] annotations, 
                                                        Class<T> paramType) {
        T paramAnnotation = null;
        for (Annotation annotation : annotations) {
            if (annotation.annotationType() == paramType) {
                paramAnnotation = (T) annotation;
                break;
            }
        }
        return paramAnnotation;
    }
}

关于实现的一些说明

最重要的部分是 ResourceInfo 是如何注入的。由于这需要在请求范围上下文中访问，我注入了 javax.inject.Provider，这允许我们延迟检索对象。当我们真正做到get()的时候，就会在一个request范围内。

需要注意的是get()必须在ParamConverter的fromString方法中调用。 ParamConverterProvider 的 getConverter 方法在应用程序加载期间被多次调用，因此我们不能在此期间尝试调用 get()。
java.lang.reflect.Parameter class I used is a Java 8 class, so in order to use this implementation, you need to be working on Java 8. If you are not using Java 8, this post 可能有助于尝试以其他方式获取参数名称。

与上面的一点相关，编译时需要应用编译器参数-parameters，才能访问形式参数名称，如here所指出的。我只是把它放在 link.

中指出的 maven-cmpiler-plugin 中

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.5.1</version>
    <inherited>true</inherited>
    <configuration>
        <compilerArgument>-parameters</compilerArgument>
        <testCompilerArgument>-parameters</testCompilerArgument>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
</plugin>

如果不这样做，调用 Parameter.getName() 将导致 argX，X 是参数的索引。

实现只允许 @FormParam 和 @QueryParam。
需要注意的一件重要事情 ()，所有未在 ParamConverter 中处理的异常（在这种情况下仅适用于 @QueryParam），将导致 404 没有问题的解释。所以如果你想要不同的行为，你需要确保你处理了你的异常。

更新

上面的实现有一个错误：

// Check if it is @FormParam or @QueryParam
for (Annotation annotation : annots) {
    if (!ANNOTATIONS.contains(annotation.annotationType())) {
        return null;
    }
}

当为每个参数调用 getConverter 时，在模型验证期间调用上述代码。上面的代码只有在只有一个注解的情况下才有效。如果除了 @QueryParam 或 @FormParam 之外还有另一个注释，比如 @NotNull，它将失败。其余代码没问题。它确实在假设将不止一个注释的情况下起作用。

以上代码的修复，类似于

boolean hasParamAnnotation = false;
for (Annotation annotation : annots) {
    if (ANNOTATIONS.contains(annotation.annotationType())) {
        hasParamAnnotation = true;
        break;
    }
}

if (!hasParamAnnotation) return null;

Answer 2

只是为了扩展上面的 peeskillets 答案，您还可以考虑使用 dropwizard 和 jerseys 内置 bean 验证来解决问题。所以，不是从工厂方法内部抛出异常，而是这样做：

public class Base32UUID{
@NotNull
private final UUID uuid;
private Base32UUID(UUID uuid){ 
   this.uuid = uuid;
}
public static Base32UUID fromString(String uuidString) {
   final UUID uuid = UUIDUtils.fromBase32(uuidString, false);
   return new Base32UUID(uuid);
   }
}

在你的 reousource 方法中，你确保用@Valid 注释参数，这应该足以让 dropwizard return 一个描述性的错误消息，但是如果你想自定义 returned 值，创建并注册一个异常映射器，如下所示：

public class ValidationMapper implements ExceptionMapper<ConstraintViolationException>{

@Context
UriInfo uri;
@Context
private javax.inject.Provider<ResourceInfo> resourceInfo;
@Override
 public Response toResponse(ConstraintViolationException exception) {
   return Response.ok().build();
 }

}

在你的申请中class：

environment.jersey().register(ValidationMapper.class);

如您所见，在他的paramconverter 示例中注入的所有所需资源peeskillet 都可以在异常映射器中注入。 bean 验证方法似乎更适合我 + 一旦设置，它可以用于验证应用程序中任何地方的几乎所有输入，不仅仅是空检查，还有正则表达式匹配、电子邮件、数字范围等，并使确保应用程序总是 return 适当且格式适当的响应。根据 dropwizard docs 验证应该开箱即用，但我必须将 dropwizard-validation 和 jersey-bean-validation 添加到我的 pom 文件中才能使其工作：

<dependency>
    <groupId>io.dropwizard</groupId>
    <artifactId>dropwizard-validation</artifactId>
    <version>0.8.2</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-bean-validation</artifactId>
    <version>2.19</version>
    <exclusions>
        <exclusion>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </exclusion>
    </exclusions>
</dependency>

有什么方法可以知道在 Jersey @__Param fromString 处理程序中正在解析哪个参数？

Is there any way to know which parameter is being parsed in a Jersey @__Param fromString handler?

java

error-handling

annotations

jax-rs

jersey

更新