如果数组在 List 或 Map 中注释，Java 8 TYPE_USE 注释不起作用

Question

我正在尝试编写一个带有注释的简单验证库，该库使用 Java 8 中的新 TYPE_USE 目标。访问这些东西的方式非常复杂，并且给我留下了两个非常混乱的代码，它们的功能完全相同，但也与他们实际要做的事情非常相关。所以我决定创建一组简单的类来以非常简单和直观的方式保存这些信息。基本上有 TypedClass，它是一个类包装器，但它可以转换为 ListClass（集合或数组）或 MapClass 以作为 TypedClass 访问其组件（或键/值）。最重要的部分是应该转换的这个助手：

static TypedClass<?> create(Field f) {
    final TypeResolver typeResolver = new TypeResolver();
    ResolvedType type = typeResolver.resolve(f.getGenericType());
    return create(f.getAnnotations(), type, f.getAnnotatedType());
}

private static TypedClass<?> create(Annotation[] annotations, ResolvedType type, AnnotatedType at) {
    if (type.isArray()) {
        AnnotatedType childAnnotatedType = ((AnnotatedArrayType) at).getAnnotatedGenericComponentType();
        ResolvedType childType = type.getArrayElementType();
        return new ListClass<>(type.getErasedType(), annotations, create(at.getAnnotations(), childType, childAnnotatedType));
    } else if (type.isInstanceOf(Collection.class)) {
        AnnotatedType childAnnotatedType = ((AnnotatedParameterizedType) at).getAnnotatedActualTypeArguments()[0];
        ResolvedType childType = type.typeParametersFor(Collection.class).get(0);
        return new ListClass<>(type.getErasedType(), annotations, createForGenerics(childType, childAnnotatedType));
    } else if (type.isInstanceOf(Map.class)) {
        AnnotatedType[] att = ((AnnotatedParameterizedType) at).getAnnotatedActualTypeArguments();
        List<ResolvedType> types = type.typeParametersFor(Map.class);
        TypedClass<?> key = createForGenerics(types.get(0), att[0]);
        TypedClass<?> value = createForGenerics(types.get(1), att[1]);
        return new MapClass<>(type.getErasedType(), annotations, key, value);
    }
    return new TypedClass<>(type.getErasedType(), annotations);
}

private static TypedClass<?> createForGenerics(ResolvedType childType, AnnotatedType childAnnotatedType) {
    return create(childAnnotatedType.getAnnotations(), childType, childAnnotatedType);
}

这里我也是使用 com.fasterxml.classmate 中的 ResolvedType，它只是用来在 Java 中的 Type 和 Class 之间架起桥梁，这也是一种痛苦。我认为这与问题无关，因为生成的结构还可以，只是注释放错了位置。

它似乎工作得很好，除非 List 或 Map 中有一个数组。例如：

@First("array") List<@First("string") String> @First("list") [] arrayOfListOfString;

工作正常（注释与相应的类型匹配）。但是当我解析时

List<@First("int[]") Integer @First("int") []> listOfArrayOfInteger;

数组和整数都与@First("int") 注释相关联。

我已经调试了我的代码，但在任何地方都找不到对 @First("int[]") 注释的引用。我要么错过了一些非常简单的东西，要么没有任何意义。该代码似乎适用于其他所有场景，即使是更复杂的场景。几周以来我一直在尝试这样做，最近才找到我认为可行的解决方案。原来我之前的两种耦合方法也不适用于这种情况（没有这个特定的测试）。所以现在我很困。

怎么了？

Answer 1

在您对create 的初始调用中，您传递了字段 注释，但没有传递AnnotatedType at 的注释。因此，方法create负责调用at.getAnnotations()。如果您查看您的实现，您会发现它仅在数组情况下才会这样做。在所有其他情况下，您的方法会将逻辑切换为“传入的注释数组是与at 关联的数组”。

问题是您的第一个示例似乎是偶然的。您没有显示@First 注释的声明，但我怀疑@Targets、ElementType.FIELD 和 ElementType.TYPE_USE 都允许使用它。在这种情况下，表单的声明

@First("array") List… [] fieldName;

不明确，注释将被记录为both，fieldName 的字段注释和List…[] 类型的注释。因此，在第一个示例中无法识别一个注释数组在递归期间丢失的事实，因为它恰好与字段注释匹配。但是，一旦只允许 TYPE_USE 而不是 FIELD 目标的注释，您的代码甚至不适用于您的第一个示例。

因此，您必须决定传入的注释数组是与at 参数关联的还是与周围上下文关联的。如果两者都关联起来会更容易，因为在这种情况下，您可以通过让方法检索该数组而不是调用者来完全摆脱该参数。

你应该记住：

1. 如果你想记录递归类型的所有类型注解和字段注解，你将比类型节点多一个注解数组
2. 如果你想主要处理TYPE_USE注解，你根本不需要处理字段注解

这是一个查找所有注释的简单直接的解析代码：

public static void fullType(Field f) {
    AnnotatedType at = f.getAnnotatedType();
    fullType("\t", at);
    System.out.println(f.getName());
}
public static void fullType(String header, AnnotatedType at) {
    final boolean arrayType = at instanceof AnnotatedArrayType;
    if(arrayType) {
        fullType(header+"\t",
            ((AnnotatedArrayType)at).getAnnotatedGenericComponentType());
    }
    for(Annotation a: at.getAnnotations())
        System.out.println(header+a);
    if(arrayType) {
        System.out.println(header+"[]");
    }
    else if(at instanceof AnnotatedParameterizedType) {
        AnnotatedParameterizedType apt = (AnnotatedParameterizedType)at;
        System.out.println(header
            +((ParameterizedType)apt.getType()).getRawType().getTypeName());
        System.out.println(header+'<');
        String subHeader=header+"\t";
        for(AnnotatedType typeArg:
            apt.getAnnotatedActualTypeArguments())
            fullType(subHeader, typeArg);
        System.out.println(header+'>');
    }
    else if(at instanceof AnnotatedTypeVariable) {
        // when appearing in a Field’s type, it refers to Class’ type variables
        System.out.println(header+at.getType().getTypeName());
    }
    else if(at instanceof AnnotatedWildcardType) {
        System.out.println(header+"?");
        final AnnotatedWildcardType awt = (AnnotatedWildcardType)at;
        AnnotatedType[] bounds=awt.getAnnotatedLowerBounds();
        if(bounds==null || bounds.length==0) {
            bounds=awt.getAnnotatedUpperBounds();
            if(bounds==null || bounds.length==0) return;
            System.out.println(header+"extends");
        }
        else System.out.println(header+"super");
        header+="\t";
        for(AnnotatedType b: bounds) fullType(header, b);
    }
    else {
        assert at.getType().getClass()==Class.class;
        System.out.println(header+at.getType().getTypeName());
    }
}

它与您的示例字段完美配合。

Answer 2

你说：

@First("array") List<@First("string") String> @First("list") [] arrayOfListOfString;

工作正常（注释与相应的类型匹配）。

这在我看来是错误的。诸如

之类的类型

@English String @NonEmpty []

读作“非空英文字符串数组”。

现在让我们考虑你的例子（我已经稍微简化了）：

@First("array") List @First("list") [] arrayOfList;

您有一个@First("list") 数组，其中每个元素都是一个@First("array") 列表。那是你要的吗？这不是名字所暗示的。

我不知道您在 listOfArrayOfInteger 案例中的代码有什么问题，但鉴于您给出的一个示例似乎不正确。