互联网编程：实验二多线程/线程池TCP服务器端程序设计

起床悠悠

于 2024-09-02 00:00:00 发布

阅读量283

点赞数 19

分类专栏： Java 互联网编程文章标签： tcp/ip 网络协议网络 java

本文链接：https://blog.csdn.net/gyeolhada/article/details/141758280

版权

Java 同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

互联网编程

2 篇文章 0 订阅

订阅专栏

1.多线程TCP服务器：

改写socket服务器端程序，设计编写出一个TCP服务器端程序：要求使用多线程处理多个客户端的连接请求（每个线程实例处理一个客户端连接）。客户端与服务器端之间的通信内容，以及服务器端的处理功能等可自由设计拓展。

（1）主要思路：

多线程处理客户端连接：

修改服务器端程序，作为多线程TCP服务器时，首先需要确保服务器能够同时处理多个客户端的连接请求，即在服务器端程序中，需要为每个客户端连接创建一个独立的线程来处理通信。具体为其在接受到新的客户端连接请求时，为每个连接创建一个新的线程来处理。这样可以确保每个客户端连接都有独立的线程来处理通信，避免阻塞主线程。

客户端与服务器端通信：

确保客户端和服务器端之间的通信能够正常进行。客户端应该能够向服务器发送消息，并且服务器能够接收到并处理这些消息。同样地，服务器应该能够向客户端发送消息。

（2）具体步骤与实现代码：

TCPServer类：

多线程TCP服务器能够处理多个客户端的连接请求，并且能够与客户端进行通信。

服务器初始化：创建一个TCPServer类，其中包括一个构造函数和一个main方法。构造函数初始化了服务器的GUI实例和客户端处理器映射。服务器的GUI实例用于显示服务器日志和在线用户列表，客户端处理器映射用于存储连接到服务器的客户端处理器。
启动服务器：tartTCPServer()方法用于启动服务器，监听客户端的连接请求。它创建了一个ServerSocket实例，指定了服务器要监听的端口号9999。然后，通过一个无限循环持续接受客户端连接。
处理客户端连接：每当有新的客户端连接时，服务器会创建一个新的ClientHandler实例来处理该客户端的连接。ClientHandler负责与客户端进行通信，并在接收到消息时转发给服务器。为了处理多个客户端连接，服务器为每个客户端连接创建一个独立的线程。这样可以确保每个客户端连接都能够独立地进行通信，不会受到其他连接的影响。
发送消息：服务器提供了向所有客户端发送消息和向特定客户端发送消息的方法。这些方法在接收到消息后，将消息发送给相应的客户端处理器，并在日志中记录发送的消息。
客户端断开连接处理：当客户端断开连接时，服务器会从在线用户列表中移除相应的客户端处理器，并在日志中记录该客户端已断开连接的消息。
主方法：main方法创建了TCPServer实例，并调用startTCPServer()方法启动服务器。
实现代码：

package experiment2;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
/*
服务器
*/
public class TCPServer {
//服务器GUI实例
private static ServerGUI serverGUI;
//存储客户端处理器的映射(实现为指定客户端服务)
private static Map<String,ClientHandler> clients;
//初始化服务器
public TCPServer(){
serverGUI = new ServerGUI(this);
clients = new HashMap<>();//使用哈希Map
}
//启动服务器,监听客户端连接
public void startTCPServer(){
try{
//创建服务器的Socket,监听指定端口号
ServerSocket serverSocket = new ServerSocket(9999);
serverGUI.logMessage("服务器已启动，等待客户端连接...");
//给每个用户分配特定编号
int clientCounter = 0;
//创建一个新线程来处理这个客户端的连接(客户端处理器)
while(true){
//持续接受客户端连接
Socket clientSocket = serverSocket.accept();
clientCounter ++;
String clientName = String.valueOf(clientCounter);
serverGUI.logMessage("客户端"+clientName+"已连接");
ClientHandler clientHandler = new ClientHandler(clientSocket,serverGUI,clientName);
//将客户端唯一编号和此客户端处理器一一对应
clients.put(clientName,clientHandler);
serverGUI.addClientHandler(clientHandler);
//启动此线程
new Thread(clientHandler).start();
}
}catch (IOException e){
e.printStackTrace();
}
}
//向所有客户端发送消息
public void sendToAllClients(String message){
serverGUI.logMessage("服务器发送给所有客户端："+message);
//获取所有客户端处理线程，向每个客户端发送消息
for(ClientHandler clientHandler : serverGUI.getClientHandlers()){
clientHandler.setToClient(message);
}
}
//向特定客户端发送消息
public void sendToOneClient(String clientName, String message) {
if (clients.containsKey(clientName)) {
serverGUI.logMessage("服务器发送给客户端"+clientName+": "+message);
clients.get(clientName).setToClient(message);
} else {
serverGUI.logMessage("客户端 " + clientName + " 不存在或已断开连接");
}
}
//客户端断开连接时从在线用户列表中移除对应的客户端处理器
public static void clientDisconnected(String clientName){
serverGUI.removeClientHandler(clients.get(clientName));
clients.remove(clientName);
serverGUI.logMessage("客户端"+clientName+"已断开连接");
}
//服务器需要main可独立启动
public static void main(String[] args){
TCPServer tcpServer = new TCPServer();
tcpServer.startTCPServer();
}
}

TCPClient类：

客户端能够连接到服务器并进行消息通信。收到的服务器消息会显示在客户端GUI中，并且客户端能够通过GUI向服务器发送消息。

客户端初始化：TCPClient类有一个构造函数，接受三个参数：客户端名称、服务器地址“localhost”和端口号9999。同时，客户端GUI实例被创建，并且连接到服务器。
连接到服务器：在构造函数中，客户端创建了一个Socket实例，用于连接到指定的服务器地址和端口号。如果连接成功，客户端GUI会显示连接成功的消息。
获取输入输出流：一旦连接建立，客户端通过socket.getInputStream()和socket.getOutputStream()获取输入输出流。这样客户端就能够接收从服务器发送的消息，并向服务器发送消息。
处理接收消息：客户端通过创建一个新的线程来处理接收消息。在这个线程中，客户端持续地从输入流中读取消息，并将其显示在客户端GUI中。如果接收到的消息为null，说明服务器关闭了连接，客户端停止接收消息并退出线程。
发送消息：客户端GUI提供了一个方法setMessageSender，用于设置消息发送器。这个方法接受一个PrintWriter作为参数，用于将消息发送给服务器。客户端可以通过调用这个方法发送消息给服务器。
实现代码：

package experiment2;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class TCPClient {
private ClientGUI clientGUI;
public TCPClient(String clientName,String serverAddress,int port){
this.clientGUI = new ClientGUI(clientName);
try{
Socket socket = new Socket(serverAddress,port);
clientGUI.logMessage("连接到服务器成功");
// 获取输入输出流
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter writer = new PrintWriter(socket.getOutputStream(),true);
// 创建一个新线程来处理接收消息
Thread receiveThread = new Thread(()->{
String message;
try{
while((message = reader.readLine()) != null){
clientGUI.logMessage("服务器发来消息: " + message);
}
}catch(IOException e){
e.printStackTrace();
}
});
// 主线程用于发送消息
receiveThread.start();
clientGUI.setMessageSender(writer::println);
}catch(IOException e){
e.printStackTrace();
}
}
}

ClientHandler类：

客户端处理器能够处理客户端的连接，接收到客户端消息时将其显示在服务器GUI中。

客户端处理器初始化：ClientHandler类有一个构造函数，接受三个参数：客户端Socket、服务器GUI实例和客户端名称。在构造函数中，客户端处理器保存了对客户端Socket和服务器GUI的引用，并初始化了一个用于向客户端发送消息的PrintWriter。
向客户端发送消息：setToClient()方法用于向客户端发送消息。它接受一个消息参数，并通过客户端的PrintWriter将消息发送给客户端。
处理客户端消息接收：在run()方法中，客户端处理器创建了一个用于读取客户端消息的BufferedReader。然后，通过一个无限循环持续监听客户端发送的消息。当客户端发送消息时，服务器GUI会记录该消息，并在服务端窗口中显示客户端名称和消息内容。
实现代码：

package experiment2;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
/*
处理客户端的连接的线程（客户端处理器）
*/
public class ClientHandler implements Runnable{
private final Socket clientSocket;//客户端Socket
private final ServerGUI serverGUI;//服务端GUI实例
private PrintWriter clientWriter;//用于向客户端发送消息的写入器
private String clientName;//客户端名称
//构造函数，初始化客户端处理器
public ClientHandler(Socket clientSocket, ServerGUI serverGUI, String clientName){
this.clientSocket = clientSocket;
this.serverGUI = serverGUI;
this.clientName = clientName;
try{
clientWriter = new PrintWriter(clientSocket.getOutputStream(),true);
}catch (IOException e){
e.printStackTrace();
}
}
//向客户端发送消息的方法
public void setToClient(String message){
clientWriter.println(message);
}
//线程运行方法，处理客户端的消息接收
@Override
public void run() {
try{//创建用于读取客户端消息的读取器
BufferedReader reader = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream())
);
String message;//持续监听客户端发来的消息
while((message = reader.readLine()) != null){
//在服务端的窗口中显示客户端发来的消息
serverGUI.logMessage("客户端"+clientName+"发来消息: " + message);
}
reader.close();
clientSocket.close();
}catch (IOException e){
e.printStackTrace();
}
}
public String getClientName() {
return clientName;
}
}

ServerGUI类：

主要用于展示服务器日志、输入消息并发送给客户端。

初始化界面：在构造函数中，创建了一个名为 "Server" 的主窗口，并设置了关闭操作为退出整个应用程序。创建了一个用于显示服务器日志的文本区域 textArea，并将其放置在主窗口的中央位置。创建了一个用于输入消息的文本框 messageTextField，以及两个发送按钮 sendToAllButton 和 sendToButton。创建了一个用于显示在线用户列表的 JList 组件 userList，并将其放置在主窗口的右侧位置。在线用户列表使用 DefaultListModel 来管理。
按钮事件监听器：为 "发送给所有客户" 按钮添加了点击事件监听器，当点击按钮时，将获取输入的消息内容，并通过服务器实例发送给所有客户端。为 "发送" 按钮添加了点击事件监听器，当点击按钮时，将获取输入的消息内容，并通过服务器实例发送给选定的特定客户端。
消息日志处理：使用 logMessage() 方法向服务器日志文本区域添加消息。这个方法通过 SwingUtilities.invokeLater() 来确保在事件分发线程中更新界面，以避免多线程并发问题。
在线用户列表管理：addClientHandler() 方法用于向客户端处理器列表添加新的客户端处理器，并将其对应的客户端名称添加到在线用户列表中。removeClientHandler() 方法用于移除客户端处理器，并将对应的客户端名称从在线用户列表中移除。
实现代码：

package experiment2;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
/*
服务端的GUI类
*/
public class ServerGUI {
private final JTextArea textArea;//用于显示服务器日志的文本区域
private JTextField messageTextField;//用于输入要发送的消息的文本框
private JButton sendToAllButton;//发送给所有客户端的按钮
private JButton sendToButton;//发送给特定客户端的按钮
private TCPServer server;//服务器实例
private List<ClientHandler> clientHandlers;//存储客户端处理器的列表
private JList<String>userList;//显示在线用户列表
private DefaultListModel<String>userListModel;//用户列表模型
public ServerGUI(TCPServer server) {
this.server = server;
clientHandlers = new ArrayList<>();
//创建主窗口
JFrame frame = new JFrame("Server");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);
//创建用于显示服务器日志的文本区域
textArea = new JTextArea();
textArea.setEditable(false);
//创建滚动面板用于放置文本区域
JScrollPane scrollPane = new JScrollPane(textArea);
frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
//创建用于输入消息的文本框和发送按钮
messageTextField = new JTextField();
JButton sendToAllButton = new JButton("发送给所有客户");
JButton sendToButton = new JButton("发送");
//在线用户列表
userListModel = new DefaultListModel<>();
userList = new JList<>(userListModel);
JScrollPane userListScrollPane = new JScrollPane(userList);
userListScrollPane.setPreferredSize(new Dimension(100,0));
//创建输入面板和按钮面板
JPanel inputPanel = new JPanel(new BorderLayout());
JPanel buttonPanel = new JPanel(new FlowLayout());
//将按钮放入按钮面板
buttonPanel.add(sendToAllButton);
buttonPanel.add(sendToButton);
//将按钮面板赫尔输入文本框都放入输入面板
inputPanel.add(messageTextField, BorderLayout.NORTH);
inputPanel.add(buttonPanel, BorderLayout.CENTER);
//将输入面板放在主窗口的下方
frame.getContentPane().add(inputPanel, BorderLayout.SOUTH);
//将用户列表放在主窗口的右侧
frame.getContentPane().add(userListScrollPane,BorderLayout.EAST);
//为"发送给所有客户"按钮添加点击事件监听器
sendToAllButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String message = messageTextField.getText();
if (!message.isEmpty()) {
server.sendToAllClients(message);
}
}
});
//为"发送"按钮添加点击事件监听器
sendToButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String message = messageTextField.getText();
if (!message.isEmpty()) {
int selectedIndex = userList.getSelectedIndex();
if(selectedIndex != -1){
String selectedClientName = userListModel.getElementAt(selectedIndex);
server.sendToOneClient(selectedClientName,message);
}
}
}
});
//设置主窗口可见
frame.setVisible(true);
}
//用于向服务器日志文本区域添加消息
public void logMessage(String message) {
SwingUtilities.invokeLater(() -> textArea.append(message + "\n"));
}
//用于向客户端处理器列表添加新的客户端处理器
public void addClientHandler(ClientHandler clientHandler) {
clientHandlers.add(clientHandler);
SwingUtilities.invokeLater(() -> userListModel.addElement(clientHandler.getClientName()));
}
//客户端下线则删掉此客户端处理器
public void removeClientHandler(ClientHandler clientHandler) {
clientHandlers.remove(clientHandler);
SwingUtilities.invokeLater(() -> userListModel.removeElement(clientHandler.getClientName()));
}
//获取客户端处理器列表
public List<ClientHandler> getClientHandlers() {
return clientHandlers;
}
}

ClientGUI类：

用于显示客户端消息、输入要发送的消息，并通过消息发送接口发送消息给服务器。

初始化界面：在构造函数中，创建了一个名为 "Client"+客户端编号的主窗口，并设置了关闭操作为退出整个应用程序。创建了一个用于显示客户端消息的文本区域 textArea，并将其放置在主窗口的中央位置。创建了一个用于输入消息的文本框 messageTextField，以及一个发送按钮 sendButton，用于发送消息。
消息发送接口：定义了一个消息发送接口 MessageSender，其中包含一个方法 sendMessage(String message)，用于在按钮点击时发送消息。
按钮事件监听器：为发送按钮 sendButton 添加了点击事件监听器，当点击按钮时，将获取输入的消息内容，并通过消息发送接口发送给服务器。在按钮点击事件中，调用了 logMessage() 方法将发送的消息显示在客户端的文本区域中，并通过消息发送接口 messageSender 发送给服务器。
消息日志处理：使用 logMessage() 方法向客户端消息文本区域添加消息。这个方法通过 SwingUtilities.invokeLater() 来确保在事件分发线程中更新界面，以避免多线程并发问题。
实现代码：

package experiment2;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/*
客户端的GUI类
*/
public class ClientGUI {
private final JTextArea textArea;//用于显示客户端消息的文本区域
private final JTextField messageTextField;//用于输入要发送的消息的文本框
private MessageSender messageSender;//消息发送接口
//定义消息发送接口，用于在按钮点击时发送消息
public interface MessageSender{
void sendMessage(String message);
}
//设置消息发送接口
public void setMessageSender(MessageSender messageSender) {
this.messageSender = messageSender;
}
//构造函数，创建客户端GUI界面
public ClientGUI(String clientName){
JFrame frame = new JFrame("Client"+clientName);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300,300);
//创建文本区域，用于显示客户端消息
textArea = new JTextArea();
textArea.setEditable(false);
//创建滚动面板放置文本区域
JScrollPane scrollPane = new JScrollPane(textArea);
frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
//创建文本框和发送按钮，用于输入和发送消息
messageTextField = new JTextField();
JButton sendButton = new JButton("发送");
//创建输入面板，包含文本框和发送按钮
JPanel inputPanel = new JPanel();
inputPanel.setLayout(new BorderLayout());
inputPanel.add(messageTextField, BorderLayout.CENTER);
inputPanel.add(sendButton, BorderLayout.EAST);
//将输入面板放在主窗口的下方
frame.getContentPane().add(inputPanel, BorderLayout.SOUTH);
//为发送按钮添加点击事件监听器
sendButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String message = messageTextField.getText();
if(!message.isEmpty()){
//在文本区域显示发送的消息并通过接口发送给服务器
logMessage("客户端"+clientName+": "+message);
messageTextField.setText("");
messageSender.sendMessage(message);
}
}
});
//设置主窗口可见
frame.setVisible(true);
}
//用于文本区域显示客户端消息
public void logMessage(String message){
SwingUtilities.invokeLater(()->textArea.append(message+"\n"));
}
}

TestTCP类：

用于启动多个客户端连接到服务器。

循环创建多个客户端：通过循环创建多个客户端，每个客户端使用不同的名称（例如，1、2、3、4、5）。每个客户端连接到指定的服务器地址和端口号9999（9999也是上面服务器监听的端口号）。多个客户端同时连接到服务器。这样可以模拟多个不同的用户或设备与服务器进行通信。
客户端连接到服务器：在循环中，创建了 TCPClient 的实例，传入了客户端名称、服务器地址和端口号。在 TCPClient 的构造函数中，创建了与服务器的连接，并启动了接收和发送消息的线程。
实现代码：

package experiment2;
public class TestTCP {
public static void main(String[] args){
String serverAddress = "localhost";
int port = 9999;
for(int i=1;i<=5;i++)
{
String clientName = String.valueOf(i);
TCPClient client = new TCPClient(clientName,serverAddress,port);
}
}
}

2.线程池TCP服务器：

改写socket服务器端程序，设计编写出一个TCP服务器端程序：要求使用线程池处理客户端的连接请求。相应需修改socket客户端程序：从本地一个txt文件（注意：客户端的此txt文件称为信源txt文件，该txt测试数据文件可自由选择或创建，只要里面包含至少10行字符串即可），逐行读取出来，每一行作为一句话，发送给服务器，服务器每收到一个客户端的一句话，就将其保存在服务器本地的一个专用于存放与该客户端通信内容的txt文件中（注意：称为通信记录txt文件，来自不同的客户端的信息需保存在不同的txt文件中，需多少个txt文件应在程序中自动根据实际连接的客户端数量自动创建），服务器还会计算每一个通信记录txt文件的安全算法摘要，将安全算法摘要和该通信记录txt文件名一起写入到服务器中一个名为SafeAbstract.txt的文件中。

（1）主要思路：

线程池TCP服务器：

创建一个线程池来处理客户端的连接请求，使用ExecutorService线程池对象，ExecutorService是JAVA提供的一个线程池框架，用于管理和调度线程执行任务。

客户端读取发送与服务器存储：

客户端从本地的一个txt文件，即信源txt文件，逐行读取出来，而且每一行作为一句话发送给服务器。服务器每收到一个客户端的一句话，把它保存在与此客户端特定的通信记录txt文件中。

服务器计算安全算法摘要：

线程池TCP服务器计算每一个客户端通信记录txt文件的安全算法摘要，并且将安全算法摘要和该通信记录txt文件名一起写入到服务器中一个名为SafeAbstract.txt文件中。使用MessageDigest消息摘要对象。MessageDigest是JAVA提供的一个安全哈希函数的类，且使用MD5哈希算法来对通信记录进行逐行加密，得到安全算法摘要。

（2）具体步骤与实现代码：

ExecutorTCPServer类：

使用线程池处理客户端连接请求的TCP服务器。

定义常量和变量：定义了常量 PORT 和 THREAD_POOL_SIZE，分别表示服务器监听的端口号和线程池的大小，即同时处理的客户端连接数。定义AtomicInteger 类型的 clientCount 来为每个客户端分配唯一的ID。
AtomicInteger：在多线程环境中，多个线程可能同时对共享变量进行读写操作，这可能导致竞态条件的发生，从而导致数据不一致或其他意外结果。使用 AtomicInteger 可以保证对clientCount的增加操作是原子的，即不可被中断的单个操作，不会出现竞态条件。
创建线程池： 使用 Executors.newFixedThreadPool(THREAD_POOL_SIZE) 创建一个固定大小为3的线程池。当有新的任务到来时，如果线程池中有空闲的线程，则会立即执行任务；如果线程池中的线程都在执行任务，新的任务会被暂时存储在一个任务队列中，等待有空闲的线程来执行。
创建服务器Socket并监听端口： 使用 ServerSocket 创建服务器Socket，并在指定的端口上监听客户端的连接请求。
接受客户端连接： 通过 serverSocket.accept() 方法等待客户端的连接请求，一旦有客户端连接请求到来，就会返回一个与客户端通信的Socket对象。
为每个客户端连接分配唯一ID，并交给线程池处理： 每当有新的客户端连接到来时，为其分配唯一的ID，并将客户端连接交给线程池处理，执行 EClientHandler 类中的任务。
关闭线程池和服务器Socket： 当服务器不再接受新的客户端连接请求时，关闭线程池，释放资源。
实现代码：

package experiment2;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class ExecutorTCPServer {
//服务器监听的端口号
private static final int PORT = 12345;
//线程池大小，即同时处理的客户端连接数
private static final int THREAD_POOL_SIZE = 3;
//客户端计数器，给每个客户端分配唯一ID
private static AtomicInteger clientCount = new AtomicInteger(0);
public static void main(String[] args){
//创建一个固定大小的线程池
//ExecutorService 是 Java 提供的一个线程池框架，用于管理和调度线程执行任务
ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try(ServerSocket serverSocket = new ServerSocket(PORT)){
System.out.println("服务器启动，正在监听端口"+PORT);
//持续接受客户端的连接
while(true){
//等待客户端连接，并返回与客户端通信的Socket对象
Socket clientSocket = serverSocket.accept();
//为新连接的客户端分配唯一的ID
int clientID = clientCount.incrementAndGet();
//将客户端连接交给线程池处理
executor.execute(new EClientHandler(clientSocket,clientID));
System.out.println("服务器已与客户端"+String.valueOf(clientID)+"连接。");
}
}catch (IOException e){
e.printStackTrace();
}finally {
//关闭线程池
executor.shutdown();
}
}
}

EClient类：

实现与服务器的通信，并能够将指定文件中的数据逐行发送到服务器。

定义常量：定义了常量 FILE_PATH，表示客户端要读取的文件路径；SERVER_ADDRESS 和 SERVER_PORT 分别表示服务器的地址和端口号。
建立与服务器的连接：使用 Socket 类创建与服务器的Socket连接，通过提供服务器的地址和端口号，向服务器发起连接请求。
初始化资源：使用 try-with-resources 结构，初始化了 Socket、BufferedReader 和 PrintWriter 这些资源。这样做的好处是，在使用完这些资源后，它们会自动关闭，无需手动调用 close() 方法关闭资源。
发送数据到服务器： 在与服务器建立连接后，使用 BufferedReader 从指定的文件中逐行读取数据。然后使用 PrintWriter 将每一行数据发送到服务器。发送完成后，通过 println() 方法将数据发送给服务器，并在控制台打印已发送的数据。
实现代码：

package experiment2;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
public class EClient {
public static void main(String[] args) {
//定义客户端要读取的文件路径
final String FILE_PATH = "client_data.txt";
//定义服务器的地址和端口号
final String SERVER_ADDRESS = "localhost";
final int SERVER_PORT = 12345;
try(
// 创建与服务器的Socket连接
Socket socket = new Socket(SERVER_ADDRESS,SERVER_PORT);
// 创建文件读取的BufferedReade
BufferedReader fileReader = new BufferedReader(new FileReader(FILE_PATH));
// 创建向服务器发送数据的PrintWriter
PrintWriter writer = new PrintWriter(socket.getOutputStream(),true);
){
System.out.println("已连接到服务器");
String line;
// 逐行读取文件内容并发送到服务器
while((line = fileReader.readLine())!=null){
// 将读取的每一行数据发送到服务器
writer.println(line);
System.out.println("发送:"+line);
}
}catch (IOException e){
e.printStackTrace();
}
}
}

EClientHandler类：

实现对客户端请求的处理，包括数据的接收、写入文件、计算安全摘要等功能。

处理客户端数据： 在 run() 方法中，通过 BufferedReader 从客户端Socket中获取输入流，并通过 BufferedWriter 将数据写入服务器的文件中。每个客户端连接都会生成一个独立的通信记录文件，文件名包含了客户端的ID。
计算安全摘要： 在处理完客户端的数据后，使用 BufferedReader 读取刚刚写入的通信记录文件。逐行读取文件内容，并使用MD5哈希计算每行数据的安全摘要，然后将文件名和对应的摘要写入到安全摘要文件中。
MessageDiagest：MessageDigest 是 Java 提供的一个安全哈希函数的类。它用于计算数据的哈希值，常用于实现数字签名算法、数据完整性校验等安全相关的功能。它使用了一种称为消息摘要算法（Message Digest Algorithm）的技术来实现。常见的消息摘要算法包括 MD5、SHA-1、SHA-256 等。通过 MessageDigest.getInstance("algorithm") 方法来获取 MessageDigest 实例，其中 "algorithm" 是指定的哈希算法的名称，例如 "MD5"、"SHA-1" 等。在这里我使用MD5的算法。获取到 MessageDigest 实例后就可以使用 update(byte[]) 方法来更新摘要信息，然后使用 digest() 方法来计算最终的哈希值。
实现代码：

package experiment2;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class EClientHandler implements Runnable{
private Socket clientSocket;// 客户端Socket连接
private int clientID;// 客户端ID
// 服务器文件目录
private static final String SERVER_DIRECTORY = "server_files/";
// 安全摘要文件名
private static final String SAFE_ABSTRACT_FILE = "SafeAbstract.txt";
// 构造函数，初始化客户端Socket和ID
public EClientHandler(Socket clientSocket,int clientID){
this.clientSocket = clientSocket;
this.clientID = clientID;
}
@Override
public void run() {
try(
// 创建从客户端读取数据的BufferedReader
BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
// 创建向服务器写入数据的BufferedWriter，追加写入模式，用于写入文件
BufferedWriter writer = new BufferedWriter(new FileWriter(SERVER_DIRECTORY+"client_"+clientID+"commute.txt",true));
// 创建写入安全摘要的BufferedWriter，追加写入模式，用于写入文件
BufferedWriter safeAbstractWriter = new BufferedWriter(new FileWriter(SERVER_DIRECTORY+SAFE_ABSTRACT_FILE,true))
){
String line;
// 逐行读取客户端发送的数据
while ((line = reader.readLine())!=null){
// 将读取的数据写入到与该客户端通信的专用文件中
writer.write(line);
writer.newLine();
writer.flush();
}
// 打开与该客户端的通信记录文件，每行读取文件里的内容并使用安全摘要
try(BufferedReader fileReader = new BufferedReader(new FileReader(SERVER_DIRECTORY+"client_"+clientID+"commute.txt"))){
String fileLine;
// 先写入文件名
safeAbstractWriter.write("client_"+clientID+"commute.txt");
safeAbstractWriter.newLine();
safeAbstractWriter.flush();
// 逐行读取文件内容并计算安全摘要
while((fileLine = fileReader.readLine())!=null){
//计算安全摘要
safeAbstractWriter.write(calculateSafeAbstract(fileLine));
safeAbstractWriter.newLine();
safeAbstractWriter.flush();
}
}catch (IOException e){
e.printStackTrace();
}
}catch (IOException e){
e.printStackTrace();
}finally {
try{
// 关闭客户端Socket连接
clientSocket.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
// 计算安全摘要的方法
private String calculateSafeAbstract(String text){
//使用安全哈希算法MD5
try{
// 创建MD5消息摘要对象
MessageDigest md5 = MessageDigest.getInstance("MD5");
// 更新摘要信息
md5.update(text.getBytes(StandardCharsets.UTF_8));
// 计算摘要
// MessageDigest 的 digest() 方法会返回一个字节数组（byte[]），这个字节数组包含了计算出来的哈希值。通常情况下，哈希值是以字节数组的形式表示的，每个字节都对应着哈希值中的一部分信息。
byte[] digest = md5.digest();
// 将字节数组转换为十六进制字符串，十六进制字符串更容易阅读和比较，
StringBuilder sb = new StringBuilder();
for(byte b:digest){
// %02x格式化为一个宽度为两个字符的十六进制表示，不足两个字符时，用零进行填充。
sb.append(String.format("%02x",b));
}
return sb.toString();
}catch (NoSuchAlgorithmException e){
e.printStackTrace();
return null;
}
}
}

3.编程扩充线程池TCP服务器的功能，增加日志功能模块：

日志记录的内容和日志存储方式可自定（比如可以记录客户端的连接时间、客户端IP等，日志存储为.TXT或.log文件等），在线程池服务器程序中调用该日志程序模块，使线程池TCP服务器具备日志功能，注意线程之间的同步操作处理。

（1）主要思路：

日志记录器：

创建Logger类，用于记录日志。该类应该包含方法来记录不同事件的日志，例如服务器事件、客户端连接、客户端断开连接等。要记录的内容包括客户端连接时间、客户端IP等。日志的存储方式选择将日志记录到文本文件server_log.txt中。

在线程池服务器程序中调用日志程序模块：

在服务器程序中合适的位置调用日志记录器类的方法，记录服务器的关键事件，如服务器启动、客户端连接、客户端断开连接等。

（2）具体步骤与实现代码：

Logger类：

作为日志记录器可以在服务器程序中被调用，用于记录服务器的关键事件和客户端的连接信息。

记录客户端连接： logConnection(Socket clientSocket) 方法用于记录客户端连接的信息。在方法中，通过 clientSocket.getInetAddress() 获取客户端的 IP 地址，并调用 getHostAddress() 方法获取 IP 地址的字符串表示形式，然后将连接时间和 IP 地址信息写入日志文件。
记录客户端断开： logDisconnection() 方法用于记录客户端断开连接的信息。在方法中，获取当前时间，并将断开连接的时间写入日志文件。
记录服务器事件： logServerEvent(String event) 方法用于记录服务器事件的信息。在方法中，接受一个事件字符串作为参数，并在事件字符串前加上时间戳，然后将整个事件信息写入日志文件。
线程同步：使用 synchronized 关键字修饰了 logConnection ,logDisconnection, logServerEvent 方法，确保在多线程环境中对日志文件的写入操作是同步的，避免多个线程同时写入导致的数据不一致性问题。
实现代码：

package experiment2;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Logger {
// 定义服务器日志的文件名称
private static final String LOG_FILE = "server_log.txt";
// 记录客户端连接的信息
public static synchronized void logConnection(Socket clientSocket){
try(PrintWriter writer = new PrintWriter((new FileWriter(LOG_FILE,true)))){
Date now = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String nowDate = dateFormat.format(now);
// 返回的是 InetAddress 类型的对象，代表了客户端的IP地址
InetAddress clientAddress = clientSocket.getInetAddress();
// clientAddress.getHostAddress(): 这是 InetAddress 类的方法，用于获取 IP 地址的字符串表示形式。返回的是客户端的 IP 地址的字符串形式。
writer.println("["+nowDate+"]"+"新的客户端连接IP地址"+clientAddress.getHostAddress());
}catch (IOException e){
e.printStackTrace();
}
}
// 记录客户端断开的信息
public static synchronized void logDisconnection() {
try(PrintWriter writer = new PrintWriter((new FileWriter(LOG_FILE,true)))){
Date now = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String nowDate = dateFormat.format(now);
writer.println("["+nowDate+"]"+"客户端断开连接");
}catch (IOException e){
e.printStackTrace();
}
}
// 记录服务器操作信息
public static synchronized void logServerEvent(String event){
try(PrintWriter writer = new PrintWriter(new FileWriter(LOG_FILE,true))){
Date now = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String nowDate = dateFormat.format(now);
writer.println("["+nowDate+"]"+event);
}catch (IOException e){
e.printStackTrace();
}
}
}