JSON解析之Gson

时间 2019-12-01

标签 json 解析 gson 栏目 JavaScript 繁體版

原文原文链接

1.Gson简介

　　Gson是一个将Java对象转为JSON表示的开源类库，由Google提供，而且也能够讲JSON字符串转为对应的Java对象。虽然有一些其余的开源项目也支持将Java对象转为JSON，但是有些须要把Java注解加到你的代码中，但是若是你不阅读源代码你是不清楚的，并且有些也不是彻底支持泛型的。而GSON在设计的时候把这两点都考虑在内了。GSON的目的就是：java

　　提供简单的toJson()和fromJson()方法将Java对象转为JSON，反之亦然apache

　　容许已存在的没法改变的类转换成JSON或者是从JSON转为json

　　大量的支持了Java泛型api

　　容许为对象定制表示方式数组

　　支持任意复杂的对象maven

2.引入相关jar包

　　最新版本是2.3，这个相应的jar包能够从maven中央仓库获取,下载连接（http://search.maven.org/remotecontent?filepath=com/google/code/gson/gson/2.3/gson-2.3.jar），不过若是不是经过直接添加jar包的方式获取的话能够经过maven或者是gradle,若是是经过maven，须要在pom.xml文件中加上环境配置ide

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.3</version>
</dependency>

若是是经过gradle那么只须要配置gradle

'com.google.code.gson:gson:2.3'

3.具体的实现

　　a):将json转为Java对象

　　Google json提供了两种方式来实现，第一种就是用 com.google.gson.Gson类，建立一个这个类的实例而后经过使用方法fromJson(String json, Class<T> classOfT)，classOfT 是JSON将要转为的java对象。第二种方式就是使用 com.google.gson.GsonBuilder 类，这个类容许设置一些特定的功能好比容许空序列化，建立一个GsonBuilder，而后设置完经过builder操做Gson类。 ui

咱们先来看下简单的GSON使用方法，操做的对象实体是Albums.javathis

public class Albums {
    
    private String title;
    private String message;
    private String[] errors = new String[]{};
    private String total;
    private int total_pages;
    private int page;
    private String limit;
    
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public String[] getErrors() {
        return errors;
    }
    public void setErrors(String[] errors) {
        this.errors = errors;
    }
    public String getTotal() {
        return total;
    }
    public void setTotal(String total) {
        this.total = total;
    }
    public int getTotal_pages() {
        return total_pages;
    }
    public void setTotal_pages(int total_pages) {
        this.total_pages = total_pages;
    }
    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
    public String getLimit() {
        return limit;
    }
    public void setLimit(String limit) {
        this.limit = limit;
    }

}

(须要注意的是errors在为实例化的时候已经赋值了为空值，这个后面有用

经过GSON操做JavaToJsonAndBack.java

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


public class JavaToJsonAndBack {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        GsonBuilder builder = new GsonBuilder();
        Gson gson = builder.create();
        
        // TODO Auto-generated method stub
        Albums albums = new Albums();
        albums.setTitle("Free Music Archive - Albums");
        albums.setMessage("");
        albums.setTitle("11259");
        albums.setTotal_pages(2252);
        albums.setPage(1);
        albums.setLimit("5");
        System.out.println("Albums");
        System.out.println(gson.toJson(albums));
        
    
    }

}

Albums
{"title":"11259","message":"","errors":[],"total_pages":2252,"page":1,"limit":"5"}

咱们注意到的是errors属性打印出来为空可是出现了，如今咱们作个小小的改动就是将pojo中Albums中的errors初始化值删掉而后再次运行main方法看打印出来的结果是什么

private String[] errors;


Albums
{"title":"11259","message":"","total_pages":2252,"page":1,"limit":"5"}

咱们却发现没有errors这个属性了这个是为何呢，这个是由于咱们在实例化的时候没有给errors赋初值，因此未能实现序列化因此没有值，那么咱们有什么办法能够讲errors这个属性即便是空值也可以打印出来呢，方法是有的那就是经过GsonBuilder

来定制，咱们设置即便为空也是序列化的.咱们将JavaToJsonAndBack.java作个简单修改

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


public class JavaToJsonAndBack {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        GsonBuilder builder = new GsonBuilder().serializeNulls();
        Gson gson = builder.create();
        
        // TODO Auto-generated method stub
        Albums albums = new Albums();
        albums.setTitle("Free Music Archive - Albums");
        albums.setMessage("");
        albums.setTitle("11259");
        albums.setTotal_pages(2252);
        albums.setPage(1);
        albums.setLimit("5");
        System.out.println("Albums");
        System.out.println(gson.toJson(albums));
        

    }

}

打印出来的结果是

Albums
{"title":"11259","message":"","errors":null,"total":null,"total_pages":2252,"page":1,"limit":"5"}

可见errors属性出来了，打出来为空

这个还能够经过注解的方式实现@SerializedName("")，还能够经过制定NamingStrategy

builder.setFieldNamingStrategy(new FieldNamingStrategy() {
 
            @Override
            public String translateName(Field f) {
                if (f.getName().equals("albumId"))
                    return "album_id";
                else
                    return f.getName();
            }
        });

b):标记解析

　　经过a咱们知道了若是将一个Java对象转为JSON的两种方式，下面介绍下如何解析JSON已经处理特殊的符号，尽管经过JSON构建Java对象看起来是一个很难完成的，可是若是你须要较高级别的去控制这个转化过程的话，它仍是很强大的并且是个不错的选择。这个是具备咱们经过JsonReader去读取JSON流，下面是一个举例。ParseTokenExample.java

import java.io.IOException;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;
 
import org.apache.commons.io.IOUtils;
 
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
 
public class ParseTokenExample{
    public static void main(String[] args) throws MalformedURLException, IOException {
        String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";
        String json = IOUtils.toString(new URL(url));
        //使用reader去读取json

        JsonReader reader = new JsonReader(new StringReader(json));
 
　　　　//调用处理对象的方法去处理完整的json对象

        handleObject(reader);
    }

    /**
     *处理对象，假设第一个标记是BEGIN_OBJECT,在对象内部即有多是数组也有可能不是，咱们须要处理这
　   *两种状况，须要注意peek()方法，它用于一般用于找出下个标记的类型
     * @param reader
     * @throws IOException
     */

    private static void handleObject(JsonReader reader) throws IOException {         reader.beginObject();         while (reader.hasNext()) {             JsonToken token = reader.peek();             if (token.equals(JsonToken.BEGIN_ARRAY))                 handleArray(reader);             else if (token.equals(JsonToken.END_ARRAY)) {                 reader.endObject();                 return;             } else                 handleNonArrayToken(reader, token);         }       }       /**
　　　*处理json数组，第一个标记是 JsonToken_BEGIN_ARRAY,数组可能包含对象或者基本原始类型      *      * @param reader      * @throws IOException      */     public static void handleArray(JsonReader reader) throws IOException {         reader.beginArray();         while (true) {             JsonToken token = reader.peek();             if (token.equals(JsonToken.END_ARRAY)) {                 reader.endArray();                 break;             } else if (token.equals(JsonToken.BEGIN_OBJECT)) {                 handleObject(reader);             } else                 handleNonArrayToken(reader, token);         }     }       /**      * 处理不是数组的符号标记      *      * @param reader      * @param token      * @throws IOException      */     public static void handleNonArrayToken(JsonReader reader, JsonToken token) throws IOException {         if (token.equals(JsonToken.NAME))             System.out.println(reader.nextName());         else if (token.equals(JsonToken.STRING))             System.out.println(reader.nextString());         else if (token.equals(JsonToken.NUMBER))             System.out.println(reader.nextDouble());         else             reader.skipValue();     } }

c）:将JSON对象转为java对象树

　　咱们能够从一个json串来构建JsonElement（com.google.gson.JsonElement）树，而后这个树能够转为java对象，JsonElement 含有isJsonObjec()以及isJsonNull()方法等等，这些方法能够识别出JsonElement的类型。而后经过getAsJsonObject()和getAsJsonPrimitive()方法能够获取真正的java对象。举例说明：ParseTreeExample.java

 
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
 
import org.apache.commons.io.IOUtils;
 
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
 
public class ParseTreeExample6 {
    public static void main(String[] args) throws MalformedURLException, IOException {
        String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";
        String json = IOUtils.toString(new URL(url));
        JsonParser parser = new JsonParser();
　　　　　//JsonElement是根节点，它多是一个对象数组为空或者java原始类型　
        JsonElement element = parser.parse(json);
        // 使用isxxx方法来找出jsonelement的类型，在咱们的例子中咱们知道跟对象是Albums对象而且包含数组对象
        if (element.isJsonObject()) {
            JsonObject albums = element.getAsJsonObject();
            System.out.println(albums.get("title").getAsString());
            JsonArray datasets = albums.getAsJsonArray("dataset");
            for (int i = 0; i < datasets.size(); i++) {
                JsonObject dataset = datasets.get(i).getAsJsonObject();
                System.out.println(dataset.get("album_title").getAsString());
            }
        }
 
    }
}

d):序列化List

　　Gson提供了com.google.gson.reflect.TypeToken这个类用于存储泛型类型，举例GenericTypesExample.java

import java.lang.reflect.Type;
 
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
 
public class GenericTypesExample{
    public static void main(String[] args) {
        Animal<dog> animal = new Animal<Dog>();
        Dog dog = new Dog("I am a dog");
 
        animal.setAnimal(dog);
        Gson gson = new Gson();
        //定义一个类型
        Type animalType = new TypeToken<Animal<Dog>>() {
        }.getType();
 
        // 咱们首先将animal对象转为json而后从这个json读取回来，可是咱们把json定义一个Animal类型
        Animal animal1 = gson.fromJson(gson.toJson(animal, animalType), Animal.class);
        System.out.println(animal1.get().getClass()); 
                                                      
 
        
        Animal animal2 = gson.fromJson(gson.toJson(animal), animalType);
        System.out.println(animal2.get().getClass());
      
 
    }
}

Animal.java

public class Animal<T> {
 
    public T animal;
 
    public void setAnimal(T animal) {
        this.animal = animal;
    }
 
    public T get() {
        return animal;
    }
 
}

Dog.java

public class Dog {
    private String name;
 
    public Dog(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
}

e):序列化内部类

　　Gson可以序列化内部类和静态嵌套类，经过下面这个例子咱们能够看到

　　　　1.序列化含有静态嵌套类

　　　　2.序列化含有非静态嵌套类

　　　　3.反序列化json到一个含有静态非静态内部类的类

　　　　4.序列化静态嵌套类

　　　　5.序列化非静态嵌套类

　　　　6.反序列化json到一个静态嵌套类

　　　　7.反序列化json到一个非静态嵌套类

　　举例:SerializeInnerClassExample.java

 
import java.lang.reflect.Modifier;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import AlbumsWithInnerClass.Dataset;
import AlbumsWithInnerClass.Dataset2;
 
public class SerializeInnerClassExample {
    public static void main(String[] args) {
        // 建立一个含有静态潜逃类和非静态嵌套类的Albums类
        AlbumsWithInnerClass albums = new AlbumsWithInnerClass();
        albums.setName("SerializeInnerClass");
        //建立一个dataset.由于它不是一个非静态的嵌套类，因此咱们须要一个闭合的类型
        Dataset dataset = albums.new Dataset();
        dataset.setAlbum_id("1");
        dataset.setAlbum_name("albums1");
        // 将datasets set到 albums中去
        albums.setDatasetsInner(new Dataset[] { dataset });
 
        // 静态的内部类可以被建立而不须要闭合的类型
        Dataset2 dataset2 = new Dataset2();
        dataset2.setAlbum_id("2");
        dataset2.setAlbum_name("albums2");
        albums.setDatasetsStatic(new Dataset2[] { dataset2 });
 
        // 建立 GsonBuilder
        GsonBuilder builder = new GsonBuilder();
       
        builder.excludeFieldsWithModifiers(Modifier.PRIVATE);
        Gson gson = builder.create();
 
        
        String json = gson.toJson(albums);
        System.out.println(json);
        // 打印的结果为
        // {"name":"SerializeInnerClass","datasetsInner":[{"album_name":"SerializeInnerClass_albums1","album_id":"1"}],
        // "datasetsStatic":[{"album_name":"albums2","album_id":"2"}]}
 
        
        Gson gson3 = new Gson();
        AlbumsWithInnerClass parsedAlbums = gson3.fromJson(json, AlbumsWithInnerClass.class);
        System.out.println(parsedAlbums.datasetsInner[0].album_name);
       
        System.out.println(parsedAlbums.datasetsStatic[0].album_name);
        
 
       
        Gson gson2 = new Gson();
        String json2 = gson2.toJson(dataset);
        System.out.println(json2);
        //打印的结果为 {"album_name":"SerializeInnerClass_albums1","album_id":"1"}
 
    
        String json3 = gson2.toJson(dataset2);
        System.out.println(json3);
        // 打印的结果为 {"album_name":"albums2","album_id":"2"}
 
        // 从json字符串中建立一个内部类
        Gson gson4 = new Gson();
        Dataset parsedDataset = gson4.fromJson(json2, Dataset.class);
        System.out.println(parsedDataset.getClass());
        // 打印结果class com.studytrails.json.gson.AlbumsWithInnerClass$Dataset
        System.out.println(parsedDataset.album_name);
        // 打印结果 SerializeInnerClass_albums1
 
        // 从json中建立一个嵌套的静态类
        Dataset2 parsedStaticNestedClass = gson4.fromJson(json3, Dataset2.class);
        System.out.println(parsedStaticNestedClass.getClass());
        // 打印结果 class com.studytrails.json.gson.AlbumsWithInnerClass$Dataset2
        System.out.println(parsedStaticNestedClass.album_name);
        // 打印结果 albums2
 
    }
}

　　AlbumsWithInnerClass.java

public class AlbumsWithInnerClass {
    public String name;
    private String year;
    public Dataset[] datasetsInner;
    public Dataset2[] datasetsStatic;
 
    public void setDatasetsInner(Dataset[] datasetsInner) {
        this.datasetsInner = datasetsInner;
    }
 
    public void setDatasetsStatic(Dataset2[] datasetsStatic) {
        this.datasetsStatic = datasetsStatic;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setYear(String year) {
        this.year = year;
    }
 
    class Dataset {
        public String album_name;
        public String album_id;
 
        public void setAlbum_id(String album_id) {
            this.album_id = album_id;
        }
 
        public void setAlbum_name(String album_name) {
            this.album_name = name + "_" + album_name;
        }
    }
 
    static class Dataset2 {
        public String album_name;
        public String album_id;
 
        public void setAlbum_id(String album_id) {
            this.album_id = album_id;
        }
 
        public void setAlbum_name(String album_name) {
            this.album_name = album_name;
        }
    }
}

f):自定义类型适配器

　　自定义类型适配器须要继承com.google.gson.TypeAdapter这个抽象类，实现方法有 public abstract T read(JsonReader in) throws IOException; and public abstract void write(JsonWriter out, T value) throws IOException;你定义的适配器可以处理空值，建立适配器实例后须要在GsonBuilder里面注册，而后经过GsonBuilder来建立Json对象，用于序列化和反序列化操做。举例：

DatasetTypeAdapterExample.java

 
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
 
import org.apache.commons.io.IOUtils;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class DatasetTypeAdapterExample {
 
    public static void main(String[] args) throws MalformedURLException, IOException {
        String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";
        String json = IOUtils.toString(new URL(url));
        // 建立自定义心里适配器而且把它注册到 GsonBuilder
        Gson gson = new GsonBuilder().registerTypeAdapter(Dataset.class, new DatasetTypeAdapter()).create();
    
        Albums albums = gson.fromJson(json, Albums.class);
        System.out.println(albums.getDataset()[1].getAlbum_title());

    }
}

DatasetTypeAdapter.java

import java.io.IOException;
 
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
 

public class DatasetTypeAdapter extends TypeAdapter<Dataset> {
    @Override
    public Dataset read(JsonReader reader) throws IOException {
       
        JsonToken token = reader.peek();
        Dataset dataset = new Dataset();
        if (token.equals(JsonToken.BEGIN_OBJECT)) {
            reader.beginObject();
            while (!reader.peek().equals(JsonToken.END_OBJECT)) {
                if (reader.peek().equals(JsonToken.NAME)) {
                    if (reader.nextName().equals("album_url"))
                        dataset.setAlbum_title(reader.nextString());
                    else
                        reader.skipValue();
 
                }
            }
            reader.endObject();
 
        }
        return dataset;
    }
 
    @Override
    public void write(JsonWriter out, Dataset value) throws IOException {
 
    }
 
}

Albums.java

public class Albums {
 
    private String title;
    private Dataset[] dataset;
 
    public void setTitle(String title) {
        this.title = title;
    }
 
    public void setDataset(Dataset[] dataset) {
        this.dataset = dataset;
    }
 
    public String getTitle() {
        return title;
    }
 
    public Dataset[] getDataset() {
        return dataset;
    }
}

g):自定义序列化器

　　建立一个自定义的序列化器须要实现com.studytrails.json.gson.JsonSerializer 接口，而后实现 public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context); 方法，src 是指源对象，Type 是指源对象的类型，举例：

DogSerializer.java

 
import java.lang.reflect.Type;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.reflect.TypeToken;
 
public class DogSerializer implements JsonSerializer<dog> {
    @Override
    public JsonElement serialize(Dog src, Type typeOfSrc, JsonSerializationContext context) {
    
        JsonObject object = new JsonObject();
        String name = src.getName().replaceAll(" ", "_");
        object.addProperty("name", name);
    
        return object;
    }
 
    public static void main(String[] args) {
        Animall<Dog> animal = new Animall<Dog>();
        Dog dog = new Dog("I am a dog");
        animal.setAnimal(dog);

        Gson gson = new GsonBuilder().registerTypeAdapter(Dog.class, new DogSerializer()).setPrettyPrinting().create();

        Type animalType = new TypeToken<Animal<Dog>>() {
        }.getType();
        System.out.println(gson.toJson(animal, animalType));
    }
}

Animal.java

public class Animal<t> {
 
    public T animal;
 
    public void setAnimal(T animal) {
        this.animal = animal;
    }
 
    public T get() {
        return animal;
    }
 
}

Dog.java

public class Dog {
    private String name;
 
    public Dog(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
}

h):自定义反序列化器

　　建立一个反序列化器须要实现的方法有 public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException;举例：

　　DogDeserialiser.java

 
import java.lang.reflect.Type;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;
 
public class DogDeserialiser implements JsonDeserializer<Dog> {
    @Override
    public Dog deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        String name = json.getAsJsonObject().get("name").getAsString();
        name = name.replace(" ", "_");
        Dog dog = new Dog(name);
 
        return dog;
    }
 
    public static void main(String[] args) {
        String json = "{\"animal\":{\"name\":\"I am a dog\"}}";
        Gson gson = new GsonBuilder().registerTypeAdapter(Dog.class, new DogDeserialiser()).create();
        Type animalType = new TypeToken<Animal<Dog>>() {
        }.getType();
        Animal<Dog> animal = gson.fromJson(json, animalType);
        System.out.println(animal.get().getName());
    }
 
}

i):GSON扩展策略

　　在缺省的状况下，GSON试着将java对象中的全部属性映射到json中相一致的属性中。可是在一些特殊的状况下咱们尝试去控制这个操做。这个是有一些方法实现的。

　　1.经过自定义注解的方式而且忽略被注解的域。

　　2.经过集成ExclusionStrategy 接口的方式自定义来实现，须要实现的方法有public boolean shouldSkipField(FieldAttributes f); and public boolean 　　shouldSkipClass(Class clazz);

　　3.经过使用@Expose 注解，而后在GsonBuilder上面使用excludeFieldsWithoutExposeAnnotation（），这个方法，除非使用 @Expose 这个注解，否　则咱们忽略全部的域。

　　举例：ExclusionExample.java

 
import java.awt.Color;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class ExclusionExample {
    public static void main(String[] args) {
        
        Cat cat = new Cat();
        cat.setName("Cat");
        cat.setAge(1);
        cat.setColor(Color.BLACK);
        cat.setCountry("US");

        Gson gson = new GsonBuilder().serializeNulls().setExclusionStrategies(new CustomExclusionStrategy(Color.class))
                .excludeFieldsWithoutExposeAnnotation().create();
        System.out.println(gson.toJson(cat));
        // 打印结果 {"name":"Cat","lazy":null}
 
    }
}

Cat.java

import java.awt.Color;
 
import com.google.gson.annotations.Expose;
 
public class Cat {
    @Expose
    private String name;
    private int age;
    private Color color;
    @Expose
    @Country
    private String country;
    @Expose
    private Boolean lazy = null;
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setColor(Color color) {
        this.color = color;
    }
 
    public int getAge() {
        return age;
    }
 
    public String getName() {
        return name;
    }
 
    public Color getColor() {
        return color;
    }
 
    public void setCountry(String country) {
        this.country = country;
    }
 
    public String getCountry() {
        return country;
    }
 
    public void setLazy(Boolean lazy) {
        this.lazy = lazy;
    }
 
    public Boolean getLazy() {
        return lazy;
    }
}

CustomExclusionStrategy.java

 
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
 

public class CustomExclusionStrategy implements ExclusionStrategy {
 
    private Class classToExclude;
 
    public CustomExclusionStrategy(Class classToExclude) {
        this.classToExclude = classToExclude;
    }
 

    @Override
    public boolean shouldSkipField(FieldAttributes f) {
        if (f.getAnnotation(Country.class) == null)
            return false;
 
        return true;
    }

    @Override
    public boolean shouldSkipClass(Class<?> clazz) {
        if (clazz.equals(classToExclude))
            return true;
        return false;
    }
 
}

4.结束

　　Gson功能的强大可见一斑，并且非常简介，毕竟是大牌厂商的产品，果真是不同，固然还有不少功能有待挖掘，最好的是阅读源码，这样能够收获更大。