Browse Source

优化采集存储

master
mh 3 months ago
parent
commit
974338664c
  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

@ -1,28 +1,16 @@
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling;
import javax.annotation.PreDestroy;
import java.util.List;
@SpringBootApplication(scanBasePackages = "com.mh.user")
@EnableScheduling
//@ServletComponentScan
public class UserServiceApplication extends SpringBootServletInitializer {
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
SpringApplication.run(UserServiceApplication.class, args);
//System.out.println(Constant.projectId);
//Constant.projectId=7;
//System.out.println(Constant.projectId);
}
@PreDestroy

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

@ -1,9 +1,7 @@
package com.mh.user.entity;
import lombok.Data;
import java.util.Date;
@Data
public class DeviceCodeParamEntity {
private Long id;
@ -24,4 +22,139 @@ public class DeviceCodeParamEntity {
private Date createTime;
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

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

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

@ -122,11 +122,17 @@ public interface DataResultMapper {
"</script>")
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,
@Param("deviceAddr") String deviceAddr,
@Param("registerAddr") String registerAddr,
@Param("projectID") String projectID);
@Param("projectID") String projectID,
@Param("grade") int grade);
//----------------------------------------------------------------------------------------------------
@Results(id="rsc", value = {
@ -204,11 +210,16 @@ public interface DataResultMapper {
"</script>")
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,
@Param("deviceAddr") String deviceAddr,
@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 (" +
@ -261,4 +272,13 @@ public interface DataResultMapper {
" #{deviceAddr},#{deviceName},#{projectID},#{lastValue},#{lastDate},#{curValue},#{curDate},#{ratio},#{calcValue},#{grade})")
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

@ -19,18 +19,35 @@ public interface DeviceCodeParamMapper {
@Result(property="id",column="id"),
@Result(property="deviceAddr",column="device_addr"),
@Result(property="deviceType",column="deviceType"),
@Result(property="dataCom",column="data_com"),
@Result(property="strData",column="strData"),
@Result(property="dataPort",column="dataPort"),
@Result(property="baudRate",column="baudrate"),
@Result(property ="brand",column ="brand"),
@Result(property ="funCode",column ="fun_code"),
@Result(property ="registerAddr",column ="register_addr"),
@Result(property ="deviceName",column ="device_name"),
@Result(property ="createTime",column ="create_time"),
@Result(property ="registerName",column ="registerName"),
@Result(property ="deviceName",column ="deviceName"),
@Result(property ="createTime",column ="createTime"),
@Result(property ="grade",column ="grade"),
@Result(property ="digit",column ="digit"),
@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);
//查询指令参数,传入串口

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4
user-service/src/main/resources/bootstrap.yml

@ -12,6 +12,10 @@ spring:
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
username: jnd
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
max-active: 100
initial-size: 1

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

@ -1,12 +1,8 @@
package com.mh.user;
import com.mh.common.page.PageRequest;
import com.mh.common.page.PageResult;
import com.mh.user.mapper.SysUserMapper;
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;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author ljf
@ -15,17 +11,25 @@ import org.springframework.beans.factory.annotation.Autowired;
* @updateTime 2020-03-14
* @throws
*/
public class SysUserTest extends UserServiceApplicationTests {
public class SysUserTest {
@Autowired
private SysUserService sysUserService;
@Test
public void findByName(){
SysUser sysUser = sysUserService.findByName("admin");
System.out.println(sysUser.toString());
// List<SysUser> sysUserList = sysUserMapper.findAllUser(1,10);
// System.out.println(sysUserList);
public static void main(String[] args) throws ParseException {
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date1 = new Date();
String str="";
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

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

Loading…
Cancel
Save