提交粮情协议1

jiazx0107@163.com

2023-12-02 5bb3ad3944ff229baff1d8bb92caf55d816ee68b

提交粮情协议1

 src/main/java/com/fzzy/api/Constant.java

@@ -1,9 +1,15 @@
package com.fzzy.api;

import com.fzzy.api.data.ApiCommonDevice;

import java.util.HashMap;
import java.util.Map;

/**
 * å…¨å±€é™æ€ç±»
 */
public class Constant {


    public static final String DEFAULT_CODE = "0";
    public static final String YN_N = "N";
@@ -307,4 +313,52 @@
     */
    public static final String DEFAULT_USER_PASSWORD = "123456";


    /**
     * å†…存数据缓存，用于存储出入库相关的临时信息，如刷卡设备当前最新数据等。
     */
    public static Map<String, ApiCommonDevice> contextDeviceMap = new HashMap<>();

    public static ApiCommonDevice getCommonDeviceCache(String sn) {
        if (null == sn) return null;
        return contextDeviceMap.get(sn);
    }

    public static void updateCacheOnline(String sn, String ip, Integer port, boolean isCreate) {
        ApiCommonDevice device = getCommonDeviceCache(sn);
        if (null == device && isCreate) {
            device = new ApiCommonDevice();
        }
        if (null != device) {
            device.setIp(ip);
            device.setPort(port);
            device.setStatus(Constant.YN_Y);
            device.setCode("SUCCESS");
            device.setMsg("设备在线");
            device.setSn(ip);
            contextDeviceMap.put(device.getSn(), device);
        }
    }

    public static void updateCacheOffline(String sn, String ip, Integer port, boolean isCreate) {
        ApiCommonDevice device = getCommonDeviceCache(sn);

        if (null == device && isCreate) {
            device = new ApiCommonDevice();
        }

        if (null != device) {
            device.setIp(ip);
            device.setPort(port);
            device.setStatus(Constant.YN_N);
            device.setCode("ERROR");
            device.setMsg("设备离线");

            contextDeviceMap.put(device.getSn(), device);
        }
    }

    public static void updateCache(ApiCommonDevice device) {
        contextDeviceMap.put(device.getSn(), device);
    }
}

 src/main/java/com/fzzy/api/data/ApiCommonDevice.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,30 @@
package com.fzzy.api.data;

import com.fzzy.api.Constant;
import lombok.Data;

/**
 * è™šæ‹Ÿé€šç”¨è®¾å¤‡ï¼Œä¸»è¦ç”¨äºŽé€šè®¯è¿‡ç¨‹ä¸­çš„设备信息，不持久化到数据库，在内存中保存和更新状态
 */
@Data
public class ApiCommonDevice {


    private String id;

    private String sn;

    private String ip;

    private Integer port;

    //状态是否在线
    private String status = Constant.YN_Y;

    private String code = "SUCCESS";

    private String msg = "成功";

    private String result;//结果信息，以字符串代替

}

 src/main/java/com/fzzy/api/data/GatewayDeviceProtocol.java

@@ -11,7 +11,7 @@
 */
public enum GatewayDeviceProtocol {

    GRAIN_FZZY_ZH_2023("GRAIN_FZZY_ZH_2023", "粮情-风正致远控制柜协议2023"),
    TCP_FZZY_V3("TCP_FZZY_V3", "粮情-风正致远控制柜协议V3"),
    GRAIN_FZZY_IGDS_V40("GRAIN_FZZY_IGDS_V40", "粮情-风正致远系统V40"),
    DEVICE_WEIGHT_HTTP("DEVICE_WEIGHT_HTTP", "地磅-HTTP协议"),
    DEVICE_WEIGHT_TCP_YH("DEVICE_WEIGHT_TCP_YH", "地磅-耀华TCP协议"),
@@ -26,7 +26,7 @@

    public static List<ApiTrigger> listTrigger() {
        List<ApiTrigger> list = new ArrayList<>();
        list.add(new ApiTrigger(GRAIN_FZZY_ZH_2023.getCode(), GRAIN_FZZY_ZH_2023.getName()));
        list.add(new ApiTrigger(TCP_FZZY_V3.getCode(), TCP_FZZY_V3.getName()));
        list.add(new ApiTrigger(GRAIN_FZZY_IGDS_V40.getCode(), GRAIN_FZZY_IGDS_V40.getName()));
        list.add(new ApiTrigger(DEVICE_WEIGHT_HTTP.getCode(), DEVICE_WEIGHT_HTTP.getName()));
        list.add(new ApiTrigger(DEVICE_WEIGHT_TCP_YH.getCode(), DEVICE_WEIGHT_TCP_YH.getName()));

 src/main/java/com/fzzy/api/utils/ContextUtil.java

@@ -4,14 +4,18 @@
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;

import java.util.Calendar;
import java.util.Date;
import java.util.UUID;
import java.util.*;

/**
 *
 */
public class ContextUtil {


    /**
     * å…¨å±€å‘½ä»¤ID
     */
    public static Map<String, Integer> contextOrderId = new HashMap<>();


    public static String getUUID() {
@@ -147,4 +151,42 @@
    public static String getServerKey(String ip, Integer port) {
        return ip + ":" + port;
    }


    /**
     * æ ¹æ®å‚数生成 æ‰§è¡Œå‘½ä»¤çš„缓存KEY
     *
     * @param companyId
     * @param serId
     * @param bizType
     * @return
     */
    public static final String buildExeOrderId(String companyId, String serId, String bizType) {
        Integer start = contextOrderId.get("ORDER_ID") == null ? 5000 : contextOrderId.get("ORDER_ID");

        contextOrderId.put("ORDER_ID", start + 1);

        return start + "";
    }

    /**
     * è®¾å¤‡ID生成规则
     *
     * @param companyId
     * @param depotId
     * @param passCode
     * @return
     */
    public static final String buildDeviceId(String companyId, String depotId, int passCode) {
        return companyId + "_" + depotId + "_" + passCode;
    }

    public static String buildDeviceStatusKey(String companyId, String serId, String passCode) {
        if (null == passCode) passCode = "NULL";
        return companyId + "_" + serId + "_STATUS_" + passCode;
    }

    public static String buildDeviceStatusKey(String companyId, String serId, int passCode) {
        return companyId + "_" + serId + "_STATUS_" + passCode;
    }
}

 src/main/java/com/fzzy/gateway/GatewayTimerScheduled.java

@@ -33,7 +33,7 @@
@Component(GatewayTimerScheduled.BEAN_ID)
public class GatewayTimerScheduled {

    public static String DEFAULT_URL = "https://v0.yiketianqi.com/api?unescape=1&version=v61&appid={appId}&appsecret={appsecret}&cityid={cityid}";
        public static String DEFAULT_URL = "https://v1.yiketianqi.com/api?unescape=1&version=v61&appid={appId}&appsecret={appsecret}&cityid={cityid}";
    public static String DEFAULT_APP_ID = "49421971";
    public static String DEFAULT_APP_SECRET = "JmJE48Fv";
    public static String DEFAULT_CITYID = "101270101";//成都

 src/main/java/com/fzzy/gateway/GatewayUtils.java

@@ -1,7 +1,10 @@
package com.fzzy.gateway;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.api.data.GatewayDeviceType;
import com.fzzy.gateway.entity.GatewayDevice;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.util.*;
@@ -11,13 +14,6 @@
 */
@Component
public class GatewayUtils {


    /**
     * è®¾å¤‡åœ¨çº¿æ ‡è®°ï¼Œé’ˆå¯¹WEBSocket请求，控制设备是否在线，key = deviceId，Value=Y/N
     */
    public static Map<String, String> contextOnlineMap = new HashMap<>();


    /**
     * è®¾å¤‡ç¼“å­˜
@@ -74,17 +70,16 @@
        cacheMapDeviceSn.remove(data.getDeviceSn());
    }

    public static void updateOnline(String deviceId) {
        contextOnlineMap.put(deviceId, "Y");
    public static String getStatus(String sn) {
        ApiCommonDevice device = Constant.getCommonDeviceCache(sn);
        if (null == device) return Constant.YN_N;
        return device.getStatus();
    }

    public static void updateOffOnline(String deviceId) {
        contextOnlineMap.put(deviceId, "N");
    }

    public static boolean isOnline(String deviceId) {
        String value = contextOnlineMap.get(deviceId);
        if (null == value || "N".equals(value)) return false;
        GatewayDevice device = getCacheByDeviceId(deviceId);
        if (null == device.getStatus() || Constant.YN_N.equals(device.getStatus())) return false;
        return true;
    }


 src/main/java/com/fzzy/gateway/controller/GatewayDeviceController.java

@@ -1,5 +1,6 @@
package com.fzzy.gateway.controller;

import com.fzzy.api.data.GatewayDeviceProtocol;
import com.fzzy.api.data.GatewayDeviceType;
import com.fzzy.gateway.GatewayUtils;
import com.fzzy.gateway.api.GatewayRemoteManager;
@@ -125,7 +126,14 @@
            return "ERROR：当前设备没有配置布线规则，无法执行";
        }

        BaseResp resp = gatewayRemoteManager.getGatewayTestService(device.getPushProtocol()).testGrain(reqData);
        BaseResp resp =null;
        if(GatewayDeviceProtocol.DEVICE_TEST.getCode().equals(device.getSyncProtocol())){
            resp = gatewayRemoteManager.getGatewayTestService(device.getPushProtocol()).testGrain(reqData);
        }else{
            reqData.setAutoReplay(false);
            resp = gatewayRemoteManager.getSyncGrainService(device.getSyncProtocol()).syncGrain(reqData);
        }

        //自动推送
        if (BaseResp.CODE_200 == resp.getCode() && reqData.isAutoReplay()) {
            reqData.setData(resp.getData());

 src/main/java/com/fzzy/gateway/entity/GatewayDevice.java

@@ -2,11 +2,13 @@

import com.bstek.dorado.annotation.PropertyDef;

import com.fzzy.api.Constant;
import lombok.Data;

import javax.persistence.*;

import java.io.Serializable;
import java.util.Date;

/**
 * ç½‘关相关的设备管理
@@ -117,4 +119,12 @@
    @PropertyDef(label = "筒仓层规则", description = "针对筒仓")
    private String cableCir;

    @Transient
    @PropertyDef(label = "设备在线状态")
    private String status = Constant.YN_N;

    @Transient
    @PropertyDef(label = "设备上线时间")
    private Date onlineTime;

}

 src/main/java/com/fzzy/io/package-info.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1 @@
package com.fzzy.io;

 src/main/java/com/fzzy/io/request/BaseRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,50 @@
package com.fzzy.io.request;

import com.fzzy.api.utils.ContextUtil;
import lombok.Data;

import java.util.Date;

/**
 *
 */
@Data
public class BaseRequest {

    private String orderId;//自定义命令ID

    private String deptId;

    private String companyId;//组织编码

    private String depotId;//仓库编号

    private String serId = "0";//分机编号

    private String ip; //分机IP

    private Integer port;//分机端口号

    private String bizType;//业务类型

    private String serName;

    private String depotName;

    private String protocol;

    private Date exeTime = new Date();//执行时间


    public BaseRequest() {
        super();
        this.orderId = ContextUtil.buildExeOrderId(null, null, null);
    }

    public BaseRequest(String companyId, String serId, String bizType) {
        this.orderId = ContextUtil.buildExeOrderId(companyId, serId, bizType);
        this.companyId = companyId;
        this.serId = serId;
        this.bizType = bizType;
    }
}

 src/main/java/com/fzzy/protocol/ProtocolRunner.java

@@ -1,5 +1,6 @@
package com.fzzy.protocol;

import com.fzzy.protocol.fzzy.server.FzzyServerEngine;
import com.fzzy.protocol.weightyh.YhScaleServerEngine;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
@@ -16,9 +17,14 @@
    @Override
    public void run(String... args) throws Exception {


        //耀华地磅TCP协议
        YhScaleServerEngine.start();


        //风正致远控制柜协议启动
        FzzyServerEngine.start(null);

    }

}

 src/main/java/com/fzzy/protocol/fzzy/analysis/AnalysisGrain.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,74 @@
package com.fzzy.protocol.fzzy.analysis;

import com.alibaba.fastjson.JSONObject;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.gateway.data.BaseReqData;
import com.fzzy.protocol.fzzy.builder.SimpleCommandBuilder;
import com.fzzy.protocol.fzzy.cmd.BaseRemoteImpl;
import com.fzzy.protocol.fzzy.data.ReMessage;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.resp.Response2102;
import com.fzzy.protocol.fzzy.server.ServerUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * ç²®æƒ…解析
 *
 * @author Andy
 */
@Slf4j
@Component(AnalysisGrain.BEAN_ID)
public class AnalysisGrain extends BaseRemoteImpl {

    public static final String BEAN_ID = "fzzy.analysisGrain";


    public static int ERROR_CHECK_TAG = -1000;//粮温，气体，虫害，故障值

    public static int ERROR_CHECK_TAG2 = -2000;//传感器故障或者不在线


    public void analysis2101(ReMessage reMessage, ApiCommonDevice ser) {
        //DO NOTHING
    }

    /**
     * ç²®æƒ…返回信息解析
     *
     * @param reMessage
     * @param ser
     */
    public void analysis2102(ReMessage reMessage, ApiCommonDevice ser) {

        try {

            //返回控制柜信息
            returnMsg(ser);

            Response2102 response = JSONObject.parseObject(reMessage.getContent(), Response2102.class);

            String depotId = response.getHouseId();

            //获取请求信息
            BaseReqData reqData = ServerUtils.getSyncReq(depotId);


            //粮情解析
            log.info("控制柜--->平台粮情信息--{}", response);


        } catch (Exception e) {

            log.error("控制柜--->平台粮情信息异常-{}", e);

        }
    }

    private void returnMsg(ApiCommonDevice ser) {
        //先回复控制柜
        SimpleCommandBuilder commandBuilder = SimpleCommandBuilder.getInstance();
        SendMessage message = commandBuilder.buildMessage(ser, ServerUtils.FUNCTION_2102);
        send(message);
    }
}

 src/main/java/com/fzzy/protocol/fzzy/analysis/AnalysisService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,193 @@
package com.fzzy.protocol.fzzy.analysis;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.protocol.fzzy.data.ReMessage;
import com.fzzy.protocol.fzzy.server.ServerUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;


/**
 * åè®®è§£æžæ€»å…¥å£
 */
@Slf4j
@Component(AnalysisService.BEAN_ID)
public class AnalysisService {

    public static final String BEAN_ID = "fzzy.analysisService";

    @Resource
    private AnalysisSystem analysisSystem;
    @Resource
    private AnalysisGrain analysisGrain;

    /**
     * åè®®è§£æžå…¥å£
     *
     * @param message è¿”回信息
     */
    public void analysis(ReMessage message) {
        try {
            if (null == message) return;

            //登录解析
            if (ServerUtils.FUNCTION_1001.equals(message.getFunctionId())) {
                analysisSystem.analysis1001(message);
                return;
            }

            String checkMsg = checkMsg(message);
            if (null != checkMsg) {
                log.error("控制柜------>>>平台：当前组织编码={}，分机ID={}，报文信息-={}，响应吗返回不正确，无法进行解析," + checkMsg, message.getCompanyId(), message.getIedId(), message.getStrMsg());
                return;
            }


            //执行的分机信息
            ApiCommonDevice commonDevice = Constant.getCommonDeviceCache(message.getSn());
            if (null == commonDevice) {
                log.warn("控制柜------>>>平台：当前组织编码={}，分机ID={}，系统没有获取到分机信息，报文无法进行解析", message.getCompanyId(), message.getIedId());
                return;
            }


            //根据接口编号进行解析路由
            switch (message.getFunctionId()) {
                case ServerUtils.FUNCTION_1003:
                    analysisSystem.analysis1003(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1004:
                    analysisSystem.analysis1004(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1005:
                    analysisSystem.analysis1005(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1006:
                    analysisSystem.analysis1006(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1007:
                    analysisSystem.analysis1007(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1008:
                    analysisSystem.analysis1008(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1009:
                    analysisSystem.analysis1009(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_1010:
                    analysisSystem.analysis1010(message, commonDevice);
                    break;

                case ServerUtils.FUNCTION_2101:
                    analysisGrain.analysis2101(message, commonDevice);
                    break;
                case ServerUtils.FUNCTION_2102:
                    analysisGrain.analysis2102(message, commonDevice);
                    break;

//                case ServerUtils.FUNCTION_2201:
//                    analysisPest.analysis2201(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_2202:
//                    analysisPest.analysis2202(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_2203:
//                    analysisPest.analysis2203(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_2204:
//                    analysisPest.analysis2204(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_2301:
//                    analysisGas.analysis2301(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_2302:
//                    analysisGas.analysis2302(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_2303:
//                    analysisGas.analysis2303(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_2304:
//                    analysisGas.analysis2304(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_3101:
//                    analysisDevice.analysis3101(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_3102:
//                    analysisDevice.analysis3102(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_3103:
//                    analysisDevice.analysis3103(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_3201:
//                    analysisDevice.analysis3201(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_3301:
//                    analysisN2.analysis3301(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_3302:
//                    analysisN2.analysis3302(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_3303:
//                    analysisN2.analysis3303(message, ser);
//                    break;
//                case ServerUtils.FUNCTION_3304:
//                    analysisN2.analysis3304(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_4001:
//                    analysisEs.analysis4001(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_5001:
//                    analysisTemp.analysis5001(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_5002:
//                    analysisTemp.analysis5002(message, ser);
//                    break;
//
//                case ServerUtils.FUNCTION_6001:
//                    analysisIot.analysis6001(message, ser);
//                    break;

                default:
                    break;
            }
        } catch (Exception e) {
            log.error("控制柜----->>>>平台：解析返回报文出现异常：" + e);
            e.printStackTrace();
        }
    }

    public String checkMsg(ReMessage message) {
        if (StringUtils.isEmpty(message.getRespCode())) return null;

        if (ServerUtils.RESP_0000.equals(message.getRespCode())) return null;

        if (ServerUtils.RESP_1000.equals(message.getRespCode())) return "控制柜编号错误";
        if (ServerUtils.RESP_1001.equals(message.getRespCode())) return "终端设备不在线";
        if (ServerUtils.RESP_1010.equals(message.getRespCode())) return "控制柜授权到期";
        if (ServerUtils.RESP_1011.equals(message.getRespCode())) return "授权码无效";
        if (ServerUtils.RESP_1012.equals(message.getRespCode())) return "授权码已被使用";
        if (ServerUtils.RESP_1013.equals(message.getRespCode())) return "授权码已过期";
        if (ServerUtils.RESP_2000.equals(message.getRespCode())) return "签名验证失败";
        if (ServerUtils.RESP_3000.equals(message.getRespCode())) return "通风模式不支持";
        if (ServerUtils.RESP_4000.equals(message.getRespCode())) return "气调模式不支持";
        if (ServerUtils.RESP_5000.equals(message.getRespCode())) return "控制柜当前为手动模式，拒绝远程操作";
        if (ServerUtils.RESP_6000.equals(message.getRespCode())) return "采集执行失败";
        if (ServerUtils.RESP_6001.equals(message.getRespCode())) return "粮情采集执行中";
        if (ServerUtils.RESP_6002.equals(message.getRespCode())) return "气体采集执行中";
        if (ServerUtils.RESP_6003.equals(message.getRespCode())) return "虫害采集执行中";
        if (ServerUtils.RESP_9999.equals(message.getRespCode())) return "未知错误";
        return null;
    }
}

 src/main/java/com/fzzy/protocol/fzzy/analysis/AnalysisSystem.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,89 @@
package com.fzzy.protocol.fzzy.analysis;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.gateway.GatewayUtils;
import com.fzzy.gateway.entity.GatewayDevice;
import com.fzzy.protocol.fzzy.builder.ObjectCommandBuilder;
import com.fzzy.protocol.fzzy.builder.SimpleCommandBuilder;
import com.fzzy.protocol.fzzy.cmd.BaseRemoteImpl;
import com.fzzy.protocol.fzzy.data.ReMessage;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.resp.Response1001;
import com.fzzy.protocol.fzzy.server.ServerUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * ç³»ç»Ÿç±»åè®®è§£æž
 */
@Slf4j
@Component(AnalysisSystem.BEAN_ID)
public class AnalysisSystem extends BaseRemoteImpl {

    public static final String BEAN_ID = "fzzy.analysisSystem";


    public void analysis1001(ReMessage reMessage) {

        //获取到登陆信息，执行设备信息整理
        ApiCommonDevice device = Constant.getCommonDeviceCache(reMessage.getSn());
        if (null == device) {
            device = new ApiCommonDevice();
        }
        device.setIp(reMessage.getIp());
        device.setPort(reMessage.getPort());
        device.setSn(reMessage.getSn());
        device.setId(reMessage.getIedId());
        Constant.updateCache(device);


        //返回当前系统时间
        Response1001 response = new Response1001();
        response.setTime(DateFormatUtils.format(new Date(), "yyyyMMddHHmmss"));

        ObjectCommandBuilder commandBuilder = ObjectCommandBuilder.getInstance();
        SendMessage message = commandBuilder.buildMessage(reMessage, ServerUtils.FUNCTION_1001, response);
        send(message);

        log.info("控制柜----->>>平台：控制柜上线登陆成功-IP={},PORT={}", reMessage.getIp(), reMessage.getPort());
    }

    public void analysis1003(ReMessage reMessage, ApiCommonDevice ser) {
    }

    public void analysis1004(ReMessage reMessage, ApiCommonDevice ser) {
    }

    public void analysis1005(ReMessage reMessage, ApiCommonDevice ser) {
        //直接返回
        SimpleCommandBuilder commandBuilder = SimpleCommandBuilder.getInstance();
        SendMessage message = commandBuilder.buildMessage(ser, ServerUtils.FUNCTION_1005);
        send(message);
    }

    public void analysis1006(ReMessage reMessage, ApiCommonDevice ser) {

        //TODO
    }

    public void analysis1007(ReMessage reMessage, ApiCommonDevice ser) {

        log.info("控制柜----->>>平台：控制柜仓库状态信息同步完成-控制柜={}", ser.getIp());
    }

    public void analysis1008(ReMessage message, ApiCommonDevice ser) {

    }

    public void analysis1009(ReMessage message, ApiCommonDevice ser) {

    }

    public void analysis1010(ReMessage reMessage, ApiCommonDevice ser) {
        log.info("控制柜----->>>平台：控制柜仓库配置信息同步完成-控制柜={}", ser.getIp());
    }
}

 src/main/java/com/fzzy/protocol/fzzy/builder/CommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,67 @@
package com.fzzy.protocol.fzzy.builder;

import com.alibaba.fastjson.JSONObject;
import com.fzzy.io.request.BaseRequest;
import com.fzzy.protocol.fzzy.data.MessageInfo;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.server.ServerUtils;


/**
 * å‘½ä»¤ç”Ÿæˆ
 *
 * @author Andy
 */
public abstract class CommandBuilder {

    public SendMessage buildMessage(BaseRequest request) {
        SendMessage message = new SendMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());

        message.setBegin(ServerUtils.MSG_BEGIN);

        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request);


        message.setEnd(ServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(SendMessage message, BaseRequest request) {
        MessageInfo info = new MessageInfo();
        info.setSign(request.getCompanyId());
        info.setIedId(request.getSerId());
        info.setFunctionId(ServerUtils.FUNCTION_1001);
        info.setRespCode("0000");
        info.setOrderId(request.getOrderId());
        info.setUserData("0");
        info.setSign("0000");
        info.setContent(null);
        message.setInfo(info);
    }

    /**
     * æ ¹æ®ç”Ÿæˆçš„命令，进行调整
     *
     * @param message
     */
    public void build(SendMessage message) {
        StringBuffer hexSb = new StringBuffer();
        hexSb.append(message.getBegin());

        message.setStrMsg(JSONObject.toJSONString(message.getInfo()));

        hexSb.append(message.getStrMsg());

        hexSb.append(message.getEnd());

        message.setByteMsg(hexSb.toString().getBytes());
    }

}

 src/main/java/com/fzzy/protocol/fzzy/builder/GrainCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,58 @@
package com.fzzy.protocol.fzzy.builder;


import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.gateway.entity.GatewayDevice;
import com.fzzy.protocol.fzzy.data.MessageInfo;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.req.Request2101;
import com.fzzy.protocol.fzzy.server.ServerUtils;

public class GrainCommandBuilder extends CommandBuilder {

    private final static GrainCommandBuilder instance = new GrainCommandBuilder();

    private GrainCommandBuilder() {
    }

    public static GrainCommandBuilder getInstance() {
        return instance;
    }


    public SendMessage buildMessage(GatewayDevice device, ApiCommonDevice apiCommonDevice) {
        SendMessage message = new SendMessage();
        message.setIp(apiCommonDevice.getIp());
        message.setPort(apiCommonDevice.getPort());

        message.setBegin(ServerUtils.MSG_BEGIN);

        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, device,apiCommonDevice);

        message.setEnd(ServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(SendMessage message, GatewayDevice device,ApiCommonDevice apiCommonDevice) {
        MessageInfo info = new MessageInfo();
        info.setSign("0000");
        info.setIedId(apiCommonDevice.getId());
        info.setFunctionId(ServerUtils.FUNCTION_2101);
        info.setRespCode("0000");
        info.setOrderId(ServerUtils.getOrderByDepotId(device.getDepotId()));
        info.setUserData("0");
        info.setSign("0000");

        Request2101 request2101 = new Request2101();
        request2101.setHouseId(device.getDepotIdSys());
        info.setContent(request2101);

        message.setInfo(info);
    }

}

 src/main/java/com/fzzy/protocol/fzzy/builder/ObjectCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,75 @@
package com.fzzy.protocol.fzzy.builder;


import com.fzzy.protocol.fzzy.data.MessageInfo;
import com.fzzy.protocol.fzzy.data.ReMessage;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.server.ServerUtils;

/**
 * ç³»ç»ŸæŽ¥å£
 */
public class ObjectCommandBuilder extends CommandBuilder {

    private final static ObjectCommandBuilder instance = new ObjectCommandBuilder();

    private ObjectCommandBuilder() {
    }

    public static ObjectCommandBuilder getInstance() {
        return instance;
    }


    public SendMessage buildMessage(ReMessage reMessage, String functionId, Object obj) {

        SendMessage message = new SendMessage();
        message.setIp(reMessage.getIp());
        message.setPort(reMessage.getPort());

        message.setBegin(ServerUtils.MSG_BEGIN);

        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, reMessage, functionId, obj);


        message.setEnd(ServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(SendMessage message, ReMessage reMessage, String functionId, Object object) {
        MessageInfo info = new MessageInfo();
        info.setSign(reMessage.getCompanyId());
        info.setIedId(reMessage.getIedId());
        info.setFunctionId(functionId);
        info.setRespCode("0000");
        info.setOrderId(reMessage.getOrderId());
        info.setUserData("0");
        info.setSign("0000");
        info.setContent(object);

        message.setInfo(info);
    }

//    public void buildInfo(SendMessage message, GatewayDevice deviceSer, String functionId, Object object) {
//        MessageInfo info = new MessageInfo();
//        info.setSign("0000");
//        info.setIedId(deviceSer.getId());
//        info.setFunctionId(functionId);
//        info.setRespCode("0000");
//        info.setOrderId(deviceSer.getOrgId());
//        info.setUserData("0");
//        info.setSign("0000");
//
//        //封装消消息内容
//        info.setContent(object);
//
//        message.setInfo(info);
//    }


}

 src/main/java/com/fzzy/protocol/fzzy/builder/SimpleCommandBuilder.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,96 @@
package com.fzzy.protocol.fzzy.builder;


import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.gateway.entity.GatewayDevice;
import com.fzzy.io.request.BaseRequest;
import com.fzzy.protocol.fzzy.data.MessageInfo;
import com.fzzy.protocol.fzzy.data.ReMessage;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.server.ServerUtils;

/**
 * æ— æ¶ˆæ¯ä½“的命令封装
 */
public class SimpleCommandBuilder extends CommandBuilder {

    private final static SimpleCommandBuilder instance = new SimpleCommandBuilder();

    private SimpleCommandBuilder() {
    }

    public static SimpleCommandBuilder getInstance() {
        return instance;
    }

    public SendMessage buildMessage(ApiCommonDevice deviceSer, String functionId) {

        BaseRequest request = new BaseRequest();
        request.setSerId(deviceSer.getSn());
        request.setBizType("grain");
        request.setCompanyId("0000");
        request.setPort(deviceSer.getPort());
        request.setSerName(deviceSer.getId());
        request.setIp(deviceSer.getIp());

        SendMessage message = new SendMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());

        message.setBegin(ServerUtils.MSG_BEGIN);

        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request, functionId);


        message.setEnd(ServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public SendMessage buildMessage(ReMessage reMessage, String functionId) {

        BaseRequest request = new BaseRequest();
        request.setSerId(reMessage.getIedId());
        request.setBizType("grain");
        request.setCompanyId(reMessage.getCompanyId());
        request.setPort(reMessage.getPort());
        request.setIp(reMessage.getIp());

        SendMessage message = new SendMessage();
        message.setIp(request.getIp());
        message.setPort(request.getPort());

        message.setBegin(ServerUtils.MSG_BEGIN);

        // è°ƒæ•´ä¿¡æ¯
        buildInfo(message, request, functionId);


        message.setEnd(ServerUtils.MSG_END);

        // ç”Ÿæˆæ•´ä½“命令信息和BYte信息
        build(message);

        return message;
    }

    public void buildInfo(SendMessage message, BaseRequest request, String functionId) {
        MessageInfo info = new MessageInfo();
        info.setSign(request.getCompanyId());
        info.setIedId(request.getSerId());
        info.setFunctionId(functionId);
        info.setRespCode("0000");
        info.setOrderId(request.getOrderId());
        info.setUserData("0");
        info.setSign("0000");
        info.setContent(null);

        message.setInfo(info);
    }


}

 src/main/java/com/fzzy/protocol/fzzy/cmd/BaseRemoteImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,61 @@
package com.fzzy.protocol.fzzy.cmd;


import com.fzzy.api.data.GatewayDeviceProtocol;
import com.fzzy.api.utils.ContextUtil;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.server.FzzyServerEngine;
import com.ld.io.api.InvokeResult;
import com.ld.io.api.IoSession;
import com.ld.io.api.IoSessionQuery;
import lombok.extern.slf4j.Slf4j;

import java.util.List;

@Slf4j
public class BaseRemoteImpl {

    /**
     * å‘送命令
     *
     * @param ip
     * @param port
     * @param msg
     * @return
     */
    public InvokeResult send(String ip, int port, byte[] msg) {
        IoSessionQuery sessionFactory = FzzyServerEngine.ioServer.getSessionQuery();
        List<IoSession> sessions = sessionFactory.getAllSession();
        IoSession session = null;
        for (IoSession ioSession : sessions) {
            if (ContextUtil.getServerKey(ip, port).equals(
                    ioSession.getBusinessKey())) {
                session = ioSession;
                break;
            }
        }
        if (null == session) {
            return InvokeResult.CHANNEL_CLOSED;
        }
        return session.invoke(msg);
    }

    public InvokeResult send(SendMessage message) {
        log.debug("平台发送报文---->>控制柜--{}", message.toString());
        IoSessionQuery sessionFactory = FzzyServerEngine.ioServer.getSessionQuery();
        List<IoSession> sessions = sessionFactory.getAllSession();
        IoSession session = null;
        for (IoSession ioSession : sessions) {
            if (ContextUtil.getServerKey(message.getIp(), message.getPort()).equals(
                    ioSession.getBusinessKey())) {
                session = ioSession;
                break;
            }
        }
        if (null == session) {
            return InvokeResult.CHANNEL_CLOSED;
        }
        return session.invoke(message.getByteMsg());
    }

}

 src/main/java/com/fzzy/protocol/fzzy/data/MessageInfo.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@
package com.fzzy.protocol.fzzy.data;

import lombok.Data;

/**
 * ä¿¡æ¯å†…容对接
 */
@Data
public class MessageInfo {

    private String orgId;//组织编码，已经于2021å¹´6月15日取消使用

    private String sn;//网关唯一标识

    private String iedId;// åˆ†æœºID，可能重复

    private String functionId;// åŠŸèƒ½ç¼–码

    private String respCode;// åº”答编码

    private String orderId;//请求编码

    private String userData;//自定义数据

    private String sign;//签名类型

    private Object content;//信息体
}

 src/main/java/com/fzzy/protocol/fzzy/data/ReMessage.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,59 @@
package com.fzzy.protocol.fzzy.data;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * è¿”回信息封装
 *
 * @author Andy
 */
@Data
public class ReMessage implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private String companyId;//组织编码

    private String begin;

    private String end;

    private String ip;//IP地址

    private int port;//端口号

    private Date receiveDate = new Date();

    private String strMsg;// å½“前命令转换为字符串的信息

    private String sn;//序列号

    private String iedId;// åˆ†æœºID

    private String functionId;// åŠŸèƒ½ç¼–码

    private String respCode;// åº”答编码

    private String orderId;//请求编码

    private String userData;//自定义数据

    private String sign;//签名类型

    private String content;//消息体

    @Override
    public String toString() {
        return "ReMessage [ip=" + ip + ", port=" + port + ", receiveDate="
                + receiveDate + ", strMsg=" + strMsg + ", sn=" + sn
                + ", iedId=" + iedId + ", functionId=" + functionId
                + ", respCode=" + respCode + ", orderId=" + orderId
                + ", content=" + content + "]";
    }
}

 src/main/java/com/fzzy/protocol/fzzy/data/SendMessage.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
package com.fzzy.protocol.fzzy.data;

import lombok.Data;

/**
 * å‘送信息封装
 */
@Data
public class SendMessage {

    private String begin;

    private String end;

    private String ip;//IP地址

    private int port;//端口号

    private String strMsg;// å½“前命令转换为字符串的信息

    private byte[] byteMsg;// å½“前命令的字节信息

    private MessageInfo info;


    @Override
    public String toString() {
        return "SendMessage{" +
                "ip='" + ip + '\'' +
                ", port=" + port +
                ", info=" + info +
                '}';
    }
}

 src/main/java/com/fzzy/protocol/fzzy/package-info.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1 @@
package com.fzzy.protocol.fzzy;

 src/main/java/com/fzzy/protocol/fzzy/req/Request2101.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,10 @@
package com.fzzy.protocol.fzzy.req;

import lombok.Data;

@Data
public class Request2101 {

    private String houseId;

}

 src/main/java/com/fzzy/protocol/fzzy/resp/Response1001.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,9 @@
package com.fzzy.protocol.fzzy.resp;

import lombok.Data;

@Data
public class Response1001 {

    private String time;
}

 src/main/java/com/fzzy/protocol/fzzy/resp/Response2102.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
package com.fzzy.protocol.fzzy.resp;

import lombok.Data;

/**
 * ç²®æƒ…返回结果对象
 */
@Data
public class Response2102 {

    private String houseId;

    private Double tIn;//仓内温度；如有故障则传故障编码，故障编码详见附录二。如：-2000，传感器不在线。

    private Double hIn;//仓内湿度；如有故障则传故障编码，故障编码详见附录二。如：-2000，传感器不在线。

    private Double tOut;//仓外温度；如有故障则传故障编码，故障编码详见附录二。如：-2000，传感器不在线。

    private Double hOut;//仓外湿度；如有故障则传故障编码，故障编码详见附录二。如：-2000，传感器不在线。

    private String points;// ä»¥è‹±æ–‡â€œ,”隔开的粮温点位信息；如有故障则传故障编码，故障编码详见附录二。如：-1000，故障点。

    private Double tAvg;

    private Double tMax;

    private Double tMin;

    private String time;//yyyyMMddHHmmss

    private String row;//平方仓-布线规则-行配置

    private String lay;//平方仓-布线规则-层配置

    private String col;//平仓仓-布线规则-列配置

    private String layout;//筒仓-布线规则，如：3-6-9 è¡¨ç¤ºå†…圈3根，中间6根，外圈9æ ¹

    private String layerPerCircle;//筒仓-布线规则，如：9-9-9 è¡¨ç¤ºå†…圈9层，中间9层，外圈9层

    private Double houseHeight;//油罐仓-建筑物高度，单位：米

    private Double liquidHeight;//油罐仓-液位高度，单位：米

    private String remark;


}

 src/main/java/com/fzzy/protocol/fzzy/server/FzzyServerEngine.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,77 @@
package com.fzzy.protocol.fzzy.server;

import com.ld.io.api.*;
import com.ld.io.netty.NettyServer;
import lombok.extern.slf4j.Slf4j;

import java.util.List;

/**
 * é£Žæ­£è‡´è¿œ-TCP主服务
 */
@Slf4j
public class FzzyServerEngine {

    public static final int default_port = 9300;

    public static NettyServer ioServer = null;

    // é…ç½®æ¶ˆæ¯æŽ¥æ”¶ç±»
    private static MsgConsumer messageConsume = new MsgConsumer();
    // ç›‘听会话的创建与销毁
    private static SessionListener ioSessionListener = new SessionListener();


    public static void start(Integer port) throws InterruptedException {

        if (null == port) port = default_port;

        // é…ç½®Server的配置
        IoServerOption ioServerOption = new IoServerOption(port);

        ioServerOption.setSplitDecoderType(SplitByteDecoderType.DELIMITER_SYMBOL);

        ioServerOption.setDelimiter(ServerUtils.MSG_END.getBytes());

        ioServer = new NettyServer(ioServerOption, messageConsume, ioSessionListener);

        ioServer.startup();


        log.info("* ========================");
        log.info("* ");
        log.info("* FZZY-TCP-V3.0，端口号={}", port);
        log.info("* ");
        log.info("* ========================");

        System.out.println("* ========================");
        System.out.println("* ");
        System.out.println("* FZZY-TCP-V3.0，端口号=" + port);
        System.out.println("* ");
        System.out.println("* ========================");
    }

    /**
     * å‘送信息
     *
     * @param ip
     * @param port
     * @param msg
     * @return
     */
    public static InvokeResult push(String ip, int port, byte[] msg) {
        IoSessionQuery sessionFactory = ioServer.getSessionQuery();
        List<IoSession> sessions = sessionFactory.getAllSession();
        IoSession session = null;
        for (IoSession ioSession : sessions) {
            if (ServerUtils.getServerKey(ip, port).equals(ioSession.getBusinessKey())) {
                session = ioSession;
                break;
            }
        }
        if (null == session) {
            return InvokeResult.CHANNEL_CLOSED;
        }
        return session.invoke(msg);
    }
}

 src/main/java/com/fzzy/protocol/fzzy/server/MsgConsumer.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,61 @@
package com.fzzy.protocol.fzzy.server;

import com.alibaba.fastjson.JSON;
import com.fzzy.api.utils.SpringUtil;
import com.fzzy.protocol.fzzy.analysis.AnalysisService;
import com.fzzy.protocol.fzzy.data.ReMessage;
import com.ld.io.api.IoMsgConsumer;
import com.ld.io.api.IoSession;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

/**
 * æŽ¥æ”¶ç»ˆç«¯è¿”回回来的信息。
 *
 * @author Andy
 */
@Slf4j
public class MsgConsumer implements IoMsgConsumer {

    private AnalysisService analysisService;

    private static final String CHARSET = "UTF-8";

    @Override
    public void consume(IoSession session, byte[] bytes) {
        ReMessage reMessage = null;
        try {
            String message = new String(bytes, CHARSET);

            message = message.substring(ServerUtils.MSG_BEGIN.length());

            reMessage = JSON.parseObject(message, ReMessage.class);


            if (StringUtils.isEmpty(reMessage.getSn()) ||
                    StringUtils.isEmpty(reMessage.getIedId()) ||
                    StringUtils.isEmpty(reMessage.getFunctionId())) {
                log.error("控制柜------>>>>平台：报文信息不完整，不做解析-IP={}，port={}，msg={}", session.getAddress(), session.getPort(), message);
                return;
            }
            reMessage.setIp(session.getAddress());
            reMessage.setPort(session.getPort());
            reMessage.setStrMsg(message);
            session.setCompanyId("0000");

            log.info("控制柜------>>>>平台：IP={}，PORT={}，message={}", reMessage.getIp(), reMessage.getPort(), message);

        } catch (Exception e) {
            log.error("控制柜------>>>>平台：收到报文解析异常：{}", e.getMessage());
            e.printStackTrace();
        }

        //调用解析接口开始解析
        if (null == analysisService) {
            analysisService = (AnalysisService) SpringUtil.getBean(AnalysisService.BEAN_ID);
        }

        analysisService.analysis(reMessage);
    }

}

 src/main/java/com/fzzy/protocol/fzzy/server/ServerUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,219 @@
package com.fzzy.protocol.fzzy.server;

import com.fzzy.api.utils.ContextUtil;
import com.fzzy.gateway.data.BaseReqData;
import com.fzzy.gateway.data.BaseResp;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * å·¥å…·ç±»
 *
 * @author Andy
 */
public class ServerUtils {

    private static Map<String, Integer> contextOrder = new HashMap<>();

    /**
     * è¯·æ±‚缓存 key = deviceId,value = requData
     */
    private static Map<String, BaseReqData> contextSyncReqMap = new HashMap<>();

    /**
     * å°†æ‰§è¡Œå‘½ä»¤ä¿¡æ¯å­˜æ”¾åœ¨ç¼“å­˜
     *
     * @param depotId ä»“库编码
     * @param reqData è¯·æ±‚参数信息
     */
    public static void addSyncReq2Map(String depotId, BaseReqData reqData) {
        contextSyncReqMap.put(depotId, reqData);
    }

    public static BaseReqData getSyncReq(String depotId) {
        return contextSyncReqMap.get(depotId);
    }


    public static final String MSG_BEGIN = "<FZZY>";
    public static final String MSG_END = "<END>";

    //功能码
    public static final String FUNCTION_1001 = "1001";// æŽ§åˆ¶æŸœè¯·æ±‚登录平台
    public static final String FUNCTION_1003 = "1003";// å¹³å°èŽ·å–控制柜设备信息
    public static final String FUNCTION_1004 = "1004";// æŽ§åˆ¶æŸœå‘平台推送警告通知
    public static final String FUNCTION_1005 = "1005";// æŽ§åˆ¶æŸœä¸»åŠ¨å‘起心跳
    public static final String FUNCTION_1006 = "1006";// å¹³å°é€ä¼ æ•°æ®
    public static final String FUNCTION_1007 = "1007";// æŽ§åˆ¶æŸœæŽ¨é€ä»“房状态
    public static final String FUNCTION_1008 = "1008";// å¹³å°è¿œç¨‹æ›´æ”¹ä»“房状态
    public static final String FUNCTION_1009 = "1009";// å¹³å°è¿œç¨‹æŽˆæƒæŽ§åˆ¶æŸœ
    public static final String FUNCTION_1010 = "1010";// å¹³å°èŽ·å–控制柜仓房信息
    public static final String FUNCTION_2101 = "2101";// å¹³å°å‘起粮情检测请求
    public static final String FUNCTION_2102 = "2102";// æŽ§åˆ¶æŸœä¸ŠæŠ¥ç²®æƒ…采集结果
    public static final String FUNCTION_2201 = "2201";// å¹³å°å‘起检测请求
    public static final String FUNCTION_2202 = "2202";// æŽ§åˆ¶ä¸ŠæŠ¥é€æ£€æµ‹è¿›åº¦
    public static final String FUNCTION_2203 = "2203";// æŽ§åˆ¶æŸœä¸ŠæŠ¥æ£€æµ‹ç»“æžœ
    public static final String FUNCTION_2204 = "2204";// å¹³å°ä¸­æ­¢è™«å®³é‡‡é›†
    public static final String FUNCTION_2301 = "2301";// å¹³å°å‘起检测请求
    public static final String FUNCTION_2302 = "2302";// æŽ§åˆ¶æŸœä¸ŠæŠ¥æ£€æµ‹è¿›åº¦
    public static final String FUNCTION_2303 = "2303";// æŽ§åˆ¶æŸœä¸ŠæŠ¥æ£€æµ‹ç»“æžœ
    public static final String FUNCTION_2304 = "2304";// å¹³å°ä¸­æ­¢æ°”体采集
    public static final String FUNCTION_3101 = "3101";// å¹³å°è¿œç¨‹æ“ä½œè®¾å¤‡
    public static final String FUNCTION_3102 = "3102";// å¹³å°èŽ·å–终端设备状态
    public static final String FUNCTION_3103 = "3103";// å¹³å°ç´§æ€¥å…¨å…³ç»ˆç«¯è®¾å¤‡
    public static final String FUNCTION_3201 = "3201";// å¹³å°å‘起自动通风
    public static final String FUNCTION_3301 = "3301";// å¹³å°å‘起自动气调
    public static final String FUNCTION_3302 = "3302";// å¹³å°è¿œç¨‹æ“æŽ§åˆ¶æ°®æœº
    public static final String FUNCTION_3303 = "3303";// å¹³å°èŽ·å–制氮机状态
    public static final String FUNCTION_3304 = "3304";// å¹³å°èŽ·å–仓内气压
    public static final String FUNCTION_4001 = "4001";// å¹³å°å‘起能耗监测请求
    public static final String FUNCTION_5001 = "5001";// å¹³å°è¿œç¨‹æ“ä½œç©ºè°ƒ
    public static final String FUNCTION_5002 = "5002";// å¹³å°èŽ·å–空调状态
    public static final String FUNCTION_6001 = "6001";//


    //响应码
    public static String RESP_0000 = "0000";//    è¡¨ç¤ºæ‰§è¡ŒæˆåŠŸ
    public static String RESP_1000 = "1000";//    æŽ§åˆ¶æŸœç¼–号错误
    public static String RESP_1001 = "1001";//    ç»ˆç«¯è®¾å¤‡ä¸åœ¨çº¿
    public static String RESP_1010 = "1010";//    æŽ§åˆ¶æŸœæŽˆæƒåˆ°æœŸ
    public static String RESP_1011 = "1011";//    æŽˆæƒç æ— æ•ˆ
    public static String RESP_1012 = "1012";//    æŽˆæƒç å·²è¢«ä½¿ç”¨
    public static String RESP_1013 = "1013";//    æŽˆæƒç å·²è¿‡æœŸ
    public static String RESP_2000 = "2000";//    ç­¾åéªŒè¯å¤±è´¥
    public static String RESP_3000 = "3000";//    é€šé£Žæ¨¡å¼ä¸æ”¯æŒ
    public static String RESP_4000 = "4000";//    æ°”调模式不支持
    public static String RESP_5000 = "5000";//    æŽ§åˆ¶æŸœå½“前为手动模式，拒绝远程操作
    public static String RESP_6000 = "6000";//    é‡‡é›†æ‰§è¡Œå¤±è´¥
    public static String RESP_6001 = "6001";//    ç²®æƒ…采集执行中
    public static String RESP_6002 = "6002";//    æ°”体采集执行中
    public static String RESP_6003 = "6003";//    è™«å®³é‡‡é›†æ‰§è¡Œä¸­
    public static String RESP_9999 = "9999";//    æœªçŸ¥é”™è¯¯

    //仓库状态
    static String DEPOT_STATUS_1001 = "1001";//通风
    static String DEPOT_STATUS_2001 = "2001";//气调
    static String DEPOT_STATUS_3001 = "3001";//熏蒸
    static String DEPOT_STATUS_4001 = "4001";//温控
    static String DEPOT_STATUS_5001 = "5001";//ç»´ä¿®
    static String DEPOT_STATUS_6001 = "6001";//出库
    static String DEPOT_STATUS_7001 = "7001";//入库
    static String DEPOT_STATUS_8001 = "8001";//满仓
    static String DEPOT_STATUS_9001 = "9001";//空仓

    //设备类型
    public static String DEVICE_TYPE_1 = "1";// é£Žçª—
    public static String DEVICE_TYPE_2 = "2";// é£Žå£
    public static String DEVICE_TYPE_3 = "3";// è½´æµé£Žæœº
    public static String DEVICE_TYPE_4 = "4";// æ··æµé£Žæœº
    public static String DEVICE_TYPE_5 = "5";// çŽ¯æµé£Žæœº
    public static String DEVICE_TYPE_6 = "6";// ç¦»å¿ƒé£Žæœº
    public static String DEVICE_TYPE_7 = "7";//加压风机
    public static String DEVICE_TYPE_8 = "8";// ç”µåŠ¨è¶é˜€
    public static String DEVICE_TYPE_9 = "9";// ç…§æ˜Ž
    public static String DEVICE_TYPE_10 = "10";//门禁
    public static String DEVICE_TYPE_11 = "11";// ç©ºè°ƒ
    public static String DEVICE_TYPE_12 = "12";// è§†é¢‘


    //设备状态
    public static String DEVICE_STATUS_01 = "1";// " å¼€(风机正转)    01
    public static String DEVICE_STATUS_02 = "2";// å…³    02
    public static String DEVICE_STATUS_03 = "3";// é£Žæœºåè½¬    03
    public static String DEVICE_STATUS_04 = "4";// å¼€æ‰§è¡Œä¸­    04
    public static String DEVICE_STATUS_05 = "5";// å…³æ‰§è¡Œä¸­    05
    public static String DEVICE_STATUS_06 = "6";// æ— æ“ä½œ    06
    public static String DEVICE_STATUS_07 = "7";// æœªçŸ¥çŠ¶æ€    07

    //空调模式
    public static String TEMP_MODE_10 = "10";//通风
    public static String TEMP_MODE_11 = "11";//制冷
    public static String TEMP_MODE_20 = "20";//风速低
    public static String TEMP_MODE_21 = "21";//风速中
    public static String TEMP_MODE_22 = "22";//风速高

    //自动气调模式
    public static String AUTO_N2_10 = "10";//抽负压    10
    public static String AUTO_N2_20 = "20";//气密性检测    20
    public static String AUTO_N2_30 = "30";//正常充氮    30
    public static String AUTO_N2_31 = "31";//加压充氮    31
    public static String AUTO_N2_40 = "40";//均氮    40
    public static String AUTO_N2_50 = "50";//氮气回收    50


    //自动通风模式
    public static String AUTO_AIR_10 = "10";// æŽ’积热通风    10
    public static String AUTO_AIR_20 = "20";//自然通风    20
    public static String AUTO_AIR_30 = "30";//保水降温通风    30
    public static String AUTO_AIR_40 = "40";//除湿通风    40
    public static String AUTO_AIR_50 = "50";//用户模式通风    50


    //仓库类型
    public static String HOUSE_TYPE_1 = "1";// å¹³æˆ¿ä»“
    public static String HOUSE_TYPE_2 = "2";//浅圆仓
    public static String HOUSE_TYPE_3 = "3";//油罐仓
    public static String HOUSE_TYPE_4 = "4";//立筒仓
    public static String HOUSE_TYPE_99 = "99";//其他


    //设备位置
    public static String DEVICE_L0 = "0";// å¹³æˆ¿ä»“-仓正面
    public static String DEVICE_L1 = "1";// å¹³æˆ¿ä»“-仓背面
    public static String DEVICE_L2 = "2";// ç­’仓-顶部
    public static String DEVICE_L3 = "3";// ç­’仓-底部


    /**
     * ç”ŸæˆTCP连接的KEY
     *
     * @param ip
     * @param port
     * @return
     */
    public static String getServerKey(String ip, Integer port) {
        return ip + ":" + port;
    }


    /**
     * æ ¹æ®æ“ä½œæ¨¡å¼ï¼Œè¿”回空调模式
     *
     * @param mode
     * @return
     */
    public static String getTempMode(String mode) {
        if (mode.equals("01")) {
            return TEMP_MODE_11;
        }
        if (mode.equals("02")) {
            return TEMP_MODE_10;
        }
        return TEMP_MODE_11;
    }

    public static String getOrderByDepotId(String depotId) {
        if (null == depotId) {
            Integer integer = contextOrder.get("ORDER");
            if (null == integer) integer = 1000;
            integer = integer + 1;
            contextOrder.put("ORDER", integer);
            return integer + "";
        }

        //只要数字
        String regEx = "[^0-9]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(depotId);
        String regDepotId = m.replaceAll("").trim();

        if (regDepotId.length() > 4) {
            regDepotId = regDepotId.substring(regDepotId.length() - 4);
        }

        return Integer.valueOf(regDepotId)+"";
    }
}

 src/main/java/com/fzzy/protocol/fzzy/server/SessionListener.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,24 @@
package com.fzzy.protocol.fzzy.server;

import com.ld.io.api.IoSession;
import com.ld.io.api.IoSessionListener;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SessionListener implements IoSessionListener {

    @Override
    public void onCreate(IoSession session) {

        log.info("++++FZZY-控制柜上线++++-IP={}，PORT={}", session.getAddress(), session.getPort());

        // æ·»åŠ è‡ªå®šä¹‰ä¸šåŠ¡ID
        session.setBusinessKey(ServerUtils.getServerKey(session.getAddress(), session.getPort()));

    }

    @Override
    public void onDestroy(IoSession session) {
        log.info("----FZZY-控制柜离线-----IP={}，PORT={}", session.getAddress(), session.getPort());
    }
}

 src/main/java/com/fzzy/protocol/fzzy/service/FzzyGatewayGrainService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,87 @@
package com.fzzy.protocol.fzzy.service;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiCommonDevice;
import com.fzzy.api.data.GatewayDeviceProtocol;
import com.fzzy.gateway.api.GatewaySyncGranService;
import com.fzzy.gateway.data.BaseReqData;
import com.fzzy.gateway.data.BaseResp;
import com.fzzy.gateway.entity.GatewayDevice;
import com.fzzy.protocol.fzzy.builder.GrainCommandBuilder;
import com.fzzy.protocol.fzzy.cmd.BaseRemoteImpl;
import com.fzzy.protocol.fzzy.data.SendMessage;
import com.fzzy.protocol.fzzy.server.ServerUtils;
import com.ld.io.api.InvokeResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * é£Žæ­£è‡´è¿œæŽ§åˆ¶æŸœåè®®
 */
@Slf4j
@Component
public class FzzyGatewayGrainService extends BaseRemoteImpl implements GatewaySyncGranService {

    @Override
    public String getGrainProtocol() {
        return GatewayDeviceProtocol.TCP_FZZY_V3.getCode();
    }

    @Override
    public BaseResp syncGrain(BaseReqData reqData) {

        BaseResp resp = new BaseResp();

        GatewayDevice device = reqData.getDevice();

        //获取连接中的设备信息
        ApiCommonDevice apiCommonDevice = Constant.getCommonDeviceCache(device.getDeviceSn());

        if (null == apiCommonDevice) {
            resp.setCode(500);
            resp.setMsg("系统未获取到下行连接设备信息，无法执行");
            log.error("----------------系统未获取到下行连接设备信息,无法执行---------");
            return resp;
        }

        if (Constant.YN_N.equals(apiCommonDevice.getStatus())) {
            resp.setCode(500);
            resp.setMsg("下行设备不在线---无法执行----" + device.getDeviceName());
            log.error("下行设备不在线---无法执行----" + device.getDeviceName());
            return resp;
        }

        device.setIp(apiCommonDevice.getIp());
        device.setPort(apiCommonDevice.getPort());

        reqData.setDevice(device);


        try {

            //Step è¯·æ±‚信息放入内存
            ServerUtils.addSyncReq2Map(device.getDepotId(), reqData);

            // Step1 ç”Ÿæˆç²®æƒ…信息
            SendMessage message = GrainCommandBuilder.getInstance().buildMessage(device,apiCommonDevice);
            // å‘送命令
            InvokeResult result = send(device.getIp(), device.getPort(), message.getByteMsg());

            log.error("平台------>>>>控制柜：粮情检测-{}", message);

            // å°è£…返回信息
            if (!InvokeResult.SUCCESS.getCode().equals(result.getCode())) {
                log.error("平台------>>>>控制柜：粮情检测-失败{}", result.getMessage());
                resp.setCode(500);
                resp.setMsg("平台------>>>>控制柜：粮情检测-失败：" + result.getMessage());
            }

        } catch (Exception e) {
            log.error("粮情检测异常：{}", e);
            resp.setCode(500);
            resp.setMsg("粮情检测异常：" + e.getMessage());
            return resp;
        }
        return resp;
    }
}

 src/main/resources/application.yml

@@ -1,7 +1,7 @@
##########################  Server   ##########################
spring:
  profiles:
    active: proGateway
    active: devGateway
  application:
    name: igds-api
  main:
@@ -29,15 +29,16 @@
    encoding: UTF-8
    cache:  false

#License é…ç½®ç¤ºä¾‹
license:
  subject: ld_license
  publicAlias: publicCert
  storePass: PUBLICFZZYXXJSGFYXGS888888
  licensePath: D:/AppData/license/license.lic
  publicKeysStorePath: D:/AppData/license/publicCerts.keystore

igds:
  default:
    companyId: 5326
  file-path: C:/app/igds-api
  img-path: D:/IGDS/FILE/
license:
  subject: ld_license
  publicAlias: publicCert
  storePass: PUBLICFZZYXXJSGFYXGS888888
  licensePath: D:/IGDS/license/license.lic
  publicKeysStorePath: D:/IGDS/license/publicCerts.keystore