/**
 * 小内存应用内存分配策略
 * 
 * 总内存: 1.5G
 * 堆内存: 1.0G (约67%)
 * 非堆内存: 0.5G (约33%)
 *   - 元空间: 128M-256M
 *   - 直接内存: 128M-256M
 *   - 线程栈: 每线程1M
 */
public class SmallMemoryConfig {
    
    /**
     * 基础内存配置（500M最小堆）
     */
    public static final String BASE_MEMORY_CONFIG = 
        "-Xms500m " +                    // 初始堆内存500M
        "-Xmx1500m " +                   // 最大堆内存1.5G
        "-XX:MetaspaceSize=128m " +      // 元空间初始大小
        "-XX:MaxMetaspaceSize=256m " +   // 元空间最大大小
        "-XX:MaxDirectMemorySize=256m";  // 直接内存最大大小
    
    /**
     * 新生代配置
     * 新生代:老年代 = 1:2 (默认)
     * 1.5G堆内存中:
     *   - 新生代: 500M
     *   - 老年代: 1000M
     */
    public static final String YOUNG_GENERATION_CONFIG = 
        "-Xmn500m " +                    // 新生代大小500M
        "-XX:SurvivorRatio=8";           // Eden:Survivor = 8:1:1
    
    /**
     * 完整的小内存配置
     */
    public static final String COMPLETE_CONFIG = 
        BASE_MEMORY_CONFIG + " " +
        YOUNG_GENERATION_CONFIG;
}

/**
 * 小内存应用内存区域划分详解
 */
public class MemoryRegionAnalysis {
    
    /**
     * 堆内存结构（1.5G总堆）
     * 
     * 新生代 (500M):
     *   - Eden区: 400M (80%)
     *   - Survivor0: 50M (10%)
     *   - Survivor1: 50M (10%)
     * 
     * 老年代 (1000M):
     *   - 长期存活对象
     *   - 大对象直接分配
     */
    public static void analyzeHeapStructure() {
        long totalHeap = 1536L * 1024 * 1024; // 1.5G
        long youngGen = 512L * 1024 * 1024;   // 500M
        long oldGen = totalHeap - youngGen;    // 1000M
        
        long eden = (long)(youngGen * 0.8);   // 400M
        long survivor = (long)(youngGen * 0.1); // 50M
        
        System.out.println("堆内存结构分析:");
        System.out.println("总堆内存: " + (totalHeap / 1024 / 1024) + "M");
        System.out.println("新生代: " + (youngGen / 1024 / 1024) + "M");
        System.out.println("  - Eden区: " + (eden / 1024 / 1024) + "M");
        System.out.println("  - Survivor0: " + (survivor / 1024 / 1024) + "M");
        System.out.println("  - Survivor1: " + (survivor / 1024 / 1024) + "M");
        System.out.println("老年代: " + (oldGen / 1024 / 1024) + "M");
    }
    
    /**
     * 非堆内存结构
     */
    public static void analyzeNonHeapStructure() {
        System.out.println("\n非堆内存结构:");
        System.out.println("元空间: 128M-256M");
        System.out.println("直接内存: 256M");
        System.out.println("线程栈: 每线程1M (默认)");
        System.out.println("程序计数器: 极小");
    }
}

/**
 * JVM内存参数配置工具类
 */
@Component
public class JVMMemoryConfigBuilder {
    
    /**
     * 构建小内存应用启动参数
     * 
     * @param minHeap 最小堆内存（MB）
     * @param maxHeap 最大堆内存（MB）
     * @return 完整的启动参数
     */
    public String buildSmallMemoryConfig(int minHeap, int maxHeap) {
        StringBuilder config = new StringBuilder();
        
        // 堆内存配置
        config.append("-Xms").append(minHeap).append("m ");
        config.append("-Xmx").append(maxHeap).append("m ");
        
        // 新生代配置（建议为堆内存的1/3）
        int youngGen = maxHeap / 3;
        config.append("-Xmn").append(youngGen).append("m ");
        
        // Survivor比例
        config.append("-XX:SurvivorRatio=8 ");
        
        // 元空间配置（小内存应用建议128M-256M）
        int metaspaceSize = Math.min(128, maxHeap / 10);
        int maxMetaspaceSize = Math.min(256, maxHeap / 6);
        config.append("-XX:MetaspaceSize=").append(metaspaceSize).append("m ");
        config.append("-XX:MaxMetaspaceSize=").append(maxMetaspaceSize).append("m ");
        
        // 直接内存配置
        int directMemory = Math.min(256, maxHeap / 6);
        config.append("-XX:MaxDirectMemorySize=").append(directMemory).append("m ");
        
        // 线程栈大小（小内存应用建议512K-1M）
        config.append("-Xss512k ");
        
        return config.toString().trim();
    }
    
    /**
     * 构建生产环境小内存配置（500M-1.5G）
     */
    public String buildProductionConfig() {
        return buildSmallMemoryConfig(500, 1536);
    }
    
    /**
     * 验证内存配置合理性
     */
    public boolean validateConfig(int minHeap, int maxHeap) {
        // 最小堆不能大于最大堆
        if (minHeap > maxHeap) {
            return false;
        }
        
        // 最大堆建议不超过2G（小内存应用）
        if (maxHeap > 2048) {
            System.out.println("警告: 最大堆超过2G，建议使用大内存配置");
        }
        
        // 最小堆建议为最大堆的1/3到1/2
        double ratio = (double) minHeap / maxHeap;
        if (ratio < 0.3 || ratio > 0.5) {
            System.out.println("警告: 最小堆与最大堆比例不在推荐范围(0.3-0.5)");
        }
        
        return true;
    }
}

/**
 * 小内存应用GC算法选择策略
 */
public class GCAlgorithmSelector {
    
    /**
     * Serial GC - 单线程GC
     * 适用场景: 小内存应用（<100M堆），单核CPU
     * 优点: 开销小，适合小应用
     * 缺点: 停顿时间长
     */
    public static final String SERIAL_GC = 
        "-XX:+UseSerialGC";
    
    /**
     * Parallel GC - 并行GC（JDK 8默认）
     * 适用场景: 吞吐量优先，多核CPU
     * 优点: 吞吐量高，适合批处理
     * 缺点: 停顿时间较长
     */
    public static final String PARALLEL_GC = 
        "-XX:+UseParallelGC " +
        "-XX:ParallelGCThreads=4 " +      // GC线程数
        "-XX:MaxGCPauseMillis=200";       // 最大停顿时间目标
    
    /**
     * G1 GC - 低延迟GC（推荐）
     * 适用场景: 延迟敏感应用，堆内存>1G
     * 优点: 可预测停顿时间，适合Web应用
     * 缺点: 内存开销稍大
     */
    public static final String G1_GC = 
        "-XX:+UseG1GC " +
        "-XX:MaxGCPauseMillis=200 " +     // 最大停顿时间目标
        "-XX:G1HeapRegionSize=16m " +     // Region大小
        "-XX:InitiatingHeapOccupancyPercent=45"; // 触发并发标记阈值
    
    /**
     * ZGC - 超低延迟GC（JDK 11+）
     * 适用场景: 超大堆，极低延迟要求
     * 优点: 停顿时间<10ms
     * 缺点: 需要JDK 11+
     */
    public static final String Z_GC = 
        "-XX:+UseZGC " +
        "-XX:MaxGCPauseMillis=10";
    
    /**
     * 为小内存应用推荐GC算法
     */
    public static String recommendGC(int maxHeapMB, boolean lowLatency) {
        if (maxHeapMB < 512) {
            // 极小内存，使用Serial GC
            return SERIAL_GC;
        } else if (maxHeapMB < 1536) {
            // 小内存应用，根据延迟要求选择
            if (lowLatency) {
                return G1_GC;
            } else {
                return PARALLEL_GC;
            }
        } else {
            // 中等内存，优先G1
            return G1_GC;
        }
    }
}

/**
 * G1 GC小内存应用优化配置
 */
@Component
public class G1GCOptimizer {
    
    /**
     * 构建G1 GC优化配置（针对500M-1.5G）
     */
    public String buildG1Config(int maxHeapMB) {
        StringBuilder config = new StringBuilder();
        
        // 启用G1 GC
        config.append("-XX:+UseG1GC ");
        
        // 停顿时间目标（小内存应用建议200-300ms）
        config.append("-XX:MaxGCPauseMillis=200 ");
        
        // Region大小（小内存应用建议4M-8M）
        int regionSize = calculateRegionSize(maxHeapMB);
        config.append("-XX:G1HeapRegionSize=").append(regionSize).append("m ");
        
        // 并发标记触发阈值（小内存应用建议40-45%）
        config.append("-XX:InitiatingHeapOccupancyPercent=45 ");
        
        // 并行GC线程数（建议为CPU核心数）
        int gcThreads = Runtime.getRuntime().availableProcessors();
        config.append("-XX:ParallelGCThreads=").append(gcThreads).append(" ");
        config.append("-XX:ConcGCThreads=").append(Math.max(1, gcThreads / 4)).append(" ");
        
        // 启用字符串去重（节省内存）
        config.append("-XX:+UseStringDeduplication ");
        
        // 启用类卸载
        config.append("-XX:+ClassUnloadingWithConcurrentMark ");
        
        return config.toString().trim();
    }
    
    /**
     * 计算合适的Region大小
     * G1要求Region数量在2048-8192之间
     */
    private int calculateRegionSize(int maxHeapMB) {
        // 尝试不同的Region大小
        int[] regionSizes = {1, 2, 4, 8, 16, 32};
        for (int size : regionSizes) {
            int regionCount = maxHeapMB / size;
            if (regionCount >= 2048 && regionCount <= 8192) {
                return size;
            }
        }
        // 默认返回4M
        return 4;
    }
}

/**
 * GC日志配置工具
 */
@Component
public class GCLogConfigBuilder {
    
    /**
     * 构建GC日志配置
     */
    public String buildGCLogConfig(String logPath) {
        StringBuilder config = new StringBuilder();
        
        // 启用GC日志
        config.append("-XX:+PrintGCDetails ");
        config.append("-XX:+PrintGCDateStamps ");
        config.append("-XX:+PrintGCTimeStamps ");
        
        // GC日志文件路径
        config.append("-Xloggc:").append(logPath).append(" ");
        
        // 使用新的日志格式（JDK 9+）
        config.append("-XX:+UseGCLogFileRotation ");
        config.append("-XX:NumberOfGCLogFiles=5 ");
        config.append("-XX:GCLogFileSize=20M ");
        
        // 使用统一日志（JDK 9+推荐）
        String unifiedLogConfig = String.format(
            "-Xlog:gc*:file=%s:time,uptime,level,tags:filecount=5,filesize=20M ",
            logPath
        );
        
        return unifiedLogConfig;
    }
    
    /**
     * 构建详细的GC监控配置
     */
    public String buildDetailedGCMonitoring() {
        return 
            "-XX:+PrintGCDetails " +
            "-XX:+PrintGCDateStamps " +
            "-XX:+PrintGCApplicationStoppedTime " +
            "-XX:+PrintGCApplicationConcurrentTime " +
            "-XX:+PrintTenuringDistribution " +
            "-XX:+HeapDumpOnOutOfMemoryError " +
            "-XX:HeapDumpPath=/tmp/heapdump.hprof";
    }
}

/**
 * 小内存应用完整启动参数配置
 */
@Configuration
public class SmallMemoryJVMConfig {
    
    /**
     * 生产环境完整配置（500M-1.5G）
     */
    public static final String PRODUCTION_CONFIG = 
        // 堆内存配置
        "-Xms500m " +
        "-Xmx1536m " +
        "-Xmn512m " +
        "-XX:SurvivorRatio=8 " +
        
        // 元空间配置
        "-XX:MetaspaceSize=128m " +
        "-XX:MaxMetaspaceSize=256m " +
        
        // 直接内存配置
        "-XX:MaxDirectMemorySize=256m " +
        
        // 线程栈配置
        "-Xss512k " +
        
        // G1 GC配置
        "-XX:+UseG1GC " +
        "-XX:MaxGCPauseMillis=200 " +
        "-XX:G1HeapRegionSize=4m " +
        "-XX:InitiatingHeapOccupancyPercent=45 " +
        "-XX:ParallelGCThreads=4 " +
        "-XX:ConcGCThreads=1 " +
        "-XX:+UseStringDeduplication " +
        
        // GC日志配置
        "-Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=5,filesize=20M " +
        
        // OOM时生成堆转储
        "-XX:+HeapDumpOnOutOfMemoryError " +
        "-XX:HeapDumpPath=/tmp/heapdump.hprof " +
        
        // JIT编译优化
        "-XX:+TieredCompilation " +
        "-XX:TieredStopAtLevel=1 " +
        
        // 其他优化
        "-XX:+UseCompressedOops " +        // 压缩指针
        "-XX:+UseCompressedClassPointers " + // 压缩类指针
        "-Djava.awt.headless=true";        // 无头模式
}

/**
 * JVM内存监控服务
 */
@Service
public class JVMMemoryMonitorService {
    
    private final MemoryMXBean memoryBean;
    private final List<GarbageCollectorMXBean> gcBeans;
    
    public JVMMemoryMonitorService() {
        this.memoryBean = ManagementFactory.getMemoryMXBean();
        this.gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
    }
    
    /**
     * 获取堆内存使用情况
     */
    public MemoryUsage getHeapMemoryUsage() {
        return memoryBean.getHeapMemoryUsage();
    }
    
    /**
     * 获取非堆内存使用情况
     */
    public MemoryUsage getNonHeapMemoryUsage() {
        return memoryBean.getNonHeapMemoryUsage();
    }
    
    /**
     * 检查内存使用率
     */
    public boolean checkMemoryUsage(double threshold) {
        MemoryUsage heapUsage = getHeapMemoryUsage();
        long used = heapUsage.getUsed();
        long max = heapUsage.getMax();
        double usageRate = (double) used / max;
        
        if (usageRate > threshold) {
            log.warn("堆内存使用率过高: {:.2f}%, 已使用: {}M, 最大: {}M",
                usageRate * 100,
                used / 1024 / 1024,
                max / 1024 / 1024);
            return false;
        }
        return true;
    }
    
    /**
     * 获取GC统计信息
     */
    public GCStats getGCStats() {
        long totalGCCount = 0;
        long totalGCTime = 0;
        
        for (GarbageCollectorMXBean gcBean : gcBeans) {
            totalGCCount += gcBean.getCollectionCount();
            totalGCTime += gcBean.getCollectionTime();
        }
        
        return GCStats.builder()
            .totalGCCount(totalGCCount)
            .totalGCTime(totalGCTime)
            .build();
    }
    
    /**
     * 定时监控内存使用
     */
    @Scheduled(fixedRate = 60000) // 每分钟
    public void monitorMemory() {
        MemoryUsage heapUsage = getHeapMemoryUsage();
        MemoryUsage nonHeapUsage = getNonHeapMemoryUsage();
        
        log.info("内存使用情况 - 堆: {}M/{}M ({}%), 非堆: {}M/{}M ({}%)",
            heapUsage.getUsed() / 1024 / 1024,
            heapUsage.getMax() / 1024 / 1024,
            (heapUsage.getUsed() * 100 / heapUsage.getMax()),
            nonHeapUsage.getUsed() / 1024 / 1024,
            nonHeapUsage.getMax() / 1024 / 1024,
            (nonHeapUsage.getMax() > 0 ? 
                nonHeapUsage.getUsed() * 100 / nonHeapUsage.getMax() : 0));
        
        // 内存使用率超过80%告警
        checkMemoryUsage(0.8);
    }
}

/**
 * GC统计信息
 */
@Data
@Builder
class GCStats {
    private long totalGCCount;
    private long totalGCTime;
}

/**
 * 内存泄漏检测工具
 */
@Component
public class MemoryLeakDetector {
    
    /**
     * 检测潜在内存泄漏
     */
    public boolean detectMemoryLeak() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        
        long used = heapUsage.getUsed();
        long max = heapUsage.getMax();
        double usageRate = (double) used / max;
        
        // 如果内存使用率持续超过85%，可能存在泄漏
        if (usageRate > 0.85) {
            log.warn("检测到潜在内存泄漏，堆内存使用率: {:.2f}%", usageRate * 100);
            
            // 建议执行Full GC
            System.gc();
            
            // 再次检查
            heapUsage = memoryBean.getHeapMemoryUsage();
            long newUsed = heapUsage.getUsed();
            
            // 如果Full GC后内存没有明显下降，可能存在泄漏
            if ((double) newUsed / max > 0.80) {
                log.error("Full GC后内存使用率仍高，可能存在内存泄漏");
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * 分析堆转储文件
     */
    public void analyzeHeapDump(String heapDumpPath) {
        log.info("分析堆转储文件: {}", heapDumpPath);
        // 可以使用Eclipse MAT或jhat分析
        // jhat -J-Xmx2g heapdump.hprof
    }
}

/**
 * 应用层内存优化实践
 */
@Service
public class ApplicationMemoryOptimizer {
    
    /**
     * 对象池化减少GC压力
     */
    private final ObjectPool<StringBuilder> stringBuilderPool;
    
    public ApplicationMemoryOptimizer() {
        GenericObjectPoolConfig<StringBuilder> config = 
            new GenericObjectPoolConfig<>();
        config.setMaxTotal(100);
        config.setMaxIdle(20);
        config.setMinIdle(5);
        
        this.stringBuilderPool = new GenericObjectPool<>(
            new BasePooledObjectFactory<StringBuilder>() {
                @Override
                public StringBuilder create() {
                    return new StringBuilder();
                }
                
                @Override
                public PooledObject<StringBuilder> wrap(StringBuilder obj) {
                    return new DefaultPooledObject<>(obj);
                }
                
                @Override
                public void passivateObject(PooledObject<StringBuilder> p) {
                    p.getObject().setLength(0); // 清空内容
                }
            },
            config
        );
    }
    
    /**
     * 使用对象池构建字符串
     */
    public String buildString(List<String> parts) {
        StringBuilder sb = null;
        try {
            sb = stringBuilderPool.borrowObject();
            for (String part : parts) {
                sb.append(part);
            }
            return sb.toString();
        } catch (Exception e) {
            log.error("获取StringBuilder失败", e);
            return String.join("", parts);
        } finally {
            if (sb != null) {
                stringBuilderPool.returnObject(sb);
            }
        }
    }
    
    /**
     * 批量处理优化（减少内存峰值）
     */
    public <T> void processBatch(List<T> items, int batchSize, 
                                 Consumer<List<T>> processor) {
        for (int i = 0; i < items.size(); i += batchSize) {
            int end = Math.min(i + batchSize, items.size());
            List<T> batch = items.subList(i, end);
            processor.accept(batch);
            
            // 处理完一批后建议GC（仅在高内存压力时）
            if (i % (batchSize * 10) == 0) {
                System.gc();
            }
        }
    }
    
    /**
     * 使用软引用缓存（内存不足时自动释放）
     */
    private final Map<String, SoftReference<Object>> softCache = 
        new ConcurrentHashMap<>();
    
    public void putToSoftCache(String key, Object value) {
        softCache.put(key, new SoftReference<>(value));
    }
    
    public Object getFromSoftCache(String key) {
        SoftReference<Object> ref = softCache.get(key);
        if (ref != null) {
            Object value = ref.get();
            if (value == null) {
                softCache.remove(key); // 已被GC，移除引用
            }
            return value;
        }
        return null;
    }
}

/**
 * 容器环境JVM参数自动检测
 */
@Component
public class ContainerJVMConfigDetector {
    
    /**
     * 检测容器内存限制并自动调整JVM参数
     */
    public String detectAndAdjustMemory() {
        // 读取容器内存限制（cgroup）
        long containerMemoryLimit = readContainerMemoryLimit();
        
        if (containerMemoryLimit > 0) {
            // 为系统和其他进程预留20%内存
            long availableMemory = (long)(containerMemoryLimit * 0.8);
            
            // 堆内存设置为可用内存的70%
            long heapMemory = (long)(availableMemory * 0.7);
            
            // 元空间设置为堆内存的15%
            long metaspaceMemory = (long)(heapMemory * 0.15);
            
            return String.format(
                "-Xms%dm -Xmx%dm -XX:MaxMetaspaceSize=%dm",
                heapMemory / 1024 / 1024,
                heapMemory / 1024 / 1024,
                metaspaceMemory / 1024 / 1024
            );
        }
        
        // 如果无法检测，使用默认配置
        return "-Xms500m -Xmx1536m -XX:MaxMetaspaceSize=256m";
    }
    
    /**
     * 读取容器内存限制（Linux cgroup）
     */
    private long readContainerMemoryLimit() {
        try {
            // 读取 /sys/fs/cgroup/memory/memory.limit_in_bytes
            Path cgroupPath = Paths.get("/sys/fs/cgroup/memory/memory.limit_in_bytes");
            if (Files.exists(cgroupPath)) {
                String content = Files.readString(cgroupPath).trim();
                long limit = Long.parseLong(content);
                // 如果限制很大（接近Long.MAX_VALUE），说明没有限制
                if (limit > 1024L * 1024 * 1024 * 1024) {
                    return 0;
                }
                return limit;
            }
        } catch (Exception e) {
            log.warn("无法读取容器内存限制", e);
        }
        return 0;
    }
}

/**
 * 内存压力测试工具
 */
@SpringBootTest
public class MemoryPressureTest {
    
    @Test
    public void testMemoryAllocation() {
        // 测试不同内存配置下的性能
        int[] heapSizes = {512, 1024, 1536}; // MB
        
        for (int heapSize : heapSizes) {
            System.out.println("\n测试堆内存大小: " + heapSize + "M");
            
            long startTime = System.currentTimeMillis();
            List<byte[]> data = new ArrayList<>();
            
            // 分配内存直到接近堆大小
            long allocated = 0;
            long targetSize = heapSize * 1024L * 1024 * 80 / 100; // 80%堆大小
            
            while (allocated < targetSize) {
                int chunkSize = 1024 * 1024; // 1MB
                byte[] chunk = new byte[chunkSize];
                data.add(chunk);
                allocated += chunkSize;
            }
            
            long endTime = System.currentTimeMillis();
            System.out.println("分配内存耗时: " + (endTime - startTime) + "ms");
            System.out.println("已分配内存: " + (allocated / 1024 / 1024) + "M");
            
            // 触发GC
            System.gc();
            Thread.sleep(1000);
            
            MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
            MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
            System.out.println("GC后堆内存使用: " + 
                (heapUsage.getUsed() / 1024 / 1024) + "M");
        }
    }
    
    @Test
    public void testGCPauseTime() {
        // 测试GC停顿时间
        List<Long> pauseTimes = new ArrayList<>();
        
        for (int i = 0; i < 100; i++) {
            // 创建大量对象触发GC
            List<String> objects = new ArrayList<>();
            for (int j = 0; j < 10000; j++) {
                objects.add("Object" + j + StringUtils.repeat("x", 100));
            }
            
            // 记录GC时间
            long gcTime = getGCTime();
            pauseTimes.add(gcTime);
        }
        
        // 统计GC停顿时间
        double avgPauseTime = pauseTimes.stream()
            .mapToLong(Long::longValue)
            .average()
            .orElse(0);
        
        long maxPauseTime = pauseTimes.stream()
            .mapToLong(Long::longValue)
            .max()
            .orElse(0);
        
        System.out.println("平均GC停顿时间: " + avgPauseTime + "ms");
        System.out.println("最大GC停顿时间: " + maxPauseTime + "ms");
    }
    
    private long getGCTime() {
        long totalGCTime = 0;
        for (GarbageCollectorMXBean gcBean : 
             ManagementFactory.getGarbageCollectorMXBeans()) {
            totalGCTime += gcBean.getCollectionTime();
        }
        return totalGCTime;
    }
}

/**
 * Spring Boot小内存应用配置
 */
@Configuration
public class SpringBootSmallMemoryConfig {
    
    /**
     * 优化Tomcat线程池（减少内存占用）
     */
    @Bean
    public TomcatServletWebServerFactory tomcatFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.addConnectorCustomizers(connector -> {
            ProtocolHandler handler = connector.getProtocolHandler();
            if (handler instanceof AbstractProtocol) {
                AbstractProtocol<?> protocol = (AbstractProtocol<?>) handler;
                protocol.setMaxThreads(50);        // 减少最大线程数
                protocol.setMinSpareThreads(10);  // 减少最小空闲线程
                protocol.setAcceptCount(100);     // 减少接受队列
            }
        });
        return factory;
    }
    
    /**
     * 优化连接池配置（减少内存占用）
     */
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setMaximumPoolSize(10);      // 减少最大连接数
        config.setMinimumIdle(2);           // 减少最小空闲连接
        config.setConnectionTimeout(3000);
        config.setIdleTimeout(600000);
        config.setMaxLifetime(1800000);
        return new HikariDataSource(config);
    }
    
    /**
     * 优化Jackson序列化（减少内存占用）
     */
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        // 使用流式API处理大JSON
        return mapper;
    }
}