完全理解Gson（2）：Gson序列化

最新推荐文章于 2024-02-22 19:58:06 发布
最新推荐文章于 2024-02-22 19:58:06 发布
阅读量612 收藏
点赞数
分类专栏： java基础 WEB前端 文章标签： gson java

通过调用 Gson API 可以把 Java 对象转换为 JSON 格式的字符串（项目主页）。在这篇文章中，我们将会讲到如何通过 Gson 默认实现和自定义实现方式，将 Java  对象转换为 JSON 字符串。

对于那些不熟悉 Gson 的读者，建议在读本篇文章之前读一下这两篇文章： 简单 Gson 实例和  Gson 反序列化实例。另外，这篇文章的讲述方式和 Gson反序列化实例一样，并且使用了相同的例子。

注意

请注意，在文章中我们将互换格式化或序列化的术语。

下面列出的所有代码都可以在这里找到： http://java-creed-examples.googlecode.com/svn/gson/Gson Serialiser Example/ 。大多数例子不会包含完整的代码，可能会忽略和要讨论的例子不相关的片段。读者可以从上面的链接下载查看完整的代码。

简单的例子

考虑下面这个 Java 对象。

1
2
3
4
5
6
7
8
9
10
11
12
package com.javacreed.examples.gson.part1;
 
public class Book {
 
   private String[] authors;
   private String isbn10;
   private String isbn13;
   private String title;
 
   // Methods removed for brevity
 
}

这个简单的 Java 类封装了一本书的属性。假如我们需要将其序列化为下面这个 JSON 对象。

1
2
3
4
5
6
7
8
9
{
   "title" : "Java Puzzlers: Traps, Pitfalls, and Corner Cases" ,
   "isbn-10" : "032133678X" ,
   "isbn-13" : "978-0321336781" ,
   "authors" : [
     "Joshua Bloch" ,
     "Neal Gafter"
   ]
}

Gson 不需要任何特殊配置就可以序列化 Book 类。Gson 使用 Java 字段名称作为 JSON 字段的名称，并赋予对应的值。如果仔细地看一下上面的那个 JSON 示例会发现， ISBN 字段包含一个减号：isbn-10 和 isbn-13。不幸的是，使用默认配置不能将这些字段包含进来。解决问题的办法之一就是使用注解，就像在这篇文章中描述的那样：Gson 注解示例。使用注解可以自定义 JSON 字段的名称，Gson将会以注解为准进行序列化。另一个方法就是使用 JsonSerialiser （Java Doc），如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.javacreed.examples.gson.part1;
 
import java.lang.reflect.Type;
 
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
 
public class BookSerialiser implements JsonSerializer {
 
     @Override
     public JsonElement serialize( final Book book, final Type typeOfSrc, final JsonSerializationContext context) {
         final JsonObject jsonObject = new JsonObject();
         //The serialisation code is missing
 
         return jsonObject;
     }
}

上面的例子还缺失了重要部分，需要通过补充序列化代码来完善。在添加更多代码使其变得复杂之前，我们先来理解下这个类。

JsonSerializer 接口要求类型是将要进行序列化的对象类型。在这个例子中，我们要序列化的 Java 对象是 Book。serialize()方法的返回类型必须是一个 JsonElement （Java 文档）类型的实例。详见这篇文章：Gson 反序列化实例，下面列出了JsonElement 四种具体实现类型：

  • JsonPrimitive (Java Doc) —— 例如一个字符串或整型
  • JsonObject (Java Doc) —— 一个以 JsonElement 名字（类型为 String）作为索引的集合。类似于 Map<String,JsonElement>集合（Java Doc）
  • JsonArray (Java Doc)—— JsonElement 的集合。注意数组的元素可以是四种类型中的任意一种，或者混合类型都支持。
  • JsonNull (Java Doc) —— 值为null

JsonElement的类型

上面这张图片展示了 JsonElement 的所有类型。可以把 JsonObject 看作值为 JsonElement 的键值对集合。因此，这些值可以是另外四种对象。

下面是序列化的完整实例：

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
package com.javacreed.examples.gson.part1;
 
import java.lang.reflect.Type;
 
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
 
public class BookSerialiser implements JsonSerializer {
 
     @Override
     public JsonElement serialize( final Book book, final Type typeOfSrc, final JsonSerializationContext context) {
         final JsonObject jsonObject = new JsonObject();
         jsonObject.addProperty( "title" , book.getTitle());
         jsonObject.addProperty( "isbn-10" , book.getIsbn10());
         jsonObject.addProperty( "isbn-13" , book.getIsbn13());
 
         final JsonArray jsonAuthorsArray = new JsonArray();
         for ( final String author : book.getAuthors()) {
             final JsonPrimitive jsonAuthor = new JsonPrimitive(author);
             jsonAuthorsArray.add(jsonAuthor);
         }
         jsonObject.add( "authors" , jsonAuthorsArray);
 
         return jsonObject;
     }
}

我们在这里添加了一些代码。在理解整个图片的含义前，我们先把它拆成一个个小的部分，先来解释下每部分的含义。

如果要序列化这个 Java 对象，首先需要创建一个 JsonElement 实例。例子中是返回了一个 JsonObject 实例来代表 Book 对象，如下所示：

1
final JsonObject jsonObject = new JsonObject();

该对象使用我们设置的字段名称进行填充，如下：

1
2
3
4
5
// The variable 'book' is passed as a parameter to the serialize() method
     final JsonObject jsonObject = new JsonObject();
     jsonObject.addProperty( "title" , book.getTitle());
     jsonObject.addProperty( "isbn-10" , book.getIsbn10());
     jsonObject.addProperty( "isbn-13" , book.getIsbn13());

使用 addProperty() 方法 （Java Doc）可以添加任何 Java 原始类型以及String和Number。注意此处的 name 必须是唯一的，否则会被前一个覆盖掉。可以将其看做是一个将字段名作为值索引的 Map。

更复杂的对象，比如 Java 对象或数组就不能使用上面的方法来添加了。JsonObject 有另外一个 add() 方法，可以用来作为替代，如下所示：

1
2
3
4
5
6
7
8
9
10
11
// The variable 'book' is passed as a parameter to the serialize() method
     jsonObject.addProperty( "title" , book.getTitle());
     jsonObject.addProperty( "isbn-10" , book.getIsbn10());
     jsonObject.addProperty( "isbn-13" , book.getIsbn13());
 
     final JsonArray jsonAuthorsArray = new JsonArray();
     for ( final String author : book.getAuthors()) {
       final JsonPrimitive jsonAuthor = new JsonPrimitive(author);
       jsonAuthorsArray.add(jsonAuthor);
     }
     jsonObject.add( "authors" , jsonAuthorsArray);

首先创建一个 JsonArray 对象，然后将所有 authors 添加进去。和 Java 不同的是，初始化 JsonArray 时不需要指定数组的大小。事实上，抛开这个类的名字不看，可以将 JsonArray 类更多地看做是一个 list 而非 array。最后将 jsonAuthorsArray  添加到 jsonObject 中。此处也可以在给 jsonAuthorsArray 添加元素之前，将其添加到 jsonObject 中。

在调用该序列化方法之前，我们需要将其注册到 Gson 中：

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
package com.javacreed.examples.gson.part1;
 
import java.io.IOException;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class Main {
 
   public static void main( final String[] args) throws IOException {
     // Configure GSON
     final GsonBuilder gsonBuilder = new GsonBuilder();
     gsonBuilder.registerTypeAdapter(Book. class , new BookSerialiser());
     gsonBuilder.setPrettyPrinting();
     final Gson gson = gsonBuilder.create();
 
     final Book javaPuzzlers = new Book();
     javaPuzzlers.setTitle( "Java Puzzlers: Traps, Pitfalls, and Corner Cases" );
     javaPuzzlers.setIsbn10( "032133678X" );
     javaPuzzlers.setIsbn13( "978-0321336781" );
     javaPuzzlers.setAuthors( new String[] { "Joshua Bloch" , "Neal Gafter" });
 
     // Format to JSON
     final String json = gson.toJson(javaPuzzlers);
     System.out.println(json);
   }
}

通过注册我们自己实现的序列化器，告诉 Gson 无论什么时候序列化 Book 类型的对象都使用该序列化器进行序列化。

在上面例子中，通过调用 set prettying printing 方法还告诉了 Gson 对生成的 JSON 对象进行格式化，如下所示：

1
gsonBuilder.setPrettyPrinting();

虽然这对于调试和教程非常有用，但请不要在生产环境中这样用，因为可能会因此产生更大的 JSON 对象（文本的大小）。除此之外，由于 Gson 必须要格式化 JSON 对象，即对其进行相应的缩进，pretty printing 会有一些性能方面的消耗。

运行上面的代码可以得到预期的 JSON 对象。对我们的第一个例子做个总结，即怎样自定义 Gson 序列化器将 Java 对象序列化为 JSON 对象。下一章将会讲到怎样使用 Gson 序列化嵌套对象。

嵌套对象

接下来的例子将会描述怎么序列化嵌套对象。所谓嵌套对象是指在其它对象内部的对象。在此我们将会引入一个新的实体：author。形成了这样一个包含 title 和 ISBN 连同 author 列表的 book。在这个例子中将会得到一个包含新实体的 JSON 对象，与前面的JSON对象不同，就像下面那样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
   "title" : "Java Puzzlers: Traps, Pitfalls, and Corner Cases" ,
   "isbn" : "032133678X" ,
   "authors" : [
     {
       "id" : 1,
       "name" : "Joshua Bloch"
     },
     {
       "id" : 2,
       "name" : "Neal Gafter"
     }
   ]
}

注意，前一个例子中 authors 只是一个简单的字符数组：

1
2
3
4
"authors" : [
     "Joshua Bloch" ,
     "Neal Gafter"
   ]

这个例子中的 authors 是一个 JSON 对象，而不仅仅只是一个基本类型。

1
2
3
4
{
       "id" : 1,
       "name" : "Joshua Bloch"
     }

author 的 JSON对象有一个 id 和一个 name字段。下面是 Author 类。

1
2
3
4
5
6
7
8
9
10
package com.javacreed.examples.gson.part2;
 
public class Author {
 
   private int id;
   private String name;
 
   // Methods removed for brevity
 
}

这个类非常简单，由两个字段组成，并且都是原始类型。Book 类被修改为使用 Author 类，如下所示：

1
2
3
4
5
6
7
8
9
10
11
package com.javacreed.examples.gson.part2;
 
public class Book {
 
   private Author[] authors;
   private String isbn;
   private String title;
 
   // Methods removed for brevity
 
}

author 字段从一个 integer 数组变成了一个 Author 数组。因此必须修改下 BookSerialiser 类来兼容这一改变，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.javacreed.examples.gson.part2;
 
import java.lang.reflect.Type;
 
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
 
public class BookSerialiser implements JsonSerializer<Book> {
 
   @Override
   public JsonElement serialize( final Book book, final Type typeOfSrc, final JsonSerializationContext context) {
     final JsonObject jsonObject = new JsonObject();
     jsonObject.addProperty( "title" , book.getTitle());
     jsonObject.addProperty( "isbn" , book.getIsbn());
 
     final JsonElement jsonAuthros = context.serialize(book.getAuthors());
     jsonObject.add( "authors" , jsonAuthros);
 
     return jsonObject;
   }
}

authors 的序列化由 context（作为 serialize() 方法的一个参数被传进来，是 JsonSerializationContext 的实例） 来完成。context 将会序列化给出的对象，并返回一个 JsonElement。同时 context 也会尝试找到一个可以序列化当前对象的序列化器。如果没有找到，其将会使用默认的序列化器。目前，我们还不会为 Author 类实现一个序列化器，仍然会使用默认实现作为替代。

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
package com.javacreed.examples.gson.part2;
 
import java.io.IOException;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class Main {
 
   public static void main( final String[] args) throws IOException {
     // Configure GSON
     final GsonBuilder gsonBuilder = new GsonBuilder();
     gsonBuilder.registerTypeAdapter(Book. class , new BookSerialiser());
     gsonBuilder.setPrettyPrinting();
     final Gson gson = gsonBuilder.create();
 
     final Author joshuaBloch = new Author();
     joshuaBloch.setId( 1 );
     joshuaBloch.setName( "Joshua Bloch" );
 
     final Author nealGafter = new Author();
     nealGafter.setId( 2 );
     nealGafter.setName( "Neal Gafter" );
 
     final Book javaPuzzlers = new Book();
     javaPuzzlers.setTitle( "Java Puzzlers: Traps, Pitfalls, and Corner Cases" );
     javaPuzzlers.setIsbn( "032133678X" );
     javaPuzzlers.setAuthors( new Author[] { joshuaBloch, nealGafter });
 
     final String json = gson.toJson(javaPuzzlers);
     System.out.println(json);
   }
}

上面的例子创建并配置 Gson 使用自定义的 BookSerialiser 进行序列化。我们创建了两个 author 对象和一个 book 对象，并序列化该 book 对象。这样将会得到在章节开始时展示的 JSON 对象。

完整起见，下面是一个 Author 类的序列化器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.javacreed.examples.gson.part2;
 
import java.lang.reflect.Type;
 
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
 
public class AuthorSerialiser implements JsonSerializer<Author> {
 
   @Override
   public JsonElement serialize( final Author author, final Type typeOfSrc, final JsonSerializationContext context) {
     final JsonObject jsonObject = new JsonObject();
     jsonObject.addProperty( "id" , author.getId());
     jsonObject.addProperty( "name" , author.getName());
 
     return jsonObject;
   }
}

上面的序列化器并没有引入什么新的特性，因此不需要再多做解释。如果想要使用这个新的序列器，需要将其注册到 GsonBuilder （Java Doc） 中。

本章对嵌套对象的序列化做了总结。可以将嵌套对象的序列化交给 context 处理，其在序列化时会顺带尝试找到一个合适的序列化器，并返回相应的 JsonElement。下一章也是最后一章将会讲如何处理对象引用的序列化。

对象引用

一个对象对其它对象的引用叫做对象引用，book 和 author 类之间的关系就是这样。同一个 author 可以有多本 book。例如 author Joshua Bloch（Author at Amazon）不止一本 book。在使用序列化器描述之前，我们将会清除重复的 author。

考虑下面这个例子：

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
package com.javacreed.examples.gson.part3;
 
import java.io.IOException;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class Example1 {
 
   public static void main( final String[] args) throws IOException {
     // Configure GSON
     final GsonBuilder gsonBuilder = new GsonBuilder();
     gsonBuilder.setPrettyPrinting();
     final Gson gson = gsonBuilder.create();
 
     final Author joshuaBloch = new Author();
     joshuaBloch.setId( 1 );
     joshuaBloch.setName( "Joshua Bloch" );
 
     final Author nealGafter = new Author();
     nealGafter.setId( 2 );
     nealGafter.setName( "Neal Gafter" );
 
     final Book javaPuzzlers = new Book();
     javaPuzzlers.setTitle( "Java Puzzlers: Traps, Pitfalls, and Corner Cases" );
     javaPuzzlers.setIsbn( "032133678X" );
     javaPuzzlers.setAuthors( new Author[] { joshuaBloch, nealGafter });
 
     final Book effectiveJava = new Book();
     effectiveJava.setTitle( "<span class=" wp_keywordlink "><a href=" http: //www.amazon.com/gp/product/B000WJOUPA/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B000WJOUPA&linkCode=as2&tag=job0ae-20" title="Effective Java" rel="nofollow" target="_blank" class="external">Effective Java</a></span> (2nd Edition)");
     effectiveJava.setIsbn( "0321356683" );
     effectiveJava.setAuthors( new Author[] { joshuaBloch });
 
     final Book[] books = new Book[] { javaPuzzlers, effectiveJava };
 
     final String json = gson.toJson(books);
     System.out.println(json);
   }
}

两个作者和两本书，其中一个作者在两本书中都有。注意，有两个 author 对象而不是三个，代表 Joshua Bloch 的实例被两个 book 对象共享。最后注意，我们故意没有使用任何自定义的序列化器。下面是执行上面代码的结果。

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
[
   {
     "authors" : [
       {
         "id" : 1,
         "name" : "Joshua Bloch"
       },
       {
         "id" : 2,
         "name" : "Neal Gafter"
       }
     ],
     "isbn" : "032133678X" ,
     "title" : "Java Puzzlers: Traps, Pitfalls, and Corner Cases"
   },
   {
     "authors" : [
       {
         "id" : 1,
         "name" : "Joshua Bloch"
       }
     ],
     "isbn" : "0321356683" ,
     "title" : "Effective Java (2nd Edition)"
   }
]

得到了两个 book 类型的 JSON 和三个 author 类型的 JSON。而对于author：Joshua Bloch 是重复的。

1
2
3
4
{
        "id" : 1,
        "name" : "Joshua Bloch"
      }

这会使得 JSON 对象明显变大，尤其是对更复杂的对象。理想情况下，book 的 JSON 对象应该只包含 author 的 id 而不是整个对象。这类似于关系型数据库中 book 表有一个外键关联到 author 表。

Book 类将会被修改为包含一个只返回 author 的 id 的方法，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.javacreed.examples.gson.part3;
 
public class Book {
 
   private Author[] authors;
   private String isbn;
   private String title;
 
   public Author[] getAuthors() {
     return authors;
   }
 
   public int [] getAuthorsIds() {
     final int [] ids = new int [authors.length];
     for ( int i = 0 ; i < ids.length; i++) {
       ids[i] = authors[i].getId();
     }
     return ids;
   } // Other methods removed for brevity
 
}

当序列化 book 时，使用 author 的 id 代替整个 author 对象，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.javacreed.examples.gson.part3;
 
import java.lang.reflect.Type;
 
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
 
public class BookSerialiser implements JsonSerializer {
 
   @Override
   public JsonElement serialize( final Book book, final Type typeOfSrc, final JsonSerializationContext context) {
     final JsonObject jsonObject = new JsonObject();
     jsonObject.addProperty( "title" , book.getTitle());
     jsonObject.addProperty( "isbn" , book.getIsbn());
 
     final JsonElement jsonAuthros = context.serialize(book.getAuthorsIds());
     jsonObject.add( "authors" , jsonAuthros);
 
     return jsonObject;
   }
}

下面是使用这个序列化器得到的结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[
   {
     "title" : "Java Puzzlers: Traps, Pitfalls, and Corner Cases" ,
     "isbn" : "032133678X" ,
     "authors" : [
       1,
       2
     ]
   },
   {
     "title" : "Effective Java (2nd Edition)" ,
     "isbn" : "0321356683" ,
     "authors" : [
       1
     ]
   }
]

现在我们使用 author 的 id 代替了整个 author。这一做法使得其比前一个有更小的空间占用。对于更大的对象将产生巨大的影响。

这个例子是整篇文章关于序列化的总结。从中我们学会了怎么使用默认或自定义的序列化选项，将 Java 对象序列化为 JSON 字符串。

原文链接：  javacreed  翻译：  ImportNew.com  -  飘扬叶
译文链接：  http://www.importnew.com/16638.html
wslovelcy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Gson 中解决 json 反序列化时相同属性对应不同类型的值的问题（代码）
04-09
Gson 中解决 json 反序列化时相同属性对应不同类型的值的问题（代码），对应文章链接：https://blog.csdn.net/ZiFung_Yip/article/details/89143255
Java 关于序列化、Json和Gson详解
SwaggerHB的博客
05-26 1167
Java 关于序列化、Json和Gson详解、基于Gson产生的工具ArgumentMaker
java gson序列化_java – Gson多态序列化
weixin_42355399的博客
03-04 291
使用Gson 2.2.2我正在尝试序列化POJO(行为)的数组列表.我有一个适配器几乎是我在网上看到的副本：public class BehaviorAdapter implements JsonSerializer {private static final String CLASSNAME = "CLASSNAME";private static final String INSTANCE =...
Gson的用法详解_Gson如何进行进行序列化和反序列化
最新发布
yanzirou的博客
02-22 361
Gson 是一个流行的 Java 序列化/反序列化库，可以将 Java 对象和 JSON 字符串相互转换，并支持自定义序列化和反序列化过程。需要注意的是，在使用 Gson 库进行序列化和反序列化时，需要注意序列化和反序列化的对象类型和属性名。如果对象中的属性名与序列化后的 JSON 字符串中的属性名不一致，那么需要使用。方法接受两个参数，第一个参数是要反序列化的 JSON 字符串，第二个参数是反序列化后的对象的类型。在上面的代码中，我们将反序列化后的结果转型为。在上面的代码中，我们使用。
安卓开发之Gson实现序列化与反序列化
niulinbiao的博客
09-18 397
文章预览前言操作1、导入依赖2、JavaBean2.1、user.java2.2、Job.java3、对Java对象进行序列化与反序列化4、对Aarray、List进行序列化与反序列化5、对Map、Set集合进行序列化与反序列化注解解释 前言 GSON弥补了JSON的许多不足的地方，在实际应用中更加适用于Java开发。在这里，我们主要讲解的是利用GSON来操作java对象和json数据之间的相互转换，包括了常见的对象序列化和反序列化的知识。 参考文章 https://www.jianshu.com/p/75
Gson工具的使用、序列化/反序列化集合、对象、遇到的问题
鸢尾_的博客
03-08 6372
Gson工具的使用、序列化/反序列化集合、对象、遇到的问题
fastjson、gson、jackson序列化和反序列化性能对比
高興
05-03 9559
注：使用jar包版本 <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson --> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.31
kotlin gson反序列化默认值失效深入讲解
08-26
主要大家介绍了关于kotlin gson反序列化默认值失效的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
gson：一个Java序列化反序列化库，用于将Java对象转换为JSON并返回
02-14
格森Gson是一个Java库，可用于将Java对象转换为其JSON表示形式。 它还可以用于将JSON字符串转换为等效的Java对象。 Gson可以处理任意Java对象，包括您没有源代码的现有对象。 有一些开源项目可以将Java对象转换为...
Gson 枚举类型的统一序列化/反序列化处理
05-09
实现了通过gson对enum的自定义转化过程，不需要预先定义enmu，并且不需要修改gson源码，在框架顶层处理基本可以达到对enum的抽象管理。
android开发中混淆后Gson序列化、反序列化的那些坑
Dream It Possible
02-28 3204
GSON的序列化与反序列化 GSON是一个很好的工具,使用它我们可以轻松的实现序列化和反序列化.但是当它一旦遇到混淆,就需要我们注意了. 一个简单的类Item,用来处理序列化和反序列化 public class Item { public String name; public int id; } 序列化的代码 Item toSerializeItem = new Item(); toSerializeItem.id = 2; toSerializeItem.name = "
【性能优化】GSON解性能瓶颈分析
TechMix的博客
01-11 462
    GSON是Google提供的开源库，使用很便捷，但是在使用过程中也发现了其短板，在Bean类结构复杂时，进行反序列化耗时占比较高，尤其是很多在应用启动阶段需要反序列化一些内置的数据时，很让人头疼，通过抓Trace每次都能发现这货肯定是大头。     为了从正面优化这个问题，于是我翻看了GSON反序列化的源码，实现了能优化的方案，希望能帮助到同样面临该问题的同学们，如有问题也可以提出来。 如上图GSON解析过程的耗时可以
高效正确的使用Gson
正儿八经小青年
11-03 773
gson的基本用法： 反序列化:将json转换为类 Gson gson = new Gson(); Data i = gson.fromJson("100", Data.class); Listlist=gson.fromJson(json，new TypeToken>() {}.getType()); //将json转换为集合String[] strings = gson.fromJ
一次gson序列化导致高CPU使用问题
duanjunkaisky的专栏
12-26 841
那么清楚了原因后，问题就比较简单了。对于我们服务来说，之所以会产生这个现像主要是有个权限校验的切面类，里面的数据有几个日期字段，那么由于压测过程中线程较多因此导致冲突，所以会出现频繁加锁block的情况。首先通过top等命令查询了具体的CPU耗费线程，发现很奇怪的是没有出现特别高的占用线程，但是会存在大量占用率不高的线程（占用值不多，但是数量比较多）在压测过程中，发现服务器的CPU使用率较高，造成整体的QPS和服务器的性能下降，需要进一步要分析原因，因此展开了相关分析。
Gson json 简化 优化
u013317653的专栏
07-08 595
今天代码review的时候 发现同事解析一段json 做法很麻烦 所以我就帮他重构了一下 { "total": 51, "per_page": 15, "current_page": 1, "last_page": 4, "data": [{ "id": 00, "title": "地铁旁+精装全明办公间+中小企业拎包入住+虚拟办公", "image": "htt...
【Android】Gson的优化
qq_23049111的博客
08-02 810
过滤不需要解析的属性
Android下谈谈Gson常见优化
06-08 1191
在 JSON 中，值必须是以下数据类型之一： 字符串 数字 对象（JSON 对象） 数组 布尔 Null JSON 的值不可以是以下数据类型之一： 函数 日期 undefined 参考链接：JSON 数据类型 后台返回数据，有的时候受语言限制或者代码没写好的原因，该返回字符串的但是返回null。返回number的但返回字符串，导致客户端序列化对象的时候出现异常 举个栗子，json数据如下： { "tempInt":"", "tempString":1111, "tempAs":[ {
java基础-序列化/反序列化-gson基础知识
qq_28136919的博客
04-09 2937
序列化/反序列化相关的知识,gson的基础知识
Gson使用及多层嵌套 json 定义类
小风筝
10-06 9987
问题描述对于简单的Json数据，其对应的java bean 也比较简单，尤其用GSON处理的时候。 但是如果是多层嵌套的json数据，如果是手工用JSONArray和JSONObject进行解析，还是可以的，虽然会繁琐一点。但是如果用GSON开源库解析，有该如何定义java bean呢？ 如果定义不好，会出现NEP空指针异常。分析在我的项目中，有这样的一段代码， public TopicApi
Gson 对LocalDateTime的序列化处理
06-01
对于Gson对LocalDateTime的序列化处理，需要先自定义一个Gson的TypeAdapter，然后在TypeAdapter中...这样，当对象中有LocalDateTime类型的属性时，在使用Gson序列化和反序列化时，就会自动调用该TypeAdapter进行处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值