autumn/jsowell-charger-web
1
0
Fork 0
mirror of https://codeup.aliyun.com/67c68d4e484ca2f0a13ac3c1/ydc/jsowell-charger-web.git synced 2026-04-20 02:55:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev-new' into dev-new-rabbitmq

Browse Source 
# Conflicts:
#	jsowell-admin/src/test/java/SpringBootTestController.java
#	jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java
#	jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java
This commit is contained in:
Guoqs
2024-12-28 15:15:15 +08:00
parent d0be55940b c9bfa8ace8
commit 665efe290b
54 changed files with 4373 additions and 2540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
jsowell-netty/src/main/java/com/jsowell/netty/decoder/YkcProtocolDecoder.java
View File

@@ -10,6 +10,7 @@ import lombok.extern.slf4j.Slf4j;
import java.util.List;
@Deprecated
@Slf4j
public class YkcProtocolDecoder extends ByteToMessageDecoder {

112
jsowell-netty/src/main/java/com/jsowell/netty/decoder/YouDianProtocolDecoder.java
View File

@@ -4,6 +4,7 @@ import com.jsowell.common.constant.Constants;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.ReferenceCountUtil;
import lombok.extern.slf4j.Slf4j;
import java.nio.charset.StandardCharsets;
@@ -37,7 +38,7 @@ public class YouDianProtocolDecoder extends ByteToMessageDecoder {
buffer.markReaderIndex();
// 判断是否为DNY包头或68包头
if (isStartOfDnyHeader(buffer, beginReader) || isStartOf68Header(buffer, beginReader)) {
if (isStartOfDnyHeader(buffer, beginReader)) {
break; // 读到了协议的开始标志，结束while循环
}
@@ -60,13 +61,13 @@ public class YouDianProtocolDecoder extends ByteToMessageDecoder {
}
// 检查包头是否是 68 协议
if (buffer.readableBytes() >= HEADER_LENGTH_68) {
if (buffer.getUnsignedByte(beginReader) == 0x68) {
// 处理 68 协议
decode68Message(buffer, out, beginReader);
return;
}
}
// if (buffer.readableBytes() >= HEADER_LENGTH_68) {
// if (buffer.getUnsignedByte(beginReader) == 0x68) {
// // 处理 68 协议
// decode68Message(buffer, out, beginReader);
// return;
// }
// }
// 未知协议，还原读指针
buffer.resetReaderIndex();
@@ -84,58 +85,61 @@ public class YouDianProtocolDecoder extends ByteToMessageDecoder {
}
// 判断是否为68包头
private boolean isStartOf68Header(ByteBuf buffer, int beginReader) {
if (buffer.readableBytes() >= HEADER_LENGTH_68) {
return buffer.getUnsignedByte(beginReader) == 0x68;
}
return false;
}
// private boolean isStartOf68Header(ByteBuf buffer, int beginReader) {
// if (buffer.readableBytes() >= HEADER_LENGTH_68) {
// return buffer.getUnsignedByte(beginReader) == 0x68;
// }
// return false;
// }
// 处理68协议消息
private void decode68Message(ByteBuf buffer, List<Object> out, int beginReader) {
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + 2) {
buffer.readerIndex(beginReader);
return;
}
// 获取消息长度
int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_68);
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + length + 2) {
buffer.readerIndex(beginReader);
return;
}
// 读取 data 数据 最后+2是帧校验域长度
ByteBuf frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_68 + 1 + length + 2);
buffer.readerIndex(beginReader + HEADER_LENGTH_68 + 1 + length + 2);
out.add(frame);
}
// private void decode68Message(ByteBuf buffer, List<Object> out, int beginReader) {
// // 检查剩余数据是否足够
// if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + 2) {
// buffer.readerIndex(beginReader);
// return;
// }
//
// // 获取消息长度
// int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_68);
// // 检查剩余数据是否足够
// if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + length + 2) {
// buffer.readerIndex(beginReader);
// return;
// }
//
// // 读取 data 数据 最后+2是帧校验域长度
// ByteBuf frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_68 + 1 + length + 2);
// buffer.readerIndex(beginReader + HEADER_LENGTH_68 + 1 + length + 2);
// out.add(frame);
// }
// 处理DNY协议消息
private void decodeDnyMessage(ByteBuf buffer, List<Object> out, int beginReader) {
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1) {
buffer.readerIndex(beginReader);
return;
ByteBuf frame = null;
try {
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1) {
buffer.readerIndex(beginReader);
return;
}
// 获取消息长度
int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_DNY);
// log.info("获取消息长度, length:{}", length);
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1 + length) {
buffer.readerIndex(beginReader);
return;
}
// 读取 data 数据
frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_DNY + length + 2);
buffer.readerIndex(beginReader + HEADER_LENGTH_DNY + length + 2);
out.add(frame);
} finally {
if (frame != null) {
ReferenceCountUtil.release(frame);
}
}
// 获取消息长度
int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_DNY);
// log.info("获取消息长度, length:{}", length);
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1 + length) {
buffer.readerIndex(beginReader);
return;
}
// 读取 data 数据
ByteBuf frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_DNY + length + 2);
buffer.readerIndex(beginReader + HEADER_LENGTH_DNY + length + 2);
out.add(frame);
}
}

140
jsowell-netty/src/main/java/com/jsowell/netty/decoder/YunKuaiChongDecoder.java
View File

@@ -1,13 +1,12 @@
package com.jsowell.netty.decoder;
import com.jsowell.common.constant.Constants;
import com.jsowell.common.core.domain.ykc.YKCDataProtocol;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.ReferenceCountUtil;
import lombok.extern.slf4j.Slf4j;
import java.nio.charset.StandardCharsets;
import java.util.List;
@Slf4j
@@ -35,7 +34,7 @@ public class YunKuaiChongDecoder extends ByteToMessageDecoder {
buffer.markReaderIndex();
// 判断是否为DNY包头或68包头
if (isStartOfDnyHeader(buffer, beginReader) || isStartOf68Header(buffer, beginReader)) {
if (isStartOf68Header(buffer, beginReader)) {
break; // 读到了协议的开始标志，结束while循环
}
@@ -45,17 +44,17 @@ public class YunKuaiChongDecoder extends ByteToMessageDecoder {
}
// 检查包头是否是 "DNY"
if (buffer.readableBytes() >= HEADER_LENGTH_DNY) {
byte[] headerBytes = new byte[HEADER_LENGTH_DNY];
buffer.getBytes(beginReader, headerBytes, 0, HEADER_LENGTH_DNY);
String header = new String(headerBytes, StandardCharsets.UTF_8);
// log.info("检查包头是否是DNY, header:{}", header);
if (Constants.EBIKE_HEADER.equals(header)) {
// 处理 DNY 协议
decodeDnyMessage(buffer, out, beginReader);
return;
}
}
// if (buffer.readableBytes() >= HEADER_LENGTH_DNY) {
// byte[] headerBytes = new byte[HEADER_LENGTH_DNY];
// buffer.getBytes(beginReader, headerBytes, 0, HEADER_LENGTH_DNY);
// String header = new String(headerBytes, StandardCharsets.UTF_8);
// // log.info("检查包头是否是DNY, header:{}", header);
// if (Constants.EBIKE_HEADER.equals(header)) {
// // 处理 DNY 协议
// decodeDnyMessage(buffer, out, beginReader);
// return;
// }
// }
// 检查包头是否是 68 协议
if (buffer.readableBytes() >= HEADER_LENGTH_68) {
@@ -71,15 +70,15 @@ public class YunKuaiChongDecoder extends ByteToMessageDecoder {
}
// 判断是否为DNY包头
private boolean isStartOfDnyHeader(ByteBuf buffer, int beginReader) {
if (buffer.readableBytes() >= HEADER_LENGTH_DNY) {
byte[] headerBytes = new byte[HEADER_LENGTH_DNY];
buffer.getBytes(beginReader, headerBytes, 0, HEADER_LENGTH_DNY);
String header = new String(headerBytes, StandardCharsets.UTF_8);
return Constants.EBIKE_HEADER.equals(header);
}
return false;
}
// private boolean isStartOfDnyHeader(ByteBuf buffer, int beginReader) {
// if (buffer.readableBytes() >= HEADER_LENGTH_DNY) {
// byte[] headerBytes = new byte[HEADER_LENGTH_DNY];
// buffer.getBytes(beginReader, headerBytes, 0, HEADER_LENGTH_DNY);
// String header = new String(headerBytes, StandardCharsets.UTF_8);
// return Constants.EBIKE_HEADER.equals(header);
// }
// return false;
// }
// 判断是否为68包头
private boolean isStartOf68Header(ByteBuf buffer, int beginReader) {
@@ -91,54 +90,59 @@ public class YunKuaiChongDecoder extends ByteToMessageDecoder {
// 处理68协议消息
private void decode68Message(ByteBuf buffer, List<Object> out, int beginReader) {
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + 2) {
buffer.readerIndex(beginReader);
return;
ByteBuf frame = null;
try {
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + 2) {
buffer.readerIndex(beginReader);
return;
}
// 获取消息长度
int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_68);
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + length + 2) {
buffer.readerIndex(beginReader);
return;
}
// 读取 data 数据 最后+2是帧校验域长度
frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_68 + 1 + length + 2);
buffer.readerIndex(beginReader + HEADER_LENGTH_68 + 1 + length + 2);
// 转为YKCDataProtocol对象
byte[] bytes = new byte[HEADER_LENGTH_68 + 1 + length + 2];
frame.readBytes(bytes);
YKCDataProtocol ykcDataProtocol = new YKCDataProtocol(bytes);
out.add(ykcDataProtocol);
} finally {
if (frame != null) {
ReferenceCountUtil.release(frame);
}
}
// 获取消息长度
int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_68);
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_68 + 1 + length + 2) {
buffer.readerIndex(beginReader);
return;
}
// 读取 data 数据 最后+2是帧校验域长度
ByteBuf frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_68 + 1 + length + 2);
buffer.readerIndex(beginReader + HEADER_LENGTH_68 + 1 + length + 2);
// 转为YKCDataProtocol对象
byte[] bytes = new byte[HEADER_LENGTH_68 + 1 + length + 2];
frame.readBytes(bytes);
YKCDataProtocol ykcDataProtocol = new YKCDataProtocol(bytes);
out.add(ykcDataProtocol);
}
// 处理DNY协议消息
private void decodeDnyMessage(ByteBuf buffer, List<Object> out, int beginReader) {
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1) {
buffer.readerIndex(beginReader);
return;
}
// 获取消息长度
int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_DNY);
// log.info("获取消息长度, length:{}", length);
// 检查剩余数据是否足够
if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1 + length) {
buffer.readerIndex(beginReader);
return;
}
// 读取 data 数据
ByteBuf frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_DNY + length + 2);
buffer.readerIndex(beginReader + HEADER_LENGTH_DNY + length + 2);
out.add(frame);
}
// private void decodeDnyMessage(ByteBuf buffer, List<Object> out, int beginReader) {
// // 检查剩余数据是否足够
// if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1) {
// buffer.readerIndex(beginReader);
// return;
// }
//
// // 获取消息长度
// int length = buffer.getUnsignedByte(beginReader + HEADER_LENGTH_DNY);
// // log.info("获取消息长度, length:{}", length);
// // 检查剩余数据是否足够
// if (buffer.readableBytes() < HEADER_LENGTH_DNY + 1 + length) {
// buffer.readerIndex(beginReader);
// return;
// }
//
// // 读取 data 数据
// ByteBuf frame = buffer.retainedSlice(beginReader, HEADER_LENGTH_DNY + length + 2);
// buffer.readerIndex(beginReader + HEADER_LENGTH_DNY + length + 2);
// out.add(frame);
// }
}

7
jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/TransactionRecordsRequestHandler.java
View File

@@ -611,6 +611,7 @@ public class TransactionRecordsRequestHandler extends AbstractYkcHandler {
String pileSn = data.getPileSn(); // 充电桩编号
PileBasicInfo pileBasicInfo = pileBasicInfoService.selectPileBasicInfoBySN(pileSn);
if (StringUtils.equals(pileBasicInfo.getBusinessType(), Constants.TWO)) {
// 个人桩处理逻辑
personalChargingRecordService.processPersonalChargingRecord(data);
// return;
}
@@ -620,7 +621,7 @@ public class TransactionRecordsRequestHandler extends AbstractYkcHandler {
OrderBasicInfo orderBasicInfo = orderBasicInfoService.getOrderInfoByTransactionCode(transactionCode);
if (orderBasicInfo != null) {
// 平台存在订单
orderBasicInfo.setReason(data.getStopReasonMsg());
// 如果订单状态为 异常，则改为 待结算
if (StringUtils.equals(OrderStatusEnum.ABNORMAL.getValue(), orderBasicInfo.getOrderStatus())) {
orderBasicInfo.setOrderStatus(OrderStatusEnum.STAY_SETTLEMENT.getValue());
@@ -640,6 +641,10 @@ public class TransactionRecordsRequestHandler extends AbstractYkcHandler {
// 将停止原因码存库
orderBasicInfo.setStopReasonCode("0x" + data.getStopReasonCode());
// 停止原因
if (StringUtils.isNotBlank(data.getStopReasonMsg())) {
orderBasicInfo.setReason(data.getStopReasonMsg());
}
orderBasicInfoService.updateOrderBasicInfo(orderBasicInfo);

30
jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/UploadRealTimeMonitorHandler.java
View File

@@ -320,27 +320,27 @@ public class UploadRealTimeMonitorHandler extends AbstractYkcHandler {
if (updateFlag) {
orderBasicInfoService.updateOrderBasicInfo(orderInfo);
}
// 判断该订单是否需要下发优惠券
String redisKey = CacheConstants.CAR_BIND_COUPON_BY_ORDER_CODE + orderInfo.getOrderCode();
Object cacheObject = redisCache.getCacheObject(redisKey);
if (cacheObject == null && sumChargingTime >= 10) {
// 异步绑定优惠券并设置缓存
CompletableFuture.runAsync(() -> {
try {
commonService.bindCoupon(orderInfo);
redisCache.setCacheObject(redisKey, Boolean.TRUE, 24, TimeUnit.HOURS);
} catch (Exception e) {
log.error("异步绑定车辆优惠券 error,", e);
}
}, executor);
}
}
// 充电时保存实时数据到redis
if (saveRedisFlag) {
pileBasicInfoService.saveRealTimeMonitorData2Redis(realTimeMonitorData);
}
// 判断该订单是否需要下发优惠券
String redisKey = CacheConstants.CAR_BIND_COUPON_BY_ORDER_CODE + orderInfo.getOrderCode();
Object cacheObject = redisCache.getCacheObject(redisKey);
if (cacheObject == null && sumChargingTime >= 10) {
// 异步绑定优惠券并设置缓存
CompletableFuture.runAsync(() -> {
try {
commonService.bindCoupon(orderInfo);
redisCache.setCacheObject(redisKey, Boolean.TRUE, 24, TimeUnit.HOURS);
} catch (Exception e) {
log.error("异步绑定车辆优惠券 error,", e);
}
}, executor);
}
}
// 异步推送第三方平台实时数据

42
jsowell-netty/src/main/java/com/jsowell/netty/server/electricbicycles/ElectricBicyclesServerHandler.java
View File

@@ -8,6 +8,7 @@ import com.jsowell.netty.service.electricbicycles.EBikeBusinessService;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.handler.timeout.ReadTimeoutException;
import io.netty.util.ReferenceCountUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -60,25 +61,30 @@ public class ElectricBicyclesServerHandler extends ChannelInboundHandlerAdapter
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object message) throws Exception {
byte[] msg = (byte[]) message;
// 处理数据
byte[] response = eBikeService.process(msg, ctx);
if (Objects.nonNull(response)) {
log.info("[电单车===>响应数据]:{}", BytesUtil.binary(response, 16));
// 响应客户端
ByteBuf buffer = ctx.alloc().buffer().writeBytes(response);
// this.channelWrite(channel.id(), buffer);
ctx.writeAndFlush(buffer);
// if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
// // 应答帧类型
// byte[] responseFrameTypeBytes = YKCFrameTypeCode.PlatformAnswersRelation.getResponseFrameTypeBytes(frameTypeBytes);
// String responseFrameType = YKCUtils.frameType2Str(responseFrameTypeBytes);
// log.info("【>>>>>平台响应消息>>>>>】channel:{}, 响应帧类型:{}, 响应帧名称:{}, 原帧类型:{}, 原帧名称:{}, 序列号域:{}, response:{}",
// channel.id(), responseFrameType, YKCFrameTypeCode.getFrameTypeStr(responseFrameType),
// frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
// BytesUtil.binary(response, 16));
// }
try {
byte[] msg = (byte[]) message;
// 处理数据
byte[] response = eBikeService.process(msg, ctx);
if (Objects.nonNull(response)) {
log.info("[电单车===>响应数据]:{}", BytesUtil.binary(response, 16));
// 响应客户端
ByteBuf buffer = ctx.alloc().buffer().writeBytes(response);
// this.channelWrite(channel.id(), buffer);
ctx.writeAndFlush(buffer);
// if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
// // 应答帧类型
// byte[] responseFrameTypeBytes = YKCFrameTypeCode.PlatformAnswersRelation.getResponseFrameTypeBytes(frameTypeBytes);
// String responseFrameType = YKCUtils.frameType2Str(responseFrameTypeBytes);
// log.info("【>>>>>平台响应消息>>>>>】channel:{}, 响应帧类型:{}, 响应帧名称:{}, 原帧类型:{}, 原帧名称:{}, 序列号域:{}, response:{}",
// channel.id(), responseFrameType, YKCFrameTypeCode.getFrameTypeStr(responseFrameType),
// frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
// BytesUtil.binary(response, 16));
// }
}
} finally {
ReferenceCountUtil.release(message);
}
}
/**

155
jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerHandler.java
View File

@@ -13,6 +13,7 @@ import io.netty.channel.*;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.handler.timeout.ReadTimeoutException;
import io.netty.util.ReferenceCountUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -39,7 +40,7 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
*/
private static final ConcurrentHashMap<ChannelId, ChannelHandlerContext> CHANNEL_MAP = new ConcurrentHashMap<>();
private final List<String> notPrintFrameTypeList = Lists.newArrayList(); // "0x03"
private final List<String> notPrintFrameTypeList = Lists.newArrayList("0x03"); // "0x03"
/**
* 有客户端连接服务器会触发此函数
@@ -127,57 +128,39 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object message) throws Exception {
YKCDataProtocol ykcDataProtocol = (YKCDataProtocol) message;
// 获取帧类型
byte[] frameTypeBytes = ykcDataProtocol.getFrameType();
String frameType = YKCUtils.frameType2Str(frameTypeBytes);
// 判断该帧类型是否为某请求帧的应答帧
// String requestFrameType = YKCFrameTypeCode.PileAnswersRelation.getRequestFrameType(frameType);
// log.info("同步获取响应数据-判断该帧类型是否为某请求帧的应答帧, frameType:{}, requestFrameType:{}", frameType, requestFrameType);
// if (StringUtils.isNotBlank(requestFrameType)) {
// // 根据请求id，在集合中找到与外部线程通信的SyncPromise对象
// String msgId = ctx.channel().id().toString() + "_" + requestFrameType;
// // log.info("同步获取响应数据-收到消息, msgId:{}", msgId);
// SyncPromise syncPromise = RpcUtil.getSyncPromiseMap().get(msgId);
// if(syncPromise != null) {
// // 设置响应结果
// syncPromise.setRpcResult(ykcDataProtocol.getBytes());
// // 唤醒外部线程
// // log.info("同步获取响应数据-唤醒外部线程, SyncPromise:{}", JSON.toJSONString(syncPromise));
// syncPromise.wake();
// }
// }
// 获取序列号域
int serialNumber = BytesUtil.bytesToIntLittle(ykcDataProtocol.getSerialNumber());
// 获取channel
Channel channel = ctx.channel();
// 心跳包0x03日志太多，造成日志文件过大，改为不打印
if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
log.info("【<<<<<平台收到消息<<<<<】channel:{}, 帧类型:{}, 帧名称:{}, 序列号域:{}, 报文:{}",
channel.id(), frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
BytesUtil.binary(ykcDataProtocol.getBytes(), 16));
}
// 处理数据
byte[] response = ykcService.process(ykcDataProtocol, ctx);
if (Objects.nonNull(response)) {
// 响应客户端
ByteBuf buffer = ctx.alloc().buffer().writeBytes(response);
this.channelWrite(channel.id(), buffer);
try {
YKCDataProtocol ykcDataProtocol = (YKCDataProtocol) message;
// 获取帧类型
byte[] frameTypeBytes = ykcDataProtocol.getFrameType();
String frameType = YKCUtils.frameType2Str(frameTypeBytes);
// 获取序列号域
int serialNumber = BytesUtil.bytesToIntLittle(ykcDataProtocol.getSerialNumber());
// 获取channel
Channel channel = ctx.channel();
// 心跳包0x03日志太多，造成日志文件过大，改为不打印
if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
// 应答帧类型
byte[] responseFrameTypeBytes = YKCFrameTypeCode.PlatformAnswersRelation.getResponseFrameTypeBytes(frameTypeBytes);
String responseFrameType = YKCUtils.frameType2Str(responseFrameTypeBytes);
log.info("【>>>>>平台响应消息>>>>>】channel:{}, 响应帧类型:{}, 响应帧名称:{}, 原帧类型:{}, 原帧名称:{}, 序列号域:{}, response:{}",
channel.id(), responseFrameType, YKCFrameTypeCode.getFrameTypeStr(responseFrameType),
frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
BytesUtil.binary(response, 16));
log.info("【<<<<<平台收到消息<<<<<】channel:{}, 帧类型:{}, 帧名称:{}, 序列号域:{}, 报文:{}",
channel.id(), frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
BytesUtil.binary(ykcDataProtocol.getBytes(), 16));
}
// 处理数据
byte[] response = ykcService.process(ykcDataProtocol, ctx);
if (Objects.nonNull(response)) {
// 响应客户端
ByteBuf buffer = ctx.alloc().buffer().writeBytes(response);
this.channelWrite(channel.id(), buffer);
if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
// 应答帧类型
byte[] responseFrameTypeBytes = YKCFrameTypeCode.PlatformAnswersRelation.getResponseFrameTypeBytes(frameTypeBytes);
String responseFrameType = YKCUtils.frameType2Str(responseFrameTypeBytes);
log.info("【>>>>>平台响应消息>>>>>】channel:{}, 响应帧类型:{}, 响应帧名称:{}, 原帧类型:{}, 原帧名称:{}, 序列号域:{}, response:{}",
channel.id(), responseFrameType, YKCFrameTypeCode.getFrameTypeStr(responseFrameType),
frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
BytesUtil.binary(response, 16));
}
}
} finally {
ReferenceCountUtil.release(message);
}
}
@@ -248,25 +231,31 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
String socketString = ctx.channel().remoteAddress().toString();
ChannelId channelId = ctx.channel().id();
String pileSn = PileChannelEntity.getPileSnByChannelId(channelId.asLongText());
if (evt instanceof IdleStateEvent) { // 超时事件
IdleStateEvent event = (IdleStateEvent) evt;
boolean flag = false;
if (event.state() == IdleState.READER_IDLE) { // 读
flag = true;
// log.error("Client-IP:【{}】, channelId:【{}】, pileSn:【{}】, READER_IDLE 读超时", socketString, channelId, pileSn);
} else if (event.state() == IdleState.WRITER_IDLE) { // 写
flag = true;
// log.error("Client-IP:【{}】, channelId:【{}】, pileSn:【{}】, WRITER_IDLE 写超时", socketString, channelId, pileSn);
} else if (event.state() == IdleState.ALL_IDLE) { // 全部
flag = true;
// log.error("Client-IP:【{}】, channelId:【{}】, pileSn:【{}】, ALL_IDLE 总超时", socketString, channelId, pileSn);
try {
String socketString = ctx.channel().remoteAddress().toString();
ChannelId channelId = ctx.channel().id();
String pileSn = PileChannelEntity.getPileSnByChannelId(channelId.asLongText());
if (evt instanceof IdleStateEvent) { // 超时事件
IdleStateEvent event = (IdleStateEvent) evt;
boolean flag = false;
if (event.state() == IdleState.READER_IDLE) { // 读
flag = true;
// log.error("Client-IP:【{}】, channelId:【{}】, pileSn:【{}】, READER_IDLE 读超时", socketString, channelId, pileSn);
} else if (event.state() == IdleState.WRITER_IDLE) { // 写
flag = true;
// log.error("Client-IP:【{}】, channelId:【{}】, pileSn:【{}】, WRITER_IDLE 写超时", socketString, channelId, pileSn);
} else if (event.state() == IdleState.ALL_IDLE) { // 全部
flag = true;
// log.error("Client-IP:【{}】, channelId:【{}】, pileSn:【{}】, ALL_IDLE 总超时", socketString, channelId, pileSn);
}
if (flag) {
ctx.channel().close();
// close(channelId, pileSn);
}
}
if (flag) {
ctx.channel().close();
// close(channelId, pileSn);
} finally {
if (evt instanceof ByteBuf) {
ReferenceCountUtil.release(evt);
}
}
}
@@ -276,20 +265,26 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ChannelId channelId = ctx.channel().id();
String channelIdShortText = channelId.asShortText();
String pileSn = PileChannelEntity.getPileSnByChannelId(channelIdShortText);
log.error("发生异常 channelId:{}, pileSn:{}", channelIdShortText, pileSn, cause);
cause.printStackTrace();
// 如果桩连到平台，在1分钟内没有发送数据过来，会报ReadTimeoutException异常
if (cause instanceof ReadTimeoutException) {
if (log.isTraceEnabled()) {
log.trace("Connection timeout 【{}】", ctx.channel().remoteAddress());
try {
ChannelId channelId = ctx.channel().id();
String channelIdShortText = channelId.asShortText();
String pileSn = PileChannelEntity.getPileSnByChannelId(channelIdShortText);
log.error("发生异常 channelId:{}, pileSn:{}", channelIdShortText, pileSn, cause);
cause.printStackTrace();
// 如果桩连到平台，在1分钟内没有发送数据过来，会报ReadTimeoutException异常
if (cause instanceof ReadTimeoutException) {
if (log.isTraceEnabled()) {
log.trace("Connection timeout 【{}】", ctx.channel().remoteAddress());
}
log.error("【{}】发生了错误, pileSn:【{}】此连接被关闭, 此时连通数量: {}", channelId, pileSn, CHANNEL_MAP.size());
ctx.channel().close();
}
} finally {
if (ctx.channel().isActive()) {
ctx.close();
}
log.error("【{}】发生了错误, pileSn:【{}】此连接被关闭, 此时连通数量: {}", channelId, pileSn, CHANNEL_MAP.size());
ctx.channel().close();
}
// close(channelId, pileSn);
}