forked from loafle/openapi-generator-original
7ce38aae38
* remove duplicated imports * fix model import in java * update generator docs * fix model import for retrofit2 client
532 lines
16 KiB
Plaintext
532 lines
16 KiB
Plaintext
{{>licenseInfo}}
|
|
|
|
package {{invokerPackage}};
|
|
|
|
import com.google.gson.Gson;
|
|
import com.google.gson.GsonBuilder;
|
|
import com.google.gson.JsonParseException;
|
|
import com.google.gson.TypeAdapter;
|
|
import com.google.gson.internal.bind.util.ISO8601Utils;
|
|
import com.google.gson.stream.JsonReader;
|
|
import com.google.gson.stream.JsonWriter;
|
|
import com.google.gson.JsonElement;
|
|
import io.gsonfire.GsonFireBuilder;
|
|
import io.gsonfire.TypeSelector;
|
|
{{#joda}}
|
|
import org.joda.time.DateTime;
|
|
import org.joda.time.LocalDate;
|
|
import org.joda.time.format.DateTimeFormatter;
|
|
import org.joda.time.format.DateTimeFormatterBuilder;
|
|
import org.joda.time.format.ISODateTimeFormat;
|
|
{{/joda}}
|
|
{{#threetenbp}}
|
|
import org.threeten.bp.LocalDate;
|
|
import org.threeten.bp.OffsetDateTime;
|
|
import org.threeten.bp.format.DateTimeFormatter;
|
|
{{/threetenbp}}
|
|
|
|
{{#models.0}}
|
|
import {{modelPackage}}.*;
|
|
{{/models.0}}
|
|
import okio.ByteString;
|
|
|
|
import java.io.IOException;
|
|
import java.io.StringReader;
|
|
import java.lang.reflect.Type;
|
|
import java.text.DateFormat;
|
|
import java.text.ParseException;
|
|
import java.text.ParsePosition;
|
|
{{#java8}}
|
|
import java.time.LocalDate;
|
|
import java.time.OffsetDateTime;
|
|
import java.time.format.DateTimeFormatter;
|
|
{{/java8}}
|
|
import java.util.Date;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.HashMap;
|
|
|
|
public class JSON {
|
|
private Gson gson;
|
|
private boolean isLenientOnJson = false;
|
|
private DateTypeAdapter dateTypeAdapter = new DateTypeAdapter();
|
|
private SqlDateTypeAdapter sqlDateTypeAdapter = new SqlDateTypeAdapter();
|
|
{{#joda}}
|
|
private DateTimeTypeAdapter dateTimeTypeAdapter = new DateTimeTypeAdapter();
|
|
private LocalDateTypeAdapter localDateTypeAdapter = new LocalDateTypeAdapter();
|
|
{{/joda}}
|
|
{{#jsr310}}
|
|
private OffsetDateTimeTypeAdapter offsetDateTimeTypeAdapter = new OffsetDateTimeTypeAdapter();
|
|
private LocalDateTypeAdapter localDateTypeAdapter = new LocalDateTypeAdapter();
|
|
{{/jsr310}}
|
|
private ByteArrayAdapter byteArrayAdapter = new ByteArrayAdapter();
|
|
|
|
public static GsonBuilder createGson() {
|
|
GsonFireBuilder fireBuilder = new GsonFireBuilder()
|
|
{{#models}}
|
|
{{#model}}
|
|
{{#discriminator}}
|
|
.registerTypeSelector({{classname}}.class, new TypeSelector() {
|
|
@Override
|
|
public Class getClassForElement(JsonElement readElement) {
|
|
Map classByDiscriminatorValue = new HashMap();
|
|
{{#mappedModels}}
|
|
classByDiscriminatorValue.put("{{mappingName}}".toUpperCase(Locale.ROOT), {{modelName}}.class);
|
|
{{/mappedModels}}
|
|
classByDiscriminatorValue.put("{{classname}}".toUpperCase(Locale.ROOT), {{classname}}.class);
|
|
return getClassByDiscriminator(classByDiscriminatorValue,
|
|
getDiscriminatorValue(readElement, "{{{propertyName}}}"));
|
|
}
|
|
})
|
|
{{/discriminator}}
|
|
{{/model}}
|
|
{{/models}}
|
|
;
|
|
GsonBuilder builder = fireBuilder.createGsonBuilder();
|
|
{{#disableHtmlEscaping}}
|
|
builder.disableHtmlEscaping();
|
|
{{/disableHtmlEscaping}}
|
|
return builder;
|
|
}
|
|
|
|
private static String getDiscriminatorValue(JsonElement readElement, String discriminatorField) {
|
|
JsonElement element = readElement.getAsJsonObject().get(discriminatorField);
|
|
if (null == element) {
|
|
throw new IllegalArgumentException("missing discriminator field: <" + discriminatorField + ">");
|
|
}
|
|
return element.getAsString();
|
|
}
|
|
|
|
private static Class getClassByDiscriminator(Map classByDiscriminatorValue, String discriminatorValue) {
|
|
Class clazz = (Class) classByDiscriminatorValue.get(discriminatorValue.toUpperCase(Locale.ROOT));
|
|
if (null == clazz) {
|
|
throw new IllegalArgumentException("cannot determine model class of name: <" + discriminatorValue + ">");
|
|
}
|
|
return clazz;
|
|
}
|
|
|
|
public JSON() {
|
|
gson = createGson()
|
|
.registerTypeAdapter(Date.class, dateTypeAdapter)
|
|
.registerTypeAdapter(java.sql.Date.class, sqlDateTypeAdapter)
|
|
{{#joda}}
|
|
.registerTypeAdapter(DateTime.class, dateTimeTypeAdapter)
|
|
.registerTypeAdapter(LocalDate.class, localDateTypeAdapter)
|
|
{{/joda}}
|
|
{{#jsr310}}
|
|
.registerTypeAdapter(OffsetDateTime.class, offsetDateTimeTypeAdapter)
|
|
.registerTypeAdapter(LocalDate.class, localDateTypeAdapter)
|
|
{{/jsr310}}
|
|
.registerTypeAdapter(byte[].class, byteArrayAdapter)
|
|
.create();
|
|
}
|
|
|
|
/**
|
|
* Get Gson.
|
|
*
|
|
* @return Gson
|
|
*/
|
|
public Gson getGson() {
|
|
return gson;
|
|
}
|
|
|
|
/**
|
|
* Set Gson.
|
|
*
|
|
* @param gson Gson
|
|
* @return JSON
|
|
*/
|
|
public JSON setGson(Gson gson) {
|
|
this.gson = gson;
|
|
return this;
|
|
}
|
|
|
|
public JSON setLenientOnJson(boolean lenientOnJson) {
|
|
isLenientOnJson = lenientOnJson;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Serialize the given Java object into JSON string.
|
|
*
|
|
* @param obj Object
|
|
* @return String representation of the JSON
|
|
*/
|
|
public String serialize(Object obj) {
|
|
return gson.toJson(obj);
|
|
}
|
|
|
|
/**
|
|
* Deserialize the given JSON string to Java object.
|
|
*
|
|
* @param <T> Type
|
|
* @param body The JSON string
|
|
* @param returnType The type to deserialize into
|
|
* @return The deserialized Java object
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public <T> T deserialize(String body, Type returnType) {
|
|
try {
|
|
if (isLenientOnJson) {
|
|
JsonReader jsonReader = new JsonReader(new StringReader(body));
|
|
// see https://google-gson.googlecode.com/svn/trunk/gson/docs/javadocs/com/google/gson/stream/JsonReader.html#setLenient(boolean)
|
|
jsonReader.setLenient(true);
|
|
return gson.fromJson(jsonReader, returnType);
|
|
} else {
|
|
return gson.fromJson(body, returnType);
|
|
}
|
|
} catch (JsonParseException e) {
|
|
// Fallback processing when failed to parse JSON form response body:
|
|
// return the response body string directly for the String return type;
|
|
if (returnType.equals(String.class)) {
|
|
return (T) body;
|
|
} else {
|
|
throw (e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gson TypeAdapter for Byte Array type
|
|
*/
|
|
public class ByteArrayAdapter extends TypeAdapter<byte[]> {
|
|
|
|
@Override
|
|
public void write(JsonWriter out, byte[] value) throws IOException {
|
|
if (value == null) {
|
|
out.nullValue();
|
|
} else {
|
|
out.value(ByteString.of(value).base64());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public byte[] read(JsonReader in) throws IOException {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String bytesAsBase64 = in.nextString();
|
|
ByteString byteString = ByteString.decodeBase64(bytesAsBase64);
|
|
return byteString.toByteArray();
|
|
}
|
|
}
|
|
}
|
|
|
|
{{#joda}}
|
|
/**
|
|
* Gson TypeAdapter for Joda DateTime type
|
|
*/
|
|
public static class DateTimeTypeAdapter extends TypeAdapter<DateTime> {
|
|
|
|
private DateTimeFormatter formatter;
|
|
|
|
public DateTimeTypeAdapter() {
|
|
this(new DateTimeFormatterBuilder()
|
|
.append(ISODateTimeFormat.dateTime().getPrinter(), ISODateTimeFormat.dateOptionalTimeParser().getParser())
|
|
.toFormatter());
|
|
}
|
|
|
|
public DateTimeTypeAdapter(DateTimeFormatter formatter) {
|
|
this.formatter = formatter;
|
|
}
|
|
|
|
public void setFormat(DateTimeFormatter dateFormat) {
|
|
this.formatter = dateFormat;
|
|
}
|
|
|
|
@Override
|
|
public void write(JsonWriter out, DateTime date) throws IOException {
|
|
if (date == null) {
|
|
out.nullValue();
|
|
} else {
|
|
out.value(formatter.print(date));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public DateTime read(JsonReader in) throws IOException {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String date = in.nextString();
|
|
return formatter.parseDateTime(date);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gson TypeAdapter for Joda LocalDate type
|
|
*/
|
|
public class LocalDateTypeAdapter extends TypeAdapter<LocalDate> {
|
|
|
|
private DateTimeFormatter formatter;
|
|
|
|
public LocalDateTypeAdapter() {
|
|
this(ISODateTimeFormat.date());
|
|
}
|
|
|
|
public LocalDateTypeAdapter(DateTimeFormatter formatter) {
|
|
this.formatter = formatter;
|
|
}
|
|
|
|
public void setFormat(DateTimeFormatter dateFormat) {
|
|
this.formatter = dateFormat;
|
|
}
|
|
|
|
@Override
|
|
public void write(JsonWriter out, LocalDate date) throws IOException {
|
|
if (date == null) {
|
|
out.nullValue();
|
|
} else {
|
|
out.value(formatter.print(date));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public LocalDate read(JsonReader in) throws IOException {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String date = in.nextString();
|
|
return formatter.parseLocalDate(date);
|
|
}
|
|
}
|
|
}
|
|
|
|
public JSON setDateTimeFormat(DateTimeFormatter dateFormat) {
|
|
dateTimeTypeAdapter.setFormat(dateFormat);
|
|
return this;
|
|
}
|
|
|
|
public JSON setLocalDateFormat(DateTimeFormatter dateFormat) {
|
|
localDateTypeAdapter.setFormat(dateFormat);
|
|
return this;
|
|
}
|
|
|
|
{{/joda}}
|
|
{{#jsr310}}
|
|
/**
|
|
* Gson TypeAdapter for JSR310 OffsetDateTime type
|
|
*/
|
|
public static class OffsetDateTimeTypeAdapter extends TypeAdapter<OffsetDateTime> {
|
|
|
|
private DateTimeFormatter formatter;
|
|
|
|
public OffsetDateTimeTypeAdapter() {
|
|
this(DateTimeFormatter.ISO_OFFSET_DATE_TIME);
|
|
}
|
|
|
|
public OffsetDateTimeTypeAdapter(DateTimeFormatter formatter) {
|
|
this.formatter = formatter;
|
|
}
|
|
|
|
public void setFormat(DateTimeFormatter dateFormat) {
|
|
this.formatter = dateFormat;
|
|
}
|
|
|
|
@Override
|
|
public void write(JsonWriter out, OffsetDateTime date) throws IOException {
|
|
if (date == null) {
|
|
out.nullValue();
|
|
} else {
|
|
out.value(formatter.format(date));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public OffsetDateTime read(JsonReader in) throws IOException {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String date = in.nextString();
|
|
if (date.endsWith("+0000")) {
|
|
date = date.substring(0, date.length()-5) + "Z";
|
|
}
|
|
return OffsetDateTime.parse(date, formatter);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gson TypeAdapter for JSR310 LocalDate type
|
|
*/
|
|
public class LocalDateTypeAdapter extends TypeAdapter<LocalDate> {
|
|
|
|
private DateTimeFormatter formatter;
|
|
|
|
public LocalDateTypeAdapter() {
|
|
this(DateTimeFormatter.ISO_LOCAL_DATE);
|
|
}
|
|
|
|
public LocalDateTypeAdapter(DateTimeFormatter formatter) {
|
|
this.formatter = formatter;
|
|
}
|
|
|
|
public void setFormat(DateTimeFormatter dateFormat) {
|
|
this.formatter = dateFormat;
|
|
}
|
|
|
|
@Override
|
|
public void write(JsonWriter out, LocalDate date) throws IOException {
|
|
if (date == null) {
|
|
out.nullValue();
|
|
} else {
|
|
out.value(formatter.format(date));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public LocalDate read(JsonReader in) throws IOException {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String date = in.nextString();
|
|
return LocalDate.parse(date, formatter);
|
|
}
|
|
}
|
|
}
|
|
|
|
public JSON setOffsetDateTimeFormat(DateTimeFormatter dateFormat) {
|
|
offsetDateTimeTypeAdapter.setFormat(dateFormat);
|
|
return this;
|
|
}
|
|
|
|
public JSON setLocalDateFormat(DateTimeFormatter dateFormat) {
|
|
localDateTypeAdapter.setFormat(dateFormat);
|
|
return this;
|
|
}
|
|
|
|
{{/jsr310}}
|
|
/**
|
|
* Gson TypeAdapter for java.sql.Date type
|
|
* If the dateFormat is null, a simple "yyyy-MM-dd" format will be used
|
|
* (more efficient than SimpleDateFormat).
|
|
*/
|
|
public static class SqlDateTypeAdapter extends TypeAdapter<java.sql.Date> {
|
|
|
|
private DateFormat dateFormat;
|
|
|
|
public SqlDateTypeAdapter() {}
|
|
|
|
public SqlDateTypeAdapter(DateFormat dateFormat) {
|
|
this.dateFormat = dateFormat;
|
|
}
|
|
|
|
public void setFormat(DateFormat dateFormat) {
|
|
this.dateFormat = dateFormat;
|
|
}
|
|
|
|
@Override
|
|
public void write(JsonWriter out, java.sql.Date date) throws IOException {
|
|
if (date == null) {
|
|
out.nullValue();
|
|
} else {
|
|
String value;
|
|
if (dateFormat != null) {
|
|
value = dateFormat.format(date);
|
|
} else {
|
|
value = date.toString();
|
|
}
|
|
out.value(value);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public java.sql.Date read(JsonReader in) throws IOException {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String date = in.nextString();
|
|
try {
|
|
if (dateFormat != null) {
|
|
return new java.sql.Date(dateFormat.parse(date).getTime());
|
|
}
|
|
return new java.sql.Date(ISO8601Utils.parse(date, new ParsePosition(0)).getTime());
|
|
} catch (ParseException e) {
|
|
throw new JsonParseException(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gson TypeAdapter for java.util.Date type
|
|
* If the dateFormat is null, ISO8601Utils will be used.
|
|
*/
|
|
public static class DateTypeAdapter extends TypeAdapter<Date> {
|
|
|
|
private DateFormat dateFormat;
|
|
|
|
public DateTypeAdapter() {}
|
|
|
|
public DateTypeAdapter(DateFormat dateFormat) {
|
|
this.dateFormat = dateFormat;
|
|
}
|
|
|
|
public void setFormat(DateFormat dateFormat) {
|
|
this.dateFormat = dateFormat;
|
|
}
|
|
|
|
@Override
|
|
public void write(JsonWriter out, Date date) throws IOException {
|
|
if (date == null) {
|
|
out.nullValue();
|
|
} else {
|
|
String value;
|
|
if (dateFormat != null) {
|
|
value = dateFormat.format(date);
|
|
} else {
|
|
value = ISO8601Utils.format(date, true);
|
|
}
|
|
out.value(value);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Date read(JsonReader in) throws IOException {
|
|
try {
|
|
switch (in.peek()) {
|
|
case NULL:
|
|
in.nextNull();
|
|
return null;
|
|
default:
|
|
String date = in.nextString();
|
|
try {
|
|
if (dateFormat != null) {
|
|
return dateFormat.parse(date);
|
|
}
|
|
return ISO8601Utils.parse(date, new ParsePosition(0));
|
|
} catch (ParseException e) {
|
|
throw new JsonParseException(e);
|
|
}
|
|
}
|
|
} catch (IllegalArgumentException e) {
|
|
throw new JsonParseException(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public JSON setDateFormat(DateFormat dateFormat) {
|
|
dateTypeAdapter.setFormat(dateFormat);
|
|
return this;
|
|
}
|
|
|
|
public JSON setSqlDateFormat(DateFormat dateFormat) {
|
|
sqlDateTypeAdapter.setFormat(dateFormat);
|
|
return this;
|
|
}
|
|
|
|
}
|