类com.fasterxml.jackson.databind.type.TypeFactory源码实例Demo

下面列出了怎么用com.fasterxml.jackson.databind.type.TypeFactory的API类实例代码及写法,或者点击链接到github查看源代码。

源代码1 项目: camunda-bpm-elasticsearch   文件: JsonHelper.java
public static Map<String, Object> readJsonFromClasspathAsMap(String fileName) {
  InputStream inputStream = null;

  try {
    inputStream = IoUtil.getResourceAsStream(fileName);
    if (inputStream == null) {
      throw new RuntimeException("File '" + fileName + "' not found!");
    }

    MapType type = TypeFactory.defaultInstance().constructMapType(HashMap.class, String.class, Object.class);
    HashMap<String, Object> mapping = objectMapper.readValue(inputStream, type);

    return mapping;
  } catch (IOException e) {
    throw new RuntimeException("Unable to load json [" + fileName + "] from classpath", e);
  } finally {
    IoUtil.closeSilently(inputStream);
  }
}
 
private void success_invocation() throws InterruptedException, ExecutionException {
  new Expectations(invocation) {
    {
      invocation.getTransportContext();
      result = transportContext;

      operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION);
      result = restOperationMeta;

      invocation.findResponseType(anyInt);
      result = TypeFactory.defaultInstance().constructType(String.class);
    }
  };

  codecFilter.onFilter(invocation, nextNode).get();
}
 
源代码3 项目: spring-cloud-function   文件: JacksonMapper.java
@Override
public <T> T fromJson(Object json, Type type) {
	T convertedValue = null;
	JavaType constructType = TypeFactory.defaultInstance().constructType(type);

	try {
		if (json instanceof String) {
			convertedValue = this.mapper.readValue((String) json, constructType);
		}
		else if (json instanceof byte[]) {
			convertedValue = this.mapper.readValue((byte[]) json, constructType);
		}
		else if (json instanceof Reader) {
			convertedValue = this.mapper.readValue((Reader) json, constructType);
		}
	}
	catch (Exception e) {
		logger.warn("Failed to convert. Possible bug as the conversion probably shouldn't have been attampted here", e);
	}
	return convertedValue;
}
 
@Override
public ParamValueProcessor create(Parameter parameter, Type genericParamType) {
  Model model = ((BodyParameter) parameter).getSchema();
  JavaType swaggerType = null;
  if (model instanceof ModelImpl) {
    swaggerType = ConverterMgr.findJavaType(((ModelImpl) model).getType(), ((ModelImpl) model).getFormat());
  }
  boolean isString = swaggerType != null && swaggerType.getRawClass().equals(String.class);

  JavaType targetType =
      genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType);
  boolean rawJson = SwaggerUtils.isRawJsonType(parameter);
  if (rawJson) {
    return new RawJsonBodyProcessor(targetType, (String) parameter.getVendorExtensions()
        .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired());
  }

  return new BodyProcessor(targetType, (String) parameter.getVendorExtensions()
      .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired());
}
 
源代码5 项目: components   文件: JdbcComponentTestIT.java
@Test
public void getJdbcDefinition() throws java.io.IOException {
    // when
    Response response = given()
            .accept(APPLICATION_JSON_UTF8_VALUE).get(getVersionPrefix() + "/definitions/DATA_STORE");
    response.then()
            .statusCode(200).log().ifError();

    // then
    List<DefinitionDTO> definitions = mapper
            .readerFor(TypeFactory.defaultInstance().constructCollectionType(List.class, DefinitionDTO.class))
            .readValue(response.asInputStream());

    DefinitionDTO jdbcDef = null;

    for (DefinitionDTO definition : definitions) {
        if (DATA_STORE_DEFINITION_NAME.equals(definition.getName())) {
            jdbcDef = definition;
            break;
        }
    }
    assertNotNull(jdbcDef);
}
 
源代码6 项目: riptide   文件: StreamConverterTest.java
@Test
void shouldSupportReadGeneric() {
    final ObjectMapper mapper = mock(ObjectMapper.class);
    final TypeFactory factory = new ObjectMapper().getTypeFactory();
    when(mapper.getTypeFactory()).thenReturn(factory);
    when(mapper.canDeserialize(any())).thenReturn(true);
    final StreamConverter<Object> unit = streamConverter(mapper, singletonList(APPLICATION_X_JSON_STREAM));

    assertFalse(unit.canRead(Object.class, getClass(), APPLICATION_X_JSON_STREAM));
    assertFalse(unit.canRead(Streams.streamOf(Object.class).getType(), getClass(), APPLICATION_XML));

    assertTrue(unit.canRead(Streams.streamOf(List.class).getType(), getClass(), APPLICATION_X_JSON_STREAM));
    assertTrue(unit.canRead(Streams.streamOf(List[].class).getType(), getClass(), APPLICATION_X_JSON_STREAM));
    assertTrue(unit.canRead(Streams.streamOf(AccountBody.class).getType(), getClass(), null));
    assertTrue(unit.canRead(Streams.streamOf(AccountBody[].class).getType(), getClass(), null));

    when(mapper.canDeserialize(factory.constructType(AccountBody.class))).thenReturn(false);
    assertFalse(unit.canRead(Streams.streamOf(AccountBody.class).getType(), getClass(), APPLICATION_X_JSON_STREAM));
}
 
private <T> RedisCacheConfiguration determineConfiguration(
        Type type) {
    CacheProperties.Redis redisProperties = this.cacheProperties.getRedis();
    RedisCacheConfiguration config = RedisCacheConfiguration
            .defaultCacheConfig();
    Jackson2JsonRedisSerializer<T> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(TypeFactory.defaultInstance().constructType(type));
    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    config = config.serializeValuesWith(RedisSerializationContext.SerializationPair
            .fromSerializer(jackson2JsonRedisSerializer));
    if (redisProperties.getTimeToLive() != null) {
        config = config.entryTtl(redisProperties.getTimeToLive());
    }
    if (redisProperties.getKeyPrefix() != null) {
        config = config.prefixKeysWith(redisProperties.getKeyPrefix());
    }
    if (!redisProperties.isCacheNullValues()) {
        config = config.disableCachingNullValues();
    }
    if (!redisProperties.isUseKeyPrefix()) {
        config = config.disableKeyPrefix();
    }
    return config;
}
 
public PojoConsumerOperationMeta(PojoConsumerMeta pojoConsumerMeta, OperationMeta operationMeta,
    SwaggerConsumerOperation swaggerConsumerOperation,
    Swagger intfSwagger, Operation intfOperation) {
  this.pojoConsumerMeta = pojoConsumerMeta;
  this.operationMeta = operationMeta;
  this.swaggerConsumerOperation = swaggerConsumerOperation;

  Type intfResponseType = ParamUtils
      .getGenericParameterType(swaggerConsumerOperation.getConsumerClass(),
          swaggerConsumerOperation.getConsumerMethod().getDeclaringClass(),
          swaggerConsumerOperation.getConsumerMethod().getGenericReturnType());

  if (intfResponseType instanceof Class && Part.class.isAssignableFrom((Class<?>) intfResponseType)) {
    responseType = TypeFactory.defaultInstance().constructType(Part.class);
    return;
  }

  intfResponseType = findResponseTypeProcessor(intfResponseType).extractResponseType(intfResponseType);
  if (intfResponseType != null) {
    responseType = TypeFactory.defaultInstance().constructType(intfResponseType);
  }
}
 
@SuppressWarnings("unchecked")
@Test
public void testGetValueSet() throws Exception {
  new Expectations() {
    {
      request.getParameterValues("name");
      result = new String[] {"value"};
    }
  };

  ParamValueProcessor processor = createProcessor("name",
      TypeFactory.defaultInstance().constructCollectionType(Set.class, String.class), null,
      true);
  Object value = processor.getValue(request);
  Assert.assertThat((Set<String>) value, Matchers.contains("value"));
}
 
public void testRootNameAccess() throws Exception
{
    final TypeFactory tf = MAPPER.getTypeFactory();
    AnnotationIntrospector ai = new JaxbAnnotationIntrospector();
    // If no @XmlRootElement, should get null (unless pkg has etc)
    assertNull(ai.findRootName(MAPPER.serializationConfig(),
            AnnotatedClassResolver.resolve(MAPPER.serializationConfig(),
            tf.constructType(SimpleBean.class), null)));
    // With @XmlRootElement, but no name, empty String
    PropertyName rootName = ai.findRootName(MAPPER.serializationConfig(),
            AnnotatedClassResolver.resolve(MAPPER.serializationConfig(),
            tf.constructType(NamespaceBean.class), null));
    assertNotNull(rootName);
    assertEquals("", rootName.getSimpleName());
    assertEquals("urn:class", rootName.getNamespace());

    // and otherwise explicit name
    rootName = ai.findRootName(MAPPER.serializationConfig(),
            AnnotatedClassResolver.resolve(MAPPER.serializationConfig(),
            tf.constructType(RootNameBean.class), null));
    assertNotNull(rootName);
    assertEquals("test", rootName.getSimpleName());
    assertNull(rootName.getNamespace());
}
 
@SuppressWarnings("unchecked")
@Test
public void testGetValueSet() throws Exception {
  new Expectations() {
    {
      request.getHeaders("h1");
      result = Collections.enumeration(Arrays.asList("h1v"));
    }
  };

  HeaderProcessor processor = createProcessor("h1",
      TypeFactory.defaultInstance().constructCollectionType(Set.class, String.class),
      null, true);
  Object value = processor.getValue(request);
  Assert.assertThat((Set<String>) value, Matchers.contains("h1v"));
}
 
源代码12 项目: registry   文件: Schema.java
@Override
public JavaType typeFromId(DatabindContext databindContext, String s) {
    Type fieldType = Schema.Type.valueOf(s);
    JavaType javaType;
    switch (fieldType) {
        case NESTED:
            javaType = TypeFactory.defaultInstance().constructType(NestedField.class);
            break;
        case ARRAY:
            javaType = TypeFactory.defaultInstance().constructType(ArrayField.class);
            break;
        default:
            javaType = TypeFactory.defaultInstance().constructType(Field.class);
    }
    return javaType;
}
 
@SuppressWarnings("unchecked")
@Test
public void testGetValueList() throws Exception {
  new Expectations() {
    {
      request.getParameterValues("name");
      result = new String[] {"value"};
    }
  };

  ParamValueProcessor processor = createProcessor("name",
      TypeFactory.defaultInstance().constructCollectionType(List.class, String.class),
      null, true);
  Object value = processor.getValue(request);
  Assert.assertThat((List<String>) value, Matchers.contains("value"));
}
 
源代码14 项目: servicecomb-java-chassis   文件: ConverterMgr.java
private static void initPropertyMap() {
  PROPERTY_MAP.put(BooleanProperty.class, TypeFactory.defaultInstance().constructType(Boolean.class));

  PROPERTY_MAP.put(FloatProperty.class, TypeFactory.defaultInstance().constructType(Float.class));
  PROPERTY_MAP.put(DoubleProperty.class, TypeFactory.defaultInstance().constructType(Double.class));
  PROPERTY_MAP.put(DecimalProperty.class, TypeFactory.defaultInstance().constructType(BigDecimal.class));

  PROPERTY_MAP.put(ByteProperty.class, TypeFactory.defaultInstance().constructType(Byte.class));
  PROPERTY_MAP.put(ShortProperty.class, TypeFactory.defaultInstance().constructType(Short.class));
  PROPERTY_MAP.put(IntegerProperty.class, TypeFactory.defaultInstance().constructType(Integer.class));
  PROPERTY_MAP.put(BaseIntegerProperty.class, TypeFactory.defaultInstance().constructType(Integer.class));
  PROPERTY_MAP.put(LongProperty.class, TypeFactory.defaultInstance().constructType(Long.class));

  // stringProperty include enum scenes, not always be string type
  // if convert by StringPropertyConverter, can support enum scenes
  PROPERTY_MAP.put(StringProperty.class, TypeFactory.defaultInstance().constructType(String.class));

  PROPERTY_MAP.put(DateProperty.class, TypeFactory.defaultInstance().constructType(LocalDate.class));
  PROPERTY_MAP.put(DateTimeProperty.class, TypeFactory.defaultInstance().constructType(Date.class));

  PROPERTY_MAP.put(ByteArrayProperty.class, TypeFactory.defaultInstance().constructType(byte[].class));

  PROPERTY_MAP.put(FileProperty.class, TypeFactory.defaultInstance().constructType(Part.class));
}
 
源代码15 项目: netty-rest   文件: ModelConverters.java
private boolean shouldProcess(Type type) {
    final Class<?> cls = TypeFactory.defaultInstance().constructType(type).getRawClass();
    if (cls.isPrimitive()) {
        return false;
    }
    String className = cls.getName();
    for (String packageName : skippedPackages) {
        if (className.startsWith(packageName)) {
            return false;
        }
    }
    for (String classToSkip : skippedClasses) {
        if (className.equals(classToSkip)) {
            return false;
        }
    }
    return true;
}
 
源代码16 项目: conf4j   文件: YamlConverter.java
@Override
public T fromString(Type type, String value, Map<String, String> attributes) {
    requireNonNull(type, "type cannot be null");

    if (value == null) {
        return null;
    }

    try {
        JavaType javaType = TypeFactory.defaultInstance().constructType(type);
        ObjectReader objectReader = objectMapper.readerFor(javaType);
        return objectReader.readValue(value);
    } catch (IOException e) {
        // should never happen
        throw new IllegalStateException(e);
    }
}
 
源代码17 项目: data-highway   文件: PayloadTypeFactory.java
static PayloadTypeFactory fromClass(Class<?> payloadClass) {
  return new PayloadTypeFactory() {
    private static final long serialVersionUID = 1L;

    @Override
    public JavaType construct(TypeFactory typeFactory) {
      return typeFactory.constructType(payloadClass);
    }
  };
}
 
@Test
public void shouldValidateNothingForPrimitiveClass() {
  // given
  JavaType type = TypeFactory.defaultInstance().constructType(int.class);
  validator = createValidatorMock(true);

  // when
  format.getMapper().validateType(type, validator);

  // then
  Mockito.verifyZeroInteractions(validator);
}
 
public static FieldDocumentationVisitorWrapper create(JavadocReader javadocReader,
        ConstraintReader constraintReader, DeserializationConfig deserializationConfig,
        TypeRegistry typeRegistry, TypeFactory typeFactory, SnippetTranslationResolver translationResolver,
        JsonProperty.Access skipAccessor) {
    FieldDocumentationVisitorContext context = new FieldDocumentationVisitorContext(
            javadocReader, constraintReader, deserializationConfig, translationResolver);
    return new FieldDocumentationVisitorWrapper(context, "", null, typeRegistry, typeFactory, skipAccessor);
}
 
@Test
public void shouldFailForMapClass() {
  // given
  JavaType type = TypeFactory.defaultInstance().constructFromCanonical("java.util.HashMap<java.lang.String, java.lang.Integer>");
  validator = createValidatorMock(false);

  // then
  thrown.expect(SpinRuntimeException.class);
  thrown.expectMessage("[java.util.HashMap, java.lang.String, java.lang.Integer]");

  // when
  format.getMapper().validateType(type, validator);
}
 
@Test
public void shouldFailForArrayClass() {
  // given
  JavaType type = TypeFactory.defaultInstance().constructType(Integer[].class);
  setValidatorMockResult(false);

  // then
  thrown.expect(IllegalArgumentException.class);
  thrown.expectMessage("[java.lang.Integer]");

  // when
  variablesResourceSpy.validateType(type);
}
 
@Override
public JavaType convert(Swagger swagger, Object def) {
  Map<String, Object> vendorExtensions = findVendorExtensions(def);
  String canonical = SwaggerUtils.getClassName(vendorExtensions);
  if (StringUtils.isEmpty(canonical)) {
    return doConvert(swagger, def);
  }

  try {
    return TypeFactory.defaultInstance().constructFromCanonical(canonical);
  } catch (Throwable e) {
    // type not exist
    return OBJECT_JAVA_TYPE;
  }
}
 
源代码23 项目: kogito-runtimes   文件: ForEachStateSerializer.java
@Override
public void serialize(ForEachState forEachState,
                      JsonGenerator gen,
                      SerializerProvider provider) throws IOException {

    // set defaults for foreach state
    forEachState.setType(DefaultState.Type.FOREACH);

    // serialize after setting default bean values...
    BeanSerializerFactory.instance.createSerializer(provider,
            TypeFactory.defaultInstance().constructType(ForEachState.class)).serialize(forEachState,
            gen,
            provider);
}
 
源代码24 项目: rest-schemagen   文件: PaginatedResponseTest.java
@Test
public void shouldDeserialize() throws Exception {
    final ObjectMapper mapper = new ObjectMapper();
    final TypeFactory typeFactory = mapper.getTypeFactory();

    final String content = "{\"members\": [{\"value\": \"foo\", \"_schema\":{\"links\": []}}, {\"value\": \"bar\", \"_schema\":{\"links\": []}}], \"offset\": 100, \"limit\": 10, \"total\": 2000, \"_schema\":{\"links\":[]}}";

    final JavaType nameWithSchemaType = typeFactory.constructParametricType(PaginatedResponse.class, Payload.class);
    final PaginatedResponse<Payload> listResponse = mapper.readValue(content, nameWithSchemaType);

    assertThat(listResponse.getMembers()).extracting(ObjectWithSchema::getObject).extracting(p -> p.value).containsExactly("foo", "bar");
    assertThat(listResponse.getLimit()).isEqualTo(10);
    assertThat(listResponse.getOffset()).isEqualTo(100);
    assertThat(listResponse.getTotal()).isEqualTo(2000);
}
 
@Test
public void shouldValidateNothingForPrimitiveClass() {
  // given
  JavaType type = TypeFactory.defaultInstance().constructType(int.class);
  setValidatorMockResult(true);

  // when
  variablesResourceSpy.validateType(type);

  // then
  Mockito.verifyZeroInteractions(validator);
}
 
源代码26 项目: n2o-framework   文件: TestDataProviderEngine.java
private List<DataSet> loadJson(InputStream is, PrimaryKeyType primaryKeyType, String primaryKeyFieldId) throws IOException {
    TypeFactory typeFactory = objectMapper.getTypeFactory();
    CollectionType collectionType = typeFactory.constructCollectionType(
            List.class, DataSet.class);
    List<DataSet> dataList = objectMapper.readValue(is, collectionType);
    for (DataSet data : dataList) {
        if (data.containsKey(primaryKeyFieldId) && integer.equals(primaryKeyType))
            data.put(primaryKeyFieldId, ((Number) data.get(primaryKeyFieldId)).longValue());
    }
    return dataList;
}
 
源代码27 项目: n2o-framework   文件: TestDataProviderEngineTest.java
@Test
public void testCreateOnFile() throws IOException {
    TestDataProviderEngine engine = new TestDataProviderEngine();
    engine.setResourceLoader(new DefaultResourceLoader());
    engine.setPathOnDisk(testFolder.getRoot() + "/");

    N2oTestDataProvider provider = new N2oTestDataProvider();
    provider.setFile(testFile.getName());

    //Добавление новых данных
    provider.setOperation(create);

    Map<String, Object> inParamsForCreate = new LinkedHashMap<>();
    inParamsForCreate.put("id", 9L);
    inParamsForCreate.put("name", "test9");
    inParamsForCreate.put("type", "9");

    engine.invoke(provider, inParamsForCreate);

    //Проверка, что после create, json файл содержит ожидаемые данные
    ObjectMapper objectMapper = new ObjectMapper();
    TypeFactory typeFactory = objectMapper.getTypeFactory();
    CollectionType collectionType = typeFactory.constructCollectionType(
            List.class, HashMap.class);
    List<Map> result = objectMapper.readValue(testFile, collectionType);

    assertThat(result.size(), is(2));
    assertThat(result.get(0).get("id"), is(9));
    assertThat(result.get(0).get("name"), is("test9"));
    assertThat(result.get(0).get("type"), is("9"));
    assertThat(result.get(1).get("id"), is(1));
    assertThat(result.get(1).get("name"), is("test1"));
    assertThat(result.get(1).get("type"), is("1"));
}
 
@Test
public void setType() {
  JavaType type = TypeFactory.defaultInstance().constructCollectionType(List.class, String.class);
  resolver.setType(type, vendorExtensions);

  Assert.assertEquals("java.util.List<java.lang.String>", vendorExtensions.get(SwaggerConst.EXT_JAVA_CLASS));
}
 
源代码29 项目: JuniperBot   文件: JacksonUtil.java
public static List mapJsonToObjectList(String json, Class clazz) {
    List list;
    TypeFactory t = TypeFactory.defaultInstance();
    try {
        list = OBJECT_MAPPER.readValue(json, t.constructCollectionType(ArrayList.class, clazz));
    } catch (IOException e) {
        throw new IllegalArgumentException("The given string value: "
                + json + " cannot be transformed to List of " + clazz.getName());
    }

    return list;
}
 
源代码30 项目: n2o-framework   文件: TestDataProviderEngineTest.java
@Test
public void testCreateOnEmptyFile() throws IOException {
    TestDataProviderEngine engine = new TestDataProviderEngine();
    engine.setResourceLoader(new DefaultResourceLoader());
    engine.setPathOnDisk(testFolder.getRoot() + "/");

    N2oTestDataProvider provider = new N2oTestDataProvider();
    provider.setFile(emptyFile.getName());

    //Добавление новых данных в пустой файл
    provider.setOperation(create);

    Map<String, Object> inParamsForCreate = new LinkedHashMap<>();
    inParamsForCreate.put("name", "test10");
    inParamsForCreate.put("type", "10");

    engine.invoke(provider, inParamsForCreate);

    //Проверка, что после create, json файл содержит ожидаемые данные
    ObjectMapper objectMapper = new ObjectMapper();
    TypeFactory typeFactory = objectMapper.getTypeFactory();
    CollectionType collectionType = typeFactory.constructCollectionType(
            List.class, HashMap.class);
    List<Map> result = objectMapper.readValue(emptyFile, collectionType);

    assertThat(result.size(), is(1));
    assertThat(result.get(0).get("id"), is(1));
    assertThat(result.get(0).get("name"), is("test10"));
    assertThat(result.get(0).get("type"), is("10"));
}
 
 同包方法