Java中的JSON序列化和反序列化开发者社区

Java中的JSON序列化和反序列化

{
  "Image": {
    "Width": 800,
    "Height": 600,
    "Title": "View from 15th Floor",
    "Thumbnail": {
      "Url": "https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png",
      "Height": 125,
      "Width": "100"
    "IDs": [116, 943, 234, 38793]
}

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>x.x.x</version>
</dependency>

public class Group {
    private Long       id;
    private String     name;
    private List<User> users = new ArrayList<User>();
}

public class User {
    private Long   id;
    private String name;
}

Group group = new Group();
group.setId(0L);
group.setName("admin");
User guestUser = new User();
guestUser.setId(2L);
guestUser.setName("guest");
User rootUser = new User();
rootUser.setId(3L);
rootUser.setName("root");
group.addUser(guestUser);
group.addUser(rootUser);

String jsonString = JSON.toJSONString(group);
System.out.println(jsonString);

Group bean = JSON.parseObject(jsonString, Group.class);

@JSONField(name="ID")
public int getId() {return id;}
// 配置date序列化和反序列使用yyyyMMdd日期格式
@JSONField(format="yyyyMMdd")
public Date date1;
// 不序列化
@JSONField(serialize=false)
public Date date2;
// 不反序列化
@JSONField(deserialize=false)
public Date date3;
// 按ordinal排序
@JSONField(ordinal = 2)
private int f1;
@JSONField(ordinal = 1)
private int f2;

@JSONType(alphabetic = false)
public static class B {
    public int f2;
    public int f1;
    public int f0;
}

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(new File("result.json"), myResultObject);
// or:
byte[] jsonBytes = mapper.writeValueAsBytes(myResultObject);
// or:
String jsonString = mapper.writeValueAsString(myResultObject);

ObjectMapper mapper = new ObjectMapper();
MyValue value = mapper.readValue(new File("data.json"), MyValue.class);
// or:
value = mapper.readValue(new URL("http://some.com/api/entry.json"), MyValue.class);
// or:
value = mapper.readValue("{\"name\":\"Bob\", \"age\":13}", MyValue.class);

Person p = new Person("Tom", 20);
Person p2 = new Person("Jack", 22);
Person p3 = new Person("Mary", 18);
List<Person> persons = new LinkedList<>();
persons.add(p);
persons.add(p2);
persons.add(p3);
Map<String, List> map = new HashMap<>();
map.put("persons", persons);
String json = null;
try {
 json = mapper.writeValueAsString(map);
} catch (JsonProcessingException e) {
 e.printStackTrace();
}

public class MyBean {
   private String _name;
   // without annotation, we'd get "theName", but we want "name":
   @JsonProperty("name")
   public String getTheName() { return _name; }
   // note: it is enough to add annotation on just getter OR setter;
   // so we can omit it here
   public void setTheName(String n) { _name = n; }
}

// means that if we see "foo" or "bar" in JSON, they will be quietly skipped
// regardless of whether POJO has such properties
@JsonIgnoreProperties({ "foo", "bar" })
public class MyBean {
   // will not be written as JSON; nor assigned from JSON:
   @JsonIgnore
   public String internal;
   // no annotation, public field is read/written normally
   public String external;
   @JsonIgnore
   public void setCode(int c) { _code = c; }
   // note: will also be ignored because setter has annotation!
   public int getCode() { return _code; }
}

public class CtorBean {
  public final String name;
  public final int age;
  @JsonCreator // constructor can be public, private, whatever
  private CtorBean(@JsonProperty("name") String name,
    @JsonProperty("age") int age)
      this.name = name;
      this.age = age;
}

@JsonPropertyOrder(alphabetic = true)
public class JacksonAnnotationBean {}

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

Gson gson = new Gson();
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(10L); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]

int i1 = gson.fromJson("1", int.class);
Integer i2 = gson.fromJson("1", Integer.class);
Long l1 = gson.fromJson("1", Long.class);
Boolean b1 = gson.fromJson("false", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);

Gson gson = new GsonBuilder()
  .setPrettyPrinting()
  .setDateFormat("yyyy-MM-dd HH:mm:ss")
  .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT, Modifier.VOLATILE)
  .create();

public class VersionedClass {
  @Since(1.1) private final String newerField;
  @Since(1.0) private final String newField;
  private final String field;
  public VersionedClass() {
    this.newerField = "newer";
    this.newField = "new";
    this.field = "old";
VersionedClass versionedObject = new VersionedClass();
Gson gson = new GsonBuilder().setVersion(1.0).create();
String jsonOutput = gson.toJson(versionedObject);
System.out.println(jsonOutput);
System.out.println();
gson = new Gson();
jsonOutput = gson.toJson(versionedObject);
System.out.println(jsonOutput);

private class SomeObject {
  @SerializedName("custom_naming") private final String someField;
  private final String someOtherField;

Java中的JSON序列化和反序列化

Java中的JSON序列化和反序列化

文章目录

Java 和 JSON 序列化

JSON 简介

JSON 是什么

JSON 标准

JSON 优缺点

JSON 工具

Java JSON 库

JSON 编码指南

Fastjson 应用

添加 maven 依赖

Fastjson API

定义 Bean

序列化

反序列化

Fastjson 注解

@JSONField

@JSONType

Jackson 应用

添加 maven 依赖

Jackson API

序列化

反序列化

容器的序列化和反序列化

Jackson 注解

@JsonProperty

@JsonIgnoreProperties 和 @JsonIgnore

@JsonCreator

@JsonPropertyOrder

Gson 应用

添加 maven 依赖

Gson API

序列化

反序列化

GsonBuilder

Gson 注解

@Since

@SerializedName