我要评论前言
select count(*) as visit_count from weblog where start_time >='2026-01-01 00:00:00' and start_time < '2026-01-02 00:00:00' group by url 这个sql代码中传参数start_time如果是字符串就会差8小时，如果start_time传值date类型，则不会差8小时。以前都是传值date，今天突然发现这个问题，登录到mysql数据库查看数据，发现表中数据也差8小时。为什么呢？
一、分别查看操作系统、mysql、jvm 时区
1. 查看操作系统时区
不同操作系统的查询命令不同，核心是获取系统的默认时区：
windows 系统，命令行：打开 cmd/powershell，执行以下命令，显示使用东八区时间（如中国标准时间 cst）
2. 查看 mysql 5.7 时区
mysql 的时区分为「全局时区」和「会话时区」，两种都需要验证，可通过 mysql 客户端（navicat、sqlyog、mysql 命令行）执行 sql 查询：
-- 方法1：同时查看全局时区（global_time_zone）和会话时区（session_time_zone） show variables like '%time_zone%';
- mysql 5.7 默认时区通常为
system（表示跟随操作系统时区）；系统默认时区是utc+8 北京 - 若查询结果中
time_zone为utc，则表示 mysql 直接使用 utc 时区，不跟随系统。
3. 查看 jvm 时区
jvm 时区是 java 程序运行时的默认时区，有 3 种常用查询方式，适配 jboot 框架场景：
import java.util.timezone;
public class timezonetest {
public static void main(string[] args) {
// 方法1：获取jvm默认时区（显示时区id，如 asia/shanghai）
timezone defaulttimezone = timezone.getdefault();
system.out.println("jvm 默认时区 id：" + defaulttimezone.getid());
system.out.println("jvm 默认时区名称：" + defaulttimezone.getdisplayname());
// 方法2：java 8+ 新增方式，更简洁
java.time.zoneid zoneid = java.time.zoneid.systemdefault();
system.out.println("jvm 默认时区（java 8+）：" + zoneid);
}
}java打印结果模式使用的东八区时间（如中国标准时间 cst）utc+8 北京
jvm 默认时区 id：asia/shanghai
jvm 默认时区名称：中国标准时间
jvm 默认时区（java 8+）：asia/shanghai
二、关键注意点：你的 mysql 连接 url 配置分析
系统配置的 url：jdbc:mysql://127.0.0.1:3306/dbname?useunicode=true&characterencoding=utf-8&usessl=false&servertimezone=utc
其中 servertimezone=utc 是jdbc 驱动与 mysql 服务器通信时使用的时区，核心注意点：该配置仅作用于「java 程序（jboot）←→mysql 服务器」的连接层，不会改变 mysql 的全局 / 会话时区，也不会改变 jvm 和操作系统的时区；
时区转换的执行载体是「mysql jdbc 驱动 jar 包」（不是 java 客户端业务代码，也不是 mysql 服务器端），servertimezone=utc 这个配置的作用域仅在jdbc 驱动（mysql-connector-java） 内部，所有与时区相关的时间转换、适配，都是在驱动 jar 中完成的，与 java 业务代码、mysql 服务器本身无直接关联。
三、代码验证时区问题
场景 1：统计某天访问量，如果开始时间和结束时间用字符串转值，开始时间"2026-01-01"，结束时间"2026-01-02"
public integer count(string start_time, string end_time) {
stringbuilder sql = new stringbuilder();
sql.append("select count(*) as visit_count from weblog where start_time >= ? and start_time <?");
list<object> paras = new arraylist<object>();
paras.add(0, end_time);
paras.add(0, start_time);
weblog weblog =(weblog)weblogdao.getdao().findfirst(sql.tostring(), paras.toarray());
return weblog.getint("visit_count");
}这种场景下，没有经过 jdbc 驱动的时区转换，偏差的产生流程如下：
- java 客户端直接将字符串格式的时间值，原封不动地通过 jdbc 连接发送给 mysql 服务器（驱动仅做数据透传，不进行任何时间解析和时区转换）；
- mysql 服务器接收到字符串后，会按照「自身的全局 / 会话时区」（东八区）来解析这个字符串，将其转换为 mysql 内部存储的时间格式（timestamp/datetime）；
- 简单说：字符串参数是「裸传」，驱动不处理，直接落地到 mysql 服务器按其自身时区解析，与
servertimezone=utc配置无关，进而出现偏差。
场景 2：统计某天访问量，如果开始时间和结束时间用date转值，开始时间date(2026-01-01)，结束时间date(2026-01-02)
public integer count(date start_time, date end_time) {
stringbuilder sql = new stringbuilder();
sql.append("select count(*) as visit_count from weblog where start_time >= ? and start_time <?");
list<object> paras = new arraylist<object>();
paras.add(0, end_time);
paras.add(0, start_time);
weblog weblog =(weblog)weblogdao.getdao().findfirst(sql.tostring(), paras.toarray());
return weblog.getint("visit_count");
}这种场景下，jdbc 驱动会主动进行时区转换，保证时间一致性，流程如下：
- java 客户端将
date类型的时间对象传递给 jdbc 驱动（日期类型本身是「时间戳（long 型，从 1970-01-01 00:00:00 utc 开始的毫秒数）」，与时区无关，是绝对时间）； - jdbc 驱动接收到这个时间戳后，会读取 url 中的
servertimezone=utc配置，将时间戳从 jvm 默认时区（东八区）转换为 utc 时区； - 驱动将转换后的 utc 时间，封装为 mysql 服务器可识别的时间格式，发送给 mysql 服务器；
- 简单说：日期类型参数会被驱动拦截，驱动基于
servertimezone=utc完成「jvm 时区 ↔ 通信时区（utc）」的转换，再与 mysql 服务器交互。增加操作和查询操作都试用日期格式，驱动都会转换时间，所以用户没有在页面发现时间差问题。
四、时区转换代码分析
com.jfinal.plugin.activerecord.model
/**
* find first model. i recommend add "limit 1" in your sql.
* @param sql an sql statement that may contain one or more '?' in parameter placeholders
* @param paras the parameters of sql
* @return model
*/
public m findfirst(string sql, object... paras) {
list<m> result = find(sql, paras);
return result.size() > 0 ? result.get(0) : null;
}
/**
* find model.
* @param sql an sql statement that may contain one or more '?' in parameter placeholders
* @param paras the parameters of sql
* @return the list of model
*/
public list<m> find(string sql, object... paras) {
return find(_getconfig(), sql, paras);
}
protected list<m> find(config config, string sql, object... paras) {
connection conn = null;
try {
conn = config.getconnection();
return find(config, conn, sql, paras);
} catch (exception e) {
throw new activerecordexception(e);
} finally {
config.close(conn);
}
}
/**
* find model.
*
* 警告：传入的 connection 参数需要由传入者在 try finally 块中自行
* 关闭掉，否则将出现 connection 资源不能及时回收的问题
*/
protected list<m> find(config config, connection conn, string sql, object... paras) throws exception {
try (preparedstatement pst = conn.preparestatement(sql)) {
config.dialect.fillstatement(pst, paras);
resultset rs = pst.executequery();
list<m> result = config.dialect.buildmodellist(rs, _getusefulclass()); // modelbuilder.build(rs, getusefulclass());
dbkit.close(rs);
return result;
}
}
com.jfinal.plugin.activerecord.dialect.fillstatement
public void fillstatement(preparedstatement pst, object... paras) throws sqlexception {
for (int i=0; i<paras.length; i++) {
pst.setobject(i + 1, paras[i]);
}
}com.alibaba.druid.pool.druidpooledpreparedstatement
@override
public void setobject(int parameterindex, object x) throws sqlexception {
checkopen();
try {
stmt.setobject(parameterindex, x);
} catch (throwable t) {
throw checkexception(t);
}
}
com.alibaba.druid.proxy.jdbc.preparedstatementproxyimpl
@override
public void setobject(int parameterindex, object x) throws sqlexception {
setobjectparameter(parameterindex, x);
createchain().preparedstatement_setobject(this, parameterindex, x);
}filterchainimpl
@override
public void preparedstatement_setobject(preparedstatementproxy statement, int parameterindex, object x)
throws sqlexception {
if (this.pos < filtersize) {
nextfilter().preparedstatement_setobject(this, statement, parameterindex, x);
return;
}
statement.getrawobject().setobject(parameterindex, x);
}com.mysql.cj.jdbc.clientpreparedstatement
@override
public void setobject(int parameterindex, object parameterobj) throws sqlexception {
synchronized (checkclosed().getconnectionmutex()) {
((preparedquery<?>) this.query).getquerybindings().setobject(getcoreparameterindex(parameterindex), parameterobj);
}
}com.mysql.cj.abstractquerybindings
@override
public void setobject(int parameterindex, object parameterobj) {
if (parameterobj == null) {
setnull(parameterindex);
} else {
if (parameterobj instanceof byte) {
setint(parameterindex, ((byte) parameterobj).intvalue());
} else if (parameterobj instanceof string) {
setstring(parameterindex, (string) parameterobj);
} else if (parameterobj instanceof bigdecimal) {
setbigdecimal(parameterindex, (bigdecimal) parameterobj);
} else if (parameterobj instanceof short) {
setshort(parameterindex, ((short) parameterobj).shortvalue());
} else if (parameterobj instanceof integer) {
setint(parameterindex, ((integer) parameterobj).intvalue());
} else if (parameterobj instanceof long) {
setlong(parameterindex, ((long) parameterobj).longvalue());
} else if (parameterobj instanceof float) {
setfloat(parameterindex, ((float) parameterobj).floatvalue());
} else if (parameterobj instanceof double) {
setdouble(parameterindex, ((double) parameterobj).doublevalue());
} else if (parameterobj instanceof byte[]) {
setbytes(parameterindex, (byte[]) parameterobj);
} else if (parameterobj instanceof java.sql.date) {
setdate(parameterindex, (java.sql.date) parameterobj);
} else if (parameterobj instanceof time) {
settime(parameterindex, (time) parameterobj);
} else if (parameterobj instanceof timestamp) {
settimestamp(parameterindex, (timestamp) parameterobj);
} else if (parameterobj instanceof boolean) {
setboolean(parameterindex, ((boolean) parameterobj).booleanvalue());
} else if (parameterobj instanceof inputstream) {
setbinarystream(parameterindex, (inputstream) parameterobj, -1);
} else if (parameterobj instanceof java.sql.blob) {
setblob(parameterindex, (java.sql.blob) parameterobj);
} else if (parameterobj instanceof java.sql.clob) {
setclob(parameterindex, (java.sql.clob) parameterobj);
} else if (this.treatutildateastimestamp.getvalue() && parameterobj instanceof java.util.date) {
settimestamp(parameterindex, new timestamp(((java.util.date) parameterobj).gettime()));
} else if (parameterobj instanceof biginteger) {
setstring(parameterindex, parameterobj.tostring());
} else if (parameterobj instanceof localdate) {
setdate(parameterindex, date.valueof((localdate) parameterobj));
} else if (parameterobj instanceof localdatetime) {
settimestamp(parameterindex, timestamp.valueof((localdatetime) parameterobj));
} else if (parameterobj instanceof localtime) {
settime(parameterindex, time.valueof((localtime) parameterobj));
} else {
setserializableobject(parameterindex, parameterobj);
}
}
}
com.mysql.cj.clientpreparedquerybindings
@override
public void settimestamp(int parameterindex, timestamp x) {
int fractlen = -1;
if (!this.sendfractionalseconds.getvalue() || !this.session.getserversession().getcapabilities().serversupportsfracsecs()) {
fractlen = 0;
} else if (this.columndefinition != null && parameterindex <= this.columndefinition.getfields().length && parameterindex >= 0) {
fractlen = this.columndefinition.getfields()[parameterindex].getdecimals();
}
settimestamp(parameterindex, x, null, fractlen);
}com.mysql.cj.clientpreparedquerybindings
@override
public void settimestamp(int parameterindex, timestamp x, calendar targetcalendar, int fractionallength) {
if (x == null) {
setnull(parameterindex);
} else {
x = (timestamp) x.clone();
if (!this.session.getserversession().getcapabilities().serversupportsfracsecs()
|| !this.sendfractionalseconds.getvalue() && fractionallength == 0) {
x = timeutil.truncatefractionalseconds(x);
}
if (fractionallength < 0) {
// default to 6 fractional positions
fractionallength = 6;
}
x = timeutil.adjusttimestampnanosprecision(x, fractionallength, !this.session.getserversession().isservertruncatesfracsecs());
this.tsdf = timeutil.getsimpledateformat(this.tsdf, "''yyyy-mm-dd hh:mm:ss", targetcalendar,
targetcalendar != null ? null : this.session.getserversession().getdefaulttimezone());
stringbuffer buf = new stringbuffer();
buf.append(this.tsdf.format(x));
if (this.session.getserversession().getcapabilities().serversupportsfracsecs()) {
buf.append('.');
buf.append(timeutil.formatnanos(x.getnanos(), 6));
}
buf.append('\'');
setvalue(parameterindex, buf.tostring(), mysqltype.timestamp);
}
}this.session.getserversession().getdefaulttimezone()—— 这个时区就是你 jdbc url 中servertimezone=utc配置的时区！
驱动会基于servertimezone配置的时区，对timestamp进行格式化，完成了「jvm 默认时区 → servertimezone 配置时区」的转换，这就是为什么传入date/timestamp类型参数不会有 8 小时偏差的底层原因。
关键区别：这里的字符串是驱动经过时区转换后生成的，和你手动传入的原始字符串（如 "2025-12-29 16:00:00"）有本质不同 —— 前者带时区适配，后者是裸传无处理。
五、总结
本文围绕操作系统、mysql 5.7、jvm 时区查看方法及java程序时区偏差问题展开，核心结论如下。三者时区查看各有路径：操作系统需按windows等系统类型执行对应命令，核心获取默认时区（如东八区cst）；mysql需区分全局与会话时区，通过sql查询验证，默认多跟随系统时区（东八区），也可能直接使用utc；jvm可通过代码获取默认时区（如asia/shanghai），适配java 8+新方式。
jdbc连接url中servertimezone=utc仅作用于驱动层，负责程序与mysql通信时的时区转换，不改变各端本身时区，转换逻辑由mysql jdbc驱动包实现，与业务代码、mysql服务器无直接关联。
代码场景中，时间参数类型决定是否出现时区偏差：字符串类型为裸传，驱动不处理，mysql按自身时区解析，与驱动配置脱节，易产生8小时偏移；date/timestamp类型为时间戳（绝对时间），驱动基于servertimezone=utc完成jvm时区到utc的转换，mysql再反向解析，抵消时差无偏差。
底层原理上，驱动通过abstractquerybindings类判断参数类型，对date/timestamp调用settimestamp方法，基于servertimezone配置格式化时间，实现时区适配，这是两种参数类型处理差异的核心原因。综上，避免时区偏差需优先使用date/timestamp类型参数，确保驱动层时区转换生效。
到此这篇关于java+mysql时区date自动转换string差8小时难题解决的文章就介绍到这了,更多相关date自动转换string差8小时内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论