Gson 源码解读

最新推荐文章于 2021-08-27 17:29:41 发布
最新推荐文章于 2021-08-27 17:29:41 发布
阅读量633 收藏
点赞数
分类专栏： java 文章标签： java gson

转载请注明本文出自maplejaw的博客（http://blog.csdn.net/maplejaw_）

开源库地址：https://github.com/google/gson 
解读版本：2.7

Gson是一个可以用来将Java对象转换为JSON字符串的Java库。当然，它也可以把JSON字符串转换为等价的Java对象。网上已经有了不少可将Java对象转换成JSON的开源项目。但是，大多数都要求你在Java类中加入注解，如果你无法修改源码的话就比较坑爹了，此外大多数开源库并没有对泛型提供完全的支持。于是，Gson在这两个重要的设计目标下诞生了。Gson可以作用于任意的Java对象（包括接触不到源码的），与此同时还加入了完整的泛型支持。

基本用法

  • 基本数据类型
// 序列化为json
Gson gson = new Gson();
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(new Long(10)); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]

// 反序列化为java object
int one = gson.fromJson("1", int.class);
Integer one = gson.fromJson("1", Integer.class);
Long one = gson.fromJson("1", Long.class);
Boolean false = gson.fromJson("false", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 对象
public class User {
    public String name="maplejaw";
    public int age=18;

    public User(){
     //无参构造方法
    }
}


// 序列化
 User obj = new User();
 Gson gson = new Gson();
 String json = gson.toJson(obj);  // ==> json is {"name":"maplejaw","age":18}

//反序列化
 User obj2 = gson.fromJson(json, User.class);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 泛型
Type type= new TypeToken<List<User>>(){}.getType();
List<User> list = gson.fromJson(json, type);
 
 
  • 1
  • 2

 
 
  • 1
  • 2
  • 配置Gson
  Gson gson=new GsonBuilder()
                 .setLenient() //设置宽松的容错性
                 .setPrettyPrinting() //设置漂亮的打印（打印出来的有缩进风格）
                 .setVersion(..) //设置当前版本号
                 ...
                 .create();

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Gson的基本用法如上所示，使用起来比较简便，一般情况下也已经够用了。需要注意的是，Java对象一定要有一个无参构造方法，这是Gson实例化对象的关键（自定义实例后面介绍）。此外，Java对象中并不要求有set/get方法。一般只要了解以上基本用法就能够应付绝大多数情况了，如果想深入了解一些高级用法，请继续往下阅读源码解读。

源码解读

Gson中的5个注解

  • @Expose 
    表示某个成员变量暴露于JSON序列化/反序列化。只需在GsonBuilder中配置excludeFieldsWithoutExposeAnnotation()时才会生效。当配置过后，只有使用了@Expose注解的成员变量才会参与序列化/反序列化工作。

    public class User {
@Expose
private String firstName;//参与序列化(JAVA对象转为JSON)/反序列化（JSON转为JAVA对象）

@Expose(serialize = false) 
private String lastName;//参与反序列化

@Expose (serialize = false, deserialize = false) 
private String emailAddress; //不参与

private String password;//不参与
}
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

  • @SerializedName 
    表示某个成员变量序列化/反序列化的名字，无需在GsonBuilder中配置就能生效,甚至会覆盖掉FieldNamingPolicy。

    public class MyClass {
@SerializedName("name") //a => name
String a;
@SerializedName(value="name1", alternate={"name2", "name3"}) 
String b;

String c;

public MyClass(String a, String b, String c) {
 this.a = a;
 this.b = b;
 this.c = c;
}
}

   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    当使用了该注解后，此时序列化/反序列化的情况如下：

    MyClass target = new MyClass("v1", "v2", "v3");
Gson gson = new Gson();
String json = gson.toJson(target);
//===== 输入的json如下 =====
{"name":"v1","name1":"v2","c":"v3"}
//同理，以下的json数据都能成功反序列化为MyClass。
{"name":"v1","name1":"v2","c":"v3"}
{"name":"v1","name2":"v2","c":"v3"}
{"name":"v1","name3":"v2","c":"v3"}
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    这个注解有什么好处呢？众所周知，在Java中的变量命名规则须遵守驼峰原则，但是，如果后台使用的是PHP等其他语言，将导致命名规则不一致；又或者因为其他原因导致多条json只有一个字段不一致，总不能建立多个实体类吧？这时候这个注解就派上用场了。

  • @Since 
    表示某个成员变量从哪个版本开始生效，只在GsonBuilder中配置了setVersion()时才会生效。

    public class User {
private String firstName;//一直参与
private String lastName;//一直参与
@Since(1.0) private String emailAddress; //当前版本>=1.0时才会参与序列化/反序列化，否则忽略
@Since(1.0) private String password;//当前版本>=1.0时才会参与序列化/反序列化，否则忽略
@Since(1.1) private Address address;//当前版本>=1.1时才会参与序列化/反序列化，否则忽略
}
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

  • @Until 
    表示某个成员变量从哪个版本开始失效，只在GsonBuilder中配置了setVersion()时才会生效。

     public class User {
  private String firstName;//一直参与
  private String lastName;//一直参与
  @Until(1.1) private String emailAddress;//当前版本<=1.1时参加序列化/反序列化
  @Until(1.1) private String password;//当前版本<=1.1时参加序列化/反序列化
 }
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

  • @JsonAdapter 
    表示在某一个成员变量或者类上使用TypeAdapter。至于TypeAdapter是什么东东，后面介绍。举个例子： 
    假如有个User类如此下:

     public class User {
  public final String firstName, lastName;
  private User(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
 }
}
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    准备编写一个UserJsonAdapter。

    public class UserJsonAdapter extends TypeAdapter<User> {
@Override 
public void write(JsonWriter out, User user) throws IOException {
 out.beginObject();
 out.name("name");
 out.value(user.firstName + " " + user.lastName);
 out.endObject();
}
@Override 
public User read(JsonReader in) throws IOException {
 in.beginObject();
 in.nextName();
 String[] nameParts = in.nextString().split(" ");
 in.endObject();
 return new User(nameParts[0], nameParts[1]);
}
}

   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    将UserJsonAdapter应用到属性：此时，Gadget中的User，将会按照UserJsonAdapter来进行序列化/反序列化

    private static final class Gadget {
@JsonAdapter(UserJsonAdapter.class)
public User user;
}

   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5

    将UserJsonAdapter应用到类：此时，在序列化/反序列User对象时，都会按照UserJsonAdapter来执行。

     @JsonAdapter(UserJsonAdapter.class)
 public class User {
  public final String firstName, lastName;
  private User(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
 }
}
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

JsonReader/JsonWriter

在Gson中，Java对象与JSON字符串之间的转换是通过字符流来进行操作的。JsonReader继承于Reader用来读取字符，JsonWriter继承于Writer用来写入字符。 
假如，现在有如下一段JSON数据用来表示一个用户列表。name为名字,age为年龄,geo为定位的经纬度。如何使用JsonReader转为java对象？ 
image_1amg2niju16qh14gc1h3odm6k7q13.png-11.3kB 
首先查看一下json的结构，不难发现最外层是一个数组。于是，我们定义出如下readJsonStream从Stream（流）中读取用户列表，读取完毕后，务必记得关闭流。


//从流中读取List<User>
public List<User> readJsonStream(InputStream in) throws IOException {
     JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
     try {
       return readUserArray(reader);//读取用户列表
     } finally {
       reader.close();//关闭流
     }
   }

//读取List<User>
   public List<User> readUserArray(JsonReader reader) throws IOException {
     List<User> users = new ArrayList<User>();
     reader.beginArray();//开始读取数组
     while (reader.hasNext()) {//是否还有下个元素
       users.add(readUser(reader));//读取下个元素
     }
     reader.endArray();//结束读取数组
     return users;
   }

 //读取User对象  
public User readUser(JsonReader reader) throws IOException {
       String name = null;
       int age = -1;
       List<Double> geo=null;
      reader.beginObject();//开始读取对象
     while (reader.hasNext()) {//是否还有下个元素
       String name = reader.nextName();//读取下一个json属性名
        //判断属性名是哪一个
       if (name.equals("name")) {
           name = reader.nextString();
       } else if (name.equals("age")) {
           age = reader.nextInt();
       } else if (name.equals("geo")&& reader.peek() != JsonToken.NULL) {
          geo = readDoublesArray(reader);
       } else {
         reader.skipValue();//忽略没有匹配到内容的值
       }
     }
     reader.endObject();//结束读取对象
     return new User(name, age,geo);
   }
   //读取经纬度
   public List<Double> readDoublesArray(JsonReader reader) throws IOException {
     List<Double> doubles = new ArrayList<Double>();

     reader.beginArray();
     while (reader.hasNext()) {
       doubles.add(reader.nextDouble());
     }
     reader.endArray();
     return doubles;
   }

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

我们不难发现如下规律，每次读取数组或者对象之前，都必须调用beginObject()或者beginArray(),读完相应内容后，也必须调用endObject()或者endArray()。reader.hasNext()用来判断是否还有下一个元素，然后调用nextName来取下一个属性名，以及一系列的nextXXX来取相应的值。 
上面介绍的是将json字符串转换为java对象的用法，现在来看看如何使用JsonWriter来讲java对象转为json字符串。

   //将List<User>写入流中
   public void writeJsonStream(OutputStream out, List<User> users) throws IOException {
     JsonWriter writer = new JsonWriter(new OutputStreamWriter(out, "UTF-8"));
     writer.setIndent("    ");//设置缩进风格(设置后写入的字符串保持缩进风格，如果没有设置，将会顶格打印）
     writeUsersArray(writer, users);//写入List<User>
     writer.close();
   }

  //写入List<User>
   public void writeUsersArray(JsonWriter writer, List<User> users) throws IOException {
     writer.beginArray();//开始写入数组
     for (User user : users) {
       writeUser(writer, user);
     }
     writer.endArray();//结束写入数组
   }
   //写入User
   public void writeUser(JsonWriter writer, User user) throws IOException {
     writer.beginObject();//开始写入对象
     writer.name("name").value(user.getName());
     writer.name("age").value(user.getAge());
     if (user.getGeo() != null) {
       writer.name("geo");
       writeDoublesArray(writer, user.getGeo());
     } else {
       writer.name("geo").nullValue();
     }
     writer.endObject();//结束写入对象
   }

   public void writeDoublesArray(JsonWriter writer, List<Double> doubles) throws IOException {
     writer.beginArray();
     for (Double value : doubles) {
       writer.value(value);
     }
     writer.endArray();
   }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

JsonWriter用来写入JSON字符串的规则和JsonWriter大相径庭，每次写入数组或者对象之前，都必须调用beginObject()或者beginArray(),写完相应内容后，也必须调用endObject()或者endArray()。name(xx)用来写入名字，value(XX)用来写入值。 
接下来，深入浅出解析源码！stream包的结构如下： 
image_1amldac2a1qe33br1n9chm1n4s9.png-8.6kB 
枚举类JsonToken的源码如下，主要用于表示JSON字符串中的名字/值的结构。

public enum JsonToken {

  BEGIN_ARRAY,//JSON array开始

  END_ARRAY,//JSON array结束

  BEGIN_OBJECT,//JSON object开始

  END_OBJECT,//JSON object结束

  NAME,//JSON 属性名,JsonReader#nextName/JsonWriter#name

  STRING,//JSON 字符串

  NUMBER,//JSON 数字，代表java中double,long,int

  BOOLEAN,//JSON 布尔值

  NULL, //表示 null

  END_DOCUMENT //表示JSON流的结尾
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

JsonScope是一个常量类，元素词法作用域。用来标识JsonReader/JsonWriter现在读/写到哪了。

final class JsonScope {

    static final int EMPTY_ARRAY = 1;//没有元素的数组（相当于之前刚读了“[”），下一个元素一定不是逗号。


    static final int NONEMPTY_ARRAY = 2;//非空数组（至少已经有一个元素），下一个元素不是逗号就是“]”


    static final int EMPTY_OBJECT = 3;//空对象（刚读到“{”,一个name/value对都没有），下一个一定不是逗号。


    static final int DANGLING_NAME = 4;//名字，下一个元素一定是值。


    static final int NONEMPTY_OBJECT = 5;//非空对象（至少一个name/value对），下一个元素不是逗号就是“}”


    static final int EMPTY_DOCUMENT = 6;//空文档，初识状态，啥也没读


    static final int NONEMPTY_DOCUMENT = 7;//文档中有一个顶级的数组/对象


    static final int CLOSED = 8;//文档已被关闭
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
JsonWriter

JsonWriter，用于将Java对象写为JSON字符串。使用前我们可以进行一些默认的配置：

  //设置缩进符号，只要你设置了缩进符号，打印出来的字符串将会拥有缩进风格，非常漂亮
  public final void setIndent(String indent)
  //设置宽松的容错性（顶级值可以不是为object/array，数字可以为无穷）
  public final void setLenient(boolean lenient)
  //html转义
  public final void setHtmlSafe(boolean htmlSafe)
  //序列化空，默认true
  public final void setSerializeNulls(boolean serializeNulls) 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

JsonWriter使用一个数组来保存当前的写入状态（就是标识写到哪了），JsonScope中已经介绍过了。

  private int[] stack = new int[32];
  private int stackSize = 0;
  {
    push(EMPTY_DOCUMENT);
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

注意stack并没有定死32的长度，当写满时将会扩大一倍。使用push来保存当前写入状态，peek查看当前状态。

  //将当前状态保存栈顶
  private void push(int newTop) {
    if (stackSize == stack.length) {//如果满了就扩大一倍
      int[] newStack = new int[stackSize * 2];
      System.arraycopy(stack, 0, newStack, 0, stackSize);
      stack = newStack;
    }
    stack[stackSize++] = newTop;
  }

  //查看栈顶的值
  private int peek() {
    if (stackSize == 0) {
      throw new IllegalStateException("JsonWriter is closed.");
    }
    return stack[stackSize - 1];
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

在写一个对象之前，必须使用beginObject()。一定很好奇beginObject()做了什么，当时还不忙着看，先来看看怎么写入name/value的。 
name(XX)源码如下：

  public JsonWriter name(String name) throws IOException {
    if (name == null) {
      throw new NullPointerException("name == null");
    }
    if (deferredName != null) {
      throw new IllegalStateException();
    }
    if (stackSize == 0) {
      throw new IllegalStateException("JsonWriter is closed.");
    }
    deferredName = name;//赋值给deferredName
    return this;
  }

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

看完源码不由觉得有点失望，只是赋值给了deferredName，其他什么事也没做。那么到底什么时候写入name的。这还得从写入value看起。 
value(XX)有很多重载函数。 
image_1amlgoj7n7bv1s5u13f8cv2baqm.png-9.9kB 
我们只看value(String)这种。

  public JsonWriter value(String value) throws IOException {
    if (value == null) {//如果空的话，写入空值
      return nullValue();
    }
    writeDeferredName();//写入name。
    beforeValue();//写入“:”（会对上次状态进行校验）
    string(value);//写入value（会对特殊字符进行转码）
    return this;
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

通过writeDeferredName写入名字，beforeValue写入:,string写入真正的值。当然writeDeferredName也不是说直接写入name，而是先beforeName进行状态校验,换行，替换状态，按需写入,，然后使用string写入name值。

  private void writeDeferredName() throws IOException {
    if (deferredName != null) {
      beforeName();//校验等
      string(deferredName);//写入名字
      deferredName = null;
    }
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

现在来看看beginObject,如果该对象是name/value中的value,那么writeDeferredName用来写入name。open写入{以及更改栈顶状态。

    public JsonWriter beginObject() throws IOException {
    writeDeferredName();//写入name（如果有）
    return open(EMPTY_OBJECT, "{"); //写入“{”
  }
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

endObject则是调用close来写入},传入的EMPTY_OBJECT,EMPTY_OBJECT用来比较是在哪种状态下进行关闭的。

  public JsonWriter endObject() throws IOException {
    return close(EMPTY_OBJECT, EMPTY_OBJECT, "}");
  }
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

至于beginArray/endArray的源码这里就不赘述了。

JsonReader

JsonReader，用于将JSON字符串转为Java对象。 
JsonReader中的setLenient的容错性那可是非常厉害。以下错误都能被忽略。

  • )]}'\n 前缀
  • 多个顶级值
  • 顶级值不是 object/array类型
  • 数字类型为无穷数，或者不是个数字
  • 一行的结尾存在//或者 #注释
  • C语言风格的注释/…/
  • name用了单引号或者没用引号
  • string用了单引号或者没用引号
  • 数组元素的分隔符用了;而不是,
  • name和value不是用：分隔，而是用=或=>
  • name/value对之间不是逗号分隔，而是;分隔

和JsonWriter一样，也使用一个数组stack来保存当前的读取到的字符的类型和状态。其中引入了一系列的PEEKED_XXint常量来记录读取的字符类型。由于篇幅问题，JsonReader就不深入研究了，以下列出JsonReader中的核心方法。

  • fillBuffer 用来读取字符到buffer数组中
  • nextNonWhitespace 用来读取非空格/注释/换行等字符
  • peek() 查看元素类型，对应于JsonToken中的值。
  • doPeek() 内部使用了nextNonWhitespace读取一个字符，然后设置当前的读取的字符类型。
  • hasNext object/array中是不是还有下一个元素
  • nextName读取下一个name
  • nextString/nextInt/nextBoolean/nextLong/nextDouble/nextNull用来读取下一个对应的值。
  • skipValue 跳过下一个value
  • nextQuotedValue/nextUnquotedValue用来读取下一个单引号/双引号没有引号括起来的name或者string value
  • beginObject/endObject/beginArray/endArray 用来消费下一个对应类型的字符

Gson中的泛型

在了解Gson中的泛型前，我们来看两个类，$Gson$Types和$Gson$Preconditions。 
$Gson$Types，专门用来处理泛型类型。核心源码如下：

  //规范化类型
  public static Type canonicalize(Type type) {
    if (type instanceof Class) {//class
      Class<?> c = (Class<?>) type;
      return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

    } else if (type instanceof ParameterizedType) {//泛型
      ParameterizedType p = (ParameterizedType) type;
      return new ParameterizedTypeImpl(p.getOwnerType(),
          p.getRawType(), p.getActualTypeArguments());

    } else if (type instanceof GenericArrayType) {//数组类型
      GenericArrayType g = (GenericArrayType) type;
      return new GenericArrayTypeImpl(g.getGenericComponentType());

    } else if (type instanceof WildcardType) {//通配符类型
      WildcardType w = (WildcardType) type;
      return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

    } else {
      // type is either serializable as-is or unsupported
      return type;
    }
  }




  //获取原始类型
    public static Class<?> getRawType(Type type) {
    if (type instanceof Class<?>) {

      return (Class<?>) type;

    } else if (type instanceof ParameterizedType) {
      //泛型
      ParameterizedType parameterizedType = (ParameterizedType) type;

      Type rawType = parameterizedType.getRawType();
      checkArgument(rawType instanceof Class);
      return (Class<?>) rawType;

    } else if (type instanceof GenericArrayType) {
      //数组类型
      Type componentType = ((GenericArrayType)type).getGenericComponentType();
      return Array.newInstance(getRawType(componentType), 0).getClass();

    } else if (type instanceof TypeVariable) {
           //类型变量的上边界是Object
           return Object.class;

    } else if (type instanceof WildcardType) {
       //返回上边界
      return getRawType(((WildcardType) type).getUpperBounds()[0]);

    } else {
      String className = type == null ? "null" : type.getClass().getName();
      throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
          + "GenericArrayType, but <" + type + "> is of type " + className);
    }
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

canonicalize这个方法中返回了一系列的XXImpl，其实只是实现了java.io.Serializable接口，重写了equal方法而已。其中ParameterizedType/GenericArrayType/WildcardType,熟悉泛型的应该不会陌生，这里就不赘述了。

$Gson$Preconditions，这个类用于条件校验，源码很是简洁。

public final class $Gson$Preconditions {
  private $Gson$Preconditions() {
    throw new UnsupportedOperationException();
  }

  public static <T> T checkNotNull(T obj) {//校验非空
    if (obj == null) {
      throw new NullPointerException();
    }
    return obj;
  }

  public static void checkArgument(boolean condition) {//校验是不是满足条件
    if (!condition) {
      throw new IllegalArgumentException();
    }
  }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

现在回过来了解Gson中的泛型，Gson中用TypeToken来表示泛型。 
源码如下：

public class TypeToken<T> {
  final Class<? super T> rawType;//T的原始类型
  final Type type; //T 的类型
  final int hashCode;

  protected TypeToken() {
   //获取父类泛型的参数类型
    this.type = getSuperclassTypeParameter(getClass());
    //获取原始类型
    this.rawType = (Class<? super T>) $Gson$Types.getRawType(type);
    this.hashCode = type.hashCode();
  }

   public final Class<? super T> getRawType() {
    return rawType;
  }

  public final Type getType() {
    return type;
  }

  //..
  //省略了部分源码

  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

由于Java中只能通过getGenericSuperclass获取父类泛型类型，所以TypeToken必须new出一个子类Type type= new TypeToken<List<User>>(){}.getType();来使用。 
getSuperclassTypeParameter的源码如下：

  static Type getSuperclassTypeParameter(Class<?> subclass) {
    Type superclass = subclass.getGenericSuperclass();//获取父类泛型类型
    if (superclass instanceof Class) {
      throw new RuntimeException("Missing type parameter.");
    }
    ParameterizedType parameterized = (ParameterizedType) superclass;
    //获取泛型参数类型，即T的类型
    return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
  }

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

JsonElement

JsonElement，一个抽象类，代表着JSON中的元素类型。可以表示JsonObject，JsonArray，JsonPrimitive，JsonNull。换言之，Gson中的JsonObject/JsonArray/JsonPrimitive/JsonNull继承于JsonElement。JsonElement也提供了一系列的getAsXXX方法来获取元素。 
我们着重看一下JsonPrimitive，JsonPrimitive代表着java中的基本数据类型。可以看出，通过构造方法进行赋值，然后通过getAsXX取值。

public final class JsonPrimitive extends JsonElement {

//基本类型列表如下
  private static final Class<?>[] PRIMITIVE_TYPES = { int.class, long.class, short.class,
      float.class, double.class, byte.class, boolean.class, char.class, Integer.class, Long.class,
      Short.class, Float.class, Double.class, Byte.class, Boolean.class, Character.class };

  //值
  private Object value;

    public JsonPrimitive(Boolean bool) {
    setValue(bool);
  }

  //赋值数字类型
  public JsonPrimitive(Number number) {
    setValue(number);
  }

 //赋值String
  public JsonPrimitive(String string) {
    setValue(string);
  }

  //赋值字符
  public JsonPrimitive(Character c) {
    setValue(c);
  }

  //赋值给value
void setValue(Object primitive) {
    if (primitive instanceof Character) {

      char c = ((Character) primitive).charValue();
      this.value = String.valueOf(c);
    } else {
      $Gson$Preconditions.checkArgument(primitive instanceof Number
              || isPrimitiveOrString(primitive));
      this.value = primitive;
    }
  }
  //..
  //省略了部分源码
  }

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

Gson中的TypeAdapter

还记得介绍注解时提到的TypeAdapter吗？TypeAdapter是一个抽象类，可以用来自定义类型转换。源码如下。

public abstract class TypeAdapter<T> {

  //抽象方法，写value（an array, object, string, number, boolean or null）
  public abstract void write(JsonWriter out, T value) throws IOException;

 //抽象方法，读value
  public abstract T read(JsonReader in) throws IOException;

  //包装方法，帮你处理了空值，你可以不用担心空值问题
  public final TypeAdapter<T> nullSafe() {
    return new TypeAdapter<T>() {
      @Override public void write(JsonWriter out, T value) throws IOException {
        if (value == null) {//如果为空，写入null
          out.nullValue();
        } else {
          TypeAdapter.this.write(out, value);
        }
      }
      @Override public T read(JsonReader reader) throws IOException {
        if (reader.peek() == JsonToken.NULL) {
          reader.nextNull();
          return null;
        }
        return TypeAdapter.this.read(reader);
      }
    };
  }




  //..
  //省略了部分源码

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

我们只需继承于TypeAdapter，实现相应方法就能实现自己的TypeAdapter，前面我们介绍了使用注解方法来使用TypeAdapter，现在来讲一下在GsonBuilder中如何使用。

  Gson gson= new GsonBuilder()
                .registerTypeAdapter(XX.class,new XXTypeAdapter())
                .create();
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

在GsonBuilder中使用registerTypeAdapter配置后，就不需要使用相关注解了。那么问题来了，如果GsonBuilder和注解为同一个类配置了不同的TypeAdapter会发生什么状况？我可以很负责任的告诉你，注解的优先级是最高的。 
此外，我们之前在编写UserJsonAdapter时没有处理空值情况，很容易会抛出异常，那怎么办？一种是自己处理空值情况，将代码改成如下形式。

public class UserJsonAdapter extends TypeAdapter<User> {
@Override 
public void write(JsonWriter out, User user) throws IOException {
if (user == null) {//判断空值
    out.nullValue();
    retrun;
  }
 out.beginObject();
 out.name("name");
 out.value(user.firstName + " " + user.lastName);
 out.endObject();
}
@Override 
public User read(JsonReader in) throws IOException {
 if (reader.peek() == JsonToken.NULL) {//判断空值
         reader.nextNull();
         return null;
    }
 in.beginObject();
 in.nextName();
 String[] nameParts = in.nextString().split(" ");
 in.endObject();
 return new User(nameParts[0], nameParts[1]);
}
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

第二种方法，使用nullSafe:

 Gson gson= new GsonBuilder()
                .registerTypeAdapter(User.class,new UserJsonAdapter().nullSafe())
                .create();
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

TypeAdapterFactory是一个创造TypeAdapter的工厂，用来创造一些相似类型的TypeAdapter。

public interface TypeAdapterFactory {

  <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type);
}
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

继承TypeAdapter，需要重写write和read相关方法，可是只想处理序列化和反序列化中的一种该怎么办？那么接下来就该介绍JsonSerializer和JsonDeserializer接口了。可以在@JsonAdapter注解和registerTypeAdapter中注册使用。


//序列化
public interface JsonSerializer<T> {

  public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context);
}

//反序列化
public interface JsonDeserializer<T> {

  public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)throws JsonParseException;
}


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

序列化策略

  • LongSerializationPolicy 
    枚举类，指定长整型的序列化类型，默认有DEFAULT，STRING两种类型，可继承它实现其他类型

  • InstanceCreator 实例创造器 
    当反序列化时需要实例化对象，但是假如该对象没有默认构造方法怎么吧？那么就自定义自己的实例创造器。InstanceCreator一般配合ConstructorConstructor一起使用。

    public interface InstanceCreator<T> {

public T createInstance(Type type);
}
   
   
    • 1
    • 2
    • 3
    • 4
    
   
   
    • 1
    • 2
    • 3
    • 4
    class UserInstanceCreator implements InstanceCreator<User> {
public User createInstance(Type type) {
  return new User(null, -1);
}
}
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5

  • FieldNamingStrategy 
    提供了一个自定义的字段命名机制

    public interface FieldNamingStrategy {
public String translateName(Field f);
}

   
   
    • 1
    • 2
    • 3
    • 4
    
   
   
    • 1
    • 2
    • 3
    • 4

  • FieldNamingPolicy 
    一个枚举类，实现了FieldNamingStrategy，提供了一些默认的字段命名机制，IDENTITY：原始机制；UPPER_CAMEL_CASE：首字母大写的驼峰映射；UPPER_CAMEL_CASE_WITH_SPACES：用空格分隔的大写驼峰LOWER_CASE_WITH_UNDERSCORES：下划线相连的小写映射;LOWER_CASE_WITH_DASHES:虚线相连的小写映射。

  • FieldAttributes 
    用来存取字段的属性：getName获取字段名，getDeclaringClass获取声明的类，getDeclaredType获取字段的声明类型，getAnnotation获取注解。

  • ExclusionStrategy 
    一个用于定义排除策略的的接口。

    public interface ExclusionStrategy {
//是否应该忽略该属性
public boolean shouldSkipField(FieldAttributes f);
//是否应该忽略该类
public boolean shouldSkipClass(Class<?> clazz);
}

   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

其他

  • Excluder 排除器，主要用于根据策略和注解来判断哪些字段应该被忽略。 
    属性如下：

    private static final double IGNORE_VERSIONS = -1.0d;
public static final Excluder DEFAULT = new Excluder();
//默认忽略版本号
private double version = IGNORE_VERSIONS;
//默认以下修饰符的字段会被忽略
private int modifiers = Modifier.TRANSIENT | Modifier.STATIC;
private boolean serializeInnerClasses = true;//序列化内部类
private boolean requireExpose;//需要Expose注解？
//存放序列化排除策略
private List<ExclusionStrategy> serializationStrategies = Collections.emptyList();
//存放反序列化排除策略
private List<ExclusionStrategy> deserializationStrategies = Collections.emptyList();

   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    所有的方法如下: 
    image_1amm2a5vkurd1t6ku4412do8om9.png-45.5kB

  • Primitives 一个工具类，用于在原始类型和包装类型间转化。wrap包装，unwrap解开。

  • ObjectConstructor 一个人通用的构造器接口。

    public interface ObjectConstructor<T> {
  public T construct();
}
   
   
    • 1
    • 2
    • 3
    
   
   
    • 1
    • 2
    • 3

  • ConstructorConstructor 保存实例构造器集合的类

    public final class ConstructorConstructor {
 //实例创造器集合
 private final Map<Type, InstanceCreator<?>> instanceCreators;
 //通过类型返回一个构造器

public <T> ObjectConstructor<T> get(TypeToken<T> typeToken) {

final Type type = typeToken.getType();//获取类型
final Class<? super T> rawType = typeToken.getRawType();//获取真实类型

//首先从集合中获取看有没有相同的Type，有就创造实例并返回
final InstanceCreator<T> typeCreator = (InstanceCreator<T>) instanceCreators.get(type);
if (typeCreator != null) {
  return new ObjectConstructor<T>() {
    @Override public T construct() {
      return typeCreator.createInstance(type);
    }
  };
}


//然后根据原始类型取，去集合中取
final InstanceCreator<T> rawTypeCreator =
    (InstanceCreator<T>) instanceCreators.get(rawType);
if (rawTypeCreator != null) {
  return new ObjectConstructor<T>() {
    @Override public T construct() {
      return rawTypeCreator.createInstance(type);
    }
  };
}

//获取默认构造方法
ObjectConstructor<T> defaultConstructor = newDefaultConstructor(rawType);
if (defaultConstructor != null) {
  return defaultConstructor;
}

//获取集合类型的构造器（Collection，EnumSet，Set，Queue，Map）
ObjectConstructor<T> defaultImplementation = newDefaultImplementationConstructor(type, rawType);
if (defaultImplementation != null) {
  return defaultImplementation;
}

// 使用不安全的分配器
return newUnsafeAllocator(type, rawType);
}
 //..
 //省略了部分源码
 }
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    
   
   
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

  • JsonStreamParser 解析器，解析为JsonElement。hasNext:是否有下一个元素，next取下一个元素，返回JsonElement。

  • Streams 内部使用TypeAdapters.JSON_ELEMENT写入/读取下一个JsonElement。

GSON 源码解读

构造方法

现在我们从Gson的构造方法入手，解读Gson是如何工作的。

 Gson(final Excluder excluder, final FieldNamingStrategy fieldNamingStrategy,
      final Map<Type, InstanceCreator<?>> instanceCreators, boolean serializeNulls,
      boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe,
      boolean prettyPrinting, boolean lenient, boolean serializeSpecialFloatingPointValues,
      LongSerializationPolicy longSerializationPolicy,
      List<TypeAdapterFactory> typeAdapterFactories) {



    this.constructorConstructor = new ConstructorConstructor(instanceCreators);//实例构造器
    this.excluder = excluder;//排除器
    this.fieldNamingStrategy = fieldNamingStrategy;//字段命名策略
    this.serializeNulls = serializeNulls;//序列化空
    this.generateNonExecutableJson = generateNonExecutableGson;//生成不可执行前缀（用来防止攻击）
    this.htmlSafe = htmlSafe;//html转义
    this.prettyPrinting = prettyPrinting;//缩进打印
    this.lenient = lenient;//宽松的容错性

    List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();//TypeAdapter的工厂列表

    //以下都是往工厂列表加入TypeAdapterFactory

    // 构建不能被重载的TypeAdapter
    factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
    factories.add(ObjectTypeAdapter.FACTORY);

    // 排除器必须在所有的用于自定义的typeAdapter之前
    factories.add(excluder);

    //用户自定义的typeAdapter工厂
    factories.addAll(typeAdapterFactories);


    //以下为默认的TypeAdapter
    factories.add(TypeAdapters.STRING_FACTORY);
    factories.add(TypeAdapters.INTEGER_FACTORY);
    factories.add(TypeAdapters.BOOLEAN_FACTORY);
    factories.add(TypeAdapters.BYTE_FACTORY);
    factories.add(TypeAdapters.SHORT_FACTORY);
    TypeAdapter<Number> longAdapter = longAdapter(longSerializationPolicy);
    factories.add(TypeAdapters.newFactory(long.class, Long.class, longAdapter));
    factories.add(TypeAdapters.newFactory(double.class, Double.class,
            doubleAdapter(serializeSpecialFloatingPointValues)));
    factories.add(TypeAdapters.newFactory(float.class, Float.class,
            floatAdapter(serializeSpecialFloatingPointValues)));
    factories.add(TypeAdapters.NUMBER_FACTORY);
    factories.add(TypeAdapters.ATOMIC_INTEGER_FACTORY);
    factories.add(TypeAdapters.ATOMIC_BOOLEAN_FACTORY);
    factories.add(TypeAdapters.newFactory(AtomicLong.class, atomicLongAdapter(longAdapter)));
    factories.add(TypeAdapters.newFactory(AtomicLongArray.class, atomicLongArrayAdapter(longAdapter)));
    factories.add(TypeAdapters.ATOMIC_INTEGER_ARRAY_FACTORY);
    factories.add(TypeAdapters.CHARACTER_FACTORY);
    factories.add(TypeAdapters.STRING_BUILDER_FACTORY);
    factories.add(TypeAdapters.STRING_BUFFER_FACTORY);
    factories.add(TypeAdapters.newFactory(BigDecimal.class, TypeAdapters.BIG_DECIMAL));
    factories.add(TypeAdapters.newFactory(BigInteger.class, TypeAdapters.BIG_INTEGER));
    factories.add(TypeAdapters.URL_FACTORY);
    factories.add(TypeAdapters.URI_FACTORY);
    factories.add(TypeAdapters.UUID_FACTORY);
    factories.add(TypeAdapters.CURRENCY_FACTORY);
    factories.add(TypeAdapters.LOCALE_FACTORY);
    factories.add(TypeAdapters.INET_ADDRESS_FACTORY);
    factories.add(TypeAdapters.BIT_SET_FACTORY);
    factories.add(DateTypeAdapter.FACTORY);
    factories.add(TypeAdapters.CALENDAR_FACTORY);
    factories.add(TimeTypeAdapter.FACTORY);
    factories.add(SqlDateTypeAdapter.FACTORY);
    factories.add(TypeAdapters.TIMESTAMP_FACTORY);
    factories.add(ArrayTypeAdapter.FACTORY);
    factories.add(TypeAdapters.CLASS_FACTORY);


    //复合的TypeAdapter
    factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
    factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
    this.jsonAdapterFactory = new JsonAdapterAnnotationTypeAdapterFactory(constructorConstructor);
    factories.add(jsonAdapterFactory);
    factories.add(TypeAdapters.ENUM_FACTORY);
    factories.add(new ReflectiveTypeAdapterFactory(
        constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));

    this.factories = Collections.unmodifiableList(factories);
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

构造方法让人看的眼花缭乱，尤其是往集合中加入了那么多的TypeAdapterFactory。由于是在太多无法逐一介绍。就挑个最简单的来讲解。总之明白TypeAdapter的作用即可。 
ObjectTypeAdapter：内部有一个静态工厂类，所以只需ObjectTypeAdapter.FACTORY这样调用即可。

public final class ObjectTypeAdapter extends TypeAdapter<Object> {
  //工厂类
  public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() {
    //该工厂用来创建Object类型的TypeAdapter
    @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
      if (type.getRawType() == Object.class) {
        return (TypeAdapter<T>) new ObjectTypeAdapter(gson);
      }
      return null;
    }
  };
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

接口的实现方法如下：

//读取
 @Override public Object read(JsonReader in) throws IOException {
    JsonToken token = in.peek();//查看元素类型
    switch (token) {
    case BEGIN_ARRAY://数组
      List<Object> list = new ArrayList<Object>();
      in.beginArray();//开始标识
      while (in.hasNext()) {//还有下一个元素？
        list.add(read(in));
      }
      in.endArray();//结束标识
      return list;

    case BEGIN_OBJECT://对象
      Map<String, Object> map = new LinkedTreeMap<String, Object>();
      in.beginObject();
      while (in.hasNext()) {
        map.put(in.nextName(), read(in));
      }
      in.endObject();
      return map;

    case STRING:
      return in.nextString();

    case NUMBER:
      return in.nextDouble();

    case BOOLEAN:
      return in.nextBoolean();

    case NULL:
      in.nextNull();
      return null;

    default:
      throw new IllegalStateException();
    }
  }

  //写为json
  @Override public void write(JsonWriter out, Object value) throws IOException {
    if (value == null) {
      out.nullValue();
      return;
    }
    //gson.getAdapter获取对应类型的TypeAdapter
    TypeAdapter<Object> typeAdapter = (TypeAdapter<Object>) gson.getAdapter(value.getClass());
    if (typeAdapter instanceof ObjectTypeAdapter) {
      out.beginObject();
      out.endObject();
      return;
    }

    typeAdapter.write(out, value);
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

关于TypeAdapter这里就不继续深究了，预定义的TypeAdapter实在太多了。其中JsonAdapterAnnotationTypeAdapterFactory用来处理@JsonAdapter注解,ReflectiveTypeAdapterFactory用来反射获取字段等等。

getAdapter

将Java对象序列化为Json字符串时，需要调用gson.getAdapter(XX)来获取相应类型的转换器，然后按照TypeAdapter中规定好的规则进行序列化/反序列化。

 public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
    //从typeTokenCache的Map中取出
    //NULL_KEY_SURROGATE表示Object类型
    TypeAdapter<?> cached = typeTokenCache.get(type == null ? NULL_KEY_SURROGATE : type);
    if (cached != null) {
      return (TypeAdapter<T>) cached;
    }

   //threadCalls是一个中间线程变量
    Map<TypeToken<?>, FutureTypeAdapter<?>> threadCalls = calls.get();
    boolean requiresThreadLocalCleanup = false;
    if (threadCalls == null) {
      threadCalls = new HashMap<TypeToken<?>, FutureTypeAdapter<?>>();
      calls.set(threadCalls);
      requiresThreadLocalCleanup = true;
    }

     //取回FutureTypeAdapter，FutureTypeAdapter是一个代理TypeAdapter
    FutureTypeAdapter<T> ongoingCall = (FutureTypeAdapter<T>) threadCalls.get(type);
    if (ongoingCall != null) {
      return ongoingCall;
    }

    try {
    //new FutureTypeAdapter
      FutureTypeAdapter<T> call = new FutureTypeAdapter<T>();
      threadCalls.put(type, call);//放入线程变量中

     //从工厂中遍历，加入typeTokenCache
      for (TypeAdapterFactory factory : factories) {
        TypeAdapter<T> candidate = factory.create(this, type);//create创造实例
        if (candidate != null) {
          call.setDelegate(candidate);
          typeTokenCache.put(type, candidate);
          return candidate;
        }
      }
      throw new IllegalArgumentException("GSON cannot handle " + type);
    } finally {
      threadCalls.remove(type);

      if (requiresThreadLocalCleanup) {
        calls.remove();
      }
    }
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

以上源码的流程是这样的。首先从typeTokenCache中获取看看有没有相应类型的Adapter，第一次肯定没有，然后利用中间变量FutureTypeAdapter,从工厂中遍历去取，然后放入typeTokenCache中。FutureTypeAdapter是一个代理TypeAdapter,内部还是原TypeAdapter进行处理。

toJson

终于快接近尾声了，现在来看toJson方法的内部原理，到底是怎么一步步将对象转为Json字符串的。最终调用的是toJson(Object src, Type typeOfSrc, JsonWriter writer)方法，通过相应的Adapter进行读写。

  //传入一个Object
  public String toJson(Object src) {
    if (src == null) {
      return toJson(JsonNull.INSTANCE);
    }
    return toJson(src, src.getClass());//重载调用
  }

  //重载方法
  public String toJson(Object src, Type typeOfSrc) {
    StringWriter writer = new StringWriter();
    toJson(src, typeOfSrc, writer);
    return writer.toString();//返回String
  }

//将StringWriter转为JsonWriter。
public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException {
    try {
      JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer));//转为JsonWriter。
      toJson(src, typeOfSrc, jsonWriter);
    } catch (IOException e) {
      throw new JsonIOException(e);
    }
  }


  public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {
    //调用getAdapter获取相应类型的TypeAdapter。
    TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
    //设置配置
    boolean oldLenient = writer.isLenient();
    writer.setLenient(true);
    boolean oldHtmlSafe = writer.isHtmlSafe();
    writer.setHtmlSafe(htmlSafe);
    boolean oldSerializeNulls = writer.getSerializeNulls();
    writer.setSerializeNulls(serializeNulls);
    try {
      //调用adapter的write方法
      ((TypeAdapter<Object>) adapter).write(writer, src);
    } catch (IOException e) {
      throw new JsonIOException(e);
    } finally {
      writer.setLenient(oldLenient);
      writer.setHtmlSafe(oldHtmlSafe);
      writer.setSerializeNulls(oldSerializeNulls);
    }
  }

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
fromJson
  //传入一个json字符串和一个转换类型。
  public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {
    Object object = fromJson(json, (Type) classOfT);//调用重载
    return Primitives.wrap(classOfT).cast(object);//如果是基本数据类型还会被包装返回（即 int => Integer）
  }

 //重载方法 
    public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
    if (json == null) {
      return null;
    }
    StringReader reader = new StringReader(json)；//使用StringReader包装
    T target = (T) fromJson(reader, typeOfT);
    return target;
  }

  //重载方法，将StringReader转为JsonReader
  public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {
    JsonReader jsonReader = newJsonReader(json);
    T object = (T) fromJson(jsonReader, typeOfT);
    assertFullConsumption(object, jsonReader);//判断是不是读完了
    return object;
  }

 //最终方法
 public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
    boolean isEmpty = true;
    boolean oldLenient = reader.isLenient();
    reader.setLenient(true);
    try {
      reader.peek();
      isEmpty = false;
      //转为TypeToken
      TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
      //获取TypeAdapter
      TypeAdapter<T> typeAdapter = getAdapter(typeToken);
      //调用TypeAdapter的read
      T object = typeAdapter.read(reader);
      return object;
    } catch (EOFException e) {
     //..
     //省略部分源码
    } finally {
      reader.setLenient(oldLenient);
    }
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

GsonBuilder

GsonBuilder用来对Gson进行配置，比如注册TypeAdapter等等。最后调用create()返回Gson对象。 
image_1amn76ilalcs2usk3t1mjddmm9.png-55.7kB

最后

Gson内部的Json与Java间的转换依赖于各类的TypeAdapter，通过registerTypeAdapter可以注册新的类型转换器，实例创造器的等。越先注册的优先级就越高。当然，如果你没有注册Adapter，对于自定义的对象一般参与转换的Adapter是ReflectiveTypeAdapterFactory。有兴趣的请自行阅读源码。 
registerTypeAdapter的源码如下：

  public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
   //校验参数
    $Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>
        || typeAdapter instanceof JsonDeserializer<?>
        || typeAdapter instanceof InstanceCreator<?>
        || typeAdapter instanceof TypeAdapter<?>);
     //实例构造器   
    if (typeAdapter instanceof InstanceCreator<?>) {
      instanceCreators.put(type, (InstanceCreator) typeAdapter);
    }
    //序列化/反序列化
    if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {
      TypeToken<?> typeToken = TypeToken.get(type);
      factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));
    }
    //TypeAdapter
    if (typeAdapter instanceof TypeAdapter<?>) {
      factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter)typeAdapter));
    }
    return this;
  }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

本期解读到此结束，由于篇幅问题，Gson中预定义的TypeAdapter实在太多就不进行分析了。

yingzijk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gson源码.rar
09-14
谷歌gson源代码，对gson 框架有兴趣的人可以看下，经本人亲测完全好使 大多数开源库并没有对泛型提供完全的支持。于是,Gson在这两个重要的设计目标下诞生了
记录gson字符串转对象包含空格等特殊字符的异常解决！
qq_30806697的博客
06-02 2032
1、当你的json字符串中字段包含空格，转化对象时，会提示如下错误： 2、只需要先将字符串转化成gson即可 Gson gson = gson.toJson(); 3、然后再进行对象转换
Gson在将对象转为json数据时会将一些字符转义的处理办法
scropio0zry的博客
02-16 3822
Gson在将对象转为json时会将一些字符进行转义，事实上，这往往是我们不希望看到的   例如： https://freevod.vip.migu.cn/pz0pF0azYLAkTIwxVRlCge2WyvFpXcXdWgAPCg6rUk0CGthcXjkoJ8fy8W44M8aSHh7PDD/4VG82p2zmqwOzPR1aFaLNbnn1zE++wFwwU6Y8mKfQgasCLeZ9...
gson解析无固定模板的json串时value值出现两个双引号的解决方法
sinat_28765197的博客
07-10 7408
问题的场景：从json文件中读取数据然后进行增加字段并且排序后，重新写入json文件，发现原本的数据中出现“\"”。{"domain":{"mty":"\"hhy\"","mt":"hh"},"weight":{"mty":70,"mt":30}}原因：在解析含有字符串的数据时候通过JsonObject jsonObje
FastJosn转化JSON字符串有多余转移符的情况解决
皇甫嗷嗷叫
11-04 2025
FastJosn转化JSON字符串有多余转移符的情况解决 首先我说明前提情况：是因为你转换了一个本来就是一个 json格式的字符串，所以他会加上转义，话不多说直接上解决方案 public static void main(String[] args) { List<Map<String,Object>> list = new ArrayList<&...
google的gson源码
07-13
Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. Gson can work with arbitrary ...
gson最新源码
04-17
gson最新源码,从google网站搬来的
gson源码包
03-20
谷歌gson源代码，对gson 框架有兴趣的人可以看下
gson官方源码文档
05-09
GSON是Google开发的Java API，用于转换Java对象和Json对象 github.com下载地址https://github.com/google/gson/archive/master.zip gson源码文档
GSON源码完整版
03-23
gson完整源码gson完整源码gson完整源码
gson-2.8.5（包含源码）
08-27
google开源的一套json解析的库文件，是.jar格式，直接导入java工程中的lib目录即可使用。（最新版gson，专门用来解析json数据）
Gson源码解析之-fromJson
豌豆的专栏
03-16 2093
上面我们学习了gson 的序列化过程方法 toJson 的源码,相信对很多的流程有了一个了解，紧接着我们来学习下gson反序列化过程,fromJson .还是老样子，代码一点一点看。 我们先模拟一个反序列化过程 String json="{\"age\":30,\"name\":\"明\",\"len\":170]}"; TestMode jsTestMode=gson.fromJson(j...
Gson源码之Type和TypeToken
meijing11的博客
08-17 1261
Type 1.定义 是Java中所有类型的公共高级接口，代表了Java中的所有类型 2.类型体系 数组类型(GenericArrayType) 例如泛型数组 T[] 参数化类型(ParamterizedType) 例如list/map 类型变量(TypeVariable) 通配符类型(WildcardType) 例如 <?>. <? extend T> 原
Gson源码解析和它的设计模式
weixin_34032792的博客
03-21 222
前言 之前一段时间，准备把糗百的项目中json解析的模块中的原生Json解析换成gson解析，工作比较繁杂，坑多，因此为了防止出错，我还对Gson做了一个源码分析。这一篇就是Gson源码分析的总结，同时对Gson内部运用的设计模式也进行了总结，相信了解了它的源码和运行机制，对于使用Gson的使用会更有帮助。 Gson简介 Gson，就是帮助我们完成序列化和反序列化的工作的一个库。 日常用法 ...
gson java bean_用JavaBean添加GSON显示错误
weixin_31708613的博客
03-02 341
用JsonObject是正常的，用Gson就会显示这个{serializeNulls:falsefactories:[Factory[typeHierarchy=com.google.gson.JsonElement,adapter=com.google.gson.internal.bind.TypeAdapters$25@67424e82], com.google.gson.internal.b...
Gson 源码分析 总结
SunnyAndroider专栏
10-28 2905
1   Gson 的简单使用： 简单对象的序列化和反序列化： Gson gson = new Gson(); // Or use new GsonBuilder().create();MyType target = new MyType();String json = gson.toJson(target); // serializes target to JsonMyType t
Gson源码解析
成长的烧年
08-27 693
文章目录基础了解几个重要的概念1. 属性赋值/序列化2. Java类型适配器3. JsonReader源码分析1. Gson初始化2. 源码分析3. 整体回顾ObjectToJson后记 基础了解 最近在解决一个Json解析时，把Gson原理过了一遍。Gson是Google开发的Json解析库，当然这种轮子市面上比较多，也不一一列举了。今天主要来聊聊Gson源码，是如何解析一个Json对象，然后按照葫芦画瓢，将一个Java对象如何序列化成 Json对象。 几个重要的概念 在分析Gson源码之前，首先需要在脑
Gson源码分析
dsfllx的博客
03-17 306
楔子 目前项目中使用的json序列号依赖都是fastjson，但是由于fastjson漏洞频发，决定一律切换为Google的Gson。本以为不过是序列化反序列化而已，两个接口搞定，但是却出现了含有泛型的对象在反序列化时，int被转为double的情况（详情和解决方案可以参考博客Gson格式转换Integer变为Double类型问题解决），为了防止再发生类似的情况，对Gson的源码进行了一点简单的分析。 序列化介绍 在分析源码之前，先总结一些序列化的知识。serialization是将一个对象转为byte s
gson maven
最新发布
09-20
gson maven是一个用于 Java 开发的 Gson 库的依赖包，可以通过 Maven 来引用。你可以在以下链接中找到Gson的maven依赖包：http://repo1.maven.org/maven2/com/google/code/gson/gson/2.8.0/ 如果你想使用Gson库，你...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值