FastJson Jackson Gson使用教程

原创 2016年08月30日 11:46:49

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());
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

gson,fastjson,jackson简单使用

  • 2015-08-13 16:42
  • 9.32MB
  • 下载

学习开源JSON框架 -- FastJson,Jackson,Gson

今天来和大家一起学习一下开源JSON框架。以前听说过同事提起JsonObject是现有json库中提供运行效率最慢的一种,趁着今天有时间,了解了一下相对运行效率比较快的,由Google提供的Gson,...

Android Jackson、Gson、FastJson解析框架对比

目前Android在使用的Json解析框架主要有Jackson、Gson、FastJson、org.json; 因为Android Studio自带的org.json解析 XML 文件时会将整个 X...

fastjson、gson、jackson序列化和反序列化性能对比

注:使用jar包版本 com.alibaba fastjson 1.2.31

解决fastjson、Jackson、Gson解析Json数据时,key为Java中关键字无法解析的问题

博文首次发布于个人博客:吾勇士的博客 无论我们在使用fastjson、Jackson还是Gson,我们在用json转换为实体类时,都是根据json数据建立对应实体类,但比较恶心的是,有时,有些服务商...

FastJson、Jackson、Gson、Json的效率简单对比

今天上班优化代码的时候,发现从Redis中取出List<Map>格式的json字符串,通过net.sf.json将其转成List的时候,如果List.size()在1000左右时,消耗处理时间为100...

FastJSON、Gson和Jackson性能对比

把Java对象JSON序列化,Jackson速度最快,在测试中比Gson快接近50%,FastJSON和Gson速度接近。 把JSON反序列化成Java对象,FastJSON、Jackson速度接近,...

Gson,FastJson, Jackson测试

Gson是google开源的json序列化和反序列化工具,拥趸众多;FastJson是阿里巴巴开源的json工具,国产高品质;而 Jackson是老牌的json工具,spring的默认json转化就使...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)