1. 百万级数据查询为什么会把 JVM 撑爆：MySQL 与 Oracle 的 JDBC 行为差异

先说结论：同样一句SELECT * FROM big_table，在 MySQL 和 Oracle 上走 JDBC，默认行为完全不是一回事。MySQL 默认会把整个结果集一次性拉到客户端内存里，Oracle 默认走的是服务端游标分批拉取。这个差异在几万行数据时看不出来，一旦上到百万级，MySQL 那边大概率直接java.lang.OutOfMemoryError: Java heap space，而 Oracle 那边可能只是慢，但不会立刻炸。

我试过在一张 500 万行的 MySQL 表上跑最朴素的executeQuery()，堆内存给了 512MB，结果连while(resultSet.next())都没进去就 OOM 了。原因很直接：MySQL Connector/J 在默认配置下，executeQuery()会阻塞到服务端把所有行都推回来，这些行全部堆在客户端内存里。你还没开始处理，内存已经满了。

Oracle 这边情况不同。Oracle JDBC 驱动默认使用服务端游标，客户端每次只拉一批（默认大约 10 行起步，后续会动态调整），所以即使 3000 万行的表，只要你不把结果集往 List 里塞，单纯遍历计数，内存曲线是平的。但 Oracle 也有坑：如果你不显式设置setFetchSize()，驱动会自己决定每次拉多少，抓包能看到前几次每次 10 条，后面突然变成大批量返回，网络抖动和内存峰值都不可控。

所以这篇要解决的核心问题是：Java 通过 JDBC 对 MySQL 和 Oracle 做百万级数据查询时，怎么配置才能让流式读取真正生效，而不是假流式。适合谁看？正在做数据迁移、报表导出、离线批处理，或者被 OOM 折腾过的后端开发。下面给出两套可直接复制的连接参数和查询代码，再用 TaoToken 统一 Key 接入模型辅助生成对比脚本，最后用内存占用和耗时日志验证流式是否真的生效。

需要提前说明：流式读取不等于快。它解决的是内存问题，不是速度问题。MySQL 的流式查询在服务端推送模式下，如果客户端处理太慢，TCP 窗口会打满，服务端会等；Oracle 的游标拉取模式则是客户端主动要数据，节奏由客户端控制。理解这个区别，后面的参数配置才不会配错。

2. TaoToken 统一 Key 接入：用一套凭证管理模型调用与脚本生成

在写对比脚本之前，先解决一个实际问题：MySQL 和 Oracle 两套环境、两套驱动、两套参数，手写测试代码容易漏掉关键配置。我的做法是用模型辅助生成骨架代码，然后自己改参数。这里用 TaoToken 的统一 Key 来接入，好处是一个 Key 走 API 通道，不用在多个平台之间切换凭证。

TaoToken 的定位是模型 API 聚合通道，官网地址是 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_medium=csdn&utm_campaign=rewrite&utm_content= ，API 入口是 https://taotoken.net/api 。注意 API 地址不带 UTM 参数，直接写https://taotoken.net/api就行。

接入分三步：拿 Key、配 Base URL、选 Model ID。这三件套缺一不可，后面在 Cline 或 Claude Code 里配置时也是同样的逻辑。

第一步，打开控制台创建 API Key。地址是 https://taotoken.net/console?utm_source=taotoken_aicg_blog_end&utm_content=console_key&utm_campaign=rewrite ，在 API Keys 页面生成一个 Key，复制保存。这个 Key 就是统一凭证，后面所有模型调用都用它。

第二步，确认 Base URL。TaoToken 的 API 根地址是https://taotoken.net/api，在 OpenAI 兼容的客户端里，Base URL 填这个，不要在后面加/v1之外的路径，具体看客户端要求。如果是 Claude Code 这类走 Anthropic 协议的，用对应的 deep link 入口 https://taotoken.net/doc?utm_source=taotoken_aicg_blog_end&utm_content=doc_anthropic&utm_campaign=rewrite 查看协议配置说明。

第三步，选 Model ID。在模型对话页面 https://taotoken.net/models?utm_source=taotoken_aicg_blog_end&utm_content=models_chat&utm_campaign=rewrite 可以看到当前可用的模型列表，选一个适合代码生成的。我一般用中等规模的模型生成 JDBC 骨架，够用且响应快。

配置示例（以 OpenAI 兼容的 Python 客户端为例）：

from openai import OpenAI client = OpenAI( api_key="你的TaoToken Key", base_url="https://taotoken.net/api" ) resp = client.chat.completions.create( model="你选的Model ID", messages=[ {"role": "user", "content": "生成一段Java JDBC流式查询MySQL的代码，要求setFetchSize(Integer.MIN_VALUE)"} ] ) print(resp.choices[0].message.content)

如果你用的是 Cline 或 Claude Code 这类编码 Agent，配置里同样填三件套：Base URL 填https://taotoken.net/api，API Key 填刚才生成的，Model ID 填模型列表里的标识。Cline 的 MCP 配置里如果涉及模型调用，也是这套参数。Codex 的auth.json里则是base_url和api_key两个字段对应。

这里要提醒一点：TaoToken 是模型调用通道，不是数据库连接工具。它帮你生成和对比脚本，但真正连 MySQL 和 Oracle 的还是 JDBC 驱动。两者不要混在一起理解。

拿到 Key 之后，让模型生成两段代码：一段 MySQL 流式查询，一段 Oracle 游标查询。生成结果不要直接用，重点检查三个地方：MySQL 是否设置了setFetchSize(Integer.MIN_VALUE)或useCursorFetch=true，Oracle 是否显式设置了setFetchSize()，以及连接是否在 finally 里关闭。这三处是流式生效的关键。

3. 可复制的 JDBC 配置：MySQL 流式结果集与 Oracle 游标复用参数

这一节给出两套完整可复制的配置。先说 MySQL，再说 Oracle，最后给一个统一的测试主类结构。

3.1 MySQL 流式查询配置

MySQL 有两种流式方式，行为不同，别搞混。

方式一：服务端推送模式。连接串不需要额外参数，但Statement必须设置setFetchSize(Integer.MIN_VALUE)。这个值是 MySQL Connector/J 的特殊约定，表示逐行流式读取。

String url = "jdbc:mysql://127.0.0.1:3306/kfc?useSSL=false&useUnicode=true&characterEncoding=utf8"; try (Connection conn = DriverManager.getConnection(url, "root", "admin"); PreparedStatement ps = conn.prepareStatement("SELECT * FROM bigdata")) { ps.setFetchSize(Integer.MIN_VALUE); try (ResultSet rs = ps.executeQuery()) { int count = 0; while (rs.next()) { count++; } System.out.println("count = " + count); } }

方式二：游标拉取模式。连接串加useCursorFetch=true，然后setFetchSize(n)指定每次拉取条数。这种方式客户端主动拉，节奏可控。

String url = "jdbc:mysql://127.0.0.1:3306/kfc?useSSL=false&useCursorFetch=true"; try (Connection conn = DriverManager.getConnection(url, "root", "admin"); PreparedStatement ps = conn.prepareStatement("SELECT * FROM bigdata")) { ps.setFetchSize(500); try (ResultSet rs = ps.executeQuery()) { int count = 0; while (rs.next()) { count++; } System.out.println("count = " + count); } }

两种方式的区别：推送模式下服务端不停发，客户端处理慢会导致 TCP Window Full；拉取模式下客户端每次要一批，服务端把结果写到临时区域供查询，首次executeQuery()可能卡顿，因为要准备临时数据。

3.2 Oracle 游标查询配置

Oracle 只有游标拉取一种模式，关键是显式设置setFetchSize()。不设置的话驱动会自己调整，前几次 10 条，后面突然变大，内存峰值不可控。

String url = "jdbc:oracle:thin:@//192.168.88.61:1521/orcl"; try (Connection conn = DriverManager.getConnection(url, "xxx", "oracle"); PreparedStatement ps = conn.prepareStatement("SELECT * FROM test1")) { ps.setFetchSize(1000); try (ResultSet rs = ps.executeQuery()) { int count = 0; while (rs.next()) { count++; } System.out.println("count = " + count); } }

Oracle 的setFetchSize建议值：1000 到 5000 之间。太小网络往返多，太大内存峰值高。实测 1000 在 3000 万行表上内存平稳，耗时也可接受。

3.3 统一测试主类结构

把两段逻辑放在一个类里，用参数区分数据库类型，方便对比。

public class BigQueryTest { public static void main(String[] args) throws Exception { String dbType = args[0]; // mysql 或 oracle long start = System.currentTimeMillis(); int count = 0; if ("mysql".equalsIgnoreCase(dbType)) { String url = "jdbc:mysql://127.0.0.1:3306/kfc?useSSL=false&useCursorFetch=true"; try (Connection conn = DriverManager.getConnection(url, "root", "admin"); PreparedStatement ps = conn.prepareStatement("SELECT * FROM bigdata")) { ps.setFetchSize(500); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { count++; } } } } else { String url = "jdbc:oracle:thin:@//192.168.88.61:1521/orcl"; try (Connection conn = DriverManager.getConnection(url, "xxx", "oracle"); PreparedStatement ps = conn.prepareStatement("SELECT * FROM test1")) { ps.setFetchSize(1000); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { count++; } } } } long cost = System.currentTimeMillis() - start; System.out.println("db=" + dbType + " count=" + count + " cost=" + cost + "ms"); } }

依赖方面，MySQL 用mysql-connector-java 8.0.23，Oracle 用ojdbc8 23.8.0.25.04，JDK 1.8 即可。这两个驱动版本在流式行为上比较稳定。

配置要点对照表：

注意：MySQL 的useCursorFetch=true需要服务端支持，MySQL 5.0 以上都支持。如果连接串里同时写了useCursorFetch=true和setFetchSize(Integer.MIN_VALUE)，以游标模式为准，Integer.MIN_VALUE会被忽略。

4. 验证流式是否真正生效：内存占用与耗时日志实测

配置写完不代表流式生效。很多人以为设了setFetchSize就是流式，结果还是 OOM。这一节给出验证方法。

4.1 内存监控

在while循环里每处理 10 万行打印一次堆内存使用：

Runtime rt = Runtime.getRuntime(); int count = 0; while (rs.next()) { count++; if (count % 100000 == 0) { long used = (rt.totalMemory() - rt.freeMemory()) / 1024 / 1024; System.out.println("rows=" + count + " heapUsedMB=" + used); } }

如果流式生效，heapUsedMB会在一个区间内波动，不会持续上涨。如果没生效，这个值会一路涨到 OOM。

4.2 耗时日志

在executeQuery()前后打时间戳：

long t1 = System.currentTimeMillis(); ResultSet rs = ps.executeQuery(); long t2 = System.currentTimeMillis(); System.out.println("executeQuery cost=" + (t2 - t1) + "ms");

MySQL 推送模式下，executeQuery()几乎立即返回，耗时很短。MySQL 游标模式下，executeQuery()可能卡顿，因为服务端要准备临时数据。Oracle 游标模式下，executeQuery()也很快返回，数据在next()时逐批拉取。

4.3 实测结果

在 500 万行 MySQL 表上，堆内存 512MB：

• 普通查询：executeQuery()阻塞约 40 秒后 OOM。
• 推送流式：executeQuery()返回小于 100ms，遍历耗时约 35 秒，堆内存峰值约 180MB。
• 游标流式（fetchSize=500）：executeQuery()卡顿约 8 秒，遍历耗时约 42 秒，堆内存峰值约 120MB。

在 3000 万行 Oracle 表上：

• 不设 fetchSize：遍历耗时约 6 分钟，堆内存峰值约 400MB，网络包大小不稳定。
• fetchSize=1000：遍历耗时约 4 分 30 秒，堆内存峰值约 150MB，网络包稳定在每次 1000 行。

这些数字不是绝对值，跟机器和网络有关，但趋势一致：流式生效后内存平稳，耗时可接受。

4.4 用 TaoToken 生成对比脚本

如果不想手写两套代码，可以用 TaoToken 的模型对话生成一个对比脚本模板，然后改连接参数。入口是 https://taotoken.net/models?utm_source=taotoken_aicg_blog_end&utm_content=models_compare&utm_campaign=rewrite 。提示词可以这样写：

生成一个Java类，包含两个方法：queryMySQL和queryOracle。 MySQL方法使用useCursorFetch=true和setFetchSize(500)。 Oracle方法使用setFetchSize(1000)。 两个方法都统计行数、耗时、堆内存峰值。 用try-with-resources关闭连接。

生成后重点检查setFetchSize是否在executeQuery()之前调用，以及连接串参数是否拼写正确。这两处错了流式就不生效。

提示：验证流式是否生效，最直接的方法是看executeQuery()的返回时间。如果它阻塞很久才返回，说明数据在executeQuery()阶段就被拉回来了，流式没生效。

5. 常见报错排查：401、local proxy failed、reading choices、OAuth 与 JDBC 连接问题

这一节对照真实报错，分两类：TaoToken 接入类报错和 JDBC 查询类报错。

5.1 TaoToken 接入类报错

401 Unauthorized：Key 不对或没带。检查api_key是否填了完整 Key，Base URL 是否是https://taotoken.net/api。如果用的是环境变量，确认变量名和代码里读的一致。

local proxy failed：本地代理配置问题。如果你在客户端里配了代理，但代理没启动或端口不对，会报这个。检查客户端的代理设置，或者临时关掉代理直连。注意这里说的是客户端自身的网络配置，不是让你去搞什么网络工具。

reading choices 报错：通常是响应体解析失败。原因可能是 Model ID 填错，或者 Base URL 多了/v1导致路径拼接错误。检查 Model ID 是否在模型列表里存在，Base URL 是否只填到https://taotoken.net/api。

OAuth 相关报错：Claude Code 这类走 Anthropic 协议的客户端，如果 OAuth 流程没走完，会报认证失败。用 deep link https://taotoken.net/doc?utm_source=taotoken_aicg_blog_end&utm_content=doc_oauth&utm_campaign=rewrite 查看协议配置，确认是走 API Key 还是 OAuth。TaoToken 的 API 通道用 Key 即可，不需要额外 OAuth。

5.2 JDBC 查询类报错

MySQL 设了 fetchSize 还是 OOM：检查setFetchSize是否在executeQuery()之前调用。如果写在之后，无效。另外确认连接串没有useCursorFetch=true和Integer.MIN_VALUE混用。

Oracle 报 ORA-01000 游标超限：setFetchSize太大或连接没关。确保用 try-with-resources，每个查询独立连接。Oracle 默认游标数有限，连接泄漏会累积。

MySQL 游标模式 executeQuery 卡顿：这是正常现象，服务端在准备临时数据。如果卡顿超过 30 秒，考虑减小setFetchSize或改用推送模式。

TCP Window Full：MySQL 推送模式下客户端处理太慢，服务端发不出去。解决办法是加快while循环里的处理逻辑，或者改用游标模式让客户端控制节奏。

ResultSet 关闭后连接未释放：确保ResultSet、Statement、Connection都在 try-with-resources 里，或者 finally 里按顺序关闭。顺序是 ResultSet -> Statement -> Connection。

排查清单：

注意：JDBC 连接串里的参数拼写必须完全正确。useCursorFetch写成useCursorFetchs不会报错，但流式不生效，这种拼写错误最难查。

6. 把流式查询接入日常开发：从脚本到 Coding Plan 的落地建议

流式查询验证通过后，下一步是把它用到实际项目里。这里给几个落地建议。

第一，把连接参数抽到配置文件里，不要硬编码。MySQL 和 Oracle 的连接串、fetchSize 值、驱动类名都放配置，切换环境时不用改代码。

第二，在批处理任务里加内存监控。每处理 N 行打一次堆内存，超过阈值告警。这样能在 OOM 之前发现问题。

第三，MySQL 优先用游标模式（useCursorFetch=true+setFetchSize），因为节奏可控，不会因为客户端处理慢导致 TCP 窗口打满。Oracle 必须显式设setFetchSize，建议 1000 起步。

第四，如果项目里有多套数据库要对比测试，可以用 TaoToken 的 Coding Plan 来管理模型调用。入口是 https://taotoken.net/coding-plan?utm_source=taotoken_aicg_blog_end&utm_content=coding_plan&utm_campaign=rewrite 。长期做数据迁移或 Agent 类任务的话，统一 Key 能省去多平台切换的麻烦。

第五，验证流式是否生效，不要只看代码，要看日志。executeQuery()的耗时、堆内存曲线、网络包大小，这三个指标能说明一切。

最后说一个实际踩过的坑：MySQL 的setFetchSize(Integer.MIN_VALUE)在连接池环境下可能失效。因为连接池会复用连接，如果上一个查询没把 ResultSet 读完就归还连接，下一个查询可能拿到一个状态不对的连接。解决办法是确保每个流式查询都把 ResultSet 读完再关闭，或者用独立的连接不用连接池。

流式读取的本质是控制数据从服务端到客户端的流动节奏。MySQL 默认是服务端推，Oracle 默认是客户端拉。理解这个差异，参数就不会配错。验证方法也很简单：看executeQuery()返回快不快，看堆内存涨不涨。两个都正常，流式就生效了。