package com.zy.service;
|
|
import com.zy.core.model.RFIDSlave;
|
import com.zy.core.properties.SlaveProperties;
|
import com.rfid.uhf288.RFIDTemplate;
|
import com.rfid.uhf288.RFIDTemplate.TagInfo;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.PostConstruct;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
/**
|
* RFID自动连接和监控服务
|
* 支持多个RFID设备独立管理，每个设备独立的连接线程和检测线程
|
* 每个设备的autoConnect配置独立控制
|
*
|
* @author Created on 2026/01/10
|
*/
|
@Slf4j
|
@Service
|
public class RFIDAutoConnectService {
|
|
@Autowired
|
private SlaveProperties slaveProperties;
|
|
@Value("${wcs-slave.rfid-config.reconnectInterval:5}")
|
private Integer globalReconnectInterval;
|
|
@Value("${wcs-slave.rfid-config.tagScanInterval:500}")
|
private Integer globalTagScanInterval;
|
|
@Value("${wcs-slave.rfid-config.tagScanTime:10}")
|
private Integer globalTagScanTime;
|
|
// 存储每个设备的连接和线程信息
|
private final Map<Integer, DeviceManager> deviceManagers = new ConcurrentHashMap<>();
|
|
/**
|
* 设备管理器 - 管理单个RFID设备的连接和检测
|
*/
|
private static class DeviceManager {
|
final RFIDSlave config;
|
final RFIDTemplate template;
|
final AtomicBoolean running = new AtomicBoolean(false);
|
final AtomicBoolean connected = new AtomicBoolean(false);
|
Thread connectThread;
|
Thread scanThread;
|
final int reconnectInterval;
|
final long tagScanInterval;
|
final int tagScanTime;
|
int reconfigCounter = 0;
|
volatile List<TagInfo> latestTags = new ArrayList<>(); // 最新检测到的标签
|
|
DeviceManager(RFIDSlave config, Integer reconnectInterval, Integer tagScanInterval, Integer tagScanTime) {
|
this.config = config;
|
this.template = new RFIDTemplate();
|
this.reconnectInterval = reconnectInterval != null ? reconnectInterval : 5;
|
this.tagScanInterval = tagScanInterval != null ? tagScanInterval : 500;
|
this.tagScanTime = tagScanTime != null ? tagScanTime : 10;
|
}
|
|
void start() {
|
if (running.get()) {
|
return;
|
}
|
|
running.set(true);
|
|
// 启动连接线程
|
// 注意：设置为非守护线程，确保应用运行期间线程一直运行
|
connectThread = new Thread(this::connectLoop,
|
String.format("RFID-Connect-%d-%s", config.getId(), config.getIp()));
|
connectThread.setDaemon(false); // 改为非守护线程，确保应用运行期间一直运行
|
connectThread.start();
|
|
// 启动标签检测线程
|
scanThread = new Thread(this::scanLoop,
|
String.format("RFID-Scan-%d-%s", config.getId(), config.getIp()));
|
scanThread.setDaemon(false); // 改为非守护线程，确保应用运行期间一直运行
|
scanThread.start();
|
}
|
|
void stop() {
|
running.set(false);
|
connected.set(false);
|
|
if (connectThread != null) {
|
connectThread.interrupt();
|
}
|
if (scanThread != null) {
|
scanThread.interrupt();
|
}
|
|
try {
|
if (connectThread != null) {
|
connectThread.join(2000);
|
}
|
if (scanThread != null) {
|
scanThread.join(2000);
|
}
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
}
|
|
if (template != null && template.isConnected()) {
|
try {
|
template.disconnect();
|
} catch (Exception e) {
|
log.error("RFID设备[{}]断开连接异常", config.getId(), e);
|
}
|
}
|
}
|
|
/**
|
* 连接循环 - 负责连接和重连
|
* 特别处理UnsatisfiedLinkError，确保DLL方法链接失败时也会定期重连
|
*/
|
private void connectLoop() {
|
log.info("RFID设备[{}]连接线程启动 - IP: {}, Port: {}",
|
config.getId(), config.getIp(), config.getPort());
|
|
while (running.get()) {
|
try {
|
if (!connected.get()) {
|
log.info("========== RFID设备[{}]尝试连接 ==========", config.getId());
|
log.info("IP: {}, Port: {}", config.getIp(), config.getPort());
|
|
// 尝试连接
|
boolean success = false;
|
try {
|
success = template.connectNetwork(config.getIp(), config.getPort());
|
} catch (UnsatisfiedLinkError e) {
|
// DLL方法链接失败，记录错误但继续重连
|
log.error("RFID设备[{}] DLL方法链接失败 - UnsatisfiedLinkError", config.getId());
|
log.error("错误信息: {}", e.getMessage());
|
log.error("可能原因：1. DLL版本不匹配 2. 方法签名不匹配 3. DLL未正确加载");
|
log.warn("将在{}秒后重试连接", reconnectInterval);
|
success = false;
|
}
|
|
if (success) {
|
connected.set(true);
|
log.info("✓ RFID设备[{}]连接成功！IP: {}, Port: {}",
|
config.getId(), config.getIp(), config.getPort());
|
} else {
|
log.warn("✗ RFID设备[{}]连接失败，{}秒后重试",
|
config.getId(), reconnectInterval);
|
Thread.sleep(reconnectInterval * 1000L);
|
}
|
} else {
|
// 已连接，检查连接状态
|
if (!template.isConnected()) {
|
log.warn("RFID设备[{}]连接已断开，准备重连", config.getId());
|
connected.set(false);
|
} else {
|
// 连接正常，定期重新配置天线（处理天线插拔情况）
|
// 每5次循环（约50秒）重新配置一次天线，确保插拔后能自动检测
|
reconfigCounter++;
|
if (reconfigCounter >= 5) {
|
reconfigCounter = 0;
|
log.debug("RFID设备[{}]定期重新配置天线（处理天线插拔）", config.getId());
|
boolean reconfigured = template.reconfigureAntenna();
|
if (reconfigured) {
|
// log.info("RFID设备[{}]天线重新配置成功，所有天线已启用", config.getId());
|
}
|
}
|
|
// 等待一段时间后再次检查
|
Thread.sleep(reconnectInterval * 1000L);
|
}
|
}
|
} catch (InterruptedException e) {
|
log.info("RFID设备[{}]连接线程被中断", config.getId());
|
Thread.currentThread().interrupt();
|
break;
|
} catch (UnsatisfiedLinkError e) {
|
// DLL方法链接失败，记录错误并继续重连
|
log.error("RFID设备[{}]连接线程 - DLL方法链接失败", config.getId());
|
log.error("错误信息: {}", e.getMessage());
|
log.error("可能原因：1. DLL版本不匹配 2. 方法签名不匹配 3. DLL未正确加载");
|
log.warn("将在{}秒后重试连接", reconnectInterval);
|
connected.set(false);
|
try {
|
Thread.sleep(reconnectInterval * 1000L);
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
break;
|
}
|
} catch (Exception e) {
|
log.error("RFID设备[{}]连接线程异常", config.getId(), e);
|
connected.set(false);
|
try {
|
Thread.sleep(reconnectInterval * 1000L);
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
break;
|
}
|
}
|
}
|
|
log.info("RFID设备[{}]连接线程已停止", config.getId());
|
}
|
|
/**
|
* 标签检测循环 - 持续检测并打印标签
|
* 特别处理UnsatisfiedLinkError，确保DLL方法链接失败时不影响重连
|
*/
|
private void scanLoop() {
|
log.info("RFID设备[{}]标签检测线程启动 - IP: {}", config.getId(), config.getIp());
|
|
while (running.get()) {
|
try {
|
if (connected.get() && template.isConnected()) {
|
try {
|
List<TagInfo> tags = template.readTags(4, 0, tagScanTime);
|
latestTags = tags != null ? new ArrayList<>(tags) : new ArrayList<>();
|
|
if (tags != null && !tags.isEmpty()) {
|
printTags(tags);
|
}
|
} catch (UnsatisfiedLinkError e) {
|
// DLL方法链接失败，标记为未连接，让连接线程重连
|
log.error("RFID设备[{}]标签检测 - DLL方法链接失败", config.getId());
|
log.error("错误信息: {}", e.getMessage());
|
log.warn("连接状态已标记为断开，连接线程将尝试重连");
|
connected.set(false);
|
// 等待一段时间后继续
|
Thread.sleep(reconnectInterval * 1000L);
|
continue;
|
}
|
} else {
|
// 未连接，等待一段时间
|
Thread.sleep(1000);
|
}
|
|
// 等待指定间隔
|
Thread.sleep(tagScanInterval);
|
} catch (InterruptedException e) {
|
log.info("RFID设备[{}]标签检测线程被中断", config.getId());
|
Thread.currentThread().interrupt();
|
break;
|
} catch (UnsatisfiedLinkError e) {
|
// DLL方法链接失败，标记为未连接
|
log.error("RFID设备[{}]标签检测线程 - DLL方法链接失败", config.getId());
|
log.error("错误信息: {}", e.getMessage());
|
connected.set(false);
|
try {
|
Thread.sleep(reconnectInterval * 1000L);
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
break;
|
}
|
} catch (Exception e) {
|
log.error("RFID设备[{}]标签检测线程异常", config.getId(), e);
|
try {
|
Thread.sleep(1000);
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
break;
|
}
|
}
|
}
|
|
log.info("RFID设备[{}]标签检测线程已停止", config.getId());
|
}
|
|
private void printTags(List<TagInfo> tags) {
|
if (tags == null || tags.isEmpty()) {
|
return;
|
}
|
for (TagInfo tag : tags) {
|
log.info("RFID设备[{}]检测到标签: EPC={}, RSSI={}dBm, 天线={}",
|
config.getId(), tag.epc, tag.rssi, tag.antenna);
|
}
|
}
|
}
|
|
/**
|
* 系统启动时初始化所有配置了autoConnect=true的设备
|
*/
|
@PostConstruct
|
public void init() {
|
log.info("========== RFID自动连接服务启动 ==========");
|
|
if (slaveProperties.getRfid() == null || slaveProperties.getRfid().isEmpty()) {
|
log.info("未配置RFID设备");
|
return;
|
}
|
|
log.info("RFID全局配置 - 重连间隔: {}秒, 检测间隔: {}毫秒, 扫描时间: {} * 100ms",
|
globalReconnectInterval, globalTagScanInterval, globalTagScanTime);
|
|
// 遍历所有RFID设备配置
|
for (RFIDSlave rfidConfigItem : slaveProperties.getRfid()) {
|
if (rfidConfigItem == null) {
|
continue;
|
}
|
|
// 检查是否启用自动连接
|
Boolean autoConnect = rfidConfigItem.getAutoConnect();
|
if (autoConnect == null || !autoConnect) {
|
log.info("RFID设备[{}] - IP: {}, Port: {} - 未启用自动连接",
|
rfidConfigItem.getId(), rfidConfigItem.getIp(), rfidConfigItem.getPort());
|
continue;
|
}
|
|
// 验证配置
|
if (rfidConfigItem.getIp() == null || rfidConfigItem.getPort() == null) {
|
log.warn("RFID设备[{}]配置不完整，跳过自动连接", rfidConfigItem.getId());
|
continue;
|
}
|
|
// 创建设备管理器并启动
|
DeviceManager manager = new DeviceManager(rfidConfigItem,
|
globalReconnectInterval, globalTagScanInterval, globalTagScanTime);
|
deviceManagers.put(rfidConfigItem.getId(), manager);
|
manager.start();
|
|
log.info("RFID设备[{}]自动连接已启动 - IP: {}, Port: {}",
|
rfidConfigItem.getId(), rfidConfigItem.getIp(), rfidConfigItem.getPort());
|
}
|
|
log.info("RFID自动连接服务已启动，共 {} 个设备启用自动连接", deviceManagers.size());
|
}
|
|
/**
|
* 手动停止所有RFID设备连接（通过API调用）
|
* 注意：移除了@PreDestroy，服务不会自动关闭，只能通过API手动关闭
|
*/
|
public void stopAll() {
|
log.info("========== RFID自动连接服务手动关闭 ==========");
|
|
// 停止所有设备管理器
|
for (Map.Entry<Integer, DeviceManager> entry : deviceManagers.entrySet()) {
|
try {
|
log.info("停止RFID设备[{}]自动连接", entry.getKey());
|
entry.getValue().stop();
|
} catch (Exception e) {
|
log.error("停止RFID设备[{}]自动连接异常", entry.getKey(), e);
|
}
|
}
|
|
deviceManagers.clear();
|
log.info("RFID自动连接服务已关闭");
|
}
|
|
/**
|
* 手动停止指定RFID设备连接（通过API调用）
|
*/
|
public boolean stopDevice(Integer deviceId) {
|
DeviceManager manager = deviceManagers.get(deviceId);
|
if (manager == null) {
|
log.warn("RFID设备[{}]未启用自动连接或不存在", deviceId);
|
return false;
|
}
|
|
try {
|
log.info("手动停止RFID设备[{}]自动连接", deviceId);
|
manager.stop();
|
deviceManagers.remove(deviceId);
|
return true;
|
} catch (Exception e) {
|
log.error("停止RFID设备[{}]自动连接异常", deviceId, e);
|
return false;
|
}
|
}
|
|
/**
|
* 手动启动指定RFID设备连接（通过API调用）
|
*/
|
public boolean startDevice(Integer deviceId) {
|
// 检查设备是否已经在运行
|
if (deviceManagers.containsKey(deviceId)) {
|
DeviceManager manager = deviceManagers.get(deviceId);
|
if (manager.running.get()) {
|
log.warn("RFID设备[{}]已经在运行", deviceId);
|
return false;
|
}
|
}
|
|
// 查找配置
|
RFIDSlave config = null;
|
for (RFIDSlave rfidConfigItem : slaveProperties.getRfid()) {
|
if (rfidConfigItem != null && rfidConfigItem.getId().equals(deviceId)) {
|
config = rfidConfigItem;
|
break;
|
}
|
}
|
|
if (config == null) {
|
log.warn("RFID设备[{}]配置不存在", deviceId);
|
return false;
|
}
|
|
// 验证配置
|
if (config.getIp() == null || config.getPort() == null) {
|
log.warn("RFID设备[{}]配置不完整", deviceId);
|
return false;
|
}
|
|
// 创建设备管理器并启动
|
DeviceManager manager = new DeviceManager(config,
|
globalReconnectInterval, globalTagScanInterval, globalTagScanTime);
|
deviceManagers.put(deviceId, manager);
|
manager.start();
|
|
log.info("RFID设备[{}]手动启动成功 - IP: {}, Port: {}",
|
deviceId, config.getIp(), config.getPort());
|
return true;
|
}
|
|
/**
|
* 获取设备连接状态
|
*/
|
public Map<String, Object> getDeviceStatus(Integer deviceId) {
|
Map<String, Object> result = new java.util.HashMap<>();
|
|
DeviceManager manager = deviceManagers.get(deviceId);
|
if (manager == null) {
|
result.put("exists", false);
|
result.put("message", "设备未启用自动连接");
|
return result;
|
}
|
|
result.put("exists", true);
|
result.put("connected", manager.connected.get());
|
result.put("running", manager.running.get());
|
result.put("ip", manager.config.getIp());
|
result.put("port", manager.config.getPort());
|
result.put("templateConnected", manager.template.isConnected());
|
|
return result;
|
}
|
|
/**
|
* 获取所有设备状态
|
*/
|
public List<Map<String, Object>> getAllDeviceStatus() {
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
for (Map.Entry<Integer, DeviceManager> entry : deviceManagers.entrySet()) {
|
Map<String, Object> status = getDeviceStatus(entry.getKey());
|
status.put("deviceId", entry.getKey());
|
result.add(status);
|
}
|
|
return result;
|
}
|
|
/**
|
* 重新配置指定设备的天线（用于天线插拔后重新配置）
|
*/
|
public boolean reconfigureAntenna(Integer deviceId) {
|
DeviceManager manager = deviceManagers.get(deviceId);
|
if (manager == null) {
|
log.warn("RFID设备[{}]未启用自动连接或不存在", deviceId);
|
return false;
|
}
|
|
if (!manager.template.isConnected()) {
|
log.warn("RFID设备[{}]未连接，无法配置天线", deviceId);
|
return false;
|
}
|
|
log.info("手动重新配置RFID设备[{}]天线", deviceId);
|
return manager.template.reconfigureAntenna();
|
}
|
|
public List<Map<String, Object>> getDeviceTags(Integer deviceId, String ip, Integer antenna) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
DeviceManager manager = null;
|
if (ip != null && !ip.isEmpty()) {
|
for (DeviceManager m : deviceManagers.values()) {
|
if (ip.equals(m.config.getIp())) {
|
manager = m;
|
break;
|
}
|
}
|
} else if (deviceId != null) {
|
manager = deviceManagers.get(deviceId);
|
}
|
|
if (manager == null || !manager.connected.get() || !manager.template.isConnected()) {
|
return result;
|
}
|
|
List<TagInfo> tags = manager.latestTags;
|
if (tags == null || tags.isEmpty()) {
|
return result;
|
}
|
|
for (TagInfo tag : tags) {
|
if (antenna != null && tag.antenna != antenna) {
|
continue;
|
}
|
Map<String, Object> tagMap = new java.util.HashMap<>();
|
tagMap.put("epc", tag.epc);
|
tagMap.put("rssi", tag.rssi);
|
tagMap.put("antenna", tag.antenna);
|
tagMap.put("timestamp", tag.timestamp);
|
tagMap.put("deviceId", manager.config.getId());
|
tagMap.put("deviceIp", manager.config.getIp());
|
result.add(tagMap);
|
}
|
return result;
|
}
|
|
public List<Map<String, Object>> queryDeviceTags(Integer deviceId, String ip, Integer antenna) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
DeviceManager manager = null;
|
if (ip != null && !ip.isEmpty()) {
|
for (DeviceManager m : deviceManagers.values()) {
|
if (ip.equals(m.config.getIp())) {
|
manager = m;
|
break;
|
}
|
}
|
} else if (deviceId != null) {
|
manager = deviceManagers.get(deviceId);
|
}
|
|
if (manager == null || !manager.connected.get() || !manager.template.isConnected()) {
|
return result;
|
}
|
|
try {
|
List<TagInfo> tags = manager.template.readTags(4, 0, manager.tagScanTime);
|
if (tags != null && !tags.isEmpty()) {
|
for (TagInfo tag : tags) {
|
if (antenna != null && tag.antenna != antenna) {
|
continue;
|
}
|
Map<String, Object> tagMap = new java.util.HashMap<>();
|
tagMap.put("epc", tag.epc);
|
tagMap.put("rssi", tag.rssi);
|
tagMap.put("antenna", tag.antenna);
|
tagMap.put("timestamp", tag.timestamp);
|
tagMap.put("deviceId", manager.config.getId());
|
tagMap.put("deviceIp", manager.config.getIp());
|
result.add(tagMap);
|
}
|
}
|
} catch (Exception e) {
|
log.error("查询RFID设备[{}]标签异常", deviceId != null ? deviceId : ip, e);
|
}
|
return result;
|
}
|
}
|
