java – 有没有办法知道在Jersey @__Param fromString处理程序中正在解析哪个参数？

2023-08-28 08:03:52

我正在使用的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);
}

但这会打破by-convention means that Jersey finds a parsing method：

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

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

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

解决方法:

所以这可以通过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()时,它将在请求范围内.

需要谨慎的是,必须在ParamConverter的fromString方法中调用get().在应用程序加载期间,ParamConverterProvider的getConverter方法被多次调用,因此在此期间我们无法尝试调用get().
>我使用的java.lang.reflect.Parameter类是Java 8类,因此为了使用此实现,您需要使用Java 8.如果您不使用Java 8,this post可能有助于尝试以其他方式获取参数名称.
>与上述相关,编译时参数-parameters需要在编译时应用,以便能够访问形式参数名称,如here所指出的那样.我只是把它放在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.
>需要注意的一件重要事情(that I learned the hard way)是,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;
上一篇：java – JAX-RS / Jersey路径参数regex用于简单字符串


下一篇：java.lang.noclassdeffounderror：org / glassfish / hk2 / api / servicelocatorfactory $createpolicy