lijianfu
/
mh_esi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

优化采集存储

master
mh 3 months ago
parent
615762986b
commit
974338664c
16 changed files with 832 additions and 808 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      user-service/src/main/java/com/mh/user/UserServiceApplication.java
  2. 137
      user-service/src/main/java/com/mh/user/entity/DeviceCodeParamEntity.java
  3. 2
      user-service/src/main/java/com/mh/user/job/JobChillers.java
  4. 28
      user-service/src/main/java/com/mh/user/mapper/DataResultMapper.java
  5. 25
      user-service/src/main/java/com/mh/user/mapper/DeviceCodeParamMapper.java
  6. 7
      user-service/src/main/java/com/mh/user/netty/EchoServer.java
  7. 446
      user-service/src/main/java/com/mh/user/netty/EchoServerHandler.java
  8. 186
      user-service/src/main/java/com/mh/user/netty/NettyChillerClient.java
  9. 630
      user-service/src/main/java/com/mh/user/netty/NettyChillerClientHandler.java
  10. 43
      user-service/src/main/java/com/mh/user/service/impl/DataResultServiceImpl.java
  11. 70
      user-service/src/main/java/com/mh/user/utils/AnalysisReceiveOrder485.java
  12. 2
      user-service/src/main/java/com/mh/user/utils/GetReadOrder485.java
  13. 5
      user-service/src/main/java/com/mh/user/utils/SendOrderUtils.java
  14. 4
      user-service/src/main/resources/bootstrap.yml
  15. 36
      user-service/src/test/java/com/mh/user/SysUserTest.java
  16. 3
      user-service/src/test/java/com/mh/user/socket/NettyClientTest.java

16
user-service/src/main/java/com/mh/user/UserServiceApplication.java
Unescape View File

@ -1,28 +1,16 @@
package com.mh.user; package com.mh.user;
import com.mh.user.constants.Constant;
import com.mh.user.entity.ProjectInfoEntity;
import com.mh.user.job.CollectionLoopRunner;
import com.mh.user.netty.EchoServer;
import com.mh.user.service.DeviceCodeParamService;
import com.mh.user.service.ProjectInfoService;
import com.mh.user.utils.GetReadOrder485;
import lombok.extern.slf4j.Slf4j;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication; import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.EnableScheduling;
import javax.annotation.PreDestroy; import javax.annotation.PreDestroy;
import java.util.List;
@SpringBootApplication(scanBasePackages = "com.mh.user") @SpringBootApplication(scanBasePackages = "com.mh.user")
@EnableScheduling @EnableScheduling
//@ServletComponentScan
public class UserServiceApplication extends SpringBootServletInitializer { public class UserServiceApplication extends SpringBootServletInitializer {
private static final Logger log = Logger.getLogger(UserServiceApplication.class); private static final Logger log = Logger.getLogger(UserServiceApplication.class);
@ -33,11 +21,7 @@ public class UserServiceApplication extends SpringBootServletInitializer {
} }
public static void main(String[] args) { //一共四个地方要修改,UserServiceApplication,RabbitmqConfig,log4j,bootstrap,DealDataJob public static void main(String[] args) { //一共四个地方要修改,UserServiceApplication,RabbitmqConfig,log4j,bootstrap,DealDataJob
SpringApplication.run(UserServiceApplication.class, args); SpringApplication.run(UserServiceApplication.class, args);
//System.out.println(Constant.projectId);
//Constant.projectId=7;
//System.out.println(Constant.projectId);
} }
@PreDestroy @PreDestroy

137
user-service/src/main/java/com/mh/user/entity/DeviceCodeParamEntity.java
Unescape View File

@ -1,9 +1,7 @@
package com.mh.user.entity; package com.mh.user.entity;
import lombok.Data;
import java.util.Date; import java.util.Date;
@Data
public class DeviceCodeParamEntity { public class DeviceCodeParamEntity {
private Long id; private Long id;
@ -24,4 +22,139 @@ public class DeviceCodeParamEntity {
private Date createTime; private Date createTime;
private String projectID; private String projectID;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getDeviceAddr() {
return deviceAddr;
}
public void setDeviceAddr(String deviceAddr) {
this.deviceAddr = deviceAddr;
}
public String getDeviceName() {
return deviceName;
}
public void setDeviceName(String deviceName) {
this.deviceName = deviceName;
}
public String getDeviceType() {
return deviceType;
}
public void setDeviceType(String deviceType) {
this.deviceType = deviceType;
}
public String getStrData() {
return strData;
}
public void setStrData(String strData) {
this.strData = strData;
}
public String getDataPort() {
return dataPort;
}
public void setDataPort(String dataPort) {
this.dataPort = dataPort;
}
public int getBaudRate() {
return baudRate;
}
public void setBaudRate(int baudRate) {
this.baudRate = baudRate;
}
public String getParity() {
return parity;
}
public void setParity(String parity) {
this.parity = parity;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getFunCode() {
return funCode;
}
public void setFunCode(String funCode) {
this.funCode = funCode;
}
public String getRegisterAddr() {
return registerAddr;
}
public void setRegisterAddr(String registerAddr) {
this.registerAddr = registerAddr;
}
public String getRegisterName() {
return registerName;
}
public void setRegisterName(String registerName) {
this.registerName = registerName;
}
public int getDigit() {
return digit;
}
public void setDigit(int digit) {
this.digit = digit;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public String getDataValue() {
return dataValue;
}
public void setDataValue(String dataValue) {
this.dataValue = dataValue;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getProjectID() {
return projectID;
}
public void setProjectID(String projectID) {
this.projectID = projectID;
}
} }

2
user-service/src/main/java/com/mh/user/job/JobChillers.java
Unescape View File

@ -1,7 +1,6 @@
package com.mh.user.job; package com.mh.user.job;
import com.mh.user.constants.SocketMessage; import com.mh.user.constants.SocketMessage;
import com.mh.user.netty.NettyChillerClient;
import lombok.SneakyThrows; import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution; import org.quartz.DisallowConcurrentExecution;
@ -35,7 +34,6 @@ public class JobChillers implements Job {
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
log.info("定时采集冷水机组"); log.info("定时采集冷水机组");
// NettyChillerClient nettyChillerClient = new NettyChillerClient(); // NettyChillerClient nettyChillerClient = new NettyChillerClient();
NettyChillerClient.connect(socketMessage.getPort(), socketMessage.getIP());
} }
} }

28
user-service/src/main/java/com/mh/user/mapper/DataResultMapper.java
Unescape View File

@ -122,11 +122,17 @@ public interface DataResultMapper {
"</script>") "</script>")
void updateDataResultCh(DataResultChEntity dataResultChEntity); void updateDataResultCh(DataResultChEntity dataResultChEntity);
@Select("select count(*) from data_result_ch where curDate=#{curDate} and deviceAddr=#{deviceAddr} and registerAddr=#{registerAddr} and projectID=#{projectID}") @Select("select count(*) from data_result_ch " +
" where curDate=#{curDate} " +
" and deviceAddr=#{deviceAddr} " +
" and registerAddr=#{registerAddr} " +
" and projectID=#{projectID} " +
" and grade = #{grade} ")
int selectDataResultChCount(@Param("curDate") String curDate, int selectDataResultChCount(@Param("curDate") String curDate,
@Param("deviceAddr") String deviceAddr, @Param("deviceAddr") String deviceAddr,
@Param("registerAddr") String registerAddr, @Param("registerAddr") String registerAddr,
@Param("projectID") String projectID); @Param("projectID") String projectID,
@Param("grade") int grade);
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
@Results(id="rsc", value = { @Results(id="rsc", value = {
@ -204,11 +210,16 @@ public interface DataResultMapper {
"</script>") "</script>")
void updateDataResultChiller(DataResultChEntity dataResultChEntity); void updateDataResultChiller(DataResultChEntity dataResultChEntity);
@Select("select count(*) from data_result_chiller where curDate=#{curDate} and deviceAddr=#{deviceAddr} and registerAddr=#{registerAddr} and projectID=#{projectID}") @Select("select count(*) from data_result_chiller where curDate=#{curDate} " +
" and deviceAddr=#{deviceAddr} " +
" and registerAddr=#{registerAddr} " +
" and projectID=#{projectID} " +
" and funCode = #{funCode} ")
int selectDataResultChillerCount(@Param("curDate") String curDate, int selectDataResultChillerCount(@Param("curDate") String curDate,
@Param("deviceAddr") String deviceAddr, @Param("deviceAddr") String deviceAddr,
@Param("registerAddr") String registerAddr, @Param("registerAddr") String registerAddr,
@Param("projectID") String projectID); @Param("projectID") String projectID,
@Param("funCode") String funCode);
@Insert("insert into data_result_now(deviceAddr,deviceType,funCode,registerAddr,registerName,curValue,curDate,projectID,grade) values (" + @Insert("insert into data_result_now(deviceAddr,deviceType,funCode,registerAddr,registerName,curValue,curDate,projectID,grade) values (" +
@ -261,4 +272,13 @@ public interface DataResultMapper {
" #{deviceAddr},#{deviceName},#{projectID},#{lastValue},#{lastDate},#{curValue},#{curDate},#{ratio},#{calcValue},#{grade})") " #{deviceAddr},#{deviceName},#{projectID},#{lastValue},#{lastDate},#{curValue},#{curDate},#{ratio},#{calcValue},#{grade})")
void saveDataChiller(ChillerModel chillerModel); void saveDataChiller(ChillerModel chillerModel);
@Select("select count(1) from data_result_cl_bak " +
" where cur_date = #{curDate} " +
" and device_addr = #{deviceAddr} " +
" and registerAddr = #{registerAddr} " +
" and project_id = #{projectId} ")
int selectDataResultChBakCount(@Param("curDate") String curDate,
@Param("deviceAddr") String deviceAddr,
@Param("registerAddr") String registerAddr,
@Param("projectId") String projectId);
} }

25
user-service/src/main/java/com/mh/user/mapper/DeviceCodeParamMapper.java
Unescape View File

@ -19,18 +19,35 @@ public interface DeviceCodeParamMapper {
@Result(property="id",column="id"), @Result(property="id",column="id"),
@Result(property="deviceAddr",column="device_addr"), @Result(property="deviceAddr",column="device_addr"),
@Result(property="deviceType",column="deviceType"), @Result(property="deviceType",column="deviceType"),
@Result(property="dataCom",column="data_com"), @Result(property="strData",column="strData"),
@Result(property="dataPort",column="dataPort"), @Result(property="dataPort",column="dataPort"),
@Result(property="baudRate",column="baudrate"), @Result(property="baudRate",column="baudrate"),
@Result(property ="brand",column ="brand"), @Result(property ="brand",column ="brand"),
@Result(property ="funCode",column ="fun_code"), @Result(property ="funCode",column ="fun_code"),
@Result(property ="registerAddr",column ="register_addr"), @Result(property ="registerAddr",column ="register_addr"),
@Result(property ="deviceName",column ="device_name"), @Result(property ="registerName",column ="registerName"),
@Result(property ="createTime",column ="create_time"), @Result(property ="deviceName",column ="deviceName"),
@Result(property ="createTime",column ="createTime"),
@Result(property ="grade",column ="grade"), @Result(property ="grade",column ="grade"),
@Result(property ="digit",column ="digit"),
@Result(property ="projectID",column ="project_id") @Result(property ="projectID",column ="project_id")
}) })
@Select("select * from device_code_param where dataPort=#{gatewayPort} order by deviceType ") @Select("select id, " +
"device_addr, " +
"deviceType, " +
"strData, " +
"dataPort, " +
"baudrate, " +
"brand, " +
"fun_code, " +
"register_addr, " +
"deviceName, " +
"createTime, " +
"grade, " +
"project_id, " +
"digit, " +
"registerName " +
" from device_code_param where dataPort=#{gatewayPort} order by deviceType ")
List<DeviceCodeParamEntity> queryCodeParam(@Param("gatewayPort") String gatewayPort); List<DeviceCodeParamEntity> queryCodeParam(@Param("gatewayPort") String gatewayPort);
//查询指令参数,传入串口 //查询指令参数,传入串口

7
user-service/src/main/java/com/mh/user/netty/EchoServer.java
Unescape View File

@ -16,11 +16,6 @@ public class EchoServer {
this.port = port; this.port = port;
} }
public static void main(String[] args) {
// new EchoServer(8090).start(); // 调用服务器的start方法
}
public void start() { public void start() {
// 创建Even-LoopGroup // 创建Even-LoopGroup
NioEventLoopGroup bossGroup = new NioEventLoopGroup(); // bossGroup 用于监听客户端连接，专门负责与客户端创建连接，并把连接注册到workerGroup的Selector中。 NioEventLoopGroup bossGroup = new NioEventLoopGroup(); // bossGroup 用于监听客户端连接，专门负责与客户端创建连接，并把连接注册到workerGroup的Selector中。
@ -37,7 +32,7 @@ public class EchoServer {
channelFuture.channel().closeFuture().sync(); // 7、获取Channel的closeFuture，并且阻塞当前线程，直到它完成 channelFuture.channel().closeFuture().sync(); // 7、获取Channel的closeFuture，并且阻塞当前线程，直到它完成
} catch (InterruptedException e) { } catch (InterruptedException e) {
e.printStackTrace(); log.error("服务器启动失败", e);
} finally { } finally {
try { try {
bossGroup.shutdownGracefully().sync(); // 8、关闭EventLoopGroup，关闭所有的资源 bossGroup.shutdownGracefully().sync(); // 8、关闭EventLoopGroup，关闭所有的资源

446
user-service/src/main/java/com/mh/user/netty/EchoServerHandler.java
Unescape View File

@ -3,8 +3,6 @@ package com.mh.user.netty;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.mh.user.constants.Constant; import com.mh.user.constants.Constant;
import com.mh.user.entity.DeviceCodeParamEntity; import com.mh.user.entity.DeviceCodeParamEntity;
import com.mh.user.model.QueueParam;
import com.mh.user.serialport.SerialPortSendReceive;
import com.mh.user.service.DeviceCodeParamService; import com.mh.user.service.DeviceCodeParamService;
import com.mh.user.service.chillers.GatewayManageService; import com.mh.user.service.chillers.GatewayManageService;
import com.mh.user.utils.*; import com.mh.user.utils.*;
@ -14,54 +12,21 @@ import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState; import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent; import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.util.Date; import java.util.Date;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Optional;
public class EchoServerHandler extends ChannelInboundHandlerAdapter { public class EchoServerHandler extends ChannelInboundHandlerAdapter {
private StringBuilder stringBuilder = new StringBuilder();
private HeartUtil heartUtil = HeartUtil.getInstance();
private boolean sendCommand = false;
private String sendStr;
private List<String> sendList;
List<DeviceCodeParamEntity> deviceCodeParamList; List<DeviceCodeParamEntity> deviceCodeParamList;
private static final Logger log = Logger.getLogger(EchoServerHandler.class); private static final Logger log = Logger.getLogger(EchoServerHandler.class);
// 返回发送指令的状态方法
public boolean isSendCommand() {
return sendCommand;
}
public void setSendCommand(boolean sendCommand) {
this.sendCommand = sendCommand;
}
public String getSendStr() {
return sendStr;
}
public void setSendStr(String sendStr) {
this.sendStr = sendStr;
}
public List<String> getSendList() {
return sendList;
}
public void setSendList(List<String> sendList) {
this.sendList = sendList;
}
// 调用service层的接口信息 // 调用service层的接口信息
ApplicationContext context = SpringBeanUtil.getApplicationContext(); ApplicationContext context = SpringBeanUtil.getApplicationContext();
DeviceCodeParamService deviceCodeParamService = context.getBean(DeviceCodeParamService.class); DeviceCodeParamService deviceCodeParamService = context.getBean(DeviceCodeParamService.class);
GatewayManageService gatewayManageService = context.getBean(GatewayManageService.class); GatewayManageService gatewayManageService = context.getBean(GatewayManageService.class);
QueueParam queueParam=new QueueParam();
/** /**
* 空闲次数 * 空闲次数
*/ */
@ -70,15 +35,9 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
private List<String> orderList; private List<String> orderList;
private int num = 0; private int num = 0;
private int size = 0; private int size = 0;
private int sendNum = 0;
private EchoServerHandler echoServerHandler; // 当前类的hashCode值
private String IP; private String IP;
private String port; private String port;
private String receiveStr=""; private String receiveStr="";
public EchoServerHandler() {
echoServerHandler = this;
}
/** /**
* 客户端连接会触发 * 客户端连接会触发
*/ */
@ -137,7 +96,7 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
//log.info("channelRead接收到的数据:" + receiveStr + ",length:" + receiveStr.length()); //log.info("channelRead接收到的数据:" + receiveStr + ",length:" + receiveStr.length());
} }
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); log.error("channelRead异常", e);
} finally { } finally {
ReferenceCountUtil.release(msg); ReferenceCountUtil.release(msg);
} }
@ -156,13 +115,11 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
}else{ }else{
receiveStr = receiveStr.replace("FE", ""); receiveStr = receiveStr.replace("FE", "");
} }
//log.info("channelReadComplete接收到的数据: ===> " + receiveStr+",长度:"+receiveStr.length());
log.info("channelReadComplete接收到的数据长度: ===> "+receiveStr.length()); log.info("channelReadComplete接收到的数据长度: ===> "+receiveStr.length());
//心跳包处理 //心跳包处理
if ((count == 0) && (receiveStr.length() == 8) && receiveStr.substring(0, 2).equals("24")) { if ((receiveStr.length() == 8) && receiveStr.startsWith("24")) {
log.info("接收到心跳包 ===> " + receiveStr); log.info("接收到心跳包 ===> " + receiveStr);
idleCount = 1; idleCount = 1;
count = 1;
port=receiveStr.substring(4,8);//心跳包包含网关端口（自己定义返回心跳包） port=receiveStr.substring(4,8);//心跳包包含网关端口（自己定义返回心跳包）
// 清空receiveStr // 清空receiveStr
receiveStr = ""; receiveStr = "";
@ -183,7 +140,6 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
SendOrderUtils.sendAllOrder(deviceCodeParamList.get(num),ctx,num,size); SendOrderUtils.sendAllOrder(deviceCodeParamList.get(num),ctx,num,size);
idleCount++; idleCount++;
}else{ }else{
System.out.println("close this channel!");
ctx.channel().close(); ctx.channel().close();
} }
}else{ }else{
@ -192,7 +148,6 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
} else if (receiveStr.length() == 36 || receiveStr.length() == 40 || receiveStr.length() == 44 || receiveStr.length() == 50) { } else if (receiveStr.length() == 36 || receiveStr.length() == 40 || receiveStr.length() == 44 || receiveStr.length() == 50) {
//电表返回数据解析 //电表返回数据解析
idleCount=1; idleCount=1;
// log.info("meter receive message ===> " + receiveStr+",length:"+receiveStr.length());
log.info("电表接收===> " + receiveStr+",长度:"+receiveStr.length()); log.info("电表接收===> " + receiveStr+",长度:"+receiveStr.length());
//解析采集的报文，并保存到数据库 //解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
@ -223,7 +178,6 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
} else if (receiveStr.length() == 18) { } else if (receiveStr.length() == 18) {
//冷量计返回数据解析 //冷量计返回数据解析
idleCount=1; idleCount=1;
// log.info("cloud receive message ===>" + receiveStr+",length:"+receiveStr.length());
log.info("冷量计接收==>" + receiveStr+",长度:"+receiveStr.length()); log.info("冷量计接收==>" + receiveStr+",长度:"+receiveStr.length());
// 解析采集的报文，并保存到数据库 // 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
@ -254,11 +208,10 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
}else if (receiveStr.length() == 12 || receiveStr.length() == 14) { }else if (receiveStr.length() == 12 || receiveStr.length() == 14) {
//冷水机返回数据解析 //冷水机返回数据解析
idleCount=1; idleCount=1;
// log.info("chiller receive message ===>" + receiveStr+",length:"+receiveStr.length());
log.info("冷水机接收===>" + receiveStr+",长度:"+receiveStr.length()); log.info("冷水机接收===>" + receiveStr+",长度:"+receiveStr.length());
// 解析采集的报文，并保存到数据库 // 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
analysisReceiveOrder485.analysisChillerOrder485(receiveStr,deviceCodeParamList.get(0)); analysisReceiveOrder485.analysisChillerOrder485(receiveStr,deviceCodeParamList.get(num));
// 清空receiveStr // 清空receiveStr
receiveStr = ""; receiveStr = "";
// 判断发送的下标，如果不等于指令数组大小 // 判断发送的下标，如果不等于指令数组大小
@ -307,259 +260,201 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
SendOrderUtils.sendAllOrder(deviceCodeParamList.get(num),ctx,num,size); SendOrderUtils.sendAllOrder(deviceCodeParamList.get(num),ctx,num,size);
} }
} }
}else if (receiveStr.length() >= 100 ){ }
if (receiveStr.substring(0,2).equalsIgnoreCase("2b") && receiveStr.substring(6,8).equalsIgnoreCase("7b")){ // else if (receiveStr.length() >= 100 ){
receiveStr=receiveStr.substring(6); // whiteGateway(ctx);
} // }
receiveStr=ExchangeStringUtil.hexStringToString(receiveStr) ; else {
// log.info("white gateway receive message ===> " + receiveStr); receiveStr = null;
log.info("白色网关接收===> " + receiveStr); }
JSONObject jsonObject = JSONObject.parseObject(receiveStr); ctx.flush();
receiveStr=""; }
port=jsonObject.getString("snr"); //网关ID,从心跳包中获得
IP=jsonObject.getString("ip"); //ip private void whiteGateway(ChannelHandlerContext ctx) throws InterruptedException {
String cmd=jsonObject.getString("cmd"); //指令模式dHeartbeat（心跳包）,data（主动采集返回）,reword if (receiveStr.substring(0,2).equalsIgnoreCase("2b") && receiveStr.substring(6,8).equalsIgnoreCase("7b")){
String name=jsonObject.getString("name"); receiveStr=receiveStr.substring(6);
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); }
Date date = new Date(); receiveStr=ExchangeStringUtil.hexStringToString(receiveStr) ;
String time = sdf1.format(date); log.info("白色网关接收===> " + receiveStr);
if(cmd.equals("dHeartbeat")){ JSONObject jsonObject = JSONObject.parseObject(receiveStr);
JSONObject jsonHeart=new JSONObject(); receiveStr="";
jsonHeart.put("snr",port); port=jsonObject.getString("snr"); //网关ID,从心跳包中获得
jsonHeart.put("cmd","uHeartbeat"); IP=jsonObject.getString("ip"); //ip
jsonHeart.put("recordCheckTime","30"); String cmd=jsonObject.getString("cmd"); //指令模式dHeartbeat（心跳包）,data（主动采集返回）,reword
jsonHeart.put("keepAliveTime","50"); //通讯保持在线间隔,秒80 String name=jsonObject.getString("name");
jsonHeart.put("resetTime","23:59:59"); SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
jsonHeart.put("ip",IP); Date date = new Date();
jsonHeart.put("time",time); String time = sdf1.format(date);
jsonHeart.put("name",name); if(cmd.equals("dHeartbeat")){
jsonHeart.put("heartInterval","20");//网关发起心跳包的时间间隔,秒70 JSONObject jsonHeart=new JSONObject();
jsonHeart.put("recordMode","cover"); jsonHeart.put("snr",port);
// String sendStr=jsonHeart.toJSONString(); jsonHeart.put("cmd","uHeartbeat");
String sendStr=jsonHeart.toString(); jsonHeart.put("recordCheckTime","30");
// log.info("white gateway reply dHeartbeat ===>" + sendStr); jsonHeart.put("keepAliveTime","50"); //通讯保持在线间隔,秒80
log.info("白色网关回复收到心跳包===>" + sendStr); jsonHeart.put("resetTime","23:59:59");
sendStr=ExchangeStringUtil.strTo16(sendStr); jsonHeart.put("ip",IP);
ByteBuf buffer = ExchangeStringUtil.getByteBuf(ctx, sendStr); jsonHeart.put("time",time);
Thread.sleep(200); jsonHeart.put("name",name);
ctx.channel().writeAndFlush(buffer); //发送数据 jsonHeart.put("heartInterval","20");//网关发起心跳包的时间间隔,秒70
// ctx.channel().writeAndFlush(sendStr); jsonHeart.put("recordMode","cover");
// ctx.channel().writeAndFlush(jsonHeart); String sendStr=jsonHeart.toString();
// 更新对应的网关在线情况 log.info("白色网关回复收到心跳包===>" + sendStr);
gatewayManageService.updateGatewayManage2(port); sendStr=ExchangeStringUtil.strTo16(sendStr);
// 生成采集指令 ByteBuf buffer = ExchangeStringUtil.getByteBuf(ctx, sendStr);
deviceCodeParamList = deviceCodeParamService.queryCodeParam(port); //心跳包包含网关端口（自己定义返回心跳包） Thread.sleep(200);
size = deviceCodeParamList.size(); ctx.channel().writeAndFlush(buffer); //发送数据
// log.info("white gateway receive message size ===> " + size); // 更新对应的网关在线情况
log.info("白色网关接收长度===> " + size); gatewayManageService.updateGatewayManage2(port);
num = 0; // 生成采集指令
// 发送采集报文 deviceCodeParamList = deviceCodeParamService.queryCodeParam(port); //心跳包包含网关端口（自己定义返回心跳包）
if (size>0) { size = deviceCodeParamList.size();
if (idleCount<2){ log.info("白色网关接收长度===> " + size);
Thread.sleep(200); num = 0;
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size); // 发送采集报文
idleCount++; if (size>0) {
}else{ if (idleCount<2){
System.out.println("close this channel!"); Thread.sleep(200);
ctx.channel().close(); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
} idleCount++;
}else{ }else{
log.info("white gateway not find deviceCodeParam!" ); System.out.println("close this channel!");
ctx.channel().close();
} }
}else{ }else{
idleCount=1; log.info("white gateway not find deviceCodeParam!" );
String data=jsonObject.getString("data"); }
String strHex=ExchangeStringUtil.base64ToHex(data); }else{
//返回值全部变成大写 idleCount=1;
strHex= strHex.toUpperCase(); String data=jsonObject.getString("data");
//截取去掉FE String strHex=ExchangeStringUtil.base64ToHex(data);
String dataStr; //返回值全部变成大写
if (strHex.length()>8){ strHex= strHex.toUpperCase();
String str1=strHex.substring(0,8); //截取去掉FE
String str2=strHex.substring(8); String dataStr;
dataStr=str1.replace("FE", "")+str2; if (strHex.length()>8){
}else{ String str1=strHex.substring(0,8);
dataStr = strHex.replace("FE", ""); String str2=strHex.substring(8);
} dataStr=str1.replace("FE", "")+str2;
if (dataStr.length() == 36 || dataStr.length() == 40 || dataStr.length() == 44 || dataStr.length() == 50){ }else{
// log.info("white gateway meter receive message ===>" + dataStr); dataStr = strHex.replace("FE", "");
log.info("白色网关电表接收===>" + dataStr); }
//deviceCodeParamList = deviceCodeParamService.queryCodeParam("2019060600007"); //心跳包包含网关端口（自己定义返回心跳包） if (dataStr.length() == 36 || dataStr.length() == 40 || dataStr.length() == 44 || dataStr.length() == 50){
// 解析采集的报文，并保存到数据库 log.info("白色网关电表接收===>" + dataStr);
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); // 解析采集的报文，并保存到数据库
analysisReceiveOrder485.analysisMeterOrder485(dataStr,deviceCodeParamList.get(num)); //电表报文解析 AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
// try{ analysisReceiveOrder485.analysisMeterOrder485(dataStr,deviceCodeParamList.get(num)); //电表报文解析
// queueParam.setDeviceType(deviceCodeParamList.get(num).getDeviceType()); // 清空dataStr
// queueParam.setProjectID(deviceCodeParamList.get(num).getProjectID()); // 判断发送的下标，如果不等于指令数组大小
// queueParam.setRegisterAddr(deviceCodeParamList.get(num).getRegisterAddr()); num = num + 1;
// queueParam.setRecData(dataStr); if (num > size - 1) {
// queueParam.setCopyTime(time); num = 0;
// analysisReceiveOrder485.sendQueue(queueParam); //发送到队列 Thread.sleep(200);
// log.info("发送消息到队列！！"); // 继续发送下一个采集指令
// }catch (Exception e){ SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
// e.printStackTrace(); System.out.println("------一轮采集完成,继续下一轮--------");
// } } else {
// 清空dataStr // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
dataStr = ""; if (Constant.WEB_FLAG) {
// 判断发送的下标，如果不等于指令数组大小
num = num + 1;
if (num > size - 1) {
// for (int j=0;j<100;j++){
// Thread.sleep(1000);
// Date date2=new Date();
// System.out.println("------时间--------"+sdf1.format(date2));
// if (ExchangeStringUtil.isInDate(date2,"00:00:00","00:00:05")==true ||
// ExchangeStringUtil.isInDate(date2,"00:00:20","00:00:25")==true ||
// ExchangeStringUtil.isInDate(date2,"00:00:40","00:00:45")==true) {
// System.out.println("------时间跳出--------"+sdf1.format(date2));
// break;
// }
// }
num = 0; num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200); Thread.sleep(200);
// 继续发送下一个采集指令 // 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
System.out.println("------一轮采集完成,继续下一轮--------");
} else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) {
num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200);
// 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size);
}
} }
}else if(dataStr.length() == 12 || dataStr.length() == 14){ }
// log.info("white gateway chiller receive message ===>" + dataStr); }else if(dataStr.length() == 12 || dataStr.length() == 14){
log.info("白色网关冷水机接收===>" + dataStr); log.info("白色网关冷水机接收===>" + dataStr);
// 解析采集的报文，并保存到数据库 // 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
analysisReceiveOrder485.analysisChillerOrder485(dataStr,deviceCodeParamList.get(0)); analysisReceiveOrder485.analysisChillerOrder485(dataStr,deviceCodeParamList.get(0));
// 清空dataStr // 清空dataStr
dataStr = ""; dataStr = "";
// 判断发送的下标，如果不等于指令数组大小 // 判断发送的下标，如果不等于指令数组大小
num = num + 1; num = num + 1;
if (num > size - 1) { if (num > size - 1) {
// for (int j=0;j<100;j++){ num = 0;
// Thread.sleep(1000); Thread.sleep(200);
// Date date2=new Date(); // 继续发送下一个采集指令
// System.out.println("------时间--------"+sdf1.format(date2)); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
// if (ExchangeStringUtil.isInDate(date2,"00:00:00","00:00:05")==true || System.out.println("------一轮采集完成,继续下一轮--------");
// ExchangeStringUtil.isInDate(date2,"00:00:20","00:00:25")==true || } else {
// ExchangeStringUtil.isInDate(date2,"00:00:40","00:00:45")==true) { // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
// System.out.println("------时间跳出--------"+sdf1.format(date2)); if (Constant.WEB_FLAG) {
// break; log.info("not send code and close collection!");
// }
// }
num = 0; num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200); Thread.sleep(200);
// 继续发送下一个采集指令 // 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
System.out.println("------一轮采集完成,继续下一轮--------");
} else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) {
log.info("not send code and close collection!");
num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200);
// 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size);
}
} }
}else if(dataStr.length() == 18){ }
}else if(dataStr.length() == 18){
// log.info("white gateway cloud receive message ===> " + dataStr); // log.info("white gateway cloud receive message ===> " + dataStr);
log.info("白色网关冷量计接收===> " + dataStr); log.info("白色网关冷量计接收===> " + dataStr);
// 解析采集的报文，并保存到数据库 // 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); //冷量机报文解析 AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); //冷量机报文解析
analysisReceiveOrder485.analysisCloudOrder485(dataStr,deviceCodeParamList.get(num) ); analysisReceiveOrder485.analysisCloudOrder485(dataStr,deviceCodeParamList.get(num) );
// try{ // 清空dataStr
// queueParam.setDeviceType(deviceCodeParamList.get(num).getDeviceType()); dataStr = "";
// queueParam.setProjectID(deviceCodeParamList.get(num).getProjectID()); // 判断发送的下标，如果不等于指令数组大小
// queueParam.setRegisterAddr(deviceCodeParamList.get(num).getRegisterAddr()); num = num + 1;
// queueParam.setRecData(dataStr); if (num > size - 1) {
// queueParam.setCopyTime(time); num = 0;
// analysisReceiveOrder485.sendQueue(queueParam); //发送到队列 Thread.sleep(200);
// }catch (Exception e){ // 继续发送下一个采集指令
// e.printStackTrace(); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
// } System.out.println("------一轮采集完成,继续下一轮--------");
// 清空dataStr } else {
dataStr = ""; // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
// 判断发送的下标，如果不等于指令数组大小 if (Constant.WEB_FLAG) {
num = num + 1; log.info("not send code and close collection!");
if (num > size - 1) {
// for (int j=0;j<100;j++){
// Thread.sleep(1000);
// Date date2=new Date();
// System.out.println("------时间--------"+sdf1.format(date2));
// if (ExchangeStringUtil.isInDate(date2,"00:00:00","00:00:05")==true ||
// ExchangeStringUtil.isInDate(date2,"00:00:20","00:00:25")==true ||
// ExchangeStringUtil.isInDate(date2,"00:00:40","00:00:45")==true) {
//
// System.out.println("------时间跳出--------"+sdf1.format(date2));
// break;
// }
// }
num = 0; num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200); Thread.sleep(200);
// 继续发送下一个采集指令 // 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
System.out.println("------一轮采集完成,继续下一轮--------");
} else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) {
log.info("not send code and close collection!");
num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200);
// 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size);
}
} }
}else { //if(dataStr.length() > 50) }
// 清空dataStr }else { //if(dataStr.length() > 50)
dataStr = null; // 清空dataStr
// 判断发送的下标,如果不等于指令数组大小 dataStr = null;
num = num + 1; // 判断发送的下标,如果不等于指令数组大小
if (num > size - 1) { num = num + 1;
if (num > size - 1) {
num = 0;
Thread.sleep(200);
// 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
System.out.println("------一轮采集完成,继续下一轮--------");
} else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) {
num = 0; num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200); Thread.sleep(200);
// 继续发送下一个采集指令 // 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size); SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num), ctx,port,IP,num,size);
System.out.println("------一轮采集完成,继续下一轮--------");
} else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) {
num = 0;
// 关闭连接
dataStr = null;
ctx.close();
} else {
Thread.sleep(200);
// 继续发送下一个采集指令
SendOrderUtils.sendAllOrder2(deviceCodeParamList.get(num),ctx,port,IP,num,size);
}
} }
} }
} }
} }
ctx.flush();
} }
// 异常捕捉 // 异常捕捉
@Override @Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
//cause.printStackTrace(); // 打印异常
ctx.close(); // 关闭该Channel ctx.close(); // 关闭该Channel
log.info("异常捕捉,执行ctx.close()......"); log.info("异常捕捉,执行ctx.close()......");
} }
@ -567,7 +462,6 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
// 客户端断开 // 客户端断开
@Override @Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception { public void channelInactive(ChannelHandlerContext ctx) throws Exception {
//super.channelInactive(ctx);
ctx.close();// 关闭流 ctx.close();// 关闭流
log.info("客户端断开,执行ctx.close()......"); log.info("客户端断开,执行ctx.close()......");
} }

186
user-service/src/main/java/com/mh/user/netty/NettyChillerClient.java
Unescape View File

@ -1,95 +1,95 @@
package com.mh.user.netty; //package com.mh.user.netty;
//
import io.netty.bootstrap.Bootstrap; //import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*; //import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup; //import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel; //import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel; //import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.timeout.IdleStateHandler; //import io.netty.handler.timeout.IdleStateHandler;
import io.netty.handler.timeout.ReadTimeoutHandler; //import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler; //import io.netty.handler.timeout.WriteTimeoutHandler;
import lombok.Getter; //import lombok.Getter;
import lombok.Setter; //import lombok.Setter;
import lombok.extern.slf4j.Slf4j; //import lombok.extern.slf4j.Slf4j;
//
import java.util.concurrent.TimeUnit; //import java.util.concurrent.TimeUnit;
//
/** ///**
* @author ljf // * @author ljf
* @title ： // * @title ：
* @description ：Netty冷水机组客户端 // * @description ：Netty冷水机组客户端
* @updateTime 2020-05-13 // * @updateTime 2020-05-13
* @throws ： // * @throws ：
*/ // */
@Slf4j //@Slf4j
@Setter //@Setter
@Getter //@Getter
public class NettyChillerClient { //public class NettyChillerClient {
//
private volatile static NettyChillerDDCClient nettyChillerDDCClient = new NettyChillerDDCClient(); // private volatile static NettyChillerDDCClient nettyChillerDDCClient = new NettyChillerDDCClient();
//
private int port; // private int port;
private String host; // private String host;
//
// 构造函数传递值 继承Thread时需要 // // 构造函数传递值 继承Thread时需要
// public NettyClient(int port, String host) { //// public NettyClient(int port, String host) {
// this.port = port; //// this.port = port;
// this.host = host; //// this.host = host;
// } //// }
//
public static void connect(int port, String host) throws InterruptedException { // public static void connect(int port, String host) throws InterruptedException {
// 配置客户端NIO线程组 // // 配置客户端NIO线程组
EventLoopGroup group = new NioEventLoopGroup(1); // EventLoopGroup group = new NioEventLoopGroup(1);
try { // try {
Bootstrap bootstrap = new Bootstrap(); // Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group).channel(NioSocketChannel.class) // bootstrap.group(group).channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true) // .option(ChannelOption.TCP_NODELAY, true)
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000) // .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
.option(ChannelOption.RCVBUF_ALLOCATOR, new FixedRecvByteBufAllocator(1024*1024)) // .option(ChannelOption.RCVBUF_ALLOCATOR, new FixedRecvByteBufAllocator(1024*1024))
.handler(new ChannelInitializer<SocketChannel>() { // .handler(new ChannelInitializer<SocketChannel>() {
@Override // @Override
protected void initChannel(SocketChannel socketChannel) { // protected void initChannel(SocketChannel socketChannel) {
// 基于换行符号 // // 基于换行符号
// socketChannel.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,4,4,-8,0)); //// socketChannel.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,4,4,-8,0));
// // 解码转String，注意调整自己的编码格式GBK、UTF-8 //// // 解码转String，注意调整自己的编码格式GBK、UTF-8
// socketChannel.pipeline().addLast(new StringDecoder(StandardCharsets.UTF_8)); //// socketChannel.pipeline().addLast(new StringDecoder(StandardCharsets.UTF_8));
// // 解码转String，注意调整自己的编码格式GBK、UTF-8 //// // 解码转String，注意调整自己的编码格式GBK、UTF-8
// socketChannel.pipeline().addLast(new StringEncoder(StandardCharsets.UTF_8)); //// socketChannel.pipeline().addLast(new StringEncoder(StandardCharsets.UTF_8));
// socketChannel.pipeline().addLast(new LengthFieldPrepender(4)); //// socketChannel.pipeline().addLast(new LengthFieldPrepender(4));
socketChannel.pipeline().addLast(new IdleStateHandler(10,10,10, TimeUnit.SECONDS)); // socketChannel.pipeline().addLast(new IdleStateHandler(10,10,10, TimeUnit.SECONDS));
// 在管道中添加我们自己的接收数据实现方法 // // 在管道中添加我们自己的接收数据实现方法
socketChannel.pipeline().addLast(new NettyChillerClientHandler()); // socketChannel.pipeline().addLast(new NettyChillerClientHandler());
// socketChannel.pipeline().addLast(new NettyMeterClientHandler()); //// socketChannel.pipeline().addLast(new NettyMeterClientHandler());
} // }
}); // });
// 发起异步连接操作 // // 发起异步连接操作
ChannelFuture channelFuture = bootstrap.connect(host, port).sync(); // ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
if (channelFuture.isSuccess()) { // if (channelFuture.isSuccess()) {
log.info("connect server 成功---------"); // log.info("connect server 成功---------");
} else { // } else {
log.info("连接失败！"); // log.info("连接失败！");
log.info("准备重连！"); // log.info("准备重连！");
// connect(port, host); //// connect(port, host);
}
// 等待客户端连接链路关闭future.channel().closeFuture().sync(); // 阻塞main线程
channelFuture.channel().closeFuture().sync();
} catch (Exception e) {
log.error("error>>>>>>" + e.getMessage());
} finally {
group.shutdownGracefully();
// try {
// TimeUnit.SECONDS.sleep(5);
// connect(port, host); // 断线重连
// } catch (InterruptedException e) {
// e.printStackTrace();
// } // }
} //
} // // 等待客户端连接链路关闭future.channel().closeFuture().sync(); // 阻塞main线程
// channelFuture.channel().closeFuture().sync();
// @SneakyThrows // } catch (Exception e) {
// @Override // log.error("error>>>>>>" + e.getMessage());
// public void run() { // } finally {
// connect(port, host); // group.shutdownGracefully();
//// try {
//// TimeUnit.SECONDS.sleep(5);
//// connect(port, host); // 断线重连
//// } catch (InterruptedException e) {
//// e.printStackTrace();
//// }
// }
// } // }
} //
//// @SneakyThrows
//// @Override
//// public void run() {
//// connect(port, host);
//// }
//}

630
user-service/src/main/java/com/mh/user/netty/NettyChillerClientHandler.java
Unescape View File

@ -1,315 +1,315 @@
package com.mh.user.netty; //package com.mh.user.netty;
//
import com.mh.user.constants.Constant; //import com.mh.user.constants.Constant;
import com.mh.user.entity.ChillersEntity; //import com.mh.user.entity.ChillersEntity;
import com.mh.user.entity.DeviceCodeParamEntity; //import com.mh.user.entity.DeviceCodeParamEntity;
import com.mh.user.service.DeviceCodeParamService; //import com.mh.user.service.DeviceCodeParamService;
import com.mh.user.service.chillers.ChillersService; //import com.mh.user.service.chillers.ChillersService;
import com.mh.user.service.chillers.GatewayManageService; //import com.mh.user.service.chillers.GatewayManageService;
import com.mh.user.utils.AnalysisReceiveOrder485; //import com.mh.user.utils.AnalysisReceiveOrder485;
import com.mh.user.utils.ExchangeStringUtil; //import com.mh.user.utils.ExchangeStringUtil;
import com.mh.user.utils.GetReadOrder485; //import com.mh.user.utils.GetReadOrder485;
import com.mh.user.utils.SpringBeanUtil; //import com.mh.user.utils.SpringBeanUtil;
import io.netty.buffer.ByteBuf; //import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel; //import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerAdapter; //import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext; //import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.timeout.IdleState; //import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent; //import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.ReferenceCountUtil; //import io.netty.util.ReferenceCountUtil;
import lombok.extern.slf4j.Slf4j; //import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext; //import org.springframework.context.ApplicationContext;
//
import java.text.SimpleDateFormat; //import java.text.SimpleDateFormat;
import java.util.Date; //import java.util.Date;
import java.util.List; //import java.util.List;
//
/** ///**
* @author ljf // * @author ljf
* @title ： // * @title ：
* @description ：客户端异步消息处理机制，采集冷水机组 // * @description ：客户端异步消息处理机制，采集冷水机组
* @updateTime 2020-05-13 // * @updateTime 2020-05-13
* @throws ： // * @throws ：
*/ // */
@Slf4j //@Slf4j
public class NettyChillerClientHandler extends ChannelHandlerAdapter { //public class NettyChillerClientHandler extends ChannelHandlerAdapter {
//
private int num = 0; // private int num = 0;
private int size = 0; // private int size = 0;
private int idle_count = 0; // private int idle_count = 0;
private String receiveStr = ""; // private String receiveStr = "";
List<DeviceCodeParamEntity> deviceCodeParamList; // List<DeviceCodeParamEntity> deviceCodeParamList;
//
// 调用service // // 调用service
ApplicationContext context = SpringBeanUtil.getApplicationContext(); // ApplicationContext context = SpringBeanUtil.getApplicationContext();
DeviceCodeParamService deviceCodeParamService = context.getBean(DeviceCodeParamService.class); // DeviceCodeParamService deviceCodeParamService = context.getBean(DeviceCodeParamService.class);
GatewayManageService gatewayManageService = context.getBean(GatewayManageService.class); // GatewayManageService gatewayManageService = context.getBean(GatewayManageService.class);
//
/** // /**
* 超时处理 // * 超时处理
* 如果120秒没有接受客户端的心跳，就触发; // * 如果120秒没有接受客户端的心跳，就触发;
* 如果超过3次，则直接关闭; // * 如果超过3次，则直接关闭;
*/ // */
@Override // @Override
public void userEventTriggered(ChannelHandlerContext ctx, Object obj) throws Exception { // public void userEventTriggered(ChannelHandlerContext ctx, Object obj) throws Exception {
if (obj instanceof IdleStateEvent) { // if (obj instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) obj; // IdleStateEvent event = (IdleStateEvent) obj;
if (IdleState.READER_IDLE.equals(event.state())) { //如果读通道处于空闲状态，说明没有接收到心跳命令 // if (IdleState.READER_IDLE.equals(event.state())) { //如果读通道处于空闲状态，说明没有接收到心跳命令
System.out.println("第" + idle_count + "已经10秒没有接收到服务器的信息了,发送第" + num + "条数据"); // System.out.println("第" + idle_count + "已经10秒没有接收到服务器的信息了,发送第" + num + "条数据");
if (deviceCodeParamList.get(num) == null) { // if (deviceCodeParamList.get(num) == null) {
System.out.println("关闭这个不活跃的channel"); // System.out.println("关闭这个不活跃的channel");
ctx.channel().close(); // ctx.channel().close();
} else { // } else {
if ((num > size - 1) || (idle_count > 3)) { // if ((num > size - 1) || (idle_count > 3)) {
System.out.println("关闭这个不活跃的channel"); // System.out.println("关闭这个不活跃的channel");
ctx.channel().close(); // ctx.channel().close();
} // }
GetReadOrder485 getReadOrder485 = new GetReadOrder485(); // GetReadOrder485 getReadOrder485 = new GetReadOrder485();
String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num)); // String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num));
ctx.channel().writeAndFlush(ExchangeStringUtil.getByteBuf(ctx, sendStr)); // ctx.channel().writeAndFlush(ExchangeStringUtil.getByteBuf(ctx, sendStr));
idle_count++; // idle_count++;
} // }
} // }
} else { // } else {
super.userEventTriggered(ctx, obj); // super.userEventTriggered(ctx, obj);
} // }
} // }
//
@Override // @Override
public void channelUnregistered(ChannelHandlerContext ctx) throws Exception { // public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
log.info("当前channel从EventLoop取消注册"); // log.info("当前channel从EventLoop取消注册");
ctx.close(); // ctx.close();
super.channelUnregistered(ctx); // super.channelUnregistered(ctx);
} // }
//
@Override // @Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { // public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
// super.exceptionCaught(ctx, cause); //// super.exceptionCaught(ctx, cause);
log.info("通信异常！！"); // log.info("通信异常！！");
// // 发送采集冷水机组指令 //// // 发送采集冷水机组指令
// GetReadOrder485 getReadOrder485 = new GetReadOrder485(); //// GetReadOrder485 getReadOrder485 = new GetReadOrder485();
// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num)); //// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num));
// // 获取采集参数个数 //// // 获取采集参数个数
// ByteBuf buffer = getByteBuf(ctx, sendStr); //// ByteBuf buffer = getByteBuf(ctx, sendStr);
// // 2.发送数据 //// // 2.发送数据
// ctx.channel().writeAndFlush(buffer); //// ctx.channel().writeAndFlush(buffer);
// receiveStr = null; //// receiveStr = null;
cause.printStackTrace(); // cause.printStackTrace();
ctx.close(); // ctx.close();
// Channel incoming = ctx.channel(); //// Channel incoming = ctx.channel();
// if (incoming.isActive()) { //// if (incoming.isActive()) {
// log.info("SimpleClient: " + incoming.remoteAddress() + "异常"); //// log.info("SimpleClient: " + incoming.remoteAddress() + "异常");
// cause.printStackTrace(); //// cause.printStackTrace();
// ctx.close(); //// ctx.close();
// receiveStr = null; //// receiveStr = null;
// try { //// try {
// TimeUnit.SECONDS.sleep(5); //// TimeUnit.SECONDS.sleep(5);
// SocketAddress remoteAddress = ctx.channel().remoteAddress(); //// SocketAddress remoteAddress = ctx.channel().remoteAddress();
// String port = ExchangeStringUtil.endData(remoteAddress.toString(),":"); //// String port = ExchangeStringUtil.endData(remoteAddress.toString(),":");
// String host = ExchangeStringUtil.splitData(remoteAddress.toString(),"/",":"); //// String host = ExchangeStringUtil.splitData(remoteAddress.toString(),"/",":");
// NettyClient nettyClient = new NettyClient(); //// NettyClient nettyClient = new NettyClient();
// nettyClient.connect(Integer.parseInt(port), host); // 断线重连 //// nettyClient.connect(Integer.parseInt(port), host); // 断线重连
// } catch (InterruptedException e) { //// } catch (InterruptedException e) {
// e.printStackTrace(); //// e.printStackTrace();
// } //// }
// } //// }
} // }
//
//
@Override // @Override
public void channelActive(ChannelHandlerContext ctx) throws Exception { // public void channelActive(ChannelHandlerContext ctx) throws Exception {
super.channelActive(ctx); // super.channelActive(ctx);
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07 // // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) { // if (Constant.WEB_FLAG) {
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
} else { // } else {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss"); // SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
Date date = new Date(); // Date date = new Date();
log.info(ctx.channel().remoteAddress() + " " + sdf1.format(date) + "链接服务端成功！"); // log.info(ctx.channel().remoteAddress() + " " + sdf1.format(date) + "链接服务端成功！");
// 截取IP地址 // // 截取IP地址
String IP = ExchangeStringUtil.getMidString(ctx.channel().remoteAddress() + "", "/", ":"); // String IP = ExchangeStringUtil.getMidString(ctx.channel().remoteAddress() + "", "/", ":");
// 截取端口号 // // 截取端口号
String port = ExchangeStringUtil.getMidString(ctx.channel().remoteAddress() + "", ":", ""); // String port = ExchangeStringUtil.getMidString(ctx.channel().remoteAddress() + "", ":", "");
log.info("IP: " + IP + ",端口号： " + port); // log.info("IP: " + IP + ",端口号： " + port);
// 更新对应的网关在线情况 // // 更新对应的网关在线情况
gatewayManageService.updateGatewayManage(IP, port); // gatewayManageService.updateGatewayManage(IP, port);
// 生成采集指令 // // 生成采集指令
deviceCodeParamList = deviceCodeParamService.queryCodeParam(port); // deviceCodeParamList = deviceCodeParamService.queryCodeParam(port);
size = deviceCodeParamList.size(); // size = deviceCodeParamList.size();
//
// 发送采集冷水机组指令 // // 发送采集冷水机组指令
GetReadOrder485 getReadOrder485 = new GetReadOrder485(); // GetReadOrder485 getReadOrder485 = new GetReadOrder485();
String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num)); // String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num));
// 获取采集参数个数 // // 获取采集参数个数
ByteBuf buffer = getByteBuf(ctx, sendStr); // ByteBuf buffer = getByteBuf(ctx, sendStr);
// 发送数据 // // 发送数据
ctx.channel().writeAndFlush(buffer); // ctx.channel().writeAndFlush(buffer);
} // }
} // }
//
private ByteBuf getByteBuf(ChannelHandlerContext ctx, String sendStr) { // private ByteBuf getByteBuf(ChannelHandlerContext ctx, String sendStr) {
// byte类型的数据 // // byte类型的数据
// byte[] bytes = "这里是将要写往服务端的数据".getBytes(Charset.forName("utf-8")); //// byte[] bytes = "这里是将要写往服务端的数据".getBytes(Charset.forName("utf-8"));
// String sendStr = "5803004900021914"; // 冷量计 //// String sendStr = "5803004900021914"; // 冷量计
// 申请一个数据结构存储信息 // // 申请一个数据结构存储信息
ByteBuf buffer = ctx.alloc().buffer(); // ByteBuf buffer = ctx.alloc().buffer();
// 将信息放入数据结构中 // // 将信息放入数据结构中
buffer.writeBytes(ExchangeStringUtil.hexStrToBinaryStr(sendStr));//对接需要16进制 // buffer.writeBytes(ExchangeStringUtil.hexStrToBinaryStr(sendStr));//对接需要16进制
return buffer; // return buffer;
} // }
//
@Override // @Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception { // public void channelInactive(ChannelHandlerContext ctx) throws Exception {
Thread.sleep(100); // Thread.sleep(100);
ctx.close(); // ctx.close();
log.info(ctx.channel().localAddress() + "退出链接！！"); // log.info(ctx.channel().localAddress() + "退出链接！！");
} // }
//
@Override // @Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
try { // try {
ByteBuf buf = (ByteBuf) msg; // ByteBuf buf = (ByteBuf) msg;
byte[] bytes = new byte[buf.readableBytes()]; // byte[] bytes = new byte[buf.readableBytes()];
buf.readBytes(bytes);//复制内容到字节数组bytes // buf.readBytes(bytes);//复制内容到字节数组bytes
buf.clear(); // buf.clear();
log.info("获取到的值： " + ExchangeStringUtil.bytesToHexString(bytes)); // log.info("获取到的值： " + ExchangeStringUtil.bytesToHexString(bytes));
if (bytes.length <= 36) { // if (bytes.length <= 36) {
// receiveStr = receiveStr.replace("null", ""); //// receiveStr = receiveStr.replace("null", "");
// receiveStr = receiveStr + ExchangeStringUtil.bytesToHexString(bytes);//将接收到的数据转为字符串，此字符串就是客户端发送的字符串 //// receiveStr = receiveStr + ExchangeStringUtil.bytesToHexString(bytes);//将接收到的数据转为字符串，此字符串就是客户端发送的字符串
// log.info(ctx.channel().remoteAddress() + " " + ctx.channel().localAddress() + " 接受服务器数据：" + receiveStr + "，大小： " + receiveStr.length()); //// log.info(ctx.channel().remoteAddress() + " " + ctx.channel().localAddress() + " 接受服务器数据：" + receiveStr + "，大小： " + receiveStr.length());
receiveStr = receiveStr + ExchangeStringUtil.bytesToHexString(bytes);//将接收到的数据转为字符串，此字符串就是客户端发送的字符串 // receiveStr = receiveStr + ExchangeStringUtil.bytesToHexString(bytes);//将接收到的数据转为字符串，此字符串就是客户端发送的字符串
receiveStr = receiveStr.replace("null", ""); // receiveStr = receiveStr.replace("null", "");
log.info("接受服务器数据：" + receiveStr + "，大小： " + receiveStr.length()); // log.info("接受服务器数据：" + receiveStr + "，大小： " + receiveStr.length());
} // }
} catch (Exception e) { // } catch (Exception e) {
e.printStackTrace(); // e.printStackTrace();
} finally { // } finally {
ReferenceCountUtil.release(msg); // ReferenceCountUtil.release(msg);
} // }
} // }
//
@Override // @Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { // public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
log.info("冷水机组--数据读取接收完成: " + receiveStr); // log.info("冷水机组--数据读取接收完成: " + receiveStr);
if (receiveStr.length() == 30) { // if (receiveStr.length() == 30) {
log.info("采集完整的报文： " + receiveStr); // log.info("采集完整的报文： " + receiveStr);
// 解析采集的报文，并保存到数据库 // // 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); // AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
analysisReceiveOrder485.analysisChillerOrder485(receiveStr,deviceCodeParamList.get(num)); // analysisReceiveOrder485.analysisChillerOrder485(receiveStr,deviceCodeParamList.get(num));
// 清空receiveStr // // 清空receiveStr
receiveStr = ""; // receiveStr = "";
// 判断发送的下标，如果不等于指令数组大小 // // 判断发送的下标，如果不等于指令数组大小
num = num + 1; // num = num + 1;
if (num > size - 1) { // if (num > size - 1) {
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
// // 继续发送下一个采集冷水机设备指令 //// // 继续发送下一个采集冷水机设备指令
// GetReadOrder485 getReadOrder485 = new GetReadOrder485(); //// GetReadOrder485 getReadOrder485 = new GetReadOrder485();
// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num)); //// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num));
// ByteBuf buffer = getByteBuf(ctx, sendStr); //// ByteBuf buffer = getByteBuf(ctx, sendStr);
// // 发送数据 //// // 发送数据
// ctx.channel().writeAndFlush(buffer); //// ctx.channel().writeAndFlush(buffer);
// log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size); //// log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size);
} else { // } else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07 // // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) { // if (Constant.WEB_FLAG) {
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
} else { // } else {
Thread.sleep(1000); // Thread.sleep(1000);
// 继续发送下一个采集冷水机设备指令 // // 继续发送下一个采集冷水机设备指令
GetReadOrder485 getReadOrder485 = new GetReadOrder485(); // GetReadOrder485 getReadOrder485 = new GetReadOrder485();
String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num)); // String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num));
ByteBuf buffer = getByteBuf(ctx, sendStr); // ByteBuf buffer = getByteBuf(ctx, sendStr);
// 发送数据 // // 发送数据
ctx.channel().writeAndFlush(buffer); // ctx.channel().writeAndFlush(buffer);
log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size); // log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size);
} // }
} // }
} else if (receiveStr.length() == 32) { // } else if (receiveStr.length() == 32) {
log.info("采集完整的报文： " + receiveStr); // log.info("采集完整的报文： " + receiveStr);
// 解析采集的报文，并保存到数据库 // // 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485(); // AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
analysisReceiveOrder485.analysisChillerOrder485(receiveStr,deviceCodeParamList.get(num)); // analysisReceiveOrder485.analysisChillerOrder485(receiveStr,deviceCodeParamList.get(num));
// 清空receiveStr // // 清空receiveStr
receiveStr = ""; // receiveStr = "";
// 判断发送的下标，如果不等于指令数组大小 // // 判断发送的下标，如果不等于指令数组大小
num = num + 1; // num = num + 1;
if (num > size - 1) { // if (num > size - 1) {
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
// // 继续发送下一个采集冷水机设备指令 //// // 继续发送下一个采集冷水机设备指令
// GetReadOrder485 getReadOrder485 = new GetReadOrder485(); //// GetReadOrder485 getReadOrder485 = new GetReadOrder485();
// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num)); //// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num));
// ByteBuf buffer = getByteBuf(ctx, sendStr); //// ByteBuf buffer = getByteBuf(ctx, sendStr);
// // 发送数据 //// // 发送数据
// ctx.channel().writeAndFlush(buffer); //// ctx.channel().writeAndFlush(buffer);
// log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size); //// log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size);
} else { // } else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07 // // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) { // if (Constant.WEB_FLAG) {
log.info("有指令下发退出定时采集冷水机组参数"); // log.info("有指令下发退出定时采集冷水机组参数");
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
} else { // } else {
Thread.sleep(1000); // Thread.sleep(1000);
// 继续发送下一个采集冷水机设备指令 // // 继续发送下一个采集冷水机设备指令
GetReadOrder485 getReadOrder485 = new GetReadOrder485(); // GetReadOrder485 getReadOrder485 = new GetReadOrder485();
String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num)); // String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num));
ByteBuf buffer = getByteBuf(ctx, sendStr); // ByteBuf buffer = getByteBuf(ctx, sendStr);
// 2.发送数据 // // 2.发送数据
ctx.channel().writeAndFlush(buffer); // ctx.channel().writeAndFlush(buffer);
log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size); // log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size);
} // }
} // }
} else if (receiveStr.length() > 36) { // } else if (receiveStr.length() > 36) {
// 清空receiveStr // // 清空receiveStr
receiveStr = null; // receiveStr = null;
// 判断发送的下标，如果不等于指令数组大小 // // 判断发送的下标，如果不等于指令数组大小
num = num + 1; // num = num + 1;
if (num > size - 1) { // if (num > size - 1) {
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
// // 继续发送下一个采集冷水机设备指令 //// // 继续发送下一个采集冷水机设备指令
// GetReadOrder485 getReadOrder485 = new GetReadOrder485(); //// GetReadOrder485 getReadOrder485 = new GetReadOrder485();
// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num)); //// String sendStr = getReadOrder485.createChillersOrder(chillersEntityList.get(num));
// ByteBuf buffer = getByteBuf(ctx, sendStr); //// ByteBuf buffer = getByteBuf(ctx, sendStr);
// // 发送数据 //// // 发送数据
// ctx.channel().writeAndFlush(buffer); //// ctx.channel().writeAndFlush(buffer);
// log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size); //// log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size);
} else { // } else {
// 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07 // // 添加一个状态值，判断是否继续发送指令 update by ljf on 2020-08-07
if (Constant.WEB_FLAG) { // if (Constant.WEB_FLAG) {
num = 0; // num = 0;
// 关闭连接 // // 关闭连接
receiveStr = null; // receiveStr = null;
ctx.close(); // ctx.close();
} else { // } else {
Thread.sleep(1000); // Thread.sleep(1000);
// 继续发送下一个采集冷水机设备指令 // // 继续发送下一个采集冷水机设备指令
GetReadOrder485 getReadOrder485 = new GetReadOrder485(); // GetReadOrder485 getReadOrder485 = new GetReadOrder485();
String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num)); // String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num));
ByteBuf buffer = getByteBuf(ctx, sendStr); // ByteBuf buffer = getByteBuf(ctx, sendStr);
// 发送数据 // // 发送数据
ctx.channel().writeAndFlush(buffer); // ctx.channel().writeAndFlush(buffer);
log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size); // log.info("客户端再次往服务端发送数据" + num + " 数据条数：" + size);
} // }
} // }
} // }
ctx.flush(); // ctx.flush();
} // }
//
} //}

43
user-service/src/main/java/com/mh/user/service/impl/DataResultServiceImpl.java
Unescape View File

@ -8,6 +8,7 @@ import com.mh.user.mapper.DataResultMapper;
import com.mh.user.mapper.DeviceInstallMapper; import com.mh.user.mapper.DeviceInstallMapper;
import com.mh.user.service.DataResultService; import com.mh.user.service.DataResultService;
import com.mh.user.service.DeviceInstallService; import com.mh.user.service.DeviceInstallService;
import com.mh.user.utils.DateUtil;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -28,10 +29,11 @@ public class DataResultServiceImpl implements DataResultService {
@Autowired @Autowired
DeviceInstallService deviceInstallService; DeviceInstallService deviceInstallService;
private final SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override @Override
public void saveDataResult(DataResultEntity dataResultEntity) { public void saveDataResult(DataResultEntity dataResultEntity) {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{ try{
//获取系统日期 //获取系统日期
Date date=new Date(); Date date=new Date();
@ -135,19 +137,23 @@ public class DataResultServiceImpl implements DataResultService {
//保存流量计用量 //保存流量计用量
@Override @Override
public void saveDataResultCl_bak(DataResultClEntity dataResultClEntity) throws ParseException { public void saveDataResultCl_bak(DataResultClEntity dataResultClEntity) throws ParseException {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{ try{
//获取系统日期 //获取系统日期
Date date=new Date();
if (dataResultClEntity.getCurDate()==null){ if (dataResultClEntity.getCurDate()==null){
Date date=new Date();
dataResultClEntity.setCurDate(date); dataResultClEntity.setCurDate(date);
} }
//从安装表获取设备信息 //从安装表获取设备信息
DeviceInstallEntity deviceInstallEntity=deviceInstallMapper.selectDevice(dataResultClEntity.getDeviceAddr(),dataResultClEntity.getDeviceType(),dataResultClEntity.getProjectID()); DeviceInstallEntity deviceInstallEntity=deviceInstallMapper.selectDevice(dataResultClEntity.getDeviceAddr(),dataResultClEntity.getDeviceType(),dataResultClEntity.getProjectID());
Double lastValue=deviceInstallEntity.getLastValue();
Double curValue=dataResultClEntity.getCurValue();
dataResultClEntity.setRatio(deviceInstallEntity.getRatio()); //倍率 dataResultClEntity.setRatio(deviceInstallEntity.getRatio()); //倍率
dataResultMapper.saveDataResultCl_bak(dataResultClEntity); //插入新的记录 String curDate = DateUtil.dateToString(dataResultClEntity.getCurDate(), "yyyy-MM-dd HH:mm:ss");
String deviceAddr = deviceInstallEntity.getDeviceAddr();
String registerAddr = dataResultClEntity.getRegisterAddr();
String projectID = dataResultClEntity.getProjectID();
int row=dataResultMapper.selectDataResultChBakCount(curDate,deviceAddr,registerAddr,projectID);//无记录
if (row==0){
dataResultMapper.saveDataResultCl_bak(dataResultClEntity); //插入新的记录
}
}catch (Exception e){ }catch (Exception e){
e.printStackTrace(); e.printStackTrace();
@ -161,28 +167,13 @@ public class DataResultServiceImpl implements DataResultService {
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
@Override @Override
public void saveDataResultCh(DataResultChEntity dataResultChEntity) throws ParseException { public void saveDataResultCh(DataResultChEntity dataResultChEntity) throws ParseException {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{ try{
//获取系统日期
Date date=new Date();
if (dataResultChEntity.getCurDate()==null){
// dataResultChEntity.setCurDate(date);
}
//从安装表获取设备信息 //从安装表获取设备信息
// DeviceInstallEntity deviceInstallEntity=deviceInstallMapper.selectDevice(dataResultChEntity.getDeviceAddr(), dataResultChEntity.getDeviceType(), dataResultChEntity.getProjectID());
//
// DataResultChEntity data=new DataResultChEntity();
// data.setDeviceAddr(dataResultChEntity.getDeviceAddr()); //通讯地址
// data.setDeviceType(dataResultChEntity.getDeviceType()); //设备类型
// String curDate=sdf1.format(dataResultChEntity.getCurDate());
// data.setCurDate(sdf1.parse(curDate));//当前日期
// data.setProjectID(deviceInstallEntity.getProjectID()); //项目编号
String deviceAddr=dataResultChEntity.getDeviceAddr(); String deviceAddr=dataResultChEntity.getDeviceAddr();
String registerAddr=dataResultChEntity.getRegisterAddr(); String registerAddr=dataResultChEntity.getRegisterAddr();
String curDate=sdf1.format(dataResultChEntity.getCurDate()); String curDate= DateUtil.dateToString(dataResultChEntity.getCurDate(),"yyyy-MM-dd HH:mm:ss");
String projectID=dataResultChEntity.getProjectID(); String projectID=dataResultChEntity.getProjectID();
int row=dataResultMapper.selectDataResultChCount(curDate,deviceAddr,registerAddr,projectID);//无记录 int row=dataResultMapper.selectDataResultChCount(curDate,deviceAddr,registerAddr,projectID, dataResultChEntity.getGrade());//无记录
if (row==0){ if (row==0){
dataResultMapper.saveDataResultCh(dataResultChEntity); //插入新的记录 dataResultMapper.saveDataResultCh(dataResultChEntity); //插入新的记录
} }
@ -232,7 +223,7 @@ public class DataResultServiceImpl implements DataResultService {
@Override @Override
public void saveDataResultChiller(DataResultChEntity dataResultChEntity) { public void saveDataResultChiller(DataResultChEntity dataResultChEntity) {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{ try{
String deviceAddr=dataResultChEntity.getDeviceAddr(); String deviceAddr=dataResultChEntity.getDeviceAddr();
@ -247,10 +238,10 @@ public class DataResultServiceImpl implements DataResultService {
} }
String curDate=""; String curDate="";
curDate=str.substring(16)+":00"; curDate=str.substring(0 ,16)+":00";
String projectID=dataResultChEntity.getProjectID(); String projectID=dataResultChEntity.getProjectID();
dataResultChEntity.setCurDate(sdf1.parse(curDate)); dataResultChEntity.setCurDate(sdf1.parse(curDate));
int row=dataResultMapper.selectDataResultChillerCount(curDate,deviceAddr,registerAddr,projectID);//无记录 int row=dataResultMapper.selectDataResultChillerCount(curDate,deviceAddr,registerAddr,projectID, dataResultChEntity.getFunCode());//无记录
if (row==0){ if (row==0){
dataResultMapper.saveDataResultChiller(dataResultChEntity); //插入新的记录 dataResultMapper.saveDataResultChiller(dataResultChEntity); //插入新的记录
}else{ }else{

70
user-service/src/main/java/com/mh/user/utils/AnalysisReceiveOrder485.java
Unescape View File

@ -45,6 +45,8 @@ public class AnalysisReceiveOrder485 {
RabbitTemplate rabbitTemplate=context.getBean(RabbitTemplate.class); RabbitTemplate rabbitTemplate=context.getBean(RabbitTemplate.class);
ProjectInfoService projectInfoService=context.getBean(ProjectInfoService.class); ProjectInfoService projectInfoService=context.getBean(ProjectInfoService.class);
private final SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//解析冷量表 //解析冷量表
public void analysisCloudOrder485(final String dataStr1,final DeviceCodeParamEntity deviceCodeParam) { public void analysisCloudOrder485(final String dataStr1,final DeviceCodeParamEntity deviceCodeParam) {
threadPoolService.execute(() -> { threadPoolService.execute(() -> {
@ -58,10 +60,8 @@ public class AnalysisReceiveOrder485 {
checkWord = checkWord.substring(2, 4) + checkWord.substring(0, 2); checkWord = checkWord.substring(2, 4) + checkWord.substring(0, 2);
if (checkWord.equalsIgnoreCase(dataStr.substring(dataStr.length() - 4))) { if (checkWord.equalsIgnoreCase(dataStr.substring(dataStr.length() - 4))) {
// log.info("cloud message check success ===>" + dataStr);
//创建SimpleDateFormat对象，指定样式 2019-05-13 22:39:30 //创建SimpleDateFormat对象，指定样式 2019-05-13 22:39:30
Date date = new Date(); Date date = new Date();
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr=""; String dateStr="";
//保留两位小数处理 //保留两位小数处理
DecimalFormat decimalFormat = new DecimalFormat("0.00"); DecimalFormat decimalFormat = new DecimalFormat("0.00");
@ -77,37 +77,30 @@ public class AnalysisReceiveOrder485 {
DataResultChEntity dataResultCh=new DataResultChEntity(); DataResultChEntity dataResultCh=new DataResultChEntity();
DataResultClEntity dataResultCl=new DataResultClEntity(); DataResultClEntity dataResultCl=new DataResultClEntity();
String registerAddr=deviceCodeParam.getRegisterAddr(); String registerAddr=deviceCodeParam.getRegisterAddr();
if (ExchangeStringUtil.isInDate(date, "00:00:00", "00:00:30")) {
dateStr= sdf1.format(date);
dateStr=dateStr.substring(0,17)+"00";
System.out.println("插入时间00"+dateStr);
}else if (ExchangeStringUtil.isInDate(date, "00:00:30", "00:00:59")) {
dateStr= sdf1.format(date);
dateStr=dateStr.substring(0,17)+"30";
System.out.println("插入时间30"+dateStr);
}
try { try {
if(registerAddr.equals("32") || registerAddr.equals("33") || registerAddr.equals("35")){ if(registerAddr.equals("32") || registerAddr.equals("33") || registerAddr.equals("35")){
dataResultCh.setDeviceAddr(cloudId); dataResultCh.setDeviceAddr(cloudId);
dataResultCh.setDeviceType(deviceCodeParam.getDeviceType()); dataResultCh.setDeviceType(deviceCodeParam.getDeviceType());
if (ExchangeStringUtil.isInDate(date,"00:00:00","00:00:30")==true) {
dateStr= sdf1.format(date);
dateStr=dateStr.substring(0,17)+"00";
dataResultCh.setCurDate(sdf1.parse(dateStr));
// dataResultCh.setCurDate(dateStr);
System.out.println("插入时间00"+dateStr);
// }else if (ExchangeStringUtil.isInDate(date,"00:00:20","00:00:40")==true) {
// dateStr= sdf1.format(date);
// dateStr=dateStr.substring(0,17)+"20";
// dataResultCh.setCurDate(sdf1.parse(dateStr));
//// dataResultCh.setCurDate(dateStr);
// System.out.println("插入时间20"+dateStr);
}else if (ExchangeStringUtil.isInDate(date,"00:00:30","00:00:59")==true) {
dateStr= sdf1.format(date);
dateStr=dateStr.substring(0,17)+"30";
dataResultCh.setCurDate(sdf1.parse(dateStr));
// dataResultCh.setCurDate(dateStr);
System.out.println("插入时间30"+dateStr);
}
dataResultCh.setCurDate(sdf1.parse(dateStr));
data = decimalFormat.format(ExchangeStringUtil.hexToSingle(data));//十六进制字符串转IEEE754浮点型 data = decimalFormat.format(ExchangeStringUtil.hexToSingle(data));//十六进制字符串转IEEE754浮点型
dataResultCh.setCurValue(data); dataResultCh.setCurValue(data);
dataResultCh.setRegisterAddr(deviceCodeParam.getRegisterAddr()); dataResultCh.setRegisterAddr(deviceCodeParam.getRegisterAddr());
dataResultCh.setRegisterName(deviceCodeParam.getRegisterName()); dataResultCh.setRegisterName(deviceCodeParam.getRegisterName());
dataResultCh.setGrade(deviceCodeParam.getGrade()); dataResultCh.setGrade(deviceCodeParam.getGrade());
dataResultCh.setProjectID(deviceCodeParam.getProjectID()); dataResultCh.setProjectID(deviceCodeParam.getProjectID());
dataResultCh.setGrade(deviceCodeParam.getGrade());
String projectName=projectInfoService.selectName(deviceCodeParam.getProjectID()); String projectName=projectInfoService.selectName(deviceCodeParam.getProjectID());
log.info("冷量计==>"+cloudId+",读数==>"+dataResultCh.getCurValue()+",项目名称==>"+projectName); log.info("冷量计==>"+cloudId+",读数==>"+dataResultCh.getCurValue()+",项目名称==>"+projectName);
dataResultService.saveDataResultCh(dataResultCh); dataResultService.saveDataResultCh(dataResultCh);
@ -115,10 +108,8 @@ public class AnalysisReceiveOrder485 {
}else if (registerAddr.equals("31") || registerAddr.equals("34")){ }else if (registerAddr.equals("31") || registerAddr.equals("34")){
dataResultCl.setDeviceAddr(cloudId); dataResultCl.setDeviceAddr(cloudId);
dataResultCl.setDeviceType(deviceCodeParam.getDeviceType()); dataResultCl.setDeviceType(deviceCodeParam.getDeviceType());
dateStr= sdf1.format(date);
dataResultCh.setCurDate(sdf1.parse(dateStr)); dataResultCh.setCurDate(sdf1.parse(dateStr));
// dataResultCh.setCurDate(dateStr); long lData= Long.parseLong(ExchangeStringUtil.hexToDec(data));
Long lData=Long.valueOf(ExchangeStringUtil.hexToDec(data));
dataResultCl.setCurValue(lData);//字符串转整型 dataResultCl.setCurValue(lData);//字符串转整型
dataResultCl.setRegisterAddr(deviceCodeParam.getRegisterAddr()); dataResultCl.setRegisterAddr(deviceCodeParam.getRegisterAddr());
dataResultCl.setRegisterName(deviceCodeParam.getRegisterName()); dataResultCl.setRegisterName(deviceCodeParam.getRegisterName());
@ -159,7 +150,6 @@ public class AnalysisReceiveOrder485 {
if (checkWord.equalsIgnoreCase(dataStr.substring(dataStr.length() - 4))) { if (checkWord.equalsIgnoreCase(dataStr.substring(dataStr.length() - 4))) {
log.info("cloud message check success ===>" + dataStr); log.info("cloud message check success ===>" + dataStr);
Date date = new Date(); Date date = new Date();
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr=""; String dateStr="";
//保留两位小数处理 //保留两位小数处理
DecimalFormat decimalFormat = new DecimalFormat("0.00"); DecimalFormat decimalFormat = new DecimalFormat("0.00");
@ -182,23 +172,14 @@ public class AnalysisReceiveOrder485 {
if(registerAddr.equals("32") || registerAddr.equals("33") || registerAddr.equals("35")){ if(registerAddr.equals("32") || registerAddr.equals("33") || registerAddr.equals("35")){
dataResultCh.setDeviceAddr(cloudId); dataResultCh.setDeviceAddr(cloudId);
dataResultCh.setDeviceType(deviceCodeParam.getDeviceType()); dataResultCh.setDeviceType(deviceCodeParam.getDeviceType());
if (ExchangeStringUtil.isInDate(date,"00:00:00","00:00:30")==true) { if (ExchangeStringUtil.isInDate(date, "00:00:00", "00:00:30")) {
dateStr= sdf1.format(date); dateStr= sdf1.format(date);
dateStr=dateStr.substring(0,17)+"00"; dateStr=dateStr.substring(0,17)+"00";
dataResultCh.setCurDate(sdf1.parse(dateStr)); dataResultCh.setCurDate(sdf1.parse(dateStr));
// dataResultCh.setCurDate(dateStr); }else if (ExchangeStringUtil.isInDate(date, "00:00:30", "00:00:59")) {
System.out.println("插入时间00"+dateStr);
// }else if (ExchangeStringUtil.isInDate(date,"00:00:20","00:00:40")==true) {
// dateStr= sdf1.format(date);
// dateStr=dateStr.substring(0,17)+"20";
// dataResultCh.setCurDate(sdf1.parse(dateStr));
//// dataResultCh.setCurDate(dateStr);
// System.out.println("插入时间20"+dateStr);
}else if (ExchangeStringUtil.isInDate(date,"00:00:30","00:00:59")==true) {
dateStr= sdf1.format(date); dateStr= sdf1.format(date);
dateStr=dateStr.substring(0,17)+"30"; dateStr=dateStr.substring(0,17)+"30";
dataResultCh.setCurDate(sdf1.parse(dateStr)); dataResultCh.setCurDate(sdf1.parse(dateStr));
// dataResultCh.setCurDate(dateStr);
System.out.println("插入时间30"+dateStr); System.out.println("插入时间30"+dateStr);
} }
@ -208,6 +189,7 @@ public class AnalysisReceiveOrder485 {
dataResultCh.setRegisterName(deviceCodeParam.getRegisterName()); dataResultCh.setRegisterName(deviceCodeParam.getRegisterName());
dataResultCh.setGrade(deviceCodeParam.getGrade()); dataResultCh.setGrade(deviceCodeParam.getGrade());
dataResultCh.setProjectID(deviceCodeParam.getProjectID()); dataResultCh.setProjectID(deviceCodeParam.getProjectID());
dataResultCh.setGrade(deviceCodeParam.getGrade());
String projectName=projectInfoService.selectName(deviceCodeParam.getProjectID()); String projectName=projectInfoService.selectName(deviceCodeParam.getProjectID());
log.info("cloudID==>" + cloudId+",curValue==>"+dataResultCh.getCurValue()+",projectName==>"+projectName); log.info("cloudID==>" + cloudId+",curValue==>"+dataResultCh.getCurValue()+",projectName==>"+projectName);
dataResultService.saveDataResultCh(dataResultCh); dataResultService.saveDataResultCh(dataResultCh);
@ -469,15 +451,14 @@ public class AnalysisReceiveOrder485 {
*/ */
public void analysisChillerOrder485(final String dataStr,final DeviceCodeParamEntity deviceCodeParam) { public void analysisChillerOrder485(final String dataStr,final DeviceCodeParamEntity deviceCodeParam) {
if (!Constant.CONTROL_WEB_FLAG) { if (!Constant.CONTROL_WEB_FLAG) {
threadPoolService.execute(() -> { // threadPoolService.execute(() -> {
String checkStr = dataStr.substring(0, dataStr.length() - 4); // 检验报文 String checkStr = dataStr.substring(0, dataStr.length() - 4); // 检验报文
byte[] strOrder = ExchangeStringUtil.hexStrToBinaryStr(checkStr); byte[] strOrder = ExchangeStringUtil.hexStrToBinaryStr(checkStr);
int checkNum = CRC16.CRC16_MODBUS(strOrder); int checkNum = CRC16.CRC16_MODBUS(strOrder);
String checkWord = ExchangeStringUtil.decToHex(String.valueOf(checkNum)); String checkWord = ExchangeStringUtil.addZeroForNum(ExchangeStringUtil.decToHex(String.valueOf(checkNum)), 4);
checkWord = checkWord.substring(2, 4) + checkWord.substring(0, 2); checkWord = checkWord.substring(2, 4) + checkWord.substring(0, 2);
if (checkWord.equalsIgnoreCase(dataStr.substring(dataStr.length() - 4))) { if (checkWord.equalsIgnoreCase(dataStr.substring(dataStr.length() - 4))) {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");
Date date = new Date(); Date date = new Date();
String dateStr = sdf1.format(date); String dateStr = sdf1.format(date);
// 冷水机组的地址 // 冷水机组的地址
@ -493,11 +474,11 @@ public class AnalysisReceiveOrder485 {
dataResultCh.setDeviceAddr(chillerAddr); dataResultCh.setDeviceAddr(chillerAddr);
dataResultCh.setDeviceType(deviceCodeParam.getDeviceType()); dataResultCh.setDeviceType(deviceCodeParam.getDeviceType());
dataResultCh.setCurDate(sdf1.parse(dateStr)); dataResultCh.setCurDate(sdf1.parse(dateStr));
// dataResultCh.setCurDate(dateStr);
dataResultCh.setCurValue(data); dataResultCh.setCurValue(data);
dataResultCh.setDeviceAddr(deviceCodeParam.getRegisterAddr()); dataResultCh.setDeviceAddr(deviceCodeParam.getRegisterAddr());
dataResultCh.setRegisterName(deviceCodeParam.getRegisterName()); dataResultCh.setRegisterName(deviceCodeParam.getRegisterName());
dataResultCh.setGrade(deviceCodeParam.getGrade()); dataResultCh.setGrade(deviceCodeParam.getGrade());
dataResultCh.setFunCode(deviceCodeParam.getFunCode());
dataResultCh.setProjectID(deviceCodeParam.getProjectID()); dataResultCh.setProjectID(deviceCodeParam.getProjectID());
String projectName=projectInfoService.selectName(deviceCodeParam.getProjectID()); String projectName=projectInfoService.selectName(deviceCodeParam.getProjectID());
log.info("冷水机:" + chillerAddr + ",状态:" + data+",项目名称:"+projectName); log.info("冷水机:" + chillerAddr + ",状态:" + data+",项目名称:"+projectName);
@ -506,6 +487,7 @@ public class AnalysisReceiveOrder485 {
log.info("冷水机保存成功!项目名称:"+projectName); log.info("冷水机保存成功!项目名称:"+projectName);
}catch (Exception e){ }catch (Exception e){
e.printStackTrace(); e.printStackTrace();
log.error("冷水机报错：{}", e);
} }
} }
} else if (dataStr.substring(2, 4).equalsIgnoreCase("03") || dataStr.substring(2, 4).equalsIgnoreCase("04")) { } else if (dataStr.substring(2, 4).equalsIgnoreCase("03") || dataStr.substring(2, 4).equalsIgnoreCase("04")) {
@ -538,14 +520,14 @@ public class AnalysisReceiveOrder485 {
log.info("冷水机保存成功!项目名称:"+projectName); log.info("冷水机保存成功!项目名称:"+projectName);
}catch (Exception e){ }catch (Exception e){
e.printStackTrace(); e.printStackTrace();
log.error(e); log.error("冷水机保存异常：", e);
} }
} }
} }
}else{ }else{
log.info("冷水机校验失败===>" + dataStr); log.info("冷水机校验失败===>" + dataStr);
} }
}); // });
} }
} }

2
user-service/src/main/java/com/mh/user/utils/GetReadOrder485.java
Unescape View File

@ -355,11 +355,11 @@ public class GetReadOrder485 {
deviceCodeParamEntity2.setDataPort(devices.getDataPort()); deviceCodeParamEntity2.setDataPort(devices.getDataPort());
deviceCodeParamEntity2.setProjectID(devices.getProjectID()); deviceCodeParamEntity2.setProjectID(devices.getProjectID());
deviceCodeParamEntity2.setParity(devices.getParity()); deviceCodeParamEntity2.setParity(devices.getParity());
deviceCodeParamEntity2.setGrade(devices.getGrade());
deviceCodeParamEntity2.setDigit(2); //保留小数位 deviceCodeParamEntity2.setDigit(2); //保留小数位
deviceCodeParamEntity2.setRegisterName("瞬时流量"); deviceCodeParamEntity2.setRegisterName("瞬时流量");
String strData2=createCloudOrder(deviceCodeParamEntity2); String strData2=createCloudOrder(deviceCodeParamEntity2);
deviceCodeParamEntity2.setStrData(strData2); deviceCodeParamEntity2.setStrData(strData2);
deviceCodeParamEntity2.setGrade(2);
deviceCodeParamEntityList.add(deviceCodeParamEntity2); deviceCodeParamEntityList.add(deviceCodeParamEntity2);
}else if (devices.getDeviceType().equals("电表")){ }else if (devices.getDeviceType().equals("电表")){

5
user-service/src/main/java/com/mh/user/utils/SendOrderUtils.java
Unescape View File

@ -129,6 +129,11 @@ public class SendOrderUtils {
// }else if(deviceType.equals("冷水机")){ // }else if(deviceType.equals("冷水机")){
// sendStr = GetReadOrder485.createChillersOrder(deviceCodeParam); // sendStr = GetReadOrder485.createChillersOrder(deviceCodeParam);
// } // }
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
log.error("线程休眠异常", e);
}
ByteBuf buffer = getByteBuf(ctx, sendStr); ByteBuf buffer = getByteBuf(ctx, sendStr);
// 发送数据 // 发送数据
ctx.channel().writeAndFlush(buffer); ctx.channel().writeAndFlush(buffer);

4
user-service/src/main/resources/bootstrap.yml
Unescape View File

@ -12,6 +12,10 @@ spring:
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
username: jnd username: jnd
password: Mh@803tech password: Mh@803tech
# url: jdbc:sqlserver://127.0.0.1:1433;DatabaseName=mh_esi;allowMultiQueries=true
# driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
# username: sa
# password: mh@803
filters: stat,wall,log4j,config filters: stat,wall,log4j,config
max-active: 100 max-active: 100
initial-size: 1 initial-size: 1

36
user-service/src/test/java/com/mh/user/SysUserTest.java
Unescape View File

@ -1,12 +1,8 @@
package com.mh.user; package com.mh.user;
import com.mh.common.page.PageRequest; import java.text.ParseException;
import com.mh.common.page.PageResult; import java.text.SimpleDateFormat;
import com.mh.user.mapper.SysUserMapper; import java.util.Date;
import com.mh.user.model.SysUser;
import com.mh.user.service.SysUserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
/** /**
* @author ljf * @author ljf
@ -15,17 +11,25 @@ import org.springframework.beans.factory.annotation.Autowired;
* @updateTime 2020-03-14 * @updateTime 2020-03-14
* @throws ： * @throws ：
*/ */
public class SysUserTest extends UserServiceApplicationTests { public class SysUserTest {
@Autowired
private SysUserService sysUserService;
@Test public static void main(String[] args) throws ParseException {
public void findByName(){ SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SysUser sysUser = sysUserService.findByName("admin"); Date date1 = new Date();
System.out.println(sysUser.toString());
// List<SysUser> sysUserList = sysUserMapper.findAllUser(1,10); String str="";
// System.out.println(sysUserList); if (date1!=null){
str=sdf1.format(date1);
}else{
Date date=new Date();//获取系统日期
str=sdf1.format(date);
}
String curDate="";
curDate=str.substring(0,16)+":00";
Date parse = sdf1.parse(curDate);
System.out.println(parse);
} }
} }

3
user-service/src/test/java/com/mh/user/socket/NettyClientTest.java
Unescape View File

@ -1,6 +1,5 @@
package com.mh.user.socket; package com.mh.user.socket;
import com.mh.user.netty.NettyChillerClient;
import com.mh.user.netty.NettyChillerDDCClient; import com.mh.user.netty.NettyChillerDDCClient;
import com.mh.user.netty.NettyClient; import com.mh.user.netty.NettyClient;
import com.mh.user.netty.NettyMeterClient; import com.mh.user.netty.NettyMeterClient;
@ -37,8 +36,6 @@ public class NettyClientTest {
@Test @Test
void testChillers() throws InterruptedException { void testChillers() throws InterruptedException {
NettyChillerClient nettyChillerClient = new NettyChillerClient();
nettyChillerClient.connect(8080,"169.254.194.199");
} }
@Test @Test

Write Preview
Loading…
Cancel
Save