Java 类com.fasterxml.jackson.databind.JavaType 实例源码

@Override
protected boolean supports(Class<?> clazz) {
    JavaType javaType = getJavaType(clazz);
    AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
    if (this.objectMapper.canDeserialize(javaType, causeRef)) {
        return true;
    }
    Throwable cause = causeRef.get();
    if (cause != null) {
        String msg = "Failed to evaluate deserialization for type " + javaType;
        if (logger.isDebugEnabled()) {
            logger.warn(msg, cause);
        }
        else {
            logger.warn(msg + ": " + cause);
        }
    }
    return false;
}

@Override
public void encode(OutputStream out, Object object) throws Exception {
    Class<?> clazz = object.getClass();
    JsonGenerator generator = constructGenerator(out);
    JavaType type = mapper.getTypeFactory().constructType(clazz);
    ObjectWriter writer = mapper.writerFor(type);
    writer.writeValue(generator, object);
    generator.close();
}

@Then("^I should get all users with the following properties: (.*)$")
public void i_should_get_all_users_with_the_following_properties(List<String> properties) throws IOException {
    ObjectMapper mapper = new ObjectMapper();

    JavaType type = mapper.getTypeFactory().constructCollectionType(List.class, User.class);
    List<User> users = mapper.readValue(httpWorld.loadResponse().getBody(), type);

    for (String property : properties) {
        assertThat(users, everyItem(HasProperty.hasProperty(property)));
    }
}

JavaType typeFromId(String id, TypeFactory typeFactory) throws IllegalStateException {
    String className = basePackage + "." + generateClassName(id);
    try {
        return typeFactory.constructType(typeFactory.findClass(className));
    } catch (ClassNotFoundException ex) {
        throw new IllegalStateException("Could not find event class for type " + id, ex);
    }
}

@Override
public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config, JavaType type,
    BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
  if (Arrays.asList(Quality.class, Format.class).contains(type.getRawClass())) {
    return new EnumDeserializer((Class<? extends Enum>) type.getRawClass());
  }
  return super.modifyEnumDeserializer(config, type, beanDesc, deserializer);
}

@Override
public Optional<Object> tryCoerceParam(InvocationContext currentContext, int param, InputEvent input, MethodWrapper method) {

    Type type = method.getTargetMethod().getGenericParameterTypes()[param];
    JavaType javaType = objectMapper(currentContext).constructType(type);

    return Optional.ofNullable(input.consumeBody(inputStream -> {
        try {
            return objectMapper(currentContext).readValue(inputStream, javaType);
        } catch (IOException e) {
            throw coercionFailed(type, e);
        }
    }));

}

@BeforeClass
public static void init() throws ParseException, IOException {
    logger.info("    Initializing RLP tests...");
    String json = getJSON("rlptest");

    Assume.assumeFalse("Local test is not available", json.equals(""));

    ObjectMapper mapper = new ObjectMapper();
    JavaType type = mapper.getTypeFactory().
            constructMapType(HashMap.class, String.class, RLPTestCase.class);

    TEST_SUITE = mapper.readValue(json, type);
}

private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
    try {
        return this.objectMapper.readValue(inputMessage.getBody(), javaType);
    }
    catch (IOException ex) {
        throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
    }
}

@Override
public JavaType doConvert(ClassLoader classLoader, String packageName, Swagger swagger, Object property) {
  ArrayProperty arrayProperty = (ArrayProperty) property;

  return findJavaType(classLoader,
      packageName,
      swagger,
      arrayProperty.getItems(),
      arrayProperty.getUniqueItems());
}

private static JavaType getOrCreateEnumByNames(ClassLoader classLoader, String packageName, List<String> enums) {
  String strEnums = enums.toString();

  synchronized (LOCK) {
    JavaType javaType = enumMap.get(strEnums);
    if (javaType != null) {
      return javaType;
    }

    String enumClsName = packageName + ".Enum" + enumMap.size();
    @SuppressWarnings("rawtypes")
    Class<? extends Enum> enumCls = JavassistUtils.createEnum(classLoader, enumClsName, enums);
    javaType = TypeFactory.defaultInstance().constructType(enumCls);
    enumMap.put(strEnums, javaType);

    return javaType;
  }
}

public static JavaType findJavaType(ClassLoader classLoader, String packageName, Swagger swagger, String type,
    String format, List<String> enums) {
  if (!isEnum(enums)) {
    return ConverterMgr.findJavaType(type, format);
  }

  // enum，且需要动态生成class
  return getOrCreateEnumByNames(classLoader, packageName, enums);
}

@Override
public JavaType doConvert(ClassLoader classLoader, String packageName, Swagger swagger, Object property) {
  StringProperty stringProperty = (StringProperty) property;

  List<String> enums = stringProperty.getEnum();
  return findJavaType(classLoader,
      packageName,
      swagger,
      stringProperty.getType(),
      stringProperty.getFormat(),
      enums);
}

public static void bulkLinkedRead1Test() throws IOException {
    SugarRestClient client = new SugarRestClient(TestAccount.Url, TestAccount.Username, TestAccount.Password);

    // -------------------Read Account Link Contact-------------------
    int count = 10;
    SugarRestResponse response = LinkedModules.bulkReadAccountLinkContact(client, count);

    assertNotNull(response);
    assertEquals(response.getStatusCode(), HttpStatus.SC_OK);

    String jsonData = response.getJData();
    assertNull(response.getData());
    assertNotNull(jsonData);

    // Deserialize json data to custom object
    ObjectMapper mapper = JsonObjectMapper.getMapper();
    JavaType type = mapper.getTypeFactory().constructCollectionType(ArrayList.class, CustomAcccount1.class) ;
    List<CustomAcccount1> customAccounts = mapper.readValue(jsonData, type);
    assertNotNull(customAccounts);
    assertEquals(customAccounts.size(), count);
}

@Override
protected MethodSpec implementDeserializeMethod(TypeElement typeElement, Builder deserializeMethodBuilder) {
    Optional<DeserializationConstructs> constructs = loadConstructs(typeElement);
    if (!constructs.isPresent()) {
        return deserializeMethodBuilder.addStatement("return null").build();
    }

    TypeElement enumTypeElement = constructs.get().getEnumTypeElement();
    ImmutableList<Element> enumValueElements = constructs.get().getEnumValueElements();
    ExecutableElement enumValueAccessorMethod = constructs.get().getEnumValueAccessorMethod();
    ExecutableElement enumInstanceAccessorMethod = constructs.get().getEnumInstanceAccessorMethod();

    String memberVariableName = this.processorUtil.createMemberVariableName(enumValueAccessorMethod);

    deserializeMethodBuilder.addStatement("$T codec = $L.getCodec()", ObjectCodec.class, JSON_PARSER_PARAMETER_NAME)
            .addStatement("$T rootNode = codec.readTree($L)", JsonNode.class, JSON_PARSER_PARAMETER_NAME)
            .addStatement("$T typeNode = rootNode.get($S)", JsonNode.class, memberVariableName)
            .beginControlFlow("if (typeNode == null)")
            .addStatement("$T javaType = $L.constructType($T.class)", JavaType.class, DESERIALIZATION_CONTEXT_PARAMETER_NAME, enumTypeElement)
            .addStatement("throw new $T($L, \"$L not present\", javaType, null)", InvalidTypeIdException.class, JSON_PARSER_PARAMETER_NAME, memberVariableName)
            .endControlFlow()
            .addStatement("$T type = codec.treeToValue(typeNode, $T.$L)", enumTypeElement, enumTypeElement, "class")
            .beginControlFlow("switch (type)");

    enumValueElements.forEach(enumValueElement -> deserializeMethodBuilder
            .beginControlFlow("case $L:", enumValueElement)
            .addStatement("return codec.treeToValue(rootNode, $T.$L.$L)", enumTypeElement, enumValueElement, enumInstanceAccessorMethod)
            .endControlFlow());

    return deserializeMethodBuilder.beginControlFlow("default :")
            .addStatement("return null")
            .endControlFlow()
            .endControlFlow()
            .build();
}

@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
                                                        Retrofit retrofit) {
    JavaType javaType = mapper.getTypeFactory().constructType(type);
    ObjectReader reader = mapper.readerFor(javaType);
    return new JacksonResponseBodyConverter<>(reader, type);
}

public static JavaType findJavaType(ClassLoader classLoader, String packageName, Swagger swagger, Object def) {
  if (def == null) {
    return VOID_JAVA_TYPE;
  }
  Converter converter = converterMap.get(def.getClass());
  if (converter == null) {
    throw new Error("not support def type: " + def.getClass());
  }

  return converter.convert(classLoader, packageName, swagger, def);
}

@Override
public JavaType typeFromId(DatabindContext context, String id) {
  JavaType type = nameToType.get(id.toLowerCase());
  if (type == null) {
    throw new NullPointerException(
        format("no subtype of %s found for enum value %s. existing mappings:\n%s",
            baseType, id, description));

  }
  return type;
}

@Override
public JavaType doConvert(ClassLoader classLoader, String packageName, Swagger swagger, Object model) {
  ArrayModel arrayModel = (ArrayModel) model;

  if (arrayModel.getItems() != null) {
    return ArrayPropertyConverter.findJavaType(classLoader,
        packageName,
        swagger,
        arrayModel.getItems(),
        false);
  }

  // don't know when will this happen.
  throw new Error("not support null array model items.");
}

public StateTestSuite(String json) throws IOException {

        ObjectMapper mapper = new ObjectMapper();
        JavaType type = mapper.getTypeFactory().
                constructMapType(HashMap.class, String.class, StateTestCase.class);

        testCases = new ObjectMapper().readValue(json, type);
    }

public static Class<?> getOrCreateClass(ClassLoader classLoader, String packageName, Swagger swagger,
    Map<String, Property> properties,
    String clsName) {
  Class<?> cls = getClassByName(classLoader, clsName);
  if (cls != null) {
    return cls;
  }

  ClassConfig classConfig = new ClassConfig();
  classConfig.setClassName(clsName);

  if (null != properties) {
    for (Entry<String, Property> entry : properties.entrySet()) {
      JavaType propertyJavaType =
          ConverterMgr.findJavaType(classLoader,
              packageName,
              swagger,
              entry.getValue());
      classConfig.addField(entry.getKey(), propertyJavaType);
    }
  }

  cls = JavassistUtils.createClass(classLoader, classConfig);
  return cls;
}

public static Class<?> getOrCreateBodyClass(OperationGenerator operationGenerator,
    List<BodyParameter> bodyParameters) {
  SwaggerGenerator swaggerGenerator = operationGenerator.getSwaggerGenerator();
  Method method = operationGenerator.getProviderMethod();
  String clsName = swaggerGenerator.ensureGetPackageName() + "." + method.getName() + "Body";
  Class<?> cls = getClassByName(swaggerGenerator.getClassLoader(), clsName);
  if (cls != null) {
    return cls;
  }

  ClassConfig classConfig = new ClassConfig();
  classConfig.setClassName(clsName);

  // 1.全是预备body
  // 2.预备body与明确body混合
  for (BodyParameter bp : bodyParameters) {
    JavaType javaType = ConverterMgr.findJavaType(swaggerGenerator.getClassLoader(),
        swaggerGenerator.ensureGetPackageName(),
        swaggerGenerator.getSwagger(),
        bp);
    classConfig.addField(bp.getName(), javaType);
  }

  return JavassistUtils.createClass(swaggerGenerator.getClassLoader(), classConfig);
}

public DifficultyTestSuite(String json) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    JavaType type = mapper.getTypeFactory().
            constructMapType(HashMap.class, String.class, DifficultyTestCase.class);

    Map<String, DifficultyTestCase> caseMap = new ObjectMapper().readValue(json, type);

    for (Map.Entry<String, DifficultyTestCase> e : caseMap.entrySet()) {
        e.getValue().setName(e.getKey());
        testCases.add(e.getValue());
    }

    Collections.sort(testCases, new Comparator<DifficultyTestCase>() {
        @Override
        public int compare(DifficultyTestCase t1, DifficultyTestCase t2) {
            return t1.getName().compareTo(t2.getName());
        }
    });
}

/**
 * Parses the network response {@link NetworkResponse} and returns the expected Type for the request.
 * @param response {@link NetworkResponse} The response for the request (Success or error).
 * @return Response object linked to a specific type
 */
@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
    this.networkResponse = response;

    JavaType returnType = getReturnType();
    T returnData = null;
    if (returnType != null) {
        try {
            if (response.data != null) {
                returnData = SpitfireManager.getObjectMapper().readValue(response.data, returnType);
            }
        } catch (Exception e) {
            VolleyLog.e(e, "An error occurred while parsing network response:");
            returnData = null;
        }
    }

    if (returnData == null && classResponse != Void.class) {
        ParseError parseError = new ParseError(response);
        String content = "";
        if (response.data != null) {
            content = new String(response.data);
        }
        VolleyLog.e(parseError, "Return data is null. API returned : "+ content);
        return Response.error(parseError);
    }

    return Response.success(returnData, HttpHeaderParser.parseCacheHeaders(response));
}

private void checkType(JavaType type) {
  // 原子类型/string在java中是abstract的
  if (type.getRawClass().isPrimitive()
      || propertyCreatorMap.containsKey(type.getRawClass())
      || String.class.equals(type.getRawClass())) {
    return;
  }

  String msg = "Must be a concrete type.";
  if (type.isMapLikeType()) {
    Class<?> keyTypeClass = type.getKeyType().getRawClass();
    if (!String.class.equals(keyTypeClass)) {
      // swagger中map的key只允许为string
      throw new Error("Type of key in map must be string, but got " + keyTypeClass.getName());
    }
  }

  if (type.isContainerType()) {
    checkType(type.getContentType());
    return;
  }

  if (type.getRawClass().isInterface()) {
    throw new ServiceCombException(type.getTypeName() + " is interface. " + msg);
  }

  if (Modifier.isAbstract(type.getRawClass().getModifiers())) {
    throw new ServiceCombException(type.getTypeName() + " is abstract class. " + msg);
  }
}

@Override
public Model resolve(JavaType type, ModelConverterContext context, Iterator<ModelConverter> next) {
  // property is not a model
  if (propertyCreatorMap.containsKey(type.getRawClass())) {
    return null;
  }

  Model model = super.resolve(type, context, next);
  if (model == null) {
    return null;
  }

  checkType(type);

  // 只有声明model的地方才需要标注类型
  if (ModelImpl.class.isInstance(model) && !StringUtils.isEmpty(((ModelImpl) model).getName())) {
    setType(type, model.getVendorExtensions());
  }
  return model;
}

@Override
public void init(JavaType baseType) {
  this.baseType = baseType;
  Class<?> baseClass = baseType.getRawClass();
  TypesEnum typesEnum = baseClass.getAnnotation(TypesEnum.class);
  while (baseClass != null && typesEnum == null) {
    baseClass = baseClass.getSuperclass();
    typesEnum = baseClass.getAnnotation(TypesEnum.class);
  }
  if (typesEnum == null) {
    throw new NullPointerException("Missing annotation TypesEnum on " + baseType.getRawClass());
  }
  SubTypeMapping mapping = new SubTypeMapping(typesEnum);
  TypeFactory defaultInstance = TypeFactory.defaultInstance();
  StringBuilder sb = new StringBuilder();
  for (Enum<?> e : mapping.getEnumConstants()) {
    String name = e.name();
    String className = mapping.getClassName(e);
    try {
      Class<?> c = Class.forName(className, false, this.getClass().getClassLoader());
      JavaType type = defaultInstance.uncheckedSimpleType(c);
      this.nameToType.put(name.toLowerCase(), type);
      this.typeToName.put(c, name);
      sb.append(name + " => " + c.getName() + "\n");
    } catch (ClassNotFoundException e1) {
      throw new RuntimeException(String.format(
          "class not found %s for enum value %s for base type %s",
          className, name, baseType
          ) , e1);
    }
  }
  this.description = sb.toString();
}

@Test
public void testConverter() {
  SwaggerGenerator generator = new SwaggerGeneratorForTest(context, null);
  Swagger swagger = generator.getSwagger();
  ParamUtils.addDefinitions(swagger, User.class);
  Model model = swagger.getDefinitions().get("User");
  model.getVendorExtensions().clear();

  JavaType javaType = ConverterMgr.findJavaType(generator, model);
  checkJavaType(swagger, javaType);

  RefModel refModel = new RefModel();
  refModel.setReference("User");
  javaType = ConverterMgr.findJavaType(generator, refModel);
  checkJavaType(swagger, javaType);
}

private Map writeAndReadJson(Repository repository) throws Exception {
    NetworkStateExporter nse = new NetworkStateExporter(repository);
    Assert.assertTrue(nse.exportStatus(jsonFileName));

    InputStream inputStream = new FileInputStream(jsonFileName);
    String json = new String(ByteStreams.toByteArray(inputStream));

    ObjectMapper mapper = new ObjectMapper();
    JavaType type = mapper.getTypeFactory().constructType(HashMap.class);
    Map result = new ObjectMapper().readValue(json, type);
    return result;
}

@Test
public void testFetchAndLock() throws CamundaRestException, IOException {
    FetchExternalTasksDto dto = new FetchExternalTasksDto();
    List<LockedExternalTaskDto> externalTasks = service.fetchAndLock(dto);

    Assert.assertNotNull(externalTasks);
    Assert.assertEquals(1, externalTasks.size());
    Assert.assertNotNull(externalTasks.get(0));

    Mockito.verify(objectMapper, Mockito.times(1)).writeValueAsString(Mockito.any());
    Mockito.verify(objectMapper, Mockito.times(1)).getTypeFactory();
    Mockito.verify(objectMapper, Mockito.times(1)).readValue(Mockito.<InputStream>any(), Mockito.<JavaType>any());
    Mockito.verify(httpClient, Mockito.times(1)).execute(Mockito.any());
}

@Override
public Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit)
{
    JavaType javaType = mapper.getTypeFactory().constructType(type);
    ObjectWriter writer = mapper.writerFor(javaType);
    return new MessagePackRequestBodyConverter<>(writer);
}

/**
 * Returns the type for the response.
 * @return null, Array, List, Map or Object.
 */
@Nullable
private JavaType getReturnType() {
    if (classResponse == Void.class) {
        return null;
    } else if (classResponse.isArray()) {
        return TypeFactory.defaultInstance().constructArrayType(classResponse.getComponentType());
    } else if (classResponse == List.class) {
        return TypeFactory.defaultInstance().constructCollectionType(List.class, classResponse.getComponentType());
    } else if (classResponse == Map.class) {
        return TypeFactory.defaultInstance().constructMapType(Map.class, String.class, classResponse.getComponentType());
    }
    return TypeFactory.defaultInstance().constructType(classResponse);
}

@Override
public ParamValueProcessor create(Parameter parameter, Type genericParamType) {
  JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType);

  if (isPart(parameter)) {
    return new PartProcessor(parameter.getName(), targetType);
  }
  return new FormProcessor(parameter.getName(), targetType);
}

default Object decodeResponse(InputStream input, JavaType type) throws Exception {
  if (input.available() == 0) {
    return null;
  }

  return doDecodeResponse(input, type);
}

@SneakyThrows
private Map<String, Set<TenantState>> getTenantsList() {
    Optional<Configuration> maybeConfiguration = configurationService.findConfiguration(CONFIG_LIST_STORAGE);
    if (!maybeConfiguration.isPresent()) {
        return new HashMap<>();
    }
    Configuration configuration = maybeConfiguration.get();

    JavaType setType = om.getTypeFactory().constructCollectionType(Set.class, TenantState.class);
    JavaType stringType = om.getTypeFactory().constructType(String.class);
    JavaType mapType = om.getTypeFactory().constructMapType(Map.class, stringType, setType);

    return om.readValue(configuration.getContent(), mapType);
}

default Object decodeResponse(Buffer buffer, JavaType type) throws Exception {
  if (buffer.length() == 0) {
    return null;
  }

  try (BufferInputStream input = new BufferInputStream(buffer.getByteBuf())) {
    return doDecodeResponse(input, type);
  }
}

@Override
public Object doDecodeResponse(InputStream input, JavaType type) throws Exception {
  // plainText类型，肯定是返回string的，想不出有其他类型的场景
  return IOUtils.toString(input, StandardCharsets.UTF_8);
  // TODO: 该方法尚需进一步修改
  //        Class<?> returnCls = type.getRawClass();
  //        if (returnCls.isPrimitive()) {
  //            // 处理char类型
  //            if (returnCls == char.class) {
  //                return ((String)result).charAt(0);
  //            }
  //            // 处理其他如int, long, boolean等类型
  //            return RestObjectMapper.INSTANCE.readValue((String)result, type);
  //        }
  //        else {
  //            // 处理如String等其他复杂类型
  //            // 对于更多处理不了的复杂类型建议使用"application/json"
  //            return returnCls.getConstructor(new Class<?>[] {String.class})
  //                    .newInstance((String)result);
  //        }
}

@Test
public void testdecodeResponseNull() throws Exception {
  JavaType resultType = TypeFactory.unknownType();
  Object result = pp.decodeResponse(Buffer.buffer(), resultType);
  Assert.assertNull(result);

  ByteArrayInputStream is = new ByteArrayInputStream(new byte[] {});
  result = pp.decodeResponse(is, resultType);
  Assert.assertNull(result);
}

/**
 * 反序列化复杂Collection如List<Bean>,
 * contructCollectionType()或contructMapType()构造类型, 然后调用本函数.
 * 
 * @see #createCollectionType(Class, Class...)
 */
@SuppressWarnings("unchecked")
public <T> T fromJson(@Nullable String jsonString, JavaType javaType) {
    if (StringUtils.isEmpty(jsonString)) {
        return null;
    }

    try {
        return (T) mapper.readValue(jsonString, javaType);
    } catch (IOException e) {
        logger.warn("parse json string error:" + jsonString, e);
        return null;
    }
}

@Override
public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    JavaType javaType = getJavaType(type, contextClass);
    return readJavaType(javaType, inputMessage);
}

@Override
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    JavaType javaType = getJavaType(clazz, null);
    return readJavaType(javaType, inputMessage);
}