求教json的问题，google库gson的bug问题_百度知道
求教json的问题，google库gson的bug问题
提问者采纳
google库gson的bug问题 [解决办法] toonyoo.ums.test.User 这个 class给一个空变数的construct 希望以上信息可以帮到您＃ 。
来自团队：
其他类似问题
为您推荐：
json的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁求教json的问题，google库gson的bug问题_百度知道
求教json的问题，google库gson的bug问题
提问者采纳
google库gson的bug问题 [解决办法] toonyoo.ums.test.User 这个 class给一个空变数的construct 希望以上信息可以帮到您＃ 如果我的回答没能帮助您，请继续追问。 你的采纳是我前进的动力。记得好评和采纳，答题不易，互相帮助。
其他类似问题
为您推荐：
json的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁当前访客身份：游客 [
当前位置：
被墙，本人特意翻墙出去扒了分 User Guide 回来，不过是英文的。
Gson User Guide
1 Authors: Inderjeet Singh, Joel Leitch
1.1 Overview
1.2 Goals for Gson
1.3 Gson Performance and Scalability
1.4 Gson Users
1.5 Using Gson
1.5.1 Primitives Examples
1.5.2 Object Examples
1.5.2.1 Finer Points with Objects
1.5.3 Nested Classes (including Inner Classes)
1.5.4 Array Examples
1.5.5 Collections Examples
1.5.5.1 Collections Limitations
1.5.6 Serializing and Deserializing Generic Types
1.5.7 Built-in Serializers and Deserializers
1.5.8 Custom Serialization and Deserialization
1.5.8.1 Writing a Serializer
1.5.8.2 Writing a Deserializer
1.5.9 Writing an Instance Creator
1.5.9.1 InstanceCreator for a Parameterized Type
1.5.10 Compact Vs. Pretty Printing for JSON Output Format
1.5.11 Null Object Support
1.5.12 Versioning Support
1.5.13 Excluding Fields From Serialization and Deserialization
1.5.13.1 Java Modifier Exclusion
1.5.13.2 Gson's @Expose
1.5.13.3 User Defined Exclusion Strategies
1.5.14 JSON Field Naming Support
1.5.15 Sharing State Across Custom Serializers and Deserializers
1.6 Issues in Designing Gson
1.7 Future Enhancements to Gson
Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. Gson is an open-source project hosted at /p/google-gson.Gson
can work with arbitrary Java objects including pre-existing objects
that you do not have source-code of.
Goals for Gson
Provide easy to
use mechanisms like toString() and constructor (factory method) to convert Java to JSON and vice-versa
pre-existing unmodifiable objects to be converted to and from JSON
custom representations for objects
Support arbitrarily complex
Generate compact and readability JSON output
Gson Performance and
Scalability
Here are some metrics that we obtained on a desktop (dual opteron, 8GB
RAM, 64-bit Ubuntu) running lots of other things along-with the tests.
You can rerun these tests by using the class PerformanceTest.
Deserialized strings of over 25MB without any problems (see disabled_testStringDeserializationPerformance method in PerformanceTest)
collections:
Serialized a collection of 1.4 million
objects (see disabled_testLargeCollectionSerialization method in PerformanceTest)
Deserialized
a collection of 87,000 objects (see disabled_testLargeCollectionDeserialization in PerformanceTest)
1.4 raised the deserialization limit for byte arrays and collection to
over 11MB from 80KB.
Note: Delete the disabled_ prefix to run these tests. We
use this prefix to prevent running these tests every time we run junit
Gson Users
originally created for use inside Google where it is currently used in a
number of projects. It is now used by a number of public projects and
companies. See details here.
Using Gson
The primary class to use is Gson which you can just create by calling new Gson(). There is also a class GsonBuilder available that can be used to
create a Gson instance with various settings like version control and so
on. The Gson instance does not maintain any state while invoking Json operations. So, you are free to reuse the same object for multiple Json serialization and deserialization operations.
Primitives Examples
(Serialization)Gson gson = new Gson();gson.toJson(1);&&&&&&&&&&& ==&
prints 1gson.toJson("abcd");&& & & ==& prints "abcd"gson.toJson(new Long(10)); ==& prints 10int[]
values = { 1 };gson.toJson(values);&&&&&& ==& prints [1](Deserialization)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);
Object Examples
class BagOfPrimitives {& private int value1 = 1;& private String value2 = "abc";& private transient int value3 = 3;& BagOfPrimitives() {&&& // no-args constructor&
}}(Serialization)BagOfPrimitives obj = new BagOfPrimitives();Gson gson = new Gson();String
json = gson.toJson(obj);& ==& json is
{"value1":1,"value2":"abc"}Note that you can
not serialize objects with circular references since that will result in
infinite recursion. (Deserialization)BagOfPrimitives
obj2 = gson.fromJson(json, BagOfPrimitives.class);&& ==& obj2 is just like obj
Finer Points with Objects
It is perfectly fine (and
recommended) to use private fields
There is no need to use any annotations to indicate a field is to be included for serialization and deserialization. All fields in the current class (and from all super classes) are included by default.
field is marked transient, (by default) it is ignored and not included
in the JSON serialization or deserialization.
implementation handles nulls correctly
While serialization, a null field is skipped from the output
deserialization, a missing entry in JSON results in setting the
corresponding field in the object to null
If a field is
synthetic, it is ignored and not included in JSON serialization
or deserialization
Fields corresponding to the outer classes in& inner classes, anonymous classes, and local classes are ignored and not included in serialization or deserialization
Nested Classes
(including Inner Classes)
Gson can serialize static nested
classes quite easily.&
Gson can also
deserialize static nested classes. However, Gson can not automatically
deserialize the pure inner classes since their no-args constructor
also need a reference to the containing Object which is not
available at the time of deserialization. You can address this problem
by either making the inner class static or by providing a custom
InstanceCreator for it. Here is an example:&
public class A { &&public S &&class
B { && &public S && &public B() {&& & &//
No args constructor for B&& &}&&} }
NOTE: The above class B can not (by
default) be serialized with Gson.Gson&can&not&deserialize {"b":"abc"} into an
instance of B since the class B is an inner class. if it was defined as static class B then Gson would have been able to deserialize the string.
Another solution is to write a custom instance creator for B.&
public class InstanceCreatorForB
implements InstanceCreator&A.B& {
&&private final A
&&public InstanceCreatorForB(A a) &{
&& &this.a =
&&public A.B createInstance(Type type) {
&& &return a.new B();
The above is possible, but not
recommended.
Array Examples
Gson gson = new Gson();int[] ints = {1, 2, 3, 4,
5};String[]
strings = {"abc", "def", "ghi"};(Serialization)gson.toJson(ints);&&&& ==&
prints [1,2,3,4,5]
gson.toJson(strings);& ==& prints ["abc", "def",
"ghi"](Deserialization)int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class); ==& ints2 will be same as intsWe also support multi-dimensional arrays, with
arbitrarily complex element types
Collections
Gson gson = new Gson();Collection&Integer& ints =
Lists.immutableList(1,2,3,4,5);(Serialization)String json = gson.toJson(ints); ==& json is [1,2,3,4,5](Deserialization)Type collectionType = new
TypeToken&Collection&Integer&&(){}.getType();Collection&Integer&
ints2 = gson.fromJson(json,
collectionType);ints2 is same as intsFairly
hideous: note how we define the type of collectionUnfortunately, no
way to get around this in Java
Collections Limitations
serialize collection of arbitrary objects but can not deserialize from
Because there is no way for the user to indicate the type
of the resulting object
While deserializing, Collection
must be of a specific generic type
All of this makes sense, and
is rarely a problem when following good Java coding practices
Serializing and
Deserializing Generic Types
When you call toJson(obj), Gson calls obj.getClass() to get
information on the fields to serialize. Similarly, you can typically
pass MyClass.class object in the fromJson(json,
MyClass.class) method. This works fine if the object is a
non-generic type. However, if the object is of a generic type, then the
Generic type information is lost because of Java Type Erasure. Here is
an example illustrating the point: List&String& myStrings = new
List&String&();gson.toJson(myStrings);
// Will cause a runtime exceptiongson.fromJson(json,
myStrings.getClass());The above call results in a runtime
exception because Gson invokes myStrings.getClass() to get its class
information, but this method returns a raw class, List.class. This
means that Gson has no way of knowing that this is a list of Strings,
and not plain objects. You can solve this problem by specifying
the correct parameterized type for your generic type. You can do this by
using the TypeToken class.
Type listType =
new TypeToken&List&String&&() {}.getType();gson.toJson(myStrings, listType);gson.fromJson(json, listType);The idiom
used to get listType actually defines an
anonymous local inner class containing a method getType() that
returns the fully parameterized type.
Built-in Serializers
and Deserializers
Gson has built-in serializers and
deserializers for commonly used classes whose default representation may
be inappropriate. Here is a list of such classes:
java.net.URL
to match it with strings like "/p/google-gson/".
java.net.URI
to match it with strings like "/p/google-gson/".
You can also
find source-code for some commonly used classes such as JodaTime at this
Serialization and Deserialization
Sometimes default representation is not what you want. This is often the case when dealing with library classes (DateTime, etc). Gson allows you
to register your own custom serializers and deserializers. This is done
by defining two parts:
Serialiers: Need to define custom serialization for an object
Deserializers: Needed to define custom deserialization for a type
Creators: Not needed if no-args constructor is available
GsonBuilder gson = new
GsonBuilder();gson.registerTypeAdapter(MyType.class, new MySerializer());gson.registerDeserializer(MyType.class, new
MyDeserializer());gson.registerInstanceCreator(MyType.class,
new MyInstanceCreator());
Writing a Serializer
Here is an
example of how to write a custom serializer for JodaTime DateTime class.
private class
DateTimeSerializer implements JsonSerializer&DateTime& {& public JsonElement
serialize(DateTime src, Type typeOfSrc, JsonSerializationContext
context) {&&& new JsonPrimitive(src.toString());& }}Gson calls toJson() when it runs into a
DateTime object during serialization.
Writing a Deserializer
an example of how to write a custom deserializer for JodaTime DateTime
class. private
class DateTimeDeserializer implements JsonDeserializer&DateTime& {& public DateTime deserialize(JsonElement
json, Type typeOfT, JsonDeserializationContext context)&&&&& throws
JsonParseException {&&& return new
DateTime(json.getAsJsonPrimitive().getAsString());& }}Gson
calls fromJson() when it needs to deserialize a JSON string fragment
into a DateTime objectFiner points with Serializers and
DeserializersOften you want to register a single handler for
all generic types corresponding to a raw type
For example,
suppose you have an "Id" class for Id representation/translation (i.e.
an internal vs. external representation).
Id&T& type that
has same serialization for all generic types
Essentially
write out the id value
Deserialization is very similar
but not exactly the same
Need to call "new Id(Class&T&,
String)" which returns an instance of Id&T&
supports registering a single handler for this. You can also register a
specific handler for a specific generic type (say Id&RequiresSpecialHandling& needed special handling).The Type parameter for the toJson and fromJson contains the generic type information to help you write a single handler for all generic types corresponding to the same raw type
Writing an Instance Creator
deserializing an Object, Gson needs to create a default instance of the
classWell-behaved& classes that are meant for serialization and
deserialization should have a no-argument constructor
Doesn't matter whether public or private
Typically,
Instance Creators are needed when you are dealing with a library class
that does NOT define a no-argument constructorInstance
Creator Exampleprivate class MoneyInstanceCreator implements
InstanceCreator&Money& {&
public Money createInstance(Type type) {&&& return new Money("1000000", CurrencyCode.USD);& }}Type could be of a
corresponding generic type
useful to invoke constructors which need specific generic type
information
For example, if the Id class stores the class for which the
Id is being created
InstanceCreator for a
Parameterized Type
Sometimes that the type that you are trying to
instantiate is a parameterized type. Generally, this is not a problem
since the actual instance is of raw type. Here is an example: class MyList&T&
extends ArrayList&T& {}class MyListInstanceCreator
implements InstanceCreator&MyList&?&& {&&& @SuppressWarnings("unchecked")& public MyList&?& createInstance(Type
type) {&&&
// No need to use a parameterized list since the actual instance will
have the raw type anyway.&&&
return new MyList();& }}However, sometimes you do need to create instance
based on the actual parameterized type. In this case, you can use the
type parameter being passed to the createInstance method. Here is an example: public class Id&T& {&
private final Class&T& classOfId;& priv&
public Id(Class&T& classOfId, long value) {&&& this.classOfId
= classOfId;&&& this.value =& }}class
IdInstanceCreator implements InstanceCreator&Id&?&& {& public Id&?& createInstance(Type type) {&&& Type[]
typeParameters = ((ParameterizedType)type).getActualTypeArguments();&&&
Type idType = typeParameters[0]; // Id has only one parameterized type T&&&
return Id.get((Class)idType, 0L);& }}In
the above example, an instance of the Id class can not be created
without actually passing in the actual type for the parameterized type.
We solve this problem by using the passed method parameter, type. The type object in this
case is the Java parameterized type representation of Id&Foo& where
the actual instance should be bound to Id&Foo&. Since Id class has just one parameterized type
parameter, T,
we use the zeroth element of the type array returned by getActualTypeArgument() which will hold Foo.class in this case.
Compact Vs. Pretty
Printing for JSON Output Format
The default JSON output that is
provide by Gson is a compact JSON format.& This means that there will
not be any whitespace in the output JSON structure.& Therefore, there
will be no whitespace between field names and its value, object fields,
and objects within arrays in the JSON output.& As well, "null" fields
will be ignored in the output (NOTE: null values will still be included
in collections/arrays of objects).& See the Null
Object Support section for information on configure Gson to output
all null values.If you like to use the Pretty Print feature, you
must configure your Gson instance using the GsonBuilder.&
The JsonFormatter&
is not exposed through our public API, so the client is unable to
configure the default print settings/margins for the JSON output.& For
now, we only provide a default JsonPrintFormatter that has default line length
of 80 character, 2 character indentation, and 4 character right margin.The
following is an example shows how to configure a Gson instance to use
the default JsonPrintFormatter instead of the JsonCompactFormatter:Gson gson = new
GsonBuilder().setPrettyPrinting().create();String jsonOutput = gson.toJson(someObject);
Null Object Support
The default
behaviour that is implemented in Gson is that null object fields are ignored.& This
allows for a more c however, the client must define
a default value for these fields as the JSON format is converted back
into its Java.Here's how you would configure a Gson instance to
output null:Gson gson = new
GsonBuilder().serializeNulls().create();NOTE: when serializing nulls with Gson, it
will add a JsonNull element to the JsonElement structure.& Therefore, this object can be used in custom
serialization/deserialization.Here's an example:public class Foo {& private final S&& public Foo() {&&&
this(null, 5);& }& public Foo(String s, int i) {&&& this.s =&&& this.i =& }}Gson gson = new
GsonBuilder().serializeNulls().create();Foo foo = new Foo();String json = gson.toJson(foo);System.out.println(json);json = gson.toJson(null);System.out.println(json);======== OUTPUT ========{"s":null,"i":5}null
Versioning
Multiple versions of the same object can be maintained by using @Since annotation. This annotation can be used on Classes, Fields and, in a future release, Methods.& In order to leverage this feature, you must
configure your Gson instance to ignore any field/object that is greater than some version
number.& If no version is set on the Gson instance then it will serialize and
deserialize all fields and classes regardless of the version.public class VersionedClass
{& @Since(1.1) private final String newerF& @Since(1.0) private final String
newF& private final S& public
VersionedClass() {&&& this.newerField = "newer";&&&
this.newField = "new";&&& this.field = "old";& }}VersionedClass
versionedObject = new VersionedClass();Gson gson = new
GsonBuilder().setVersion(1.0).create(); String jsonOutput =
gson.toJson(someObject);System.out.println(jsonOutput);System.out.println();gson = new Gson();jsonOutput = gson.toJson(someObject); System.out.println(jsonOutput);======== OUTPUT ========{"newField":"new","field":"old"} {"newerField":"newer","newField":"new","field":"old"}
Excluding Fields
From Serialization and Deserialization
Gson supports numerous mechanisms for excluding
top-level classes, fields and field types.& Below are pluggable
mechanism that allow field and class exclusion. If none of the below
mechanism satisfy your needs then you can always use custom
serializers and deserializers.
Java Modifier Exclusion
default, if you mark a field as transient, it will be excluded.& As well, if a
field is marked as "static" then by default it will be excluded. If you
want to include some transient fields then you can do the following:import
java.lang.reflect.MGson gson = new GsonBuilder()&&&
.excludeFieldsWithModifier(Modifier.STATIC)&&& .create();NOTE:
you can use any number of the Modifier constants to "excludeFieldsWithModifier" method.& For
example:Gson gson =
new GsonBuilder() &&& .excludeFieldsWithModifier(Modifier.STATIC, Modifier.TRANSIENT,
Modifier.VOLATILE) &&& .create();
feature provides a way where you can mark certain
fields of your objects to be excluded for consideration for
serialization and deserialization to JSON. To use this annotation, you
must create Gson by using new
GsonBuilder().excludeFieldsWithoutExposeAnnotation().create().
The Gson instance created will exclude all fields in a class that are
not marked with @Expose annotation.
User Defined Exclusion
Strategies
If the above mechanisms for excluding fields and
class type do not work for you then you can always write your own
exclusion strategy and plug it into Gson. See the ExclusionStrategy JavaDoc for more information.The following example shows how to
exclude fields marked with a specific "@Foo" annotation and excludes
top-level types (or declared field type) of class String.&
@Retention(RetentionPolicy.RUNTIME)& @Target({ElementType.FIELD})& public @interface Foo {&&& // Field tag only annotation& }& public class
SampleObjectForTest {&&&
@Foo private
final int annotatedF&&&
private final String stringF&&&
private final long longF&&&
private final Class&?& clazzF&&& public
SampleObjectForTest() {&&&&&
annotatedField = 5;&&&&&
stringField = "someDefaultValue";&&&&&
longField = 1234;&&& }& }& public class
MyExclusionStrategy implements ExclusionStrategy {&&& private final Class&?& typeToS&&& private MyExclusionStrategy(Class&?&
typeToSkip) {&&&&& this.typeToSkip =
typeToS&&& }&&& public boolean shouldSkipClass(Class&?& clazz)
{&&&&& return (clazz ==
typeToSkip);&&& }&&& public boolean shouldSkipField(FieldAttributes f) {&&&&& return f.getAnnotation(Foo.class) !=&&& }& }& public static void main(String[] args) {&&& Gson
gson = new GsonBuilder()&&&&&&& .setExclusionStrategies(new
MyExclusionStrategy(String.class))&&&&&&& .serializeNulls()&&&&&&&
.create();&&& SampleObjectForTest src = new SampleObjectForTest();&&&
String json = gson.toJson(src);&&& System.out.println(json);&
OUTPUT ========{"longField":1234}
JSON Field Naming Support
supports some pre-defined field naming policies to convert the standard
Java field names (i.e. camel cased names starting with lower case ---
"sampleFieldNameInJava") to a Json field name (i.e.
sample_field_name_in_java or SampleFieldNameInJava). See the FieldNamingPolicy class
for information on the pre-defined naming policies.It also has
an annotation based strategy to allows clients to define custom names on
a per field basis.& Note, that the annotation based strategy has field
name validation which will raise "Runtime" exceptions if an invalid
field name is provided as the annotation value.The following is
an example of how to use both Gson naming policy features:private class SomeObject
@SerializedName("custom_naming") private final String someF&
private final String someOtherF& public SomeObject(String
a, String b) {&&& this.someField =&&& this.someOtherField =& }}SomeObject someObject = new SomeObject("first",
"second");Gson gson = new
GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();String jsonRepresentation =
gson.toJson(someObject);System.out.println(jsonRepresentation);======== OUTPUT ========{"custom_naming":"first","SomeOtherField":"second"}
you have a need for custom naming policy (see
this discussion), you can use the @SerializedName annotation.&
State Across Custom Serializers and Deserializers
you need to share state across custom serializers/deserializers (see
this discussion). You can use the following three strategies to
accomplish this:&
Store shared state in static fields
the serializer/deserializer as inner classes of a parent type, and use
the instance fields of parent type to store shared state
Java ThreadLocal
1 and 2 are not thread-safe options, but 3
Designing Gson
See the Gson design document for a discussion of issues we faced while designing Gson. It also include a comparison of Gson with other Java libraries that can be used for Json conversion.
Enhancements to Gson
For the latest list of proposed enhancements
or if you'd like to suggest new ones, see the Issues section under the project website.
共有13个评论
这墙看来翻的够高。
不过俺英文不咋样。 看的晕。 瞄过。
&Gson能说说么？
我记得有一篇国人翻译的，Gson用起来很简单的，最爽的是支持泛型。
&上有个工具类可以使用。
天朝太专横了，想看个原样都要翻墙，上次翻墙摔跤了，再也不敢爬墙了。
引用来自&SudyX&的帖子
天朝太专横了，想看个原样都要翻墙，上次翻墙摔跤了，再也不敢爬墙了。
&呵呵.楼上的是怎么摔的啊?
,It's just the thing I wanted.
这个是GSON 是线程安全的吗？能看懂英语的解释下。
翻墙，红薯没被整成薯片呀？
恩，是被墙了。唉。
.cn/Article/java/70.html（中文的）
,呵呵，英文的也没有问题呀～～～
谢谢，红薯！
简直是太感谢了，正在找这方面的资料
更多开发者职位上
有什么技术问题吗？
红薯的其他问题
类似的话题}