当前位置: 代码网 > it编程>编程语言>Java > SpringBoot JDBC连接MySQL总是连不上?这5个坑你踩过几个

SpringBoot JDBC连接MySQL总是连不上?这5个坑你踩过几个

2026年11月17日 • Java •我要评论
1. 从一次「连不上库」的排查说起:spring boot + jdbc 这套东西到底解决什么上个月帮人看一个后台管理项目,spring boot 启动日志干干净净,一到查询就抛 communica

1. 从一次「连不上库」的排查说起:spring boot + jdbc 这套东西到底解决什么

上个月帮人看一个后台管理项目,spring boot 启动日志干干净净,一到查询就抛 communications link failure ,前后改了四版 url 才通。

这类问题不是 spring boot 的锅,多半卡在 jdbc 这一层的驱动、时区、连接池参数没对齐。

这份 java springboot 使用 jdbc 连接 mysql 的整套方案,就是把这些最容易出岔子的地方一次性摆平:从 mysql 安装包、建库建表脚本,到 starter-jdbc 依赖、hikaricp 连接池,再到 jdbctemplate 的增删改查、批量写入和事务边界,配置和代码都能直接替换成自己的业务表跑起来。

它适合刚接手 crud 后台、又不想一上来就背 mybatis 或 jpa 那套映射规则的开发者;也适合想弄明白 orm 框架底下数据库这一层到底在干什么的人,把这份源码当成一层薄封装来读,收获比翻文档大。

2. 工程骨架与依赖:spring-boot-starter-jdbc 到底替我们做了什么

2.1 目录结构:四层分包,sql 不要撒得到处都是

拿到源码先别急着运行,把包结构看一遍,后面改代码的时候才知道该往哪儿下手。

这套工程的划分是典型的三层加一个配置层,没有为了炫技搞 ddd 那套聚合根,读起来负担小:

src/main/java/com/example/jdbcdemo
├── jdbcdemoapplication.java     # 启动类,@springbootapplication
├── config
│   └── datasourceconfig.java    # 数据源自定义(需要加密密码/多数据源时才用)
├── controller
│   └── ordercontroller.java     # 只做参数校验和结果包装,不写 sql
├── service
│   ├── orderservice.java        # 业务编排 + 事务边界
│   └── impl/orderserviceimpl.java
├── dao
│   └── orderdao.java            # 所有 jdbctemplate 调用集中在这
├── entity
│   └── order.java               # 和表字段一一对应
└── common
    ├── pageresult.java          # 分页返回结构
    └── apiresponse.java         # 统一响应体

分层的关键不在名字好不好听,而在 边界清晰 。controller 不碰 jdbctemplate ,dao 不写业务判断,service 不拼 sql 字符串。我见过不少新手项目把 jdbctemplate.query() 直接写在 controller 里,一开始省事,等要加事务、要复用查询、要写单元测试的时候,就得整段整段地搬代码。

这里 dao 层只有注入的 jdbctemplate 一个依赖,意味着它天然可测——用 @jdbctest 配一个内存数据库或者测试库就能单跑。

config 目录里的 datasourceconfig 默认是注释掉的。这点很关键: spring-boot-starter-jdbc 自带自动装配,只要 application.yml 里写了 spring.datasource.* ,spring boot 就会自己造一个 hikaridatasource 注入容器。只有当你需要密码加解密、要多数据源、或者要挂自定义的 datasourceinitializer 时,才需要打开这个类手动 @bean 。很多人一上来就抄个 datasourceconfig 覆盖掉自动装配,结果 hikaricp 的默认参数全丢了,连接数不够用还找不到原因。

common 包里两个类看着不起眼,实际是二次开发时改动最少、收益最高的部分。 apiresponse 固定了 code / message / data 三段式,前端对接不用一版一议; pageresult 收口了 total / pageno / pagesize / list ,省得每个接口自己拼分页结构。

2.2 pom.xml:驱动坐标在 spring boot 2 和 3 里不是同一个

依赖这块最容易翻车的地方是版本。

spring-boot-starter-jdbc 本身不带数据库驱动,得自己引。而 mysql 驱动的坐标在 spring boot 2.x 和 3.x 之间换过一次:

<!-- 连接池 + jdbctemplate + 事务管理,全在这一包里 -->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-jdbc</artifactid>
</dependency>
<!-- spring boot 3.x / 8.0+ 驱动用这个坐标 -->
<dependency>
    <groupid>com.mysql</groupid>
    <artifactid>mysql-connector-j</artifactid>
    <scope>runtime</scope>
</dependency>
<!-- spring boot 2.x 用这个老坐标,别混用 -->
<!--
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
    <scope>runtime</scope>
</dependency>
-->

scope 写 runtime 是有讲究的:业务代码里压根不该出现 java.sql.drivermanager 或者 com.mysql.cj.jdbc.driver 的硬引用,驱动是靠 spi 机制在运行时被 drivermanager 自动加载的。写成 runtime 能顺带帮你检查代码里有没有偷偷 new 驱动对象。

spring-boot-starter-jdbc 会传递进来 spring-jdbc 、 hikaricp 、 spring-tx 三个核心件,所以连接池和事务管理器都不需要单独声明版本,交给 spring boot 的 bom 统一管理就行——自己写版本号反而容易和父工程打架。

提示:如果 mvn dependency:tree 里同时看到 mysql-connector-java 和 mysql-connector-j ,说明有别的 starter 传递了老坐标,用 <exclusion> 排掉,否则类路径上会出现两份驱动。

2.3 安装包与建库脚本:先把库和表跑起来

随包的 mysql 安装程序装完之后,第一件事是建库建表,别急着启动 java 工程。

脚本里字符集统一用 utf8mb4 ,别用 utf8 ——后者在 mysql 里其实是三个字节的残缺实现,存 emoji 会直接报错,这个坑十年了还在坑人。

create database if not exists demo_db
  default character set utf8mb4
  collate utf8mb4_general_ci;
use demo_db;
create table t_order (
  id          bigint unsigned not null auto_increment comment '主键',
  order_no    varchar(32)     not null                comment '业务订单号',
  user_id     bigint          not null                comment '下单用户',
  amount      decimal(10,2)   not null default 0.00   comment '金额,别用 double',
  status      tinyint         not null default 0      comment '0待付 1已付 2取消',
  remark      varchar(255)    default null,
  create_time datetime        not null default current_timestamp,
  update_time datetime        not null default current_timestamp on update current_timestamp,
  primary key (id),
  unique key uk_order_no (order_no),
  key idx_user_id (user_id)
) engine=innodb default charset=utf8mb4;

几个字段类型的选择值得说一句。金额用 decimal(10,2) 而不是 double ,浮点累加会出现 0.1 + 0.2 = 0.30000000000000004 这种事,财务口径上不能接受,java 侧对应 bigdecimal 。

status 用 tinyint ,一个字节够用,别上 varchar 存 "paid" 这种字符串,索引体积和比较开销都亏。

create_time 给默认值 current_timestamp ,插入时不传也能落库,减少一处出错可能。

还要建一个业务账号,别拿 root 跑应用:

create user 'demo'@'%' identified by 'demo123';
grant select, insert, update, delete on demo_db.* to 'demo'@'%';
flush privileges;

权限只给 dml,不给 drop 和 grant 。这不是形式主义,我带过的项目里真有人把生产库账号配成 root 写进配置文件,一次误操作删表,血泪经验。

3. 数据源配置:application.yml 里每一行都在动哪个开关

3.1 最小可用配置与参数逐行说明

spring boot 的自动装配让这件事变得很短,但每一行都有明确的语义,缺一个就可能连不上:

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.driver
    url: jdbc:mysql://127.0.0.1:3306/demo_db?useunicode=true&characterencoding=utf8&servertimezone=gmt%2b8&usessl=false&allowpublickeyretrieval=true&rewritebatchedstatements=true
    username: demo
    password: ${db_password:demo123}
    hikari:
      pool-name: demo-pool
      maximum-pool-size: 10
      minimum-idle: 2
      connection-timeout: 3000
      idle-timeout: 600000
      max-lifetime: 1200000
      connection-test-query: select 1

url 后面那串参数逐个拆开看:

参数作用不写会怎样
useunicode + characterencoding指定客户端字符集中文写入变问号,或读出来乱码
servertimezone=gmt%2b8告诉驱动服务端时区驱动 8.x 报 the server time zone value is unrecognized
usessl=false关闭 ssl 握手本地无证书环境握手失败,日志刷一屏警告
allowpublickeyretrieval=true允许取服务端公钥mysql 8 默认 caching_sha2_password 认证直接失败
rewritebatchedstatements=true把批量 insert 改写成多值语法批量插入逐条发,一万条能跑几分钟

servertimezone 这里用 gmt%2b8 而不是时区名字,是为了绕开某些环境下时区数据库不全的问题, %2b 是 + 的 url 编码,写错了会被当成空格。

connection-timeout: 3000 意思是拿不到连接最多等 3 秒,默认 30 秒太长了,接口超时都触发了连接还没失败,排查时看不到真实原因。

3.2 hikaricp 连接池:几个必须改的数字

spring boot 默认就用 hikaricp, spring.datasource.hikari.* 下的配置会直接映射到 hikariconfig 。默认值不是不能用,但几个关键参数得按实际场景调:

maximum-pool-size 默认 10。这个数不是越大越好,数据库那边每个连接都是一个线程加一块内存,几百个连接打过去,mysql 自己先趴下。经验公式是 (cpu 核数 * 2) + 有效磁盘数 ,再按实际压测微调,单实例 10 到 20 是常见区间。 minimum-idle 保持小一点,2 到 5 之间,让空闲连接能被回收,云上按连接数计费的实例尤其要注意。

max-lifetime 必须小于数据库的 wait_timeout (mysql 默认 28800 秒,也就是 8 小时)。连接池里躺着一个被服务端单方面掐断的连接,取出来用就是 communications link failure 。设成 1200000 毫秒(20 分钟)留足余量。 idle-timeout 只对超过 minimum-idle 的空闲连接生效,600000 毫秒即 10 分钟。 connection-test-query: select 1 是每次借出前的探活,mysql 支持 jdbc4 isvalid() ,其实可以不配,配了也不亏。

注意: max-lifetime 设成 0 表示永不过期,看着省事,实际是把连接被服务端杀掉的定时炸弹留在了池子里,不要这么干。

3.3 密码外置与多环境切换

配置文件里写明文密码是最常见的翻车点,源码里给的是占位符写法: ${db_password:demo123} ,冒号后面是默认值。本地开发不设环境变量就用默认密码,上了测试或生产,启动脚本里注入 db_password 即可,代码不用改一行。

多环境按 spring boot 的惯例拆文件: application-dev.yml 、 application-test.yml 、 application-prod.yml ,主配置里用 spring.profiles.active: dev 决定激活哪个。生产环境的文件不要进代码仓库,走配置中心或者部署时的外 挂目录( --spring.config.additional-location=/etc/app/ )。我在项目里还会加一条:生产的 hikari.maximum-pool-size 单独调大, connection-timeout 调小,因为生产环境连接拿不到就该快速失败让上游重试,而不是干等。

如果要给密码做加密,就在 config/datasourceconfig.java 里手动建 hikaridatasource ,把解密后的密码 set 进去。这时记得把 application.yml 里的 spring.datasource 整段删掉或者标注清楚,否则自动装配和手动 bean 打架,谁生效取决于加载顺序,这种玄学问题排查起来能耗掉一整天。

4. 核心链路拆解:一个查询请求从 controller 走到 resultset

4.1 实体与 rowmapper:把 resultset 变成对象

实体类不做多余的事,字段名用驼峰,和表的下划线字段靠 rowmapper 桥接:

public class order {
    private long id;
    private string orderno;      // 对应 order_no
    private long userid;         // 对应 user_id
    private bigdecimal amount;
    private integer status;
    private string remark;
    private localdatetime createtime;
    private localdatetime updatetime;
    // getter / setter 省略
}

映射有两种写法。图省事可以用 beanpropertyrowmapper.newinstance(order.class) ,它会把 order_no 自动转成 orderno ;但要求字段类型严格对得上, datetime 到 localdatetime 在部分驱动版本上会抛转换异常。

源码里用的是手写 rowmapper ,啰嗦但可控:

private static final rowmapper<order> order_mapper = (rs, rownum) -> {
    order o = new order();
    o.setid(rs.getlong("id"));
    o.setorderno(rs.getstring("order_no"));
    o.setuserid(rs.getlong("user_id"));
    o.setamount(rs.getbigdecimal("amount"));   // 金额必须走 bigdecimal
    o.setstatus(rs.getint("status"));

    // datetime 列允许 null,直接 tolocaldatetime() 会 npe
    timestamp ct = rs.gettimestamp("create_time");
    o.setcreatetime(ct == null ? null : ct.tolocaldatetime());
    timestamp ut = rs.gettimestamp("update_time");
    o.setupdatetime(ut == null ? null : ut.tolocaldatetime());

    o.setremark(rs.getstring("remark"));
    return o;
};

这里有两个参数值得说明: rs 是当前游标指向的那一行结果集, rownum 是行号(从 0 开始),一般在映射逻辑里用不上,但做「序号列」或者分批处理时能派上用场。整个 lambda 会被 jdbctemplate 在每一行上调用一次,所以里面不要做 io、不要查别的表,保持纯函数。

4.2 dao 层:jdbctemplate 的增删改查四板斧

dao 层是这套方案的核心,所有 sql 都收在这一个类里。构造器注入 jdbctemplate ,不要用字段注入:

@repository
public class orderdao {

    private final jdbctemplate jdbctemplate;

    public orderdao(jdbctemplate jdbctemplate) {
        this.jdbctemplate = jdbctemplate;
    }

    // 增:返回自增主键
    public long insert(order order) {
        string sql = "insert into t_order(order_no, user_id, amount, status, remark) values(?,?,?,?,?)";
        keyholder keyholder = new generatedkeyholder();
        jdbctemplate.update(conn -> {
            preparedstatement ps = conn.preparestatement(sql, statement.return_generated_keys);
            ps.setstring(1, order.getorderno());
            ps.setlong(2, order.getuserid());
            ps.setbigdecimal(3, order.getamount());
            ps.setint(4, order.getstatus());
            ps.setstring(5, order.getremark());
            return ps;
        }, keyholder);
        number key = keyholder.getkey();
        return key == null ? null : key.longvalue();
    }

    // 查单个:不要用 queryforobject,空结果会抛异常
    public optional<order> findbyorderno(string orderno) {
        string sql = "select * from t_order where order_no = ?";
        list<order> list = jdbctemplate.query(sql, order_mapper, orderno);
        return list.stream().findfirst();
    }

    // 改:返回受影响行数,调用方自己判断是否 0
    public int updatestatus(long id, integer status) {
        string sql = "update t_order set status = ? where id = ?";
        return jdbctemplate.update(sql, status, id);
    }

    // 删
    public int deletebyid(long id) {
        return jdbctemplate.update("delete from t_order where id = ?", id);
    }
}

jdbctemplate.update() 的参数是可变长 object... ,底层会用 preparedstatement.setobject() 按顺序绑定,所以参数顺序必须和 sql 里的占位符严格一致——这是最常见的低级错误,尤其 sql 一长就容易错位。永远用 ? 占位符,不要字符串拼接,sql 注入不是理论风险。

queryforobject 在结果为空时抛 emptyresultdataaccessexception ,很多人拿它查「可能不存在」的记录,然后靠 catch 异常做分支,日志里全是堆栈。用 query() 拿 list 再 findfirst() 转 optional 更干净。

返回自增主键要传 statement.return_generated_keys ,配合 generatedkeyholder 。注意 mysql 批量插入时 getkey() 只会返回第一条,别指望它给每行都返回主键。

4.3 service 与事务:@transactional 生效的三个前提

事务写在 service 层,因为一次业务操作可能涉及多次 dao 调用:

@service
public class orderserviceimpl implements orderservice {

    private final orderdao orderdao;

    public orderserviceimpl(orderdao orderdao) {
        this.orderdao = orderdao;
    }

    @override
    @transactional(rollbackfor = exception.class)
    public void createandpay(order order) {
        long id = orderdao.insert(order);
        int rows = orderdao.updatestatus(id, 1);
        if (rows != 1) {
            throw new illegalstateexception("状态更新失败,id=" + id); // 触发回滚
        }
        // 这里如果调用 this.othermethod(),那个方法上的 @transactional 不生效
    }
}

三个前提缺一不可:第一,类得是 spring 管理的 bean, @service 或 @component 都行,自己 new 出来的对象没有代理;第二,方法必须是 public ,spring 的 aop 代理拦不到私有方法;第三,异常必须是 runtimeexception 或其子类,受检异常默认不回滚,所以统一写 rollbackfor = exception.class 更稳。

至于「同类内部调用导致事务失效」,这是新手最常问的一个问题: this.othermethod() 走的是原始对象,压根不经过代理。解决办法要么把方法挪到另一个 bean 里,要么注入自身代理( @lazy 注入自己),要么用 transactiontemplate 手动控制。我一般选第一种,最不容易出问题。

事务管理器不用自己配, spring-boot-starter-jdbc 检测到唯一的 datasource 就会自动注册 datasourcetransactionmanager 。只有一个数据源的时候别去手写 @enabletransactionmanagement ,配错了反而把自动装配顶掉。

4.4 分页与批量:别用 for 循环一条条 insert

分页在 jdbc 层就是 limit 加 offset ,但要记得额外查一次总数:

public list<order> page(int pageno, int pagesize) {
    int offset = (pageno - 1) * pagesize;   // 页码从 1 开始
    string sql = "select * from t_order order by id desc limit ? offset ?";
    return jdbctemplate.query(sql, order_mapper, pagesize, offset);
}

public long countall() {
    long total = jdbctemplate.queryforobject("select count(*) from t_order", long.class);
    return total == null ? 0l : total;
}

深分页( offset 到了几十万)会越翻越慢,因为 mysql 要把前面那些行全扫一遍再丢掉。改造成「游标分页」: where id < 上一页最后一个 id order by id desc limit ? ,配合主键索引,翻到第几页都是毫秒级。这个改法在后台列表里非常实用。

批量插入更值得展开。一万条数据,for 循环调 insert() 是灾难,每次都要网络往返加事务提交:

public int[] batchinsert(list<order> list) {
    string sql = "insert into t_order(order_no, user_id, amount, status) values(?,?,?,?)";
    return jdbctemplate.batchupdate(sql, new batchpreparedstatementsetter() {
        @override
        public void setvalues(preparedstatement ps, int i) throws sqlexception {
            order o = list.get(i);
            ps.setstring(1, o.getorderno());
            ps.setlong(2, o.getuserid());
            ps.setbigdecimal(3, o.getamount());
            ps.setint(4, o.getstatus());
        }

        @override
        public int getbatchsize() {
            return list.size();
        }
    });
}

batchupdate 会把 addbatch() 攒起来一次性发,配合 url 里的 rewritebatchedstatements=true ,驱动会把 n 条 insert 改写成 insert into ... values (...),(...),(...) 一条语句,实测一万条从几十秒降到一秒级。 getbatchsize() 返回批次大小, setvalues 的 i 就是当前下标,两个方法必须对上,否则会漏数据或者 indexoutofbounds 。

分批的粒度也要注意,别把十万条塞进一个批次,mysql 的 max_allowed_packet 会拦你。按 500 到 1000 条切一刀,外面再包一层 @transactional ,出错整批回滚。

5. 避坑与排查:连 mysql 时最容易翻车的五个点

5.1 连接层:驱动、时区、认证

现象一 :启动就报 java.lang.classnotfoundexception: com.mysql.jdbc.driver 。 原因:驱动类名在 8.x 版本改成了 com.mysql.cj.jdbc.driver ,老名字虽然还保留了兼容壳,但有些环境里被裁掉了;另一种情况是依赖坐标引错,2.x 的 mysql-connector-java 和 3.x 的 mysql-connector-j 混着写。 解决:统一用 com.mysql.cj.jdbc.driver ,并且 driver-class-name 这行其实可以整个删掉——spi 会自动发现,写了反而多一个出错点。

现象二 : the server time zone value '…' is unrecognized or represents more than one time zone 。 原因:驱动 8.x 要求明确服务端时区,jvm 时区和服务端对不上时直接抛错。 解决:url 里加 servertimezone=gmt%2b8 。加完如果发现存取的时间差 8 小时,检查是不是用了 timestamp 字段—— timestamp 会随时区转换, datetime 不会,业务时间统一用 datetime 更省心。

现象三 : access denied for user 'demo'@'localhost' ,密码明明是对的。 原因:mysql 8 默认认证插件是 caching_sha2_password ,老版本驱动或者没开 allowpublickeyretrieval 时握手失败;另外 'demo'@'%' 和 'demo'@'localhost' 是两个不同的用户记录,本地连经常撞上后者。 解决:url 加 allowpublickeyretrieval=true&usessl=false ,并确认 mysql.user 表里确实有对应 host 的账号。

5.2 sql 与映射层:驼峰、空值、批量

现象四 :查出来对象里 orderno 、 userid 全是 null ,但 id 有值。 原因:手写 rowmapper 里写成了 rs.getstring("orderno") ,而列名是 order_no ;或者用了 beanpropertyrowmapper 但 sql 里 select 的列被别名改掉了。 解决: rowmapper 里的名字必须是数据库列名不是 java 属性名; select * 在多表 join 时会出现同名列覆盖,显式写别名更保险。

现象五 :批量插入一万条跑了两分多钟,数据库 cpu 还不高。 原因: rewritebatchedstatements=true 没加,驱动老老实实一条一条发;或者方法外面没有事务,每条 insert 都自动提交一次,磁盘刷得飞起。 解决:url 补参数,service 层包 @transactional ,批次大小控制在 500 到 1000。

顺带说一个排查习惯,连不上库的时候按这个顺序看,比乱改配置快得多:先 mysql -u demo -p -h 127.0.0.1 -p 3306 确认库本身能连;再看应用启动日志里 hikaricp 打印的 pool-name 和连接串;最后才去怀疑代码。黑匣子式的盲目试错,往往改好了也不知道为什么好。

6. 二次开发:把示例表换成你自己的业务表

拿到源码后最实际的改造路径,是照着 t_order 这条路走一遍换成自己的表,别一上来就重构分层。具体四步:第一步,写建表 sql,主键建议 bigint unsigned auto_increment ,业务唯一键单独加唯一索引;第二步,建实体类,字段用驼峰, decimal 对应 bigdecimal , datetime 对应 localdatetime ;第三步,复制 orderdao 改成 xxxdao ,把 order_mapper 里的字段逐行改掉,这是唯一需要手写的地方;第四步,service 里注入新 dao,事务注解照抄。

改造时最容易漏的是 rowmapper 的字段名,我习惯在 dao 类顶部把列名集中成常量,改的时候一眼能看到全部:

private static final string col_id      = "id";
private static final string col_order_no = "order_no";

private static final rowmapper<order> order_mapper = (rs, rownum) -> {
    order o = new order();
    o.setid(rs.getlong(col_id));
    o.setorderno(rs.getstring(col_order_no));
    // ...
    return o;
};

如果想再省事,可以直接把 order_mapper 换成 beanpropertyrowmapper.newinstance(xxx.class) ,前提是开启了下划线转驼峰( beanpropertyrowmapper 默认就支持),并且所有字段类型都能被驱动安全转换。我的做法是:新建表先用 beanpropertyrowmapper 快速跑通,等遇到类型转换问题再改成手写,两种可以共存。

还有一个验证技巧值得记住:改完 dao 先别启动整个应用,用 @jdbctest 加一个测试方法直接把 sql 跑一遍,比等 spring 上下文加载快十倍:

@jdbctest
class orderdaotest {

    @autowired
    private jdbctemplate jdbctemplate;

    @test
    void mapper_should_map_all_columns() {
        jdbctemplate.execute("create table t_order(id bigint primary key, order_no varchar(32))");
        jdbctemplate.update("insert into t_order values(1,'no001')");
        orderdao dao = new orderdao(jdbctemplate);
        // 断言映射结果,字段漏改会立刻暴露
        assertthat(dao.findbyid(1l)).ispresent();
    }
}

扩展方向上,这套薄封装的性价比在于「可控」。要做读写分离,加一个 abstractroutingdatasource 按注解切库;要做慢 sql 监控,包一层 jdbctemplate 覆盖 query() 记耗时;要接分页插件,自己算 offset 也就十几行。代价是所有 sql 都得手写,字段一多就容易漏,这时候再引入 mybatis 也不迟——但你会清楚地知道它到底替你做了什么,而不是只会配 xml。

那次排查完之后我落了个习惯:每接一个新库,先把 connection-timeout 调到 3 秒,把 max-lifetime 压到比 wait_timeout 小,然后写一个只做 select 1 的接口当健康检查,跑通了再写业务。这个动作花不到十分钟,能挡掉后面一大半「时好时坏」的玄学问题。希望帮到你。

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持代码网。

赞 (0)

相关文章:

版权声明:本文内容由互联网用户贡献,该文观点仅代表作者本人。本站仅提供信息存储服务,不拥有所有权,不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 2386932994@qq.com 举报,一经查实将立刻删除。

发表评论

验证码:
Copyright © 2017-2026  代码网 保留所有权利. 粤ICP备2024248653号
站长QQ:2386932994 | 联系邮箱:2386932994@qq.com