Jackson
1.引入maven
<!-- jackson-->
<!-- jackson-core，核心包，提供基于"流模式"解析的相关 API，它包括 JsonPaser 和 JsonGenerator。 Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。-->
<!-- jackson-annotations，注解包，提供标准注解功能；-->
<!-- jackson-databind ，数据绑定包， 提供基于"对象绑定" 解析的相关 API （ ObjectMapper ） 和"树模型" 解析的相关 API （JsonNode）；基于"对象绑定" 解析的 API 和"树模型"解析的 API 依赖基于"流模式"解析的 API。-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.1</version>
</dependency>
2.序列化
Date date = new Date();
JackBean1 j11 = new JackBean1(null, "张三", date, null, null);
JackBean1 j12 = new JackBean1(2, "李四", date, true, "ok");
JackBean2 j21 = new JackBean2(2, "李四", date, true, "ok");
//序列化
@Test
public void test02() throws IOException {
ObjectMapper mapper = new ObjectMapper();
String json1 = mapper.writeValueAsString(j11);
String json2 = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(j11);
// 美化输出
mapper.enable(SerializationFeature.INDENT_OUTPUT);
// 允许序列化空的POJO类
// （否则会抛出异常）
mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
// 把java.util.Date, Calendar输出为数字（时间戳）
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
// 在遇到未知属性的时候不抛出异常
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 强制JSON 空字符串("")转换为null对象值:
mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
// 在JSON中允许C/C++ 样式的注释(非标准，默认禁用)
mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
// 允许没有引号的字段名（非标准）
mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
// 允许单引号（非标准）
mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
// 强制转义非ASCII字符
mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true);
// 将内容包裹为一个JSON属性，属性名由@JsonRootName注解指定
mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
System.out.println(json1);
System.out.println(json2);
// 写为字符串
String text = mapper.writeValueAsString(j11);
// 写为文件
mapper.writeValue(new File("JackBean1.json"), j11);
System.out.println(text);
// 写为字节流
byte[] bytes = mapper.writeValueAsBytes(j11);
}
3.反序列化（解析）
//反序列化
@Test
public void test03() throws IOException {
ObjectMapper mapper = new ObjectMapper();
String text = mapper.writeValueAsString(j11);
mapper.writeValue(new File("JackBean1.json"), j11);
byte[] bytes = mapper.writeValueAsBytes(j11);
//解析
// 从字符串中读取
JackBean1 newFriend = mapper.readValue(text, JackBean1.class);
System.out.println(newFriend);
// 从字节流中读取
newFriend = mapper.readValue(bytes, JackBean1.class);
System.out.println(newFriend);
// 从文件中读取
newFriend = mapper.readValue(new File("JackBean1.json"), JackBean1.class);
System.out.println(newFriend);
//集合的映射解析
System.out.println("--------------集合解析------------");
Map<String, Object> map = new HashMap<String, Object>();
map.put("age", 25);
map.put("name", "yitian");
map.put("interests", new String[]{"pc games", "music"});
text = mapper.writeValueAsString(map);
System.out.println(text);
Map<String, Object> map2 = mapper.readValue(text, new TypeReference<Map<String, Object>>() {
});
System.out.println(map2);
JsonNode root = mapper.readTree(text);
String name = root.get("name").asText();
int age = root.get("age").asInt();
System.out.println("name:" + name + " age:" + age);
}
4.注解
// @JsonProperty 用于属性，把属性的名称序列化时转换为另外一个名称。示例：
// @JsonProperty("birth_ d ate")
// private Date birthDate;
// @JsonFormat 用于属性或者方法，把属性的格式序列化时转换成指定的格式。示例：
// @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm")
// public Date getBirthDate()
// @JsonPropertyOrder 用于类， 指定属性在序列化时 json 中的顺序 ， 示例：
// @JsonPropertyOrder({ "birth_Date", "name" })
// public class Person
// @JsonCreator 用于构造方法，和 @JsonProperty 配合使用，适用有参数的构造方法。 示例：
// @JsonCreator
// public Person(@JsonProperty("name")String name) {…}
// @JsonAnySetter 用于属性或者方法，设置未反序列化的属性名和值作为键值存储到 map 中
// @JsonAnySetter
// public void set(String key, Object value) {
// map.put(key, value);
// }
// @JsonAnyGetter 用于方法 ，获取所有未序列化的属性
// public Map<String, Object> any() { return map; }
@Builder
@Data
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
@JsonRootName("jackBean2")
@JsonIgnoreProperties({"bak"})
@JsonPropertyOrder({ "id", "name","birth" })
public class JackBean2 implements Serializable {
private static final long serialVersionUID = 4075203235870637427L;
@JsonProperty("ID")
private Integer id;
@JsonProperty("Name")
private String name;
@JsonProperty("Birthday")
@JsonFormat(pattern = "yyyy-MM-DD")
private Date birth;
@JsonIgnore
private Boolean deleted;
private String bak;
5.案例
springMVC 配置jackson
<!--start:使用Jackson 1.x的配置，需要导入的jar包：jackson-core-lpgl-xxx.jar、jackson-mapper-lgpl-xxx.jar -->
<bean class ="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" >
<property name="messageConverters">
<list>
<!-- 设置返回字符串编码,避免使用@ResponseBody后返回乱码 -->
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name = "supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
</list>
</property>
</bean>
<!-- json转换器 -->
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" >
<property name="supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
</list>
</property>
</bean>
</list>
</property>
</bean>
<!--end:使用Jackson 1.x的配置，需要导入的jar包：jackson-core-lpgl-xxx.jar、jackson-mapper-lgpl-xxx.jar -->
<!--start:使用Jackson 2.x的配置，需要导入的jar包：jackson-core-xxx.jar、jackson-annotations-xxx.jar、jackson-databind-xxx.jar-->
<!--通过处理器映射DefaultAnnotationHandlerMapping来开启支持@Controller注解-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />
<!--通过处理器适配器AnnotationMethodHandlerAdapter来开启支持@RequestMapping注解-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<!-- 设置返回字符串编码 -->
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name = "supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
<value>application/json;charset=UTF-8</value>
</list>
</property>
</bean>
<!-- json转换器 -->
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
<value>application/json;charset=UTF-8</value>
</list>
</property>
</bean>
</list>
</property>
</bean>
<!--end:使用Jackson 2.x的配置，需要导入的jar包：jackson-core-xxx.jar、jackson-annotations-xxx.jar、jackson-databind-xxx.jar-->
springboot 配置jackson
spring.jackson.date-format指定日期格式，比如yyyy-MM-dd HH:mm:ss，或者具体的格式化类的全限定名
spring.jackson.deserialization是否开启Jackson的反序列化
spring.jackson.generator是否开启json的generators.
spring.jackson.joda-date-time-format指定Joda date/time的格式，比如yyyy-MM-ddHH:mm:ss). 如果没有配置的话，dateformat会作为backup
spring.jackson.locale指定json使用的Locale.
spring.jackson.mapper是否开启Jackson通用的特性.
spring.jackson.parser是否开启jackson的parser特性.
spring.jackson.property-naming-strategy指定PropertyNamingStrategy(CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES)或者指定PropertyNamingStrategy子类的全限定类名.
spring.jackson.serialization是否开启jackson的序列化.
spring.jackson.serialization-inclusion指定序列化时属性的inclusion方式，具体查看JsonInclude.Include枚举.
spring.jackson.time-zone指定日期格式化时区，比如America/Los_Angeles或者GMT+10.
FastJson
1.引入maven
<!-- fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.68</version>
</dependency>
2.序列化
Date date = new Date();
FastBean1 f11 = new FastBean1(null, "张三", date, null, null);
FastBean1 f12 = new FastBean1(2, "李四", date, true, "ok");
FastBean2 f21 = new FastBean2(2, "李四", date, true, "ok");
FastBean3 f31 = new FastBean3(1, "李四", date, true, "ok");
// **2.序列化**
@Test
public void test21() {
// java对象
Map<String, String> map = new HashMap<String, String>();
map.put("不加默认值", JSON.toJSONString(f11));
map.put("字符空值转null", JSON.toJSONString(f11, SerializerFeature.WriteMapNullValue));
map.put("字符空值转''", JSON.toJSONString(f11, SerializerFeature.WriteNullStringAsEmpty));
map.put("数值空值转0", JSON.toJSONString(f11, SerializerFeature.WriteNullNumberAsZero));
map.put("布尔空值false", JSON.toJSONString(f11, SerializerFeature.WriteNullBooleanAsFalse));
map.put("时间类型格式化", JSON.toJSONString(f11, SerializerFeature.WriteDateUseDateFormat));
map.put("格式化输出", JSON.toJSONString(f11, SerializerFeature.WriteMapNullValue, SerializerFeature.PrettyFormat));
for (String key : map.keySet()) {
System.out.println(key + " \t:: \t" + map.get(key));
}
}
@Test
public void test22() {
// list集合
List<FastBean1> list = new ArrayList<FastBean1>();
list.add(f11);
list.add(f12);
System.out.println(JSON.toJSONString(list));
}
@Test
public void test23() {
// map
Map<String, FastBean1> map = new HashMap<String, FastBean1>();
map.put("f11", f11);
map.put("f12", f12);
System.out.println(JSON.toJSONString(map));
}
3.反序列化（解析）
// **3.反序列化（解析）**
@Test
public void test31() {
// java对象
String jsonString = JSON.toJSONString(f11);
System.out.println("json字符: \t" + jsonString);
FastBean1 fastBean1 = JSON.parseObject(jsonString, FastBean1.class);
System.out.println("java对象: \t" + fastBean1);
}
@Test
public void test32() {
// list集合
List<FastBean1> list = new ArrayList<FastBean1>();
list.add(f11);
list.add(f12);
String jsonString = JSON.toJSONString(list);
List<FastBean1> list1 = JSON.parseArray(jsonString, FastBean1.class);
for (FastBean1 fastBean1 : list1) {
System.out.println(fastBean1);
}
}
@Test
public void test33() {
// map
Map<String, FastBean1> map = new HashMap<String, FastBean1>();
map.put("f11", f11);
map.put("f12", f12);
String jsonString = JSON.toJSONString(map);
Map<String, FastBean1> map1 = JSON.parseObject(jsonString, new TypeReference<Map<String, FastBean1>>() {
});
for (String key : map1.keySet()) {
System.out.println(key + " \t:" + map1.get(key));
}
}
4.注解
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class FastBean2 implements Serializable {
private static final long serialVersionUID = 4075203235870637427L;
// JSONField可作用方法，参数，成员变量上
// name 指定名称
// ordinal 指定顺序
// format 指定格式
// serialize 指定是否序列化
// deserialize 指定是否反序列化
// serialzeFeatures 枚举类指定序列化格式
//指定输出字段名，和序列化 serialize/deserialize，ordinal顺序,format格式
@JSONField(name = "ID", ordinal = 1)
private int id;
@JSONField(name = "USERNAME", ordinal = 2)
private String name;
@JSONField(name = "BIRTH", format = "yyyy/MM/dd HH:mm:ss", ordinal = 4)
private Date birth;
@JSONField(name = "deleted", ordinal = 3)
private Boolean deleted;
@JSONField(serialize = false)
private String bak;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@JSONType(includes = {"id", "name", "birth", "deleted"}, orders = {"id", "name", "deleted", "birth", "bak"}, ignores = {"name"})
public class FastBean3 implements Serializable {
// JSONType作用在类上
// includes 需要序列化的字段
// orders 指定序列化顺序
// ignores 忽略字段(在includes未配置的时候生效)
// serialzeFeatures 枚举类指定序列化格式
private static final long serialVersionUID = 4075203235870637427L;
private int id;
private String name;
private Date birth;
@JSONField(serialize = true) //JSONField和JSONType指定序列化有。优先执行JSONTyp,在之前的基础上再执行JSONField
private Boolean deleted;
private String bak;
}
5.案例
1.springMVC 用 fastjson
<!-- 开启mvc注解并设置编码格式，并且设置Fastjson支持 -->
<mvc:annotation-driven>
<mvc:message-converters register-defaults="true">
<!-- @ResponseBody乱码问题，将StringHttpMessageConverter的默认编码设为UTF-8 -->
<bean id="stringHttpMessageConverter" class="org.springframework.http.converter.StringHttpMessageConverter">
<constructor-arg value="UTF-8" index="0"/>
</bean>
<!-- 配置Fastjson支持 -->
<bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
<property name="charset" value="UTF-8" />
<property name="supportedMediaTypes">
<list>
<value>application/json</value>
<value>text/html;charset=UTF-8</value>
</list>
</property>
<property name="features">
<list>
<value>QuoteFieldNames</value>
<value>WriteMapNullValue</value>
<value>WriteDateUseDateFormat</value>
<value>WriteEnumUsingToString</value>
<value>DisableCircularReferenceDetect</value>
</list>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
<!--
Fastjson的SerializerFeature序列化属性：
QuoteFieldNames 输出key时是否使用双引号,默认为true
WriteMapNullValue 是否输出值为null的字段,默认为false
WriteNullNumberAsZero 数值字段如果为null,输出为0,而非null
WriteNullListAsEmpty List字段如果为null,输出为[],而非null
WriteNullStringAsEmpty 字符类型字段如果为null,输出为”“,而非null
WriteNullBooleanAsFalse Boolean字段如果为null,输出为false,而非null
WriteDateUseDateFormat Date的日期转换器
DisableCircularReferenceDetect 解决FastJson循环引用的问题避免出现{"$ref":"$.rows[0].user"}
-->
2.springBoot 用 fastjson
方式一：在启动类中配置
@SpringBootApplication
@EnableDiscoveryClient
@EnableScheduling
public class App extends WebMvcConfigurerAdapter {
/**
* 配置FastJson为方式一
* @return*/
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
super.configureMessageConverters(converters);
/*
* 1、需要先定义一个convert转换消息的对象 2、添加fastJson的配置信息，比如：是否要格式化返回json数据 3、在convert中添加配置信息
* 4、将convert添加到converters当中
*
*/
// 1、需要先定义一个·convert转换消息的对象；
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
// 2、添加fastjson的配置信息，比如 是否要格式化返回json数据
FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
// 3、在convert中添加配置信息.
fastConverter.setFastJsonConfig(fastJsonConfig);
// 4、将convert添加到converters当中.
converters.add(fastConverter);
}
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}
方式二：通过@Bean方式注入
/**
* fastJson替换JackJson
*/
@Configuration
public class HttpConverterConfig {
@Bean
public HttpMessageConverters fastJsonHttpMessageConverters() {
// 1.定义一个converters转换消息的对象
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
// 2.添加fastjson的配置信息，比如: 是否需要格式化返回的json数据
FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
// 3.在converter中添加配置信息
fastConverter.setFastJsonConfig(fastJsonConfig);
//处理中文乱码问题
List<MediaType> oFastMediaTypeList = new ArrayList<>();
oFastMediaTypeList.add(MediaType.APPLICATION_JSON_UTF8);
fastConverter.setSupportedMediaTypes(oFastMediaTypeList);
// 4.将converter赋值给HttpMessageConverter
HttpMessageConverter<?> converter = fastConverter;
// 5.返回HttpMessageConverters对象
return new HttpMessageConverters(converter);
}
}
976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
