企业官网建设流程全解析

1. 为什么今天还要写一个 Swing 文件管理系统？

你点开这个标题，第一反应可能是：“都2024年了，还用 Swing？不是早被 JavaFX、Web 前端甚至 Electron 淘汰了吗？”——这恰恰是我三年前在某高校实验室带学生做课程设计时，听到最多的一句质疑。当时我们接了一个真实需求：为某基层档案室开发一套离线可用、零依赖、不联网也能稳定运行的本地文件归档工具。它要跑在一批平均配置是 i3-2100 + 4GB 内存 + Windows 7 的老式台式机上，不能装 JDK 17，不能连外网下载依赖，更不能要求用户先装 Node.js 或 Chrome。

结果我们选了Java 8 + Swing，上线后连续两年没出过一次 UI 崩溃或渲染异常。不是因为怀旧，而是因为 Swing 在这件事上，是经过二十年实战验证的“最小可靠解”：它不依赖 GPU 加速，不调用系统原生渲染管线，所有控件由 Java 自己绘制；它没有 Web 容器的内存膨胀问题，一个完整功能的文件管理器 JAR 包压到 800KB 以内；它启动快（实测冷启动 320ms）、响应稳（拖拽千个文件不卡顿）、权限干净（无需管理员提权就能读写本地磁盘）。这些特性，在边缘设备、老旧终端、离线政务/教育场景里，不是加分项，而是生死线。

所以这篇不是“Swing 复古教学”，而是一个仍在一线维护 Swing 系统的开发者，把过去五年里踩过的坑、压测过的边界、优化过的细节，全盘托出。你会看到：

• 如何让 JTree 在加载 5 万级节点时不卡死（不是靠懒加载，是靠节点生命周期控制）；
• 为什么JFileChooser在 Windows 上默认禁用符号链接，以及绕过它的安全前提；
• 怎样用SwingWorker实现真正的后台扫描，同时让进度条和文件预览图同步更新；
• 文件操作失败时，如何把IOException的底层错误码（比如 Windows 的 ERROR_ACCESS_DENIED）翻译成用户能懂的中文提示；
• 最关键的是：Swing 不是“过时”，而是“被误用”——90% 的 Swing 程序崩溃，根源不在框架本身，而在开发者强行把它当 Web 框架用：在 EDT 线程里做 IO、用repaint()强刷导致重绘风暴、把整个文件树塞进内存再渲染……

这篇文章，就是一份给“还在用 Swing 做实事”的人的生存手册。它不教你怎么画圆角按钮，只告诉你：当用户双击一个 2GB 的.zip文件时，你的程序该在第 372 毫秒弹出“正在解析目录结构”，而不是在第 8 秒后直接黑屏。

2. 架构设计：三层隔离 + 事件总线，让 Swing 不再“一崩全死”

很多 Swing 项目失败，不是功能做不出来，而是改一行代码，整个 UI 就开始抽风。根本原因在于：Swing 的线程模型和数据模型被混在一起了。比如，有人直接在ActionListener里调用Files.walk()扫描磁盘，结果 EDT（Event Dispatch Thread）被阻塞，鼠标悬停效果卡住，菜单弹不出来——用户第一反应是“软件坏了”，其实只是你把硬盘 IO 塞进了图形线程。

我们采用的架构，核心就八个字：UI 归 UI，数据归数据，通信靠事件。它不是什么新概念，但落地细节决定成败。

2.1 数据层：用Path代替File，用FileSystem代替硬编码路径分隔符

Java 7 引入的java.nio.file是 Swing 文件系统的基石。很多人还在用new File("C:\\Users\\xxx\\Documents")，这是危险信号。File类无法处理 UNC 路径（\\server\share）、不支持符号链接元数据、对大小写敏感性判断模糊。而Path是纯路径语义对象，配合FileSystem可以精准控制行为：

// ✅ 正确：获取当前系统的默认文件系统，自动适配分隔符与大小写规则 FileSystem fs = FileSystems.getDefault(); Path root = fs.getPath("C:", "Users", "xxx", "Documents"); // Windows 下自动转为 C:\Users\xxx\Documents // ✅ 正确：安全解析用户输入的路径（防 ../ 路径穿越） Path userInput = fs.getPath("/home/user/../tmp/malicious"); Path safePath = root.resolve(userInput).normalize(); if (!safePath.startsWith(root)) { throw new SecurityException("路径越界：试图访问根目录外资源"); }

提示：Path.normalize()不仅会压缩..，还会处理.和重复分隔符（如//），但它不会检查路径是否存在。真正校验存在性，必须用Files.exists(safePath, LinkOption.NOFOLLOW_LINKS)，且明确传入NOFOLLOW_LINKS——否则恶意构造的符号链接可能把你引向系统关键目录。

2.2 业务逻辑层：状态机驱动的文件操作引擎

文件管理不是 CRUD，而是状态流。复制一个文件，要经历：源检查 → 目标空间计算 → 权限校验 → 分块读写 → 校验和生成 → 元数据同步。任何一个环节失败，都要能回滚、能重试、能向 UI 报告精确阶段。

我们用轻量状态机实现（不引入 Spring State Machine 这类重型依赖）：

public enum FileOpState { IDLE, SOURCE_CHECKING, SPACE_CALCULATING, PERMISSION_CHECKING, COPYING, VERIFYING, METADATA_SYNCING, COMPLETED, FAILED } public class FileOperationEngine { private final AtomicReference<FileOpState> state = new AtomicReference<>(IDLE); public void startCopy(Path src, Path dst) { if (!state.compareAndSet(IDLE, SOURCE_CHECKING)) { throw new IllegalStateException("操作未完成，无法启动新任务"); } // 后台线程执行，绝不阻塞 EDT new SwingWorker<Void, ProgressUpdate>() { @Override protected Void doInBackground() throws Exception { setState(SOURCE_CHECKING); if (!Files.exists(src)) throw new NoSuchFileException(src.toString()); setState(SPACE_CALCULATING); long size = Files.size(src); if (size > getAvailableSpace(dst.getParent())) { throw new IOException("目标磁盘空间不足：" + formatSize(size)); } setState(COPYING); Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING); setState(VERIFYING); if (!MessageDigest.isEqual( Files.readAllBytes(src), Files.readAllBytes(dst) )) { throw new IOException("文件校验失败：复制后内容不一致"); } setState(COMPLETED); return null; } @Override protected void process(List<ProgressUpdate> chunks) { // 更新 UI 进度条，见下文 3.2 节 } @Override protected void done() { try { get(); // 获取异常，触发 catch } catch (ExecutionException e) { setState(FAILED); EventBus.post(new OperationFailedEvent(e.getCause())); } } }.execute(); } }

这个设计的关键在于：状态变更只发生在setState()方法内，且所有setState()调用都加了synchronized或AtomicReference保证线程安全。UI 层通过监听OperationFailedEvent来刷新错误面板，而不是轮询state.get()——避免了竞态条件。

2.3 UI 层：JTree + ListCellRenderer 的深度定制，解决万级节点卡顿

Swing 的JTree默认性能极差。加载 1 万个节点，DefaultTreeModel会创建 1 万个TreeNode对象，每个对象都持有父节点引用，内存占用飙升，GC 频繁。更糟的是，JTree默认开启setRootVisible(true)，意味着每次展开节点，都要重新计算整个树的布局。

我们的解法是：虚拟化 + 懒加载 + 节点复用。

首先，放弃DefaultTreeModel，手写AbstractTreeModel：

public class VirtualFileTreeModel extends AbstractTreeModel { private final Path rootPath; private final Map<Path, TreeNode> nodeCache = new ConcurrentHashMap<>(); // 缓存已展开的节点 public VirtualFileTreeModel(Path rootPath) { this.rootPath = rootPath; // 根节点不实际加载子项，只占位 nodeCache.put(rootPath, new VirtualTreeNode(rootPath, true)); } @Override public Object getChild(Object parent, int index) { Path parentPath = ((VirtualTreeNode) parent).getPath(); try { // 只在需要时，才扫描该目录的子项（限前 1000 个，防恶意超大目录） List<Path> children = Files.list(parentPath) .limit(1000) .sorted(Comparator.comparing(p -> !Files.isDirectory(p))) // 目录优先 .collect(Collectors.toList()); if (index < children.size()) { Path child = children.get(index); VirtualTreeNode node = new VirtualTreeNode(child, Files.isDirectory(child)); nodeCache.put(child, node); return node; } } catch (IOException ignored) {} return null; } @Override public int getChildCount(Object parent) { Path parentPath = ((VirtualTreeNode) parent).getPath(); try { return (int) Files.list(parentPath).limit(1001).count(); // +1 判断是否超限 } catch (IOException e) { return 0; } } }

其次，JTree渲染器必须重写getListCellRendererComponent，禁止创建新组件：

public class FileTreeCellRenderer extends JLabel implements TreeCellRenderer { private final ImageIcon folderIcon = loadIcon("folder.png"); private final ImageIcon fileIcon = loadIcon("file.png"); @Override public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { VirtualTreeNode node = (VirtualTreeNode) value; setText(node.getPath().getFileName().toString()); if (node.isDirectory()) { setIcon(folderIcon); } else { setIcon(fileIcon); } // 关键：复用 JLabel，不 new 新对象 if (selected) { setBackground(tree.getSelectionBackground()); setForeground(tree.getSelectionForeground()); } else { setBackground(tree.getBackground()); setForeground(tree.getForeground()); } return this; } }

注意：JTree.setCellRenderer(new FileTreeCellRenderer())必须在JTree创建后立即调用，且绝对不要在getTreeCellRendererComponent里调用setIcon()加载新图标——图标加载是 I/O 操作，会严重拖慢滚动帧率。所有图标必须在初始化时一次性ImageIO.read()并缓存。

最后，给JTree加上键盘导航支持（这是 Swing 常被忽略的体验细节）：

tree.addKeyListener(new KeyAdapter() { @Override public void keyPressed(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_F2) { // F2 重命名 TreePath path = tree.getSelectionPath(); if (path != null) { startEditingAtPath(path); // 调用 JTree 内置编辑器 } } } });

这套组合拳下来，实测在 i5-4200U + 8GB 内存的机器上，JTree加载并展开含 3.2 万个子项的目录（如C:\Windows\System32），首次响应时间 < 1.2 秒，后续展开同级目录平均 80ms，内存增量 < 15MB。

3. 核心功能实现：从浏览、搜索到批量操作的全链路细节

一个文件管理器的核心价值，不在于它能显示多少种图标，而在于用户能否在 3 秒内找到想要的文件。这要求每一个功能模块都经过“反人类测试”：故意输错名字、故意选中 1000 个文件、故意在复制中途拔掉 U 盘……下面拆解三个最易翻车的功能点。

3.1 搜索：用Files.find()替代递归遍历，支持正则与大小过滤

Swing 自带的JFileChooser没有搜索功能。自己实现时，常见错误是写一个递归方法：

// ❌ 危险：递归深度过大导致 StackOverflowError，且无法中断 private void searchRecursively(Path dir, String pattern) { try { for (Path child : Files.list(dir).collect(Collectors.toList())) { if (child.getFileName().toString().contains(pattern)) { results.add(child); } if (Files.isDirectory(child)) { searchRecursively(child, pattern); // 深度未知！ } } } catch (IOException ignored) {} }

正确做法是用Files.find()，它基于Stream，天然支持limit()、filter()、parallel()，且可被SwingWorker.cancel(true)中断：

public class FileSearcher { private final ExecutorService searchPool = Executors.newSingleThreadExecutor(); public void startSearch(Path root, String pattern, long maxSizeBytes) { searchPool.submit(() -> { try { Files.find(root, Integer.MAX_VALUE, (path, attrs) -> { String name = path.getFileName().toString(); boolean nameMatch = name.matches(".*" + Pattern.quote(pattern) + ".*"); boolean sizeMatch = maxSizeBytes <= 0 || attrs.size() <= maxSizeBytes; return nameMatch && sizeMatch; }) .limit(5000) // 防止结果爆炸 .forEach(path -> EventBus.post(new SearchResultEvent(path))); } catch (IOException | RuntimeException e) { EventBus.post(new SearchErrorEvent(e)); } }); } }

这里的关键细节：

• Files.find()的第二个参数maxDepth设为Integer.MAX_VALUE，不是为了真搜到底，而是让Stream能自然终止于文件系统边界（如挂载点、权限拒绝目录）；
• Pattern.quote(pattern)是必须的——用户输入*.log，你要匹配字面量*，而不是正则通配符；
• limit(5000)是用户体验底线：返回前 5000 个结果，比卡死 30 秒然后返回 2 万个结果更友好；
• EventBus.post()发送事件，UI 层用@Subscribe接收，绝不直接在搜索线程里SwingUtilities.invokeLater()更新列表——事件总线天然解耦，且可批量合并事件（如 100 个SearchResultEvent合并为一次 UI 刷新）。

3.2 批量操作：用TransferHandler实现跨应用拖拽，支持 ZIP 解压直传

Swing 的TransferHandler是被严重低估的 API。它能让JList、JTable甚至自定义组件，像操作系统文件管理器一样支持拖拽。难点在于：如何让拖拽出来的数据，被其他应用（如 Windows 资源管理器）识别为标准文件？

答案是实现DataFlavor的application/x-java-file-list：

public class FileTransferHandler extends TransferHandler { @Override public int getSourceActions(JComponent c) { return COPY_OR_MOVE; } @Override protected Transferable createTransferable(JComponent c) { JList<Path> list = (JList<Path>) c; List<Path> selected = list.getSelectedValuesList(); // 构建标准文件列表（供外部应用读取） List<File> fileList = selected.stream() .map(Path::toFile) .collect(Collectors.toList()); // 构建自定义数据（供本应用内部使用，如记录原始 Path） byte[] customData = serializePaths(selected); return new FileListTransferable(fileList, customData); } private static class FileListTransferable implements Transferable { private final List<File> files; private final byte[] customData; private static final DataFlavor FILE_LIST_FLAVOR = new DataFlavor("application/x-java-file-list;class=java.util.List"); private static final DataFlavor CUSTOM_FLAVOR = new DataFlavor("application/x-custom-path-list;class=[B"); FileListTransferable(List<File> files, byte[] customData) { this.files = files; this.customData = customData; } @Override public DataFlavor[] getTransferDataFlavors() { return new DataFlavor[]{FILE_LIST_FLAVOR, CUSTOM_FLAVOR}; } @Override public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException { if (flavor.equals(FILE_LIST_FLAVOR)) { return files; } else if (flavor.equals(CUSTOM_FLAVOR)) { return customData; } else { throw new UnsupportedFlavorException(flavor); } } } }

这样，用户在你的JList里选中 100 个文件，拖到桌面，就会生成 100 个快捷方式；拖到微信窗口，就能直接发送。而拖拽到本应用的另一个JList，getTransferData(CUSTOM_FLAVOR)会返回序列化的Path列表，保留原始符号链接、权限等元数据，避免File对象丢失信息。

注意：TransferHandler的canImport()方法必须严格校验目标位置权限。例如，拖拽到只读目录时，应禁用MOVE操作，只允许COPY。实测发现，Windows 10 的资源管理器在拖拽到 NTFS 只读文件夹时，会静默失败而不报错，必须在importData()里主动Files.isWritable(target.getParent())检查。

3.3 文件预览：用ImageIO和AudioSystem实现零依赖缩略图

Swing 没有内置预览控件。很多教程教你怎么用JLabel.setIcon(new ImageIcon(path))，但这会导致：

• 大图加载卡 UI（ImageIcon构造函数是同步的）；
• 不支持 GIF 动画、WebP 等格式；
• 无法限制内存占用（一张 8K 图片解码后占 256MB 内存）。

我们的方案是：异步解码 + 尺寸约束 + 缓存淘汰。

public class ThumbnailLoader { private final ScheduledExecutorService cacheCleaner = Executors.newSingleThreadScheduledExecutor(); private final Map<Path, BufferedImage> thumbnailCache = new ConcurrentHashMap<>(); public void loadThumbnail(Path file, JLabel label, int maxWidth, int maxHeight) { // 先查缓存 BufferedImage cached = thumbnailCache.get(file); if (cached != null) { label.setIcon(new ImageIcon(cached)); return; } // 后台线程解码 CompletableFuture.supplyAsync(() -> { try { BufferedImage original = ImageIO.read(file.toFile()); if (original == null) return null; // 格式不支持 // 等比缩放，保持宽高比 double scale = Math.min( (double) maxWidth / original.getWidth(), (double) maxHeight / original.getHeight() ); if (scale >= 1.0) return original; // 原图更小，直接返回 int newWidth = (int) (original.getWidth() * scale); int newHeight = (int) (original.getHeight() * scale); BufferedImage scaled = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB); Graphics2D g = scaled.createGraphics(); g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); g.drawImage(original, 0, 0, newWidth, newHeight, null); g.dispose(); return scaled; } catch (IOException e) { return null; } }, ForkJoinPool.commonPool()) .thenAccept(thumb -> { if (thumb != null) { thumbnailCache.put(file, thumb); // LRU 缓存淘汰：超过 100 个，删最久未用的 if (thumbnailCache.size() > 100) { thumbnailCache.entrySet().stream() .min(Map.Entry.comparingByValue()) .ifPresent(entry -> thumbnailCache.remove(entry.getKey())); } SwingUtilities.invokeLater(() -> label.setIcon(new ImageIcon(thumb))); } }); } }

这个实现的精妙之处在于：

• CompletableFuture.supplyAsync()确保解码不阻塞 EDT；
• RenderingHints.KEY_INTERPOLATION设置为BILINEAR，比默认的NEAREST_NEIGHBOR清晰数倍；
• 缓存淘汰不用复杂 LRU 算法，而是简单按entrySet().stream().min()——因为ConcurrentHashMap的entrySet()遍历顺序，天然接近插入顺序（JDK 8+ 保证）；
• 对非图片文件（如.mp3），我们扩展loadThumbnail()：用AudioSystem.getAudioFileFormat()读取 ID3 标签里的封面图，失败则返回通用音频图标。

实测在 4GB 内存的机器上，同时预览 200 个 10MB 的 PNG 文件，内存峰值 < 380MB，且 UI 响应无延迟。

4. 稳定性攻坚：处理 Windows 权限、符号链接与长路径的实战经验

Swing 程序在 Windows 上崩溃，90% 出在三件事上：权限不足、符号链接循环、路径超长。这些不是 Java 的 Bug，而是 Windows 文件系统与 Java NIO 的交互陷阱。下面全是血泪换来的解决方案。

4.1 Windows 权限：AccessDeniedException的七种死法与解法

Files.list(path)抛AccessDeniedException是家常便饭。但直接e.printStackTrace()给用户看，等于告诉对方“你的电脑坏了”。我们必须翻译成可操作的提示。

首先，区分权限类型。Windows 的AccessDeniedException底层对应不同错误码，可通过反射获取：

public static String getWindowsErrorCode(IOException e) { try { Field field = e.getClass().getDeclaredField("errorCode"); field.setAccessible(true); Object code = field.get(e); if (code instanceof Integer) { return String.valueOf(code); } } catch (Exception ignored) {} return "UNKNOWN"; } // 使用示例 try { Files.list(path).forEach(System.out::println); } catch (AccessDeniedException e) { String code = getWindowsErrorCode(e); switch (code) { case "5": // ERROR_ACCESS_DENIED return "无权访问此文件夹。请右键点击文件夹 → 属性 → 安全 → 编辑权限"; case "32": // ERROR_SHARING_VIOLATION return "文件正被其他程序使用。请关闭 Word、Excel 等可能锁定该文件的软件"; case "1223": // ERROR_CANCELLED return "操作被用户取消。请检查是否点了‘否’或按了 Esc 键"; default: return "访问被拒绝（错误码：" + code + "）。请以管理员身份运行本程序"; } }

注意：errorCode字段名在不同 JDK 版本可能变化（如 JDK 11 改为win32ErrorCode），生产环境必须用try-catch包裹反射逻辑，失败时降级为通用提示。

其次，对关键操作（如删除、重命名）必须预检权限：

public static boolean canDelete(Path path) { try { // 检查父目录是否有写权限（删除需要父目录写权限） Path parent = path.getParent(); if (parent == null) return false; return Files.isWritable(parent) && (Files.isRegularFile(path) || Files.isDirectory(path)); } catch (IOException e) { return false; } }

4.2 符号链接：NOFOLLOW_LINKS是金科玉律，但也要懂何时该跟随

Java NIO 默认不跟随符号链接（NOFOLLOW_LINKS），这是安全的。但有些场景必须跟随，比如用户双击一个指向D:\Data\Projects的链接，你得打开真实目录，而不是显示链接文件本身。

我们的策略是：浏览时跟随，操作时禁止跟随。

• 浏览JTree：用Files.walk(path, 1, FOLLOW_LINKS)获取第一层子项，确保用户看到的是链接指向的内容；
• 删除/重命名：永远用NOFOLLOW_LINKS，否则Files.delete(linkPath)会删掉真实目录，而不是链接文件；
• 复制：StandardCopyOption.COPY_ATTRIBUTES会保留链接属性，但REPLACE_EXISTING会覆盖链接为普通文件——必须显式判断Files.isSymbolicLink(path)，如果是链接，则用Files.createSymbolicLink()重建。

最关键的是：检测循环链接。Windows 允许创建A → B → A这样的死循环。Files.walk()默认会抛FileSystemLoopException，但这个异常在SwingWorker里会被吞掉。必须手动检测：

public static boolean hasLoop(Path path) { Set<Path> visited = new HashSet<>(); Path current = path; while (Files.isSymbolicLink(current)) { if (!visited.add(current)) return true; // 已访问过，存在循环 try { current = Files.readSymbolicLink(current); } catch (IOException e) { break; // 读取失败，视为终点 } } return false; }

4.3 长路径：突破 Windows 的 MAX_PATH 限制（260 字符）

Windows 默认路径长度上限 260 字符，C:\very\long\path\...超过就PathTooLongException。解决方案有两个层面：

系统级（需用户配合）：
在C:\Windows\System32\GroupPolicy\LocalGp\Software\Policies\Microsoft\Windows\Explorer下新建DWORD值LongPathsEnabled = 1，重启生效。这是微软官方推荐方案，但要求 Windows 10 1607+。

代码级（必须实现）：
在所有Path构造前，自动添加\\?\前缀（仅 Windows）：

public static Path toLongPath(Path path) { if (System.getProperty("os.name").toLowerCase().contains("win")) { String str = path.toString(); if (!str.startsWith("\\\\?\\") && str.length() > 240) { return Paths.get("\\\\?\\" + str); } } return path; } // 使用 Path longPath = toLongPath(Paths.get("C:", "very", "long", "path", ...)); Files.exists(longPath); // 现在能成功

注意：\\?\前缀会使路径变为“扩展长度路径”，此时File.getCanonicalPath()会失效，必须全程用PathAPI。所有String路径拼接都必须改为Path.resolve()。

5. 发布与部署：如何让 JAR 包在任何 Windows 电脑上双击就运行

写完功能只是开始。最终交付物是一个.jar文件，用户双击就能用。这要求我们解决三个终极问题：JRE 依赖、图标嵌入、防误关闭。

5.1 JRE 打包：用 jlink 构建最小化运行时（JDK 11+）

别再让用户自己装 JDK。jlink可以把 JRE 削减到 40MB 以内：

# 1. 分析你的 jar 依赖哪些模块 jdeps --list-deps your-app.jar # 2. 构建最小运行时（只含必要模块） jlink --add-modules java.base,java.desktop,java.logging,java.nio \ --output jre-minimal \ --compress=2 \ --no-header-files \ --no-man-pages # 3. 把 jar 和 jre 打包成单目录 mkdir dist cp -r jre-minimal dist/jre cp your-app.jar dist/

然后写一个launch.bat：

@echo off if exist "jre\bin\java.exe" ( jre\bin\java.exe -Dfile.encoding=UTF-8 -jar your-app.jar ) else ( echo 错误：找不到 Java 运行时，请安装 JDK 11 或更高版本。 pause )

实测jre-minimal目录大小 38.2MB，启动时间比完整 JRE 快 40%。

5.2 图标嵌入：用 Resource Hacker 替换 exe 图标（Windows）

.jar双击运行，Windows 用javaw.exe启动，任务栏图标是 Java 默认咖啡杯。要换成自己的图标，必须生成.exe包装器。

我们用开源工具Launch4j（免费、无广告、支持签名）：

• Header→GUI application（隐藏控制台）；
• JRE→Min JRE version: 11.0，Max JRE version: 17.0；
• Icons→ 添加.ico文件（必须含 16x16, 32x32, 48x48, 256x256 四种尺寸）；
• Wrapper→Don't wrap the jar（只包装，不加密）。

生成的your-app.exe双击即运行，任务栏、Alt+Tab、任务管理器都显示自定义图标。

5.3 防误关闭：拦截用户点击关闭按钮的三种时机

用户狂点右上角 ×，程序还没保存配置就退出，是最大体验灾难。Swing 提供三层拦截：

第一层：窗口关闭确认（最常用）

frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { int result = JOptionPane.showConfirmDialog(frame, "配置尚未保存，确定要退出吗？", "确认退出", JOptionPane.YES_NO_OPTION); if (result == JOptionPane.YES_OPTION) { saveConfig(); // 保存配置 System.exit(0); } } });

第二层：进程退出钩子（兜底）

Runtime.getRuntime().addShutdownHook(new Thread(() -> { try { saveConfig(); // 确保 Ctrl+C、kill -15 也能保存 } catch (Exception ignored) {} }));

第三层：系统关机监听（Windows 专用）

// 注册 Windows 服务消息 User32.INSTANCE.RegisterHotKey(null, 1, 0, (int) WinUser.VK_CANCEL); // 在 WndProc 里监听 WM_QUERYENDSESSION

但注意：WM_QUERYENDSESSION是询问，不是命令。你必须在 5 秒内返回TRUE（允许关机）或FALSE（阻止关机）。实践中，我们只在这里触发快速保存（不执行耗时操作），然后返回TRUE，让用户关机流程不卡住。

6. 我的个人体会：Swing 的不可替代性，在于它把“确定性”刻进了基因

写完这篇，我打开自己维护的档案室系统，它正运行在一台贴着“Windows 7 Service Pack 1”标签的旧主机上。屏幕右下角，系统托盘里那个小小的文件管理器图标，已经亮了 782 天，没重启过一次。

这不是技术炫耀。而是想说：当一个系统需要在没有 IT 支持的乡镇办公室里，连续运行三年不崩溃；当它的用户是平均年龄 58 岁、只会用鼠标双击的档案员；当它的硬件是别人淘汰的二手电脑——这时候，技术选型的首要标准，从来不是“新”，而是“确定”。

Swing 的确定性体现在：

• 它的渲染不依赖显卡驱动，NVIDIA 300 系列和 Intel HD 3000 显卡表现完全一致；
• 它的线程模型强制你思考并发，SwingWorker的publish/process机制，比 React 的useState更早教会开发者“状态更新必须批量”；
• 它的 API 设计充满“防御性”：JTable.setModel(null)会抛NullPointerException，逼你写if (model != null)；JTree.setSelectionPath(null)直接静默失败，逼你校验参数。

所以，如果你正在评估一个需要长期稳定运行的本地工具，别急着否定 Swing。先问自己三个问题：

1. 这个工具的用户，会不会在没有网络的环境下使用？
2. 它的部署环境，是不是由非技术人员维护？
3. 你能否接受“每年升级一次框架，就重写 70% 的 UI 代码”？

如果答案是“是、是、不能”，那么 Swing 不是退路，而是经过时间验证的最优解。它不酷，不炫，不支持 CSS，但它像一把用了二十年的瑞士军刀——没有花哨功能，但每次打开，都稳稳地切开你需要的那部分现实。