服务器卡、光烧钱扩容？HikariCP的核心门道，大白话唠明白，老板技术都能懂！ - 慧知开源充电桩平台

<!-- 重卡充电桩平台 - HikariCP数据库连接池依赖（Spring Boot 2.x及以上可省略，未集成则添加） -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

spring:
  datasource:
    # HikariCP连接池配置（适配重卡充电桩高并发场景）
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 替换为自己的数据库地址、数据库名（charger_db可改为你的库名）
    url: jdbc:mysql://localhost:3306/charger_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: 你的数据库账号  # 替换为自己的数据库账号（如root）
    password: 你的数据库密码  # 替换为自己的数据库密码
    hikari:
      minimum-idle: 20 # 最小空闲连接：1个场站10台桩设20，多场站按比例增加
      maximum-pool-size: 200 # 最大连接数：5000并发设200，10000并发设400，按实际调整
      idle-timeout: 300000 # 空闲5分钟（300000毫秒）的连接自动回收，不占资源
      max-lifetime: 1800000 # 连接最长生命周期30分钟（1800000毫秒），防止失效
      connection-test-query: SELECT 1 # 每次获取连接前验证有效性，避免用失效连接
      connection-timeout: 3000 # 3秒内获取不到连接则超时，适配充电桩高并发场景
      pool-name: ChargerHikariPool # 连接池名称，方便排查问题（可自定义）

package com.charger.platform.netty; // 替换为自己项目的包名（如com.xxx.charger.netty）

import io.netty.channel.Channel;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 重卡充电桩场站TCP连接池（Netty）
 * 功能：按场站分组管理充电桩与平台的通信连接，连接复用、自动清理断连设备，直接复用无需修改
 */
@Component
public class ChargerTcpConnPool {
    // 存储连接：key1=场站ID，key2=充电桩ID，value=通信Channel（连接对象）
    private static final Map<String, Map<String, Channel>> STATION_CONN_MAP = new ConcurrentHashMap<>();

    /**
     * 设备连接成功后，将连接加入对应场站的连接池
     * @param stationId 场站ID（自定义，如"logistics-park-01"）
     * @param chargerId 充电桩ID（设备自身ID）
     * @param channel 通信连接对象（Netty的Channel）
     */
    public void addConn(String stationId, String chargerId, Channel channel) {
        // 若场站ID不存在，自动创建该场站的连接Map；再将充电桩连接加入
        STATION_CONN_MAP.computeIfAbsent(stationId, k -> new ConcurrentHashMap<>()).put(chargerId, channel);
        // 设备断连时，自动从连接池中移除该连接，避免占用资源
        channel.closeFuture().addListener(future -> {
            if (STATION_CONN_MAP.containsKey(stationId)) {
                STATION_CONN_MAP.get(stationId).remove(chargerId);
            }
        });
    }

    /**
     * 根据场站ID和充电桩ID，获取对应的通信连接（复用连接，无需新建）
     * @param stationId 场站ID
     * @param chargerId 充电桩ID
     * @return 可用的通信Channel；若连接不存在/不可用，返回null
     */
    public Channel getConn(String stationId, String chargerId) {
        // 获取该场站的所有充电桩连接
        Map<String, Channel> chargerConnMap = STATION_CONN_MAP.get(stationId);
        if (chargerConnMap == null) {
            return null; // 场站不存在，无对应连接
        }
        // 获取该充电桩的连接
        Channel channel = chargerConnMap.get(chargerId);
        // 验证连接是否可用（活跃且可写入数据），不可用则移除，返回null
        if (channel == null || !channel.isActive() || !channel.isWritable()) {
            chargerConnMap.remove(chargerId);
            return null;
        }
        return channel;
    }

    /**
     * 给指定场站的所有充电桩发送指令（如批量查询设备状态）
     * @param stationId 场站ID
     * @param msg 要发送的指令（自定义，如"query-status"）
     */
    public void sendMsgByStation(String stationId, String msg) {
        Map<String, Channel> chargerConnMap = STATION_CONN_MAP.get(stationId);
        if (chargerConnMap == null) {
            return; // 场站不存在，无需发送
        }
        // 遍历该场站所有可用连接，发送指令
        chargerConnMap.values().forEach(channel -> {
            if (channel.isActive() && channel.isWritable()) {
                channel.writeAndFlush(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8));
            }
        });
    }
}

<!-- 重卡充电桩平台 - OkHttp3全局HTTP连接池依赖（调支付/监管/短信接口用） -->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>

package com.charger.platform.http; // 替换为自己项目的包名（如com.xxx.charger.http）

import okhttp3.*;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * 第三方接口全局HTTP连接池工具类（OkHttp3）
 * 功能：复用HTTP连接，支持GET/POST（JSON）请求，自动重试，适配支付/监管/短信接口
 */
@Component
public class ThirdPartyHttpPoolUtil {
    // 全局唯一HTTP连接池，配置好参数无需修改，所有第三方接口共享
    private static final OkHttpClient OK_HTTP_CLIENT;

    // 静态代码块：初始化连接池参数（适配重卡充电桩接口调用场景）
    static {
        // 连接池配置：最大50个空闲连接，空闲5分钟后回收
        ConnectionPool connectionPool = new ConnectionPool(50, 5, TimeUnit.MINUTES);
        OK_HTTP_CLIENT = new OkHttpClient.Builder()
                .connectionPool(connectionPool)
                .connectTimeout(5, TimeUnit.SECONDS) // 5秒连接超时（避免卡太久）
                .readTimeout(10, TimeUnit.SECONDS)   // 10秒读取超时（适配监管接口大数据量）
                .writeTimeout(10, TimeUnit.SECONDS)  // 10秒写入超时（适配支付接口）
                .retryOnConnectionFailure(true)      // 连接失败自动重试
                .addInterceptor(new RetryInterceptor(3)) // 最多重试3次，避免网络波动导致失败
                .build();
    }

    /**
     * GET请求（如调用监管平台查询接口、短信接口查询状态）
     * @param url 接口地址（如"https://xxx.jiangguan.com/query"）
     * @return 接口返回的字符串；若失败/无返回，返回null
     * @throws IOException 异常（可根据项目需求捕获，无需修改此方法）
     */
    public String doGet(String url) throws IOException {
        Request request = new Request.Builder().url(url).get().build();
        // 自动复用连接池中的连接，无需新建
        try (Response response = OK_HTTP_CLIENT.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            }
            return null;
        }
    }

    /**
     * POST请求（JSON参数，如支付宝/微信支付接口、监管平台数据同步接口）
     * @param url 接口地址（如"https://openapi.alipay.com/gateway.do"）
     * @param jsonParam JSON格式的请求参数（如{"out_trade_no":"123456","total_amount":100}）
     * @return 接口返回的字符串；若失败/无返回，返回null
     * @throws IOException 异常（可根据项目需求捕获，无需修改此方法）
     */
    public String doPostJson(String url, String jsonParam) throws IOException {
        // 配置请求体为JSON格式
        RequestBody requestBody = RequestBody.create(
                MediaType.parse("application/json; charset=utf-8"),
                jsonParam
        );
        Request request = new Request.Builder().url(url).post(requestBody).build();
        // 自动复用连接池中的连接，无需新建
        try (Response response = OK_HTTP_CLIENT.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            }
            return null;
        }
    }

    /**
     * 重试拦截器（内部类，无需修改，自动处理连接失败重试）
     * 最多重试3次，避免因网络波动导致接口调用失败
     */
    static class RetryInterceptor implements Interceptor {
        private final int maxRetry; // 最大重试次数
        private int retryCount = 0; // 当前重试次数

        // 构造方法：初始化最大重试次数（外部已配置为3次）
        public RetryInterceptor(int maxRetry) {
            this.maxRetry = maxRetry;
        }

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Response response = chain.proceed(request);
            // 接口调用失败且未达到最大重试次数，自动重试
            while (!response.isSuccessful() && retryCount < maxRetry) {
                retryCount++;
                response.close(); // 关闭失败的连接
                response = chain.proceed(request); // 重新调用接口
            }
            return response;
        }
    }
}

package com.charger.platform.pay; // 替换为自己项目的包名（如com.xxx.charger.pay）

import com.charger.platform.http.ThirdPartyHttpPoolUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 支付宝支付接口调用示例（复用HTTP连接池，直接复制可用）
 * 说明：只需注入ThirdPartyHttpPoolUtil，调用doPostJson方法即可，无需新建HTTP连接
 */
@Service
public class AliPayService {
    // 注入全局HTTP连接池工具类（已配置好，直接使用）
    @Autowired
    private ThirdPartyHttpPoolUtil thirdPartyHttpPoolUtil;

    // 日志（可选，用于排查调用失败问题）
    private static final Logger log = LoggerFactory.getLogger(AliPayService.class);

    /**
     * 调用支付宝支付接口（重卡充电桩充电订单支付）
     * @param orderId 充电订单ID（自定义，如"charger-order-123456"）
     * @param amount 支付金额（如100.00元）
     * @return 支付宝返回的结果（如"success"或支付表单）；失败返回"fail"
     */
    public String aliPay(String orderId, BigDecimal amount) {
        // 支付宝支付接口地址（替换为你自己的支付宝接口地址）
        String url = "https://openapi.alipay.com/gateway.do";
        // 构造JSON请求参数（根据支付宝接口要求调整，此处为示例）
        String jsonParam = "{\"out_trade_no\":\"" + orderId + "\",\"total_amount\":\"" + amount + "\",\"subject\":\"重卡充电订单支付\"}";

        try {
            // 复用HTTP连接池中的连接，调用POST接口（无需新建连接）
            return thirdPartyHttpPoolUtil.doPostJson(url, jsonParam);
        } catch (IOException e) {
            // 捕获异常，打印日志（便于排查问题）
            log.error("支付宝支付调用失败，订单号：{}，异常信息：{}", orderId, e.getMessage());
            return "fail";
        }
    }
}