Java Cafe原型项目实战：基于Java的咖啡厅管理系统设计与实现

杜连涛

427人浏览 · 2025-11-04 12:51:20

杜连涛 · 2025-11-04 12:51:20 发布

简介：Java Cafe原型是一个基于Java技术构建的咖啡厅运营模拟系统，全面展示了Java语言在实际应用开发中的核心特性与技术实践。该项目涵盖面向对象编程、GUI界面设计、事件处理、数据结构应用、异常处理、文件读写、数据库连接、多线程处理及常用设计模式等关键技术，并通过JUnit进行单元测试以保障代码质量。本项目不仅体现了Java跨平台与面向对象的优势，还为学习者提供了一个完整的Java应用程序开发范例，适合用于掌握企业级Java开发流程与技能。

1. Java Cafe原型系统概述与核心设计思想

Java Cafe原型系统是一个基于Java语言开发的桌面级综合管理应用，模拟真实咖啡店的订单处理、库存管理和用户交互流程。系统采用面向对象设计理念，通过封装、继承与多态等机制实现高内聚、低耦合的模块化架构。核心类如 Coffee 、 Order 、 Customer 和 Menu 均围绕业务实体进行抽象建模，并通过ArrayList、HashMap等集合类支撑运行时数据状态管理。本系统不仅体现Java SE核心技术的实际应用，更作为连接编程基础与工程实践的桥梁，为后续GUI设计、事件驱动、数据库集成等内容奠定架构基础。

2. GUI界面设计与事件驱动编程机制

在现代软件开发中，图形用户界面（GUI）是连接用户与系统逻辑的核心桥梁。尤其对于桌面级应用而言，一个直观、响应迅速且具备良好交互体验的界面，能够极大提升系统的可用性与专业度。Java 提供了多种 GUI 开发技术栈，其中 Swing 和 JavaFX 是最为广泛使用的两种方案。本章将深入探讨如何基于 Swing 框架 构建 Java Cafe 原型系统的用户界面，并结合事件驱动编程模型实现动态交互行为。

2.1 Java GUI技术选型与Swing基础组件应用

选择合适的 GUI 技术栈是构建高质量应用程序的第一步。在 Java 生态中，Swing 作为 AWT 的轻量级替代品，凭借其跨平台兼容性和丰富的组件库，仍然是许多企业级桌面项目的首选。尽管 JavaFX 在视觉表现和动画支持上更具优势，但考虑到 Java Cafe 系统的目标是教学实践与工程基础能力培养，Swing 更加适合初学者掌握底层事件处理机制和组件结构组织方式。

2.1.1 Swing与JavaFX对比分析及选择依据

特性	Swing	JavaFX
组件类型	轻量级（纯 Java 实现）	重量级（部分依赖本地库）
UI 渲染	基于 AWT 的绘制机制	使用硬件加速（Prism 引擎）
样式控制	需手动设置外观或使用 LookAndFeel	支持 CSS 样式表
动画支持	有限，需自定义 Timer 控制	内建强大动画 API
FXML 支持	不支持	支持声明式 UI 定义
学习曲线	较低，API 直观易懂	中等偏高，需理解 Scene Graph 模型
社区资源	成熟稳定，文档丰富	新兴但仍活跃

graph TD
    A[GUI技术选型] --> B{是否需要高级动画/多媒体?}
    B -->|是| C[推荐JavaFX]
    B -->|否| D{是否强调教学可读性?}
    D -->|是| E[推荐Swing]
    D -->|否| F[根据团队熟悉度决定]

从上述对比可见，JavaFX 更适用于富客户端应用如媒体播放器或数据可视化工具；而 Swing 则更适合以功能为主导的教学项目。Java Cafe 并不涉及复杂动画或 3D 图形渲染，因此采用 Swing 可降低学习门槛，同时便于展示事件监听、布局管理等核心概念。

此外，Swing 的“一切皆组件”理念有助于开发者理解 GUI 的层次结构——从顶层容器 JFrame 到中间层 JPanel ，再到具体控件如按钮、标签等，每一层都遵循统一的对象模型。

2.1.2 JFrame、JPanel、 JButton、 JLabel等基本容器与控件使用

构建 GUI 的第一步是创建主窗口。在 Swing 中， JFrame 是最常用的顶级容器类，它封装了一个独立的窗口，包含标题栏、边框以及可关闭操作。

以下是一个典型的 Java Cafe 主界面初始化代码：

import javax.swing.*;

public class CafeMainFrame extends JFrame {
    private JLabel titleLabel;
    private JButton orderButton;
    private JButton menuButton;

    public CafeMainFrame() {
        // 设置窗口标题
        setTitle("Java Cafe 管理系统");
        // 设置默认关闭行为
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置窗口大小
        setSize(800, 600);
        // 居中显示
        setLocationRelativeTo(null);

        // 初始化UI组件
        initComponents();
        // 显示窗口
        setVisible(true);
    }

    private void initComponents() {
        // 创建内容面板（使用BorderLayout）
        JPanel mainPanel = new JPanel();
        mainPanel.setLayout(new BorderLayout());

        // 标题标签
        titleLabel = new JLabel("欢迎光临 Java Cafe", SwingConstants.CENTER);
        titleLabel.setFont(new java.awt.Font("微软雅黑", java.awt.Font.BOLD, 24));
        mainPanel.add(titleLabel, BorderLayout.NORTH);

        // 按钮面板（用于放置操作按钮）
        JPanel buttonPanel = new JPanel();
        orderButton = new JButton("下单");
        menuButton = new JButton("查看菜单");

        buttonPanel.add(orderButton);
        buttonPanel.add(menuButton);

        mainPanel.add(buttonPanel, BorderLayout.CENTER);

        // 将主面板添加到JFrame
        setContentPane(mainPanel);
    }

    public static void main(String[] args) {
        // 启动Swing应用应在事件调度线程中运行
        SwingUtilities.invokeLater(() -> new CafeMainFrame());
    }
}

代码逻辑逐行解读：

setTitle("Java Cafe 管理系统"); ：设置窗口标题，出现在标题栏。
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ：指定点击关闭按钮时终止 JVM 进程。
setSize(800, 600); ：设定初始窗口尺寸，单位为像素。
setLocationRelativeTo(null); ：使窗口居中于屏幕中央。
initComponents() ：封装所有 UI 组件的创建与组装逻辑，提高可维护性。
JLabel 使用 SwingConstants.CENTER 对齐文本，增强视觉一致性。
mainPanel.setLayout(new BorderLayout()); ：采用边界布局，将组件按方位分布（北、南、东、西、中）。
setContentPane(mainPanel); ：替换默认内容面板，确保布局生效。
SwingUtilities.invokeLater(...) ：保证所有 Swing 操作都在事件调度线程（EDT）中执行，避免线程安全问题。

⚠️ 注意：Swing 是单线程框架，任何对组件的修改必须在 EDT 中进行，否则可能导致不可预知的行为。

该代码成功构建了一个包含标题和两个功能按钮的基础界面，为后续事件绑定打下基础。

2.1.3 布局管理器（FlowLayout、BorderLayout、GridLayout）的合理配置

Swing 不推荐使用绝对坐标定位（ null 布局），而是通过 布局管理器 自动安排组件位置，以适应不同分辨率和窗口缩放。

常见布局管理器对比：

布局管理器	特点	适用场景
`FlowLayout`	按照添加顺序水平排列，换行自动	工具栏、按钮组
`BorderLayout`	分为五个区域（N/S/E/W/C）	主窗口整体结构
`GridLayout`	网格均分空间，行列固定	表单输入、数字键盘
`GridBagLayout`	最灵活，支持复杂约束	高级表单布局

例如，在订单填写界面中，可以使用 GridLayout 来整齐排列多个输入字段：

JPanel formPanel = new JPanel(new GridLayout(4, 2, 10, 10)); // 4行2列，间距10px
formPanel.setBorder(BorderFactory.createTitledBorder("顾客信息"));

formPanel.add(new JLabel("姓名："));
formPanel.add(new JTextField());

formPanel.add(new JLabel("电话："));
formPanel.add(new JTextField());

formPanel.add(new JLabel("饮品："));
formPanel.add(new JComboBox<>(new String[]{"美式咖啡", "拿铁", "摩卡"}));

formPanel.add(new JLabel("数量："));
formPanel.add(new JSpinner(new SpinnerNumberModel(1, 1, 10, 1)));

此设计使得每个标签与其对应的输入控件成对出现，布局规整且易于扩展。若未来需要增加新字段，只需继续调用 add() 即可，无需重新计算坐标。

合理的布局策略不仅能提升美观度，还能增强可访问性与响应式体验，特别是在多屏环境下尤为重要。

2.2 界面逻辑分层与用户交互设计

良好的 GUI 设计不仅关注外观，更应注重信息流的组织与用户体验的优化。Java Cafe 系统需处理多个功能模块（如菜单浏览、订单提交、历史查询），这就要求界面具备清晰的层级结构和一致的操作逻辑。

2.2.1 主界面与子窗口的层级组织策略

为了防止主界面过于臃肿，通常将次要功能封装在独立的 JDialog 子窗口中。例如，“添加新订单”功能可通过弹出对话框完成：

public class OrderInputDialog extends JDialog {
    private JTextField customerNameField;
    private JComboBox<String> drinkComboBox;
    private JSpinner quantitySpinner;
    private boolean confirmed = false;

    public OrderInputDialog(JFrame parent) {
        super(parent, "新建订单", true); // 模态对话框
        setSize(300, 200);
        setLocationRelativeTo(parent);

        setLayout(new GridLayout(5, 2, 10, 10));

        add(new JLabel("顾客姓名："));
        customerNameField = new JTextField();
        add(customerNameField);

        add(new JLabel("选择饮品："));
        drinkComboBox = new JComboBox<>(new String[]{"美式", "拿铁", "卡布奇诺"});
        add(drinkComboBox);

        add(new JLabel("数量："));
        quantitySpinner = new JSpinner(new SpinnerNumberModel(1, 1, 10, 1));
        add(quantitySpinner);

        JButton okButton = new JButton("确认");
        JButton cancelButton = new JButton("取消");

        okButton.addActionListener(e -> {
            if (!customerNameField.getText().trim().isEmpty()) {
                confirmed = true;
                dispose(); // 关闭对话框
            } else {
                JOptionPane.showMessageDialog(this, "请填写顾客姓名！", "输入错误", JOptionPane.ERROR_MESSAGE);
            }
        });

        cancelButton.addActionListener(e -> dispose());

        add(okButton);
        add(cancelButton);

        pack(); // 自动调整大小以适配内容
    }

    // 获取输入值
    public String getCustomerName() { return customerNameField.getText(); }
    public String getDrink() { return (String) drinkComboBox.getSelectedItem(); }
    public int getQuantity() { return (int) quantitySpinner.getValue(); }
    public boolean isConfirmed() { return confirmed; }
}

参数说明与逻辑分析：

super(parent, "新建订单", true) ：创建模态对话框，阻塞主窗口操作直至关闭。
confirmed 标志位用于判断用户是否点击“确认”，避免直接返回未完成的数据。
输入验证放在 ActionListener 中，只有合法输入才允许关闭并标记为已确认。
pack() 方法自动调整窗口大小，避免手动设置 setSize() 导致的冗余代码。

这种分层设计实现了职责分离：主界面负责导航，子窗口专注数据采集，提升了系统的模块化程度。

2.2.2 表单输入验证与用户体验优化技巧

有效的输入验证能显著减少后端处理异常的概率。除了基本的非空检查外，还可引入实时反馈机制：

customerNameField.getDocument().addDocumentListener(new DocumentListener() {
    @Override
    public void insertUpdate(DocumentEvent e) { validateInput(); }
    @Override
    public void removeUpdate(DocumentEvent e) { validateInput(); }
    @Override
    public void changedUpdate(DocumentEvent e) { validateInput(); }

    private void validateInput() {
        String text = customerNameField.getText().trim();
        if (text.length() < 2) {
            customerNameField.setBackground(Color.PINK);
        } else {
            customerNameField.setBackground(Color.WHITE);
        }
    }
});

该监听器在文本变化时立即触发颜色提示，帮助用户即时发现错误，优于提交后再报错的传统模式。

2.2.3 图标资源加载与界面美化实践

为提升视觉吸引力，可在按钮或标题旁添加图标：

ImageIcon icon = new ImageIcon(getClass().getResource("/images/coffee.png"));
titleLabel.setIcon(icon);
titleLabel.setHorizontalTextPosition(SwingConstants.RIGHT);

前提是确保 /images/coffee.png 存在于 src/main/resources 路径下，并被正确打包进 JAR 文件。使用相对路径配合 getClass().getResource() 可保障跨平台资源定位准确性。

2.3 事件监听机制原理与ActionListener实现

Swing 采用 事件委托模型（Event Delegation Model） ，即将事件源（如按钮）与监听器对象解耦，由外部类注册监听并响应动作。

2.3.1 事件委托模型的工作流程解析

sequenceDiagram
    participant 用户
    participant JButton as 按钮(Button)
    participant Listener as 监听器(Listener)
    participant 处理逻辑

    用户->>JButton: 点击
    JButton->>Listener: 触发actionPerformed()
    Listener->>处理逻辑: 执行业务代码
    处理逻辑-->>JButton: 更新状态（可选）

这一机制实现了松耦合设计：按钮无需知道谁来处理点击，只需通知所有注册的监听器即可。

2.3.2 ActionListener接口绑定按钮点击行为

最常见的方式是为 JButton 添加 ActionListener ：

orderButton.addActionListener(e -> {
    OrderInputDialog dialog = new OrderInputDialog(CafeMainFrame.this);
    if (dialog.isConfirmed()) {
        System.out.println("新订单：" + dialog.getCustomerName() +
                          ", 饮品：" + dialog.getDrink() +
                          ", 数量：" + dialog.getQuantity());
        // 此处可调用订单服务保存数据
    }
});

Lambda 表达式简化了匿名内部类的写法，使代码更加简洁。

2.3.3 内部类与Lambda表达式简化事件处理代码

传统做法使用匿名内部类：

menuButton.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        showMenuWindow();
    }
});

现代 Java 推荐使用 Lambda：

menuButton.addActionListener(e -> showMenuWindow());

两者功能等价，但后者语法更紧凑，尤其适用于简单逻辑。对于复杂事件处理（如多步骤校验），仍建议提取为独立方法或命名内部类以便调试。

2.4 综合案例：订单提交界面的完整实现

整合前述知识点，构建完整的订单提交流程。

2.4.1 用户选择商品并触发下单操作

public class OrderSubmissionPanel extends JPanel {
    private JList<String> menuList;
    private DefaultListModel<String> menuModel;
    private JTextField customerField;
    private JButton submitButton;

    public OrderSubmissionPanel() {
        setLayout(new BorderLayout());

        // 菜单列表
        menuModel = new DefaultListModel<>();
        menuModel.addElement("美式咖啡 - ¥20");
        menuModel.addElement("拿铁 - ¥28");
        menuModel.addElement("摩卡 - ¥30");
        menuList = new JList<>(menuModel);
        add(new JScrollPane(menuList), BorderLayout.CENTER);

        // 输入区域
        JPanel inputPanel = new JPanel(new GridLayout(2, 2));
        inputPanel.add(new JLabel("顾客姓名："));
        customerField = new JTextField();
        inputPanel.add(customerField);

        submitButton = new JButton("提交订单");
        inputPanel.add(submitButton);
        add(inputPanel, BorderLayout.SOUTH);

        // 绑定事件
        setupEventHandlers();
    }

    private void setupEventHandlers() {
        submitButton.addActionListener(e -> {
            String selected = menuList.getSelectedValue();
            String name = customerField.getText().trim();

            if (selected == null || name.isEmpty()) {
                JOptionPane.showMessageDialog(this,
                    "请选择商品并填写顾客姓名！",
                    "提示",
                    JOptionPane.WARNING_MESSAGE);
                return;
            }

            // 模拟发送至后台
            System.out.printf("【订单创建】%s 订购：%s%n", name, selected);
            JOptionPane.showMessageDialog(this, "订单提交成功！");
        });
    }
}

逻辑分析：

DefaultListModel 支持动态增删菜单项，便于后期扩展。
JScrollPane 包裹 JList 实现滚动功能，防止内容溢出。
提交前双重验证：确保选择了商品且填写了姓名。
成功后弹窗提示，形成闭环反馈。

2.4.2 数据传递至后台处理模块的接口定义

为实现前后端解耦，定义标准化接口：

public interface OrderService {
    boolean placeOrder(Order order);
    List<Order> getPendingOrders();
}

public class SimpleOrderService implements OrderService {
    private Queue<Order> orderQueue = new LinkedList<>();

    @Override
    public boolean placeOrder(Order order) {
        order.setOrderId("ORD" + System.currentTimeMillis() % 10000);
        return orderQueue.offer(order);
    }

    @Override
    public List<Order> getPendingOrders() {
        return new ArrayList<>(orderQueue);
    }
}

在 GUI 中注入服务实例完成数据流转：

private OrderService orderService = new SimpleOrderService();

// 在事件处理器中：
Order order = new Order(name, selected.split(" - ")[0], quantity);
boolean success = orderService.placeOrder(order);

至此，GUI 层完成了从用户输入 → 事件响应 → 数据封装 → 服务调用的完整链路，体现了事件驱动架构的实际价值。

3. 数据结构集成与运行时状态管理

在现代软件系统中，数据的组织方式直接决定了程序的可维护性、扩展性和执行效率。Java Cafe作为一个模拟真实业务场景的桌面应用原型，其核心功能依赖于对订单、菜单、用户交互等动态信息的高效管理。这些信息本质上是运行时状态，需要借助合适的数据结构进行存储、检索和更新。若仅使用基础变量或数组来处理复杂逻辑，将导致代码冗余、耦合度高且难以调试。因此，选择恰当的集合类不仅是一种编程技巧，更是架构设计的关键环节。

Java 提供了丰富的 java.util 集合框架，涵盖列表、映射、队列、栈等多种抽象数据类型，能够满足不同业务场景下的需求。本章将深入探讨如何根据实际问题特征，合理选用 ArrayList、HashMap、Queue 和 Stack 等典型数据结构，并将其无缝集成到 Java Cafe 的业务流程中。同时，还将分析这些结构在多线程环境中的并发访问风险，通过泛型机制提升类型安全性，并结合迭代器模式实现灵活遍历。最终，在实战演练部分构建一个具备增删改查能力、支持状态追踪与扩展性的订单管理中心，为后续持久化与并发处理打下坚实基础。

3.1 动态数据存储结构的选择与应用场景

在 Java Cafe 系统中，数据并非静态不变，而是随着用户操作持续变化。例如，顾客不断下单会导致订单数量增长；厨房完成制作后需移除已完成的任务；前台可能临时添加新品或下架旧饮品。这种动态特性要求系统必须采用可变长度、支持高效操作的数据结构。传统的数组虽然访问速度快，但长度固定，插入删除成本高，显然不适用于此类场景。相比之下，Java 集合框架提供了多种动态容器，可根据具体用途精准匹配。

选择合适的数据结构应基于三个维度： 访问模式 （是否频繁查找）、 修改频率 （增删改比例）以及 顺序要求 （是否需要维持插入顺序或优先级）。以下将围绕四个典型结构展开说明，并结合 Java Cafe 中的具体模块进行案例解析。

3.1.1 ArrayList用于维护菜单项列表的增删改查

ArrayList 是基于动态数组实现的列表结构，支持随机访问，底层通过 Object[] 存储元素，并在容量不足时自动扩容。它非常适合用于存储有序且经常按索引访问的数据集合，如咖啡店的菜单项列表。

假设 Java Cafe 的菜单包含若干饮品对象，每个饮品具有名称、价格、分类等属性。使用 ArrayList<MenuItem> 可以方便地实现菜单的动态管理：

import java.util.ArrayList;

public class MenuManager {
    private ArrayList<MenuItem> menuItems;

    public MenuManager() {
        this.menuItems = new ArrayList<>();
    }

    // 添加新饮品
    public void addMenuItem(MenuItem item) {
        menuItems.add(item);
        System.out.println("已添加饮品: " + item.getName());
    }

    // 根据索引删除饮品
    public boolean removeMenuItem(int index) {
        if (index >= 0 && index < menuItems.size()) {
            MenuItem removed = menuItems.remove(index);
            System.out.println("已删除饮品: " + removed.getName());
            return true;
        }
        System.out.println("无效索引: " + index);
        return false;
    }

    // 修改指定位置的饮品信息
    public boolean updateMenuItem(int index, MenuItem newItem) {
        if (index >= 0 && index < menuItems.size()) {
            menuItems.set(index, newItem);
            System.out.println("已更新饮品: " + newItem.getName());
            return true;
        }
        System.out.println("无法更新，索引越界");
        return false;
    }

    // 查询所有菜单项
    public void displayMenu() {
        System.out.println("\n=== 当前菜单 ===");
        for (int i = 0; i < menuItems.size(); i++) {
            MenuItem item = menuItems.get(i);
            System.out.printf("%d. %s - ¥%.2f (%s)\n", 
                i, item.getName(), item.getPrice(), item.getCategory());
        }
    }
}

代码逻辑逐行解读与参数说明

第5行 ：声明私有字段 menuItems ，类型为 ArrayList<MenuItem> ，利用泛型确保只能存放 MenuItem 类型对象，避免类型转换错误。
第9–10行 ：构造函数初始化空列表，初始容量默认为10，后续会根据需要自动扩容。
第14–17行 ： add() 方法时间复杂度为 O(1)，尾部追加效率极高，适合频繁新增操作。
第21–27行 ： remove(index) 操作需移动后续元素，平均时间复杂度为 O(n)，但在菜单管理中删除频率较低，可接受。
第36–42行 ： displayMenu() 使用索引遍历，充分发挥 ArrayList 支持随机访问的优势（O(1) 访问），比链表更优。

操作	时间复杂度	适用性分析
`get(index)`	O(1)	极佳，适合展示菜单
`add(item)`	O(1) am	表现良好
`remove(index)`	O(n)	删除较少发生，可接受
`contains(item)`	O(n)	不推荐用于查找，应配合 HashMap

该结构适用于菜单这类“读多写少”、强调顺序展示的场景。若未来需支持按名称快速查询，则应引入辅助映射结构。

3.1.2 HashMap实现订单编号与订单对象的快速映射查找

当订单量上升时，系统需要根据唯一订单号快速定位订单详情。此时 HashMap 成为首选——它基于哈希表实现键值对映射，提供接近 O(1) 的查找性能。

import java.util.HashMap;
import java.util.Map;

public class OrderRegistry {
    private HashMap<String, Order> orderMap;

    public OrderRegistry() {
        this.orderMap = new HashMap<>(16); // 初始容量16，负载因子0.75
    }

    // 注册新订单
    public void registerOrder(Order order) {
        String orderId = order.getOrderId();
        orderMap.put(orderId, order);
        System.out.println("订单注册成功: " + orderId);
    }

    // 根据ID查询订单
    public Order findOrderByID(String orderId) {
        Order order = orderMap.get(orderId);
        if (order != null) {
            System.out.println("找到订单: " + orderId);
            return order;
        } else {
            System.out.println("未找到订单: " + orderId);
            return null;
        }
    }

    // 取消订单
    public boolean cancelOrder(String orderId) {
        if (orderMap.containsKey(orderId)) {
            orderMap.remove(orderId);
            System.out.println("订单已取消: " + orderId);
            return true;
        }
        System.out.println("取消失败：订单不存在");
        return false;
    }
}

代码解释与参数说明

第5行 ： HashMap<String, Order> 明确键为字符串类型的订单ID，值为订单对象，类型安全。
第9行 ：传入初始容量 16 ，避免频繁 rehash；默认负载因子 0.75 平衡空间与性能。
第14行 ： put() 方法计算 key 的 hashCode() ，定位桶位，冲突时转为链表或红黑树（JDK8+）。
第20行 ： get() 平均时间复杂度 O(1)，远优于遍历列表查找。

graph TD
    A[客户端请求查询订单] --> B{输入订单ID}
    B --> C[调用 orderMap.get(ID)]
    C --> D[计算 hashCode()]
    D --> E[定位数组下标]
    E --> F{是否存在冲突?}
    F -- 否 --> G[返回对应Value]
    F -- 是 --> H[遍历链表/树节点比对equals]
    H --> I[命中则返回Order]

上述流程图展示了 HashMap.get() 的完整工作路径，体现了其高效性的底层原理。

此外，为保证正确性，自定义类作为 Key 时必须重写 equals() 与 hashCode() 方法：

@Override
public int hashCode() {
    return Objects.hash(orderId); // 使用统一算法生成散列值
}

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Order)) return false;
    Order other = (Order) obj;
    return orderId.equals(other.orderId);
}

否则可能出现“明明相等却查不到”的问题。

3.1.3 Queue在排队叫号系统中的先进先出调度应用

咖啡店通常采用“先下单先服务”的原则，这天然契合队列（FIFO）模型。Java 中可通过 LinkedList 实现 Queue 接口完成此功能。

import java.util.LinkedList;
import java.util.Queue;

public class OrderQueue {
    private Queue<Order> pendingOrders;

    public OrderQueue() {
        this.pendingOrders = new LinkedList<>();
    }

    // 新订单入队
    public void enqueue(Order order) {
        pendingOrders.offer(order);
        System.out.println("订单进入队列: " + order.getOrderId());
    }

    // 出队处理（厨房取单）
    public Order dequeue() {
        Order order = pendingOrders.poll();
        if (order != null) {
            System.out.println("正在处理订单: " + order.getOrderId());
        } else {
            System.out.println("当前无待处理订单");
        }
        return order;
    }

    // 查看队首订单（预览下一单）
    public Order peekNext() {
        return pendingOrders.peek();
    }

    // 获取当前队列长度
    public int size() {
        return pendingOrders.size();
    }
}

方法对比与性能分析

方法	是否抛异常	返回null行为	适用场景
`add()` / `remove()`	是	失败抛异常	要求严格响应
`offer()` / `poll()`	否	失败返回null	推荐，更安全
`element()` / `peek()`	是 / 否	分别抛异常或返回null	安全查看头部

推荐使用 offer/poll/peek 组合，增强鲁棒性。

sequenceDiagram
    participant Customer
    participant GUI
    participant OrderQueue

    Customer->>GUI: 提交订单
    GUI->>OrderQueue: enqueue(order)
    OrderQueue-->>GUI: 入队成功
    GUI->>Customer: 显示排队号码

    Note right of OrderQueue: FIFO顺序保存

    loop 厨房轮询
        Kitchen->>OrderQueue: dequeue()
        alt 有订单
            OrderQueue-->>Kitchen: 返回订单
        else 无订单
            OrderQueue-->>Kitchen: 返回null
        end
    end

该图示清晰表达了订单从提交到被消费的生命周期流转过程。

3.1.4 Stack在撤销操作或历史记录回溯中的使用

尽管 Java 中已有 Deque 更通用，但 Stack 仍可用于实现简单的“撤销”功能，比如撤回刚添加的商品项。

import java.util.Stack;

public class OrderUndoManager {
    private Stack<OrderItem> addedItems; // 记录最近添加的项目

    public OrderUndoManager() {
        this.addedItems = new Stack<>();
    }

    // 添加商品并记录
    public void addItem(OrderItem item) {
        addedItems.push(item);
        System.out.println("商品加入订单: " + item.getName());
    }

    // 撤销最后一次添加
    public OrderItem undoLastAdd() {
        if (!addedItems.isEmpty()) {
            OrderItem undone = addedItems.pop();
            System.out.println("已撤销商品: " + undone.getName());
            return undone;
        } else {
            System.out.println("无可撤销操作");
            return null;
        }
    }

    // 查看上次添加的是什么
    public OrderItem getLastAdded() {
        if (!addedItems.isEmpty()) {
            return addedItems.peek();
        }
        return null;
    }
}

虽然 Stack 继承自 Vector ，线程安全但性能略低，建议生产环境中改用 Deque ：

Deque<OrderItem> stack = new ArrayDeque<>();
stack.push(item);   // 入栈
stack.pop();        // 出栈
stack.peek();       // 查看栈顶

这种方式性能更高，且 API 更现代。

3.2 数据结构与业务逻辑的耦合设计

数据结构不应孤立存在，而应深度融入业务逻辑之中。良好的设计应当让数据结构服务于业务语义，而非反过来让业务迁就数据形式。本节将讨论如何通过泛型、迭代器与并发控制手段，实现松耦合、高内聚的系统架构。

3.2.1 订单队列的并发访问控制问题探讨

在多线程环境下，多个服务员可能同时提交订单，厨房线程也在不断取单处理。此时共享的 OrderQueue 若未加同步，极易引发竞态条件。

考虑如下非线程安全场景：

// 危险！多线程并发修改可能导致结构性破坏
new Thread(() -> queue.enqueue(new Order("O001"))).start();
new Thread(() -> queue.enqueue(new Order("O002"))).start();
new Thread(() -> queue.dequeue()).start();

解决方案包括：

使用线程安全替代品 ：
java Queue<Order> safeQueue = new ConcurrentLinkedQueue<>(); // 无锁高性能队列 BlockingQueue<Order> blockingQueue = new LinkedBlockingQueue<>(100); // 支持阻塞操作
手动同步关键代码段 ：
java public synchronized Order dequeue() { return pendingOrders.poll(); }
使用 Collections.synchronizedList/map/queue 包装 ：
java Queue<Order> syncQueue = Collections.synchronizedQueue(new LinkedList<>());

注意：即使包装后，复合操作（如检查再删除）仍需外部同步。

推荐优先使用 java.util.concurrent 包提供的专用工具类，如 ConcurrentHashMap 、 CopyOnWriteArrayList 等，它们针对常见并发场景做了高度优化。

3.2.2 利用泛型提升集合操作的安全性与可读性

泛型（Generics）是 Java 5 引入的重要特性，允许在编译期进行类型检查，消除强制类型转换带来的运行时异常。

对比以下两种写法：

// 原始类型（不推荐）
List menuList = new ArrayList();
menuList.add(new MenuItem("拿铁", 28.0));
MenuItem item = (MenuItem) menuList.get(0); // 强制转型，易出错

// 泛型版本（推荐）
List<MenuItem> menuList = new ArrayList<>();
menuList.add(new MenuItem("拿铁", 28.0));
MenuItem item = menuList.get(0); // 无需转型，类型安全

泛型还能支持通配符与边界限定，进一步增强灵活性：

// 上界通配符：接受 MenuItem 或其子类的集合
public void printMenu(List<? extends MenuItem> items) {
    for (MenuItem item : items) {
        System.out.println(item.getName());
    }
}

// 下界通配符：可用于添加操作
public void addSpecialItems(List<? super SpecialMenuItem> dest) {
    dest.add(new SpecialMenuItem("节日特饮", 35.0));
}

这使得组件之间解耦更强，API 更清晰。

3.2.3 迭代器模式遍历集合元素的最佳实践

直接使用 for-i 循环遍历集合虽直观，但在删除元素时容易出现 ConcurrentModificationException 。正确的做法是使用 Iterator ：

Iterator<Order> it = orderMap.values().iterator();
while (it.hasNext()) {
    Order order = it.next();
    if (order.isCompleted()) {
        it.remove(); // 安全删除
    }
}

或者使用增强 for-each 循环配合 removeIf() ：

orderMap.values().removeIf(Order::isCompleted);

两者都基于 Iterator 实现，避免了 fail-fast 机制触发异常。

此外， Iterable 接口使得自定义类也能被 for-each 遍历，提高一致性：

public class Cafe implements Iterable<MenuItem> {
    private List<MenuItem> items;

    @Override
    public Iterator<MenuItem> iterator() {
        return items.iterator();
    }
}

Cafe cafe = new Cafe();
for (MenuItem item : cafe) { // 支持增强for循环
    System.out.println(item.getName());
}

3.3 性能考量与内存使用优化

数据结构的选择不仅关乎功能实现，更直接影响系统的响应速度与资源消耗。开发者必须具备基本的时间/空间复杂度分析能力，才能做出科学决策。

3.3.1 不同数据结构的时间复杂度比较分析

下表总结了常用操作在主要集合类中的表现：

结构	插入	删除	查找	遍历	有序性	线程安全
`ArrayList`	O(n) avg	O(n) avg	O(n)	O(n)	保持插入序	否
`LinkedList`	O(1) head/tail	O(1) known node	O(n)	O(n)	保持插入序	否
`HashMap`	O(1) avg	O(1) avg	O(1) avg	O(n)	无序（JDK8+ treeify）	否
`LinkedHashMap`	O(1)	O(1)	O(1)	O(n)	保持插入/访问序	否
`TreeMap`	O(log n)	O(log n)	O(log n)	O(n)	键排序	否
`PriorityQueue`	O(log n)	O(log n)	O(n)	O(n)	按优先级排序	否

在 Java Cafe 中，若需按下单时间排序显示订单，可选用 LinkedHashMap ；若要实现VIP优先处理，则可用 PriorityQueue<Order> 自定义比较器。

PriorityQueue<Order> priorityQueue = new PriorityQueue<>((o1, o2) -> {
    if (o1.isVip() && !o2.isVip()) return -1;
    if (!o1.isVip() && o2.isVip()) return 1;
    return Long.compare(o1.getTimestamp(), o2.getTimestamp()); // 时间先后
});

3.3.2 避免内存泄漏的关键编码规范

不当使用集合可能导致对象无法被 GC 回收，造成内存泄漏。常见情况包括：

长生命周期集合持有短生命周期对象引用
监听器未注销导致对象滞留
缓存未设置上限

示例：全局订单注册表未清理已完成订单：

// 错误示范
private static final Map<String, Order> ALL_ORDERS = new HashMap<>();

// 正确做法：定期归档或使用弱引用
private static final Map<String, Order> ACTIVE_ORDERS = new HashMap<>();
private static final Queue<Order> COMPLETED_ARCHIVE = new LinkedList<>();

// 处理完成后转移并释放引用
public void completeOrder(String id) {
    Order order = ACTIVE_ORDERS.remove(id);
    if (order != null) {
        COMPLETED_ARCHIVE.offer(order);
        trimArchive(); // 控制归档大小
    }
}

还可结合 WeakHashMap 实现基于垃圾回收的自动清理机制。

3.4 实战演练：实现一个可扩展的订单管理中心

综合前述知识，构建一个完整的 OrderCenter 模块，整合多种数据结构，提供统一接口。

public class OrderCenter {
    private final Map<String, Order> orderIndex;     // 快速查找
    private final Queue<Order> orderQueue;           // 排队处理
    private final List<Order> recentOrders;          // 最近订单记录
    private AtomicInteger sequence;                  // 订单编号生成器

    public OrderCenter() {
        this.orderIndex = new ConcurrentHashMap<>(); // 线程安全
        this.orderQueue = new LinkedBlockingQueue<>();
        this.recentOrders = new CopyOnWriteArrayList<>();
        this.sequence = new AtomicInteger(1000);
    }

    public String generateOrderId() {
        return "ORD" + sequence.getAndIncrement();
    }

    public void submitOrder(Order order) {
        String id = generateOrderId();
        order.setOrderId(id);

        orderIndex.put(id, order);
        orderQueue.offer(order);
        recentOrders.add(0, order); // 最新的放前面

        System.out.println("订单提交成功: " + id);
    }

    public Order processNextOrder() {
        Order order = orderQueue.poll();
        if (order != null) {
            order.markAsProcessing();
            return order;
        }
        return null;
    }

    public Order getOrderByID(String id) {
        return orderIndex.get(id);
    }

    public int getPendingCount() {
        return orderQueue.size();
    }
}

该中心实现了：
- 唯一 ID 生成
- 多结构协同（索引 + 队列 + 列表）
- 线程安全保障
- 高效查询与调度

真正做到了“一次设计，处处可用”，为系统演进预留充足空间。

4. 异常处理机制与文件持久化操作

在现代软件系统中，稳定性和数据可靠性是衡量一个应用成熟度的核心指标。Java Cafe原型系统作为一款模拟真实业务流程的桌面级管理工具，不仅要保证用户交互的流畅性，还必须具备对运行时错误的有效响应能力以及关键业务数据的长期保存机制。本章将深入探讨Java中的异常处理体系如何为系统提供健壮的容错能力，并结合文件I/O技术实现订单记录、配置信息等重要数据的本地持久化存储。通过合理设计异常捕获策略与持久化方案，Java Cafe能够在程序崩溃或重启后依然保留核心业务状态，从而提升整体可用性。

异常处理不仅是代码健壮性的保障手段，更是系统设计层面的重要考量。当用户输入非法数据、文件读写失败或网络连接中断时，若缺乏有效的异常管理机制，整个应用程序可能因一次未被捕获的异常而终止运行。因此，理解Java异常分类体系及其控制结构，掌握自定义异常的设计方法，成为构建高可用系统的必备技能。与此同时，仅依赖内存中的数据结构（如ArrayList、HashMap）来维护订单和菜单信息显然无法满足实际需求——一旦程序关闭，所有数据都将丢失。为此，引入基于文本文件的持久化机制成为必要补充，它使得系统可以在启动时加载历史数据，在运行过程中持续记录变更，并在发生故障时提供恢复依据。

本章内容由浅入深地展开：首先解析Java异常模型的基本构成，包括检查型异常与非检查型异常的区别、 try-catch-finally 语句块的工作机制；随后介绍如何构建用户友好的错误提示系统，利用自定义异常封装业务逻辑错误并配合日志输出增强调试能力；接着重点讲解文件I/O操作的具体实现方式，涵盖路径管理、配置文件读取与订单日志写入等典型场景；最后讨论当前文本文件存储方案的技术局限，并提出向数据库迁移的数据格式准备方向，为后续章节引入JDBC打下基础。

4.1 异常分类体系与try-catch-finally语句结构

Java的异常处理机制建立在一个完整的类继承体系之上，其核心目标是在程序出现运行时问题时，能够以可控的方式中断执行流并进行相应处理，而不是直接导致虚拟机崩溃。该机制围绕 Throwable 类展开，所有可抛出的异常或错误都直接或间接继承自这一基类。 Throwable 有两个主要子类： Error 和 Exception ，分别代表系统级严重错误和程序可恢复的异常情况。其中， Exception 又进一步划分为 检查型异常（checked exception） 和 非检查型异常（unchecked exception） ，这种区分直接影响编译器的行为和开发者的编码习惯。

检查型异常是指那些在编译期就必须被显式处理的异常类型，例如 IOException 、 SQLException 等。这类异常通常表示外部资源访问失败或环境问题，比如文件不存在、网络断开等。Java要求开发者在调用可能抛出此类异常的方法时，要么使用 try-catch 语句捕获，要么在方法签名中通过 throws 关键字声明向上抛出。这种强制性机制促使程序员提前考虑潜在风险，增强了程序的健壮性。相反，非检查型异常继承自 RuntimeException ，如 NullPointerException 、 ArrayIndexOutOfBoundsException 等，它们通常由编程逻辑错误引起，编译器不强制要求处理，但一旦发生往往意味着代码缺陷。

为了有效管理异常流程，Java提供了 try-catch-finally 语句结构。 try 块用于包裹可能抛出异常的代码段；一个或多个 catch 块用于捕获特定类型的异常并执行对应的恢复逻辑；而 finally 块则无论是否发生异常都会被执行，常用于释放资源，如关闭文件流、数据库连接等。值得注意的是， finally 块的存在意义在于确保清理操作不会因为异常跳转而被跳过，这是保证资源安全的关键环节。

下面通过一段典型的文件读取操作示例展示该结构的实际应用：

import java.io.*;

public class FileReaderExample {
    public static void readFile(String filePath) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(filePath));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到：" + e.getMessage());
        } catch (IOException e) {
            System.err.println("读取文件时发生IO异常：" + e.getMessage());
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    System.err.println("关闭流时出错：" + e.getMessage());
                }
            }
        }
    }
}

代码逻辑逐行解读与参数说明

第5行 ：声明一个 BufferedReader 对象 reader ，初始值为 null 。由于需要在 finally 块中访问该对象以关闭资源，故需将其作用域提升至 try 块之外。
第6-10行 ： try 块中尝试打开指定路径的文件并逐行读取内容。 new FileReader(filePath) 构造函数可能抛出 FileNotFoundException ，而 readLine() 方法可能抛出 IOException 。
第11-13行 ：第一个 catch 块专门捕获 FileNotFoundException ，表明文件路径无效或文件不存在。此时应提示用户具体错误原因。
第14-16行 ：第二个 catch 块捕获更广泛的 IOException ，覆盖其他I/O相关问题，如权限不足、磁盘损坏等。两个 catch 块的顺序遵循“子类在前，父类在后”的原则，避免父类异常掩盖子类。
第17-23行 ： finally 块确保无论是否发生异常， reader 都会被关闭。即使 close() 方法本身也可能抛出 IOException ，因此仍需嵌套 try-catch 进行防护。

异常类型	是否检查型	常见触发场景	处理建议
`FileNotFoundException`	是	文件路径错误或文件不存在	检查路径是否存在，提示用户重新输入
`IOException`	是	读写过程中发生I/O错误	记录日志，尝试重试或终止操作
`NullPointerException`	否	对象引用为空时调用方法	提前判空，使用Optional优化
`IllegalArgumentException`	否	方法接收到非法参数	抛出自定义异常并提示正确格式

此外，Java 7引入了 try-with-resources 语法，可以自动管理实现了 AutoCloseable 接口的资源，极大简化了代码：

public static void readFileWithTryResources(String filePath) {
    try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        System.err.println("读取文件失败：" + e.getMessage());
    }
}

上述代码无需手动关闭流，JVM会在 try 块结束时自动调用 close() 方法，且即使 try 块内部抛出异常也能保证资源释放。这不仅减少了样板代码，也降低了资源泄漏的风险。

graph TD
    A[程序执行] --> B{是否发生异常?}
    B -- 否 --> C[正常执行完毕]
    B -- 是 --> D[查找匹配的catch块]
    D --> E{是否存在对应异常处理器?}
    E -- 是 --> F[执行catch中的恢复逻辑]
    E -- 否 --> G[异常继续向上抛出]
    F --> H[执行finally块]
    G --> H
    H --> I[程序退出或交由上层处理]

该流程图清晰展示了异常传播路径及 finally 块的执行时机。无论异常是否被捕获，只要进入了 try 块， finally 都会执行，除非JVM进程被强制终止或发生 System.exit() 调用。

综上所述，合理的异常结构设计不仅能防止程序意外崩溃，还能提高系统的可观测性与可维护性。在Java Cafe系统中，这一机制被广泛应用于文件读写、用户输入验证、网络通信等多个模块，确保每个潜在故障点都有相应的兜底策略。

4.2 用户友好型错误提示机制构建

在图形化应用程序中，异常不应仅仅表现为控制台打印的一串堆栈信息，而应转化为用户可理解的反馈。特别是在Java Cafe这样的终端管理系统中，收银员或店长可能不具备编程背景，他们需要的是明确的操作指引而非技术术语。因此，构建一套兼顾用户体验与开发调试需求的错误提示机制至关重要。该机制应当包含两个通道：一是面向用户的弹窗提示，简洁明了地说明问题及解决方案；二是后台日志记录，详细保存异常上下文以便后期排查。

4.2.1 自定义异常类封装业务错误信息

标准异常类虽然通用，但难以表达特定业务含义。例如，“订单编号重复”、“库存不足”、“支付金额小于应付总额”等问题属于领域逻辑错误，使用 IllegalArgumentException 虽可行，但语义模糊。为此，应创建专门的自定义异常类来增强代码可读性与错误分类能力。

// 定义业务异常基类
public class CafeBusinessException extends Exception {
    private final String errorCode;

    public CafeBusinessException(String message, String errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    public String getErrorCode() {
        return errorCode;
    }
}

// 具体异常实现
public class OrderNotFoundException extends CafeBusinessException {
    public OrderNotFoundException(String orderId) {
        super("未找到订单：" + orderId, "ORDER_NOT_FOUND");
    }
}

public class InsufficientStockException extends CafeBusinessException {
    private final String productName;

    public InsufficientStockException(String productName, int available) {
        super("商品【" + productName + "】库存不足，当前仅剩" + available + "件", "INSUFFICIENT_STOCK");
        this.productName = productName;
    }

    public String getProductName() {
        return productName;
    }
}

参数说明与设计意图分析

errorCode 字段用于标识错误类型，便于前端根据编码显示不同提示语或触发特定行为（如自动跳转到补货界面）。
继承自 Exception 而非 RuntimeException ，表示这些是预期中可能出现的业务异常，调用方应主动处理。
构造函数中传入具体参数（如 orderId 、 productName ），使异常消息更具上下文信息，有助于快速定位问题。

此类异常可在服务层抛出，并由GUI控制器捕获后转换为可视化提示：

private void completeOrder(String orderId) {
    try {
        orderService.complete(orderId);
        JOptionPane.showMessageDialog(this, "订单已完成！", "成功", JOptionPane.INFORMATION_MESSAGE);
    } catch (OrderNotFoundException e) {
        JOptionPane.showMessageDialog(this, e.getMessage(), "订单错误", JOptionPane.WARNING_MESSAGE);
    } catch (CafeBusinessException e) {
        JOptionPane.showMessageDialog(this, "操作失败：" + e.getMessage(), "业务异常", JOptionPane.ERROR_MESSAGE);
    } catch (Exception e) {
        JOptionPane.showMessageDialog(this, "系统内部错误，请联系管理员", "未知错误", JOptionPane.ERROR_MESSAGE);
        Logger.getLogger(OrderFrame.class.getName()).severe("Unexpected error: " + e.getMessage());
    }
}

4.2.2 弹窗提示与日志输出双通道反馈设计

为实现双通道反馈，需整合Swing的 JOptionPane 组件与Java内置的日志框架 java.util.logging 。以下是一个统一的异常处理器示例：

import java.util.logging.*;

public class ExceptionHandler {
    private static final Logger logger = Logger.getLogger(ExceptionHandler.class.getName());

    static {
        setupLogger();
    }

    private static void setupLogger() {
        FileHandler fileHandler;
        try {
            fileHandler = new FileHandler("logs/app.log", true); // 追加模式
            SimpleFormatter formatter = new SimpleFormatter();
            fileHandler.setFormatter(formatter);
            logger.addHandler(fileHandler);
            logger.setLevel(Level.ALL);
        } catch (IOException e) {
            System.err.println("无法初始化日志处理器：" + e.getMessage());
        }
    }

    public static void handle(Exception e, Component parentComponent) {
        String userMessage;
        if (e instanceof CafeBusinessException) {
            userMessage = e.getMessage();
            logger.warning("业务异常：" + e.getClass().getSimpleName() + " | Code: " +
                    ((CafeBusinessException)e).getErrorCode() + " | Message: " + e.getMessage());
        } else {
            userMessage = "系统发生未知错误，请查看日志文件获取详情。";
            logger.severe("未处理异常：" + e.getClass().getName() + "\n" + getStackTraceAsString(e));
        }

        JOptionPane.showMessageDialog(parentComponent, userMessage,
                "错误提示", JOptionPane.ERROR_MESSAGE);
    }

    private static String getStackTraceAsString(Throwable t) {
        StringBuilder sb = new StringBuilder();
        for (StackTraceElement element : t.getStackTrace()) {
            sb.append("\tat ").append(element.toString()).append("\n");
        }
        return sb.toString();
    }
}

该类实现了集中式异常处理逻辑，既保证了UI一致性，又完成了详细的日志归档。每次异常发生时，都会在 logs/app.log 中追加记录，内容如下所示：

May 22, 2025 3:15:22 PM com.javacafe.ExceptionHandler handle
WARNING: 业务异常：InsufficientStockException | Code: INSUFFICIENT_STOCK | Message: 商品【拿铁咖啡】库存不足，当前仅剩0件

反馈通道	使用场景	技术实现	优点
GUI弹窗	即时告知用户操作结果	`JOptionPane.showMessageDialog()`	直观、阻塞性强
日志文件	开发调试与事后审计	`FileHandler + Logger`	持久化、支持搜索分析
控制台输出	快速开发阶段辅助	`System.err.println()`	简单快捷，但不适合生产环境

sequenceDiagram
    participant User as 用户
    participant GUI as 图形界面
    participant Service as 业务服务
    participant Logger as 日志系统

    User->>GUI: 提交订单
    GUI->>Service: 调用completeOrder()
    alt 库存充足
        Service-->>GUI: 返回成功
        GUI-->>User: 显示“完成”提示
    else 库存不足
        Service->>Logger: 记录警告级别日志
        Logger-->>Service: 确认写入
        Service->>GUI: 抛出InsufficientStockException
        GUI->>User: 弹出库存不足警告
    end

该序列图展示了异常从产生到反馈的完整生命周期。通过分层处理机制，系统实现了职责分离：业务层专注逻辑判断，表现层负责交互呈现，日志系统承担追踪职责。这种架构不仅提升了代码可维护性，也为未来的监控报警系统预留了扩展接口。

4.3 文件I/O操作在本地数据保存中的应用

对于Java Cafe这类轻量级管理系统而言，在尚未接入数据库之前，采用文件系统进行数据持久化是一种低成本且高效的过渡方案。通过对菜单配置、历史订单、营业统计等信息的定期写入与读取，系统可在重启后恢复上次运行状态，避免数据丢失。本节将详细介绍如何利用Java标准库中的 File 、 Scanner 、 PrintWriter 等类完成本地持久化功能的实现。

4.3.1 使用File类进行路径管理与目录创建

在进行任何文件操作前，必须确保目标路径存在且具有读写权限。 java.io.File 类提供了跨平台的路径抽象与目录管理能力。

public class DataFileInitializer {
    private static final String BASE_DIR = "data";
    private static final String ORDERS_FILE = BASE_DIR + "/orders.txt";
    private static final String MENU_FILE = BASE_DIR + "/menu.csv";

    public static void initDirectories() throws IOException {
        File baseDir = new File(BASE_DIR);
        if (!baseDir.exists()) {
            if (baseDir.mkdirs()) {
                System.out.println("创建数据目录：" + BASE_DIR);
            } else {
                throw new IOException("无法创建目录：" + BASE_DIR);
            }
        }

        File ordersFile = new File(ORDERS_FILE);
        if (!ordersFile.exists()) {
            if (ordersFile.createNewFile()) {
                System.out.println("创建订单文件：" + ORDERS_FILE);
            } else {
                throw new IOException("无法创建文件：" + ORDERS_FILE);
            }
        }
    }
}

该初始化方法在系统启动时调用，确保所需目录与文件均已就绪。 mkdirs() 会递归创建所有缺失的父目录，适合多层结构场景。

4.3.2 Scanner读取配置文件或历史订单记录

假设菜单信息以CSV格式存储，每行包含饮品名称、价格、库存三项：

美式咖啡,25.0,100
拿铁咖啡,30.0,80
卡布奇诺,28.0,90

可通过 Scanner 按行解析：

public List<Drink> loadMenuFromCSV() {
    List<Drink> drinks = new ArrayList<>();
    File file = new File(MENU_FILE);
    if (!file.exists()) {
        return drinks; // 返回空列表
    }

    try (Scanner scanner = new Scanner(file)) {
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine().trim();
            if (line.isEmpty() || line.startsWith("#")) continue; // 忽略空行和注释

            String[] parts = line.split(",");
            if (parts.length != 3) continue;

            String name = parts[0].trim();
            double price = Double.parseDouble(parts[1].trim());
            int stock = Integer.parseInt(parts[2].trim());

            drinks.add(new Drink(name, price, stock));
        }
    } catch (FileNotFoundException e) {
        Logger.getLogger(DataManager.class.getName()).severe("菜单文件未找到：" + e.getMessage());
    } catch (NumberFormatException e) {
        Logger.getLogger(DataManager.class.getName()).warning("数值格式错误：" + e.getMessage());
    }
    return drinks;
}

此方法具备良好的容错性，能跳过格式不正确的行而不中断整体加载过程。

4.3.3 PrintWriter实现订单日志的追加写入功能

每当完成一笔订单，应将其摘要写入日志文件，便于后续统计与审计：

public void logOrder(Order order) {
    File file = new File(ORDERS_FILE);
    try (PrintWriter writer = new PrintWriter(new FileOutputStream(file, true))) {
        String entry = String.format("%d,%s,%.2f,%s",
                order.getId(),
                order.getDrinkName(),
                order.getTotalPrice(),
                order.getTimestamp().toString()
        );
        writer.println(entry);
    } catch (IOException e) {
        Logger.getLogger(OrderLogger.class.getName()).severe("写入订单日志失败：" + e.getMessage());
    }
}

其中 new FileOutputStream(file, true) 的第二个参数 true 表示启用追加模式，新内容将添加到文件末尾而非覆盖原内容。

操作类型	类/方法	是否自动刷新	适用场景
读取文本	`Scanner`	否	解析结构化文本文件
写入文本	`PrintWriter`	可设置 `autoFlush`	日志记录、简单数据导出
二进制读写	`FileInputStream/FileOutputStream`	否	图片、音频等非文本数据

flowchart LR
    A[系统启动] --> B{数据目录存在?}
    B -- 否 --> C[创建data/目录]
    C --> D[创建orders.txt/menu.csv]
    B -- 是 --> E[读取menu.csv加载菜单]
    E --> F[显示主界面]
    F --> G[用户下单]
    G --> H[调用logOrder()]
    H --> I[追加写入orders.txt]

该流程图描绘了从初始化到持久化的完整数据流动路径。通过这套机制，Java Cafe实现了基本的数据保全能力，为后续向数据库迁移奠定了坚实基础。

5. JDBC数据库连接与多线程并发处理

在现代企业级应用中，系统的数据持久化能力与高并发处理性能是衡量其成熟度的重要指标。Java Cafe原型系统作为一款模拟真实咖啡店运营场景的桌面应用程序，不仅要实现菜单管理、订单提交等基础功能，还需确保这些操作的数据能够长期可靠地存储，并在多用户或高频操作环境下保持稳定响应。为此，本章将深入探讨如何通过JDBC技术实现与关系型数据库的高效对接，并结合Java多线程机制提升后台任务的并发执行效率。

随着业务规模的增长，仅依赖文件I/O进行数据持久化已无法满足一致性、查询效率和事务控制的需求。因此，引入结构化数据库成为必然选择。JDBC（Java Database Connectivity）作为Java平台标准的数据库访问API，提供了统一的接口规范，使得Java Cafe可以灵活对接MySQL、SQLite等多种数据库引擎。与此同时，订单处理、库存更新、状态推送等操作往往需要异步执行以避免阻塞UI主线程，这就要求系统具备良好的多线程支持能力。本章将围绕这两个核心技术点展开，构建一个既安全又高效的后端运行环境。

5.1 JDBC编程模型与MySQL/SQLite数据库对接

JDBC是Java平台上用于连接和操作数据库的标准API，它定义了一套通用的接口和类，屏蔽了不同数据库厂商之间的差异，使开发者能够在不修改核心代码的前提下切换底层数据库。在Java Cafe系统中，使用JDBC不仅提升了数据存储的可靠性，还为后续可能的数据库迁移（如从SQLite过渡到MySQL）提供了技术保障。

5.1.1 DriverManager获取连接的基本流程

要实现Java程序与数据库的通信，首要步骤是建立数据库连接。 DriverManager 类是JDBC中最基础的连接管理工具，负责加载合适的驱动并返回 Connection 对象。该过程通常包含以下几个关键环节：

注册数据库驱动 ：通过 Class.forName() 显式加载驱动类；
获取连接 ：调用 DriverManager.getConnection(url, username, password) 方法；
异常处理 ：捕获 SQLException 以防连接失败；
资源释放 ：使用try-with-resources语句自动关闭连接。

以下是一个典型的数据库连接示例代码：

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

public class DatabaseConnector {
    private static final String URL = "jdbc:sqlite:./data/cafe.db"; // SQLite数据库路径
    private static final String USER = "";
    private static final String PASSWORD = "";

    public static Connection getConnection() throws SQLException {
        try {
            Class.forName("org.sqlite.JDBC"); // 显式加载SQLite驱动
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("SQLite JDBC驱动未找到", e);
        }
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }
}

代码逻辑逐行解读分析：

第7行：定义数据库URL，采用SQLite的本地文件协议 jdbc:sqlite: ，指向项目根目录下的 data/cafe.db 。
第10–12行：由于SQLite驱动不在JDK默认类路径中，需通过 Class.forName() 动态加载。若未引入对应JAR包，会抛出 ClassNotFoundException 。
第15行： DriverManager.getConnection() 根据URL识别协议类型，调用匹配的驱动创建连接实例。
整个方法声明抛出 SQLException ，便于上层调用者统一处理连接异常。

参数	说明
`URL`	数据库连接地址，格式为 `jdbc:<subprotocol>:<subname>`
`USER`	登录用户名（SQLite无需认证，留空）
`PASSWORD`	登录密码（同上）

注意：对于MySQL数据库，URL应类似 jdbc:mysql://localhost:3306/cafe_db ，并需提供有效的用户名和密码。

graph TD
    A[启动Java应用] --> B{是否已加载JDBC驱动?}
    B -->|否| C[执行Class.forName()]
    B -->|是| D[调用DriverManager.getConnection()]
    C --> D
    D --> E[返回Connection对象]
    E --> F[执行SQL操作]
    F --> G[关闭连接释放资源]

此流程图清晰展示了JDBC连接建立的完整生命周期，强调了驱动加载与连接获取的先后顺序。

5.1.2 PreparedStatement防止SQL注入攻击

直接拼接字符串构造SQL语句存在严重的安全风险——SQL注入。例如，当用户输入 " OR '1'='1" 作为用户名时，可能导致非授权访问。为解决这一问题，JDBC提供了 PreparedStatement 接口，它预编译SQL模板并通过占位符（ ? ）传参，从根本上杜绝恶意代码注入。

以下是使用 PreparedStatement 插入新订单的代码示例：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class OrderDAO {
    private static final String INSERT_ORDER_SQL = 
        "INSERT INTO orders (order_id, customer_name, total_price, status, create_time) VALUES (?, ?, ?, ?, ?)";

    public void insertOrder(Order order) throws SQLException {
        try (Connection conn = DatabaseConnector.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(INSERT_ORDER_SQL)) {

            pstmt.setString(1, order.getOrderId());
            pstmt.setString(2, order.getCustomerName());
            pstmt.setDouble(3, order.getTotalPrice());
            pstmt.setString(4, order.getStatus());
            pstmt.setTimestamp(5, new Timestamp(order.getCreateTime().getTime()));

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected + " 行被插入.");
        }
    }
}

代码逻辑逐行解读分析：

第6行：定义带参数占位符的SQL语句，所有值均用 ? 代替；
第10–11行：使用try-with-resources自动管理 Connection 和 PreparedStatement 的关闭；
第13–17行：通过 setXxx(index, value) 方法按位置设置参数值，类型安全且防注入；
第19行：调用 executeUpdate() 执行INSERT语句，返回受影响行数。

方法	功能说明
`setString(int, String)`	设置字符串参数
`setDouble(int, double)`	设置浮点数值
`setTimestamp(int, Timestamp)`	设置时间戳字段

相比 Statement ， PreparedStatement 的优势还包括：
- 预编译提升执行效率（尤其在批量操作中）；
- 支持批处理（ addBatch() / executeBatch() ）；
- 自动转义特殊字符，增强安全性。

5.1.3 ResultSet结果集解析与对象映射

执行查询语句后，数据库返回的结果封装在 ResultSet 对象中。该对象以游标形式遍历每一行数据，开发者可通过 getXxx(columnIndex|columnName) 方法提取字段值，并将其映射为Java对象（即ORM雏形）。

以下是从数据库读取所有待处理订单的实现：

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public List<Order> findPendingOrders() throws SQLException {
    List<Order> orders = new ArrayList<>();
    String sql = "SELECT order_id, customer_name, total_price, status, create_time FROM orders WHERE status = 'PENDING'";

    try (Connection conn = DatabaseConnector.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql);
         ResultSet rs = pstmt.executeQuery()) {

        while (rs.next()) {
            Order order = new Order();
            order.setOrderId(rs.getString("order_id"));
            order.setCustomerName(rs.getString("customer_name"));
            order.setTotalPrice(rs.getDouble("total_price"));
            order.setStatus(rs.getString("status"));
            order.setCreateTime(new Date(rs.getTimestamp("create_time").getTime()));
            orders.add(order);
        }
    }
    return orders;
}

代码逻辑逐行解读分析：

第8行：SQL查询筛选状态为”PENDING”的订单；
第12行：调用 executeQuery() 获得只读结果集；
第14–21行：循环读取每条记录，利用列名获取字段值并填充至 Order 对象；
最终返回订单列表供前端展示。

ResultSet方法	对应Java类型
`getString()`	String
`getInt()`	int
`getDouble()`	double
`getTimestamp()`	java.sql.Timestamp

该过程体现了“数据-对象”映射的核心思想，虽未使用框架，但已具备轻量级DAO模式的基础形态。

5.2 数据库表结构设计与CRUD操作封装

合理的数据库建模是系统可维护性和扩展性的基石。在Java Cafe中，主要涉及三张核心表：菜单项表、订单主表以及订单明细表。通过规范化设计减少冗余，同时借助DAO（Data Access Object）模式解耦数据访问逻辑与业务逻辑，提升代码复用性与测试便利性。

5.2.1 菜单表、订单表、用户表的关系建模

根据业务需求，设计如下ER模型：

erDiagram
    MENU ||--o{ ORDER_ITEM : contains
    ORDERS ||--o{ ORDER_ITEM : has
    CUSTOMER ||--o{ ORDERS : places

    MENU {
        string item_id PK
        string name
        double price
        string category
    }

    ORDERS {
        string order_id PK
        string customer_id FK
        double total_price
        string status
        datetime create_time
    }

    ORDER_ITEM {
        int item_line_id PK
        string order_id FK
        string item_id FK
        int quantity
    }

    CUSTOMER {
        string customer_id PK
        string name
        string phone
        string email
    }

上述ER图展示了实体间的关联关系：
- 一个订单包含多个订单项（一对多）；
- 每个订单项对应一种菜单项；
- 客户可下多个订单。

对应的建表SQL语句如下（以SQLite为例）：

CREATE TABLE IF NOT EXISTS menu (
    item_id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    price REAL NOT NULL,
    category TEXT CHECK(category IN ('COFFEE', 'TEA', 'DESSERT'))
);

CREATE TABLE IF NOT EXISTS customers (
    customer_id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    phone TEXT,
    email TEXT UNIQUE
);

CREATE TABLE IF NOT EXISTS orders (
    order_id TEXT PRIMARY KEY,
    customer_id TEXT,
    total_price REAL NOT NULL,
    status TEXT DEFAULT 'PENDING',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

CREATE TABLE IF NOT EXISTS order_items (
    item_line_id INTEGER PRIMARY KEY AUTOINCREMENT,
    order_id TEXT,
    item_id TEXT,
    quantity INTEGER NOT NULL,
    FOREIGN KEY (order_id) REFERENCES orders(order_id),
    FOREIGN KEY (item_id) REFERENCES menu(item_id)
);

该设计遵循第三范式（3NF），避免数据重复，支持高效索引与外键约束。

5.2.2 DAO模式分离数据访问逻辑与业务逻辑

DAO模式通过抽象出独立的数据访问层，将数据库操作集中管理，降低业务模块对具体实现的依赖。以 MenuDAO 为例：

public interface MenuDAO {
    List<Menu> findAll();
    Menu findById(String itemId);
    void save(Menu menu);
    void update(Menu menu);
    void delete(String itemId);
}

public class MenuDAOImpl implements MenuDAO {
    @Override
    public List<Menu> findAll() {
        // 查询全部菜单项
    }

    @Override
    public Menu findById(String itemId) {
        // 根据ID查找菜单项
    }

    // 其他方法略...
}

这种分层架构使得未来更换数据库或引入缓存机制时，只需替换DAO实现而不影响上层服务。

5.3 多线程在订单处理中的并发支持

GUI应用程序必须保证界面响应流畅，任何耗时操作（如数据库写入、网络请求）都应移出主线程。Java Cafe通过多线程机制实现订单异步处理，提升用户体验。

5.3.1 Thread类与Runnable接口创建工作线程

最基础的方式是继承 Thread 或实现 Runnable 接口：

public class OrderProcessingTask implements Runnable {
    private final Order order;

    public OrderProcessingTask(Order order) {
        this.order = order;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(2000); // 模拟处理延迟
            System.out.println("订单 " + order.getOrderId() + " 已处理完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 使用方式
new Thread(new OrderProcessingTask(order)).start();

尽管简单，但频繁创建线程会造成资源浪费。

5.3.2 ExecutorService线程池管理后台任务执行

更优方案是使用 ExecutorService 统一调度：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TaskScheduler {
    private static final ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void submitOrderTask(Runnable task) {
        executor.submit(task);
    }

    public static void shutdown() {
        executor.shutdown();
    }
}

线程池有效控制并发数量，避免系统过载。

5.3.3 synchronized关键字保障共享资源安全

当多个线程访问订单队列时，需同步访问：

public class OrderQueue {
    private final Queue<Order> queue = new LinkedList<>();

    public synchronized void add(Order order) {
        queue.offer(order);
    }

    public synchronized Order poll() {
        return queue.poll();
    }
}

synchronized 确保任一时刻只有一个线程能进入临界区，防止竞态条件。

5.4 高并发环境下的性能调优建议

5.4.1 连接池技术（如HikariCP）引入预研

传统每次请求新建连接开销大。HikariCP作为高性能连接池，显著降低延迟：

<!-- Maven依赖 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

配置示例：

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:sqlite:./data/cafe.db");
config.setMaximumPoolSize(10);
config.setConnectionTimeout(30000);

HikariDataSource dataSource = new HikariDataSource(config);

连接池复用物理连接，极大提升吞吐量。

5.4.2 事务隔离级别设置对一致性的影响

在订单扣减库存场景中，应设置适当隔离级别防止脏读：

connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

虽然提高一致性，但可能降低并发性，需权衡利弊。

6. 设计模式融合与系统集成测试验证

6.1 单例模式确保系统全局唯一实例

在Java Cafe原型系统中，某些核心组件（如订单管理器、数据库连接池、日志服务）在整个应用生命周期内应仅存在一个实例。单例模式（Singleton Pattern）正是解决此类需求的经典设计模式。

6.1.1 懒汉式与饿汉式实现方式对比

饿汉式 在类加载时即创建实例，线程安全但可能造成资源浪费：

public class OrderManager {
    // 类加载时立即初始化
    private static final OrderManager INSTANCE = new OrderManager();

    private OrderManager() {}

    public static OrderManager getInstance() {
        return INSTANCE;
    }
}

懒汉式 延迟初始化，节省资源，但需处理多线程并发问题：

public class OrderManager {
    private static OrderManager instance;

    private OrderManager() {}

    public static synchronized OrderManager getInstance() {
        if (instance == null) {
            instance = new OrderManager();
        }
        return instance;
    }
}

实现方式	是否线程安全	初始化时机	资源利用率
饿汉式	是	类加载时	低（可能未使用）
懒汉式	否（加synchronized后是）	第一次调用getInstance()	高

6.1.2 双重检查锁定在多线程环境下的正确实现

为兼顾性能与线程安全，推荐使用“双重检查锁定”（Double-Checked Locking）模式：

public class DatabaseConnectionPool {
    // volatile保证多线程下instance的可见性与禁止指令重排序
    private static volatile DatabaseConnectionPool instance;

    private DatabaseConnectionPool() {}

    public static DatabaseConnectionPool getInstance() {
        if (instance == null) {                       // 第一次检查
            synchronized (DatabaseConnectionPool.class) {
                if (instance == null) {               // 第二次检查
                    instance = new DatabaseConnectionPool();
                }
            }
        }
        return instance;
    }
}

参数说明 ：
- volatile ：防止JVM指令重排序导致其他线程获取到未完全构造的对象。
- 双重 if (instance == null) ：避免每次调用都进入同步块，提升性能。

该实现广泛应用于高并发场景下的单例对象创建，是现代Java开发中的标准实践之一。

6.2 工厂模式解耦对象创建过程

6.2.1 简单工厂模式生成不同类型的饮品对象

定义抽象饮品类：

abstract class Beverage {
    protected String name;
    protected double price;

    public abstract void brew();
    public abstract void addCondiments();

    @Override
    public String toString() {
        return name + " ¥" + price;
    }
}

具体子类示例：

class Latte extends Beverage {
    public Latte() {
        this.name = "拿铁";
        this.price = 30.0;
    }

    @Override
    public void brew() { System.out.println("萃取浓缩咖啡..."); }

    @Override
    public void addCondiments() { System.out.println("加入热牛奶..."); }
}

简单工厂类封装创建逻辑：

class BeverageFactory {
    public static Beverage createBeverage(String type) {
        return switch (type.toLowerCase()) {
            case "latte" -> new Latte();
            case "espresso" -> new Espresso();
            case "cappuccino" -> new Cappuccino();
            default -> throw new IllegalArgumentException("未知饮品类型: " + type);
        };
    }
}

调用示例：

Beverage latte = BeverageFactory.createBeverage("latte");
latte.brew();
latte.addCondiments();

6.2.2 扩展为工厂方法模式支持未来新增品类

当系统需要支持多个品牌或产地的饮品工厂时，可升级为 工厂方法模式 ：

interface BeverageFactory {
    Beverage createBeverage();
}

class ItalianLatteFactory implements BeverageFactory {
    public Beverage createBeverage() {
        return new Latte(); // 可定制原料来源
    }
}

class AmericanEspressoFactory implements BeverageFactory {
    public Beverage createBeverage() {
        return new Espresso();
    }
}

此结构便于后期扩展，符合开闭原则（对扩展开放，对修改关闭）。

6.3 观察者模式实现订单状态实时通知

6.3.1 定义Subject与Observer接口契约

import java.util.ArrayList;
import java.util.List;

// 被观察者（主题）
interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers(String status);
}

// 观察者接口
interface Observer {
    void update(String status);
}

订单类作为被观察者：

class Order implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String orderId;
    private String status;

    public Order(String orderId) {
        this.orderId = orderId;
    }

    public void setStatus(String status) {
        this.status = status;
        notifyObservers(status); // 状态变更自动推送
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers(String status) {
        for (Observer observer : observers) {
            observer.update("订单[" + orderId + "]状态更新为：" + status);
        }
    }
}

6.3.2 界面组件作为观察者接收状态变更推送

GUI组件实现Observer接口：

class StatusBar implements Observer {
    @Override
    public void update(String status) {
        System.out.println("[状态栏] " + status); // 可替换为JLabel.setText()
    }
}

class NotificationPopup implements Observer {
    @Override
    public void update(String status) {
        if (status.contains("完成")) {
            System.out.println("🔔 弹窗提示：您的订单已准备就绪！");
        }
    }
}

使用流程：

Order order = new Order("O20240518001");
order.registerObserver(new StatusBar());
order.registerObserver(new NotificationPopup());

order.setStatus("制作中");
order.setStatus("已完成");

输出：

[状态栏] 订单[O20240518001]状态更新为：制作中
[状态栏] 订单[O20240518001]状态更新为：已完成
🔔 弹窗提示：您的订单已准备就绪！

6.4 JUnit单元测试保障核心模块可靠性

6.4.1 编写测试用例覆盖订单创建、查询、删除逻辑

添加JUnit依赖（Maven）：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

测试订单管理器：

import org.junit.*;
import static org.junit.Assert.*;

public class OrderManagerTest {
    private OrderManager manager;

    @Before
    public void setUp() {
        manager = OrderManager.getInstance();
        manager.clearOrders(); // 清空测试数据
    }

    @Test
    public void testCreateAndFindOrder() {
        Order order = new Order("O001");
        order.setStatus("待处理");
        manager.addOrder(order);

        Order found = manager.findOrder("O001");
        assertNotNull(found);
        assertEquals("待处理", found.getStatus());
    }

    @Test(expected = IllegalArgumentException.class)
    public void testInvalidBeverageCreation() {
        BeverageFactory.createBeverage("unknown");
    }

    @Test
    public void testOrderCount() {
        manager.addOrder(new Order("O001"));
        manager.addOrder(new Order("O002"));
        assertEquals(2, manager.getOrderCount());
    }
}

6.4.2 Mock对象模拟数据库依赖进行隔离测试

使用Mockito框架（需引入依赖）模拟DAO层：

@Mock
private OrderDAO orderDAO;

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
}

@Test
public void testSaveOrderWithMock() throws SQLException {
    Order order = new Order("O001");
    when(orderDAO.save(order)).thenReturn(true);

    boolean result = orderDAO.save(order);
    assertTrue(result);
    verify(orderDAO).save(order); // 验证方法是否被调用
}

6.5 Java Cafe原型系统全流程集成与部署演示

6.5.1 从启动界面到完成一笔订单的端到端验证

系统启动流程图（Mermaid）：

sequenceDiagram
    participant User
    participant GUI
    participant Controller
    participant Service
    participant DAO
    participant DB

    User->>GUI: 启动程序
    GUI->>Controller: 初始化主界面
    Controller->>Service: 加载菜单项
    Service->>DAO: queryAllBeverages()
    DAO->>DB: 执行SQL查询
    DB-->>DAO: 返回结果集
    DAO-->>Service: 映射为List<Beverage>
    Service-->>Controller: 返回菜单数据
    Controller-->>GUI: 展示商品按钮
    User->>GUI: 选择“拿铁”并点击下单
    GUI->>Controller: 提交订单请求
    Controller->>Service: createOrder(beverage)
    Service->>Order: new Order(id)
    Service->>Subject: notifyObservers("已下单")
    Service->>DAO: save(order)
    DAO->>DB: INSERT INTO orders
    DB-->>DAO: 返回成功
    DAO-->>Service: 返回结果
    Service-->>Controller: 返回订单信息
    Controller-->>GUI: 显示订单编号和排队号