Skip to content

Z
zhmes-agecal
Commit c0abff62 authored by wanghao's avatar wanghao
Browse files
Options

1 定时任务写时间功能代码重构，主要针对在线程使用方面及使用modbus4j方面

parent f799feed
Hide whitespace changes
Inline Side-by-side
Showing with 210 additions and 295 deletions
zhmes-agecal-quartz/src/main/java/com/zehong/quartz/config/ScheduleConfig.java
View file @ c0abff62
package com.zehong.quartz.config;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.Properties;
......
zhmes-agecal-quartz/src/main/java/com/zehong/quartz/service/impl/SysJobServiceImpl.java
View file @ c0abff62
......@@ -37,7 +37,8 @@ public class SysJobServiceImpl implements ISysJobService
@PostConstruct
public void init() throws SchedulerException, TaskException
{
scheduler.clear();
//20251021 wh 调整
//scheduler.clear();
List<SysJob> jobList = jobMapper.selectJobAll();
for (SysJob job : jobList)
{
......
zhmes-agecal-system/src/main/java/com/zehong/system/task/DeviceCommunicationJob.java
View file @ c0abff62
......@@ -9,8 +9,10 @@ import com.serotonin.modbus4j.ip.tcp.TcpMaster;
import com.serotonin.modbus4j.msg.ModbusResponse;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersRequest;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersResponse;
import com.zehong.system.domain.PalletDeviceBinding;
import com.zehong.system.domain.TEquipmentAlarmData;
import com.zehong.system.domain.TStoreyInfo;
import com.zehong.system.mapper.PalletDeviceBindingMapper;
import com.zehong.system.mapper.TStoreyInfoMapper;
import com.zehong.system.modbus.handler.ModbusResultHandler;
import com.zehong.system.modbus.handler.dto.DeviceStatusReaderDto;
......@@ -22,16 +24,15 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Calendar;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.net.Socket;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* 设备通信Job（修复版：显式暴露错误，避免Trigger变ERROR）
......@@ -54,6 +55,14 @@ public class DeviceCommunicationJob implements Job {
private static final int REG_START_ADDR = 0;
private static final int REG_READ_COUNT = 10;
// 全局线程池 - 避免重复创建
private static final ExecutorService GLOBAL_DEVICE_EXECUTOR = new ThreadPoolExecutor(
50, 100, 60, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(500),
r -> new Thread(r, "global-modbus-device"),
new ThreadPoolExecutor.CallerRunsPolicy()
);
// 工厂（单例）
private static final ModbusFactory modbusFactory = new ModbusFactory();
// -------------------------- 依赖注入 --------------------------
......@@ -63,304 +72,228 @@ public class DeviceCommunicationJob implements Job {
private TStoreyInfoMapper tStoreyInfoMapper;
@Autowired
private ModbusResultHandler resultHandler;
@Resource
private PalletDeviceBindingMapper palletDeviceBindingMapper;
// -------------------------- 核心执行逻辑 --------------------------
@Override
public void execute(JobExecutionContext context) {
// 关键：不隐藏任何致命异常，让Quartz感知错误（但捕获后包装为JobExecutionException）
long taskStartTime = System.currentTimeMillis();
String storeyIdStr = getStoreyIdFromContext(context);
ExecutorService deviceExecutor = null; // 线程池：每次任务新建，结束后关闭
long startTime = System.currentTimeMillis();
try {
// 1. 初始化线程池（每次任务新建，避免泄漏）
deviceExecutor = new ThreadPoolExecutor(
3, 3, // 核心=最大=3（对应3个端口，1:1映射）
0, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(20), // 队列20个（足够72个设备）
r -> new Thread(r, "modbus-port-pool-" + storeyIdStr), // 线程名含设备ID，便于追踪
new ThreadPoolExecutor.AbortPolicy() // 队列满时抛异常，显式暴露问题
TStoreyInfo storeyInfo = validateAndGetStoreyInfo(storeyIdStr);
// 并行处理3个端口
List<CompletableFuture<Void>> portFutures = Arrays.asList(
processPort(storeyInfo, 501, Arrays.asList(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27)),
processPort(storeyInfo, 502, Arrays.asList(28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54)),
processPort(storeyInfo, 503, Arrays.asList(55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72))
);
// 2. 执行核心逻辑（带总超时）
boolean executeSuccess = executeWithTotalTimeout(context, deviceExecutor, taskStartTime);
if (!executeSuccess) {
log.info("DeviceCommunicationJob执行超时：fStoreyId={}，总耗时={}ms",storeyIdStr,TOTAL_TASK_TIMEOUT_SEC);
}
// 等待所有端口完成，带总超时
CompletableFuture<Void> allPorts = CompletableFuture.allOf(
portFutures.toArray(new CompletableFuture[0])
);
log.info("DeviceCommunicationJob执行成功：fStoreyId={}，总耗时={}ms",
storeyIdStr, System.currentTimeMillis() - taskStartTime);
} catch (JobExecutionException e) {
// 主动抛出的任务异常：Quartz会记录日志，但Trigger状态仍为NORMAL（需配置Misfire）
log.error("DeviceCommunicationJob执行异常（已主动抛出，避免Trigger变ERROR）：fStoreyId={}",
storeyIdStr, e);
} catch (Throwable e) {
// 未预期的致命异常：包装为JobExecutionException，显式暴露
String errMsg = "DeviceCommunicationJob发生未预期致命异常：fStoreyId=" + storeyIdStr;
log.error(errMsg, e);
recordAlarm(null, storeyIdStr, errMsg + "：" + e.getMessage());
} finally {
// 关键：无论成功/失败，关闭线程池，避免资源泄漏
if (deviceExecutor != null && !deviceExecutor.isShutdown()) {
deviceExecutor.shutdownNow(); // 强制关闭，中断所有未完成任务
try {
// 等待线程池关闭，避免JVM退出前资源未释放
if (!deviceExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
log.warn("线程池关闭超时，强制终止：fStoreyId={}", storeyIdStr);
}
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
log.error("线程池关闭被中断：fStoreyId={}", storeyIdStr, ie);
}
}
log.debug("DeviceCommunicationJob最终清理完成：fStoreyId={}", storeyIdStr);
allPorts.get(TOTAL_TASK_TIMEOUT_SEC, TimeUnit.SECONDS);
log.info("任务执行成功: fStoreyId={}, 耗时={}ms",
storeyIdStr, System.currentTimeMillis() - startTime);
} catch (TimeoutException e) {
log.warn("任务执行超时: fStoreyId={}", storeyIdStr);
recordAlarm(null, storeyIdStr, "任务执行超时");
} catch (Exception e) {
log.error("任务执行异常: fStoreyId={}", storeyIdStr, e);
recordAlarm(null, storeyIdStr, "任务执行异常: " + e.getMessage());
}
}
/**
* 带总超时的核心执行逻辑
* 处理单个端口的所有设备
*/
private boolean executeWithTotalTimeout(JobExecutionContext context, ExecutorService deviceExecutor, long taskStartTime) throws Exception {
String storeyIdStr = getStoreyIdFromContext(context);
TStoreyInfo storeyInfo = validateAndGetStoreyInfo(storeyIdStr);
private CompletableFuture<Void> processPort(TStoreyInfo storeyInfo, int port, List<Integer> deviceIds) {
return CompletableFuture.runAsync(() -> {
String ip = storeyInfo.getfIp();
String storeyIdStr = storeyInfo.getfStoreyId().toString();
// 用自定义线程池执行端口通信（避免混用CompletableFuture默认线程池）
CountDownLatch portLatch = new CountDownLatch(3); // 3个端口，计数器3
AtomicInteger portErrorCount = new AtomicInteger(0);
log.info("开始端口通信: ip={}, port={}, 设备数={}", ip, port, deviceIds.size());
// 端口501通信
deviceExecutor.submit(() -> {
try {
executeSinglePort(storeyInfo.getfIp(), 501,
Arrays.asList(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27),
storeyIdStr, storeyInfo);
} catch (Exception e) {
portErrorCount.incrementAndGet();
log.error("端口501通信异常：fStoreyId={}", storeyIdStr, e);
} finally {
portLatch.countDown();
}
});
AtomicInteger errorCount = new AtomicInteger(0);
// 端口502通信
deviceExecutor.submit(() -> {
try {
executeSinglePort(storeyInfo.getfIp(), 502,
Arrays.asList(28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54),
storeyIdStr, storeyInfo);
} catch (Exception e) {
portErrorCount.incrementAndGet();
log.error("端口502通信异常：fStoreyId={}", storeyIdStr, e);
} finally {
portLatch.countDown();
}
});
// 并行处理该端口的所有设备
List<CompletableFuture<Boolean>> deviceFutures = deviceIds.stream()
.map(deviceId -> processDeviceWithWrite(ip, port, deviceId, storeyIdStr, errorCount))
.collect(Collectors.toList());
// 端口503通信
deviceExecutor.submit(() -> {
try {
executeSinglePort(storeyInfo.getfIp(), 503,
Arrays.asList(55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72),
storeyIdStr, storeyInfo);
// 等待该端口所有设备完成
CompletableFuture<Void> allDevices = CompletableFuture.allOf(
deviceFutures.toArray(new CompletableFuture[0])
);
// 端口超时 = 设备数 * 单设备超时 / 并发因子
int portTimeout = Math.max(30, deviceIds.size() * SINGLE_DEVICE_TIMEOUT_SEC / 5);
allDevices.get(portTimeout, TimeUnit.SECONDS);
} catch (TimeoutException e) {
log.warn("端口{}通信超时: ip={}, fStoreyId={}", port, ip, storeyIdStr);
recordAlarm(storeyInfo, "端口" + port + "通信超时");
} catch (Exception e) {
portErrorCount.incrementAndGet();
log.error("端口503通信异常：fStoreyId={}", storeyIdStr, e);
} finally {
portLatch.countDown();
log.error("端口{}通信异常: ip={}, fStoreyId={}", port, ip, storeyIdStr, e);
}
});
// 等待所有端口完成，带总超时
boolean allPortCompleted = portLatch.await(SINGLE_PORT_TIMEOUT_SEC, TimeUnit.SECONDS);
long totalCost = System.currentTimeMillis() - taskStartTime;
// 检查总耗时是否超任务超时
if (totalCost > TOTAL_TASK_TIMEOUT_SEC * 1000) {
log.warn("任务总耗时超阈值：fStoreyId={}，耗时={}ms（阈值={}ms）",
storeyIdStr, totalCost, TOTAL_TASK_TIMEOUT_SEC * 1000);
recordAlarm(storeyInfo, "任务总超时：" + totalCost + "ms（阈值" + TOTAL_TASK_TIMEOUT_SEC + "秒）");
return false;
}
// 检查端口错误数
if (portErrorCount.get() > 0) {
String errMsg = "部分端口通信失败：fStoreyId=" + storeyIdStr + "，失败端口数=" + portErrorCount.get();
log.error(errMsg);
recordAlarm(storeyInfo, errMsg);
// 此处不抛出异常，仅记录告警，避免Trigger变ERROR
}
if (errorCount.get() > 0) {
log.warn("端口{}部分设备失败: 失败数={}, fStoreyId={}",
port, errorCount.get(), storeyIdStr);
}
return allPortCompleted;
log.info("端口通信完成: ip={}, port={}, fStoreyId={}", ip, port, storeyIdStr);
}, GLOBAL_DEVICE_EXECUTOR);
}
/**
* 验证参数并获取设备信息（参数错误直接抛出异常）
* 处理单个设备（读取 + 条件写入）
*/
private TStoreyInfo validateAndGetStoreyInfo(String storeyIdStr) {
// 1. 校验storeyIdStr
if (StringUtils.isBlank(storeyIdStr)) {
String errMsg = "fStoreyId参数为空，任务终止";
log.error(errMsg);
recordAlarm(null, "unknown", errMsg);
}
// 2. 转换storeyId
Long storeyId = null;
try {
storeyId = Long.parseLong(storeyIdStr);
} catch (NumberFormatException e) {
String errMsg = "fStoreyId格式错误：" + storeyIdStr;
log.error(errMsg, e);
recordAlarm(null, storeyIdStr, errMsg);
}
// 3. 查询设备信息
TStoreyInfo storeyInfo = tStoreyInfoMapper.selectTStoreyInfoById(storeyId);
if (storeyInfo == null) {
String errMsg = "未查询到设备信息：fStoreyId=" + storeyId;
log.error(errMsg);
recordAlarm(null, storeyIdStr, errMsg);
}
private CompletableFuture<Boolean> processDeviceWithWrite(String ip, int port, int deviceId,
String storeyIdStr, AtomicInteger errorCount) {
return CompletableFuture.supplyAsync(() -> {
ModbusMaster master = null;
try {
// 1. 读取设备数据
int[] result = readDeviceWithRetry(ip, port, deviceId, storeyIdStr);
// 4. 校验设备IP
assert storeyInfo != null;
if (StringUtils.isBlank(storeyInfo.getfIp())) {
String errMsg = "设备IP为空：fStoreyId=" + storeyId;
log.error(errMsg);
recordAlarm(storeyInfo, errMsg);
}
// 2. 查询设备绑定信息
PalletDeviceBinding binding = palletDeviceBindingMapper.selectByTrayIdAndIndex(ip, deviceId);
if (binding == null) {
log.warn("未找到设备绑定: ip={}, deviceId={}", ip, deviceId);
recordAlarm(null, "ip:" + ip + ",port:" + port + ",deviceId:" + deviceId, "未找到设备绑定");
errorCount.incrementAndGet();
return false;
}
return storeyInfo;
}
// 3. 更新设备状态
binding.setStatus(String.valueOf(result[1]));
/**
* 单个端口通信（含设备级超时和重试）
*/
private void executeSinglePort(String ip, int port, List<Integer> deviceIds,
String storeyIdStr, TStoreyInfo storeyInfo) throws Exception {
log.info("开始端口通信：ip={}，port={}，设备数={}，fStoreyId={}",
ip, port, deviceIds.size(), storeyIdStr);
CountDownLatch deviceLatch = new CountDownLatch(deviceIds.size());
AtomicInteger deviceErrorCount = new AtomicInteger(0);
for (int deviceId : deviceIds) {
// 每个设备用独立线程执行，带超时
Executors.newSingleThreadExecutor(r ->
new Thread(r, "modbus-device-" + storeyIdStr + "-" + port + "-" + deviceId)
).submit(() -> {
try {
// 单个设备通信（带超时）
executeSingleDeviceWithTimeout(ip, port, deviceId, storeyIdStr);
} catch (Exception e) {
deviceErrorCount.incrementAndGet();
log.error("设备通信异常：ip={}，port={}，deviceId={}，fStoreyId={}",
ip, port, deviceId, storeyIdStr, e);
recordAlarm(storeyInfo, "设备" + deviceId + "通信异常：" + e.getMessage());
} finally {
deviceLatch.countDown();
// 4. 条件写入时间
if (result[1] == 1 || result[1] == 3 || result[1] == 4) {
// 重用之前的master连接进行写操作
master = createModbusMaster(ip, port);
writeCurrentTimeToDevice(master, deviceId, binding, ip, port);
}
});
}
// 等待该端口所有设备完成，带超时
boolean allDeviceCompleted = deviceLatch.await((long) SINGLE_DEVICE_TIMEOUT_SEC * deviceIds.size() / 10, TimeUnit.SECONDS);
if (!allDeviceCompleted) {
String errMsg = "端口" + port + "部分设备超时：ip=" + ip + "，未完成设备数=" + deviceLatch.getCount() + "，fStoreyId=" + storeyIdStr;
log.error(errMsg);
recordAlarm(storeyInfo, errMsg);
}
// 5. 更新数据库
palletDeviceBindingMapper.updatePalletDeviceBinding(binding);
if (deviceErrorCount.get() > 0) {
String errMsg = "端口" + port + "部分设备通信失败：ip=" + ip + "，失败数=" + deviceErrorCount.get() + "，fStoreyId=" + storeyIdStr;
log.error(errMsg);
}
log.debug("设备{}处理完成: ip={}, port={}, status={}", deviceId, ip, port, result[1]);
return true;
log.info("端口通信完成：ip={}，port={}，fStoreyId={}", ip, port, storeyIdStr);
} catch (Exception e) {
log.error("设备{}处理异常: ip={}, port={}", deviceId, ip, port, e);
errorCount.incrementAndGet();
return false;
} finally {
destroyModbusMaster(master, deviceId);
}
}, GLOBAL_DEVICE_EXECUTOR);
}
/**
* 单个设备通信（带超时和重试）
* 验证参数并获取设备信息（参数错误直接抛出异常）
*/
private void executeSingleDeviceWithTimeout(String ip, int port, int deviceId, String storeyIdStr) {
// 单个设备通信超时：SINGLE_DEVICE_TIMEOUT_SEC秒
Future<?> deviceFuture = Executors.newSingleThreadExecutor().submit(() -> {
try {
// 带重试的设备通信
int[] result = readDeviceWithRetry(ip, port, deviceId, storeyIdStr);
// 处理结果（若有）
if (resultHandler != null) {
resultHandler.accept(new DeviceStatusReaderDto(ip, port, deviceId, result));
}
} catch (Exception e) {
log.info("设备" + deviceId + "通信异常");
}
});
private TStoreyInfo validateAndGetStoreyInfo(String storeyIdStr) {
if (StringUtils.isBlank(storeyIdStr)) {
log.error("fStoreyId参数为空");
return null;
}
try {
deviceFuture.get(SINGLE_DEVICE_TIMEOUT_SEC, TimeUnit.SECONDS);
} catch (TimeoutException e) {
deviceFuture.cancel(true);
String errMsg = "设备" + deviceId + "通信超时（>" + SINGLE_DEVICE_TIMEOUT_SEC + "秒）：ip=" + ip + "，port=" + port;
log.info(errMsg);
} catch (Exception e) {
String errMsg = "设备" + deviceId + "通信异常：ip=" + ip + "，port=" + port;
log.info(errMsg);
Long storeyId = Long.parseLong(storeyIdStr);
TStoreyInfo storeyInfo = tStoreyInfoMapper.selectTStoreyInfoById(storeyId);
if (storeyInfo == null || StringUtils.isBlank(storeyInfo.getfIp())) {
log.error("设备信息无效: fStoreyId={}", storeyIdStr);
return null;
}
return storeyInfo;
} catch (NumberFormatException e) {
log.error("fStoreyId格式错误: {}", storeyIdStr);
return null;
}
}
/**
* 带重试的设备寄存器读取（取消Modbus内置重试，统一自定义重试）
* 带重试的设备读取
*/
private int[] readDeviceWithRetry(String ip, int port, int deviceId, String storeyIdStr) throws Exception {
private int[] readDeviceWithRetry(String ip, int port, int deviceId, String storeyIdStr) {
ModbusMaster master = null;
int[] result = null;
boolean readSuccess = false;
for (int retry = 0; retry <= CUSTOM_RETRY_TIMES; retry++) {
try {
// 1. 创建Modbus连接（取消内置重试，master.setRetries(0)）
master = createModbusMaster(ip, port);
// 2. 读取寄存器
result = readDeviceRegisters(master, deviceId);
// 3. 检查结果（若有停止条件）
Predicate<int[]> stopCondition = ModbusResultHandler.createDefaultStopCondition();
if (stopCondition.test(result)) {
readSuccess = true;
log.debug("设备读取成功（满足停止条件）：ip={}，port={}，deviceId={}，重试次数={}，fStoreyId={}",
ip, port, deviceId, retry, storeyIdStr);
break;
} else if (retry < CUSTOM_RETRY_TIMES) {
log.debug("设备读取结果不满足条件，准备重试：ip={}，port={}，deviceId={}，重试次数={}，fStoreyId={}",
ip, port, deviceId, retry, storeyIdStr);
Thread.sleep(RETRY_DELAY_MS);
int[] result = readDeviceRegisters(master, deviceId);
// 检查停止条件
if (resultHandler != null && ModbusResultHandler.createDefaultStopCondition().test(result)) {
log.debug("设备{}读取成功: ip={}, port={}", deviceId, ip, port);
return result;
}
if (retry < CUSTOM_RETRY_TIMES) {
Thread.sleep(200);
}
} catch (Exception e) {
if (retry < CUSTOM_RETRY_TIMES) {
log.warn("设备读取异常，准备重试：ip={}，port={}，deviceId={}，重试次数={}，fStoreyId={}",
ip, port, deviceId, retry, storeyIdStr, e);
Thread.sleep(RETRY_DELAY_MS);
log.debug("设备{}读取失败，准备重试: ip={}, port={}", deviceId, ip, port);
} else {
String errMsg = "设备读取重试耗尽（共" + CUSTOM_RETRY_TIMES + "次）：ip=" + ip + "，port=" + port + "，deviceId=" + deviceId;
log.error(errMsg, e);
log.error("设备{}读取重试耗尽: ip={}, port={}", deviceId, ip, port, e);
throw new RuntimeException("设备读取失败", e);
}
} finally {
// 每次重试后销毁连接，避免资源泄漏
destroyModbusMaster(master, deviceId);
}
}
if (!readSuccess) {
String errMsg = "设备读取未满足停止条件（重试" + CUSTOM_RETRY_TIMES + "次）：ip=" + ip + "，port=" + port + "，deviceId=" + deviceId;
log.error(errMsg);
throw new RuntimeException("设备读取未满足条件");
}
/**
* 写入当前时间到设备
*/
private void writeCurrentTimeToDevice(ModbusMaster master, int deviceId,
PalletDeviceBinding binding, String ip, int port) {
try {
Calendar cal = Calendar.getInstance();
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH) + 1;
int day = cal.get(Calendar.DATE);
int hour = cal.get(Calendar.HOUR_OF_DAY);
int minute = cal.get(Calendar.MINUTE);
// 写入时间寄存器
boolean success;
success = Modbus4jUtils.writeRegister(master, deviceId, 4, (short) year);
success &= Modbus4jUtils.writeRegister(master, deviceId, 5, (short) month);
success &= Modbus4jUtils.writeRegister(master, deviceId, 6, (short) day);
success &= Modbus4jUtils.writeRegister(master, deviceId, 7, (short) hour);
success &= Modbus4jUtils.writeRegister(master, deviceId, 8, (short) minute);
if (success) {
binding.setRecordYear(String.valueOf(year));
binding.setRecordMonth(String.valueOf(month));
binding.setRecordDate(String.valueOf(day));
binding.setRecordHour(String.valueOf(hour));
binding.setRecordMinute(String.valueOf(minute));
log.debug("设备{}时间写入成功", deviceId);
} else {
recordAlarmByBinding(binding, "设备时间写入失败");
}
} catch (Exception e) {
log.error("设备{}时间写入异常", deviceId, e);
recordAlarmByBinding(binding, "设备时间写入异常: " + e.getMessage());
}
return result;
}
// -------------------------- Modbus工具方法（显式抛出异常）--------------------------
/**
* 创建Modbus连接（取消内置重试，统一自定义重试）
......@@ -372,9 +305,8 @@ public class DeviceCommunicationJob implements Job {
TcpMaster master = (TcpMaster) modbusFactory.createTcpMaster(params, true);
master.setTimeout(MODBUS_CONN_TIMEOUT_MS);
master.setRetries(0); // 取消内置重试，避免和自定义重试冲突
master.setRetries(0);
master.init();
log.debug("Modbus连接创建成功：ip={}，port={}，master={}", ip, port, master);
return master;
}
......@@ -406,55 +338,13 @@ public class DeviceCommunicationJob implements Job {
* 销毁Modbus连接（反射失败直接抛出异常，显式暴露问题）
*/
private void destroyModbusMaster(ModbusMaster master, int deviceId) {
if (master == null) return;
try {
// 反射获取Socket（若失败，直接抛异常，不隐藏）
Socket socket = getUnderlyingSocket(master);
if (socket != null && !socket.isClosed()) {
socket.close();
log.trace("设备{}：Modbus底层Socket已关闭", deviceId);
}
} catch (Exception e) {
String errMsg = "设备" + deviceId + "：销毁Modbus Socket异常（可能导致连接泄漏）";
log.error(errMsg, e);
// 此处不抛出异常（避免中断销毁流程），但记录严重告警
recordAlarm(null, String.valueOf(deviceId), errMsg + "：" + e.getMessage());
} finally {
if (master != null) {
try {
master.destroy();
log.trace("设备{}：ModbusMaster已销毁", deviceId);
} catch (Exception e) {
log.error("设备{}：销毁ModbusMaster异常", deviceId, e);
}
}
}
/**
* 反射获取TcpMaster的Socket（失败直接抛出异常，显式暴露问题）
*/
private Socket getUnderlyingSocket(ModbusMaster master) {
if (!(master instanceof TcpMaster)) {
log.info("TcpMaster类型转换失败：" + master.getClass().getName());
}
TcpMaster tcpMaster = (TcpMaster) master;
try {
// 反射获取socket字段（根据你的TcpMaster源码确认字段名，必须正确）
Field socketField = TcpMaster.class.getDeclaredField("socket");
socketField.setAccessible(true);
Socket socket = (Socket) socketField.get(tcpMaster);
if (socket == null) {
log.warn("TcpMaster的socket字段为null（未建立连接）");
log.debug("设备{}: ModbusMaster销毁异常", deviceId, e);
}
return socket;
} catch (NoSuchFieldException e) {
log.info("反射获取Socket失败：TcpMaster中不存在'socket'字段（版本不匹配");
} catch (IllegalAccessException e) {
log.info("反射获取Socket失败：无访问权限（可能被安全管理器拦截）");
}
return null;
}
// -------------------------- 辅助方法（日志/告警）--------------------------
......@@ -494,4 +384,27 @@ public class DeviceCommunicationJob implements Job {
private void recordAlarm(TStoreyInfo storeyInfo, String alarmData) {
recordAlarm(storeyInfo, storeyInfo != null ? storeyInfo.getfStoreyCode() : "unknown", alarmData);
}
/**
* 统一告警记录（修复字段错误，确保写入成功）
*/
private void recordAlarmByBinding(PalletDeviceBinding binding, String alarmMsg) {
String equipmentCode = binding != null ? binding.getDeviceCode() : "unknown";
recordAlarmByBingding(equipmentCode, alarmMsg);
}
private void recordAlarmByBingding(String equipmentCode, String alarmMsg) {
try {
TEquipmentAlarmData alarm = new TEquipmentAlarmData();
alarm.setfAlarmType("04"); // 04.点位告警
alarm.setfEquipmentCode(equipmentCode);
alarm.setfAlarmData(alarmMsg);
alarm.setfCreateTime(new Date()); // 修复字段错误：用fCreateTime而非createTime
alarmDataService.insertTEquipmentAlarmData(alarm);
log.debug("告警记录成功：equipmentCode={}, msg={}", equipmentCode, alarmMsg);
} catch (Exception e) {
log.error("告警记录失败：equipmentCode={}, msg={}", equipmentCode, alarmMsg, e);
}
}
}
\ No newline at end of file
zhmes-agecal-system/src/main/java/com/zehong/system/task/DeviceTaskScheduler.java
View file @ c0abff62
package com.zehong.system.task;
import com.zehong.quartz.config.QuartzTaskMonitor;
import com.zehong.system.task.DeviceCommJob.*;
import com.zehong.system.task.DeviceCommJob.DeviceComm501Device1Job;
import com.zehong.system.task.DeviceCommJob.DeviceComm501Device2Job;
import com.zehong.system.task.DeviceCommJob.DeviceComm501Device3Job;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.terracotta.quartz.wrappers.TriggerWrapper;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
......@@ -153,6 +153,7 @@ public class DeviceTaskScheduler {
SimpleTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey)
.forJob(jobKey)
.withDescription("设备" + fStoreyId + "最终任务触发器，触发时间是:" + triggerTime)
.startAt(triggerTime)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withRepeatCount(0) // 只执行一次
......@@ -268,7 +269,7 @@ public class DeviceTaskScheduler {
SimpleTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey)
.forJob(jobKey)
.withDescription("设备" + fStoreyId + "最终任务触发器")
.withDescription("设备" + fStoreyId + "最终任务触发器，触发时间是:" + executeTime)
.startAt(executeTime)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withMisfireHandlingInstructionFireNow() // 错过立即执行
......
zhmes-agecal-web/src/views/screen/index.vue
View file @ c0abff62
......@@ -126,7 +126,11 @@ export default {
this.selectedMenu = index;
},
goToAdmin() {
this.$router.push('/index') // 或者 '/dashboard' 如果已经登录
// 先跳转到目标页面
this.$router.push('/index').then(() => {
// 跳转成功后刷新页面
window.location.reload()
})
},
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment