下面列出了com.fasterxml.jackson.databind.ObjectMapper#registerModule ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Create an instance of the API for authenticated access
* @param username an OpenSky username
* @param password an OpenSky password for the given username
*/
public OpenSkyApi(String username, String password) {
lastRequestTime = new HashMap<>();
// set up JSON mapper
mapper = new ObjectMapper();
SimpleModule sm = new SimpleModule();
sm.addDeserializer(OpenSkyStates.class, new OpenSkyStatesDeserializer());
mapper.registerModule(sm);
authenticated = username != null && password != null;
if (authenticated) {
okHttpClient = new OkHttpClient.Builder()
.addInterceptor(new BasicAuthInterceptor(username, password))
.build();
} else {
okHttpClient = new OkHttpClient();
}
}
private ObjectMapper getObjectMapper() {
objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false);
// objectMapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS,
// true);
objectMapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, true);
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
objectMapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true);
objectMapper.enableDefaultTypingAsProperty(DefaultTyping.JAVA_LANG_OBJECT, "_typeName");
TypeResolverBuilder<?> joynrTypeResolverBuilder = objectMapper.getSerializationConfig()
.getDefaultTyper(SimpleType.construct(Object.class));
SimpleModule module = new SimpleModule("NonTypedModule", new Version(1, 0, 0, "", "", ""));
module.addSerializer(new JoynrEnumSerializer());
module.addSerializer(new JoynrListSerializer());
TypeDeserializer typeDeserializer = joynrTypeResolverBuilder.buildTypeDeserializer(objectMapper.getDeserializationConfig(),
SimpleType.construct(Object.class),
null);
module.addDeserializer(Object.class, new JoynrUntypedObjectDeserializer(typeDeserializer));
objectMapper.registerModule(module);
return objectMapper;
}
public SwaggerReader(Swagger swagger, ObjectMapper mapper, BiConsumer<Method, Operation> swaggerOperationConsumer, Map<Class, PrimitiveType> externalTypes)
{
this.swagger = swagger;
modelConverters = new ModelConverters(mapper);
this.swaggerOperationConsumer = swaggerOperationConsumer;
modelConverters.addConverter(new ModelResolver(mapper));
if (externalTypes != null) {
setExternalTypes(externalTypes);
}
mapper.registerModule(
new SimpleModule("swagger", Version.unknownVersion()) {
@Override
public void setupModule(SetupContext context) {
context.insertAnnotationIntrospector(new SwaggerJacksonAnnotationIntrospector());
}
});
errorProperty = modelConverters.readAsProperty(HttpServer.ErrorMessage.class);
swagger.addDefinition("ErrorMessage", modelConverters.read(HttpServer.ErrorMessage.class).entrySet().iterator().next().getValue());
}
private ObjectMapper createObjectMapper() {
final ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
objectMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);
objectMapper.configure(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS, true);
objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
objectMapper.registerModule(new Jdk8Module());
objectMapper.registerModule(new JavaTimeModule());
return objectMapper;
}
public KafkaConsumerOffsetFetcher(ZKConfig config, String... parameters) {
try {
this.curator = CuratorFrameworkFactory.newClient(config.zkQuorum, config.zkSessionTimeoutMs, 15000,
new RetryNTimes(config.zkRetryTimes, config.zkRetryInterval));
curator.start();
this.zkRoot = config.zkRoot;
mapper = new ObjectMapper();
Module module = new SimpleModule("offset").registerSubtypes(new NamedType(KafkaConsumerOffset.class));
mapper.registerModule(module);
zkPathToPartition = String.format(config.zkRoot, parameters);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Generic helper method that takes a string and a mapping function
*
* @param <E> The desired output type
* @param parseText The input data to be parsed
* @param fn A {@code Function} object to take a string bag and produce an instance of {@code E}
* @return An instance of {@code E}
*/
public static <E> E parse(final String parseText, final Function<Map<String, ?>, E> fn) {
final ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new Jdk8Module());
try {
return fn.apply(mapper.readValue(parseText, new TypeReference<Map<String, ?>>() {
}));
} catch (IOException iox) {
throw new RuntimeException(iox);
}
}
public Module getObjectMapperModule() {
return (binder) -> {
final ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new GuavaModule());
objectMapper.registerModule(new Jdk8Module());
binder.bind(ObjectMapper.class).toInstance(objectMapper);
};
}
@Test
void testSerialize() throws Exception {
BlockHeader header = BlockHeaderTest.generateBlockHeader();
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new EthJsonModule());
mapper.writer().writeValueAsString(header);
}
@Test
public void testFromJsonWithLog4jModule() throws Exception {
final ObjectMapper mapper = new ObjectMapper();
final boolean encodeThreadContextAsList = false;
final SimpleModule module = new Log4jJsonModule(encodeThreadContextAsList, true, false, false);
module.addDeserializer(StackTraceElement.class, new Log4jStackTraceElementDeserializer());
mapper.registerModule(module);
final StackTraceElement expected = new StackTraceElement("package.SomeClass", "someMethod", "SomeClass.java", 123);
final String s = this.aposToQuotes("{'class':'package.SomeClass','method':'someMethod','file':'SomeClass.java','line':123}");
final StackTraceElement actual = mapper.readValue(s, StackTraceElement.class);
Assert.assertEquals(expected, actual);
}
@ApiOperation(value = "最近一次停车记录")
@GetMapping(value = "/last_car_fee", produces = "application/json; charset=utf-8")
public ResponseEntity<?> car_fee_list() throws Exception {
OAuth2Authentication auth = (OAuth2Authentication) SecurityContextHolder.getContext().getAuthentication();
Long currentUserId = ((SecurityUser) auth.getPrincipal()).getId();
List<Car> carList = carService.selectAll(
new QueryParameter[]{new QueryParameter("userId", QueryParameterMethod.EQUAL, currentUserId.toString(), QueryParameterType.LONG)});
String cars = EMPTY_STRING;
for (int i = 0; i < carList.size(); i++) {
cars += carList.get(i).getCarNumber();
if (i != carList.size() - 1)
cars += ",";
}
QueryParameter[] parameters = new QueryParameter[]{
new QueryParameter("carNumber", QueryParameterMethod.IN, cars, QueryParameterType.ARRAY),
new QueryParameter("userId", QueryParameterMethod.IS_NULL, EMPTY_STRING, QueryParameterType.STRING)};
List<CarFee> carFeeList = carFeeService.selectTop(1, parameters);
if (carFeeList.size() != 1) {
parameters = new QueryParameter[]{
new QueryParameter("userId", QueryParameterMethod.EQUAL, currentUserId.toString(), QueryParameterType.LONG)
};
carFeeList = carFeeService.selectTop(1, parameters);
}
if (carFeeList.size() == 1) {
Park park = parkService.selectByID(carFeeList.get(0).getParkId()).get();
ObjectMapper mapper = new ObjectMapper();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
SimpleModule module = new SimpleModule();
module.addSerializer(String.class, new StringUnicodeSerializer());
mapper.registerModule(module);
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
return ResponseEntity.status(HttpStatus.OK).header("park", mapper.writeValueAsString(park)).body(carFeeList.get(0));
} else {
return ResponseEntity.ok().build();
}
}
private static ObjectMapper configureObjectMapper(
ObjectMapper objectMapper, boolean shouldIncludeRawResponses) {
if (shouldIncludeRawResponses) {
SimpleModule module = new SimpleModule();
module.setDeserializerModifier(
new BeanDeserializerModifier() {
@Override
public JsonDeserializer<?> modifyDeserializer(
DeserializationConfig config,
BeanDescription beanDesc,
JsonDeserializer<?> deserializer) {
if (Response.class.isAssignableFrom(beanDesc.getBeanClass())) {
return new RawResponseDeserializer(deserializer);
}
return deserializer;
}
});
objectMapper.registerModule(module);
}
objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
return objectMapper;
}
public static ObjectMapper getObjectMapper(TimeZone timezone, String dateFormatPattern) {
ObjectMapper mapper = new ObjectMapper();
mapper.setTimeZone(timezone);
mapper.setDateFormat(DateUtilities.getFormat(dateFormatPattern, timezone));
mapper.registerModule(new LocalDateTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
return mapper;
}
private JacksonJsonProvider createMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
mapper.setSerializationInclusion(NON_NULL);
mapper.registerModule(new Jdk8Module());
mapper.registerModule(new JavaTimeModule());
return new JacksonJaxbJsonProvider(mapper, DEFAULT_ANNOTATIONS);
}
static Foo read(InputStream stream) throws IOException {
ObjectMapper mapper = JsonUtil.createObjectMapper();
SimpleModule module = new SimpleModule();
module.addDeserializer(Foo.class, new FooDeserializer());
mapper.registerModule(module);
return mapper.readValue(stream, Foo.class);
}
private static ObjectMapper createMapper() {
ObjectMapper mapper = CardshifterIO.mapper();
SimpleModule module = new SimpleModule("ECSModule", new Version(0, 1, 0, "alpha", "com.cardshifter", "cardshifter"));
module.addSerializer(Entity.class, new EntitySerializer());
mapper.registerModule(module);
mapper.enable(SerializationFeature.INDENT_OUTPUT);
return mapper;
}
/**
* json 类型参数 序列化问题
* Long -> string
* date -> string
*
* @param builder
* @return
*/
@Bean
@Primary
@ConditionalOnMissingBean
public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
ObjectMapper objectMapper = builder.createXmlMapper(false)
.featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
.timeZone(TimeZone.getTimeZone("Asia/Shanghai"))
.build();
//忽略未知字段
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//日期格式
SimpleDateFormat outputFormat = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
objectMapper.setDateFormat(outputFormat);
SimpleModule simpleModule = new SimpleModule();
/**
* 将Long,BigInteger序列化的时候,转化为String
*/
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
simpleModule.addSerializer(BigInteger.class, ToStringSerializer.instance);
simpleModule.addSerializer(BigDecimal.class, ToStringSerializer.instance);
objectMapper.registerModule(simpleModule);
return objectMapper;
}
@Test
public void testFromJsonWithSimpleModule() throws Exception {
final ObjectMapper mapper = new ObjectMapper();
final SimpleModule module = new SimpleModule();
module.addDeserializer(StackTraceElement.class, new Log4jStackTraceElementDeserializer());
mapper.registerModule(module);
final StackTraceElement expected = new StackTraceElement("package.SomeClass", "someMethod", "SomeClass.java",
123);
final String s = this
.aposToQuotes("{'class':'package.SomeClass','method':'someMethod','file':'SomeClass.java','line':123}");
final StackTraceElement actual = mapper.readValue(s, StackTraceElement.class);
Assert.assertEquals(expected, actual);
}
@Produces
@GazpachoResource
@RequestScoped
public QuestionnaireResource createQuestionnairResource(HttpServletRequest request) {
RespondentAccount principal = (RespondentAccount) request.getUserPrincipal();
String apiKey = principal.getApiKey();
String secret = principal.getSecret();
logger.info("Getting QuestionnaireResource using api key {}/{} ", apiKey, secret);
JacksonJsonProvider jacksonProvider = new JacksonJsonProvider();
ObjectMapper mapper = new ObjectMapper();
// mapper.findAndRegisterModules();
mapper.registerModule(new JSR310Module());
mapper.setSerializationInclusion(Include.NON_EMPTY);
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
jacksonProvider.setMapper(mapper);
QuestionnaireResource resource = JAXRSClientFactory.create(BASE_URI, QuestionnaireResource.class,
Collections.singletonList(jacksonProvider), null);
// proxies
// WebClient.client(resource).header("Authorization", "GZQ " + apiKey);
Client client = WebClient.client(resource);
ClientConfiguration config = WebClient.getConfig(client);
config.getOutInterceptors().add(new HmacAuthInterceptor(apiKey, secret));
return resource;
}
@Test
public void testPolymorphicJacksonSerializationAndDeserialization()
{
ObjectMapper mapper = new ObjectMapper();
SimpleModule testModule = new SimpleModule("testModule", new Version(1, 0, 0, null, null, null))
.addDeserializer( QueryFilter.class, new QueryFilterDeserializer() )
.addSerializer( LogicalFilter2.class, new LogicalFilter2Serializer() );
mapper.registerModule(testModule);
// Verifying that we can pass in a custom Mapper and create a new JsonUtil
JsonUtil jsonUtil = JsonUtils.customJsonUtil( mapper );
String testFixture = "/jsonUtils/testdomain/two/queryFilter-realAndLogical2.json";
// TEST JsonUtil and our deserialization logic
QueryFilter queryFilter = jsonUtil.classpathToType( testFixture, new TypeReference<QueryFilter>() {} );
// Make sure the hydrated QFilter looks right
Assert.assertTrue( queryFilter instanceof LogicalFilter2 );
Assert.assertEquals( QueryParam.AND, queryFilter.getQueryParam() );
Assert.assertTrue( queryFilter.isLogical() );
Assert.assertEquals( 3, queryFilter.getFilters().size() );
Assert.assertNotNull( queryFilter.getFilters().get( QueryParam.OR ) );
// Make sure one of the top level RealFilters looks right
QueryFilter productIdFilter = queryFilter.getFilters().get( QueryParam.PRODUCTID );
Assert.assertTrue( productIdFilter.isReal() );
Assert.assertEquals( QueryParam.PRODUCTID, productIdFilter.getQueryParam() );
Assert.assertEquals( "Acme-1234", productIdFilter.getValue() );
// Make sure the nested OR looks right
QueryFilter orFilter = queryFilter.getFilters().get( QueryParam.OR );
Assert.assertTrue( orFilter.isLogical() );
Assert.assertEquals( QueryParam.OR, orFilter.getQueryParam() );
Assert.assertEquals( 2, orFilter.getFilters().size() );
// Make sure nested AND looks right
QueryFilter nestedAndFilter = orFilter.getFilters().get( QueryParam.AND );
Assert.assertTrue( nestedAndFilter.isLogical() );
Assert.assertEquals( QueryParam.AND, nestedAndFilter.getQueryParam() );
Assert.assertEquals( 2, nestedAndFilter.getFilters().size() );
// SERIALIZE TO STRING to test serialization logic
String unitTestString = jsonUtil.toJsonString( queryFilter );
// LOAD and Diffy the plain vanilla JSON versions of the documents
Map<String, Object> actual = JsonUtils.jsonToMap( unitTestString );
Map<String, Object> expected = JsonUtils.classpathToMap( testFixture );
// Diffy the vanilla versions
Diffy.Result result = diffy.diff( expected, actual );
if (!result.isEmpty()) {
Assert.fail( "Failed.\nhere is a diff:\nexpected: " + JsonUtils.toJsonString( result.expected ) + "\n actual: " + JsonUtils.toJsonString( result.actual ) );
}
}
private static ObjectMapper expectedObjectMapper() {
final ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new Jdk8Module());
return mapper;
}