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

优化采集存储

master
mh 10 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
Split 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. 134
      user-service/src/main/java/com/mh/user/netty/EchoServerHandler.java
  8. 184
      user-service/src/main/java/com/mh/user/netty/NettyChillerClient.java
  9. 576
      user-service/src/main/java/com/mh/user/netty/NettyChillerClientHandler.java
  10. 41
      user-service/src/main/java/com/mh/user/service/impl/DataResultServiceImpl.java
  11. 60
      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;
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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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，关闭所有的资源

134
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.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,12 +260,21 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
SendOrderUtils.sendAllOrder(deviceCodeParamList.get(num),ctx,num,size);
}
}
}else if (receiveStr.length() >= 100 ){
}
// 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("white gateway receive message ===> " + receiveStr);
log.info("白色网关接收===> " + receiveStr);
JSONObject jsonObject = JSONObject.parseObject(receiveStr);
receiveStr="";
@ -335,22 +297,17 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
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;
// 发送采集报文
@ -382,39 +339,14 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
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;
// }
// }
num = 0;
Thread.sleep(200);
// 继续发送下一个采集指令
@ -434,7 +366,6 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
}
}
}else if(dataStr.length() == 12 || dataStr.length() == 14){
// log.info("white gateway chiller receive message ===>" + dataStr);
log.info("白色网关冷水机接收===>" + dataStr);
// 解析采集的报文，并保存到数据库
AnalysisReceiveOrder485 analysisReceiveOrder485 = new AnalysisReceiveOrder485();
@ -444,17 +375,6 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
// 判断发送的下标，如果不等于指令数组大小
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;
Thread.sleep(200);
// 继续发送下一个采集指令
@ -480,33 +400,11 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
// 解析采集的报文，并保存到数据库
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;
// }
// }
num = 0;
Thread.sleep(200);
// 继续发送下一个采集指令
@ -553,13 +451,10 @@ public class EchoServerHandler extends ChannelInboundHandlerAdapter {
}
}
}
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()......");
}

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

@ -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();
//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 {
// TimeUnit.SECONDS.sleep(5);
// connect(port, host); // 断线重连
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
}
}
// @SneakyThrows
// 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
// public void run() {
// connect(port, host);
// 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();
//// }
// }
// }
//
//// @SneakyThrows
//// @Override
//// public void run() {
//// connect(port, host);
//// }
//}
}

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

@ -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("通信异常！！");
//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(chillersEntityList.get(num));
// String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.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();
// }
// }
//
// 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();
// receiveStr = null;
// log.info(ctx.channel().localAddress() + "退出链接！！");
// }
//
// @Override
// public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 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) {
// 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 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();
//
// @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(chillersEntityList.get(num));
// String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.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();
// }
// }
// } 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(chillersEntityList.get(num));
// String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.get(num));
// ByteBuf buffer = getByteBuf(ctx, sendStr);
// // 发送数据
// // 2.发送数据
// 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();
// }
// }
// } 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(chillersEntityList.get(num));
// String sendStr = getReadOrder485.createChillersOrder(deviceCodeParamList.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();
}
}
// }
// }
// }
// ctx.flush();
// }
//
//}

41
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.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()); //倍率
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{

60
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);
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();
try {
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);
}
try {
if(registerAddr.equals("32") || registerAddr.equals("33") || registerAddr.equals("35")){
dataResultCh.setDeviceAddr(cloudId);
dataResultCh.setDeviceType(deviceCodeParam.getDeviceType());
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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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

Write Preview
Loading…
Cancel
Save