Gson 源码解读

开源库地址：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);
  • 对象
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);
  • 泛型
Type type= new TypeToken<List<User>>(){}.getType();
List<User> list = gson.fromJson(json, type);
  • 配置Gson
  Gson gson=new GsonBuilder()
                 .setLenient() //设置宽松的容错性
                 .setPrettyPrinting() //设置漂亮的打印（打印出来的有缩进风格）
                 .setVersion(..) //设置当前版本号
                 ...
                 .create();

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;//不参与
}
  • @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;
}
}

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

    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"}

    这个注解有什么好处呢？众所周知，在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时才会参与序列化/反序列化，否则忽略
}
  • @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时参加序列化/反序列化
 }
  • @JsonAdapter

    表示在某一个成员变量或者类上使用TypeAdapter。至于TypeAdapter是什么东东，后面介绍。举个例子：

    假如有个User类如此下:

     public class User {
  public final String firstName, lastName;
  private User(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
 }
}

    准备编写一个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]);
}
}

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

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

    将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;
 }
}

JsonReader/JsonWriter

在Gson中，Java对象与JSON字符串之间的转换是通过字符流来进行操作的。JsonReader继承于Reader用来读取字符，JsonWriter继承于Writer用来写入字符。

假如，现在有如下一段JSON数据用来表示一个用户列表。name为名字,age为年龄,geo为定位的经纬度。如何使用JsonReader转为java对象？

首先查看一下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;
   }

我们不难发现如下规律，每次读取数组或者对象之前，都必须调用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();
   }

JsonWriter用来写入JSON字符串的规则和JsonWriter大相径庭，每次写入数组或者对象之前，都必须调用beginObject()或者beginArray(),写完相应内容后，也必须调用endObject()或者endArray()。name(xx)用来写入名字，value(XX)用来写入值。

接下来，深入浅出解析源码！stream包的结构如下：

枚举类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流的结尾
}

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;//文档已被关闭
}

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)

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

  private int[] stack = new int[32];
  private int stackSize = 0;
  {
    push(EMPTY_DOCUMENT);
  }

注意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];
  }

在写一个对象之前，必须使用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;
  }

看完源码不由觉得有点失望，只是赋值给了deferredName，其他什么事也没做。那么到底什么时候写入name的。这还得从写入value看起。

value(XX)有很多重载函数。

我们只看value(String)这种。

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

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

  private void writeDeferredName() throws IOException {
    if (deferredName != null) {
      beforeName();//校验等
      string(deferredName);//写入名字
      deferredName = null;
    }
  }

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

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

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

  public JsonWriter endObject() throws IOException {
    return close(EMPTY_OBJECT, EMPTY_OBJECT, "}");
  }

至于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);
    }
  }

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();
    }
  }
}

现在回过来了解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;
  }

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

  }

由于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]);
  }

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;
    }
  }
  //..
  //省略了部分源码
  }

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);
      }
    };
  }

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

}

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

  Gson gson= new GsonBuilder()
                .registerTypeAdapter(XX.class,new XXTypeAdapter())
                .create();

在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]);
}
}

第二种方法，使用nullSafe:

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

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

public interface TypeAdapterFactory {

  <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type);
}

继承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;
}

序列化策略

  • LongSerializationPolicy

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

  • InstanceCreator 实例创造器

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

    public interface InstanceCreator<T> {

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

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

    public interface FieldNamingStrategy {
public String translateName(Field f);
}
  • 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);
}

其他

  • 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();

    所有的方法如下:

  • Primitives 一个工具类，用于在原始类型和包装类型间转化。wrap包装，unwrap解开。
  • ObjectConstructor 一个人通用的构造器接口。 
    public interface ObjectConstructor<T> {
  public T construct();
}
  • 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);
}
 //..
 //省略了部分源码
 }
  • 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);
  }

构造方法让人看的眼花缭乱，尤其是往集合中加入了那么多的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;
    }
  };

接口的实现方法如下：

//读取
 @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);
  }

关于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();
      }
    }
  }

以上源码的流程是这样的。首先从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);
    }
  }

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);
    }
  }

GsonBuilder

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

最后

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;
  }

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

时间： 2024-10-01 07:50:20

Gson 源码解读的相关文章

Retrofit2 源码解读

开源库地址:https://github.com/square/retrofit 解读版本:2.1.0 基本概念 Retrofit 是一个针对Java/Android类型安全的Http请求客户端. 基本使用如下: 首先定义一个接口,抽象方法的返回值必须为Call<XX>. public interface GitHubService { @GET("users/{user}/repos") Call<List<Repo>> listRepos(@Pa

PhotoView 源码解读

开源库地址:https://github.com/chrisbanes/PhotoView PhotoView是一个用来帮助开发者轻松实现ImageView缩放的库.开发者可以轻易控制对图片的缩放旋等等操作. PhotoView的使用极其简单,而且提供了两种方案.可以使用普通的ImageView,也可以使用该库中提供的ImageView(PhotoView). 使用PhotoView 只需如下引用该库中的ImageView,无需关心其它实现细节,你的ImageView便可拥有缩放效果. <uk.

QCustomplot使用分享(二) 源码解读

一.头文件概述 从这篇文章开始,我们将正式的进入到QCustomPlot的实践学习中来,首先我们先来学习下QCustomPlot的类图,如果下载了QCustomPlot源码的同学可以自己去QCustomPlot的目录下documentation/qcustomplot下寻找一个名字叫做index.html的文件,将其在浏览器中打开,也是可以找到这个库的类图.如图1所示,是组成一个QCustomPlot类图的可能组成形式. 一个图表(QCustomPlot):包含一个或者多个图层.一个或多个ite

vue源码解读预热-0

vueJS的源码解读 vue源码总共包含约一万行代码量(包括注释)特别感谢作者Evan You开放的源代码,访问地址为Github 代码整体介绍与函数介绍预览 代码模块分析 代码整体思路 总体的分析 从图片中可以看出的为采用IIFE(Immediately-Invoked Function Expression)立即执行的函数表达式的形式进行的代码的编写 常见的几种插件方式: (function(,){}(,))或(function(,){})(,)或!function(){}()等等,其中必有

SpringMVC源码解读 - RequestMapping注解实现解读 - RequestCondition体系

一般我们开发时,使用最多的还是@RequestMapping注解方式. @RequestMapping(value = "/", param = "role=guest", consumes = "!application/json") public void myHtmlService() { // ... } 台前的是RequestMapping ,正经干活的却是RequestCondition,根据配置的不同条件匹配request. @Re

jdk1.8.0_45源码解读——HashMap的实现

jdk1.8.0_45源码解读——HashMap的实现 一.HashMap概述 HashMap是基于哈希表的Map接口实现的,此实现提供所有可选的映射操作.存储的是<key,value>对的映射,允许多个null值和一个null键.但此类不保证映射的顺序,特别是它不保证该顺序恒久不变.  除了HashMap是非同步以及允许使用null外,HashMap 类与 Hashtable大致相同. 此实现假定哈希函数将元素适当地分布在各桶之间,可为基本操作(get 和 put)提供稳定的性能.迭代col

15、Spark Streaming源码解读之No Receivers彻底思考

在前几期文章里讲了带Receiver的Spark Streaming 应用的相关源码解读,但是现在开发Spark Streaming的应用越来越多的采用No Receivers(Direct Approach)的方式,No Receiver的方式的优势: 1. 更强的控制自由度 2. 语义一致性 其实No Receivers的方式更符合我们读取数据,操作数据的思路的.因为Spark 本身是一个计算框架,他底层会有数据来源,如果没有Receivers,我们直接操作数据来源,这其实是一种更自然的方式

jdk1.8.0_45源码解读——Set接口和AbstractSet抽象类的实现

jdk1.8.0_45源码解读——Set接口和AbstractSet抽象类的实现 一. Set架构 如上图: (01) Set 是继承于Collection的接口.它是一个不允许有重复元素的集合.(02) AbstractSet 是一个抽象类,它继承于AbstractCollection.AbstractCollection实现了Set中的绝大部分函数,为Set的实现类提供了便利.(03) HastSet 和 TreeSet 是Set的两个实现类.        HashSet依赖于HashMa

线程本地变量ThreadLocal源码解读

  一.ThreadLocal基础知识   原始线程现状: 按照传统经验,如果某个对象是非线程安全的,在多线程环境下,对对象的访问必须采用synchronized进行线程同步.但是Spring中的各种模板类并未采用线程同步机制,因为线程同步会影响并发性和系统性能,而且实现难度也不小. ThreadLocal在Spring中发挥着重要的作用.在管理request作用域的bean,事务管理,任务调度,AOP等模块中都出现了它的身影. ThreadLocal介绍: 它不是一个线程,而是线程的一个本地化