package jiekou;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.*;
|
import java.net.Socket;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
/**
|
* TCP客户端工具类
|
* 实现发卡机与服务器的所有通信接口
|
*/
|
public class TcpClientUtil {
|
private static final Logger logger = LoggerFactory.getLogger(TcpClientUtil.class);
|
|
private Socket socket;
|
private OutputStream outputStream;
|
private InputStream inputStream;
|
private BufferedReader reader;
|
private volatile boolean running = false;
|
private MessageListener messageListener;
|
|
// 重连相关配置
|
private String serverIp;
|
private int serverPort;
|
private String deviceId;
|
private final AtomicBoolean reconnecting = new AtomicBoolean(false);
|
private static final int RECONNECT_INTERVAL = 3000; // 重连间隔3秒
|
|
// JSON解析模式
|
private static final Pattern JSON_PATTERN = Pattern.compile("\"([^\"]+)\"\\s*:\\s*(\"[^\"]*\"|[^,\\}\\s]*)");
|
private static final Pattern ARRAY_PATTERN = Pattern.compile("\\{([^}]*)\\}");
|
|
/**
|
* 连接TCP服务器
|
* @param ip 服务器IP地址
|
* @param port 服务器端口
|
* @return 连接是否成功
|
*/
|
public boolean connect(String ip, int port) {
|
try {
|
// 保存连接参数用于重连
|
this.serverIp = ip;
|
this.serverPort = port;
|
|
// 1. 创建Socket连接服务器
|
this.socket = new Socket(ip, port);
|
// 移除超时设置，让监听线程可以无限等待
|
socket.setSoTimeout(0);
|
|
// 2. 获取输入输出流
|
this.outputStream = socket.getOutputStream();
|
this.inputStream = socket.getInputStream();
|
this.reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
|
|
logger.info("成功连接到服务器: {}:{}", ip, port);
|
reconnecting.set(false); // 重置重连状态
|
return true;
|
|
} catch (IOException e) {
|
logger.error("TCP连接异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 连接并登录服务器
|
* @param ip 服务器IP地址
|
* @param port 服务器端口
|
* @param deviceId 设备ID
|
* @return 登录是否成功
|
*/
|
public boolean connectAndLogin(String ip, int port, String deviceId) {
|
this.deviceId = deviceId; // 保存设备ID用于重连后重新登录
|
if (!connect(ip, port)) {
|
return false;
|
}
|
|
Map<String, Object> response = sendLoginRequest(deviceId);
|
return response != null &&
|
"logined".equals(response.get("cmd")) &&
|
"100".equals(String.valueOf(response.get("code")));
|
}
|
|
/**
|
* 发送登录请求
|
* @param deviceId 设备ID
|
* @return 登录响应数据
|
*/
|
public Map<String, Object> sendLoginRequest(String deviceId) {
|
try {
|
// 构建登录请求JSON
|
String loginRequest = buildLoginRequestJson(deviceId);
|
logger.debug("发送登录请求: {}", loginRequest);
|
|
// 发送登录请求
|
boolean sendSuccess = sendMessage(loginRequest);
|
if (!sendSuccess) {
|
return null;
|
}
|
|
// 读取服务器响应
|
String response = reader.readLine();
|
logger.info("收到服务器登录响应: {}", response);
|
|
// 解析响应并返回
|
return parseJson(response);
|
|
} catch (IOException e) {
|
logger.error("登录请求异常: {}", e.getMessage(), e);
|
return null;
|
}
|
}
|
|
/**
|
* 请求人员数据
|
* @param deviceId 设备ID
|
* @return 人员数据列表
|
*/
|
public List<Map<String, Object>> requestPersonData(String deviceId) {
|
try {
|
// 构建人员数据请求JSON
|
String batchGetRequest = buildBatchGetRequestJson(deviceId);
|
logger.debug("发送人员数据请求: {}", batchGetRequest);
|
|
// 发送请求
|
boolean sendSuccess = sendMessage(batchGetRequest);
|
if (!sendSuccess) {
|
return null;
|
}
|
|
// 读取服务器响应（人员数据）
|
String response = reader.readLine();
|
logger.info("收到人员数据: {}", response);
|
|
// 解析响应
|
Map<String, Object> responseMap = parseJson(response);
|
if ("send".equals(responseMap.get("cmd")) && "101".equals(String.valueOf(responseMap.get("code")))) {
|
// 解析人员数据
|
String dataStr = (String) responseMap.get("data");
|
List<Map<String, Object>> personList = parsePersonDataArray(dataStr);
|
|
// 发送成功应答
|
sendSentAck();
|
|
return personList;
|
}
|
|
return null;
|
|
} catch (IOException e) {
|
logger.error("请求人员数据异常: {}", e.getMessage(), e);
|
return null;
|
}
|
}
|
|
/**
|
* 发送人员数据接收成功应答
|
*/
|
public boolean sendSentAck() {
|
try {
|
String ackJson = "{\"code\":101,\"cmd\":\"sent\",\"data\":null}";
|
return sendMessage(ackJson);
|
} catch (Exception e) {
|
logger.error("发送成功应答异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 发送删除人员成功应答
|
* @param userId 用户ID
|
* @return 发送是否成功
|
*/
|
public boolean sendDeleteAck(String userId) {
|
try {
|
String ackJson = "{\"code\":102,\"cmd\":\"deleted\",\"data\":null}";
|
boolean success = sendMessage(ackJson);
|
if (success) {
|
logger.info("发送删除人员成功应答，用户ID: {}", userId);
|
}
|
return success;
|
} catch (Exception e) {
|
logger.error("发送删除人员成功应答异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 发送开锁成功应答
|
* @param doorNo 门编号
|
* @return 发送是否成功
|
*/
|
public boolean sendOpenDoorAck(String doorNo) {
|
try {
|
String ackJson = "{\"code\":103,\"cmd\":\"opened\",\"data\":null}";
|
boolean success = sendMessage(ackJson);
|
if (success) {
|
logger.info("发送开锁成功应答，门编号: {}", doorNo);
|
}
|
return success;
|
} catch (Exception e) {
|
logger.error("发送开锁成功应答异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 发送升级成功应答
|
* @param updateUrl 升级文件URL
|
* @return 发送是否成功
|
*/
|
public boolean sendUpdateAck(String updateUrl) {
|
try {
|
String ackJson = "{\"code\":104,\"cmd\":\"upDated\",\"data\":null}";
|
boolean success = sendMessage(ackJson);
|
if (success) {
|
logger.info("发送升级成功应答，升级URL: {}", updateUrl);
|
}
|
return success;
|
} catch (Exception e) {
|
logger.error("发送升级成功应答异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 发送自定义命令
|
* @param code 命令代码
|
* @param cmd 命令类型
|
* @param data 数据
|
* @return 发送是否成功
|
*/
|
public boolean sendCommand(String code, String cmd, String data) {
|
try {
|
String json = buildCommandJson(code, cmd, data);
|
boolean success = sendMessage(json);
|
if (success) {
|
logger.debug("发送命令: {}", json);
|
}
|
return success;
|
} catch (Exception e) {
|
logger.error("发送命令异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 通用消息发送方法
|
* @param message 要发送的消息
|
* @return 发送是否成功
|
*/
|
public boolean sendMessage(String message) {
|
if (!isConnected()) {
|
logger.error("连接未建立，无法发送消息");
|
return false;
|
}
|
|
try {
|
outputStream.write((message + "\n").getBytes(StandardCharsets.UTF_8));
|
outputStream.flush();
|
return true;
|
} catch (IOException e) {
|
logger.error("发送消息异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 读取服务器响应
|
* @return 服务器响应数据
|
*/
|
public String readResponse() {
|
try {
|
return reader.readLine();
|
} catch (IOException e) {
|
logger.error("读取响应异常: {}", e.getMessage(), e);
|
return null;
|
}
|
}
|
|
/**
|
* 读取并解析服务器响应
|
* @return 解析后的响应Map
|
*/
|
public Map<String, Object> readAndParseResponse() {
|
String response = readResponse();
|
if (response != null) {
|
return parseJson(response);
|
}
|
return null;
|
}
|
|
/**
|
* 断线重连功能
|
*/
|
private void reconnect() {
|
if (reconnecting.getAndSet(true)) {
|
logger.debug("重连操作已在进行中，跳过本次重连");
|
return;
|
}
|
|
logger.info("开始断线重连...");
|
while (running) {
|
try {
|
logger.info("尝试重连，目标服务器: {}:{}", serverIp, serverPort);
|
|
// 关闭旧连接
|
closeResources(reader, inputStream, outputStream, socket);
|
|
// 等待一段时间后重连
|
Thread.sleep(RECONNECT_INTERVAL);
|
|
// 尝试重新连接
|
if (connect(serverIp, serverPort)) {
|
// 重新登录
|
if (deviceId != null) {
|
Map<String, Object> loginResponse = sendLoginRequest(deviceId);
|
if (loginResponse != null &&
|
"logined".equals(loginResponse.get("cmd")) &&
|
"100".equals(String.valueOf(loginResponse.get("code")))) {
|
|
logger.info("重连并登录成功");
|
reconnecting.set(false);
|
|
// 重新启动消息监听
|
if (messageListener != null) {
|
startMessageListener(messageListener);
|
}
|
return;
|
}
|
} else {
|
// 如果没有设备ID，只连接不登录
|
logger.info("重连成功");
|
reconnecting.set(false);
|
if (messageListener != null) {
|
startMessageListener(messageListener);
|
}
|
return;
|
}
|
}
|
|
logger.warn("重连失败，{} 毫秒后重试", RECONNECT_INTERVAL);
|
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
logger.warn("重连过程被中断");
|
break;
|
} catch (Exception e) {
|
logger.error("重连异常: {}", e.getMessage());
|
}
|
}
|
|
reconnecting.set(false);
|
if (running) {
|
logger.error("重连循环退出，将在下次断开后重新尝试");
|
}
|
}
|
|
/**
|
* 启动消息监听器
|
* @param listener 消息监听回调接口
|
*/
|
public void startMessageListener(MessageListener listener) {
|
this.messageListener = listener;
|
running = true;
|
new Thread(() -> {
|
try {
|
while (running && socket != null && !socket.isClosed()) {
|
try {
|
String message = reader.readLine();
|
if (message != null) {
|
logger.debug("收到服务器消息: {}", message);
|
|
// 解析消息
|
Map<String, Object> parsedMessage = parseJson(message);
|
|
// 回调给监听器
|
if (messageListener != null) {
|
messageListener.onMessageReceived(message, parsedMessage);
|
}
|
} else {
|
// 读到null表示连接已关闭
|
logger.warn("连接被服务器关闭");
|
break;
|
}
|
} catch (IOException e) {
|
if (running) {
|
logger.error("读取消息异常: {}", e.getMessage());
|
// 如果不是主动停止，尝试重连
|
if (running && !reconnecting.get()) {
|
reconnect();
|
}
|
break;
|
}
|
}
|
}
|
} finally {
|
logger.info("消息监听线程结束");
|
// 如果还在运行状态但连接已断开，尝试重连
|
if (running && !reconnecting.get()) {
|
reconnect();
|
}
|
}
|
}, "TCP-Client-Listener").start();
|
}
|
|
/**
|
* 停止消息监听
|
*/
|
public void stopMessageListener() {
|
running = false;
|
messageListener = null;
|
reconnecting.set(false); // 停止重连
|
}
|
|
/**
|
* 解析简单JSON字符串为Map
|
* @param json JSON字符串
|
* @return 解析后的Map
|
*/
|
public Map<String, Object> parseJson(String json) {
|
Map<String, Object> result = new HashMap<>();
|
if (json == null || json.trim().isEmpty()) {
|
return result;
|
}
|
|
// 移除首尾的{}
|
String content = json.trim();
|
if (content.startsWith("{") && content.endsWith("}")) {
|
content = content.substring(1, content.length() - 1).trim();
|
}
|
|
Matcher matcher = JSON_PATTERN.matcher(content);
|
while (matcher.find()) {
|
String key = matcher.group(1);
|
String value = matcher.group(2).trim();
|
|
// 移除值的引号（如果存在）
|
if (value.startsWith("\"") && value.endsWith("\"")) {
|
value = value.substring(1, value.length() - 1);
|
}
|
|
// 处理null值
|
if ("null".equals(value)) {
|
result.put(key, null);
|
} else {
|
result.put(key, value);
|
}
|
}
|
|
return result;
|
}
|
|
/**
|
* 解析人员数据数组
|
* @param dataStr 数据字符串
|
* @return 人员列表
|
*/
|
private List<Map<String, Object>> parsePersonDataArray(String dataStr) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
if (dataStr == null || dataStr.trim().isEmpty()) {
|
return result;
|
}
|
|
// 使用正则表达式匹配数组中的每个对象
|
Matcher matcher = ARRAY_PATTERN.matcher(dataStr);
|
while (matcher.find()) {
|
String objStr = matcher.group(1);
|
Map<String, Object> person = parsePersonObject(objStr);
|
if (!person.isEmpty()) {
|
result.add(person);
|
}
|
}
|
|
return result;
|
}
|
|
/**
|
* 解析单个人员对象
|
* @param objStr 对象字符串
|
* @return 人员信息Map
|
*/
|
private Map<String, Object> parsePersonObject(String objStr) {
|
Map<String, Object> person = new HashMap<>();
|
if (objStr == null || objStr.trim().isEmpty()) {
|
return person;
|
}
|
|
// 分割键值对
|
String[] pairs = objStr.split(",");
|
for (String pair : pairs) {
|
String[] keyValue = pair.split(":", 2);
|
if (keyValue.length == 2) {
|
String key = keyValue[0].trim();
|
String value = keyValue[1].trim();
|
|
// 移除值的引号（如果存在）
|
if (value.startsWith("'") && value.endsWith("'")) {
|
value = value.substring(1, value.length() - 1);
|
} else if (value.startsWith("\"") && value.endsWith("\"")) {
|
value = value.substring(1, value.length() - 1);
|
}
|
|
person.put(key, value);
|
}
|
}
|
|
return person;
|
}
|
|
/**
|
* 构建登录请求JSON
|
* @return JSON字符串
|
*/
|
private String buildLoginRequestJson(String deviceId) {
|
return "{\"code\":100,\"cmd\":\"login\",\"deviceId\":\"" + deviceId + "\"}";
|
}
|
|
/**
|
* 构建人员数据请求JSON
|
* @return JSON字符串
|
*/
|
private String buildBatchGetRequestJson(String deviceId) {
|
return "{\"code\":101,\"cmd\":\"batchGet\",\"deviceId\":\"" + deviceId + "\"}";
|
}
|
|
/**
|
* 构建通用命令JSON
|
* @param code 命令代码
|
* @param cmd 命令类型
|
* @param data 数据
|
* @return JSON字符串
|
*/
|
private String buildCommandJson(String code, String cmd, String data) {
|
if (data != null) {
|
return "{\"code\":\"" + code + "\",\"cmd\":\"" + cmd + "\",\"data\":\"" + data + "\"}";
|
} else {
|
return "{\"code\":\"" + code + "\",\"cmd\":\"" + cmd + "\",\"data\":null}";
|
}
|
}
|
|
/**
|
* 关闭连接
|
*/
|
public void disconnect() {
|
stopMessageListener();
|
closeResources(reader, inputStream, outputStream, socket);
|
logger.info("断开与服务器的连接");
|
}
|
|
/**
|
* 检查连接状态
|
* @return 是否连接
|
*/
|
public boolean isConnected() {
|
return socket != null && !socket.isClosed() && socket.isConnected();
|
}
|
|
/**
|
* 关闭所有资源
|
*/
|
private static void closeResources(Closeable... resources) {
|
for (Closeable resource : resources) {
|
if (resource != null) {
|
try {
|
resource.close();
|
} catch (IOException e) {
|
logger.error("关闭资源时发生异常: {}", e.getMessage(), e);
|
}
|
}
|
}
|
}
|
|
/**
|
* 消息监听回调接口
|
*/
|
public interface MessageListener {
|
/**
|
* 当收到服务器消息时回调
|
* @param rawMessage 原始消息字符串
|
* @param parsedMessage 解析后的消息Map
|
*/
|
void onMessageReceived(String rawMessage, Map<String, Object> parsedMessage);
|
|
}
|
}
|
