Durid 和 HikariCP，哪个更好？

// 错误示例：每次请求都创建新连接
public void getData() {
    Class.forName("com.mysql.jdbc.Driver");
    Connection conn = DriverManager.getConnection(url, user, password);
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT * FROM users");
    // ...
    rs.close();
    stmt.close();
    conn.close();
}

// 模拟高并发获取连接
publicclass ConnectionPoolBenchmark {
    
    @Test
    public void testHikari() throws Exception {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        config.setUsername("root");
        config.setPassword("123456");
        config.setMaximumPoolSize(20);
        // 开启泄漏检测（后面会讲到）
        config.setLeakDetectionThreshold(5000);
        
        HikariDataSource ds = new HikariDataSource(config);
        
        // 100个线程并发获取连接
        ExecutorService executor = Executors.newFixedThreadPool(100);
        long start = System.currentTimeMillis();
        
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try (Connection conn = ds.getConnection()) {
                    // 模拟业务操作
                    conn.isValid(1);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        long end = System.currentTimeMillis();
        System.out.println("总耗时: " + (end - start) + "ms");
    }
}

public class ConcurrentBag<T> {
    // sharedList保存了所有的连接
    privatefinal CopyOnWriteArrayList<T> sharedList;
    // threadList保存当前线程用过连接的引用
    privatefinal ThreadLocal<List<Object>> threadList;
    // 等待获取连接的线程数
    privatefinal AtomicInteger waiters;
    
    /**
     * 从连接池中获取连接的核心方法
     */
    public T borrow(long timeout, final TimeUnit timeUnit) 
            throws InterruptedException {
        
        // ① 先尝试从ThreadLocal中拿——这一步完全无锁！
        List<Object> list = threadList.get();
        for (int i = list.size() - 1; i >= 0; i--) {
            final T bagEntry = (T) list.remove(i);
            // CAS操作，无锁更新连接状态
            if (bagEntry != null && 
                bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
                return bagEntry;
            }
        }
        
        // ② ThreadLocal中没有，再从sharedList中拿
        // 等待timeout时间，通过synchronizer进行线程间同步
        // ...
    }
}

# HikariCP推荐配置（生产环境）
spring:
datasource:
    hikari:
      maximum-pool-size:20          # 最大连接数，根据黄金公式设置
      minimum-idle:20               # 建议等于maximumPoolSize，固定大小
      connection-timeout:3000       # 连接超时，建议调小到3秒
      idle-timeout:600000           # 空闲超时10分钟
      max-lifetime:1800000          # 最大存活30分钟，必须小于数据库wait_timeout
      leak-detection-threshold:60000# 连接泄漏检测，60秒未归还就报警
      validation-timeout:5000       # 连接校验超时5秒

# application.yml
spring:
datasource:
    druid:
      # 监控页面配置
      stat-view-servlet:
        enabled:true
        url-pattern:/druid/*
        login-username:admin
        login-password:123456
        reset-enable:false
      
      # Web监控过滤器
      web-stat-filter:
        enabled:true
        url-pattern:/*
        exclusions:"*.js,*.css,*.jpg,/druid/*"
        session-stat-enable:true
      
      # SQL监控配置
      filter:
        stat:
          enabled:true
          db-type:mysql
          log-slow-sql:true
          slow-sql-millis:1000# 超过1秒算慢查询
        wall:
          enabled:true           # 开启防火墙
          config:
            delete-allow:false   # 禁止全表删除
            drop-table-allow:false# 禁止删表

@Configuration
publicclass DruidConfig {
    
    @Bean
    public DataSource druidDataSource() {
        DruidDataSource ds = new DruidDataSource();
        
        // 连接池基础配置
        ds.setUrl("jdbc:mysql://localhost:3306/test");
        ds.setUsername("root");
        ds.setPassword("123456");
        ds.setInitialSize(10);
        ds.setMaxActive(100);
        ds.setMinIdle(10);
        
        // 🔥 核心防泄漏配置
        ds.setRemoveAbandoned(true);              // 开启泄漏连接自动回收
        ds.setRemoveAbandonedTimeout(180);        // 180秒未归还算泄漏
        ds.setLogAbandoned(true);                 // 记录泄漏连接的堆栈信息
        ds.setAbandonWhenOverflow(true);          // 连接池满时立即回收泄漏连接
        
        // 连接保活配置
        ds.setValidationQuery("SELECT 1");
        ds.setTestWhileIdle(true);
        ds.setTimeBetweenEvictionRunsMillis(60000);
        
        // 开启监控和防火墙
        ds.setFilters("stat,wall");
        
        return ds;
    }
}

// 开启WallFilter配置
ds.setFilters("stat,wall");  // stat=监控，wall=防火墙

// 高级配置：自定义拦截规则
Map<String, String> wallConfig = new HashMap<>();
wallConfig.put("deleteAllow", "false");     // 禁止DELETE操作
wallConfig.put("dropTableAllow", "false");  // 禁止DROP TABLE
wallConfig.put("createTableAllow", "false"); // 禁止CREATE TABLE

WallConfig config = new WallConfig(wallConfig);
WallFilter wallFilter = new WallFilter();
wallFilter.setConfig(config);
ds.setProxyFilters(Arrays.asList(wallFilter));