update 修复离线bug

jsowell-common/src/main/java/com/jsowell/common/constant/CacheConstants.java

@@ -168,6 +168,16 @@ public class CacheConstants {
 	 */
 	public static final String PILE_LAST_CONNECTION = "pile_last_connection:";
 
+	/**
+	 * 充电桩待确认断链标记
+	 */
+	public static final String PILE_PENDING_DISCONNECT = "pile_pending_disconnect:";
+
+	/**
+	 * 充电桩已确认离线标记
+	 */
+	public static final String PILE_OFFLINE_CONFIRMED = "pile_offline_confirmed:";
+
 	/**
 	 * 查询枪口信息列表前缀
 	 */

jsowell-common/src/main/java/com/jsowell/common/enums/ykc/PileChannelEntity.java

@@ -137,6 +137,21 @@ public class PileChannelEntity {
         manager.remove(pileSn);
     }
 
+    public static boolean removeByPileSnAndChannelId(String pileSn, String expectedChannelId) {
+        if (StringUtils.isBlank(pileSn) || StringUtils.isBlank(expectedChannelId)) {
+            return false;
+        }
+        ChannelHandlerContext currentCtx = manager.get(pileSn);
+        if (currentCtx == null || currentCtx.channel() == null) {
+            return false;
+        }
+        String currentChannelId = currentCtx.channel().id().asLongText();
+        if (!StringUtils.equals(currentChannelId, expectedChannelId)) {
+            return false;
+        }
+        return manager.remove(pileSn, currentCtx);
+    }
+
     public static void removeByChannelId(String channelId){
         if (StringUtils.isBlank(channelId)) {
             return;

jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/AbstractYkcHandler.java

@@ -67,6 +67,9 @@ public abstract class AbstractYkcHandler implements InitializingBean {
           String redisKey = CacheConstants.PILE_LAST_CONNECTION + pileSn;
           redisCache.setCacheObject(redisKey, DateUtils.getDateTime(), CacheConstants.cache_expire_time_30d);
 
+          redisCache.deleteObject(CacheConstants.PILE_PENDING_DISCONNECT + pileSn);
+          redisCache.deleteObject(CacheConstants.PILE_OFFLINE_CONFIRMED + pileSn);
+
           // 保存桩号和channel的关系
           PileChannelEntity.checkChannel(pileSn, ctx);
 

jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerChannelInitializer.java

@@ -34,8 +34,8 @@ public class NettyServerChannelInitializer extends ChannelInitializer<SocketChan
 		// pipeline.addLast("frameDecoder", new YkcProtocolDecoder());
 		pipeline.addLast("decoder", new ByteArrayDecoder());
 		pipeline.addLast("encoder", new ByteArrayDecoder());
-		// 读超时时间设置为30s，0表示不监控
-		pipeline.addLast(new IdleStateHandler(30, 0, 0, TimeUnit.SECONDS));
+		// 读空闲tick设置为15s，连续3次空闲后再由handler执行关闭
+		pipeline.addLast(new IdleStateHandler(15, 0, 0, TimeUnit.SECONDS));
 		// pipeline.addLast("handler", nettyServerHandler);
 		pipeline.addLast(businessGroup, nettyServerHandler); // 消息先进入业务线程池
 		pipeline.addLast(echoServerHandler);

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

@@ -5,19 +5,22 @@ import com.jsowell.common.core.domain.ykc.YKCDataProtocol;
 import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode;
 import com.jsowell.common.enums.ykc.PileChannelEntity;
 import com.jsowell.common.util.BytesUtil;
-import com.jsowell.common.util.StringUtils;
+import com.jsowell.common.util.DateUtils;
 import com.jsowell.common.util.YKCUtils;
 import com.jsowell.netty.service.yunkuaichong.YKCBusinessService;
-import com.jsowell.netty.service.yunkuaichong.impl.YKCBusinessServiceImpl;
 import io.netty.buffer.ByteBuf;
-import io.netty.channel.*;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelId;
+import io.netty.channel.ChannelInboundHandlerAdapter;
 import io.netty.handler.timeout.IdleState;
 import io.netty.handler.timeout.IdleStateEvent;
 import io.netty.handler.timeout.ReadTimeoutException;
+import io.netty.util.AttributeKey;
 import io.netty.util.ReferenceCountUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
@@ -34,6 +37,16 @@ import java.util.concurrent.ConcurrentHashMap;
 @Component
 public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 
+	public static final AttributeKey<Integer> IDLE_COUNT = AttributeKey.valueOf("ykc_idle_count");
+	public static final AttributeKey<String> LAST_FRAME_TYPE = AttributeKey.valueOf("ykc_last_frame_type");
+	public static final AttributeKey<String> LAST_RECEIVE_AT = AttributeKey.valueOf("ykc_last_receive_at");
+	public static final AttributeKey<String> LAST_SERIAL_NUMBER = AttributeKey.valueOf("ykc_last_serial_number");
+	public static final AttributeKey<String> DISCONNECT_REASON = AttributeKey.valueOf("ykc_disconnect_reason");
+
+	private static final int IDLE_STRIKE_THRESHOLD = 3;
+	private static final String DISCONNECT_REASON_READER_IDLE_3X = "reader_idle_3x";
+	private static final String DISCONNECT_REASON_READ_TIMEOUT = "read_timeout";
+
 	@Resource
 	private YKCBusinessService ykcService;
 
@@ -42,9 +55,7 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 	 */
 	private static final ConcurrentHashMap<ChannelId, ChannelHandlerContext> CHANNEL_MAP = new ConcurrentHashMap<>();
 
-	protected static final List<String> notPrintFrameTypeList = Lists.newArrayList("0x03"); // "0x03"
-
-	// private final YKCBusinessService ykcService = new YKCBusinessServiceImpl();
+	protected static final List<String> notPrintFrameTypeList = Lists.newArrayList("0x03");
 
 	/**
 	 * 有客户端连接服务器会触发此函数
@@ -55,107 +66,42 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 		InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
 		String clientIp = insocket.getAddress().getHostAddress();
 		int clientPort = insocket.getPort();
-		//获取连接通道唯一标识
 		ChannelId channelId = ctx.channel().id();
-		//如果map中不包含此连接，就保存连接
+		ctx.channel().attr(IDLE_COUNT).set(0);
 		if (CHANNEL_MAP.containsKey(channelId)) {
 			log.info("客户端【{}】是连接状态，连接通道数量: {}", channelId, CHANNEL_MAP.size());
 		} else {
-			//保存连接
 			CHANNEL_MAP.put(channelId, ctx);
 			log.info("客户端【{}】, 连接netty服务器【IP:{}, PORT:{}】, 连接通道数量: {}", channelId, clientIp, clientPort, CHANNEL_MAP.size());
 		}
 	}
 
-	/**
-	 * 有客户端发消息会触发此函数
-	 */
-	// @Override
-	// public void channelRead(ChannelHandlerContext ctx, Object message) throws Exception {
-	// 	// log.info("channelRead-aClass:{}", message.getClass());
-	// 	// log.info("加载客户端报文channelRead=== channelId:" + ctx.channel().id() + ", msg:" + message);
-	// 	// 下面可以解析数据，保存数据，生成返回报文，将需要返回报文写入write函数
-	// 	YKCDataProtocol ykcDataProtocol = (YKCDataProtocol) message;
-	// 	byte[] msg = ykcDataProtocol.getBytes();
-	//
-	// 	// 获取帧类型
-	// 	byte[] frameTypeBytes = BytesUtil.copyBytes(msg, 5, 1);
-	// 	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(msg);
-	// 			// 唤醒外部线程
-	// 			// log.info("同步获取响应数据-唤醒外部线程, SyncPromise:{}", JSON.toJSONString(syncPromise));
-	// 			syncPromise.wake();
-	// 		}
-	// 	}
-	//
-	// 	// 获取序列号域
-	// 	int serialNumber = BytesUtil.bytesToIntLittle(BytesUtil.copyBytes(msg, 2, 2));
-	//
-	// 	// 获取channel
-	// 	Channel channel = ctx.channel();
-	//
-	// 	// 心跳包0x03日志太多，造成日志文件过大，改为不打印
-	// 	if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
-	// 		log.info("【<<<<<平台收到消息<<<<<】channel:{}, 帧类型:{}, 帧名称:{}, 序列号域:{}, 报文:{}",
-	// 				channel.id(), frameType, YKCFrameTypeCode.getFrameTypeStr(frameType), serialNumber,
-	// 				BytesUtil.binary(msg, 16));
-	// 	}
-	//
-	// 	// 处理数据
-	// 	byte[] response = ykcService.process(msg, 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));
-	// 		}
-	// 	}
-	// }
-
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object message) throws Exception {
 		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日志太多，造成日志文件过大，改为不打印
+
+			ctx.channel().attr(IDLE_COUNT).set(0);
+			ctx.channel().attr(LAST_FRAME_TYPE).set(frameType);
+			ctx.channel().attr(LAST_RECEIVE_AT).set(DateUtils.getDateTime());
+			ctx.channel().attr(LAST_SERIAL_NUMBER).set(String.valueOf(serialNumber));
+			ctx.channel().attr(DISCONNECT_REASON).set(null);
+
 			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);
 				super.channelRead(ctx, buffer);
 				if (!CollectionUtils.containsAny(notPrintFrameTypeList, frameType)) {
-					// 应答帧类型
 					byte[] responseFrameTypeBytes = YKCFrameTypeCode.PlatformAnswersRelation.getResponseFrameTypeBytes(frameTypeBytes);
 					String responseFrameType = YKCUtils.frameType2Str(responseFrameTypeBytes);
 					log.info("【>>>>>平台响应消息>>>>>】channel:{}, 响应帧类型:{}, 响应帧名称:{}, 原帧类型:{}, 原帧名称:{}, 序列号域:{}, response:{}",
@@ -171,32 +117,21 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 
 	/**
 	 * 批量发送信息
-	 * @param pileSn
-	 * @param ctx
-	 * @param msg
+	 *
+	 * @param pileSn 桩编号
+	 * @param msg 消息体
 	 */
 	private void channelWriteBatch(String pileSn, Object msg) {
-		// 获取该桩下的所有channel
 		List<ChannelHandlerContext> list = PileChannelEntity.pileMap.get(pileSn);
-		if(CollectionUtils.isEmpty(list)) {
+		if (CollectionUtils.isEmpty(list)) {
 			return;
 		}
-		// 批量写入
 		for (ChannelHandlerContext context : list) {
 			context.write(msg);
-			//刷新缓存区
 			context.flush();
 		}
-
-		// 如果通道不存在，则将连接删除
-
 	}
 
-	// @Override
-	// protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
-	// 	log.info("channelRead0=== channelId:" + ctx.channel().id() + ", msg:" + msg);
-	// }
-
 	/**
 	 * 有客户端终止连接服务器会触发此函数
 	 */
@@ -205,33 +140,39 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 		InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
 		String clientIp = insocket.getAddress().getHostAddress();
 		ChannelId channelId = ctx.channel().id();
-		//包含此客户端才去删除
+		String pileSn = PileChannelEntity.getPileSnByChannelId(channelId.asLongText());
+		String disconnectReason = defaultString(ctx.channel().attr(DISCONNECT_REASON).get(), "channel_inactive");
 		if (CHANNEL_MAP.containsKey(channelId)) {
 			ykcService.exit(ctx);
-			//删除连接
 			CHANNEL_MAP.remove(channelId);
+		}
+		log.info(
+				"云快充连接断开 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, idleCount:{}, offlineConfirmed:{}, 连接通道数量:{}",
+				defaultString(pileSn),
+				channelId.asLongText(),
+				buildRemoteAddress(ctx),
+				disconnectReason,
+				defaultString(ctx.channel().attr(LAST_FRAME_TYPE).get()),
+				defaultString(ctx.channel().attr(LAST_RECEIVE_AT).get()),
+				getIdleCount(ctx),
+				false,
+				CHANNEL_MAP.size()
+		);
+		if (insocket != null) {
 			log.info("客户端【{}】, 退出netty服务器【IP:{}, PORT:{}】, 连接通道数量: {}", channelId, clientIp, insocket.getPort(), CHANNEL_MAP.size());
 		}
 	}
 
 	@Override
-	public void handlerAdded(ChannelHandlerContext ctx) throws Exception { // (2)
-		// Channel incoming = ctx.channel();
-		// log.info("handlerAdded: handler被添加到channel的pipeline connect:" + incoming.remoteAddress());
+	public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
 	}
 
 	@Override
-	public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { // (3)
-		// Channel incoming = ctx.channel();
-		// log.info("handlerRemoved: handler从channel的pipeline中移除 connect:" + incoming.remoteAddress());
-		// ChannelMapByEntity.removeChannel(incoming);
-		// ChannelMap.removeChannel(incoming);
+	public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
 	}
 
 	@Override
 	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
-		Channel channel = ctx.channel();
-		// log.info("channel:【{}】读数据完成", channel.id());
 		super.channelReadComplete(ctx);
 	}
 
@@ -239,7 +180,7 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 	 * 服务端给客户端发送消息
 	 *
 	 * @param channelId 连接通道唯一id
-	 * @param msg       需要发送的消息内容
+	 * @param msg 需要发送的消息内容
 	 */
 	public void channelWrite(ChannelId channelId, Object msg) throws Exception {
 		ChannelHandlerContext ctx = CHANNEL_MAP.get(channelId);
@@ -251,41 +192,64 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 			log.info("服务端响应空的消息");
 			return;
 		}
-		//将客户端的信息直接返回写入ctx
 		ctx.write(msg);
-		//刷新缓存区
 		ctx.flush();
 	}
 
 	@Override
 	public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-		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);
-				}
-			}
-		} finally {
-			if (evt instanceof ByteBuf) {
-				ReferenceCountUtil.release(evt);
-			}
+		if (!(evt instanceof IdleStateEvent)) {
+			super.userEventTriggered(ctx, evt);
+			return;
 		}
+		IdleStateEvent event = (IdleStateEvent) evt;
+		ChannelId channelId = ctx.channel().id();
+		String pileSn = PileChannelEntity.getPileSnByChannelId(channelId.asLongText());
+		if (event.state() == IdleState.READER_IDLE) {
+			int idleCount = getIdleCount(ctx) + 1;
+			ctx.channel().attr(IDLE_COUNT).set(idleCount);
+			if (idleCount < IDLE_STRIKE_THRESHOLD) {
+				log.warn(
+						"云快充连接读空闲告警 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, idleCount:{}, lastSerialNumber:{}, pendingOffline:{}",
+						defaultString(pileSn),
+						channelId.asLongText(),
+						buildRemoteAddress(ctx),
+						defaultString(ctx.channel().attr(DISCONNECT_REASON).get()),
+						defaultString(ctx.channel().attr(LAST_FRAME_TYPE).get()),
+						defaultString(ctx.channel().attr(LAST_RECEIVE_AT).get()),
+						idleCount,
+						defaultString(ctx.channel().attr(LAST_SERIAL_NUMBER).get()),
+						false
+				);
+				return;
+			}
+			ctx.channel().attr(DISCONNECT_REASON).set(DISCONNECT_REASON_READER_IDLE_3X);
+			log.error(
+					"云快充连接连续读空闲关闭 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, idleCount:{}, lastSerialNumber:{}, pendingOffline:{}",
+					defaultString(pileSn),
+					channelId.asLongText(),
+					buildRemoteAddress(ctx),
+					DISCONNECT_REASON_READER_IDLE_3X,
+					defaultString(ctx.channel().attr(LAST_FRAME_TYPE).get()),
+					defaultString(ctx.channel().attr(LAST_RECEIVE_AT).get()),
+					idleCount,
+					defaultString(ctx.channel().attr(LAST_SERIAL_NUMBER).get()),
+					true
+			);
+			ctx.close();
+			return;
+		}
+		log.warn(
+				"云快充连接空闲事件 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, idleCount:{}, idleState:{}",
+				defaultString(pileSn),
+				channelId.asLongText(),
+				buildRemoteAddress(ctx),
+				defaultString(ctx.channel().attr(DISCONNECT_REASON).get()),
+				defaultString(ctx.channel().attr(LAST_FRAME_TYPE).get()),
+				defaultString(ctx.channel().attr(LAST_RECEIVE_AT).get()),
+				getIdleCount(ctx),
+				event.state()
+		);
 	}
 
 	/**
@@ -293,44 +257,39 @@ public class NettyServerHandler extends ChannelInboundHandlerAdapter {
 	 */
 	@Override
 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
-		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());
-				// 删除连接
-				// PileChannelEntity.deleteChannel(pileSn, ctx);
-				ctx.channel().close();
-			}
-		} finally {
-			if (ctx.channel().isActive()) {
-				ctx.close();
-			}
-		}
+		ChannelId channelId = ctx.channel().id();
+		String pileSn = PileChannelEntity.getPileSnByChannelId(channelId.asLongText());
+		String disconnectReason = cause instanceof ReadTimeoutException ? DISCONNECT_REASON_READ_TIMEOUT : cause.getClass().getSimpleName();
+		ctx.channel().attr(DISCONNECT_REASON).set(disconnectReason);
+		log.error(
+				"云快充连接异常 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, idleCount:{}, lastSerialNumber:{}",
+				defaultString(pileSn),
+				channelId.asLongText(),
+				buildRemoteAddress(ctx),
+				disconnectReason,
+				defaultString(ctx.channel().attr(LAST_FRAME_TYPE).get()),
+				defaultString(ctx.channel().attr(LAST_RECEIVE_AT).get()),
+				getIdleCount(ctx),
+				defaultString(ctx.channel().attr(LAST_SERIAL_NUMBER).get()),
+				cause
+		);
+		ctx.close();
 	}
 
+	private int getIdleCount(ChannelHandlerContext ctx) {
+		Integer idleCount = ctx.channel().attr(IDLE_COUNT).get();
+		return idleCount == null ? 0 : idleCount;
+	}
 
-	// 公共方法 关闭连接
-	private void closeConnection(String pileSn, ChannelHandlerContext ctx) {
-		Channel channel = ctx.channel();
-		ChannelId channelId = channel.id();
-		log.error("close方法-发生异常，关闭链接，channelId:{}, pileSn:{}", channelId.asShortText(), pileSn);
-		if (channel != null && !channel.isActive() && !channel.isOpen() && !channel.isWritable()) {
-			channel.close();
-			// 删除连接
-			CHANNEL_MAP.remove(channelId);
-		}
-		// 删除桩编号和channel的关系
-		if (StringUtils.isNotBlank(pileSn)) {
-			PileChannelEntity.removeByPileSn(pileSn);
-		}
+	private String buildRemoteAddress(ChannelHandlerContext ctx) {
+		return ctx.channel().remoteAddress() == null ? "" : ctx.channel().remoteAddress().toString();
+	}
+
+	private String defaultString(String value) {
+		return value == null ? "" : value;
+	}
+
+	private String defaultString(String value, String defaultValue) {
+		return value == null ? defaultValue : value;
 	}
 }

jsowell-netty/src/main/java/com/jsowell/netty/service/yunkuaichong/impl/YKCBusinessServiceImpl.java

@@ -1,29 +1,43 @@
 package com.jsowell.netty.service.yunkuaichong.impl;
 
+import com.jsowell.common.constant.CacheConstants;
 import com.jsowell.common.core.domain.ykc.YKCDataProtocol;
 import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode;
+import com.jsowell.common.core.redis.RedisCache;
 import com.jsowell.common.enums.ykc.PileChannelEntity;
 import com.jsowell.common.enums.ykc.PileConnectorDataBaseStatusEnum;
+import com.jsowell.common.util.DateUtils;
 import com.jsowell.common.util.StringUtils;
 import com.jsowell.common.util.YKCUtils;
 import com.jsowell.netty.factory.YKCOperateFactory;
 import com.jsowell.netty.factory.YKCOperateFactoryV2;
 import com.jsowell.netty.handler.yunkuaichong.AbstractYkcHandler;
+import com.jsowell.netty.server.yunkuaichong.NettyServerHandler;
 import com.jsowell.netty.service.yunkuaichong.YKCBusinessService;
 import com.jsowell.netty.strategy.ykc.AbstractYkcStrategy;
 import com.jsowell.pile.dto.SavePileMsgDTO;
 import com.jsowell.pile.service.OrderBasicInfoService;
 import com.jsowell.pile.service.PileConnectorInfoService;
 import com.jsowell.pile.service.PileMsgRecordService;
+import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import javax.annotation.Resource;
+import java.util.Date;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
 @Slf4j
 @Service
 public class YKCBusinessServiceImpl implements YKCBusinessService {
 
+    private static final int OFFLINE_CONFIRM_SECONDS = 60;
+    private static final int OFFLINE_MARKER_TTL_SECONDS = 300;
+    private static final String OFFLINE_CONFIRMED_VALUE = "1";
+
     @Autowired
     private PileMsgRecordService pileMsgRecordService;
 
@@ -34,19 +48,21 @@ public class YKCBusinessServiceImpl implements YKCBusinessService {
     private OrderBasicInfoService orderBasicInfoService;
 
     @Autowired
-    private YKCOperateFactoryV2 ykcOperateFactoryV2; // 使用注解注入
+    private YKCOperateFactoryV2 ykcOperateFactoryV2;
+
+    @Autowired
+    private RedisCache redisCache;
+
+    @Resource(name = "scheduledExecutorService")
+    private ScheduledExecutorService scheduledExecutorService;
 
     @Override
     public byte[] process(byte[] msg, ChannelHandlerContext ctx) {
         if (!YKCUtils.checkMsg(msg)) {
-            // 校验不通过，丢弃消息
             return null;
         }
         YKCDataProtocol ykcDataProtocol = new YKCDataProtocol(msg);
-        // 获取帧类型
         String frameType = YKCUtils.frameType2Str(ykcDataProtocol.getFrameType());
-        // 获取业务处理handler
-        // AbstractYkcHandler invokeStrategy = YKCOperateFactory.getInvokeStrategy(frameType);
         AbstractYkcStrategy invokeStrategy = ykcOperateFactoryV2.getInvokeStrategy(frameType);
         return invokeStrategy.supplyProcess(ykcDataProtocol, ctx);
     }
@@ -54,53 +70,182 @@ public class YKCBusinessServiceImpl implements YKCBusinessService {
     @Override
     public byte[] process(YKCDataProtocol ykcDataProtocol, ChannelHandlerContext ctx) {
         if (!YKCUtils.checkMsg(ykcDataProtocol)) {
-            // 校验不通过，丢弃消息
             return null;
         }
-        // 获取帧类型
         String frameType = YKCUtils.frameType2Str(ykcDataProtocol.getFrameType());
-
-        // 获取业务处理handler
-        AbstractYkcHandler invokeStrategy = YKCOperateFactory.getInvokeStrategy(frameType); // 老逻辑
-        // AbstractYkcStrategy invokeStrategy = ykcOperateFactoryV2.getInvokeStrategy(frameType); // 新逻辑
+        AbstractYkcHandler invokeStrategy = YKCOperateFactory.getInvokeStrategy(frameType);
         return invokeStrategy.supplyProcess(ykcDataProtocol, ctx);
     }
 
     @Override
     public void exit(ChannelHandlerContext ctx) {
-        // 获取桩编号
-        String pileSn = PileChannelEntity.getPileSnByChannelId(ctx.channel().id().asLongText());
+        Channel channel = ctx.channel();
+        String channelId = channel.id().asLongText();
+        String pileSn = PileChannelEntity.getPileSnByChannelId(channelId);
         if (StringUtils.isBlank(pileSn)) {
             return;
         }
-        log.info("充电桩退出:{}, 类型:主动断开链接, channelId:{}", pileSn, PileChannelEntity.getChannelByPileSn(pileSn).channel().id());
 
-        // 充电桩断开连接，所有枪口都设置为【离线】
-        pileConnectorInfoService.updateConnectorStatusByPileSn(pileSn, PileConnectorDataBaseStatusEnum.OFF_NETWORK.getValue());
+        String disconnectReason = defaultString(channel.attr(NettyServerHandler.DISCONNECT_REASON).get(), "channel_inactive");
+        String lastFrameType = defaultString(channel.attr(NettyServerHandler.LAST_FRAME_TYPE).get(), "");
+        String lastReceiveAt = defaultString(channel.attr(NettyServerHandler.LAST_RECEIVE_AT).get(), "");
+        String lastSerialNumber = defaultString(channel.attr(NettyServerHandler.LAST_SERIAL_NUMBER).get(), "");
+        String remoteAddress = buildRemoteAddress(ctx);
+        String occurredAt = DateUtils.getDateTime();
+        String pendingKey = CacheConstants.PILE_PENDING_DISCONNECT + pileSn;
+        String pendingValue = buildPendingValue(channelId, disconnectReason, occurredAt);
 
-        // 将此桩正在进行充电的订单状态改为 异常
-        orderBasicInfoService.updateOrderStatusAsAbnormal(pileSn);
+        PileChannelEntity.removeByPileSnAndChannelId(pileSn, channelId);
+        redisCache.setCacheObject(pendingKey, pendingValue, OFFLINE_MARKER_TTL_SECONDS);
 
-        // 记录充电桩退出msg
-        // 保存报文
-        String type = YKCFrameTypeCode.PILE_LOG_OUT.getCode() + "";
-        String jsonMsg = YKCFrameTypeCode.PILE_LOG_OUT.getValue() + ": 充电桩主动断开链接";
-        // pileMsgRecordService.save(pileSn, pileSn, type, jsonMsg, "");
+        log.warn(
+                "云快充断链进入待确认 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, idleCount:{}, pendingOffline:{}, offlineConfirmed:{}",
+                pileSn,
+                channelId,
+                remoteAddress,
+                disconnectReason,
+                lastFrameType,
+                lastReceiveAt,
+                getIdleCount(ctx),
+                true,
+                false
+        );
+
+        savePileMsg(
+                pileSn,
+                YKCFrameTypeCode.PILE_LOG_OUT.getCode() + "",
+                YKCFrameTypeCode.PILE_LOG_OUT.getValue() + ": 连接断开待确认离线, reason=" + disconnectReason
+                        + ", channelId=" + channelId
+                        + ", lastFrameType=" + lastFrameType
+                        + ", lastReceiveAt=" + lastReceiveAt
+                        + ", lastSerialNumber=" + lastSerialNumber
+        );
+
+        scheduledExecutorService.schedule(
+                () -> confirmOffline(pileSn, channelId, disconnectReason, lastFrameType, lastReceiveAt, pendingValue, remoteAddress),
+                OFFLINE_CONFIRM_SECONDS,
+                TimeUnit.SECONDS
+        );
+    }
+
+    private void confirmOffline(String pileSn, String expectedChannelId, String disconnectReason, String lastFrameType,
+                                String lastReceiveAt, String expectedPendingValue, String remoteAddress) {
+        String pendingKey = CacheConstants.PILE_PENDING_DISCONNECT + pileSn;
+        String offlineConfirmedKey = CacheConstants.PILE_OFFLINE_CONFIRMED + pileSn;
+        try {
+            String pendingValue = redisCache.getCacheObject(pendingKey);
+            if (StringUtils.isBlank(pendingValue)) {
+                return;
+            }
+            if (!StringUtils.equals(expectedPendingValue, pendingValue)) {
+                return;
+            }
+
+            ChannelHandlerContext currentCtx = PileChannelEntity.getChannelByPileSn(pileSn);
+            if (currentCtx != null && currentCtx.channel() != null) {
+                String currentChannelId = currentCtx.channel().id().asLongText();
+                if (!StringUtils.equals(currentChannelId, expectedChannelId)) {
+                    redisCache.deleteObject(pendingKey);
+                    log.info(
+                            "云快充宽限期内连接恢复 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, pendingOffline:{}, offlineConfirmed:{}",
+                            pileSn,
+                            currentChannelId,
+                            buildRemoteAddress(currentCtx),
+                            disconnectReason,
+                            lastFrameType,
+                            lastReceiveAt,
+                            false,
+                            false
+                    );
+                    return;
+                }
+            }
+
+            String lastConnectionTime = redisCache.getCacheObject(CacheConstants.PILE_LAST_CONNECTION + pileSn);
+            if (isRecentCommunication(lastConnectionTime)) {
+                redisCache.deleteObject(pendingKey);
+                log.info(
+                        "云快充宽限期内通信恢复 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, pendingOffline:{}, offlineConfirmed:{}",
+                        pileSn,
+                        expectedChannelId,
+                        remoteAddress,
+                        disconnectReason,
+                        lastFrameType,
+                        lastReceiveAt,
+                        false,
+                        false
+                );
+                return;
+            }
+
+            pileConnectorInfoService.updateConnectorStatusByPileSn(pileSn, PileConnectorDataBaseStatusEnum.OFF_NETWORK.getValue());
+            orderBasicInfoService.updateOrderStatusAsAbnormal(pileSn);
+            redisCache.setCacheObject(offlineConfirmedKey, OFFLINE_CONFIRMED_VALUE, OFFLINE_MARKER_TTL_SECONDS);
+            redisCache.deleteObject(pendingKey);
+
+            savePileMsg(
+                    pileSn,
+                    YKCFrameTypeCode.PILE_LOG_OUT.getCode() + "",
+                    YKCFrameTypeCode.PILE_LOG_OUT.getValue() + ": 正式离线确认, reason=" + disconnectReason
+                            + ", channelId=" + expectedChannelId
+                            + ", lastFrameType=" + lastFrameType
+                            + ", lastReceiveAt=" + lastReceiveAt
+            );
+
+            log.error(
+                    "云快充正式离线确认 pileSn:{}, channelId:{}, remoteAddress:{}, disconnectReason:{}, lastFrameType:{}, lastReceiveAt:{}, pendingOffline:{}, offlineConfirmed:{}",
+                    pileSn,
+                    expectedChannelId,
+                    remoteAddress,
+                    disconnectReason,
+                    lastFrameType,
+                    lastReceiveAt,
+                    false,
+                    true
+            );
+        } catch (Exception e) {
+            log.error("云快充离线确认任务执行异常 pileSn:{}, channelId:{}", pileSn, expectedChannelId, e);
+        }
+    }
+
+    private boolean isRecentCommunication(String lastConnectionTime) {
+        if (StringUtils.isBlank(lastConnectionTime)) {
+            return false;
+        }
+        Date lastConnectionDate = DateUtils.parseDate(lastConnectionTime);
+        if (lastConnectionDate == null) {
+            return false;
+        }
+        long diffMillis = System.currentTimeMillis() - lastConnectionDate.getTime();
+        return diffMillis >= 0 && diffMillis < OFFLINE_CONFIRM_SECONDS * 1000L;
+    }
+
+    private void savePileMsg(String pileSn, String frameType, String jsonMsg) {
         SavePileMsgDTO dto = SavePileMsgDTO.builder()
                 .pileSn(pileSn)
                 .connectorCode("")
                 .transactionCode("")
-                .frameType(type)
+                .frameType(frameType)
                 .jsonMsg(jsonMsg)
                 .originalMsg(jsonMsg)
                 .build();
         pileMsgRecordService.save(dto);
-
-        // 删除连接
-        // PileChannelEntity.deleteChannel(pileSn, ctx);
-
-        // 删除桩编号和channel的关系
-        // PileChannelEntity.removeByPileSn(pileSn);
     }
 
+    private String buildPendingValue(String channelId, String reason, String occurredAt) {
+        return channelId + "|" + reason + "|" + occurredAt;
+    }
+
+    private int getIdleCount(ChannelHandlerContext ctx) {
+        Integer idleCount = ctx.channel().attr(NettyServerHandler.IDLE_COUNT).get();
+        return idleCount == null ? 0 : idleCount;
+    }
+
+    private String buildRemoteAddress(ChannelHandlerContext ctx) {
+        return ctx.channel().remoteAddress() == null ? "" : ctx.channel().remoteAddress().toString();
+    }
+
+    private String defaultString(String value, String defaultValue) {
+        return StringUtils.isBlank(value) ? defaultValue : value;
+    }
 }

jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java

@@ -905,6 +905,9 @@ public class PileConnectorInfoServiceImpl implements PileConnectorInfoService {
      */
     @Override
     public boolean checkPileOffLine(String pileSn) {
+        if (Boolean.TRUE.equals(redisCache.hasKey(CacheConstants.PILE_OFFLINE_CONFIRMED + pileSn))) {
+            return true;
+        }
         boolean flag = false;
         // 获取桩最后连接时间，最后连接到平台的时间在3分钟之前，判定为离线
         String lastConnectionTime = redisCache.getCacheObject(CacheConstants.PILE_LAST_CONNECTION + pileSn);

plan/2026-03-21_08-48-24-ykc-midnight-offline-fix-tracker.md

@@ -0,0 +1,345 @@
+---
+mode: plan
+cwd: /Users/guoqiusi/Workspace/jsowell-charger-web
+task: 云快充1.6协议凌晨离线问题修复与协议对齐
+complexity: high
+planning_method: builtin
+created_at: 2026-03-21T08:48:24+08:00
+---
+
+# Plan: 云快充1.6凌晨离线修复跟踪
+
+## 任务概述
+
+当前项目中，云快充 1.6 协议设备在凌晨时段存在离线现象。经代码与协议文档对照，未发现明确的“凌晨主动断链”定时任务，更可能是夜间网络/SIM 抖动触发了当前偏激进的离线判定逻辑，导致短时弱网被放大为设备离线。
+
+本计划用于跟踪以下三类工作：
+
+1. 先止血：降低“短时抖动即离线”的敏感度。
+2. 再纠偏：按协议修正登录、心跳、费率、对时流程。
+3. 最后收敛：统一实现入口，减少后续维护风险。
+
+## 关键结论
+
+- 协议要求：
+  - `0x03` 心跳为 10 秒周期上送，连续 3 次未收到才视为网络异常并重新登录。
+  - `0x13` 实时监测数据周期上送，待机 5 分钟、充电 15 秒。
+  - `0x05 -> 0x06 -> 0x09 -> 0x0A` 为费率模型校验与拉取闭环。
+  - `0x56` 对时为 1 天周期发送。
+- 当前实现中的高风险点：
+  - Netty 读空闲 30 秒即触发关闭连接。
+  - 断链后立即将枪口置离线，并将充电中订单改异常。
+  - 桩状态按“任意枪口离线即整桩离线”计算。
+  - `0x05` 校验请求当前固定返回“一致”，未真正校验费率模型。
+  - 登录后主动下发 `0x58`，与协议标准流程不完全一致。
+  - 对时仅在登录后发送一次，未发现每日自动对时任务。
+  - 线上实际走老 Handler 链路，新 Strategy 链路当前不生效。
+
+## 目标与验收口径
+
+### 业务目标
+
+- 凌晨 `00:00-06:00` 时段，短时网络抖动不再导致桩状态频繁离线。
+- 单次 `30-40s` 的弱网抖动不应直接把充电中订单改为异常。
+- 桩在线状态与真实链路状态更一致，减少前端“在线/离线闪断”。
+
+### 协议目标
+
+- `0x03` 按协议节奏与容错逻辑处理。
+- `0x05/0x06/0x09/0x0A` 恢复为真实校验与请求链路。
+- `0x56/0x55` 具备每日自动对时能力和执行记录。
+
+### 验收标准
+
+- 短时网络抖动：
+  - 30-40 秒无上行数据后恢复，不直接离线。
+  - 宽限期内重连成功，不产生订单异常。
+- 长时网络中断：
+  - 超出配置阈值后，设备进入离线状态。
+  - 若有正在充电订单，按规则进入异常处理。
+- 协议链路：
+  - 桩上报旧费率模型时，平台能正确返回不一致并等待 `0x09` 请求。
+  - 每日自动对时后，可看到 `0x55` 应答记录。
+- 排障能力：
+  - 日志能够还原“最后正常通信 -> 空闲超时 -> 关闭连接 -> 是否重连成功”的完整链路。
+
+## 执行批次
+
+### 第一批：先止血
+
+- 调整 Netty 空闲断链策略。
+- 引入断链宽限期，避免瞬断即离线。
+- 补连接生命周期日志。
+- 修复 channel 映射清理。
+
+### 第二批：协议纠偏
+
+- 修复费率模型校验与拉取闭环。
+- 新增每日自动对时。
+- 将关键阈值配置化。
+
+### 第三批：实现收敛
+
+- 收敛云快充双实现，只保留一条实际生效链路。
+- 补齐专项回归验证与联调记录。
+
+## 任务清单
+
+### YKC-001
+
+- 优先级：P0
+- 状态：todo
+- 目标：将云快充连接保活从“30 秒空闲直接断开”改为“允许短时抖动，按连续丢心跳或宽限期判定断链”。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerChannelInitializer.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerHandler.java`
+- 设计要点：
+  - `IdleStateHandler` 读空闲阈值调整为 `40-45s` 或等效容错值。
+  - `userEventTriggered` 不再第一次超时就 `close()`。
+  - 结合最近通信时间和连续空闲次数处理。
+- 验收标准：
+  - 单次 `30-40s` 无上行数据不直接断链。
+  - 凌晨弱网时连接不会频繁抖动为离线。
+- 风险：
+  - 阈值过宽会延迟真实离线发现，需要与业务确认容忍度。
+
+### YKC-002
+
+- 优先级：P0
+- 状态：todo
+- 目标：增加“断链宽限期”，避免瞬断立刻将枪口置离线、订单置异常。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/service/yunkuaichong/impl/YKCBusinessServiceImpl.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java`
+- 设计要点：
+  - `exit()` 中先记录“断链待确认”状态。
+  - 宽限期结束且未恢复登录时，才正式落离线和订单异常。
+  - 若宽限期内重连，取消离线确认。
+- 验收标准：
+  - 短时断链后在宽限期内重连，不产生订单异常。
+  - 真正长断链后仍能正确离线。
+- 风险：
+  - 需防止宽限期任务重复执行或状态竞争。
+
+### YKC-003
+
+- 优先级：P0
+- 状态：todo
+- 目标：补齐连接生命周期日志，支持“凌晨离线”专项排查。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerHandler.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/HeartbeatRequestHandler.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/LoginRequestHandler.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/UploadRealTimeMonitorHandler.java`
+- 设计要点：
+  - 统一打印 `pileSn`、`channelId`、远端 IP、最后一帧类型、最后上报时间、IdleState 类型、重连耗时。
+  - 对凌晨时段日志加清晰关键词，便于筛查。
+- 验收标准：
+  - 一次离线事件能从日志完整还原链路。
+- 风险：
+  - 需控制日志量，避免高频心跳刷爆日志。
+
+### YKC-004
+
+- 优先级：P0
+- 状态：todo
+- 目标：修复 channel 映射清理不完整的问题，避免旧连接残留。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/service/yunkuaichong/impl/YKCBusinessServiceImpl.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-common/src/main/java/com/jsowell/common/enums/ykc/PileChannelEntity.java`
+- 设计要点：
+  - 恢复 `removeByPileSn/removeByChannelId` 的正常调用。
+  - 确保断链、异常、重连时旧 `channel` 被清理。
+- 验收标准：
+  - 同一桩重连后只保留一个有效 `channel`。
+  - 下行命令不会打到死连接。
+- 风险：
+  - 需避免误删新连接。
+
+### YKC-005
+
+- 优先级：P1
+- 状态：todo
+- 目标：将桩离线判定从“任意枪状态为离线即整桩离线”改为“最近通信时间 + 枪状态 + 宽限期”的综合判定。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java`
+- 设计要点：
+  - `getPileStatus/getPileStatusV2/checkPileOffLine` 使用统一判定逻辑。
+  - 将固定 3 分钟阈值改为可配置。
+- 验收标准：
+  - 前端在线状态与真实通信状态一致。
+  - 短时抖动不出现整桩离线闪断。
+- 风险：
+  - 旧缓存与新判定逻辑可能短期不一致，需要同步清理策略。
+
+### YKC-006
+
+- 优先级：P1
+- 状态：todo
+- 目标：按协议修正费率模型交互，去掉“固定返回一致”的实现。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BillingTemplateValidateRequestHandler.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BillingTemplateRequestHandler.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/LoginRequestHandler.java`
+- 设计要点：
+  - `0x05` 真比较平台模型号与桩上报模型号。
+  - 不一致返回 `0x01`。
+  - 由桩继续发 `0x09`，平台回 `0x0A`。
+  - 登录后主动 `0x58` 改为开关控制或移除。
+- 验收标准：
+  - 费率模型链路符合协议。
+  - 跨天费率切换时行为可解释、可追踪。
+- 风险：
+  - 需确认现网桩程序是否依赖“登录后强推模板”的兼容行为。
+
+### YKC-007
+
+- 优先级：P1
+- 状态：todo
+- 目标：补每日自动对时，降低跨天时钟漂移的影响。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/YKCPushCommandServiceImpl.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/TimeCheckSettingResponseHandler.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java`
+- 设计要点：
+  - 每日定时给在线桩批量发 `0x56`。
+  - 记录 `0x55` 应答结果与桩回传时间。
+- 验收标准：
+  - 每日有自动对时执行记录。
+  - 对时失败可重试，可观测。
+- 风险：
+  - 大批量对时可能集中打到凌晨，需控制任务节奏。
+
+### YKC-008
+
+- 优先级：P1
+- 状态：todo
+- 目标：将关键超时和离线参数配置化，避免硬编码。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerChannelInitializer.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-admin/src/main/resources/application.yml`
+- 设计要点：
+  - 至少抽出：
+    - `readerIdleSeconds`
+    - `offlineConfirmSeconds`
+    - `lastConnectionOfflineMinutes`
+    - `dailyTimeSyncCron`
+- 验收标准：
+  - 不改代码即可在环境配置中调整离线策略。
+- 风险：
+  - 需注意各环境默认值兼容。
+
+### YKC-009
+
+- 优先级：P2
+- 状态：todo
+- 目标：收敛云快充双实现，避免后续修错入口。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/service/yunkuaichong/impl/YKCBusinessServiceImpl.java`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong`
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/strategy/ykc`
+- 设计要点：
+  - 确认唯一线上入口。
+  - 如果保留老 Handler，则冻结或移除 Strategy。
+  - 如果迁移到 Strategy，则需一次性迁完。
+- 验收标准：
+  - 线上只存在一套实际生效的云快充处理链路。
+- 风险：
+  - 涉及面较大，需单独回归。
+
+### YKC-010
+
+- 优先级：P1
+- 状态：todo
+- 目标：补专项回归验证和凌晨专项验证脚本或测试用例。
+- 修改文件：
+  - `/Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-admin/src/test/java`
+- 设计要点：
+  - 覆盖场景：
+    - `30-40s` 无心跳但恢复。
+    - 宽限期内重连。
+    - 费率模型不一致重新请求。
+    - 每日对时成功和失败。
+- 验收标准：
+  - 每个修复点至少有一条可复现、可回归的验证路径。
+- 风险：
+  - 若缺真实协议模拟器，需先补测试桩或伪报文能力。
+
+## 推荐执行顺序
+
+1. YKC-001
+2. YKC-002
+3. YKC-003
+4. YKC-004
+5. YKC-005
+6. YKC-008
+7. YKC-006
+8. YKC-007
+9. YKC-010
+10. YKC-009
+
+## 文件级改造备注
+
+### 连接与断链主链路
+
+- `NettyServerChannelInitializer`
+  - 负责 IdleState 参数配置。
+- `NettyServerHandler`
+  - 负责空闲事件、异常事件、连接关闭事件的断链控制。
+- `YKCBusinessServiceImpl`
+  - 负责断链后离线和订单状态变更逻辑。
+
+### 在线状态与业务影响主链路
+
+- `PileChannelEntity`
+  - 管理桩与 channel 的映射。
+- `PileConnectorInfoServiceImpl`
+  - 管理枪口状态、桩状态聚合与前端在线判断。
+- `OrderBasicInfoServiceImpl`
+  - 管理充电订单异常状态的最终落库。
+
+### 协议对齐主链路
+
+- `LoginRequestHandler`
+  - 登录后当前有对时和费率主动推送逻辑。
+- `HeartbeatRequestHandler`
+  - 心跳包处理与最后通信时间刷新。
+- `BillingTemplateValidateRequestHandler`
+  - 当前实现与协议偏差最大。
+- `BillingTemplateRequestHandler`
+  - 负责 `0x09 -> 0x0A`。
+- `TimeCheckSettingResponseHandler`
+  - 用于记录 `0x55` 对时应答。
+
+## 风险清单
+
+- 现网桩程序可能已适配当前“非标准但可用”的平台行为，协议纠偏前需确认兼容性。
+- 离线判定放宽后，真实离线的发现速度会变慢，需要平衡运维体验。
+- 订单异常处理若改为延迟确认，需防止漏处理真正断电或断网导致的异常订单。
+- 双实现收敛前，所有改动应明确打在老 Handler 链路上，避免误改新 Strategy 无法生效。
+
+## 进度记录模板
+
+```md
+### 进度记录
+
+- 任务ID: YKC-001
+- 优先级: P0
+- 状态: todo
+- 负责人:
+- 开始时间:
+- 完成时间:
+- 目标: 调整 Netty 空闲断链策略，避免 30 秒无上行直接断链
+- 修改文件:
+  - /Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerChannelInitializer.java
+  - /Users/guoqiusi/Workspace/jsowell-charger-web/jsowell-netty/src/main/java/com/jsowell/netty/server/yunkuaichong/NettyServerHandler.java
+- 验收结果:
+- 备注/风险:
+```
+
+## 当前建议
+
+- 先以第一批任务为本周主线，尽快止住凌晨离线误判。
+- 第二批在止血完成后推进，避免协议纠偏与连接策略变更叠加，增加联调复杂度。
+- 第三批收敛放在前两批稳定后执行。