import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Test
public void personToJsonString() {
    Person duke = new Person("Duke", LocalDate.of(1995, 5, 23));
    duke.setPhoneNumbers(
            Arrays.asList(
                    new PhoneNumber(HOME, "100000"),
                    new PhoneNumber(OFFICE, "200000")
            )
    );

    Jsonb jsonMapper = JsonbBuilder.create();
    String json = jsonMapper.toJson(duke);

    LOG.log(Level.INFO, "converted json result: {0}", json);

    String name = JsonPath.parse(json).read("$.name");
    assertEquals("Duke", name);

    Configuration config = Configuration.defaultConfiguration()
            .jsonProvider(new GsonJsonProvider())
            .mappingProvider(new GsonMappingProvider());
    TypeRef<List<String>> typeRef = new TypeRef<List<String>>() {
    };

    List<String> numbers = JsonPath.using(config).parse(json).read("$.phoneNumbers[*].number", typeRef);

    assertEquals(Arrays.asList("100000", "200000"), numbers);
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
private static ConnectorTemplate fetchSwaggerConnectorTemplateFromDeployment() {
    final Configuration configuration = Configuration.builder()//
        .jsonProvider(new JacksonJsonProvider(Json.mapper()))//
        .mappingProvider(new JacksonMappingProvider(Json.mapper()))//
        .build();

    final List<ConnectorTemplate> templates = JsonPath.using(configuration)
        .parse(AbstractSwaggerConnectorTest.class.getResourceAsStream("/io/syndesis/dao/deployment.json"))
        .read("$..[?(@['id'] == 'swagger-connector-template')]", new TypeRef<List<ConnectorTemplate>>() {
            // type token pattern
        });

    return templates.get(0);
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T map(Object source, final TypeRef<T> targetType, Configuration configuration) {
    if(source == null){
        return null;
    }
    JavaType type = objectMapper.getTypeFactory().constructType(targetType.getType());

    try {
        return (T)objectMapper.convertValue(source, type);
    } catch (Exception e) {
        throw new MappingException(e);
    }

}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T map(Object source, TypeRef<T> targetType, Configuration configuration) {
    if(source == null){
        return null;
    }
    try {
        return (T) factory.call().getAdapter(TypeToken.get(targetType.getType())).fromJsonTree((JsonElement) source);
    } catch (Exception e){
        throw new MappingException(e);
    }
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T map(Object source, TypeRef<T> targetType, Configuration configuration) {
  if (targetType.getType() instanceof Class) {
    return mapper.convertValue(source, (Class<T>) targetType.getType());
  } else {
    throw new IllegalArgumentException("Cannot convert to " + targetType);
  }
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <U> List<U> select(String value, DataConverter<String, U> converter) {
	try {
		List<String> results = context.read(evaluations.get(value), new TypeRef<List<String>>() {
		});
		return results.stream().map(el -> converter.convert(el)).collect(Collectors.toList());
	} catch (ExecutionException e) {
		throw Throwables.propagate(e);
	}
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T map(final Object source, final TypeRef<T> targetType, final Configuration configuration) {
  throw new UnsupportedOperationException(
      "Tapestry JSON provider does not support TypeRef! Use a Jackson or Gson based provider");
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T map(Object source, TypeRef<T> targetType, Configuration configuration) {
    throw new UnsupportedOperationException("Json-smart provider does not support TypeRef! Use a Jackson or Gson based provider");
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T map(Object source, TypeRef<T> targetType, Configuration configuration) {
    throw new UnsupportedOperationException("JsonOrg provider does not support TypeRef! Use a Jackson or Gson based provider");
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
@Override
public <T> T read(JsonPath path, TypeRef<T> type) {
    return convert(read(path), type, configuration);
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
private <T> T convert(Object obj, TypeRef<T> targetType, Configuration configuration){
    return configuration.mappingProvider().map(obj, targetType, configuration);
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
/**
 * Extracts a JSON array using a JsonPath expression and wrap it in a {@link ListAssert}. This method requires
 * the JsonPath to be <a href="https://github.com/jayway/JsonPath#jsonprovider-spi">configured with Jackson or
 * Gson</a>.
 *
 * @param path JsonPath to extract the array
 * @param type The type to cast the content of the array, i.e.: {@link String}, {@link Integer}
 * @return an instance of {@link ListAssert}
 */
public <T> AbstractListAssert<?, ? extends List<? extends T>, T> jsonPathAsListOf(String path, Class<T> type) {
    return Assertions.assertThat(actual.read(path, new TypeRef<List<T>>() {
    }));
}
 

import com.jayway.jsonpath.TypeRef; //导入依赖的package包/类
/**
 *
 * @param source object to map
 * @param targetType the type the source object should be mapped to
 * @param configuration current configuration
 * @param <T> the mapped result type
 * @return return the mapped object
 */
<T> T map(Object source, TypeRef<T> targetType, Configuration configuration);