GSON速学必会

作者:www.s0081.com

GSON速学必会。二. 供给精晓的12个GSON天性

在本节中,将明白GSON库帮忙的十分重要效率以至怎么样促成这一个效应。

5. 数组

GSON援助将Java数组转变为JSON表示。

让大家来看二个数组的例证:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class ArrayFeature {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().create();

        int[] numberArray = { 121, 23, 34, 44, 52 };

        String[] fruitsArray = { "apple", "oranges", "grapes" };

        String jsonNumber = gson.toJson(numberArray);
        String jsonString = gson.toJson(fruitsArray);

        System.out.println(jsonNumber);
        System.out.println(jsonString);

        int[] numCollectionArray = gson.fromJson(jsonNumber, int[].class);
        String[] fruitBasketArray = gson.fromJson(jsonString, String[].class);

        System.out.println("Number Array Length " + numCollectionArray.length);
        System.out.println("Fruit Array Length " + fruitBasketArray.length);

    }

}

出口结果为:

[121,23,34,44,52]
["apple","oranges","grapes"]
Number Array Length 5
Fruit Array Length 3

构造器使用安装方式

在这里种措施中,能够应用GsonBuilder类和create办法成立多个GSON类对象:

Gson gson = new GsonBuilder ().create ();

前方的代码调用了GsonBuildercreate方式,它回到三个Gson指标实行开始化。

GSON速学必会。下表列举了GSONGSON速学必会。国有的生龙活虎部分格局:

方法 描述
fromJson 此方法用于反序列化以获取Java对象。 API中有此方法的重载的形式。
toJson 该方法将Java对象序列化为等效的JSON表示形式。 API中有此方法的重载的形式。
toJsonTree 该方法使用它们的泛型类型序列化对象。API中有此方法的重载的形式。

2. 篇章和科目

  • Google提供的客户指南:
  • Mkyong的博客:

6. 泛型

GSON速学必会。GSON使用com.google.gson.reflect.TypeToken来支持泛型类型的Java类对象,用于连串化和反体系化。使用TypeToken类的指标是利用Java泛型类型的体系擦除的特色。

类型擦除发生在编译期,在那处,Java泛型类型被完全除去,以发出字节码。由此,在将JSON字符串反系列化为泛型Java类时,它大概会并未有科学地反种类化。

上边包车型客车代码演示了泛型类型连串化/反体系化以至TypeToken类是用来缓慢解决那一个难题:

import java.lang.reflect.Type;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

class StudentGeneric<T, E> {

    T mark;

    E name;

    public T getMark() {
        return mark;
    }

    public void setMark(T mark) {
        this.mark = mark;
    }

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

public class GenericTypeFeature {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        Gson gson = new Gson();
        StudentGeneric<Integer, String> studGenericObj1 = new StudentGeneric<Integer, String>();
        studGenericObj1.setMark(25);
        studGenericObj1.setName("Sandeep");

        String json = gson.toJson(studGenericObj1);
        System.out.println("Serialized Output :");
        System.out.println(json);

        StudentGeneric<Integer, String> studGenericObj2 = gson.fromJson(json, StudentGeneric.class);
        System.out.println("DeSerialized Output :");
        System.out.println("Mark : " + studGenericObj2.getMark());

        Type studentGenericType = new TypeToken<StudentGeneric<Integer, String>>() {}.getType();

        StudentGeneric<Integer, String> studGenericObj3 = gson.fromJson(json, studentGenericType);
        System.out.println("TypeToken Use DeSerialized Output :");
        System.out.println("Mark : " + studGenericObj3.getMark());
    }

}

出口结果为:

Serialized Output :
{"mark":25,"name":"Sandeep"}
DeSerialized Output :
Mark : 25.0
TypeToken Use DeSerialized Output :
Mark : 25

在上边的代码中,StudentGeneric类选取七个泛型参数,并有分其他getter和setter方法。StudentGeneric类对象使用IntegerString作为markname的档期的顺序来创制的。在类别化时,mark被开首化为25,但反体系化输出显示为25.0,这是三个不得法的值,因为项目擦除属性在编写翻译时从类中剔除了泛型类型的参数。使用TypeToken类来减轻这几个难题。getType()情势重临具备泛型参数的原始类类型,它扶助GSON精确地反种类化对象,并将科学值输出为25。

1. 官方网站网站

  • 主页: 
  • 手册和文书档案:
  • 维基百科:
  • 源码:
  • 统筹文书档案:
  • 反馈:

(2) 实例之中类

Java中的三个实例之中类能够通过运用外部类对象来实例化。上面包车型客车代码演示了GSON怎么样系列化和反连串化一个实例之中类的Java类对象:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

class Student {

    private String studentName;
    private int mark;

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getMark() {
        return mark;
    }

    public void setMark(int mark) {
        this.mark = mark;
    }

    public class Course {

        private String courseName;

        private String duration;

        public String getCourseName() {
            return courseName;
        }

        public void setCourseName(String courseName) {
            this.courseName = courseName;
        }

        public String getDuration() {
            return duration;
        }

        public void setDuration(String duration) {
            this.duration = duration;
        }
    }
}

public class InstanceNestedClassFeature {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        Student outstudent = new Student();
        Student.Course instanceCourse = outstudent.new Course();

        instanceCourse.setCourseName("M.TECH.");
        instanceCourse.setDuration("12 hr");

        String jsonCourse = gson.toJson(instanceCourse);
        System.out.println(jsonCourse);

        Student.Course anotherCourse = gson.fromJson(jsonCourse, Student.Course.class);
        System.out.println("Course : " + anotherCourse.getCourseName() + "Duration : " + anotherCourse.getDuration());
    }
}

出口结果为:

{
  "courseName": "M.TECH.",
  "duration": "12 hr"
}
Course : M.TECH.Duration : 12 hr

在前边的代码中,Course是贰个实例之中类,有四个字段和它们的getter和setter方法。Course对象的nstanceccourse是运用外界类对象outstudent实例化的。这些里面类对象被停放到系列化和反连串化中,进而在调整台上发生结果。在反种类化进度中,fromJson()艺术应用Student用作第一个参数。当然,它支持GSON成功地将其反体系化到里头类对象中。

1. 在 GSON 中创造你的第一个 JSON

在本节中,将学习实例化GSON及其各样措施的意义,然后是一个不慢示例代码,展现包装档期的顺序Java对象的骨干体系化。

10. 性质命名的支持

该本性为开采人员在种类化Java对象时提供自定义名称提供了灵活性。JSON表示变得更有意义和可读性。

GSON提供了多少个持有内置属性命名辅助的FieldNamingPolicy类:

import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.SerializedName;

class College {

    @SerializedName("instituteName")
    private String name;

    private String[] coursesOffer;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String[] getCoursesOffer() {
        return coursesOffer;
    }

    public void setCoursesOffer(String[] coursesOffer) {
        this.coursesOffer = coursesOffer;
    }
}

public class FieldNamingFeature {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).setPrettyPrinting()
                .create();

        College aCollege = new College();
        aCollege.setName("VIT University, Vellore");
        String[] courses = { "BTECH, MTECH, BSC, MSC" };
        aCollege.setCoursesOffer(courses);

        String jsonCollege = gson.toJson(aCollege);
        System.out.println(jsonCollege);
        College anotherCollege = gson.fromJson(jsonCollege, College.class);
        System.out.println("College Name : " + anotherCollege.getName());
    }
}

输出结果为:

{
  "instituteName": "VIT University, Vellore",
  "CoursesOffer": [
    "BTECH, MTECH, BSC, MSC"
  ]
}
College Name : VIT University, Vellore

一. GSON 简介

GSON是三个Java语言编写的用来拍卖JSON数据格式的开源应用程序编制程序接口项目。它将Java对象转变为JSON表示。还足以用于将JSON字符串调换为相近的Java对象。

图片 1

gson手包含了JSON数据管理的享有常见类和接口。gson中间的子包reflectannotation, 和 streamreflect双肩包含管理Java泛型类型音信的类和接口。annotation手提袋含相关的类和接口,用于对象属性的自定义名称映射。stream手袋含与读写相关的类和接口。

GSON设计的初志如下:

  • 有贰个简便的调换机制,可以将Java对象转变为JSON。GSON Java项目有雅量的实用方法作为api供开垦人士使用。
  • 同意将从前设有的不行改革的Java对象调换为JSON和从JSON调换。
  • 定制对象的象征。GSON为对象字段提供了名称的自定义映射,同临时间将其类别化为JSON字符串。
  • 提供三个黄金年代体和格式化的输出。暗中认可意况下,为Java对象生成的JSON字符串是大器晚成环扣意气风发环的格局。GSON提供优秀的打字与印刷设备以使其以人类可读的格式。

(3卡塔 尔(英语:State of Qatar)客户自定义属性消逝表明

GSON为开采职员提供了灵活性,能够创制一个自定义注明,用于破除属性和类。下边包车型客车手续示例了如何创设自定义注解:

  1. 宣称一个标志Java接口。二个标志接口是简轻松单的Java接口,未有其他性质或艺术。一句话来讲,三个空的Java接口是二个标志接口。该接口的名目将用作自定义消弭注明。
  2. 一个Java类来落到实处com.google.gson.ExclusionStrategyExclusionStrategy接口提供了三种艺术。通过完结那个接口,Java类提供了定制祛除申明的功用。当GSON在类别化或反体系化并找到多个自定义申明时,它会翻动完毕了ExclusionStrategy接口的Java类,以寻觅哪些管理它。

ExclusionStrategy接口提供了三种情势:

方法名 详细说明
shouldSkipField 参数:FieldAttributes 引用类型;返回Boolean值:true:属性将被序列化/反序列化输出的一部分;false:属性将不会被序列化/反序列化输出的一部分。
shouldSkipClass 参数:Class类的引用类型。返回Boolean值:true:类将序列化/反序列化输出的一部分;false:类将不会被序列化/反序列化输出的一部分。

让我们来看一个顾客定义的属性排除注明的身先士卒:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD })
@interface MyExclude {
}

class CustomExclusionStrategy implements ExclusionStrategy {

    private final Class<?> typeToExclude;

    CustomExclusionStrategy(Class<?> typeToExclude) {
        this.typeToExclude = typeToExclude;
    }

    public boolean shouldSkipClass(Class<?> classname) {
        return (classname == typeToExclude);
    }

    public boolean shouldSkipField(FieldAttributes f) {
        return f.getAnnotation(MyExclude.class) != null;
    }

}

class Vegetable {

    private String name;
    @MyExclude
    private int price;

    public Vegetable() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

public class UserDefinedFieldExclusion {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().setExclusionStrategies(new CustomExclusionStrategy(MyExclude.class)).create();

        Vegetable aVegetable = new Vegetable();
        aVegetable.setName("Potato");
        aVegetable.setPrice(26);
        String jsonVegetable = gson.toJson(aVegetable);

        System.out.println(jsonVegetable);
    }
}

输出结果为:

{"name":"Potato"}

下边包车型客车代码推行以下步骤:

  • 使用java.lang.annotation始建客商自定义注明@MyExclude
  • 选取含有MyExclude.class参数的CustomExclusionStrategy类实例化二个自定义淹没计谋。
  • 使用setExclusionStrategies方法,GsonBuilder配置那么些新的清除计谋。
  • 现在,由GsonBuilder创建的Gson目的将免除带有@MyExclude注脚的字段。

8. 本子扶助

GSON提供了版本化的种类化/反类别化的Java对象的JSON表示。这有利于迭代开荒和发布值对象。GSON API提供了生机勃勃种体制来满足这个分裂版本数据的号令。

让大家看贰个版本支持的例子:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Since;

@Since(1.0)
class Student {

    private String name;

    private String subject;

    private int mark;

    @Since(1.1)
    private String gender;

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public int getMark() {
        return mark;
    }

    public void setMark(int mark) {
        this.mark = mark;
    }
}

public class VersionSupportFeature {

    public static void main(String[] args) {

        Student aStudent = new Student();
        aStudent.setName("Sandeep Kumar Patel");
        aStudent.setSubject("Algebra");
        aStudent.setMark(534);
        aStudent.setGender("Male");

        System.out.println("Student json for Version 1.0 ");
        Gson gson = new GsonBuilder().setVersion(1.0).setPrettyPrinting().create();
        String jsonOutput = gson.toJson(aStudent);
        System.out.println(jsonOutput);

        System.out.println("Student json for Version 1.1 ");
        gson = new GsonBuilder().setVersion(1.1).setPrettyPrinting().create();
        jsonOutput = gson.toJson(aStudent);
        System.out.println(jsonOutput);
    }
}

出口结果为:

Student json for Version 1.0 
{
  "name": "Sandeep Kumar Patel",
  "subject": "Algebra",
  "mark": 534
}
Student json for Version 1.1 
{
  "name": "Sandeep Kumar Patel",
  "subject": "Algebra",
  "mark": 534,
  "gender": "Male"
}

私下认可方法

在这里种措施中,能够行使new重要字实例化GSON类对象。这种措施创设了一个不曾设置的object实例。

2. 一个轻巧易行的例证

让我们看看三个简易的例证代码,显示的宗旨使用GSON库对Java包装类进行系列化/反种类化对象的JSON字符串:

import com.google.gson.Gson;

public class QuickStartDemo {

    public static void main(String[] args) {

        Gson gson = new Gson();

    /*Java Wrapper Type*/
        String jsonInteger = gson.toJson(new Integer(1));
        String jsonDouble = gson.toJson(new Double(12345.5432));

        System.out.println("GSON toJson Method Use ");
        System.out.println(jsonInteger);
        System.out.println(jsonDouble);

        Integer javaInteger = gson.fromJson(jsonInteger, Integer.class);
        Double javaDouble = gson.fromJson(jsonDouble, Double.class);

        System.out.println("GSON fromJson Method Use ");
        System.out.println(javaInteger);
        System.out.println(javaDouble);
    }
}

出口结果为:

GSON toJson Method Use
1
12345.5432
GSON fromJson Method Use
1
12345.5432

前方的代码演示了toJsonfromJson的两种情势的长足利用。

在代码的率先片段中,使用私下认可方法实例化了二个Gson类对象,并使用值112345.5432实例化了四个Java 包装类对象,即Integer类和Double类。这一个目的传递给toJson主意,该方法生成JSON等效字符串格局。

方法                           详细说明
toJSON        参数:使用Java类对象进行序列化。 返回:JSON对象的字符串表示形式
fromJSON   参数:第一个参数是JSON表示的字符串类型,第二个参数是预期的Java类类型。返回:预期的Java类对象

在代码的末段意气风发有的中,JSON等效字符串传递给fromJson主意。 该情势有四个参数,第叁个参数是贰个字符串,第叁个参数是贰个预料的Java类品种。 fromJson办法的回来类型始终是Java类型。

(1) 客商自定义属性命名

除了这些之外主导的习性命名意义之外,GSON还提供了一个FieldNamingStrategy类,以使开垦人士能够创制自个儿的性质命名战术。以下步骤示举例何创造自定义属性命名战术:

  • 始建三个 Java 类并得以达成FieldNamingStrategy接口
  • 重写translateName方法
  • 该方法提供了自定义属性命名计谋的着实兑现。GSON在拍卖自定义属性名称攻略时,使用该措施中的逻辑作为属性名:
方法 详细说明
translateName 参数:java.lang.reflect.Field;返回:已更改的属性名字符串

让大家看一个客户定义属性命名的亲自去做:

import java.lang.reflect.Field;
import com.google.gson.FieldNamingStrategy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

class College {

    private String name;

    private String[] coursesOffer;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String[] getCoursesOffer() {
        return coursesOffer;
    }

    public void setCoursesOffer(String[] coursesOffer) {
        this.coursesOffer = coursesOffer;
    }
}

class CustomFieldStrategy implements FieldNamingStrategy {

    @Override
    public String translateName(Field aField) {

        String nameOfField = aField.getName();

        return nameOfField.toUpperCase();
    }
}

public class CustomFieldNamingFeature {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().setFieldNamingStrategy(new CustomFieldStrategy()).setPrettyPrinting().create();

        College aCollege = new College();
        aCollege.setName("VIT University, Vellore");
        String[] courses = { "BTECH, MTECH, BSC, MSC" };
        aCollege.setCoursesOffer(courses);

        String jsonCollege = gson.toJson(aCollege);
        System.out.println(jsonCollege);
    }
}

输出结果为:

{
  "NAME": "VIT University, Vellore",
  "COURSESOFFER": [
    "BTECH, MTECH, BSC, MSC"
  ]
}

三. 你应当通晓的帮扶文书档案

生龙活虎经您需求相关GSON资料文书档案的帮忙,这里有风度翩翩部分网站是那么些有效的:

(1)配置GsonBuilder

GsonBuilder提供excludeFieldsWithModifiers()办法来清除属性体系化。该形式提供了打消具备具备钦点修饰符的类属性的技术。该办法的原型特征如下:

public GsonBuilder excludeFieldsWithModifiers(int... modifiers)
  • 输入参数:...标识,表示入参是java.lang.reflect.Modifier项目可变参数,比如Modifier.STATICModifier.PUBLICModifier.PRIVATE
  • 归来类型:再次来到三个GsonBuilder品类的引用对象。

让大家来看一个配置GsonBuilder的示例:

import java.lang.reflect.Modifier;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

class Employee {

    private String name;
    private transient String gender;
    private static String designation;
    protected String department;

    public Employee() {
        this("Abcd Employee", "MALE", "Tech Lead", "IT Services");
    }

    @SuppressWarnings("static-access")
    public Employee(String name, String gender, String designation,
                    String department) {
        this.name = name;
        this.gender = gender;
        this.designation = designation;
        this.department = department;
    }
}

public class FieldExclusionFeature {

    public static void main(String[] args) {

        Gson gson = new Gson();

        String json = gson.toJson(new Employee("Sandeep", "Male", "Tech Lead", "IT Services"));
        System.out.println(json);

        Gson gson2 = new GsonBuilder().excludeFieldsWithModifiers().create();
        json = gson2.toJson(new Employee("Sandeep", "MALE", "Tech Lead", "IT Services"));
        System.out.println(json);

        Gson gson3 = new GsonBuilder().excludeFieldsWithModifiers(Modifier.STATIC).create();
        json = gson3.toJson(new Employee("Sandeep", "MALE", "Tech Lead", "IT Services"));
        System.out.println(json);
    }

}

出口结果为:

{"name":"Sandeep","department":"IT Services"}
{"name":"Sandeep","gender":"MALE","designation":"Tech Lead","department":"IT Services"}
{"name":"Sandeep","gender":"MALE","department":"IT Services"}

大家得以从以前的代码中收获四个启发:

  • 输出的第豆蔻梢头行有贰个Employee类JSON字符串,它有七个属性:namedepartment。那么些输出是由于Gson对象,使用暗中同意的法子创造的。因此,在类别化时,它归纳了statictransient修饰的性情。
  • 输出的第二行有三个Employee类JSON字符串,它有四个个性:namegenderdesignationdepartment。那些输出是出于Gson对象使用构造器的方法和excludeFieldWithModifiers()格局。当未有参数字传送递时,它会类别化Employee对象中设有的具有字属性类型。
  • 出口的第三行有二个Employee类JSON字符串,该字符串包涵几特天性:namegenderdepartment。输出是由于Gson对象使用构造器的点子和excludeFieldsWithModifiers()方法。Modifier.STATIC用作一个参数字传送递给这几个法子,它不类别化Employee对象的其它静态属性。

步骤1 - 实例化GSON

要使用GSON库,Gson类供给实例化三个com .google.GSON的对象。GSON对象不爱戴其余意况,这么些特点有支持在三个地方重用GSON对象。

GSON库提供了实例化的二种艺术:

  • 私下认可方法
  • 构造器使用安装格局

7. 对 null 对象的帮忙

GSON也能够对null对象实行体系化/反种类化的JSON表示。

让我们看三个空对象的事例:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class NullSupportFeature {

    public static void main(String[] args) {
        Gson gson = new GsonBuilder().serializeNulls().setPrettyPrinting().create();

        Student aStudent = new Student();
        aStudent.setName("Sandeep Kumar Patel");
        aStudent.setSubject(null);
        aStudent.setMark(234);

        String studentJson = gson.toJson(aStudent);

        System.out.println(studentJson);

        Student javaStudentObject = gson.fromJson(studentJson, Student.class);

        System.out.println("Student Subject: " + javaStudentObject.getSubject());
        System.out.println("Student Name: " + javaStudentObject.getName());
    }
}

出口结果为:

{
  "name": "Sandeep Kumar Patel",
  "subject": null,
  "mark": 234
}
Student Subject:null
Student Name:Sandeep Kumar Patel

11. 品质消释战略

GSON API也扶助种类化时期的属性清除。开拓人士能够在种类化Java对象时去掉有个别品质。GSON提供了二种分歧的措施来兑现属性的破除:

  • 配置GsonBuilder
  • 接纳申明

图片 2

眼下的图片展现了GSON中二种不一致的天性祛除计策方法的摘要。每意气风发种方法都有详细的批注。

4. 内部类

Java内部类能够有两体系型:

  • 静态内部类
  • 实例之中类

下面将见到GSON如哪里理那一个项目标内部类类对象的。

(2卡塔尔使用评释

GSON提供@Expose讲解实现在种类化时期消亡钦点属性。属性标有@Expose注脚的将系列化为JSON表示。GSON的excludeFieldsWithoutExposeAnnotation()格局必得在布署GsonBuilder使用@Expose评释时被调用。

让我们来看贰个应用@Expose讲明的事例:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;

class Vegetable {

    private String name;
    @Expose
    private int price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

public class FieldExclusionAnnotationUse {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation()
                .create();
        Vegetable aVegetable = new Vegetable();
        aVegetable.setName("Potato");
        aVegetable.setPrice(26);
        String jsonVegetable = gson.toJson(aVegetable);

        System.out.println("JSON Representation of Vegetable : ");
        System.out.println(jsonVegetable);
    }
}

出口结果为:

JSON Representation of Vegetable : 
{"price":26}

我们能够在那早前方的代码中得出以下几点启迪:

  • 前生龙活虎段代码的出口有一个带属性price的JSON字符串。那一个输出是由于Gson对象使用构造器的情势和excludeFieldsWithoutExposeAnnotation()方法。
  • 队列化Java对象时,它只连串化带有@Expose的属性。

2. 种类化与反系列化

GSON有一点点类的隐式连串化,比方Java包装类(IntegerLongDouble等等)、Java.net.urljava.net.URIjava.util.Date,等等。

让自家看个例证:

import java.util.Date;
import com.google.gson.Gson;

public class InbuiltSerializerFeature {
    public static void main(String[] args) {
        Date aDateJson = new Date();
        Gson gson = new Gson();
        String jsonDate = gson.toJson(aDateJson);
        System.out.println(jsonDate);
    }
}

出口结果为:

"Sep 15, 2017 10:38:35 PM"

前方的代码是将Java的Date类对象体系化为JSON表示。在后边的生机勃勃对中,您已经领会了怎么运用GSON来种类化和反连串化对象,甚至它什么为客户定义的Java类对象提供定制化的种类化器和反体系化器。让大家看看它是怎样专门的职业的。

除此以外,GSON还为开荒人士提供了可定制的连串化的特色。

下边包车型客车代码是贰个可定制连串化器的自己要作为榜样遵守规则:

public class StudentTypeSerializer implements JsonSerializer<Student> {

    @Override
    public JsonElement serialize(Student student, Type type,
                                 JsonSerializationContext context) {
        JsonObject obj = new JsonObject();

        obj.addProperty("studentname", student.getName());
        obj.addProperty("subjecttaken", student.getSubject());
        obj.addProperty("marksecured", student.getMark());

        return obj;
    }
}

下边的代码是三个自定义反种类化器的事例:

class StudentTypeDeserializer implements JsonDeserializer<Student> {

    @Override
    public Student deserialize(JsonElement jsonelment, Type type,
                               JsonDeserializationContext context) throws JsonParseException {

        JsonObject jsonObject = jsonelment.getAsJsonObject();

        Student aStudent = new Student();
        aStudent.setName(jsonObject.get("studentname").getAsString());
        aStudent.setSubject(jsonObject.get("subjecttaken").getAsString());
        aStudent.setMark(jsonObject.get("marksecured").getAsInt());

        return aStudent;
    }
}

以下代码测验自定义类别化器和反系列化器:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class CustomSerializerFeature {

    public static void main(String[] args) {

        GsonBuilder gsonBuilder = new GsonBuilder();

        gsonBuilder.registerTypeAdapter(Student.class, new StudentTypeSerializer());

        Gson gson = gsonBuilder.create();

        Student aStudent = new Student();

        aStudent.setName("Sandeep");

        aStudent.setMark(150);

        aStudent.setSubject("Arithmetic");

        String studentJson = gson.toJson(aStudent);

        System.out.println("Custom Serializer : Json String Representation ");
        System.out.println(studentJson);

        gsonBuilder.registerTypeAdapter(Student.class, new StudentTypeDeserializer());
        Gson gsonde = gsonBuilder.create();
        Student deStudent = gsonde.fromJson(studentJson, Student.class);

        System.out.println("Custom DeSerializer : Java Object Creation");

        System.out.println("Student Name " + deStudent.getName());
        System.out.println("Student Mark " + deStudent.getMark());
        System.out.println("Student Subject " + deStudent.getSubject());
        System.out.println("is anotherStudent is type of Student " + (deStudent instanceof Student));
    }
}

输出结果为:

Custom Serializer : Json String Representation 
{"studentname":"Sandeep","subjecttaken":"Arithmetic","marksecured":150}
Custom DeSerializer : Java Object Creation
Student Name Sandeep
Student Mark 150
Student Subject Arithmetic
is anotherStudent is type of Student true

4. 博客

  • Java code geek博客:
  • GSON应用程序:

(1) 静态内部类

GSON能够隐式地体系化/反种类化静态内部类。无需杰出的配置。

让我们看三个静态内部类的例子:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

class Student {

    private String studentName;

    private int mark;

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getMark() {
        return mark;
    }

    public void setMark(int mark) {
        this.mark = mark;
    }

    public static class Course {

        private String courseName;

        private String duration;

        public String getCourseName() {
            return courseName;
        }

        public void setCourseName(String courseName) {
            this.courseName = courseName;
        }

        public String getDuration() {
            return duration;
        }

        public void setDuration(String duration) {
            this.duration = duration;
        }
    }
}

public class StaticNestedClassFeature {

    public static void main(String[] args) {

        Gson gson = new GsonBuilder().setPrettyPrinting().create();

        Student.Course aCourse = new Student.Course();
        aCourse.setCourseName("M.TECH.");
        aCourse.setDuration("120 hr");

        String jsonCourse = gson.toJson(aCourse);
        System.out.println(jsonCourse);

        Student.Course anotherCourse = gson.fromJson(jsonCourse, Student.Course.class);

        System.out.println("Course : " + anotherCourse.getCourseName() + "Duration : " + anotherCourse.getDuration());
    }
}

输出结果为:

{
  "courseName": "M.TECH.",
  "duration": "120 hr"
}
Course : M.TECH.Duration : 120 hr

在上头的代码中,Course类是Student类内的静态内部类。courseNameduration是多个属性,以致分级的getter和setter方法在。通过外界类的.操作符调用,能够在Java中实例化二个静态的中间类。Student.Course aCourse = new Student.Course()用来初叶化内部Course类的。M.TECH.120 hr则是用来实例化它的四个值。从出口中得以看到,GSON能够连串化生成Course对象的JSON表示的静态内部类。输出的尾声大器晚成行展现GSON成功地将其反类别化。

3. 社区

  • 官方论坛:
  • 非官方论坛:

12. 应用GSON

在JSON格式和它对应的言语库GSON的表明之后,Java web应用程序的付出(客户端与劳动器端举办通信并以JSON格式对数据进行响应)获得了大气的盛行,那使得Web 2.0应用程序特别成功。

以下StudentJsonDataServlet.java显示了二个Java servlet怎么样回到Student花色的JSON数据,并在浏览器中表现为HTML表格:

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.google.gson.Gson;
import com.packt.myapp.data.Student;

@WebServlet("/StudentJsonDataServlet")
public class StudentJsonDataServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public StudentJsonDataServlet() {
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        Gson gson = new Gson();

        List<Student> listOfStudent = getStudentData();

        String jsonString = gson.toJson(listOfStudent);

        response.setContentType("application/json");

        response.getWriter().write(jsonString);
    }

    /**
     * Returns List of Static Student data
     */
    private List<Student> getStudentData() {

        Student s1 = new Student();
        s1.setName("Sandeep");
        s1.setSubject("Computer");
        s1.setMark(85);

        Student s2 = new Student();
        s2.setName("John");
        s2.setSubject("Science");
        s2.setMark(85);

        Student s3 = new Student();
        s3.setName("Ram");
        s3.setSubject("Computer");
        s3.setMark(85);

        List<Student> listOfStudent = new ArrayList<Student>();
        listOfStudent.add(s1);
        listOfStudent.add(s2);
        listOfStudent.add(s3);

        return listOfStudent;
    }
}

StudentJsonDataServlet将学员的详细消息作为JSON字符串再次回到。并向浏览器注明,数据响应是二个json类型的头文件,要求设置为application/json

以下studentstableview.html是在浏览器中渲染servlet响应的文本:

<html>
  <head>
  <title>Students JSON Table View</title>
  <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
  </head>
  <body>
    <div id="student-data-container"></div>
    <script>
    $(document).ready(function(){

      var getStudentTableHtml, html, 

      htmlStudent, container =$('#student-data-container'),

      ajaxRequest = $.ajax({
        url: "StudentJsonDataServlet",

        dataType: "JSON",

        success: function(data){

          htmlStudent = getStudentTableHtml(data);

          container.html(htmlStudent)
        }
    }),

    getStudentTableHtml = function(data){

      html = [];

      html.push("<TABLE border='2px' cellspacing='2px'>");
      html.push("<TR>");
      html.push("<TH>NAME</TH>");
      html.push("<TH>SUBJECT</TH>");
      html.push("<TH>MARK</TH>");
      html.push("</TR>");

      $.each(data,function(index, aStudent){
        html.push("<TR>");
        html.push("<TD>");
        html.push(aStudent.name);
        html.push("</TD>");
        html.push("<TD>");
        html.push(aStudent.subject);
        html.push("</TD>");
        html.push("<TD>");
        html.push(aStudent.mark);
        html.push("</TD>");
        html.push("</TR>");
      });
      html.push("</TABLE>")

      return html.join("");
    }
  })
    </script>
  </body>
</html>

上边的代码展示了在DOM就绪事件上调用jQuery Ajax事件。servlet使用GSON API将Student指标的列表调换为相应的JSON表示,并将其用作响应内容发送到顾客端。以下截图中的Firebug调节台展现了JSON对象中的Ajax诉求和响应:

图片 3

在赢得响适那时候,jQuery调用success形式来拍卖。作为再次来到,成功管理程序调用getStudentTableHtml()主意在HTML中创设三个报表。

该情势运用for循环来迭代每种学子JSON对象来营造表格的行。上边截图展现了学员JSON响应数据创设的学子详细消息的HTML表格:

图片 4

9. 对无参数构造方法的支撑

尽管Java对象开展种类化/反系列化或JSON字符串,GSON创造四个私下认可实例的类的构造方法。有二个暗中同意的Java类的无参数构造方法是很好的。要是多个类未有暗中认可构造函数,GSON提供多个class.google.gson.InstanceCreator接口达成来处理它。

方法 详细说明
createInstance 参数:java.lang.reflect.Type类的实例;返回值:T类型的默认对象实例,引用对象实例的类类型。

让大家看二个无参构造方法的例证:

import java.lang.reflect.Type;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.InstanceCreator;

class Employee {

    private String name;
    private Salary salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Salary getSalary() {
        return salary;
    }

    public void setSalary(Salary salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", salary=" + salary + " ]";
    }
}

class Salary {

    private int salaryAmount;

    Salary(int salary) {
        this.salaryAmount = salary;
    }

    @Override
    public String toString() {
        return "Salary [salaryAmount=" + salaryAmount + "]";
    }
}

class SalaryInstanceCreator implements InstanceCreator<Salary> {
    @Override
    public Salary createInstance(Type type) {
        return new Salary(25000);
    }
}

public class InstanceCreatorUse {

    public static void main(String[] args) {

        String jsonString = "{"name" :"Sandeep" , "salary": {}}";

        Gson gson = new GsonBuilder().serializeNulls().registerTypeAdapter(Salary.class, new SalaryInstanceCreator())
                .setPrettyPrinting().create();

        System.out.println(gson.fromJson(jsonString, Employee.class));
    }
}

下面的代码演示了二个JSON字符串类型的Employee类,该字符串被反类别化为Employee品类的靶子。

  • 输入:一个 JSON 对象:jsonString = "{"name" :"Sandeep" , "salary": {}}";
  • 输出:一个 Java 对象:重写了toString()方法:Employee [name=Sandeep, salary=Salary [salaryAmount=25000]]

使用com .google. gson.InstanceCreator来实现二个SalaryInstanceCreator类,一视同仁写createInstance()方法,该方法重回值25000的参数化的Salary构造方法。

这个SalaryInstanceCreator使用registerTypeAdapter()艺术注册为GSON。

当GSON找到空的Salary字符串时,它将搜索类型Salary的暗许构造方法。由于不设有私下认可的Salary构造方法,所以它寻觅类型适配器的GsonBuilder设置,并找到SalaryInstanceCreator。并调用createInstance()方法。

所以,当对三个空的Salary类对象进行反连串化时,GSON将获得25000当做私下认可值。

3. 优越的打字与印刷

GSON的连串化输出的JSON表示格式紧密。假若有大批量的Java对象集合,况兼每一个对象都有相当多种类化的性质,那么它们紧密的JSON表示的可读性是老大差的,何况看起来很丢脸。

为了减轻那一个主题材料,GsonBuilder支撑美好的打字与印刷配置,同一时候为序列化使用创立二个Gson目的。那些理想的打字与印刷效能通过适当的价签缩进和新的换行来吹捧JSON字符串的出口。

以下是有关格式化程序的意气风发对首要内容:

  • JsonPrintFormatterJsonCompactFormatter是GSON中的二种格式化类型的表示。
  • JsonCompactFormatter是GSON的暗中认可格式化程序。
  • JsonPrintFormatter用来优异的打字与印刷,它不会揭穿在API中。所以开辟者不可能改过。
  • JsonPrintFormatter支撑三个默许行长度为七十八个字符,多个字符缩进,以至侧边保持八个字符。
  • 能够由此调用GsonBuildersetPrettyPrinting()措施来利用JsonPrintFormatter

切实看一个例证:

import java.util.ArrayList;
import java.util.List;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.packt.chapter.vo.Student;

 public class PrettyPrintFeature {


  public static void main(String[] args) {

    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    List<Student> listOfStudent = new ArrayList<Student>();

    Student student1 = new Student();
    student1.setName("Sandeep Kumar Patel");
    student1.setSubject("Arithmetic");
    student1.setMark(234);

    Student student2 = new Student();
    student2.setName("Sangeeta Patel");
    student2.setSubject("Geography");
    student2.setMark(214);

    listOfStudent.add(student1);
    listOfStudent.add(student2);

    String prettyJsonString = gson.toJson(listOfStudent);
    System.out.println(prettyJsonString);
  }

}

出口结果为:

[
  {
    "name": "Sandeep Kumar Patel",
    "subject": "Arithmetic",
    "mark": 234
  },
  {
    "name": "Sangeeta Patel",
    "subject": "Geography",
    "mark": 214
  }
]

地点的代码将学员列表种类化为JSON表示。它选用GsonBuilder类得到一个Gson对象。使用setPrettyPrinting()主意配置精美的打印。能够看看从前的代码的输出已经不错地缩进,况兼阅读起来很喜欢。

1. 对 Java 对象的扶植

GSON中的对象被称得上JsonElement的类型:

图片 5

GSON库能够将别的客户定义的类对象调换为JSON表示。Student类是三个顾客定义的类,GSON能够将其他Student对象种类化为JSON。
以下是 Student.java 的代码:

package com.lee.jsondemo;

public class Student {

    private String name;

    private String subject;

    private int mark;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public int getMark() {
        return mark;
    }

    public void setMark(int mark) {
        this.mark = mark;
    }

}

Student类进行操作的JavaObjectFeaturesUse.java代码如下:

import com.google.gson.Gson;
importcom.packt.chapter.vo.Student;

public class JavaObjectFeaturesUse {

public static void main(String[] args){

Gsongson = new Gson();

Student aStudent = new Student();
aStudent.setName("Sandeep");
aStudent.setMark(128);
aStudent.setSubject("Computer Science");

String studentJson = gson.toJson(aStudent);
System.out.println(studentJson);

Student anotherStudent = gson.fromJson(studentJson, Student.class);
System.out.println(anotherStudentinstanceof  Student);
  }
}

试行结果为:

{"name":"Sandeep","subject":"Computer Science","mark":128}
true

上边的代码创设了叁个name属性为sandeep的上学的小孩子对象,subject个性设置为Computer Sciencmark128。然后将二个Gson对象实例化,并将学子对象作为一个参数字传送递给toJson()主意。它回到三个字符串,该字符串具备Java对象的JSON表示。该字符串作为调整新竹的第风姿浪漫行打字与印刷。学子对象的出口JSON表示是键/值没有错集纳。学子类的Java属性成为JSON字符串中的键。

在代码的末段风流倜傥部分中,fromJson()方法将JSON生成的字符串作为第二个输入参数,Student.class用作第叁个参数,将JSON字符串调换回Java对象。代码的终极后生可畏行采用Student用作第二行操作符的实例来验证由fromJson()艺术生成的Java对象是还是不是是Student系列的。在调整高雄,它输出true,则意味着大家将获取与JSON肖似的值。

本文由金沙城中心全部网址发布,转载请注明来源

关键词: