// TcpServer.java
|
package home;
|
|
import java.io.*;
|
import java.net.BindException;
|
import java.net.InetAddress;
|
import java.net.ServerSocket;
|
import java.net.Socket;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
public class TcpServer extends NetworkBase {
|
private ServerSocket serverSocket;
|
private ExecutorService acceptorThread;
|
private ConcurrentHashMap<String, ClientHandler> clients = new ConcurrentHashMap<>();
|
private ClientListListener clientListListener;
|
|
public interface ClientListListener {
|
void onClientListChanged(java.util.List<String> clients);
|
}
|
|
public void setClientListListener(ClientListListener listener) {
|
this.clientListListener = listener;
|
}
|
|
public TcpServer(String host, int port) {
|
this.host = host;
|
this.port = port;
|
}
|
|
@Override
|
public boolean start() throws Exception {
|
try {
|
InetAddress localAddress = InetAddress.getByName(host);
|
serverSocket = new ServerSocket(port, 50, localAddress);
|
|
isRunning.set(true);
|
startAcceptor();
|
notifyStatus("TCP服务器已启动 - " + host + ":" + port, true);
|
return true;
|
|
} catch (BindException e) {
|
notifyError("端口 " + port + " 被占用，请选择其他端口");
|
return false;
|
} catch (Exception e) {
|
notifyError("启动TCP服务器失败: " + e.getMessage());
|
return false;
|
}
|
}
|
|
@Override
|
public void stop() {
|
isRunning.set(false);
|
try {
|
for (ClientHandler client : clients.values()) {
|
client.stop();
|
}
|
clients.clear();
|
updateClientList();
|
|
if (serverSocket != null && !serverSocket.isClosed()) {
|
serverSocket.close();
|
}
|
} catch (Exception e) {
|
// 忽略关闭时的异常
|
}
|
if (acceptorThread != null) {
|
acceptorThread.shutdownNow();
|
}
|
notifyStatus("TCP服务器已停止", false);
|
}
|
|
@Override
|
public boolean sendData(String data) throws Exception {
|
// TCP服务器可以向所有客户端或特定客户端发送数据
|
// 这里简单实现向所有客户端发送
|
boolean sent = false;
|
for (ClientHandler client : clients.values()) {
|
if (client.sendData(data)) {
|
sent = true;
|
}
|
}
|
return sent;
|
}
|
|
/**
|
* 发送字节数据到所有客户端
|
*/
|
public boolean sendData(byte[] data) throws Exception {
|
boolean sent = false;
|
for (ClientHandler client : clients.values()) {
|
if (client.sendData(data)) {
|
sent = true;
|
}
|
}
|
return sent;
|
}
|
|
/**
|
* 发送字节数据到特定客户端
|
*/
|
public boolean sendDataToClient(String clientKey, byte[] data) throws Exception {
|
ClientHandler client = clients.get(clientKey);
|
if (client != null) {
|
return client.sendData(data);
|
}
|
return false;
|
}
|
|
@Override
|
public boolean isConnected() {
|
return isRunning.get() && serverSocket != null && !serverSocket.isClosed();
|
}
|
|
private void startAcceptor() {
|
acceptorThread = Executors.newSingleThreadExecutor();
|
acceptorThread.execute(() -> {
|
while (isRunning.get() && serverSocket != null && !serverSocket.isClosed()) {
|
try {
|
Socket clientSocket = serverSocket.accept();
|
ClientHandler clientHandler = new ClientHandler(clientSocket);
|
String clientKey = clientSocket.getInetAddress().getHostAddress() + ":" + clientSocket.getPort();
|
clients.put(clientKey, clientHandler);
|
updateClientList();
|
notifyStatus("客户端连接: " + clientKey, true);
|
|
} catch (Exception e) {
|
if (isRunning.get()) {
|
notifyError("接受客户端连接错误: " + e.getMessage());
|
}
|
}
|
}
|
});
|
}
|
|
private void updateClientList() {
|
if (clientListListener != null) {
|
clientListListener.onClientListChanged(new java.util.ArrayList<>(clients.keySet()));
|
}
|
}
|
|
private class ClientHandler {
|
private Socket socket;
|
private OutputStream outputStream;
|
private InputStream inputStream;
|
private ExecutorService receiverThread;
|
private AtomicBoolean running = new AtomicBoolean(true);
|
|
public ClientHandler(Socket socket) throws Exception {
|
this.socket = socket;
|
this.outputStream = socket.getOutputStream();
|
this.inputStream = socket.getInputStream();
|
startReceiver();
|
}
|
|
public boolean sendData(String data) {
|
if (outputStream != null && !socket.isClosed()) {
|
try {
|
outputStream.write(data.getBytes());
|
outputStream.flush();
|
return true;
|
} catch (IOException e) {
|
return false;
|
}
|
}
|
return false;
|
}
|
|
public boolean sendData(byte[] data) {
|
if (outputStream != null && !socket.isClosed()) {
|
try {
|
outputStream.write(data);
|
outputStream.flush();
|
return true;
|
} catch (IOException e) {
|
return false;
|
}
|
}
|
return false;
|
}
|
|
public void stop() {
|
running.set(false);
|
try {
|
if (outputStream != null) outputStream.close();
|
if (inputStream != null) inputStream.close();
|
if (socket != null) socket.close();
|
} catch (Exception e) {
|
// 忽略关闭时的异常
|
}
|
if (receiverThread != null) {
|
receiverThread.shutdownNow();
|
}
|
}
|
|
private void startReceiver() {
|
receiverThread = Executors.newSingleThreadExecutor();
|
receiverThread.execute(() -> {
|
byte[] buffer = new byte[1024];
|
while (running.get() && socket != null && !socket.isClosed()) {
|
try {
|
int bytesRead = inputStream.read(buffer);
|
if (bytesRead > 0) {
|
byte[] receivedData = new byte[bytesRead];
|
System.arraycopy(buffer, 0, receivedData, 0, bytesRead);
|
String fromAddress = socket.getInetAddress().getHostAddress() + ":" + socket.getPort();
|
|
// 调用新的字节数组版本的notifyData方法
|
notifyData(receivedData, fromAddress);
|
} else if (bytesRead == -1) {
|
// 客户端断开连接
|
break;
|
}
|
} catch (IOException e) {
|
if (running.get()) {
|
// 客户端连接错误
|
break;
|
}
|
}
|
}
|
|
// 清理客户端
|
String clientKey = socket.getInetAddress().getHostAddress() + ":" + socket.getPort();
|
clients.remove(clientKey);
|
updateClientList();
|
notifyStatus("客户端断开: " + clientKey, false);
|
});
|
}
|
}
|
|
/**
|
* 通知数据接收（字节数组版本）
|
*/
|
protected void notifyData(byte[] data, String fromAddress) {
|
if (dataListener != null) {
|
dataListener.onDataReceived(data, fromAddress);
|
}
|
}
|
}
|
