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

最新推荐文章于 2024-09-22 18:02:07 发布
最新推荐文章于 2024-09-22 18:02:07 发布
阅读量206 收藏
点赞数 1
文章标签： java json 数据库
原文链接：http://www.cnblogs.com/atwanli/articles/4899213.html
版权

通过调用 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 字符串。

转载于:https://www.cnblogs.com/atwanli/articles/4899213.html

dengyiyu5280
关注
Gson解析之自定义序列化和反序列化
10-20
Gson解析之自定义序列化和反序列化的代码例子，但后端对同一个字段给的数据类型与文档不一致时的处理
Gson源码之序列化(Java Object转String)
meijing11的博客
08-17 1659
通过Gson将Java Bean转换为String的入口是toJson()，那它到底做了什么？ 1.Gson的构造函数主要是初始化factories (TypeAdapterFactory 集合)，便于在getAapter()根据数据类型返回对应的TypeAdapterFactory，从而获取对应的TypeAdapter进行序列化和反序列化。 toJson()是序列化入口,首先会判断传入的数据是不是空，如为空则调用参数为JsonElement的toJson()方法;若不为空则调用传入Object和Class
序列化方式二——JSON之Gson
最新发布
zhouhengzhe的博客
09-22 1428
JsonSerializer和JsonDeserializer：Gson 1.x版本中提供的自定义序列化器和反序列化器接口，基于树型结构进行解析。TypeAdapter：Gson 2.0版本中新增的自定义序列化器和反序列化器接口，基于流式结构进行解析，相比树型结构更节省内存。通过实现JsonSerializer和JsonDeserializer接口来自定义序列化和反序列化过程。这在你需要处理复杂对象或特殊格式时非常有用。Builder;Data;Date;
Java实践之路——Gson
lvdong5830的专栏
01-05 130
Java实践之路——Gson 分类： java javascript2011-07-30 11:12 413人阅读 评论(0) 收藏 举报 在java中采用ajax技术难免会遇到将java对象序列化的问题，而json作为一种轻量级且易懂易操作的数据格式得到广泛的应用。所以，这里我们讲一下将Java对象序列化为Json数据的方法，这里主要讲一下google开发的开源工具Gso...
Gson 序列化
请叫我搞向
08-17 1104
通过调用 Gson API 可以把 Java 对象转换为 JSON 格式的字符串（项目主页）。在这篇文章中，我们将会讲到如何通过 Gson 默认实现和自定义实现方式，将 Java 对象转换为 JSON 字符串。对于那些不熟悉 Gson 的读者，建议在读本篇文章之前读一下这两篇文章：简单 Gson 实例和 Gson 反序列化实例。另外，这篇文章的讲述方式和Gson反序列化实例一样，并且使用了相同的例
google-gson 使用及GsonBuilder设置
Funny IT
03-21 1755
Json是一种类似于XML的通用数据交换格式,具有比XML更高的传输效率. 从结构上看，所有的数据（data）最终都可以分解成三种类型： 第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"北京"这个单独的词。 第二种类型是序列（sequence），也就是若干个相关的数据按照一定顺序并列在一起，又叫做数组（array
gson-2.6.2.jar包（com.google.code.gson:gson:2.6.2）
09-29
它的全名是Google Simple JSON，其版本2.6.2在Android开发中被广泛使用，尤其是在处理JSON序列化和反序列化任务时。Gson库通过提供`Gson`类，使得Java对象可以方便地转换为JSON字符串，反之也可以将JSON文本解析成...
Gson 枚举类型的统一序列化/反序列化处理
05-09
然而，在使用Gson库进行JSON序列化和反序列化时，枚举处理默认方式可能无法满足所有需求。本篇文章将详细探讨如何通过自定义Gson适配器实现枚举类型的统一序列化和反序列化处理，无需预先定义枚举，也无需修改Gson...
Gson-Example:Gson 库的使用、自定义序列化器、排除策略等
06-05
Gson的基本使用方法包括两个主要操作：对象到JSON的序列化和JSON到对象的反序列化。例如，如果你有一个名为`Person`的Java类，你可以这样将其实例转化为JSON字符串： ```java public class Person { String name; ...
fx-gson:一组Google Gson的类型适配器，使JavaFX属性序列化更加自然
05-04
FX Gson只需删除属性“包装”，然后将值的序列化委托给Gson。 这意味着在序列化该类型的属性时，将考虑您添加到Gson的有关该类型的任何配置。 对于对象和基元来说确实如此。 为什么使用FX Gson？ 在JavaFX中，POJO...
Gson 中解决 json 反序列化时相同属性对应不同类型的值的问题（代码）
04-09
Gson 中解决 json 反序列化时相同属性对应不同类型的值的问题（代码），对应文章链接：https://blog.csdn.net/ZiFung_Yip/article/details/89143255
Gson的序列化和反序列化
热门推荐
残梦
12-23 1万+
序列化和反序列化Java序列化是指把Java对象转换为可传输的字节序列的过程；而Java反序列化是指把传输的字节序列恢复为Java对象的过程。这两个过程使我们非常方便的存储和传输数据。Gson概述Gson是一个Java库，可用于将Java对象转换为JSON表示，它也可以用来将JSON字符串转换为等效的Java对象。
Gson解析（序列化，反序列化）
twenty_four_7的博客
05-08 3688
Gson解析（序列化，反序列化） Gson 是google解析Json的一个开源框架，是Google提供的用来在java对象和JSON字符串之间进行映射的类库，可以将一个JSON字符串转成一个java对象（反序列化），或者把java对象转成一个JSON字符串（序列化） 1.导入依赖 implementation 'com.google.code.gson:gson:2.8.6' 2.Gson的基本用法之JavaBean转换成Json字符串 gson提供 publicString toJson(Obje
java gson序列化_Gson序列化内部类
weixin_42116604的博客
02-23 390
本篇文章帮大家学习Gson序列化内部类，包含了Gson序列化内部类使用方法、操作技巧、实例演示和注意事项，有一定的学习价值，大家可以用来参考。在本章中，我们将解释具有内部类的类的序列化/反序列化。嵌套内部类示例参考以下示例代码片段 -Student student = new Student();student.setRollNo(1);Student.Name name = student.ne...
Android 中使用Gson完成对象的序列化与反序列化
路宇的博客
05-27 2251
前言： JSON(JavaScript ObjectNotation):是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。 Gson简介：Gson是Google提供的用来在java对象和json数据之间进行映射的java类库，可以将一个JSON字符串转成一个java对象(反序列化)，或者将java对象转成一个JSON字符串(序列化)。 在Android 下build.gradle下引入依赖： 接下来用一个使用Gson将Student类型对象进行序列化，与反序列 1.Student类
GSON序列化与反序列化应用
TIM_LONG的博客
03-05 236
GSON应用实例    GSON简介：Gson（又称Google Gson）是Google公司发布的一个开放原始码的Java库，主要用途为序列化Java物件为JSON字串，或反序列化JSON字串成Java物件。    使用Gson对象进行java bean与json数据之间的转换相当方便,这是我们常用的一行代码，简介而方便。eg： Object obj = new Gson().fromJs...
Gson的基本使用：解析Json格式数据 序列化与反序列化
IH_LZH的博客
07-22 1580
Gson是Google发布的一个Java库，可以用来将Java对象转换为Json字符串表示，或者将Json字符串转换为等效的Java对象；
Gson的用法详解_Gson如何进行进行序列化和反序列化
yanzirou的博客
02-22 664
Gson 是一个流行的 Java 序列化/反序列化库，可以将 Java 对象和 JSON 字符串相互转换，并支持自定义序列化和反序列化过程。需要注意的是，在使用 Gson 库进行序列化和反序列化时，需要注意序列化和反序列化的对象类型和属性名。如果对象中的属性名与序列化后的 JSON 字符串中的属性名不一致，那么需要使用。方法接受两个参数，第一个参数是要反序列化的 JSON 字符串，第二个参数是反序列化后的对象的类型。在上面的代码中，我们将反序列化后的结果转型为。在上面的代码中，我们使用。
Kotlin Gson反序列化默认值失效详解及实例
"本文将深入探讨Kotlin中的Gson反序列化默认值失效问题，并通过详细的示例代码帮助读者理解这一概念。Gson反序列化是将JSON数据转换为Java对象的过程，主要包括两个关键步骤：根据TypeToken创建对象和解析JSON数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值