Gsonとは？Jacksonとの違いから理解する特徴と利点

Google製ライブラリとしての信頼性と実績

Gsonは、Googleが開発・メンテナンスしているJavaのオープンソースライブラリで、JavaオブジェクトとJSON形式のデータを相互に変換するための機能を提供します。2008年にリリースされて以来、多くの企業や開発者に採用され、現在も活発に開発が継続されています。

主な採用企業・プロジェクト：

• Google Android SDK（標準ライブラリとして採用）
• Spring Framework（サポート対象ライブラリ）
• Apache Camel（データ変換コンポーネント）
• Netflix（一部のマイクロサービス）

Gsonの最大の特徴は、シンプルな設計思想と使いやすさにあります。初期設定で多くのユースケースをカバーしながら、必要に応じて細かなカスタマイズも可能な設計となっています。

柔軟なカスタマイズ性能が光る自由度

GsonとJacksonを比較すると、以下のような特徴の違いが浮かび上がります：

柔軟なカスタマイズの例

Gsonの強みである柔軟なカスタマイズ性能を示す具体例をいくつか見てみましょう：

1. 日付形式のカスタマイズ

Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd HH:mm:ss")
    .create();

2. null値の扱いの制御

Gson gson = new GsonBuilder()
    .serializeNulls()  // null値も含めてシリアライズ
    .create();

3. カスタムシリアライザの実装

public class CustomDateSerializer implements JsonSerializer<Date> {
    @Override
    public JsonElement serialize(Date date, Type type, JsonSerializationContext context) {
        return new JsonPrimitive(new SimpleDateFormat("MM/dd/yyyy").format(date));
    }
}

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new CustomDateSerializer())
    .create();

主な用途とユースケース

Gsonは以下のような場面で特に力を発揮します：

1. RESTful APIの開発

• HTTPリクエスト/レスポンスのJSON処理
• WebサービスのデータバインディングG

1. 設定ファイルの処理

• アプリケーション設定のJSON形式での保存/読み込み
• 外部設定ファイルの処理

1. データ永続化

• オブジェクトのJSON形式でのシリアライズ
• キャッシュデータの保存

これらの特徴から、Gsonは特に以下のような場合に最適な選択肢となります：

• シンプルで直感的なAPIを重視する場合
• カスタマイズ性の高いJSON処理が必要な場合
• 学習コストを抑えつつ、柔軟な実装を行いたい場合
• メモリ使用量を抑えたい場合

一方で、以下のような場合はJacksonの使用を検討することをお勧めします：

• 大規模なデータ処理が必要な場合
• XMLなど他のデータフォーマットも扱う必要がある場合
• より詳細な設定やカスタマイズが必要な場合

Gson導入から基本的な使い方まで

Maven/Gradleでの依存関係の追加方法

Mavenでの追加

pom.xmlに以下の依存関係を追加します：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

Gradleでの追加

build.gradleに以下の依存関係を追加します：

dependencies {
    implementation 'com.google.code.gson:gson:2.10.1'
}

GsonBuilderを使った初期設定のベストプラクティス

GsonBuilderを使用することで、Gsonインスタンスの動作をカスタマイズできます。以下に、よく使用される設定パターンを紹介します。

1. 基本的な初期化

// 最もシンプルな初期化
Gson gson = new Gson();

// GsonBuilderを使用した基本的な初期化
Gson gson = new GsonBuilder().create();

2. 推奨される標準設定

Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd HH:mm:ss")  // 日付フォーマットの指定
    .serializeNulls()                       // null値も含めてシリアライズ
    .setPrettyPrinting()                    // 整形されたJSONを出力
    .disableHtmlEscaping()                  // HTML特殊文字のエスケープを無効化
    .create();

3. プロジェクト固有の要件に応じた設定

Gson gson = new GsonBuilder()
    // バージョン管理されたフィールドを除外
    .setVersion(1.0)  
    // 特定のフィールドを除外
    .excludeFieldsWithoutExposeAnnotation()
    // トランジェントフィールドを含める
    .includeFields()
    // カスタムアダプターの登録
    .registerTypeAdapter(Date.class, new DateTypeAdapter())
    .create();

基本的な使用方法と実装例

1. オブジェクトからJSONへの変換（シリアライズ）

public class User {
    private String name;
    private int age;
    private String email;

    // コンストラクタ、getter、setterは省略
}

// シリアライズの例
User user = new User("山田太郎", 30, "yamada@example.com");
String json = gson.toJson(user);
// 結果: {"name":"山田太郎","age":30,"email":"yamada@example.com"}

2. JSONからオブジェクトへの変換（デシリアライズ）

// デシリアライズの例
String json = "{\"name\":\"山田太郎\",\"age\":30,\"email\":\"yamada@example.com\"}";
User user = gson.fromJson(json, User.class);

3. コレクション型の処理

// List<User>のシリアライズ
List<User> users = Arrays.asList(
    new User("山田太郎", 30, "yamada@example.com"),
    new User("鈴木花子", 25, "suzuki@example.com")
);
String json = gson.toJson(users);

// List<User>のデシリアライズ
Type userListType = new TypeToken<List<User>>(){}.getType();
List<User> userList = gson.fromJson(json, userListType);

4. プリミティブ型とJSONの変換

// プリミティブ型の変換例
int number = 42;
String jsonNumber = gson.toJson(number);  // "42"

boolean bool = true;
String jsonBool = gson.toJson(bool);      // "true"

// JSONからプリミティブ型への変換
int parsedNumber = gson.fromJson("42", int.class);
boolean parsedBool = gson.fromJson("true", boolean.class);

実装時の注意点

1. スレッドセーフティ

• Gsonインスタンスはスレッドセーフなので、アプリケーション全体で再利用可能です
• static finalフィールドとして定義することを推奨します

public class GsonUtil {
    private static final Gson GSON = new GsonBuilder()
        .setDateFormat("yyyy-MM-dd HH:mm:ss")
        .create();

    // privateコンストラクタでインスタンス化を防止
    private GsonUtil() {}

    public static Gson getGson() {
        return GSON;
    }
}

2. エラーハンドリング

• JsonSyntaxExceptionやJsonIOExceptionをtry-catchで適切に処理します

try {
    User user = gson.fromJson(json, User.class);
} catch (JsonSyntaxException e) {
    // JSON形式が不正な場合の処理
    logger.error("Invalid JSON format", e);
} catch (JsonIOException e) {
    // I/Oエラーの処理
    logger.error("I/O error during JSON processing", e);
}

これらの基本的な使い方を押さえておくことで、Gsonを使用したJSON処理の大部分のケースに対応できます。次のセクションでは、より高度な実装パターンについて解説していきます。

7つの実装パターンでマスターするJSON処理

1. 基本オブジェクトのシリアライズ/デシリアライズ

カスタムフィールド名の指定

@SerializedNameアノテーションを使用して、JavaのフィールドとJSONのプロパティ名のマッピングをカスタマイズできます。

public class Product {
    @SerializedName("product_id")
    private String productId;

    @SerializedName("product_name")
    private String name;

    @SerializedName("price_amount")
    private BigDecimal price;

    // getter/setterは省略
}

// 使用例
Product product = new Product("P001", "高級腕時計", new BigDecimal("29800"));
String json = gson.toJson(product);
// 結果: {"product_id":"P001","product_name":"高級腕時計","price_amount":29800}

2. ネスト化されたオブジェクトの効率処理メソッド

複雑なオブジェクト構造を持つJSONを効率的に処理する方法を示します。

public class Order {
    private String orderId;
    private Customer customer;
    private List<OrderItem> items;
    private Address shippingAddress;

    public static class Customer {
        private String id;
        private String name;
        private String email;
    }

    public static class OrderItem {
        private String productId;
        private int quantity;
        private BigDecimal price;
    }

    public static class Address {
        private String street;
        private String city;
        private String postalCode;
    }
}

// ネスト化されたオブジェクトの処理
Order order = gson.fromJson(complexJson, Order.class);

3. リストやマップ構造のハンドリングテクニック

ジェネリックコレクションの処理

TypeTokenを使用して、ジェネリックコレクションを適切に処理します。

// リストの処理
Type listType = new TypeToken<List<Product>>(){}.getType();
List<Product> products = gson.fromJson(jsonArray, listType);

// マップの処理
Type mapType = new TypeToken<Map<String, Product>>(){}.getType();
Map<String, Product> productMap = gson.fromJson(jsonObject, mapType);

// 複雑なネストされたコレクション
Type complexType = new TypeToken<Map<String, List<Order>>>(){}.getType();
Map<String, List<Order>> ordersByCustomer = gson.fromJson(jsonData, complexType);

4. カスタムシリアライザ/デシリアライザの実装手順

特殊なデータ型や複雑な変換ロジックを実装する方法を示します。

public class DateSerializer implements JsonSerializer<Date> {
    private final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");

    @Override
    public JsonElement serialize(Date date, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(format.format(date));
    }
}

public class DateDeserializer implements JsonDeserializer<Date> {
    private final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");

    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
            throws JsonParseException {
        try {
            return format.parse(json.getAsString());
        } catch (ParseException e) {
            throw new JsonParseException(e);
        }
    }
}

// カスタムシリアライザ/デシリアライザの登録
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateSerializer())
    .registerTypeAdapter(Date.class, new DateDeserializer())
    .create();

5. 日付形式のカスタマイズと国際化対応

様々な日付形式と地域設定に対応する実装方法です。

public class LocalizedDateAdapter implements JsonSerializer<Date>, JsonDeserializer<Date> {
    private final Locale locale;
    private final String pattern;

    public LocalizedDateAdapter(Locale locale, String pattern) {
        this.locale = locale;
        this.pattern = pattern;
    }

    @Override
    public JsonElement serialize(Date date, Type typeOfSrc, JsonSerializationContext context) {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern, locale);
        return new JsonPrimitive(formatter.format(date));
    }

    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
            throws JsonParseException {
        SimpleDateFormat formatter = new SimpleDateFormat(pattern, locale);
        try {
            return formatter.parse(json.getAsString());
        } catch (ParseException e) {
            throw new JsonParseException(e);
        }
    }
}

// 使用例
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new LocalizedDateAdapter(Locale.JAPAN, "yyyy年MM月dd日"))
    .create();

6. NULLの扱いとオプションフィールドの実装

NULL値とオプショナルフィールドを適切に処理する方法です。

public class OptionalFieldsExample {
    @SerializedName("required_field")
    private String requiredField;

    @SerializedName("optional_field")
    @Expose(serialize = true, deserialize = true)
    private String optionalField;

    @SerializedName("nullable_field")
    private String nullableField;

    // トランジェントフィールドは JSON 変換から除外
    transient private String temporaryField;
}

Gson gson = new GsonBuilder()
    .serializeNulls()  // NULL値もシリアライズする
    .excludeFieldsWithoutExposeAnnotation()  // @Exposeアノテーションがないフィールドを除外
    .create();

7. バージョニングとフィールドの互換制御

APIのバージョン管理と下位互換性を維持する実装方法です。

public class VersionedClass {
    @Since(1.0)
    private String field1;

    @Since(1.1)
    private String field2;

    @Until(2.0)
    private String deprecatedField;

    // バージョン1.0のインスタンス生成
    Gson gsonV1 = new GsonBuilder().setVersion(1.0).create();

    // バージョン1.1のインスタンス生成
    Gson gsonV11 = new GsonBuilder().setVersion(1.1).create();
}

実装時のベストプラクティス

1. 型安全性の確保

• TypeTokenの適切な使用
• ジェネリック型の完全な指定

1. エラー処理の強化

• カスタム例外の実装
• バリデーションの追加

1. パフォーマンスの最適化

• Gsonインスタンスの再利用
• 適切なバッファサイズの設定

1. テスト容易性の向上

• モック可能な設計
• ユニットテストの作成

これらのパターンを適切に組み合わせることで、堅牢で保守性の高いJSON処理を実現できます。

パフォーマンスを最大化する実装のコツ

GsonBuilderのチューニングポイント

GsonBuilderの設定を最適化することで、JSON処理のパフォーマンスを大幅に向上させることができます。

1. 不要な機能の無効化

Gson gson = new GsonBuilder()
    .disableHtmlEscaping()           // HTML特殊文字のエスケープを無効化
    .disableInnerClassSerialization() // 内部クラスのシリアライズを無効化
    .excludeFieldsWithoutExposeAnnotation() // @Exposeのないフィールドを除外
    .create();

2. フィールドネーミングポリシーの最適化

// デフォルトのフィールド名を使用（変換処理をスキップ）
Gson gson = new GsonBuilder()
    .setFieldNamingPolicy(FieldNamingPolicy.IDENTITY)
    .create();

ベンチマーク結果

メモリ使用量を重視したストリーミング処理の実装

大規模なJSONデータを扱う際は、ストリーミング処理を使用してメモリ使用量を抑制できます。

1. JsonReaderを使用した効率的な読み込み

public List<User> readUsersStream(Reader reader) {
    List<User> users = new ArrayList<>();
    JsonReader jsonReader = new JsonReader(reader);

    try {
        jsonReader.beginArray();
        while (jsonReader.hasNext()) {
            User user = gson.fromJson(jsonReader, User.class);
            users.add(user);
        }
        jsonReader.endArray();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }

    return users;
}

// 使用例
try (FileReader reader = new FileReader("large_users.json")) {
    List<User> users = readUsersStream(reader);
}

2. JsonWriterを使用した効率的な書き込み

public void writeUsersStream(Writer writer, List<User> users) {
    JsonWriter jsonWriter = new JsonWriter(writer);

    try {
        jsonWriter.beginArray();
        for (User user : users) {
            gson.toJson(user, User.class, jsonWriter);
        }
        jsonWriter.endArray();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

// 使用例
try (FileWriter writer = new FileWriter("output_users.json")) {
    writeUsersStream(writer, users);
}

キャッシュを活用した処理速度の向上

1. Gsonインスタンスのキャッシュ

public class GsonCache {
    private static final Gson INSTANCE = new GsonBuilder()
        .disableHtmlEscaping()
        .create();

    private GsonCache() {} // インスタンス化を防止

    public static Gson getInstance() {
        return INSTANCE;
    }
}

2. TypeTokenのキャッシュ

public class TypeTokenCache {
    private static final Map<Class<?>, Type> TOKEN_CACHE = new ConcurrentHashMap<>();

    public static <T> Type getListType(Class<T> clazz) {
        return TOKEN_CACHE.computeIfAbsent(clazz, 
            k -> TypeToken.getParameterized(List.class, k).getType());
    }

    public static <K, V> Type getMapType(Class<K> keyClass, Class<V> valueClass) {
        return TOKEN_CACHE.computeIfAbsent(keyClass, 
            k -> TypeToken.getParameterized(Map.class, keyClass, valueClass).getType());
    }
}

// 使用例
Type userListType = TypeTokenCache.getListType(User.class);
List<User> users = gson.fromJson(json, userListType);

パフォーマンス最適化のベストプラクティス

1. バッファサイズの最適化

// 大きなJSONファイルを読み込む際のバッファサイズ設定
BufferedReader reader = new BufferedReader(
    new FileReader("large_file.json"), 
    32768  // 32KBのバッファサイズ
);

2. メモリ使用量のモニタリング

public class MemoryMonitor {
    public static void logMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        long usedMemory = totalMemory - freeMemory;

        System.out.printf("Used Memory: %d MB%n", usedMemory / (1024 * 1024));
    }
}

3. パフォーマンス計測用のユーティリティ

public class PerformanceTimer {
    public static <T> T measureTime(String operation, Supplier<T> action) {
        long start = System.currentTimeMillis();
        T result = action.get();
        long end = System.currentTimeMillis();

        System.out.printf("%s took %d ms%n", operation, (end - start));
        return result;
    }
}

// 使用例
String json = PerformanceTimer.measureTime("JSON Serialization",
    () -> gson.toJson(largeObject));

これらの最適化テクニックを適切に組み合わせることで、Gsonを使用したJSON処理のパフォーマンスを最大限に引き出すことができます。ただし、最適化は必要な場合にのみ行い、コードの可読性とメンテナンス性とのバランスを常に考慮することが重要です。

エラーハンドリングのベストプラクティス

よくあるエラーとその解決方法

1. JsonSyntaxException

JSON構文が不正な場合に発生する最も一般的なエラーです。

public class JsonValidator {
    private static final Gson gson = new Gson();

    public static boolean isValidJson(String jsonStr) {
        try {
            // JsonElementとしてパースを試みる
            gson.fromJson(jsonStr, JsonElement.class);
            return true;
        } catch (JsonSyntaxException e) {
            return false;
        }
    }

    public static String formatJsonError(String jsonStr) {
        try {
            gson.fromJson(jsonStr, JsonElement.class);
            return "Valid JSON";
        } catch (JsonSyntaxException e) {
            return "Invalid JSON: " + e.getMessage();
        }
    }
}

2. JsonParseException

特定の型への変換時に発生するエラーです。

public class SafeJsonParser<T> {
    private final Gson gson;
    private final Class<T> type;

    public SafeJsonParser(Class<T> type) {
        this.gson = new Gson();
        this.type = type;
    }

    public Optional<T> parse(String json) {
        try {
            T result = gson.fromJson(json, type);
            return Optional.ofNullable(result);
        } catch (JsonParseException e) {
            logger.error("Failed to parse JSON: {}", json, e);
            return Optional.empty();
        }
    }
}

// 使用例
SafeJsonParser<User> parser = new SafeJsonParser<>(User.class);
Optional<User> user = parser.parse(jsonString);
user.ifPresent(u -> System.out.println("User parsed: " + u.getName()));

3. データ型の不一致エラー

public class TypeSafeParser {
    private static final Gson gson = new Gson();

    public static <T> T parseWithTypeCheck(JsonElement element, Class<T> expectedType) {
        try {
            if (expectedType == String.class && !element.isJsonPrimitive()) {
                throw new JsonParseException("Expected String but got " + element.getClass().getSimpleName());
            }
            return gson.fromJson(element, expectedType);
        } catch (NumberFormatException e) {
            throw new JsonParseException("Expected number but got: " + element);
        }
    }
}

例外処理を適切に実装するためのポイント

1. カスタム例外の実装

public class GsonException extends RuntimeException {
    private final String json;
    private final String targetType;

    public GsonException(String message, String json, String targetType, Throwable cause) {
        super(message, cause);
        this.json = json;
        this.targetType = targetType;
    }

    public String getJson() {
        return json;
    }

    public String getTargetType() {
        return targetType;
    }
}

// カスタム例外を使用したラッパークラス
public class GsonWrapper {
    private final Gson gson;

    public GsonWrapper(Gson gson) {
        this.gson = gson;
    }

    public <T> T fromJson(String json, Class<T> classOfT) throws GsonException {
        try {
            return gson.fromJson(json, classOfT);
        } catch (JsonSyntaxException | JsonParseException e) {
            throw new GsonException(
                "Failed to parse JSON",
                json,
                classOfT.getSimpleName(),
                e
            );
        }
    }
}

2. エラーログの強化

public class JsonLogger {
    private static final Logger logger = LoggerFactory.getLogger(JsonLogger.class);

    public static void logJsonError(String operation, String json, Exception e) {
        logger.error("JSON {} failed. Input: {}", operation, maskSensitiveData(json), e);
    }

    private static String maskSensitiveData(String json) {
        // センシティブデータのマスク処理
        return json.replaceAll("\"password\":\"[^\"]*\"", "\"password\":\"*****\"")
                  .replaceAll("\"creditCard\":\"[^\"]*\"", "\"creditCard\":\"*****\"");
    }
}

3. バリデーション機能の実装

public class JsonValidator {
    private final Gson gson;
    private final JsonSchema schema;

    public JsonValidator(String schemaJson) {
        this.gson = new Gson();
        this.schema = JsonSchema.parse(schemaJson);
    }

    public ValidationResult validate(String json) {
        try {
            JsonElement element = gson.fromJson(json, JsonElement.class);
            List<ValidationError> errors = new ArrayList<>();

            // スキーマに基づくバリデーション
            validateElement(element, schema, "", errors);

            return new ValidationResult(errors.isEmpty(), errors);
        } catch (JsonSyntaxException e) {
            return new ValidationResult(false, 
                Collections.singletonList(new ValidationError("Invalid JSON syntax")));
        }
    }
}

デバッグのためのユーティリティ

public class GsonDebugger {
    private static final Gson PRETTY_GSON = new GsonBuilder().setPrettyPrinting().create();

    public static String prettyPrint(String json) {
        try {
            JsonElement je = JsonParser.parseString(json);
            return PRETTY_GSON.toJson(je);
        } catch (JsonSyntaxException e) {
            return "Invalid JSON: " + e.getMessage();
        }
    }

    public static void debugJson(String json, Class<?> targetType) {
        System.out.println("=== JSON Debug Info ===");
        System.out.println("Input JSON:");
        System.out.println(prettyPrint(json));
        System.out.println("\nTarget Type: " + targetType.getSimpleName());
        try {
            Object parsed = new Gson().fromJson(json, targetType);
            System.out.println("Successfully parsed to: " + parsed);
        } catch (Exception e) {
            System.out.println("Parsing failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

エラーハンドリングのベストプラクティス

1. 階層的な例外処理

• 具体的な例外から順に捕捉
• 適切な例外の変換と情報の保持

1. エラーメッセージの標準化

• 明確で一貫性のあるメッセージ
• エラーコードの活用

1. リカバリー戦略の実装

• フォールバック値の提供
• 再試行メカニズムの実装

1. 監視とロギング

• 構造化ログの活用
• エラー傾向の分析

これらの実装パターンを適切に組み合わせることで、堅牢なJSON処理システムを構築できます。

実践的なユースケースと実装例

REST APIの応答処理での活用方法

1. Spring Bootとの統合例

@RestController
@RequestMapping("/api")
public class UserController {
    private final Gson gson;

    public UserController() {
        this.gson = new GsonBuilder()
            .setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
            .serializeNulls()
            .create();
    }

    @PostMapping("/users")
    public ResponseEntity<String> createUser(@RequestBody String jsonBody) {
        try {
            User user = gson.fromJson(jsonBody, User.class);
            // ビジネスロジックの処理
            return ResponseEntity.ok(gson.toJson(user));
        } catch (JsonParseException e) {
            return ResponseEntity.badRequest()
                .body(gson.toJson(new ErrorResponse("Invalid JSON format")));
        }
    }
}

2. HTTPクライアントでの使用例

public class ApiClient {
    private final OkHttpClient client;
    private final Gson gson;
    private final String baseUrl;

    public ApiClient(String baseUrl) {
        this.client = new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build();
        this.gson = new Gson();
        this.baseUrl = baseUrl;
    }

    public <T> T get(String path, Class<T> responseType) throws IOException {
        Request request = new Request.Builder()
            .url(baseUrl + path)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected response " + response);
            }

            String responseBody = response.body().string();
            return gson.fromJson(responseBody, responseType);
        }
    }

    public <T> T post(String path, Object requestBody, Class<T> responseType) throws IOException {
        String json = gson.toJson(requestBody);
        RequestBody body = RequestBody.create(json, MediaType.parse("application/json"));

        Request request = new Request.Builder()
            .url(baseUrl + path)
            .post(body)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected response " + response);
            }

            String responseBody = response.body().string();
            return gson.fromJson(responseBody, responseType);
        }
    }
}

設定ファイルの読み書きの実装例

1. アプリケーション設定の管理

public class ConfigManager {
    private static final String CONFIG_FILE = "config.json";
    private final Gson gson;
    private AppConfig config;

    public static class AppConfig {
        private String databaseUrl;
        private int maxConnections;
        private Map<String, String> features;
        private List<String> allowedOrigins;

        // getter/setterは省略
    }

    public ConfigManager() {
        this.gson = new GsonBuilder()
            .setPrettyPrinting()
            .create();
        loadConfig();
    }

    private void loadConfig() {
        try (Reader reader = new FileReader(CONFIG_FILE)) {
            config = gson.fromJson(reader, AppConfig.class);
        } catch (IOException e) {
            config = new AppConfig(); // デフォルト設定
            saveConfig(); // デフォルト設定を保存
        }
    }

    public void saveConfig() {
        try (Writer writer = new FileWriter(CONFIG_FILE)) {
            gson.toJson(config, writer);
        } catch (IOException e) {
            throw new RuntimeException("Failed to save config", e);
        }
    }

    public AppConfig getConfig() {
        return config;
    }
}

2. 環境別設定の管理

public class EnvironmentConfig {
    private static final Map<String, String> CONFIG_FILES = Map.of(
        "development", "config.dev.json",
        "staging", "config.staging.json",
        "production", "config.prod.json"
    );

    private final Gson gson;
    private final String environment;

    public EnvironmentConfig(String environment) {
        this.gson = new GsonBuilder()
            .setPrettyPrinting()
            .create();
        this.environment = environment;
    }

    public <T> T loadConfig(Class<T> configClass) {
        String configFile = CONFIG_FILES.get(environment);
        if (configFile == null) {
            throw new IllegalArgumentException("Unknown environment: " + environment);
        }

        try (InputStream is = getClass().getClassLoader().getResourceAsStream(configFile)) {
            if (is == null) {
                throw new FileNotFoundException("Config file not found: " + configFile);
            }
            Reader reader = new InputStreamReader(is);
            return gson.fromJson(reader, configClass);
        } catch (IOException e) {
            throw new RuntimeException("Failed to load config", e);
        }
    }
}

他システムとの連携での活用方法

1. WebSocketでのメッセージ処理

@WebSocket
public class WebSocketHandler {
    private final Gson gson;

    public WebSocketHandler() {
        this.gson = new GsonBuilder()
            .setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
            .create();
    }

    @OnMessage
    public void onMessage(Session session, String message) {
        try {
            JsonObject jsonMessage = JsonParser.parseString(message).getAsJsonObject();
            String type = jsonMessage.get("type").getAsString();

            switch (type) {
                case "chat":
                    ChatMessage chatMessage = gson.fromJson(message, ChatMessage.class);
                    handleChatMessage(session, chatMessage);
                    break;
                case "notification":
                    Notification notification = gson.fromJson(message, Notification.class);
                    handleNotification(session, notification);
                    break;
                default:
                    session.getBasicRemote().sendText(
                        gson.toJson(new ErrorMessage("Unknown message type: " + type))
                    );
            }
        } catch (Exception e) {
            try {
                session.getBasicRemote().sendText(
                    gson.toJson(new ErrorMessage("Failed to process message: " + e.getMessage()))
                );
            } catch (IOException ex) {
                // ログ出力
            }
        }
    }
}

2. キャッシュシステムとの連携

public class CacheManager<T> {
    private final Gson gson;
    private final Redis redis;
    private final Class<T> type;

    public CacheManager(Redis redis, Class<T> type) {
        this.gson = new Gson();
        this.redis = redis;
        this.type = type;
    }

    public void put(String key, T value, Duration ttl) {
        String json = gson.toJson(value);
        redis.set(key, json, ttl);
    }

    public Optional<T> get(String key) {
        String json = redis.get(key);
        if (json == null) {
            return Optional.empty();
        }

        try {
            T value = gson.fromJson(json, type);
            return Optional.ofNullable(value);
        } catch (JsonSyntaxException e) {
            redis.delete(key); // 不正なJSONを削除
            return Optional.empty();
        }
    }
}

これらの実装例は、実際のプロジェクトですぐに活用できる形で提供しています。必要に応じて、プロジェクトの要件に合わせてカスタマイズしてください。