FastJson Jackson Gson使用教程

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/jiangxishidayuan/article/details/52366837

1. Gson

Gson是非常强大的API，它支持Java泛型，支持现成的JSON与Java对象的转换，只要对象的成员名称与JSON中的一致即可。如果针对Java bean和JSON要使用不同的名称，那么可以使用@SerializedName注解来映射JSON和Java类中的变量。
Gson是主类，它暴露出fromJson()和toJson()方法进行转换工作，对于默认实现，可以直接创建对象，也可以使用GsonBuilder类提供的实用选项进行转换，比如整齐打印，字段命名转换，排除字段，日期格式化等等

public static void objectToJson() {

   Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
   //构造Builder设置参数
   // Gson gson = new GsonBuilder().setPrettyPrinting().create();
   Gson gson = new Gson(); //默认参数

   //toJson Object-->Json
   String jsonString = gson.toJson(p);

   System.out.println("---------单一对象生成--------");
   System.out.println(jsonString);

   //Json --> Object  单个对象
   Person person = gson.fromJson(jsonString, Person.class);

   System.out.println("---------单一对象解析--------");
   System.out.println(person.toString());

}

public static void objectsToJson() {
   Gson gson = new Gson();
   Person person = new Person("zhaokaiqiang", 22,
           new Birthday(1992, 1, 19));
   ArrayList<Person> arrayList = new ArrayList<>();
   arrayList.add(person);
   arrayList.add(person);
   arrayList.add(person);

   String jsonString = gson.toJson(arrayList);

   System.out.println("---------集合对象生成--------");
   System.out.println(jsonString);

   //集合的类型
   Type type = new TypeToken<ArrayList<Person>>() {
   }.getType();

   //集合对象类型
   ArrayList<Person> persons = gson.fromJson(jsonString, type);

   System.out.println("---------集合对象解析--------");
   System.out.println(persons.toString());
}

//符合对象key--value
public static String getJsonString() {
   Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
   JsonElement element = new JsonParser().parse(new Gson().toJson(p));

   JsonObject jsonObject = new JsonObject();
   jsonObject.addProperty("name", "zhao");
   jsonObject.addProperty("age", 22);
   jsonObject.add("person", element);
   System.out.println(jsonObject.toString());

   return jsonObject.toString();
}

public static void fromJsonString() {
   Gson gson = new Gson();
   JsonElement jsonElement = new JsonParser().parse(getJsonString());
   //JsonObject对象
   JsonObject jsonObject = jsonElement.getAsJsonObject();
   //key-->value 键值对元素
   JsonElement personElement = jsonObject.get("person");
   Person person = gson.fromJson(personElement, Person.class);

   JsonElement nameElement = jsonObject.get("name");
   String name = nameElement.getAsString();

   JsonElement ageElement = jsonObject.get("age");
   int age = ageElement.getAsInt();

   System.out.println(person);
   System.out.println(name);
   System.out.println(age);
}

类型介绍：
1. Gson：这个类在前面已经用过了，是我们完成Json转换和解析的主要类，主要使用toJson()和fromJson()这两个方法。
2. JsonObject：这个是我们构建Object形式的Json数据的主要类，我们可以设置key和value。
3. JsonElement：这个是Json元素类，它里面可以是一个JsonObject、JsonArray、JsonNull或者是一个JsonPrimitive。注意，它里面的数据只能看作是一个元素。
4. JsonArray：这个是我们想构造Array形式的主要类，我们可以往数组里面添加数据，数据是有序的。
5. JsonParser：这个是Json的解析器，主要作用是把一个Json形式的字符串转换成一个JsonElement对象。
PS：

1）对泛型的支持

//不再重复定义Result类
Type userType = new TypeToken<Result<User>>(){}.getType();
Result<User> userResult = gson.fromJson(json,userType);
User user = userResult.data;

Type userListType = new TypeToken<Result<List<User>>>(){}.getType();
Result<List<User>> userListResult = gson.fromJson(json,userListType);
List<User> users = userListResult.data;

2. Jackson

Jackson分为三个库
1. Core库：streaming parser/generator，即流式的解析器和生成器。
2. Annotations库：databinding annotations，即带注解的数据绑定包。
3. Databind库：ObjectMapper, Json Tree Model，即对象映射器，JSON树模型。

我们先介绍一下常用的几个类的功能：
1. JsonFactory：这个类是Jackson项目主要的工厂方法，主要用于配置和构建解析器(比如 JsonParser)和生成器(比如 JsonGenerator)，这个工厂实例是线程安全的，如果有配置的话，可以重复使用。
2. JsonGenerator：这个类主要是用来生成Json格式的内容的，我们可以使用JsonFactory的方法生成一个实例。
3. JsonParser：这个主要是用来读取Json格式的内容，并且完成解析操作的，我们可以使用JsonFactory的方法生成一个实例。
4. ObjectMapper：这个类提供了Java对象和Json之间的转化，主要通过JsonParser和JsonGenerator实例来完成实际的对Json数据的读写操作。这个类是ObjectCodec的子类，主要的实现细节都在ObjectCodec里面。而且这个类可以重复使用，所以一般会创建这个类的一个单例模式。

//单例模式获取ObjectMapper对象
public class JacksonMapper {

    private static final ObjectMapper mapper = new ObjectMapper();

    private JacksonMapper() {
    }

    public static ObjectMapper getInstance() {
        return mapper;
    }

}

//获取对象对应的Json字符串
public static String getJsonString(Object object) throws JsonProcessingException {
    return JacksonMapper.getInstance().writeValueAsString(object);
}

//获取对象对应的Json字符串
public static String getJsonString1(Object object) throws IOException {
    ObjectMapper mapper = JacksonMapper.getInstance();
    StringWriter sw = new StringWriter(); //StringWriter流对象
    JsonGenerator gen = new JsonFactory().createGenerator(sw);
    mapper.writeValue(gen, object); //把对象写到StringWriter里去
    gen.flush();
    gen.close();
    return sw.toString();
}

//Object --> Json
public static void objectToJson() throws Exception {
    Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
    System.out.println(getJsonString(p));
}


//集合List --> Json
public static void objectsToJson() throws Exception {
    Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));

    ArrayList<Person> persons = new ArrayList<Person>();
    persons.add(p);
    persons.add(p);
    persons.add(p);

    System.out.println(getJsonString(persons));
}

//复杂对象-->Json
public static String createObjectJson() throws Exception {

    Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));

    StringWriter stringWriter = new StringWriter();

    // 必须通过这种方式获取
    JsonGenerator jsonGenerator = JacksonMapper.getInstance()
            .getFactory().createGenerator(stringWriter);

    jsonGenerator.writeStartObject(); //写入不同的对象
    jsonGenerator.writeStringField("name", "zhaokaiqiang");
    jsonGenerator.writeNumberField("age", 22);
    jsonGenerator.writeObjectField("person", p);
    jsonGenerator.writeEndObject();

    jsonGenerator.flush();
    jsonGenerator.close();

    System.out.println(stringWriter.toString());
    return stringWriter.toString();

}

//数组对象（包含不同类型的数据）--> Json
public static void createArrayJson() throws Exception {

    Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));

    StringWriter stringWriter = new StringWriter();
    // 只能通过这种方式获取
    JsonGenerator jsonGenerator = JacksonMapper.getInstance()
            .getFactory().createGenerator(stringWriter);

    jsonGenerator.writeStartArray();
    jsonGenerator.writeString("zhaokaiqiang");
    jsonGenerator.writeNumber(22);
    jsonGenerator.writeObject(p);
    jsonGenerator.writeEndArray();

    jsonGenerator.flush();
    jsonGenerator.close();

    System.out.println(stringWriter.toString());
}


//转换为普通对象
public static void toObject() throws Exception {

    ObjectMapper objectMapper = JacksonMapper.getInstance();
    Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
    String jsonString = getJsonString(p);
    Person person = objectMapper.readValue(jsonString, Person.class);//转换为对象
    System.out.println(person.toString());

}

//解析数组对象
public static void toObjects() throws Exception {

    Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));

    ArrayList<Person> persons = new ArrayList<>();
    persons.add(p);
    persons.add(p);
    persons.add(p);

    ObjectMapper objectMapper = JacksonMapper.getInstance();
    String jsonString = getJsonString(persons);
    //泛型支持
    JavaType javaType = getCollectionType(ArrayList.class, Person.class);
    ArrayList<Person> arrayList = objectMapper.readValue(jsonString, javaType);

   System.out.println(arrayList);

}

//List<String> HashMap<String, String>等泛型的支持
public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
    return JacksonMapper.getInstance().getTypeFactory().constructParametricType(collectionClass, elementClasses);
}

//解析生成复杂对象
public static void fromJsons() throws Exception {

    String jsonString = createObjectJson();
    ObjectMapper objectMapper = JacksonMapper.getInstance();

    JsonNode jsonNode = objectMapper.readTree(jsonString);
    JsonNode nameNode = jsonNode.get("name");
    JsonNode ageNode = jsonNode.get("age");
    JsonNode persoNode = jsonNode.get("person");

    String personString = persoNode.toString();
    Person person = objectMapper.readValue(personString, Person.class);

    System.out.println("person=" + person.toString());
    System.out.println("age=" + ageNode.asInt());
    System.out.println("name=" + nameNode.asText());

}

3. FastJson

Java Bean 对象 <–> json 字符串 <–> JSONObject 互相转化
Java Bean 对象 <–> json 字符串 <–> JSONArray 对象 互相转化
直接上代码

public static final String json_student =  "{\"age\":42,\"id\":1,\"male\":true,\"name\":\"Sherlock Holmes\",\"schoolId\":1}";
public static final String json_array = "[{\"age\":42,\"id\":1,\"male\":true,\"name\":\"Sherlock Holmes\",\"schoolId\":1},{\"age\":42,\"id\":2,\"male\":false,\"name\":\"John Watson\",\"schoolId\":1}]";

public static void toJsonString() {
    Student student = new Student(1, "Sherlock Holmes", 42, true, 5);
    String json = JSON.toJSONString(student);
    System.out.println(json);
    System.out.println("-------------");
    String format_json = JSON.toJSONString(student, true);
    System.out.println(format_json);
}

public static void toJsonTest() {
    //创建一个 Student 对象
    Student student_s = new Student(1, "Sherlock Holmes", 42, true, 1);
    //将 java bean 对象转为 JSONObject 对象
    JSONObject object = (JSONObject) JSON.toJSON(student_s);

    //JSONObject 直接打印, 打印 toString() 或者 toJSONString() 输出结果是一样的
    System.out.println(object + " -- 打印 JSONOBject 本身");
    System.out.println(object.toString() + " -- 打印 JSONOBject.toString()");
    System.out.println(object.toJSONString() + " -- 打印 JSONOBject.toJSONString()");

    //再创建一个 Student 对象
    Student student_j = new Student(2, "John Watson", 42, false, 1);
    //将两个 Student 对象放到 List 集合中
    List<Student> students = new ArrayList<>();
    students.add(student_s);
    students.add(student_j);
    //将 List 集合对象转为 JSONArray 对象
    JSONArray array = (JSONArray) JSON.toJSON(students);

    //JSONArray 直接打印, 打印 toString() 或者 toJSONString() 输出结果是一样的
    System.out.println(array + " -- 打印 JSONArray 本身");
    System.out.println(array.toString() + " -- 打印 JSONArray.toString()");
    System.out.println(array.toJSONString() + " -- 打印 JSONArray.toJSONString()");
}

public static void parseArray() {

    JSONArray array = JSON.parseArray(json_array);
    System.out.println(array);

    List<Student> students = JSON.parseArray(json_array, Student.class);
    students.forEach(System.out::println);
}

public static void parseObject() {

    //将 json 字符串转为 JSONObject 对象
    JSONObject object = JSON.parseObject(json_student);
    //打印 JSONObject 对象
    System.out.println(object);

    //将 json 字符串转为 Student 对象
    Student student = JSON.parseObject(json_student, Student.class);
    //打印 Student 对象
    System.out.println(student.toString());
}

public static void parse() {
    //将 json 字符串转为 JSONObect 对象
    JSONObject object = (JSONObject) JSON.parse(json_student);
    //打印 JSONObject 对象
    System.out.println(object);

    //将 json 字符串 转为 JSONArray 对象
    JSONArray array = (JSONArray) JSON.parse(json_array);
    //打印 JSONArray 对象
    System.out.println(array);
}

public static void jsonObjectTest() {
    //创建 一个 Student 对象
    Student student = new Student(1, "Sherlock Holmes", 42, true, 1);
    //将 Java Bean 对象转为 JSONObject 对象
    JSONObject object = (JSONObject) JSON.toJSON(student);
    //打印 JSONObject 对象
    System.out.println(object.toString());

    //获取 JSONObject 对象的 age 和 male 值
    String age = object.getString("age");
    boolean isMale = object.getBoolean("male");
    System.out.println("age : " + age + " , male : " + isMale);

    //向 JSONObject 对象中添加单个属性
    object.put("action", "fuck");
    System.out.println(object.toString());

    //向 JSONObject 对象中添加多个属性
    Map<String, String> map = new HashMap<>();
    map.put("home", "American");
    map.put("school", "harvard");
    object.putAll(map);
    System.out.println(object.toJSONString());

    //移除 JSONObject 对象中的属性
    object.remove("action");
    System.out.println(object);

    //获取 JSONObject 中的属性个数
    System.out.println(object.size());
}