// ❌ 错误：资源未关闭
public void readFile() throws IOException {
    FileInputStream fis = new FileInputStream("test.txt");
    BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
    String line = reader.readLine();
    // 忘记关闭资源
}

// ✅ 正确：使用 try-with-resources
public void readFile() throws IOException {
    try (FileInputStream fis = new FileInputStream("test.txt");
         BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
        String line = reader.readLine();
    } // 自动关闭资源
}

// ✅ 使用 HikariCP 管理数据库连接
HikariConfig config = new HikariConfig();
config.setMaximumPoolSize(10);
config.setIdleTimeout(300000);
HikariDataSource dataSource = new HikariDataSource(config);

// ✅ 使用 OkHttp 连接池
OkHttpClient client = new OkHttpClient.Builder()
    .connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES))
    .build();

// ❌ 错误：ThreadLocal 未清理
private static final ThreadLocal<UserContext> userContext = new ThreadLocal<>();

public void handleRequest(User user) {
    userContext.set(new UserContext(user));
    // 业务逻辑...
    // 忘记调用 remove()
}

// ✅ 正确：在 Filter 中统一管理
@Component
public class UserContextFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        try {
            User user = extractUser(request);
            UserContext context = new UserContext(user);
            UserContextHolder.set(context);
            
            chain.doFilter(request, response);
        } finally {
            // 确保清理
            UserContextHolder.remove();
        }
    }
}

// ✅ 使用 AOP 自动清理
@Aspect
@Component
public class ThreadLocalCleanAspect {
    
    @Around("@annotation(CleanThreadLocal)")
    public Object cleanThreadLocal(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            return joinPoint.proceed();
        } finally {
            // 清理所有 ThreadLocal
            UserContextHolder.remove();
            RequestContextHolder.remove();
        }
    }
}

// ❌ 错误：无界集合
private static final Map<String, Object> cache = new HashMap<>();

public void addToCache(String key, Object value) {
    cache.put(key, value);  // 无限增长
}

// ✅ 正确：带淘汰策略的缓存
private static final Cache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)              // 最大容量
    .expireAfterWrite(10, TimeUnit.MINUTES)  // 写入后 10 分钟过期
    .expireAfterAccess(5, TimeUnit.MINUTES)  // 访问后 5 分钟过期
    .recordStats()                    // 记录统计信息
    .build();

public void addToCache(String key, Object value) {
    cache.put(key, value);
}

// ✅ Guava Cache
private static final LoadingCache<String, Object> cache = CacheBuilder.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .removalListener(notification -> {
        log.info("Key {} removed, reason: {}", 
                 notification.getKey(), notification.getCause());
    })
    .build(new CacheLoader<String, Object>() {
        @Override
        public Object load(String key) throws Exception {
            return loadDataFromDB(key);
        }
    });

// ✅ 使用 LinkedHashMap 实现 LRU
private static final Map<String, Object> lruCache = new LinkedHashMap<String, Object>(100, 0.75f, true) {
    @Override
    protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {
        return size() > 1000;  // 超过 1000 个元素时移除最老的
    }
};

// ❌ 错误：循环内创建动态代理
for (int i = 0; i < 10000; i++) {
    // 每次循环都创建新的代理类
    MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
        getClass().getClassLoader(),
        new Class<?>[]{MyInterface.class},
        new MyInvocationHandler()
    );
}

// ✅ 正确：复用代理类
private static final Map<Class<?>, Object> proxyCache = new ConcurrentHashMap<>();

public <T> T getProxy(Class<T> interfaceClass) {
    return (T) proxyCache.computeIfAbsent(interfaceClass, clazz -> 
        Proxy.newProxyInstance(
            getClass().getClassLoader(),
            new Class<?>[]{clazz},
            new MyInvocationHandler()
        )
    );
}

// ❌ 错误：Netty ByteBuf 未释放
ByteBuf buf = Unpooled.buffer(1024);
buf.writeBytes(data);
channel.writeAndFlush(buf);
// 忘记 release

// ✅ 正确：手动释放
ByteBuf buf = Unpooled.buffer(1024);
try {
    buf.writeBytes(data);
    channel.writeAndFlush(buf);
} finally {
    // 如果 writeAndFlush 失败，需要手动释放
    if (buf.refCnt() > 0) {
        buf.release();
    }
}

// ✅ 更好的方式：使用 ReferenceCountUtil
ByteBuf buf = Unpooled.buffer(1024);
buf.writeBytes(data);
ReferenceCountUtil.releaseLater(channel.writeAndFlush(buf));

// ✅ 强制使用 try-with-resources
try (Connection conn = dataSource.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql);
     ResultSet rs = ps.executeQuery()) {
    // 业务逻辑
}

// ✅ 强制在 finally 块中清理
try {
    UserContextHolder.set(userContext);
    // 业务逻辑
} finally {
    UserContextHolder.remove();
}

// ✅ 强制设置最大容量和过期时间
Cache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)  // 必须设置
    .expireAfterWrite(10, TimeUnit.MINUTES)  // 必须设置
    .build();