Java JsonSubTypes.value方法代码示例

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <S> Class<S> resolveJsonType(String path, Class<S> type) {
    JsonTypeInfo typeInfo = AnnotationUtils.findAnnotation(type, JsonTypeInfo.class);
    if (typeInfo == null) {
        return null;
    }
    String property = getPropertyName(typeInfo);
    String proppath = KvUtils.join(path, property);
    try {
        KvNode node = getStorage().get(proppath);
        if(node == null) {
            return null;
        }
        String str = node.getValue();
        JsonSubTypes subTypes = AnnotationUtils.findAnnotation(type, JsonSubTypes.class);
        for (JsonSubTypes.Type t : subTypes.value()) {
            if (t.name().equals(str)) {
                return (Class<S>) t.value();
            }
        }
    } catch (Exception e) {
        log.error("can't instantiate class", e);
    }
    return null;
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
private void getSubTypes(ClassInformation information, ReflectClass<?> cls) {
    JsonSubTypes annot = cls.getAnnotation(JsonSubTypes.class);
    if (annot == null) {
        return;
    }

    for (JsonSubTypes.Type subtype : annot.value()) {
        Class<?> subclass = subtype.value();
        ClassInformation subtypeInformation = get(subclass.getName());
        if (subtypeInformation == null) {
            continue;
        }
        information.inheritance.subTypes.add(subtypeInformation);
        // TODO check whether name conflicts with one got from JsonTypeName
        if (!subtype.name().isEmpty()) {
            subtypeInformation.typeName = subtype.name();
        }
        if (subtypeInformation.typeName == null) {
            subtypeInformation.typeName = "";
        }
    }
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
private String getJsonType(Class<?> clazz, JsonTypeInfo typeInfo) {
    String value;
    JsonTypeInfo.Id use = typeInfo.use();
    switch (use) {
        case CLASS:
            value = clazz.getName();
            break;
        case NAME: {
            JsonSubTypes.Type needed = null;
            JsonSubTypes subTypes = AnnotationUtils.findAnnotation(clazz, JsonSubTypes.class);
            if(subTypes != null) {
                for(JsonSubTypes.Type type: subTypes.value()) {
                    if(type.value().equals(clazz)) {
                        needed = type;
                        break;
                    }
                }
            }
            if(needed == null) {
                throw new IllegalArgumentException("On " + clazz + " can not find 'JsonSubTypes' record for current type.");
            }
            value = needed.name();
            break;
        }
        default:
            throw new IllegalArgumentException("On " + clazz + " find unexpected 'JsonTypeInfo.use' value: " + use);
    }
    return value;
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
private static List<JavaType> resolveNonArrayTypes(JavaType javaType, TypeFactory typeFactory) {
    List<JavaType> types = new ArrayList<>();
    types.add(javaType);

    Class<?> rawClass = javaType.getRawClass();
    JsonSubTypes jsonSubTypes = rawClass.getAnnotation(JsonSubTypes.class);
    if (jsonSubTypes != null) {
        for (JsonSubTypes.Type subType : jsonSubTypes.value()) {
            JavaType javaSubType = typeFactory.constructType(subType.value());
            types.add(javaSubType);
        }
    }

    return types;
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
public List<NamedType> findSubtypes(Annotated paramAnnotated)
{
  JsonSubTypes localJsonSubTypes = (JsonSubTypes)paramAnnotated.getAnnotation(JsonSubTypes.class);
  if (localJsonSubTypes == null)
    return null;
  JsonSubTypes.Type[] arrayOfType = localJsonSubTypes.value();
  ArrayList localArrayList = new ArrayList(arrayOfType.length);
  int i = arrayOfType.length;
  for (int j = 0; j < i; j++)
  {
    JsonSubTypes.Type localType = arrayOfType[j];
    localArrayList.add(new NamedType(localType.value(), localType.name()));
  }
  return localArrayList;
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
public void doForSubtype(SchemaFactoryWrapper factoryWrapper, ObjectNode schema, ArrayNode form, JsonSubTypes subtype) throws JsonMappingException {
	List<String> types = new ArrayList<>();
	for (JsonSubTypes.Type type : subtype.value()) {
		objectMapper.acceptJsonFormatVisitor(objectMapper.constructType(type.value()), factoryWrapper);
		JsonSchema jsonSchema = factoryWrapper.finalSchema();
		jsonSchema.setId(null);
		String title = type.name().replaceAll("\\.", "_");
		jsonSchema.asObjectSchema().setTitle(title);

		iterateOnProperties(jsonSchema.asObjectSchema().getProperties());
		schema.putPOJO(title, jsonSchema);
		types.add(title);
	}

	ObjectNode choice = objectMapper.createObjectNode();
	choice.put("type", "string");
	choice.putPOJO("enum", types);
	schema.set("choice", choice);

	form.addPOJO(objectMapper
			.createObjectNode()
			.put("type", "fieldset")
			.put("title", "Sources")
			.set("items",
					objectMapper.createArrayNode().add(
							objectMapper.createObjectNode().put("type", "selectfieldset").put("key", "choice").put("title", "Choose a source")
									.putPOJO("items", types))));
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
private static JsonSubTypes.Type getJsonSubTypeForClass(JsonSubTypes types, Class<?> cls) {
    for (JsonSubTypes.Type type : types.value()) {
        if (type.value().equals(cls)) {
            return type;
        }
    }
    return null;
}
 

import com.fasterxml.jackson.annotation.JsonSubTypes; //导入方法依赖的package包/类
@Nonnull
@Override
public Result<Map<TypeDescriptor, String>> subclasses(TypeDescriptor type) {
    JsonSubTypes jsonSubType = type.getAnnotation(JsonSubTypes.class);
    if (jsonSubType != null && jsonSubType.value().length > 0) {
        TypeDescriptors typeDescriptors = type.getTypeDescriptors();
        Map<TypeDescriptor, String> aliasesByTypes = asList(jsonSubType.value()).stream()
                .collect(toMap(subType -> typeDescriptors.get(subType.value()), Type::name));
        return Result.of(aliasesByTypes);
    }
    return Result.notFound();
}