手把手带你用JDBC+MySQL实现订单管理系统，练透Java基本功-代码聚汇网

手把手带你用JDBC+MySQL实现订单管理系统，练透Java基本功

不靠谱的糖饼·2026-09-04·阅读 22 GEO检测（免费）

JavaJDBCMySQL

|难度：普通|阅读约 39 分钟

如果你的 Java 语法已经看完，但看到“写项目”三个字还是会心里没底，那“订单管理”就是最适合的入门题目。这个题目的好处在于足够小：不需要微服务、不需要分布式，只需要把一张订单表处理好，你就能把类设计、数据库操作、程序分层这些核心基本功真正串起来；同时它又足够真实，几乎所有企业后台里都有订单的影子。对初级开发者、应届生、准备做课程设计的同学来说，都是性价比很高的练手方向。

下面我会按自己实际带新人时的习惯，把整个项目从需求分析、技术选型、建表、编码到踩坑，一步步拆开讲清楚。看完之后你不只是会抄代码，还会明白每一步为什么这么设计。

1. 动手前先想清楚：这个简版订单系统到底要做什么

1.1 需求清单：别一上来就写代码

很多初级开发者拿到“订单管理”题目，第一反应是打开 IDE 直接建类，这是一个非常典型的问题。真实项目里第一步永远是问需求：要管理订单的哪些信息？用户有哪些操作？

我建议把需求收敛成一张极简清单：

订单核心字段：订单编号、客户名称、商品名称、下单数量、商品单价、订单总金额、订单状态、创建时间。
基础操作：创建订单、查看订单列表、根据订单号查询、修改订单状态（比如把“待支付”改成“已支付”）、删除订单。
数据存储：使用 MySQL，保证程序重启后数据不丢失。
交互形式：初级项目最合适的是控制台菜单，把功能跑通后再考虑 Web 界面。

初次做项目，功能宁少勿多。把增删改查做扎实，把三层结构分清楚，比强行堆出五个用不到的功能有价值得多。如果你能对着别人讲清楚每一行代码为什么存在，面试官对你的印象会远好于“我做过一个功能很多但说不清内部逻辑的管理系统”。

1.2 技术选型：为什么我坚持让你用 JDBC，而不是直接上 SpringBoot

现在的网络上到处是 SpringBoot 教程，很多人学完 JavaSE 就想直接冲微服务。但初级项目的核心目标是理解底层原理，所以我倾向选择最朴素的组合：JavaSE + MySQL + JDBC，加上一个简单的三层结构（实体层、数据访问层、业务层）。

JDBC 让你被迫手动处理连接、预编译语句、结果集映射，才能真正理解框架替你做了什么。
不引入 Spring 容器，代码里没有“魔法”，每个对象都自己 new，出问题可以顺着调用栈一路查。
控制台交互足够验证逻辑，如果一开始就上 JSP / Vue，很容易陷入“页面调不通”的泥潭，反而忽略了业务本身。

当然，这并不意味着 SpringBoot 不该学。我的建议是先把这个版本的底层逻辑摸透，后续升级框架时你会豁然开朗：MyBatis 其实就是把 JDBC 封装得更优雅，Spring 解决的是对象管理和解耦问题。基础牢的人学框架速度非常快。

1.3 预期成果与学习目标：做完你能收获什么

按我下面的步骤做完，你会得到一个能真实运行的控制台订单管理系统。通过这个系统，你能在实战中掌握：

如何设计一张符合基本规范的数据表，包括字段类型、主键、索引、表名关键字避坑。
如何使用 JDBC 操作 MySQL，包括 PreparedStatement 预编译、结果集映射、获取自增主键。
为什么要分层，DAO 层、Service 层分别解决什么问题。
事务是什么，为什么创建订单这类复合操作必须有事务保护。
最基本的排错思路：驱动缺失、乱码、数据库连接失败分别怎么处理。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 环境准备与数据库设计：把地基打牢

2.1 起步检查清单：JDK、MySQL、IDE

在写任何业务代码前，先把环境确认一遍，能省下大量莫名其妙的报错时间。我的建议版本如下：

JDK：8 及以上都可以，我推荐 JDK 8 或 JDK 11，JDK 17 也行，但要注意后续部分框架的兼容性。
MySQL：5.7 或 8.0，本教程 SQL 两种版本通用。
IDE：IntelliJ IDEA 社区版足够，不需要破解旗舰版。
数据库图形化工具：Navicat 或 DBeaver 都行，DBeaver 免费且跨平台。

命令行里执行 java -version 确认 JDK 成功安装，执行 mysql --version 确认 MySQL 客户端可用。如果遇到“java 不是内部或外部命令”，说明 JAVA_HOME 环境变量或 PATH 还没配好，这条是新手最常见的拦路虎，按系统教程重新配置一次即可。

另外建议在本地建一个专门的数据库，不要用系统默认的 test 库。命令行登录 MySQL 后执行：

sql复制CREATE DATABASE IF NOT EXISTS order_demo DEFAULT CHARACTER SET utf8mb4;

utf8mb4 是必须的。它支持完整的中文和 Emoji 字符，比老的 utf8 更靠谱，也避免后面插入中文订单数据时变成乱码。

2.2 数据表设计：字段不是随便拍的

订单表是最经典的业务表之一。初次设计时你不需要搞出订单主表和订单明细表两张表，但核心字段必须想清楚。我给出的建表 SQL 如下：

sql复制CREATE TABLE t_order (
    id BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '主键ID',
    order_no VARCHAR(32) NOT NULL UNIQUE COMMENT '订单编号',
    customer_name VARCHAR(50) NOT NULL COMMENT '客户名称',
    goods_name VARCHAR(100) NOT NULL COMMENT '商品名称',
    goods_count INT NOT NULL DEFAULT 1 COMMENT '商品数量',
    goods_price DECIMAL(10,2) NOT NULL COMMENT '商品单价',
    total_amount DECIMAL(10,2) NOT NULL COMMENT '订单总金额',
    status TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0待支付 1已支付 2已取消',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

这张表里有几个点值得专门说一下。第一，为什么表名叫 t_order 而不是 order？因为 ORDER 是 SQL 里的关键字，ORDER BY 排序语句天天用，如果你给表起名 order，写 SQL 时就得加上反引号写成 `order`，容易出错且阅读性差。加前缀 t_ 是常见规避手段。

第二，金额为什么用 DECIMAL(10,2) 而不是 float 或 double？因为浮点数在计算机里用二进制存储，金额这类对精度敏感的数据很容易出现 0.1 + 0.2 不等于 0.3 的情况。虽然本项目的计算只是单价格乘以数量，但初级开发者从第一张表开始就应该养成正确习惯。

第三，status 字段用 TINYINT 而不是字符串。你可能会想“那用户在控制台看到的是什么”这个问题由 Java 代码负责翻译。保存状态用数字，展示状态时再用代码映射成中文，这是很成熟的做法，比在数据库里存“待支付”这种字符串更省空间也更好扩展。

第四，order_no 加了 UNIQUE 唯一约束。因为它是业务上的唯一标识，直接用数据库约束做兜底，比完全依赖 Java 代码判断更安全。

2.3 工程结构与包命名：代码该放在哪里

设计包结构时不要把所有类堆在一个包下。我常用的简易结构如下：

code复制com.example.order
├── Main.java                      // 程序入口，控制台菜单
├── entity/Order.java              // 订单实体类
├── dao/OrderDao.java              // 数据访问层
├── service/OrderService.java      // 业务逻辑层
└── util/DBUtil.java               // 数据库连接工具类

每个类只承担一种职责，这就是最基础的高内聚低耦合思想。entity 包里放对象模型，dao 包里只写数据库增删改查，service 包里放业务流程和判断规则，Main 负责和用户交互。以后你学习 Spring、MyBatis、Controller 时，会发现分层的思路依然如此，只是载体从普通类变成了框架注解。

3. 核心编码实现：把每个环节写清楚

3.1 数据库连接工具类：避免到处重复打开连接

写 JDBC 代码时最大的重复工作就是获取连接和释放资源。所以我的习惯是第一步就封装一个 DBUtil 工具类。这个类里放两样东西：数据库连接参数和获取连接的方法。

java复制package com.example.order.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {

    private static final String URL = "jdbc:mysql://localhost:3306/order_demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "你的数据库密码";

    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }
}

这里有三个细节值得初级开发者反复揣摩。第一，Class.forName("com.mysql.cj.jdbc.Driver") 是加载 MySQL 驱动类，括号里的字符串如果拼错，运行时就会报 ClassNotFoundException，这是新手最常见的报错之一。如果你用的是 MySQL 5.7，驱动类名通常是 com.mysql.jdbc.Driver，而 MySQL 8.0 用的是 com.mysql.cj.jdbc.Driver，两者不要搞混。

第二，URL 后面那一长串参数不是可有可无的。characterEncoding=utf8 保证中文能正确写入数据库，serverTimezone=Asia/Shanghai 解决 MySQL 8.0 的时区报错问题。如果连接时出现 The server time zone value 提示，八成就是少了时区参数。

第三，静态代码块里的 Class.forName 其实在 JDBC 4.0 之后可以省略，因为驱动 jar 包的 META-INF 服务文件会自动完成注册。但初级项目保留它反而有助于理解“驱动加载”这个过程。

3.2 实体类：让数据库字段变成 Java 对象

实体类的作用是把数据库表映射成 Java 对象。字段命名习惯上使用驼峰命名法，数据表字段使用下划线命名法，二者之间的转换你要心里有数。

java复制package com.example.order.entity;

import java.math.BigDecimal;
import java.time.LocalDateTime;

public class Order {
    private Long id;
    private String orderNo;
    private String customerName;
    private String goodsName;
    private Integer goodsCount;
    private BigDecimal goodsPrice;
    private BigDecimal totalAmount;
    private Integer status;
    private LocalDateTime createTime;

    // 无参构造器
    public Order() {}

    // getter 和 setter 方法，此处省略，务必自己补全
    // 建议额外提供一个方便输出订单信息的 showInfo() 方法
}

强调一下，实体类字段类型要和数据库字段类型匹配：数据库 BIGINT 对应 Java Long，DECIMAL 对应 BigDecimal，DATETIME 对应 LocalDateTime 或 java.util.Date。用错类型很容易在结果集取值时报 ClassCastException。

不要在小项目里偷工减料把所有字段拼成一个长字符串。扎实的实体类可以让你在 Service 层很方便地取出某个字段做判断，比如判断状态是否为待支付。编码时写完 getter/setter 后，建议添加一个 showInfo 方法，负责把状态从数字翻译成中文并格式化输出，后续控制台打印会非常方便。

3.3 DAO 层：代码只做数据库操作这一件事

DAO 层和数据库直接打交道，我建议把所有 JDBC 操作集中在这里。下面用“新增订单”和“查询订单列表”这两个最核心的方法举例。

先看新增方法：

java复制package com.example.order.dao;

import com.example.order.entity.Order;
import com.example.order.util.DBUtil;

import java.math.BigDecimal;
import java.sql.*;

public class OrderDao {

    public int insert(Order order) {
        String sql = "INSERT INTO t_order (order_no, customer_name, goods_name, goods_count, goods_price, total_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?)";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            ps.setString(1, order.getOrderNo());
            ps.setString(2, order.getCustomerName());
            ps.setString(3, order.getGoodsName());
            ps.setInt(4, order.getGoodsCount());
            ps.setBigDecimal(5, order.getGoodsPrice());
            BigDecimal total = order.getGoodsPrice().multiply(new BigDecimal(order.getGoodsCount()));
            ps.setBigDecimal(6, total);
            ps.setInt(7, order.getStatus());
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
}

仔细看这段代码，每一步都有讲究。你可能会问：为什么不直接用 Statement 拼接 SQL？答案是要防 SQL 注入。用 ? 占位符加 PreparedStatement 预编译，用户输入的东西永远只是参数，不可能被拼进 SQL 语法里。初级项目里就要养成这个习惯，不要觉得“本地练习无所谓”。

我也特别注意了 try-with-resources 语法的使用。try (...) 中声明的 Connection、PreparedStatement 会在 try 块结束后自动关闭，不需要手动调用 close 方法。这在 Java 7 之后引入，可以保证即使代码抛异常，资源也能被正确释放，避免数据库连接耗尽。初学者早期手动写 finally { conn.close(); } 经常忘记处理异常或者关闭顺序不对，使用 try-with-resources 能从语法层面规避这个坑。

再写一个查询订单列表的方法：

java复制public List<Order> findAll() {
    String sql = "SELECT id, order_no, customer_name, goods_name, goods_count, goods_price, total_amount, status, create_time FROM t_order ORDER BY id DESC";
    List<Order> list = new ArrayList<>();
    try (Connection conn = DBUtil.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql);
         ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            Order order = new Order();
            order.setId(rs.getLong("id"));
            order.setOrderNo(rs.getString("order_no"));
            // 其余字段按同样方式映射，此处省去
            list.add(order);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return list;
}

写这段时最容易出现的一个低级错误是 rs.getXxx 方法传入的字符串和 SQL 里的别名或者表字段不一致。报错信息要么是 Column not found，要么是取出来一直是 null。所以建议先在数据库客户端里执行一遍 SQL，确认字段名没有写错，再回来写映射代码。

3.4 Service 层与事务：创建订单为什么必须一起成功或一起失败

Service 层是很多初级项目最容易忽略的部分。不少人把所有代码堆在 DAO 里，最后 DAO 变成了大杂烩。我的建议是：任何包含“多个数据操作”的业务逻辑都放 Service，DAO 只做单表简单操作。

举一个现实中的例子：真正的下单业务除了插入订单，通常还要更新库存、记录日志。如果先插入订单成功，但更新库存失败，数据库里就会出现一笔“幽灵订单”。要解决这个问题，就必须引入数据库事务：要么所有操作都成功，要么全部回滚。

在 JDBC 里，事务控制的基本代码如下：

java复制public void createOrder(Order order) {
    Connection conn = null;
    try {
        conn = DBUtil.getConnection();
        conn.setAutoCommit(false); // 关闭自动提交，开启事务

        // 这里可以执行多次数据库操作
        // 例如通过 OrderDao 插入订单、扣减库存等

        conn.commit();             // 全部成功则提交
    } catch (SQLException e) {
        if (conn != null) {
            try {
                conn.rollback();   // 发生异常则回滚
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
        e.printStackTrace();
    } finally {
        if (conn != null) {
            try {
                conn.setAutoCommit(true); // 恢复自动提交
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

这段代码虽然比简单版多了一些啰嗦的异常处理，但它暗含了真实工程中非常重要的设计思路。事务的边界在哪？事务从 setAutoCommit(false) 开始，到 commit 或 rollback 结束。初级项目里至少要能把一个“创建订单”过程放在事务里跑一遍，体会一下回滚是什么效果。

你可以做一个实验：在事务里故意插入两条订单，第二条单价写成负数违反检查约束，看第一条订单是否会被回滚掉。只要第一条不在数据库中出现，你就真正理解事务的意义了。

3.5 控制台交互层：让用户能真正操作系统

Service 写完后，最后一步是把程序跑起来。我建议先用一个简单的 Main 类做控制台菜单，不要急着写 Web 页面。

java复制public class Main {
    public static void main(String[] args) {
        OrderService orderService = new OrderService();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("=== 简易订单管理系统 ===");
            System.out.println("1. 创建订单");
            System.out.println("2. 查询所有订单");
            System.out.println("3. 修改订单状态");
            System.out.println("4. 删除订单");
            System.out.println("5. 退出");
            System.out.print("请选择：");

            int choice;
            try {
                choice = Integer.parseInt(scanner.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("请输入数字！");
                continue;
            }

            switch (choice) {
                case 1:
                    // 读取客户名、商品名、数量、单价，封装 Order 对象后调用 orderService.createOrder()
                    break;
                case 2:
                    // 调用 orderService.findAll() 并循环打印订单信息
                    break;
                // ... 其余分支
                case 5:
                    System.out.println("已退出系统");
                    scanner.close();
                    return;
                default:
                    System.out.println("没有这个选项");
            }
        }
    }
}

写控制台交互时有一个细节新手经常踩坑：用 scanner.nextInt() 后紧接着 scanner.nextLine() 读取字符串，会发现读取不到内容。这是因为 nextInt() 不会消费掉输入末尾的换行符，残留的换行被 nextLine() 读掉了。为了避免这个坑，我统一使用 scanner.nextLine() 读取后再手动 Integer.parseInt 转换，反而更省心。

这个控制台版本虽然简陋，但已经具备一个完整系统的雏形。建议你运行一遍，真正体验“用户输入数据 → 写入 MySQL → 再查询出来”的完整流程。

4. 全流程验证与后续升级方向

4.1 用一条用户路径把系统过一遍

项目写完以后，不要急着认为“代码能编译就完成了”，最好模拟一次真实用户操作流程。我的建议流程如下：

启动程序，选择创建订单，输入客户名“张三”，商品“机械键盘”，数量 2，单价 499.9。
程序计算总金额并写入数据库，此时状态默认为 0（待支付）。
选择查询所有订单，应该看到这条记录，金额显示 999.80，时间由数据库自动生成。
选择修改订单状态，输入新状态 1（已支付）。
再次查询，确认状态已变化。
选择删除订单，删除后再查询，列表为空。

如果你操作到哪一步出错，正好可以借机检查是 SQL 问题、类型转换问题还是业务逻辑问题。全程跑通后，顺手到 MySQL 客户端执行 SELECT * FROM t_order;，看数据是否真实落盘。这一步会给你一种“我做的东西真的有用”的实感，非常提升信心。

4.2 从控制台到 Web 的平滑升级

控制台版本验证完成后，可以按两条路径继续升级。

第一条路是保留 JavaSE 基础，把控制台界面换成 Swing 桌面小工具，适合课设展示，但不推荐作为主要方向，因为桌面端开发目前不是 Java 的主要战场。

第二条路是走向 JavaWeb。你可以把 Main 类拆成 OrderServlet，把控制台输入换成 HTML 表单，先把最基础的 Servlet + JSP 流程跑通。此时 OrderDao 和 OrderService 几乎不用改，只需要增加一层 Servlet 负责接收请求参数并调用 Service。你会发现，之前分层的价值这一刻就体现出来了：如果没有分层，从控制台改到 Web 需要把所有查询显示逻辑全部推翻重写。

更进一步的升级线是引入 MyBatis，把 DAO 层的手写 JDBC 替换为 Mapper 文件；再往后才轮到 SpringBoot 整合。我给新人的建议是不要一步跨到位，每层框架都亲手加一次，你才能理解什么叫框架是工具而不是魔法。

5. 初级项目高频踩坑与调试习惯

5.1 六个新手最常遇到的报错

我过去看新人提交的作业，发现有些问题出现频率极高。我整理成了一张速查表，遇到对应报错可以直接对着排查：

现象	根本原因	处理建议
`java.lang.ClassNotFoundException: com.mysql.cj.jdbc.Driver`	MySQL 驱动 jar 未引入或驱动类名拼错	确认 pom.xml 或项目 lib 里引入了 mysql-connector-java；确认版本对应类名
`Access denied for user 'root'@'localhost'`	数据库用户名或密码错误	到命令行用相同账号密码登录 MySQL 验证
`Unknown database 'order_demo'`	数据库没创建或库名拼写错误	先执行建库 SQL，再检查 DBUtil 中的 URL
中文插入后显示 `??`	连接 URL 没有设置 utf8，或数据库表本身不是 utf8mb4	URL 加 `characterEncoding=utf8`；确认建表语句 `DEFAULT CHARSET=utf8mb4`
打印订单时间格式很难看	LocalDateTime 默认输出格式问题	使用 `DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")` 格式化
程序运行几次后卡住或报连接池耗尽	数据库连接没有关闭	全局搜代码，确保每个 Connection/Statement/ResultSet 都正确关闭或使用 try-with-resources

5.2 排查问题时要有的两个思维习惯

第一个习惯叫“先确认基础环境，再怀疑业务代码”。我自己见过太多同学花了两个小时调一个 DAO 方法，最后发现是数据库服务没启动。遇到异常时先看异常栈最顶部的几行，明确是哪一层出了问题；如果你不确定 SQL 是否正确，就把它拿出来手动在数据库客户端里执行一次。SQL 本身没问题，再回过头检查 Java 代码里的参数传递和类型映射，这样定位问题能快很多。

第二个习惯叫“动手前先想输出”。写代码遇到“不知道对不对”的时候，可以先在关键位置打印一下当前变量值。比如调用 insert 之前，打印 order.getCustomerName()，确认用户输入确实封装到对象里了。很多增删改查问题最后都出在对象没赋值成功，而不是 SQL 写错。

5.3 好代码是慢慢改出来的，不是一次写对的

最后分享一点我在带新人过程中特别喜欢强调的观点：初版代码写得粗糙没关系，但要有意愿回头重构。我第一次写订单管理时，DAO 里的方法到处用 System.out.println 输出结果，后来学习了日志再回头看，觉得当时的代码约定俗成但不够好。真正让一个初级开发者成长的是第二次甚至第三次修改同一个项目。

具体操作上，我建议每完成一个小功能就做一次 git 提交，每个版本写清楚改动点，比如“feat: 实现新增订单”、“refactor: 把数据库连接逻辑抽到 DBUtil”。这样当你把代码改乱时还能回退，同时也能留下自己的成长轨迹。这个小习惯的成本极低，但长期收益非常大。等这个简版订单系统完整跑通后，你可以继续加商品表、加订单明细表、加库存扣减逻辑、加登录鉴权，慢慢你会发现自己写的代码越来越有“工程味”，而不只是能运行的 Demo。我一直认为，Java 初学阶段做“少而透”的小项目，胜过做“多而浅”的大项目。一个订单系统从控制台版一路改到 SpringBoot 版，这个过程本身就是最好的 Java 学习路线。