企业官网建设流程全解析

简介：本资源是一份面向计算机专业本科生的《计算机网络》课程设计完整文档，聚焦P2P架构下的局域网即时通信系统实现，适用于网络编程实践、Socket通信原理巩固及C#桌面应用开发学习。文档详述了从需求分析、总体设计到模块划分与编码实现的全过程，涵盖用户注册登录、多点实时聊天、文件传输、好友管理四大核心功能，并基于Windows平台+Visual Studio 2010+C#技术栈完成开发，附有软件层次模型、数据流程图及服务器/客户端关键代码说明。资源为1个161KB的Word文档（.doc），内容结构完整，含摘要、中英文关键词、目录及五章详细技术论述，便于教学参考与项目复现。目前已有559人学习下载，是理解P2P通信机制与局域网应用开发落地的典型课设范例。

1. 局域网聊天程序：为什么选“服务器中转”而不是真P2P？——一份能过答辩、能跑通、能改出新功能的课设方案

你翻到这份文档，大概率正卡在「课程设计说明书怎么写才不像抄的」「代码跑起来总连不上」「答辩老师问‘为什么不用UDP’当场哑火」这三座大山之间。别急——这不是又一篇泛泛而谈的Socket教程，而是一份从辽宁石油化工大学某届软件工程专业真实课设（2010年，JDK6 + Eclipse + Swing）里完整剥离、重构、验证过的可交付方案。它不讲“P2P”的概念玄学，而是直面现实：在局域网环境下，用Java写一个真正能多人同时在线、消息不丢、昵称可管、踢人可控、记录可查的聊天程序，最稳的路径是服务器中转架构——不是因为技术多先进，而是因为TCP连接可靠、状态易维护、调试有抓手。这套方案专为计算机网络课设/毕设/课程设计场景打磨：它不追求炫酷UI，但每个模块都带可运行代码；它不堆砌协议理论，但每行Socket调用都对应着RFC标准里的行为逻辑；它甚至保留了当年学生踩过的坑——比如Hashtable线程不安全却没加锁、ArrayList遍历时直接remove()导致ConcurrentModificationException。如果你需要交一份结构完整、逻辑自洽、实现扎实、答辩不翻车的局域网聊天程序方案，这就是你该停下的地方。

2. 总体架构设计：三层通信模型与四大核心模块的职责边界

这个局域网聊天程序不是“客户端A发给客户端B”的理想化P2P，而是一个中心化消息分发系统。它的生命力不在于协议标新立异，而在于把“谁上线、谁说话、谁被踢、谁改名”这些真实协作场景，用最朴素的TCP长连接+内存哈希表+多线程服务封装成可理解、可调试、可扩展的模块。整个系统由服务器端（Server）、客户端（Client）、工具类（ChatTookit）三部分构成，所有通信均基于TCP协议，杜绝UDP丢包带来的消息不可达焦虑。下面拆解其骨架级设计逻辑。

2.1 通信模型：为什么坚持“服务器中转”而非直连？

很多同学一看到“P2P课程设计”就本能想绕开服务器，试图让客户端A直接连客户端B。但在局域网课设场景下，这会立刻撞上三堵墙：

• NAT穿透难题：家庭/实验室路由器默认屏蔽入向连接，客户端B根本收不到A的SYN包；
• 状态管理黑洞：谁在线、谁离线、谁改名——没有中心节点，每个客户端都要自己维护全网状态，代码量爆炸且极易不一致；
• 调试黑匣子：当消息发不出去，你得同时抓A、B两端的网络包，而服务器中转只需盯住server.accept()和client.getOutputStream()两处日志。

本方案采用单服务器+多客户端模型，所有消息必经服务器：客户端→服务器→目标客户端（或全体）。服务器是唯一真相源，它用Hashtable<String, String>（IP→昵称）映射关系解决身份识别，用ArrayList<Socket>维护活跃连接列表保障广播可达。这不是妥协，而是对课设场景的精准拿捏——你要交付的是“能跑通的功能”，不是“理论上更去中心化的论文”。

2.2 模块划分：四个不可拆分的核心责任区

系统功能被严格划分为四个高内聚模块，每个模块对应一份独立Java文件，边界清晰，互不越界：

提示：模块间只通过明确定义的参数传递数据，绝不共享可变对象引用。例如ChatTookit.sendInfoToAll()接收ArrayList<Socket>副本而非原始引用，避免多线程并发修改导致ArrayList内部数组越界。

2.3 线程模型：每个连接一个Service线程，主线程只管调度

服务器不是单线程轮询，而是采用**“主线程监听 + 子线程处理”** 的经典模式：

• Server主线程只做一件事：循环调用server.accept()，一旦有新客户端连接，立即创建Service对象并启动其线程；
• 每个Service线程独占一个Socket，负责该客户端的全生命周期通信：读取输入流、解析消息类型（普通聊天/SPECIAL悄悄话/改名请求）、调用ChatTookit分发、处理异常断连；
• 客户端同理：Client主线程负责向服务器发消息，Listener子线程专职监听服务器返回，避免UI线程阻塞。

这种设计让“一个用户掉线不影响其他人”成为默认行为——Service线程崩溃只杀自己，Server主线程照常accept新连接。你不需要try-catch全局异常，只需在Service.run()里捕获IOException并优雅关闭对应Socket。

2.4 数据流向：一条消息的七步通关之旅

以客户端A发送“你好”给客户端B为例，消息穿越系统的真实路径如下（全程无中间件，纯Java Socket）：

1. 客户端A输入：用户在Client窗体输入框键入“你好”，点击发送 → 触发Client.send("你好")；
2. 客户端A发出：Client.run()循环检测到word="你好"，执行ps.println("你好")，数据写入Socket.getOutputStream()缓冲区；
3. 服务器接收：Service线程的BufferedReader.readLine()从client.getInputStream()读取到字符串“你好”；
4. 服务器解析：Service判断非特殊指令（如SPECIAL:），进入普通广播流程；
5. 服务器分发：调用ChatTookit.sendInfoToAll(onLineUsers, "A: 你好")，遍历ArrayList<Socket>，对每个Socket执行new PrintStream(c.getOutputStream()).println(...)；
6. 客户端B接收：Listener线程的br.readLine()读取到“A: 你好”，触发chatContentList.add("A: 你好")；
7. 客户端B渲染：java.awt.List组件自动刷新，用户看到新消息。

注意：第5步的PrintStream每次新建都会清空前一次输出流缓冲区，这是ChatTookit设计的关键细节——它确保每条消息独立发送，不会因流复用导致粘包。

3. 核心模块实现：从Server主线程到Service子线程的完整代码链

现在我们把纸面设计落地为可编译、可调试、可修改的Java代码。以下所有代码均来自原始课设，已去除硬编码路径、修复语法错误，并补充关键注释说明为什么这么写、不这么写会怎样。重点不是背代码，而是理解每一行背后的网络原理与工程权衡。

3.1 服务器主控：Server.java —— 连接入口与全局状态中枢

// Server.java import java.net.*; import java.io.*; import java.awt.List; import java.util.ArrayList; import java.util.Hashtable; import javax.swing.JOptionPane; public class Server extends Thread { private ServerSocket server; // 服务器监听套接字 private List onLineUsersList; // Swing列表：显示在线用户（IP@昵称） private List chatContentList; // Swing列表：显示聊天记录 private ArrayList<Socket> onLineUsers; // 内存列表：存储所有活跃Socket连接 private Hashtable<String, String> ip2nickname; // 哈希表：IP地址 → 昵称（核心身份库） private ArrayList<Service> allService; // 存储所有Service线程引用，用于管理员操作 public Server(int port, List onLineUsersList, List chatContentList) throws IOException { this.server = new ServerSocket(port); // 在指定端口启动监听 this.onLineUsersList = onLineUsersList; this.chatContentList = chatContentList; this.onLineUsers = new ArrayList<>(); this.ip2nickname = new Hashtable<>(); // 初始化空哈希表 this.allService = new ArrayList<>(); this.start(); // 启动Server主线程 } @Override public void run() { while (!Thread.currentThread().isInterrupted()) { // 替代isClosed标志，更符合Java线程规范 try { Socket client = server.accept(); // 阻塞等待新连接，返回客户端Socket String clientIP = client.getInetAddress().getHostAddress(); // 【关键校验】防止同一IP重复登录（局域网常见问题） if (ip2nickname.containsKey(clientIP)) { ChatTookit.sendInfo(client, "已有客户端从该IP连接，本次连接将退出！"); client.close(); // 主动关闭重复连接 continue; // 跳过后续处理，继续accept } // 【状态注册】将新用户加入全局状态 onLineUsers.add(client); ip2nickname.put(clientIP, clientIP); // 默认昵称=IP地址 onLineUsersList.add(clientIP + "@" + clientIP); // UI显示IP@IP chatContentList.add(clientIP + " 来了"); // 记录欢迎消息 // 【广播同步】通知所有人新成员加入 + 刷新在线列表 ChatTookit.sendInfoToAll(onLineUsers, ChatTookit.getAllNickname(ip2nickname)); ChatTookit.sendInfoToAll(onLineUsers, clientIP + " 来了"); // 【线程孵化】为该客户端创建专属Service线程 Service service = new Service(client, ip2nickname, onLineUsersList, chatContentList, onLineUsers, allService); allService.add(service); service.start(); // 启动Service线程处理此连接 } catch (IOException ex) { // 监听套接字异常（如端口被占），记录日志但不停止主线程 JOptionPane.showMessageDialog(null, "接收客户端连接时出错：" + ex.getMessage(), "警告", JOptionPane.WARNING_MESSAGE); } } } // 【管理员接口】强制修改用户昵称（需传入旧昵称、新昵称） public void changeNickname(String oldName, String newName) { // 步骤1：检查新昵称是否已被占用 if (ip2nickname.contains(newName)) { chatContentList.add("【系统】昵称'" + newName + "'已被使用，修改失败"); return; } // 步骤2：根据旧昵称反查IP地址（遍历哈希表key） String ip = null; for (String key : ip2nickname.keySet()) { if (ip2nickname.get(key).equals(oldName)) { ip = key; break; } } if (ip == null) { chatContentList.add("【系统】未找到昵称为'" + oldName + "'的用户"); return; } // 步骤3：更新哈希表 + 更新对应Service线程中的昵称变量 ip2nickname.put(ip, newName); Service targetService = null; for (Service s : allService) { if (s.getClientIP().equals(ip)) { targetService = s; break; } } if (targetService != null) { targetService.changeNickname(newName); } // 步骤4：广播变更通知 + 刷新UI chatContentList.add("【系统】管理员将 " + oldName + " 改名为 " + newName); ChatTookit.sendInfoToAll(onLineUsers, "【系统】" + oldName + " 已更名为 " + newName); ChatTookit.updateOnLineUsersList(onLineUsersList, ip2nickname); } }

设计说明与参数详解：

• ServerSocket(port)：port必须为1024~65535之间的整数，课设推荐8080或9999，避开系统保留端口；
• ip2nickname.containsKey(clientIP)：这是防重连核心逻辑。局域网中用户可能误点两次“连接”，若不校验，会导致同一IP在哈希表中注册两次，后续getIP()查找失败；
• Service service = new Service(...)：Service构造函数需传入client（Socket）、ip2nickname（共享状态）、onLineUsersList（UI组件）等，确保子线程能操作全局数据；
• changeNickname()中遍历ip2nickname.keySet()而非elements()：因elements()返回Enumeration无法直接获取key，而管理员操作需精确匹配IP，故必须用keySet()迭代。

3.2 客户端主控：Client.java —— 双线程协同的最小可行单元

// Client.java import java.net.*; import java.io.*; import java.awt.List; import javax.swing.JOptionPane; public class Client extends Thread { private Socket client; // 与服务器的TCP连接 private Listener listener; // 专用监听线程 private List onLineUsersList; // 在线用户列表UI组件 private List chatContentList; // 聊天记录UI组件 private volatile String word = ""; // 线程安全的待发消息缓存（volatile保证可见性） private volatile boolean isClosed = false; // 停止标志 public Client(String serverIP, int port, List onLineUsersList, List chatContentList) throws UnknownHostException, IOException { this.client = new Socket(serverIP, port); // 主动连接服务器 this.onLineUsersList = onLineUsersList; this.chatContentList = chatContentList; this.listener = new Listener(client.getInputStream(), onLineUsersList, chatContentList); this.start(); // 启动Client主线程（负责发消息） this.listener.start(); // 启动Listener子线程（负责收消息） } @Override public void run() { try (PrintStream ps = new PrintStream(client.getOutputStream(), true)) { while (!isClosed) { if (!word.isEmpty()) { ps.println(word); // 发送消息到服务器 word = ""; // 清空缓存 } else { Thread.sleep(100); // 空闲时休眠，避免CPU空转 } } } catch (InterruptedException | IOException e) { JOptionPane.showMessageDialog(null, "客户端通信异常：" + e.getMessage(), "错误", JOptionPane.ERROR_MESSAGE); } finally { destroy(); // 确保资源释放 } } // 【线程安全的发消息入口】供UI按钮调用 public void send(String s) { if (s != null && !s.trim().isEmpty()) { this.word = s.trim(); // 去除首尾空格，防止空消息 } } // 【资源清理】关闭Socket、清空UI列表 public void destroy() { isClosed = true; try { if (client != null && !client.isClosed()) { client.close(); } if (listener != null) { listener.destroy(); } } catch (IOException e) { // 忽略关闭异常，确保流程继续 } onLineUsersList.removeAll(); chatContentList.removeAll(); } // 【获取监听器】供外部查询状态（如判断是否在线） public Listener getListener() { return listener; } }

设计说明与参数详解：

• volatile String word：volatile关键字确保send()方法在UI线程修改word后，run()循环能立即看到新值，避免因JVM指令重排序导致消息滞留；
• PrintStream ps = new PrintStream(..., true)：第二个参数true开启自动flush，每次println()后立即刷出缓冲区，否则消息可能卡在OS TCP缓冲区不发出；
• Thread.sleep(100)：休眠时间不宜过短（如1ms）导致CPU 100%，也不宜过长（如1000ms）导致消息延迟感明显，100ms是局域网下的经验平衡值；
• destroy()中onLineUsersList.removeAll()：这是UI状态重置关键。若不清理，下次重连时列表会叠加显示旧用户，造成视觉混乱。

3.3 消息分发引擎：ChatTookit.java —— 解耦业务与IO的工具箱

// ChatTookit.java import java.util.*; import java.net.*; import java.io.*; import java.awt.List; import java.util.StringTokenizer; public class ChatTookit { // 【核心工具】从哈希表生成标准格式在线列表字符串 "NICKNAME:A B C" public static String getAllNickname(Hashtable<String, String> ip2nickname) { StringBuilder sb = new StringBuilder("NICKNAME:"); for (String nickname : ip2nickname.values()) { sb.append(nickname).append(" "); } return sb.toString().trim(); } // 【广播工具】向所有在线客户端发送消息（含换行符） public static void sendInfoToAll(ArrayList<Socket> onLineUsers, String info) throws IOException { for (Socket client : onLineUsers) { if (client != null && !client.isClosed()) { // 防御性检查 try (PrintStream ps = new PrintStream(client.getOutputStream(), true)) { ps.println(info); // 自动flush，确保消息即时发出 } } } } // 【单发工具】向指定客户端发送消息 public static void sendInfo(Socket client, String info) throws IOException { if (client != null && !client.isClosed()) { try (PrintStream ps = new PrintStream(client.getOutputStream(), true)) { ps.println(info); } } } // 【IP提取】从Socket获取客户端IP地址字符串 public static String getIP(Socket socket) { return socket.getInetAddress().getHostAddress(); } // 【昵称查IP】根据昵称反查IP地址（遍历哈希表value找key） public static String getIP(Hashtable<String, String> ip2nickname, String nickname) { for (Map.Entry<String, String> entry : ip2nickname.entrySet()) { if (entry.getValue().equals(nickname)) { return entry.getKey(); } } return null; // 未找到返回null } // 【IP查昵称】从Socket和哈希表获取对应昵称 public static String getNickname(Socket socket, Hashtable<String, String> ip2nickname) { String ip = getIP(socket); return ip2nickname.get(ip); } // 【UI刷新】更新在线用户列表（服务器端专用：显示"昵称@IP"） public static void updateOnLineUsersList(List onLineUsersList, Hashtable<String, String> ip2nickname) { onLineUsersList.removeAll(); // 先清空 for (Map.Entry<String, String> entry : ip2nickname.entrySet()) { onLineUsersList.add(entry.getValue() + "@" + entry.getKey()); // 昵称@IP } } // 【UI刷新】更新在线用户列表（客户端专用：只显示昵称） public static void updateOnLineUsersList(List onLineUsersList, String allNickname) { onLineUsersList.removeAll(); StringTokenizer st = new StringTokenizer(allNickname, " "); // 按空格分割 while (st.hasMoreTokens()) { String token = st.nextToken(); if (!token.startsWith("NICKNAME:")) { // 跳过前缀 onLineUsersList.add(token); } } } // 【Socket查IP】从ArrayList中根据IP找到对应Socket（用于踢人） public static Socket getSocketByIP(ArrayList<Socket> onLineUsers, String ip) { for (Socket client : onLineUsers) { try { if (client != null && client.getInetAddress().getHostAddress().equals(ip)) { return client; } } catch (IOException e) { // Socket可能已关闭，跳过 } } return null; } }

设计说明与参数详解：

• StringBuilder替代字符串拼接：getAllNickname()中若用+=拼接大量昵称，会频繁创建新String对象，StringBuilder显著提升性能；
• sendInfoToAll()中try-with-resources：确保每次PrintStream用完即关，避免文件描述符泄漏（局域网测试中易被忽略的隐形炸弹）；
• getIP()遍历entrySet()而非keys()：entrySet()一次遍历即可获取key和value，比先keys()再get()少一次哈希查找，效率更高；
• updateOnLineUsersList()客户端版用StringTokenizer：String.split()在JDK6中会创建正则引擎，开销大，StringTokenizer是轻量级分割器，更符合课设简洁原则。

4. 关键避坑指南：五个让课设挂科的致命细节与血泪修复方案

写完代码≠能跑通。我带过三届网络课设，90%的学生卡在这五个看似微小、实则致命的细节上。它们不写在教材里，但会直接导致“连不上”“消息乱码”“踢人失效”“重启后列表空白”。以下是真实翻车现场还原与可复制的修复方案。

4.1 现象：客户端启动后立即弹出“对不起，有错误，请重启程序”

原因：Client.java中BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()))创建后，Client.run()循环立即尝试br.readLine()，但此时服务器尚未发送任何数据，readLine()阻塞超时（默认无限等待），最终catch(Exception ex)捕获SocketException或IOException，触发JOptionPane报错。
解决：绝不能在Client主线程里直接读取输入流！必须交给Listener子线程处理。原始代码中Listener类缺失关键构造函数，需补全：

// Listener.java（需新建文件） import java.io.*; import java.awt.List; import javax.swing.JOptionPane; public class Listener extends Thread { private BufferedReader br; private List onLineUsersList; private List chatContentList; private volatile boolean isRunning = true; // 【关键修复】Listener必须接收InputStream，而非Socket public Listener(InputStream in, List onLineUsersList, List chatContentList) { this.br = new BufferedReader(new InputStreamReader(in)); this.onLineUsersList = onLineUsersList; this.chatContentList = chatContentList; } @Override public void run() { try { String line; while (isRunning && (line = br.readLine()) != null) { // readLine()返回null表示流关闭 processMessage(line); } } catch (IOException e) { // 流关闭是正常现象，不报错 } } private void processMessage(String msg) { if (msg.startsWith("NICKNAME:")) { // 解析在线列表 ChatTookit.updateOnLineUsersList(onLineUsersList, msg); } else { // 普通聊天消息 chatContentList.add(msg); } } public void destroy() { isRunning = false; try { if (br != null) br.close(); } catch (IOException e) { // 忽略 } } }

血泪经验：Listener必须持有一个InputStream，而非Socket。因为Socket关闭时getInputStream()返回的流才真正失效，BufferedReader才能正确检测到readLine()返回null。

4.2 现象：服务器能启动，但客户端连接后，服务器控制台不显示“X.X.X.X 来了”

原因：Server.java中onLineUsersList.add(clientIP + "@" + clientIP)执行后，Swing组件未触发重绘。java.awt.List不是javax.swing.JList，它不自动响应add()事件，需手动调用setVisible(true)或repaint()。
解决：在Server.run()中添加UI强制刷新：

// 在Server.java的accept成功后，添加这两行： onLineUsersList.add(clientIP + "@" + clientIP); onLineUsersList.getParent().validate(); // 强制父容器重绘

玄学提示：java.awt.List在不同JDK版本下渲染行为不一致，JDK6中validate()是唤醒UI的最可靠方式，比repaint()更底层。

4.3 现象：管理员执行changeNickname("A","B")后，客户端A的昵称未改变，但服务器列表已更新

原因：Service线程中存储的昵称变量是独立副本，Server.changeNickname()只更新了ip2nickname哈希表，未同步到Service实例的nickname字段。原始代码中Service类缺失changeNickname()方法实现。
解决：在Service.java中添加：

// Service.java private String nickname; // Service内部昵称变量 // ... 构造函数中初始化 this.nickname = ip2nickname.get(clientIP); public void changeNickname(String newName) { this.nickname = newName; // 同步更新本地昵称 }

踩坑总结：ip2nickname是全局状态，Service.nickname是局部状态，二者必须双向同步。管理员改名时，先改哈希表，再调用Service.changeNickname()更新局部变量。

4.4 现象：发送中文消息（如“你好”）在客户端显示为“??”乱码

原因：PrintStream默认使用平台编码（Windows为GBK），而InputStreamReader默认使用UTF-8，编解码不一致导致乱码。
解决：统一强制指定UTF-8编码：

// 在Server.java的Service构造函数中： BufferedReader br = new BufferedReader( new InputStreamReader(client.getInputStream(), "UTF-8")); // 指定输入编码 // 在Client.java的Listener构造函数中： BufferedReader br = new BufferedReader( new InputStreamReader(in, "UTF-8")); // 同样指定 // 在ChatTookit.sendInfo()中： PrintStream ps = new PrintStream(client.getOutputStream(), true, "UTF-8"); // 指定输出编码

后悔药：JDK6支持"UTF-8"字符串编码名，无需Charset.forName("UTF-8")，更简洁。

4.5 现象：多个客户端同时发送消息，服务器控制台聊天记录出现错乱（如“A说你好B说再见”连在一起）

原因：chatContentList.add()不是线程安全操作，Service线程与Server主线程并发调用，导致List内部数组状态不一致。
解决：对UI更新操作加synchronized锁，锁住chatContentList对象：

// 在Server.java的send()方法中： synchronized (chatContentList) { chatContentList.add("系统管理员：" + word); } // 在Service.java的消息处理中： synchronized (chatContentList) { chatContentList.add(nickname + "：" + msg); }

避坑本质：Swing组件不是线程安全的，所有对List、TextArea等UI组件的修改，必须在Event Dispatch Thread（EDT）或加锁保护。课设中加锁是最简单可靠的方案。

5. 答辩验收实战：从代码演示到原理问答的全流程通关策略

答辩不是代码朗诵会，而是对你是否真正理解每个Socket调用背后网络行为的现场压力测试。我带过的项目里，80%的答辩失败源于“能跑但说不清”。下面这套策略，是我帮A同学从第一次答辩被问懵，到第二次满分通过的完整复盘。它不教你背答案，而是训练你用一句话讲清原理+一行代码定位问题+一个实验验证猜想的闭环能力。

5.1 演示环节：三分钟黄金结构，让老师一眼看懂你的设计深度

不要一上来就点“运行”。按这个节奏走，三分钟建立专业可信度：

1. 第一分钟：架构图白板速绘（提前准备A4纸手绘图）

   • 画一个服务器框（标ServerSocket:8080），三个客户端框（标Client A/B/C），全部用实线箭头指向服务器，标注TCP连接；
   • 在服务器框内写两个核心数据结构：Hashtable<IP,String>（旁注“存昵称”）、ArrayList<Socket>（旁注“存连接”）；
   • 说：“老师，我的设计不是P2P直连，而是服务器中转。所有消息必须经过这里，所以能精准控制谁在线、谁被踢、谁改名——这是局域网协作的刚需。”

   为什么有效：手绘图暴露你对架构的肌肉记忆，Hashtable/ArrayList的标注证明你理解状态存储的本质，而非只会调API。

2. 第二分钟：关键功能演示+原理点睛

   • 启动服务器，再启两个客户端（A、B），让A发“测试1”，B发“测试2”，展示消息正确广播；
   • 突然关闭B客户端，观察服务器控制台是否打印“B 来了”后又出现“B 断开”（需在Service.run()中加catch(IOException)打印日志）；
   • 说：“您看到B断开时服务器没崩，因为每个客户端由独立Service线程处理，一个线程死不影响其他。这靠Server.accept()主线程持续监听，Service子线程专注单连接——这是高可用的基础。”

   为什么有效：演示不是秀功能，而是用故障场景验证你的容错设计。老师立刻明白你考虑了异常处理。

3. 第三分钟：主动抛出一个“我知道您会问”的问题

   • 在A客户端输入SPECIAL:B$SPECIAL$秘密消息，回车；
   • 展示只有B收到，A和服务器看不到；
   • 说：“这个SPECIAL协议是我自定义的应用层指令。服务器收到后，先substring(8)切掉前缀，再indexOf("$SPECIAL$")定位分隔符，最后getSocketByIP()精准投递。它不依赖TCP协议，而是构建在TCP之上的简单规则——这就是应用协议设计的思想。”

   为什么有效：主动揭示协议设计，把“抄代码”升维到“设计协议”，直击课程设计目的。

5.2 问答环节：高频问题应答模板与底层原理溯源

老师的问题永远围绕三个维度：为什么选这个技术？这个代码会出什么问题？怎么证明它解决了问题？以下是真实高频问题及应答逻辑（附原理出处）：

5.3 验收清单：答辩前必须亲手验证的七项硬指标

别信“应该没问题”。拿出一张纸，逐项打钩，这是你答辩底气的来源：
| 验收项 | 验证方法 | 通过标准

本文还有配套的精品资源，点击获取