public abstract class TypeAdapter<T> extends Object
public class PointAdapter extends TypeAdapter<Point> {
public Point read(JsonReader reader) throws IOException {
if (reader.peek() == JsonToken.NULL) {
reader.nextNull();
return null;
}
String xy = reader.nextString();
String[] parts = xy.split(",");
int x = Integer.parseInt(parts[0]);
int y = Integer.parseInt(parts[1]);
return new Point(x, y);
}
public void write(JsonWriter writer, Point value) throws IOException {
if (value == null) {
writer.nullValue();
return;
}
String xy = value.getX() + "," + value.getY();
writer.value(xy);
}
}
With this type adapter installed, Gson will convert Points
to JSON as
strings like "5,8"
rather than objects like {"x":5,"y":8}
. In
this case the type adapter binds a rich Java class to a compact JSON value.
The read()
method must read exactly one value
and write()
must write exactly one value.
For primitive types this is means readers should make exactly one call to
nextBoolean()
, nextDouble()
, nextInt()
, nextLong()
, nextString()
or nextNull()
. Writers should make
exactly one call to one of value()
or nullValue()
.
For arrays, type adapters should start with a call to beginArray()
,
convert all elements, and finish with a call to endArray()
. For
objects, they should start with beginObject()
, convert the object,
and finish with endObject()
. Failing to convert a value or converting
too many values may cause the application to crash.
Type adapters should be prepared to read null from the stream and write it
to the stream. Alternatively, they should use nullSafe()
method while
registering the type adapter with Gson. If your Gson
instance
has been configured to GsonBuilder.serializeNulls()
, these nulls will be
written to the final document. Otherwise the value (and the corresponding name
when writing to a JSON object) will be omitted automatically. In either case
your type adapter must handle null.
To use a custom type adapter with Gson, you must register it with a
GsonBuilder
:
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Point.class, new PointAdapter());
// if PointAdapter didn't check for nulls in its read/write methods, you should instead use
// builder.registerTypeAdapter(Point.class, new PointAdapter().nullSafe());
...
Gson gson = builder.create();
Constructor and Description |
---|
TypeAdapter() |
Modifier and Type | Method and Description |
---|---|
T |
fromJson(Reader in)
Converts the JSON document in
in to a Java object. |
T |
fromJson(String json)
Converts the JSON document in
json to a Java object. |
T |
fromJsonTree(JsonElement jsonTree)
Converts
jsonTree to a Java object. |
TypeAdapter<T> |
nullSafe()
This wrapper method is used to make a type adapter null tolerant.
|
abstract T |
read(JsonReader in)
Reads one JSON value (an array, object, string, number, boolean or null)
and converts it to a Java object.
|
String |
toJson(T value)
Converts
value to a JSON document. |
void |
toJson(Writer out,
T value)
Converts
value to a JSON document and writes it to out . |
JsonElement |
toJsonTree(T value)
Converts
value to a JSON tree. |
abstract void |
write(JsonWriter out,
T value)
Writes one JSON value (an array, object, string, number, boolean or null)
for
value . |
public abstract void write(JsonWriter out, T value) throws IOException
value
.value
- the Java object to write. May be null.IOException
public final void toJson(Writer out, T value) throws IOException
value
to a JSON document and writes it to out
.
Unlike Gson's similar toJson
method, this write is strict. Create a lenient
JsonWriter
and call
write(com.google.gson.stream.JsonWriter, Object)
for lenient
writing.value
- the Java object to convert. May be null.IOException
public final TypeAdapter<T> nullSafe()
Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class,
new TypeAdapter<Foo>() {
public Foo read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
// read a Foo from in and return it
}
public void write(JsonWriter out, Foo src) throws IOException {
if (src == null) {
out.nullValue();
return;
}
// write src as JSON to out
}
}).create();
You can avoid this boilerplate handling of nulls by wrapping your type adapter with
this method. Here is how we will rewrite the above example:
Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class,
new TypeAdapter<Foo>() {
public Foo read(JsonReader in) throws IOException {
// read a Foo from in and return it
}
public void write(JsonWriter out, Foo src) throws IOException {
// write src as JSON to out
}
}.nullSafe()).create();
Note that we didn't need to check for nulls in our type adapter after we used nullSafe.public final String toJson(T value)
value
to a JSON document. Unlike Gson's similar toJson
method, this write is strict. Create a lenient
JsonWriter
and call
write(com.google.gson.stream.JsonWriter, Object)
for lenient
writing.value
- the Java object to convert. May be null.public final JsonElement toJsonTree(T value)
value
to a JSON tree.value
- the Java object to convert. May be null.JsonNull
.public abstract T read(JsonReader in) throws IOException
IOException
public final T fromJson(Reader in) throws IOException
in
to a Java object. Unlike Gson's
similar fromJson
method, this
read is strict. Create a lenient
JsonReader
and call read(JsonReader)
for lenient reading.IOException
public final T fromJson(String json) throws IOException
json
to a Java object. Unlike Gson's
similar fromJson
method, this read is
strict. Create a lenient
JsonReader
and call read(JsonReader)
for lenient reading.IOException
public final T fromJsonTree(JsonElement jsonTree)
jsonTree
to a Java object.jsonTree
- the Java object to convert. May be JsonNull
.Copyright © 2016. All Rights Reserved.