有没有办法知道在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,因此我记录的异常和返回的用户错误非常清楚.理想情况下,我的转换方法会有一个额外的参数用于细节,如下所示:

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);
}

但是这会打破惯例意味着Jersey找到了解析方法:

3. 有一个名为valueOf或fromString接受单个String参数的静态方法(例如,参见,Integer.valueOf(String)和java.util.UUID.fromString(String));

我也看过ParamConverterProvider那个也可以注册以提供转换,但它似乎也没有添加足够的上下文.它提供的最接近的是Annotations数组,但是从我可以看到的注释,你不能从那里回溯以确定注释所在的变量或方法.我已经找到了这个和这个例子,但它们没有有效地使用Annotations[]参数或暴露我能看到的任何转换上下文.

有没有办法获得这些信息？或者我是否需要在我的端点方法中回退到显式转换调用？

如果它有所作为,我使用的是Dropwizard 0.8.0,它使用的是Jersey 2.16和Jetty 9.2.9.v20150224.

Answer 1

所以这可以用ParamConverter/ 来完成ParamConverterProvider.我们只需要注入一个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()此操作时,它将在请求范围内.

  需要谨慎的是它get() 必须在fromString方法中调用ParamConverter.在应用程序加载期间多次调用该getConverter方法ParamConverterProvider,因此get()在此期间我们无法尝试调用它.

• java.lang.reflect.Parameter我使用的类是Java 8类,因此为了使用此实现,您需要使用Java 8.如果您不使用Java 8,这篇文章可能有助于尝试以其他方式获取参数名称.

• 与上述观点,编译器参数-parameters进行编译时的指出了应用,才能够访问形式参数的名称,在这里.我只是把它放在链接中指出的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没有解释问题.因此,如果您想要不同的行为,则需要确保处理异常.

UPDATE

上面的实现中有一个错误:

// 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;