package com.architect.pitfalls.immutable.cause;

import java.io.*;
import java.util.*;

/**
 * 不可變集合序列化陷阱演示 - 問題代碼
 * 
 * 演示List.of()、Set.of()、Map.of()返回的不可變集合在序列化場景中的問題：
 * 1. 內(nèi)部實(shí)現(xiàn)類在不同JDK版本中可能不同
 * 2. 跨JDK版本序列化/反序列化可能失敗
 * 3. 與ArrayList等可變集合的序列化行為差異
 */
public class ImmutableCollectionSerializationDemo {
    
    public static void main(String[] args) {
        System.out.println("=== 不可變集合序列化陷阱演示 ===\n");
        
        // 場景1：分析List.of()返回的實(shí)際類型
        System.out.println("========================================");
        System.out.println("場景1: List.of()返回的實(shí)際類型分析");
        System.out.println("========================================\n");
        analyzeCollectionTypes();
        
        // 場景2：序列化與反序列化演示
        System.out.println("\n========================================");
        System.out.println("場景2: 序列化與反序列化演示");
        System.out.println("========================================\n");
        demonstrateSerialization();
        
        // 場景3：不可變集合的操作限制
        System.out.println("\n========================================");
        System.out.println("場景3: 不可變集合的操作限制");
        System.out.println("========================================\n");
        demonstrateImmutableRestrictions();
    }
    
    private static void analyzeCollectionTypes() {
        // 創(chuàng)建不同方式的List
        List<String> arrayList = new ArrayList<>(Arrays.asList("a", "b", "c"));
        List<String> immutableList = List.of("a", "b", "c");
        List<String> arraysAsList = Arrays.asList("a", "b", "c");
        
        System.out.println("集合類型分析：");
        System.out.println("  new ArrayList<>(): " + arrayList.getClass().getName());
        System.out.println("  List.of():         " + immutableList.getClass().getName());
        System.out.println("  Arrays.asList():   " + arraysAsList.getClass().getName());
        System.out.println();
        
        // 創(chuàng)建不同方式的Set
        Set<String> hashSet = new HashSet<>(Arrays.asList("a", "b", "c"));
        Set<String> immutableSet = Set.of("a", "b", "c");
        
        System.out.println("Set類型分析：");
        System.out.println("  new HashSet<>(): " + hashSet.getClass().getName());
        System.out.println("  Set.of():        " + immutableSet.getClass().getName());
        System.out.println();
        
        // 創(chuàng)建不同方式的Map
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("a", "1");
        Map<String, String> immutableMap = Map.of("a", "1", "b", "2");
        
        System.out.println("Map類型分析：");
        System.out.println("  new HashMap<>(): " + hashMap.getClass().getName());
        System.out.println("  Map.of():        " + immutableMap.getClass().getName());
        System.out.println();
        
        System.out.println("?? 關(guān)鍵發(fā)現(xiàn)：");
        System.out.println("  - List.of()返回的是java.util.ImmutableCollections$ListN（JDK內(nèi)部類）");
        System.out.println("  - 這些內(nèi)部類的serialVersionUID在不同JDK版本可能不同");
        System.out.println("  - 跨JDK版本序列化可能失敗");
    }
    
    private static void demonstrateSerialization() {
        try {
            // 序列化ArrayList
            List<String> arrayList = new ArrayList<>(Arrays.asList("a", "b", "c"));
            byte[] arrayListData = serialize(arrayList);
            System.out.println("ArrayList序列化成功，大小: " + arrayListData.length + " 字節(jié)");
            
            // 序列化不可變List
            List<String> immutableList = List.of("a", "b", "c");
            byte[] immutableListData = serialize(immutableList);
            System.out.println("List.of()序列化成功，大小: " + immutableListData.length + " 字節(jié)");
            
            // 反序列化ArrayList
            @SuppressWarnings("unchecked")
            List<String> deserializedArrayList = (List<String>) deserialize(arrayListData);
            System.out.println("ArrayList反序列化成功: " + deserializedArrayList);
            
            // 反序列化不可變List
            @SuppressWarnings("unchecked")
            List<String> deserializedImmutableList = (List<String>) deserialize(immutableListData);
            System.out.println("List.of()反序列化成功: " + deserializedImmutableList);
            System.out.println();
            
            System.out.println("?? 潛在問題：");
            System.out.println("  - 當(dāng)前JDK版本序列化的數(shù)據(jù)，在其他JDK版本可能無法反序列化");
            System.out.println("  - 原因：內(nèi)部類ImmutableCollections的serialVersionUID可能不同");
            System.out.println("  - 例如：JDK 9/10/11/17/21的內(nèi)部實(shí)現(xiàn)可能有差異");
            
        } catch (Exception e) {
            System.out.println("序列化/反序列化失敗: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    private static void demonstrateImmutableRestrictions() {
        List<String> immutableList = List.of("a", "b", "c");
        
        System.out.println("嘗試修改不可變List：");
        try {
            immutableList.add("d");
            System.out.println("  add() 成功");
        } catch (UnsupportedOperationException e) {
            System.out.println("  add() 拋出 UnsupportedOperationException ?");
        }
        
        try {
            immutableList.remove(0);
            System.out.println("  remove() 成功");
        } catch (UnsupportedOperationException e) {
            System.out.println("  remove() 拋出 UnsupportedOperationException ?");
        }
        
        try {
            immutableList.set(0, "x");
            System.out.println("  set() 成功");
        } catch (UnsupportedOperationException e) {
            System.out.println("  set() 拋出 UnsupportedOperationException ?");
        }
        
        System.out.println();
        System.out.println("?? 業(yè)務(wù)場景問題：");
        System.out.println("  1. 反序列化后得到的仍然是不可變集合");
        System.out.println("  2. 如果業(yè)務(wù)代碼需要修改集合，會(huì)拋出異常");
        System.out.println("  3. 與ArrayList的反序列化行為不一致");
    }
    
    private static byte[] serialize(Object obj) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.close();
        return bos.toByteArray();
    }
    
    private static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

=== 不可變集合序列化陷阱演示 ===

========================================
場景1: List.of()返回的實(shí)際類型分析
========================================

集合類型分析：
  new ArrayList<>(): java.util.ArrayList
  List.of():         java.util.ImmutableCollections$ListN
  Arrays.asList():   java.util.Arrays$ArrayList

Set類型分析：
  new HashSet<>(): java.util.HashSet
  Set.of():        java.util.ImmutableCollections$SetN

Map類型分析：
  new HashMap<>(): java.util.HashMap
  Map.of():        java.util.ImmutableCollections$MapN

?? 關(guān)鍵發(fā)現(xiàn)：
  - List.of()返回的是java.util.ImmutableCollections$ListN（JDK內(nèi)部類）
  - 這些內(nèi)部類的serialVersionUID在不同JDK版本可能不同
  - 跨JDK版本序列化可能失敗

========================================
場景2: 序列化與反序列化演示
========================================

ArrayList序列化成功，大小: 123 字節(jié)
List.of()序列化成功，大小: 106 字節(jié)
ArrayList反序列化成功: [a, b, c]
List.of()反序列化成功: [a, b, c]

?? 潛在問題：
  - 當(dāng)前JDK版本序列化的數(shù)據(jù)，在其他JDK版本可能無法反序列化
  - 原因：內(nèi)部類ImmutableCollections的serialVersionUID可能不同
  - 例如：JDK 9/10/11/17/21的內(nèi)部實(shí)現(xiàn)可能有差異

========================================
場景3: 不可變集合的操作限制
========================================

嘗試修改不可變List：
  add() 拋出 UnsupportedOperationException ?
  remove() 拋出 UnsupportedOperationException ?
  set() 拋出 UnsupportedOperationException ?

?? 業(yè)務(wù)場景問題：
  1. 反序列化后得到的仍然是不可變集合
  2. 如果業(yè)務(wù)代碼需要修改集合，會(huì)拋出異常
  3. 與ArrayList的反序列化行為不一致

// JDK 11中的實(shí)現(xiàn)
static final class ListN<E> extends AbstractImmutableList<E> implements Serializable {
    private static final long serialVersionUID = 1L;
    private final E[] elements;
    // ...
}

// JDK 17/21中可能有不同的實(shí)現(xiàn)細(xì)節(jié)
// serialVersionUID可能相同，但內(nèi)部結(jié)構(gòu)可能變化

package com.architect.pitfalls.immutable.solution;

import java.io.*;
import java.util.*;

/**
 * 解決方案一：使用ArrayList/HashMap等可序列化集合
 * 
 * 在需要序列化的場景中，使用ArrayList、HashMap等標(biāo)準(zhǔn)集合類，
 * 而不是List.of()、Map.of()返回的不可變集合
 */
public class UseMutableCollectionSolution {
    
    public static void main(String[] args) {
        System.out.println("=== 解決方案一：使用可序列化集合 ===\n");
        
        // 創(chuàng)建可序列化的集合
        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
        Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        
        System.out.println("使用標(biāo)準(zhǔn)集合類：");
        System.out.println("  List: " + list.getClass().getName());
        System.out.println("  Set:  " + set.getClass().getName());
        System.out.println("  Map:  " + map.getClass().getName());
        System.out.println();
        
        try {
            // 序列化
            byte[] listData = serialize(list);
            byte[] setData = serialize(set);
            byte[] mapData = serialize(map);
            System.out.println("序列化成功：");
            System.out.println("  List大小: " + listData.length + " 字節(jié)");
            System.out.println("  Set大小:  " + setData.length + " 字節(jié)");
            System.out.println("  Map大小:  " + mapData.length + " 字節(jié)");
            System.out.println();
            
            // 反序列化
            @SuppressWarnings("unchecked")
            List<String> deserializedList = (List<String>) deserialize(listData);
            @SuppressWarnings("unchecked")
            Set<String> deserializedSet = (Set<String>) deserialize(setData);
            @SuppressWarnings("unchecked")
            Map<String, String> deserializedMap = (Map<String, String>) deserialize(mapData);
            
            System.out.println("反序列化成功：");
            System.out.println("  List: " + deserializedList);
            System.out.println("  Set:  " + deserializedSet);
            System.out.println("  Map:  " + deserializedMap);
            System.out.println();
            
            // 驗(yàn)證可修改性
            System.out.println("驗(yàn)證反序列化后可修改：");
            deserializedList.add("d");
            System.out.println("  List添加元素成功: " + deserializedList);
            deserializedSet.add("d");
            System.out.println("  Set添加元素成功: " + deserializedSet);
            deserializedMap.put("c", "3");
            System.out.println("  Map添加元素成功: " + deserializedMap);
            System.out.println();
            
            System.out.println("? 方案優(yōu)點(diǎn)：");
            System.out.println("  - 跨JDK版本兼容性好");
            System.out.println("  - 反序列化后可修改");
            System.out.println("  - serialVersionUID穩(wěn)定");
            System.out.println();
            System.out.println("?? 方案缺點(diǎn)：");
            System.out.println("  - 需要額外的new ArrayList<>()包裝");
            System.out.println("  - 代碼稍顯冗長");
            
        } catch (Exception e) {
            System.out.println("異常: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    private static byte[] serialize(Object obj) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.close();
        return bos.toByteArray();
    }
    
    private static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

=== 解決方案一：使用可序列化集合 ===

使用標(biāo)準(zhǔn)集合類：
  List: java.util.ArrayList
  Set:  java.util.HashSet
  Map:  java.util.HashMap

序列化成功：
  List大小: 123 字節(jié)
  Set大小: 136 字節(jié)
  Map大小: 152 字節(jié)

反序列化成功：
  List: [a, b, c]
  Set:  [a, b, c]
  Map:  {a=1, b=2}

驗(yàn)證反序列化后可修改：
  List添加元素成功: [a, b, c, d]
  Set添加元素成功: [a, b, c, d]
  Map添加元素成功: {a=1, b=2, c=3}

? 方案優(yōu)點(diǎn)：
  - 跨JDK版本兼容性好
  - 反序列化后可修改
  - serialVersionUID穩(wěn)定

?? 方案缺點(diǎn)：
  - 需要額外的new ArrayList<>()包裝
  - 代碼稍顯冗長

package com.architect.pitfalls.immutable.solution;

import java.io.*;
import java.util.*;

/**
 * 解決方案二：使用序列化代理模式
 * 
 * 通過定義序列化代理類，確保集合在序列化時(shí)轉(zhuǎn)換為可序列化的形式，
 * 反序列化后再轉(zhuǎn)換回不可變集合
 */
public class SerializationProxySolution {
    
    public static void main(String[] args) {
        System.out.println("=== 解決方案二：序列化代理模式 ===\n");
        
        try {
            // 創(chuàng)建使用代理的配置對象
            Config config = new Config("app-config", 
                List.of("server1", "server2", "server3"),
                Map.of("timeout", "30", "retry", "3"));
            
            System.out.println("原始配置：");
            System.out.println("  名稱: " + config.getName());
            System.out.println("  服務(wù)器列表: " + config.getServers());
            System.out.println("  屬性: " + config.getProperties());
            System.out.println("  Servers類型: " + config.getServers().getClass().getName());
            System.out.println();
            
            // 序列化
            byte[] data = serialize(config);
            System.out.println("序列化成功，大小: " + data.length + " 字節(jié)");
            System.out.println();
            
            // 反序列化
            Config deserializedConfig = (Config) deserialize(data);
            System.out.println("反序列化后配置：");
            System.out.println("  名稱: " + deserializedConfig.getName());
            System.out.println("  服務(wù)器列表: " + deserializedConfig.getServers());
            System.out.println("  屬性: " + deserializedConfig.getProperties());
            System.out.println("  Servers類型: " + deserializedConfig.getServers().getClass().getName());
            System.out.println();
            
            // 驗(yàn)證不可變性
            System.out.println("驗(yàn)證不可變性：");
            try {
                deserializedConfig.getServers().add("server4");
                System.out.println("  ?? 列表可修改，不是不可變集合");
            } catch (UnsupportedOperationException e) {
                System.out.println("  ? 列表不可修改，保持不可變性");
            }
            System.out.println();
            
            System.out.println("? 方案優(yōu)點(diǎn)：");
            System.out.println("  - 保持不可變集合的語義");
            System.out.println("  - 跨JDK版本兼容");
            System.out.println("  - 序列化格式穩(wěn)定");
            System.out.println();
            System.out.println("?? 方案缺點(diǎn)：");
            System.out.println("  - 需要為每個(gè)類實(shí)現(xiàn)writeReplace/readResolve");
            System.out.println("  - 代碼復(fù)雜度增加");
            
        } catch (Exception e) {
            System.out.println("異常: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    /**
     * 配置類 - 使用序列化代理模式
     */
    public static class Config implements Serializable {
        private static final long serialVersionUID = 1L;
        
        private final String name;
        private final List<String> servers;
        private final Map<String, String> properties;
        
        public Config(String name, List<String> servers, Map<String, String> properties) {
            this.name = name;
            this.servers = servers;
            this.properties = properties;
        }
        
        public String getName() { return name; }
        public List<String> getServers() { return servers; }
        public Map<String, String> getProperties() { return properties; }
        
        /**
         * 序列化代理 - 將不可變集合轉(zhuǎn)換為可序列化的形式
         */
        private Object writeReplace() {
            return new SerializationProxy(this);
        }
        
        /**
         * 序列化代理類
         */
        private static class SerializationProxy implements Serializable {
            private static final long serialVersionUID = 1L;
            
            private final String name;
            private final List<String> servers;
            private final Map<String, String> properties;
            
            public SerializationProxy(Config config) {
                this.name = config.name;
                // 轉(zhuǎn)換為ArrayList進(jìn)行序列化
                this.servers = new ArrayList<>(config.servers);
                this.properties = new HashMap<>(config.properties);
            }
            
            /**
             * 反序列化時(shí)重建不可變集合
             */
            private Object readResolve() {
                return new Config(
                    name,
                    List.copyOf(servers),  // 轉(zhuǎn)換回不可變集合
                    Map.copyOf(properties)
                );
            }
        }
    }
    
    private static byte[] serialize(Object obj) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.close();
        return bos.toByteArray();
    }
    
    private static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

=== 解決方案二：序列化代理模式 ===

原始配置：
  名稱: app-config
  服務(wù)器列表: [server1, server2, server3]
  屬性: {timeout=30, retry=3}
  Servers類型: java.util.ImmutableCollections$ListN

序列化成功，大小: 215 字節(jié)

反序列化后配置：
  名稱: app-config
  服務(wù)器列表: [server1, server2, server3]
  屬性: {timeout=30, retry=3}
  Servers類型: java.util.ImmutableCollections$ListN

驗(yàn)證不可變性：
  ? 列表不可修改，保持不可變性

? 方案優(yōu)點(diǎn)：
  - 保持不可變集合的語義
  - 跨JDK版本兼容
  - 序列化格式穩(wěn)定

?? 方案缺點(diǎn)：
  - 需要為每個(gè)類實(shí)現(xiàn)writeReplace/readResolve
  - 代碼復(fù)雜度增加

package com.architect.pitfalls.immutable.solution;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import java.util.*;

/**
 * 解決方案三：使用JSON序列化替代Java原生序列化
 * 
 * JSON序列化的優(yōu)點(diǎn)：
 * 1. 跨語言兼容
 * 2. 不依賴Java內(nèi)部類實(shí)現(xiàn)
 * 3. 可讀性好，便于調(diào)試
 * 4. 版本兼容性好
 */
public class JsonSerializationSolution {
    
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    public static void main(String[] args) {
        System.out.println("=== 解決方案三：JSON序列化 ===\n");
        
        try {
            // 創(chuàng)建不可變集合
            List<String> immutableList = List.of("a", "b", "c");
            Set<String> immutableSet = Set.of("x", "y", "z");
            Map<String, String> immutableMap = Map.of("key1", "value1", "key2", "value2");
            
            System.out.println("原始集合類型：");
            System.out.println("  List類型: " + immutableList.getClass().getName());
            System.out.println("  Set類型:  " + immutableSet.getClass().getName());
            System.out.println("  Map類型:  " + immutableMap.getClass().getName());
            System.out.println();
            
            // JSON序列化
            String listJson = objectMapper.writeValueAsString(immutableList);
            String setJson = objectMapper.writeValueAsString(immutableSet);
            String mapJson = objectMapper.writeValueAsString(immutableMap);
            
            System.out.println("JSON序列化結(jié)果：");
            System.out.println("  List: " + listJson);
            System.out.println("  Set:  " + setJson);
            System.out.println("  Map:  " + mapJson);
            System.out.println();
            
            // JSON反序列化
            List<String> deserializedList = objectMapper.readValue(listJson, 
                new TypeReference<List<String>>() {});
            Set<String> deserializedSet = objectMapper.readValue(setJson, 
                new TypeReference<Set<String>>() {});
            Map<String, String> deserializedMap = objectMapper.readValue(mapJson, 
                new TypeReference<Map<String, String>>() {});
            
            System.out.println("反序列化后類型：");
            System.out.println("  List類型: " + deserializedList.getClass().getName());
            System.out.println("  Set類型:  " + deserializedSet.getClass().getName());
            System.out.println("  Map類型:  " + deserializedMap.getClass().getName());
            System.out.println();
            
            // 驗(yàn)證可修改性
            System.out.println("驗(yàn)證反序列化后可修改：");
            deserializedList.add("d");
            System.out.println("  List添加元素成功: " + deserializedList);
            deserializedSet.add("w");
            System.out.println("  Set添加元素成功: " + deserializedSet);
            deserializedMap.put("key3", "value3");
            System.out.println("  Map添加元素成功: " + deserializedMap);
            System.out.println();
            
            // 演示復(fù)雜對象序列化
            System.out.println("復(fù)雜對象序列化演示：");
            Config config = new Config("my-app", 
                List.of("server1", "server2"), 
                Map.of("timeout", "30"));
            String configJson = objectMapper.writeValueAsString(config);
            System.out.println("  原始對象: " + config);
            System.out.println("  JSON: " + configJson);
            
            Config deserializedConfig = objectMapper.readValue(configJson, Config.class);
            System.out.println("  反序列化: " + deserializedConfig);
            System.out.println();
            
            System.out.println("? 方案優(yōu)點(diǎn)：");
            System.out.println("  - 跨JDK版本完全兼容");
            System.out.println("  - 跨語言支持");
            System.out.println("  - 可讀性強(qiáng)，便于調(diào)試");
            System.out.println("  - 不依賴Java內(nèi)部類實(shí)現(xiàn)");
            System.out.println("  - 適合網(wǎng)絡(luò)傳輸和存儲(chǔ)");
            System.out.println();
            System.out.println("?? 方案缺點(diǎn)：");
            System.out.println("  - 需要引入第三方庫（Jackson/Gson）");
            System.out.println("  - 性能略低于Java原生序列化");
            System.out.println("  - 反序列化后是可變集合（可手動(dòng)轉(zhuǎn)換）");
            
        } catch (Exception e) {
            System.out.println("異常: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    /**
     * 配置類 - 用于演示復(fù)雜對象序列化
     */
    public static class Config {
        private String name;
        private List<String> servers;
        private Map<String, String> properties;
        
        public Config() {}
        
        public Config(String name, List<String> servers, Map<String, String> properties) {
            this.name = name;
            this.servers = servers;
            this.properties = properties;
        }
        
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        
        public List<String> getServers() { return servers; }
        public void setServers(List<String> servers) { this.servers = servers; }
        
        public Map<String, String> getProperties() { return properties; }
        public void setProperties(Map<String, String> properties) { this.properties = properties; }
        
        @Override
        public String toString() {
            return "Config{name='" + name + "', servers=" + servers + ", properties=" + properties + "}";
        }
    }
}

=== 解決方案三：JSON序列化 ===

原始集合類型：
  List類型: java.util.ImmutableCollections$ListN
  Set類型:  java.util.ImmutableCollections$SetN
  Map類型:  java.util.ImmutableCollections$MapN

JSON序列化結(jié)果：
  List: ["a","b","c"]
  Set:  ["x","y","z"]
  Map:  {"key1":"value1","key2":"value2"}

反序列化后類型：
  List類型: java.util.ArrayList
  Set類型:  java.util.HashSet
  Map類型:  java.util.LinkedHashMap

驗(yàn)證反序列化后可修改：
  List添加元素成功: [a, b, c, d]
  Set添加元素成功:  [x, y, z, w]
  Map添加元素成功:  {key1=value1, key2=value2, key3=value3}

復(fù)雜對象序列化演示：
  原始對象: Config{name='my-app', servers=[server1, server2], properties={timeout=30}}
  JSON: {"name":"my-app","servers":["server1","server2"],"properties":{"timeout":"30"}}
  反序列化: Config{name='my-app', servers=[server1, server2], properties={timeout=30}}

? 方案優(yōu)點(diǎn)：
  - 跨JDK版本完全兼容
  - 跨語言支持
  - 可讀性強(qiáng)，便于調(diào)試
  - 不依賴Java內(nèi)部類實(shí)現(xiàn)
  - 適合網(wǎng)絡(luò)傳輸和存儲(chǔ)

?? 方案缺點(diǎn)：
  - 需要引入第三方庫（Jackson/Gson）
  - 性能略低于Java原生序列化
  - 反序列化后是可變集合（可手動(dòng)轉(zhuǎn)換）