From bcd20131cc4dca1a5a02edfbeb83d1c23ce56e4f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9C=A8=E8=91=89=20Scarlet?= <93977077+mukjepscarlet@users.noreply.github.com> Date: Tue, 25 Nov 2025 23:27:10 +0800 Subject: [PATCH 1/7] refactor: move derived adapters from Gson to TypeAdapters --- gson/src/main/java/com/google/gson/Gson.java | 159 +--------------- .../google/gson/LongSerializationPolicy.java | 16 ++ .../gson/internal/bind/TypeAdapters.java | 175 +++++++++++++++--- .../gson/internal/sql/SqlTypesSupport.java | 11 ++ 4 files changed, 182 insertions(+), 179 deletions(-) diff --git a/gson/src/main/java/com/google/gson/Gson.java b/gson/src/main/java/com/google/gson/Gson.java index ef8c81e378..282120fa98 100644 --- a/gson/src/main/java/com/google/gson/Gson.java +++ b/gson/src/main/java/com/google/gson/Gson.java @@ -16,11 +16,12 @@ package com.google.gson; +import static com.google.gson.internal.bind.TypeAdapters.*; + import com.google.gson.annotations.JsonAdapter; import com.google.gson.internal.ConstructorConstructor; import com.google.gson.internal.Excluder; import com.google.gson.internal.GsonBuildConfig; -import com.google.gson.internal.LazilyParsedNumber; import com.google.gson.internal.Primitives; import com.google.gson.internal.Streams; import com.google.gson.internal.bind.ArrayTypeAdapter; @@ -47,8 +48,6 @@ import java.io.StringReader; import java.io.Writer; import java.lang.reflect.Type; -import java.math.BigDecimal; -import java.math.BigInteger; import java.text.DateFormat; import java.util.ArrayList; import java.util.Collections; @@ -337,7 +336,7 @@ public Gson() { factories.add(TypeAdapters.BOOLEAN_FACTORY); factories.add(TypeAdapters.BYTE_FACTORY); factories.add(TypeAdapters.SHORT_FACTORY); - TypeAdapter longAdapter = longAdapter(longSerializationPolicy); + TypeAdapter longAdapter = longSerializationPolicy.typeAdapter(); factories.add(TypeAdapters.newFactory(long.class, Long.class, longAdapter)); factories.add( TypeAdapters.newFactory( @@ -355,12 +354,11 @@ public Gson() { factories.add(TypeAdapters.CHARACTER_FACTORY); factories.add(TypeAdapters.STRING_BUILDER_FACTORY); factories.add(TypeAdapters.STRING_BUFFER_FACTORY); - factories.add(TypeAdapters.newFactory(BigDecimal.class, TypeAdapters.BIG_DECIMAL)); - factories.add(TypeAdapters.newFactory(BigInteger.class, TypeAdapters.BIG_INTEGER)); + factories.add(TypeAdapters.BIG_DECIMAL_FACTORY); + factories.add(TypeAdapters.BIG_INTEGER_FACTORY); // Add adapter for LazilyParsedNumber because user can obtain it from Gson and then try to // serialize it again - factories.add( - TypeAdapters.newFactory(LazilyParsedNumber.class, TypeAdapters.LAZILY_PARSED_NUMBER)); + factories.add(TypeAdapters.LAZILY_PARSED_NUMBER_FACTORY); factories.add(TypeAdapters.URL_FACTORY); factories.add(TypeAdapters.URI_FACTORY); factories.add(TypeAdapters.UUID_FACTORY); @@ -370,13 +368,7 @@ public Gson() { factories.add(TypeAdapters.BIT_SET_FACTORY); factories.add(DefaultDateTypeAdapter.DEFAULT_STYLE_FACTORY); factories.add(TypeAdapters.CALENDAR_FACTORY); - - if (SqlTypesSupport.SUPPORTS_SQL_TYPES) { - factories.add(SqlTypesSupport.TIME_FACTORY); - factories.add(SqlTypesSupport.DATE_FACTORY); - factories.add(SqlTypesSupport.TIMESTAMP_FACTORY); - } - + factories.addAll(SqlTypesSupport.SQL_TYPE_FACTORIES); factories.add(ArrayTypeAdapter.FACTORY); factories.add(TypeAdapters.CLASS_FACTORY); @@ -446,143 +438,6 @@ public boolean htmlSafe() { return htmlSafe; } - private TypeAdapter doubleAdapter(boolean serializeSpecialFloatingPointValues) { - if (serializeSpecialFloatingPointValues) { - return TypeAdapters.DOUBLE; - } - return new TypeAdapter() { - @Override - public Double read(JsonReader in) throws IOException { - if (in.peek() == JsonToken.NULL) { - in.nextNull(); - return null; - } - return in.nextDouble(); - } - - @Override - public void write(JsonWriter out, Number value) throws IOException { - if (value == null) { - out.nullValue(); - return; - } - double doubleValue = value.doubleValue(); - checkValidFloatingPoint(doubleValue); - out.value(doubleValue); - } - }; - } - - private TypeAdapter floatAdapter(boolean serializeSpecialFloatingPointValues) { - if (serializeSpecialFloatingPointValues) { - return TypeAdapters.FLOAT; - } - return new TypeAdapter() { - @Override - public Float read(JsonReader in) throws IOException { - if (in.peek() == JsonToken.NULL) { - in.nextNull(); - return null; - } - return (float) in.nextDouble(); - } - - @Override - public void write(JsonWriter out, Number value) throws IOException { - if (value == null) { - out.nullValue(); - return; - } - float floatValue = value.floatValue(); - checkValidFloatingPoint(floatValue); - // For backward compatibility don't call `JsonWriter.value(float)` because that method has - // been newly added and not all custom JsonWriter implementations might override it yet - Number floatNumber = value instanceof Float ? value : floatValue; - out.value(floatNumber); - } - }; - } - - static void checkValidFloatingPoint(double value) { - if (Double.isNaN(value) || Double.isInfinite(value)) { - throw new IllegalArgumentException( - value - + " is not a valid double value as per JSON specification. To override this" - + " behavior, use GsonBuilder.serializeSpecialFloatingPointValues() method."); - } - } - - private static TypeAdapter longAdapter(LongSerializationPolicy longSerializationPolicy) { - if (longSerializationPolicy == LongSerializationPolicy.DEFAULT) { - return TypeAdapters.LONG; - } - return new TypeAdapter() { - @Override - public Number read(JsonReader in) throws IOException { - if (in.peek() == JsonToken.NULL) { - in.nextNull(); - return null; - } - return in.nextLong(); - } - - @Override - public void write(JsonWriter out, Number value) throws IOException { - if (value == null) { - out.nullValue(); - return; - } - out.value(value.toString()); - } - }; - } - - private static TypeAdapter atomicLongAdapter(TypeAdapter longAdapter) { - return new TypeAdapter() { - @Override - public void write(JsonWriter out, AtomicLong value) throws IOException { - longAdapter.write(out, value.get()); - } - - @Override - public AtomicLong read(JsonReader in) throws IOException { - Number value = longAdapter.read(in); - return new AtomicLong(value.longValue()); - } - }.nullSafe(); - } - - private static TypeAdapter atomicLongArrayAdapter( - TypeAdapter longAdapter) { - return new TypeAdapter() { - @Override - public void write(JsonWriter out, AtomicLongArray value) throws IOException { - out.beginArray(); - for (int i = 0, length = value.length(); i < length; i++) { - longAdapter.write(out, value.get(i)); - } - out.endArray(); - } - - @Override - public AtomicLongArray read(JsonReader in) throws IOException { - List list = new ArrayList<>(); - in.beginArray(); - while (in.hasNext()) { - long value = longAdapter.read(in).longValue(); - list.add(value); - } - in.endArray(); - int length = list.size(); - AtomicLongArray array = new AtomicLongArray(length); - for (int i = 0; i < length; ++i) { - array.set(i, list.get(i)); - } - return array; - } - }.nullSafe(); - } - /** * Returns the type adapter for {@code type}. * diff --git a/gson/src/main/java/com/google/gson/LongSerializationPolicy.java b/gson/src/main/java/com/google/gson/LongSerializationPolicy.java index df7c8fa167..2e2f17a59a 100644 --- a/gson/src/main/java/com/google/gson/LongSerializationPolicy.java +++ b/gson/src/main/java/com/google/gson/LongSerializationPolicy.java @@ -16,6 +16,8 @@ package com.google.gson; +import com.google.gson.internal.bind.TypeAdapters; + /** * Defines the expected format for a {@code long} or {@code Long} type when it is serialized. * @@ -39,6 +41,11 @@ public JsonElement serialize(Long value) { } return new JsonPrimitive(value); } + + @Override + TypeAdapter typeAdapter() { + return TypeAdapters.LONG; + } }, /** @@ -55,6 +62,11 @@ public JsonElement serialize(Long value) { } return new JsonPrimitive(value.toString()); } + + @Override + TypeAdapter typeAdapter() { + return TypeAdapters.LONG_AS_STRING; + } }; /** @@ -64,4 +76,8 @@ public JsonElement serialize(Long value) { * @return the serialized version of {@code value} */ public abstract JsonElement serialize(Long value); + + /** Returns the corresponding {@link TypeAdapter} for this serialization policy. */ + // Internal method + abstract TypeAdapter typeAdapter(); } diff --git a/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java b/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java index 71f98c0034..8c7f166e77 100644 --- a/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java +++ b/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java @@ -43,11 +43,14 @@ import java.util.GregorianCalendar; import java.util.List; import java.util.Locale; +import java.util.Objects; import java.util.StringTokenizer; import java.util.UUID; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicIntegerArray; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicLongArray; /** * Type adapters for basic types. More complex adapters exist as separate classes in the enclosing @@ -299,6 +302,22 @@ public void write(JsonWriter out, AtomicInteger value) throws IOException { public static final TypeAdapterFactory ATOMIC_INTEGER_FACTORY = newFactory(AtomicInteger.class, TypeAdapters.ATOMIC_INTEGER); + public static TypeAdapter atomicLongAdapter(TypeAdapter longAdapter) { + Objects.requireNonNull(longAdapter); + return new TypeAdapter() { + @Override + public AtomicLong read(JsonReader in) throws IOException { + Number value = longAdapter.read(in); + return new AtomicLong(value.longValue()); + } + + @Override + public void write(JsonWriter out, AtomicLong value) throws IOException { + longAdapter.write(out, value.get()); + } + }.nullSafe(); + } + public static final TypeAdapter ATOMIC_BOOLEAN = new TypeAdapter() { @Override @@ -349,6 +368,38 @@ public void write(JsonWriter out, AtomicIntegerArray value) throws IOException { public static final TypeAdapterFactory ATOMIC_INTEGER_ARRAY_FACTORY = newFactory(AtomicIntegerArray.class, TypeAdapters.ATOMIC_INTEGER_ARRAY); + public static TypeAdapter atomicLongArrayAdapter( + TypeAdapter longAdapter) { + Objects.requireNonNull(longAdapter); + return new TypeAdapter() { + @Override + public AtomicLongArray read(JsonReader in) throws IOException { + List list = new ArrayList<>(); + in.beginArray(); + while (in.hasNext()) { + long value = longAdapter.read(in).longValue(); + list.add(value); + } + in.endArray(); + int length = list.size(); + AtomicLongArray array = new AtomicLongArray(length); + for (int i = 0; i < length; ++i) { + array.set(i, list.get(i)); + } + return array; + } + + @Override + public void write(JsonWriter out, AtomicLongArray value) throws IOException { + out.beginArray(); + for (int i = 0, length = value.length(); i < length; i++) { + longAdapter.write(out, value.get(i)); + } + out.endArray(); + } + }.nullSafe(); + } + public static final TypeAdapter LONG = new TypeAdapter() { @Override @@ -374,7 +425,7 @@ public void write(JsonWriter out, Number value) throws IOException { } }; - public static final TypeAdapter FLOAT = + public static final TypeAdapter LONG_AS_STRING = new TypeAdapter() { @Override public Number read(JsonReader in) throws IOException { @@ -382,43 +433,104 @@ public Number read(JsonReader in) throws IOException { in.nextNull(); return null; } - return (float) in.nextDouble(); + return in.nextLong(); } @Override public void write(JsonWriter out, Number value) throws IOException { if (value == null) { out.nullValue(); - } else { - // For backward compatibility don't call `JsonWriter.value(float)` because that method - // has been newly added and not all custom JsonWriter implementations might override - // it yet - Number floatNumber = value instanceof Float ? value : value.floatValue(); - out.value(floatNumber); + return; } + out.value(value.toString()); } }; - public static final TypeAdapter DOUBLE = - new TypeAdapter() { - @Override - public Number read(JsonReader in) throws IOException { - if (in.peek() == JsonToken.NULL) { - in.nextNull(); - return null; - } - return in.nextDouble(); - } + private static class FloatAdapter extends TypeAdapter { + private final boolean strict; - @Override - public void write(JsonWriter out, Number value) throws IOException { - if (value == null) { - out.nullValue(); - } else { - out.value(value.doubleValue()); - } - } - }; + FloatAdapter(boolean strict) { + this.strict = strict; + } + + @Override + public Float read(JsonReader in) throws IOException { + if (in.peek() == JsonToken.NULL) { + in.nextNull(); + return null; + } + return (float) in.nextDouble(); + } + + @Override + public void write(JsonWriter out, Number value) throws IOException { + if (value == null) { + out.nullValue(); + return; + } + float floatValue = value.floatValue(); + if (strict) { + checkValidFloatingPoint(floatValue); + } + // For backward compatibility don't call `JsonWriter.value(float)` because that method has + // been newly added and not all custom JsonWriter implementations might override it yet + Number floatNumber = value instanceof Float ? value : floatValue; + out.value(floatNumber); + } + } + + private static class DoubleAdapter extends TypeAdapter { + private final boolean strict; + + DoubleAdapter(boolean strict) { + this.strict = strict; + } + + @Override + public Double read(JsonReader in) throws IOException { + if (in.peek() == JsonToken.NULL) { + in.nextNull(); + return null; + } + return in.nextDouble(); + } + + @Override + public void write(JsonWriter out, Number value) throws IOException { + if (value == null) { + out.nullValue(); + return; + } + double doubleValue = value.doubleValue(); + if (strict) { + checkValidFloatingPoint(doubleValue); + } + out.value(doubleValue); + } + } + + private static void checkValidFloatingPoint(double value) { + if (Double.isNaN(value) || Double.isInfinite(value)) { + throw new IllegalArgumentException( + value + + " is not a valid double value as per JSON specification. To override this" + + " behavior, use GsonBuilder.serializeSpecialFloatingPointValues() method."); + } + } + + public static final TypeAdapter FLOAT = new FloatAdapter(false); + public static final TypeAdapter FLOAT_STRICT = new FloatAdapter(true); + + public static TypeAdapter floatAdapter(boolean serializeSpecialFloatingPointValues) { + return serializeSpecialFloatingPointValues ? TypeAdapters.FLOAT : TypeAdapters.FLOAT_STRICT; + } + + public static final TypeAdapter DOUBLE = new DoubleAdapter(false); + public static final TypeAdapter DOUBLE_STRICT = new DoubleAdapter(true); + + public static TypeAdapter doubleAdapter(boolean serializeSpecialFloatingPointValues) { + return serializeSpecialFloatingPointValues ? TypeAdapters.DOUBLE : TypeAdapters.DOUBLE_STRICT; + } public static final TypeAdapter CHARACTER = new TypeAdapter() { @@ -490,6 +602,9 @@ public void write(JsonWriter out, BigDecimal value) throws IOException { } }; + public static final TypeAdapterFactory BIG_DECIMAL_FACTORY = + newFactory(BigDecimal.class, BIG_DECIMAL); + public static final TypeAdapter BIG_INTEGER = new TypeAdapter() { @Override @@ -513,6 +628,9 @@ public void write(JsonWriter out, BigInteger value) throws IOException { } }; + public static final TypeAdapterFactory BIG_INTEGER_FACTORY = + newFactory(BigInteger.class, BIG_INTEGER); + public static final TypeAdapter LAZILY_PARSED_NUMBER = new TypeAdapter() { // Normally users should not be able to access and deserialize LazilyParsedNumber because @@ -533,6 +651,9 @@ public void write(JsonWriter out, LazilyParsedNumber value) throws IOException { } }; + public static final TypeAdapterFactory LAZILY_PARSED_NUMBER_FACTORY = + newFactory(LazilyParsedNumber.class, LAZILY_PARSED_NUMBER); + public static final TypeAdapterFactory STRING_FACTORY = newFactory(String.class, STRING); public static final TypeAdapter STRING_BUILDER = diff --git a/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java b/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java index e1a384b0b9..6edacbcec2 100644 --- a/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java +++ b/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java @@ -19,7 +19,10 @@ import com.google.gson.TypeAdapterFactory; import com.google.gson.internal.bind.DefaultDateTypeAdapter.DateType; import java.sql.Timestamp; +import java.util.Arrays; +import java.util.Collections; import java.util.Date; +import java.util.List; /** * Encapsulates access to {@code java.sql} types, to allow Gson to work without the {@code java.sql} @@ -42,6 +45,8 @@ public final class SqlTypesSupport { public static final TypeAdapterFactory TIME_FACTORY; public static final TypeAdapterFactory TIMESTAMP_FACTORY; + public static final List SQL_TYPE_FACTORIES; + static { boolean sqlTypesSupport; try { @@ -71,6 +76,10 @@ protected Timestamp deserialize(Date date) { DATE_FACTORY = SqlDateTypeAdapter.FACTORY; TIME_FACTORY = SqlTimeTypeAdapter.FACTORY; TIMESTAMP_FACTORY = SqlTimestampTypeAdapter.FACTORY; + + SQL_TYPE_FACTORIES = + Collections.unmodifiableList( + Arrays.asList(TIME_FACTORY, DATE_FACTORY, TIMESTAMP_FACTORY)); } else { DATE_DATE_TYPE = null; TIMESTAMP_DATE_TYPE = null; @@ -78,6 +87,8 @@ protected Timestamp deserialize(Date date) { DATE_FACTORY = null; TIME_FACTORY = null; TIMESTAMP_FACTORY = null; + + SQL_TYPE_FACTORIES = Collections.emptyList(); } } From f983a303073180a666019c2e3f7195233b22d1a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9C=A8=E8=91=89=20Scarlet?= <93977077+mukjepscarlet@users.noreply.github.com> Date: Tue, 25 Nov 2025 23:42:11 +0800 Subject: [PATCH 2/7] fix wildcard import --- gson/src/main/java/com/google/gson/Gson.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/gson/src/main/java/com/google/gson/Gson.java b/gson/src/main/java/com/google/gson/Gson.java index 282120fa98..494244d451 100644 --- a/gson/src/main/java/com/google/gson/Gson.java +++ b/gson/src/main/java/com/google/gson/Gson.java @@ -16,8 +16,6 @@ package com.google.gson; -import static com.google.gson.internal.bind.TypeAdapters.*; - import com.google.gson.annotations.JsonAdapter; import com.google.gson.internal.ConstructorConstructor; import com.google.gson.internal.Excluder; @@ -60,6 +58,11 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicLongArray; +import static com.google.gson.internal.bind.TypeAdapters.atomicLongAdapter; +import static com.google.gson.internal.bind.TypeAdapters.atomicLongArrayAdapter; +import static com.google.gson.internal.bind.TypeAdapters.doubleAdapter; +import static com.google.gson.internal.bind.TypeAdapters.floatAdapter; + /** * This is the main class for using Gson. Gson is typically used by first constructing a Gson * instance and then invoking {@link #toJson(Object)} or {@link #fromJson(String, Class)} methods on From 57b282848aba51b5d4f29cc01133f9f32f0169e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9C=A8=E8=91=89=20Scarlet?= <93977077+mukjepscarlet@users.noreply.github.com> Date: Tue, 25 Nov 2025 23:48:38 +0800 Subject: [PATCH 3/7] import order --- gson/src/main/java/com/google/gson/Gson.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/gson/src/main/java/com/google/gson/Gson.java b/gson/src/main/java/com/google/gson/Gson.java index 494244d451..d1f6ee85aa 100644 --- a/gson/src/main/java/com/google/gson/Gson.java +++ b/gson/src/main/java/com/google/gson/Gson.java @@ -16,6 +16,11 @@ package com.google.gson; +import static com.google.gson.internal.bind.TypeAdapters.atomicLongAdapter; +import static com.google.gson.internal.bind.TypeAdapters.atomicLongArrayAdapter; +import static com.google.gson.internal.bind.TypeAdapters.doubleAdapter; +import static com.google.gson.internal.bind.TypeAdapters.floatAdapter; + import com.google.gson.annotations.JsonAdapter; import com.google.gson.internal.ConstructorConstructor; import com.google.gson.internal.Excluder; @@ -58,11 +63,6 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicLongArray; -import static com.google.gson.internal.bind.TypeAdapters.atomicLongAdapter; -import static com.google.gson.internal.bind.TypeAdapters.atomicLongArrayAdapter; -import static com.google.gson.internal.bind.TypeAdapters.doubleAdapter; -import static com.google.gson.internal.bind.TypeAdapters.floatAdapter; - /** * This is the main class for using Gson. Gson is typically used by first constructing a Gson * instance and then invoking {@link #toJson(Object)} or {@link #fromJson(String, Class)} methods on From b3ed594c686acb19a9726e47cd96d67a9c69e57b Mon Sep 17 00:00:00 2001 From: MukjepScarlet <93977077+mukjepscarlet@users.noreply.github.com> Date: Wed, 26 Nov 2025 11:43:17 +0800 Subject: [PATCH 4/7] add test --- .../java/com/google/gson/internal/sql/SqlTypesSupportTest.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java index 23778079c7..ccf03a299e 100644 --- a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java +++ b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java @@ -31,5 +31,8 @@ public void testSupported() { assertThat(SqlTypesSupport.DATE_FACTORY).isNotNull(); assertThat(SqlTypesSupport.TIME_FACTORY).isNotNull(); assertThat(SqlTypesSupport.TIMESTAMP_FACTORY).isNotNull(); + + // DATE_FACTORY, TIME_FACTORY, TIMESTAMP_FACTORY + assertThat(SqlTypesSupport.SQL_TYPE_FACTORIES.size()).isEqualTo(3); } } From 350d33a07325499cdc94cdf927e3d50dda54ca0b Mon Sep 17 00:00:00 2001 From: MukjepScarlet <93977077+mukjepscarlet@users.noreply.github.com> Date: Wed, 26 Nov 2025 11:49:12 +0800 Subject: [PATCH 5/7] adjust javadoc --- .../java/com/google/gson/internal/sql/SqlTypesSupport.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java b/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java index 6edacbcec2..02f6eae857 100644 --- a/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java +++ b/gson/src/main/java/com/google/gson/internal/sql/SqlTypesSupport.java @@ -30,8 +30,10 @@ * java.sql} module is not present. * *

If {@link #SUPPORTS_SQL_TYPES} is {@code true}, all other constants of this class will be - * non-{@code null}. However, if it is {@code false} all other constants will be {@code null} and - * there will be no support for {@code java.sql} types. + * non-{@code null} and {@link #SQL_TYPE_FACTORIES} will contain the SQL type adapter factories. + * However, if it is {@code false} all other constants will be {@code null} and {@link + * #SQL_TYPE_FACTORIES} will be an empty list, and there will be no support for {@code java.sql} + * types. */ @SuppressWarnings("JavaUtilDate") public final class SqlTypesSupport { From 3a9e9e701b13ca32d5fc83196a9d6c3489a67e68 Mon Sep 17 00:00:00 2001 From: MukjepScarlet <93977077+mukjepscarlet@users.noreply.github.com> Date: Wed, 26 Nov 2025 11:57:39 +0800 Subject: [PATCH 6/7] move back --- gson/src/main/java/com/google/gson/Gson.java | 18 ++++++++++-------- .../gson/internal/bind/TypeAdapters.java | 8 -------- 2 files changed, 10 insertions(+), 16 deletions(-) diff --git a/gson/src/main/java/com/google/gson/Gson.java b/gson/src/main/java/com/google/gson/Gson.java index d1f6ee85aa..3f14acefe2 100644 --- a/gson/src/main/java/com/google/gson/Gson.java +++ b/gson/src/main/java/com/google/gson/Gson.java @@ -18,8 +18,6 @@ import static com.google.gson.internal.bind.TypeAdapters.atomicLongAdapter; import static com.google.gson.internal.bind.TypeAdapters.atomicLongArrayAdapter; -import static com.google.gson.internal.bind.TypeAdapters.doubleAdapter; -import static com.google.gson.internal.bind.TypeAdapters.floatAdapter; import com.google.gson.annotations.JsonAdapter; import com.google.gson.internal.ConstructorConstructor; @@ -341,12 +339,8 @@ public Gson() { factories.add(TypeAdapters.SHORT_FACTORY); TypeAdapter longAdapter = longSerializationPolicy.typeAdapter(); factories.add(TypeAdapters.newFactory(long.class, Long.class, longAdapter)); - factories.add( - TypeAdapters.newFactory( - double.class, Double.class, doubleAdapter(serializeSpecialFloatingPointValues))); - factories.add( - TypeAdapters.newFactory( - float.class, Float.class, floatAdapter(serializeSpecialFloatingPointValues))); + factories.add(TypeAdapters.newFactory(double.class, Double.class, doubleAdapter())); + factories.add(TypeAdapters.newFactory(float.class, Float.class, floatAdapter())); factories.add(NumberTypeAdapter.getFactory(numberToNumberStrategy)); factories.add(TypeAdapters.ATOMIC_INTEGER_FACTORY); factories.add(TypeAdapters.ATOMIC_BOOLEAN_FACTORY); @@ -441,6 +435,14 @@ public boolean htmlSafe() { return htmlSafe; } + private TypeAdapter floatAdapter() { + return serializeSpecialFloatingPointValues ? TypeAdapters.FLOAT : TypeAdapters.FLOAT_STRICT; + } + + private TypeAdapter doubleAdapter() { + return serializeSpecialFloatingPointValues ? TypeAdapters.DOUBLE : TypeAdapters.DOUBLE_STRICT; + } + /** * Returns the type adapter for {@code type}. * diff --git a/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java b/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java index 8c7f166e77..0cbb96083b 100644 --- a/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java +++ b/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java @@ -521,17 +521,9 @@ private static void checkValidFloatingPoint(double value) { public static final TypeAdapter FLOAT = new FloatAdapter(false); public static final TypeAdapter FLOAT_STRICT = new FloatAdapter(true); - public static TypeAdapter floatAdapter(boolean serializeSpecialFloatingPointValues) { - return serializeSpecialFloatingPointValues ? TypeAdapters.FLOAT : TypeAdapters.FLOAT_STRICT; - } - public static final TypeAdapter DOUBLE = new DoubleAdapter(false); public static final TypeAdapter DOUBLE_STRICT = new DoubleAdapter(true); - public static TypeAdapter doubleAdapter(boolean serializeSpecialFloatingPointValues) { - return serializeSpecialFloatingPointValues ? TypeAdapters.DOUBLE : TypeAdapters.DOUBLE_STRICT; - } - public static final TypeAdapter CHARACTER = new TypeAdapter() { @Override From 0e37be45ac94923fa0c1a8bf49bf42f268eb44a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9C=A8=E8=91=89=20Scarlet?= <93977077+mukjepscarlet@users.noreply.github.com> Date: Thu, 27 Nov 2025 23:42:53 +0800 Subject: [PATCH 7/7] correct test Co-authored-by: Marcono1234 --- .../google/gson/internal/sql/SqlTypesSupportTest.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java index ccf03a299e..2334cd9647 100644 --- a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java +++ b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java @@ -31,8 +31,11 @@ public void testSupported() { assertThat(SqlTypesSupport.DATE_FACTORY).isNotNull(); assertThat(SqlTypesSupport.TIME_FACTORY).isNotNull(); assertThat(SqlTypesSupport.TIMESTAMP_FACTORY).isNotNull(); - - // DATE_FACTORY, TIME_FACTORY, TIMESTAMP_FACTORY - assertThat(SqlTypesSupport.SQL_TYPE_FACTORIES.size()).isEqualTo(3); + assertThat(SqlTypesSupport.SQL_TYPE_FACTORIES) + .containsExactly( + SqlTypesSupport.TIME_FACTORY, + SqlTypesSupport.DATE_FACTORY, + SqlTypesSupport.TIMESTAMP_FACTORY) + .inOrder(); } }