$ show google/gson
Gson is a mature Java library for JSON serialization/deserialization, offering both streaming (JsonReader/JsonWriter) and tree-based (JsonElement hierarchy) APIs. It is centered around a flexible type adapter system (TypeAdapter/TypeAdapterFactory) that enables custom serialization for arbitrary Java objects, including support for Java generics, annotations (@SerializedName, @Expose, @JsonAdapter), and versioning. The core module provides reflection-based adapters for most common types, while extras and proto modules extend support for runtime polymorphism and Protocol Buffers. The library is in maintenance mode (bug fixes only, no major new features), but remains actively maintained with CI builds on multiple JDKs (11 through 25), integration tests for JPMS, GraalVM native image, and code shrinking (ProGuard/R8). Its design emphasizes extensibility and backward compatibility, though it relies heavily on Java reflection and sun.misc.Unsafe, which may pose risks on future JDK versions.
The LLM identified 5 files worth highlighting for reuse:
A reusable TypeAdapterFactory that enables polymorphic JSON serialization/deserialization by using a designated type field (e.g., "type"). It registers subclass adapters and automatically resolves the concrete type during deserialization. The implementation is self-contained (depends only on Gson's public API) and can be extracted into any Gson-based project. It demonstrates a clean strategy pattern for type discrimination.
A high-performance streaming JSON parser implemented as a deterministic finite automaton. It supports multiple strictness levels (STRICT, LEGACY_STRICT, LENIENT) with configurable leniency for malformed JSON, tracks nested paths for error reporting, enforces nesting depth limits to prevent stack overflow, and handles optional non-execute prefixes. The class is well-tested (100+ tests) and can be extracted as a standalone JSON tokenizer, as it has no dependencies on Gson's core serialization logic.
A compact, high-performance utility for parsing and formatting dates in ISO 8601 format. It avoids the overhead of Java's SimpleDateFormat by manually scanning string tokens. The implementation is zero-dependency (only standard Java) and handles timezone offsets, fractional seconds, and various date formats. It can be extracted into any Java project needing fast ISO 8601 date processing.
A lightweight Number subclass that defers parsing of the numeric value until one of its converters (intValue, longValue, doubleValue, etc.) is explicitly called. It internally stores the raw string and caches only BigDecimal/BigInteger results, minimizing conversion costs for unused representations. This pattern is reusable for any application that needs to handle numeric values in an optimized, lazy manner without premature loss of precision.
A Red-Black/AVL tree-based Map implementation that combines sorted key ordering with insertion-order iteration. Derived from Android's TreeMap, it is space-efficient and provides O(log n) operations without relying on standard Java collections. The implementation is fully self-contained (only depends on java.util) and can be reused in projects needing a map with both natural ordering and predictable iteration order.