Skip to content

S
supplyheatdevicedatacollection
Commit 86fbb808 authored by 耿迪迪's avatar 耿迪迪
Browse files
Options

供热设备数据接收

parents
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 2232 additions and 0 deletions
.gitignore 0 → 100644
View file @ 86fbb808
######################################################################
# Build Tools
.gradle
/build/
!gradle/wrapper/gradle-wrapper.jar
target/
!.mvn/wrapper/maven-wrapper.jar
######################################################################
# IDE
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
/target/
*.class
*.jar
*.log
/logs/*
/target/*
.settings*
### NetBeans ###
nbproject/private/
build/*
nbbuild/
dist/
nbdist/
.nb-gradle/
######################################################################
# Others
*.log
*.xml.versionsBackup
*.swp
!*/build/*.java
!*/build/*.html
!*/build/*.xml
.DS_Store
node_modules
/dist
# local env files
.env.local
.env.*.local
# Log files
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Editor directories and files
.idea
.vscode
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?
pom.xml 0 → 100644
View file @ 86fbb808
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.zehong</groupId>
<artifactId>supplyheatdevicedatacollection</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.3</version>
</parent>
<dependencies>
<!-- spring-boot-start-web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- spring-boot-start-test -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- hutool -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.19</version>
</dependency>
<!--netty-->
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.65.Final</version>
</dependency>
<!--集成redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- pool 对象池 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.10</version>
</dependency>
<!--mysql数据库驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.0</version>
</dependency>
<!-- pagehelper 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>1.3.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
\ No newline at end of file
src/main/java/com/zehong/SupplyHeatDeviceDataCollectionApplication.java 0 → 100644
View file @ 86fbb808
package com.zehong;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author gengd
* 供热设备数据收集系统
*/
@SpringBootApplication
@MapperScan("com.zehong.dao")
public class SupplyHeatDeviceDataCollectionApplication {
public static void main(String[] args) {
SpringApplication.run(SupplyHeatDeviceDataCollectionApplication.class, args);
}
}
src/main/java/com/zehong/config/NettyClientConfig.java 0 → 100644
View file @ 86fbb808
package com.zehong.config;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
@Configuration
@Data
public class NettyClientConfig {
/**
* netty 客户端服务器地址
*/
@Value("confirmClient.host")
private String host;
/**
* netty 客户端端口
*/
@Value("${confirmClient.port}")
private int port;
}
src/main/java/com/zehong/config/RedisConfig.java 0 → 100644
View file @ 86fbb808
package com.zehong.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author gengd
* 缓存配置
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
/**
* retemplate相关配置
* @param factory 连接工厂
* @return RedisTemplate
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 配置连接工厂
template.setConnectionFactory(factory);
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
// 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSeial.setObjectMapper(om);
// 值采用json序列化
template.setValueSerializer(jacksonSeial);
//使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
// 设置hash key 和value序列化模式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(jacksonSeial);
template.afterPropertiesSet();
return template;
}
/**
* 对hash类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
/**
* 对redis字符串类型数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForValue();
}
/**
* 对链表类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
/**
* 对无序集合类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
/**
* 对有序集合类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
}
src/main/java/com/zehong/dao/TControllerValuesDataDao.java 0 → 100644
View file @ 86fbb808
package com.zehong.dao;
import com.zehong.entity.TControllerValuesData;
import java.util.List;
/**
* 阀控数据Mapper接口
*
* @author zehong
* @date 2022-05-07
*/
public interface TControllerValuesDataDao {
/**
* 查询阀控数据
*
* @param controllerValueId 阀控数据ID
* @return 阀控数据
*/
TControllerValuesData selectTControllerValuesDataById(Long controllerValueId);
/**
* 查询阀控数据列表
*
* @param tControllerValuesData 阀控数据
* @return 阀控数据集合
*/
List<TControllerValuesData> selectTControllerValuesDataList(TControllerValuesData tControllerValuesData);
/**
* 新增阀控数据
*
* @param tControllerValuesData 阀控数据
* @return 结果
*/
int insertTControllerValuesData(TControllerValuesData tControllerValuesData);
/**
* 修改阀控数据
*
* @param tControllerValuesData 阀控数据
* @return 结果
*/
int updateTControllerValuesData(TControllerValuesData tControllerValuesData);
/**
* 删除阀控数据
*
* @param controllerValueId 阀控数据ID
* @return 结果
*/
int deleteTControllerValuesDataById(Long controllerValueId);
/**
* 批量删除阀控数据
*
* @param controllerValueIds 需要删除的数据ID
* @return 结果
*/
int deleteTControllerValuesDataByIds(Long[] controllerValueIds);
}
src/main/java/com/zehong/dao/THeatDataDao.java 0 → 100644
View file @ 86fbb808
package com.zehong.dao;
import com.zehong.entity.THeatData;
import java.util.List;
/**
* 热量数据Mapper接口
*
* @author zehong
* @date 2022-05-07
*/
public interface THeatDataDao {
/**
* 查询热量数据
*
* @param heatId 热量数据ID
* @return 热量数据
*/
THeatData selectTHeatDataById(Long heatId);
/**
* 查询热量数据列表
*
* @param tHeatData 热量数据
* @return 热量数据集合
*/
List<THeatData> selectTHeatDataList(THeatData tHeatData);
/**
* 新增热量数据
*
* @param tHeatData 热量数据
* @return 结果
*/
int insertTHeatData(THeatData tHeatData);
/**
* 修改热量数据
*
* @param tHeatData 热量数据
* @return 结果
*/
int updateTHeatData(THeatData tHeatData);
/**
* 删除热量数据
*
* @param heatId 热量数据ID
* @return 结果
*/
int deleteTHeatDataById(Long heatId);
/**
* 批量删除热量数据
*
* @param heatIds 需要删除的数据ID
* @return 结果
*/
int deleteTHeatDataByIds(Long[] heatIds);
}
src/main/java/com/zehong/entity/TControllerValuesData.java 0 → 100644
View file @ 86fbb808
package com.zehong.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
/**
* 阀控数据对象 t_controller_values_data
*
* @author zehong
* @date 2022-05-07
*/
@Data
public class TControllerValuesData {
/** 阀控id */
private Long controllerValueId;
/** 厂商编号 */
private String manufacturersId;
/** 阀控类型 */
private String equipmentTypeValue;
/** 阀控编号 */
private String valueId;
/** 阀控协议类型：保留，目前未使用，全FF表示数据无效 */
private String protocolType;
/** 阀门操作类型，十六进制，0：温控，1：常开，2：常关，3：自由温控；4：强制；5：用户控制；6：固定温控 */
private String valveOperateType;
/** 温度下限 */
private BigDecimal lowControlTemperatureRange;
/** 温度上限 */
private BigDecimal highControlTemperatureRange;
/** 室内温控器向阀门上报室温最大时间周期，单位分钟，范围1到30，全FF表示数据无效 */
private String indoorTemperatureReportMaxTimer;
/** 温控温度 */
private BigDecimal controlTemperature;
/** 室内温度 */
private BigDecimal indoorTemperature;
/** 当前阀门开关状态 0：关闭；100：打开；对于开度阀0、10、…100对应0~10挡位 */
private String openedPercent;
/** 阀门关机防冻标记，0：关闭关机防冻功能；1：打开关机防冻功能 */
private String preventFrozenFlag;
/** 阀门控制器与室内温控器通信方式，0：无线；1：有线 */
private String communicateType;
/** 阀门控制器供电方式，0：市电；1：电池 */
private String valvePowerStyle;
/** 允许的最大挡位，十六进制数，0、10、… 100对应0~10挡位 */
private String panelPowerTyle;
/** 对码状态，十六进制数，0：未对码；1：已对码 */
private String pairingStatus;
/** 阀门累计开时间，单位秒 */
private String cumulativeOpenedTime;
/** 阀门累计工作时间，单位秒 */
private String cumulativeWorkingTime;
/** 实时时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
private Date dateTimeValue;
/** 十六进制，高字节为阀门控制器状态，低字节为室内温控器状态 */
private String status;
/** 累计阀开/关次数 */
private String cumulativeOpenAndCloseTimes;
/** 累计室温*时间（分钟） */
private String cumulativeIndoorTempMultiplySecond;
/** 软件版本，十六进制数，高位为主版本号；低位为次版本号 */
private String softwareVersion;
/** 频点，十六进制数，全FF表示数据无效 */
private String freq;
/** Snum，十六进制数，全FF表示数据无效 */
private String snum;
/** 创建时间 */
private Date createTime;
}
src/main/java/com/zehong/entity/THeatData.java 0 → 100644
View file @ 86fbb808
package com.zehong.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
/**
* 热量数据对象 t_heat_data
*
* @author zehong
* @date 2022-05-07
*/
@Data
public class THeatData {
/** 热量id */
private Long heatId;
/** 厂商编号 */
private String manufacturersId;
/** 表类型 */
private String equipmentTypeValue;
/** 热量表编号 */
private String heatMeterId;
/** 表协议类型：保留，目前未使用 */
private String protocolType;
/** 累计冷量 */
private BigDecimal cumulativeCool;
/** 累计冷量单位，单位最高位为0表示累计冷量为正；最高位为1表示累计冷量为负 */
private String cumulativeCoolUnit;
/** 累积热量 */
private BigDecimal cumulativeHeat;
/** 累积热量单位，单位最高位为0表示累计热量为正；最高位为1表示累计热量为负 */
private String cumulativeHeatUnit;
/** 瞬时功率 */
private BigDecimal theCurrentThermalPower;
/** 瞬时功率单位，单位最高位为0表示瞬时功率为正；最高位为1表示瞬时功率为负 */
private String theCurrentThermalPowerUnit;
/** 瞬时流量 */
private BigDecimal currentFlow;
/** 瞬时流量单位，单位最高位为0表示瞬时流量为正；最高位为1表示瞬时流量为负 */
private String currentFlowUnit;
/** 累积流量 */
private BigDecimal cumulativeFlow;
/** 累积流量单位，单位最高位为0表示累计流量为正；最高位为1表示累计流量为负 */
private String cumulativeFlowUnit;
/** 当前供水温度 */
private BigDecimal theCurrentWaterTemperature;
/** 当前回水温度 */
private BigDecimal currentReturnTemperature;
/** 累积工作时间，单位小时 */
private String cumulativeWorkingTime;
/** 热量表实时时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
private Date dateTimeValue;
/** 回水累计流量 */
private BigDecimal cumulativeReturnFlow;
/** 回水累计流量单位，单位最高位为0表示回水累计流量为正；最高位为1表示回水累计流量为负 */
private String cumulativeReturnFlowUnit;
/** 累计流量差 */
private BigDecimal cumulativeFlowDifference;
/** 累计流量差单位，单位最高位为0表示累计流量差为正；最高位为1表示累计流量差为负 */
private String cumulativeFlowDifferenceUnit;
/** 有效标志（是否支持回水累计流量、累计流量差）,十六进制，高位在前、低位在后0x0000：无效；0x0001：有效 */
private String returnFlowFlag;
/** 状态ST */
private String stStatus;
/** 创建时间 */
private Date createTime;
}
src/main/java/com/zehong/enums/InformationTypeEnum.java 0 → 100644
View file @ 86fbb808
package com.zehong.enums;
/**
* @author gengd
* 信息单元类型
*/
public enum InformationTypeEnum {
/** （原因值）*/
CAUSE("01"),
/**（日期时间） */
DATE_TIME("02"),
/** （分包信息）*/
PACKET_INFORMATION("03"),
/**（程序版本） */
PROGRAM_VERSION("11"),
/** （集中器网络参数）*/
CONCENTRATOR_NETWORK("12"),
/** （集中器上报数据时间）*/
CONCENTRATOR_REPORTED_TIME("13"),
/** （集中器参数）*/
CONCENTRATOR_PARAMETER("14"),
/** （设备ID列表）*/
EQUIPMENT_ID_LISTS("16"),
/**（读数据失败设备列表） */
ERROR_DATA_EQUIPMENT_ID_LISTS("20"),
/** （热量表数据）*/
HEAT_METER_DATA("21"),
/** （热量表数据列表）*/
HEAT_METER_DATA_LISTS("22"),
/** （阀门数据）*/
VALVE_DATA("31"),
/** （阀门数据列表）*/
VALVE_DATA_LISTS("32"),
/**（阀门操作列表） */
VALVE_OPERATE_LISTS("33"),
/** （阀门操作原因值）*/
VALVE_OPERATE_CAUSE("34"),
/** （阀门操作）*/
VALVE_OPERATE("35"),
/**（集中器中历史数据日期列表） */
HISTORY_DATE_LISTS("50"),
/**（设备类型） */
EQUIPMENT_TYPE("61"),
/** （设备ID）*/
EQUIPMENT_ID("62"),
/**（分包确认指示） */
MULTI_PACKET_CONFIRM_INDICATION("A1"),
/** （集中器告警）*/
CONCENTRATOR_ALARM("A3"),
/**（自由温控控制温度） */
FREE_CONTROL_TEMPERATURE("C1"),
/** （温控温度范围）*/
CONTROL_TEMPERATURE_RANGE("C2"),
/** （室温上报最大时间间隔）*/
INDOOR_TEMPERATURE_REPORT_MAX_TIMER("C3"),
/** （长关模式下防冻）*/
PREVENT_FROZEN_UNDER_CLOSED_MODE("C4"),
/**（对码标记） */
PAIRING_FLAG("CA"),
/**（启动时阀门动作延时） */
VALVE_OPERATE_DELAY_ON_START_UP("CB");
public String value;
InformationTypeEnum(String value){
this.value = value;
}
}
src/main/java/com/zehong/enums/MessageTypeEnum.java 0 → 100644
View file @ 86fbb808
package com.zehong.enums;
/**
* @author gengd
* 消息类型
*/
public enum MessageTypeEnum {
/**（集中器注册请求）*/
CONCENTRATOR_REGISTRATION_REQUEST("01"),
/**（集中器注册响应）*/
CONCENTRATOR_REGISTRATION_RESPONSE("02"),
/** （心跳）*/
HEARTBEAT("03"),
/** （集中器校时）*/
CONCENTRATOR_CALIBRATION("05"),
/** （获取集中器数据上报时间的请求）*/
GET_CONCENTRATOR_REPORTED_TIME_REQUEST("13"),
/** （获取集中器数据上报时间的响应）*/
GET_CONCENTRATOR_REPORTED_TIME_RESPONSE("14"),
/**（设置集中器数据上报时间的请求） */
SET_CONCENTRATOR_REPORTED_TIME_REQUEST("23"),
/**（设置集中器数据上报时间的响应） */
SET_CONCENTRATOR_REPORTED_TIME_RESPONSE("24"),
/** （获取集中器下设备ID的请求）*/
GET_EQUIPMENT_ID_REQUEST("31"),
/** （获取集中器下设备ID的响应）*/
GET_EQUIPMENT_ID_RESPONSE("32"),
/**（设置集中器下设备ID的请求） */
SET_EQUIPMENT_ID_REQUEST("33"),
/** （设置集中器下设备ID的响应）*/
SET_EQUIPMENT_ID_RESPONSE("34"),
/** （定时维护数据上传通知）*/
MAINTENANCE_DATA_NOTIFY("51"),
/** （定时维护数据接收完成确认）*/
MAINTENANCE_DATA_CONFIRM("52"),
/** （读取定时维护数据的请求）*/
READ_DATA_REQUEST("53"),
/** （读取定时维护数据的响应）*/
READ_DATA_RESPONSE("54"),
/**（读取集中器中存储的历史抄表数据时间的请求） */
GET_MAINTENANCE_HISTORY_DATE_REQUEST("61"),
/**（读取集中器中存储的历史抄表数据时间的响应） */
GET_MAINTENANCE_HISTORY_DATE_RESPONSE("62"),
/** （实时读表阀的请求）*/
EQUIPMENT_REAL_DATA_REQUEST("67"),
/**（指定阀门进行操作） */
EQUIPMENT_REAL_DATA_RESPONSE("68"),
/**（指定阀门进行操作） */
VALVE_OPERATE_REQUEST("71"),
/** （阀门操作结果） */
VALVE_OPERATE_RESPONSE("75");
public String value;
MessageTypeEnum(String value){
this.value = value;
}
}
src/main/java/com/zehong/netty/NettyTcpStart.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty;
import com.zehong.netty.handler.TcpServerHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
/**
* 物联网 开启检测 并写入数据库
*/
@Component
public class NettyTcpStart {
private Logger logger = LoggerFactory.getLogger(NettyTcpStart.class);
@Resource
private TcpServerHandler TcpServerHandler;
private EventLoopGroup bossGroup = new NioEventLoopGroup();
private EventLoopGroup workGroup = new NioEventLoopGroup();
@Value("${TCPNetty.ports}")
private int[] ports;
/**
* 启动netty服务
* @throws InterruptedException
*/
@PostConstruct
public void start() throws InterruptedException {
ServerBootstrap b=new ServerBootstrap();
b.group(bossGroup,workGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG,128)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(TcpServerHandler);
}
});
//开启需要监听 的端口
for(int port : ports){
ChannelFuture future = b.bind(port).sync();
if (future.isSuccess()) {
logger.info("TCP server启动 "+ port +" 成功");
}
}
}
/**
* 销毁
*/
@PreDestroy
public void destroy() {
bossGroup.shutdownGracefully().syncUninterruptibly();
workGroup.shutdownGracefully().syncUninterruptibly();
logger.info("TCP server关闭 Netty 成功");
}
}
src/main/java/com/zehong/netty/decode/CauseDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author gengd
* 信息单元原因解析
*/
public class CauseDecode {
private Logger logger = LoggerFactory.getLogger(CauseDecode.class);
/**
* 解析消息
*/
private MsgDecode decode;
/**
* 原因
*/
private String cause;
public CauseDecode(MsgDecode decode){
this.decode = decode;
this.cause = decode.getMsgInfo().substring(0,8);
}
/**
* 解析原因
*/
public void decodeCause(){
//信息单元类型
String ieType = this.cause.substring(0,2);
//长度
String length = this.cause.substring(2,6);
//原因值
String causeValue = this.cause.substring(6,8);
logger.info("transmissionId:" + decode.getTransmissionId() + "原因： 信息单元类型："+ ieType +" 长度：" + length + "原因值：" + causeValue);
}
}
src/main/java/com/zehong/netty/decode/DateTimeDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zehong.utils.DateTimeValueUtil;
/**
* @author gengd
* 信息单元时间日期解析
*/
public class DateTimeDecode {
private Logger logger = LoggerFactory.getLogger(CauseDecode.class);
private MsgDecode decode;
/**
* 日期时间
*/
private String dateTime;
public DateTimeDecode(MsgDecode decode){
this.dateTime = decode.getMsgInfo().substring(8,28);
}
public void decodeDateTime(){
//信息单元类型
String ieType = dateTime.substring(0,2);
//长度
String length = dateTime.substring(2,6);
//日期时间
String dateTimeStr = DateTimeValueUtil.getDateTimeStr(dateTime.substring(6,20));
logger.info("transmissionId:" + decode.getTransmissionId() + "时间日期： 信息单元类型："+ ieType +" 长度：" + length + "原因值：" + dateTimeStr);
}
}
src/main/java/com/zehong/netty/decode/ErrorDataEquipmentIdListsDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.Map;
/**
* @author gengd
* 读取数据失败ID列表
*/
public class ErrorDataEquipmentIdListsDecode {
private Logger logger = LoggerFactory.getLogger(ErrorDataEquipmentIdListsDecode.class);
private MsgDecode decode;
/**
* 设备类型
*/
private Map<String,String> equipmentTypeValueMap = new HashMap<>();
{
equipmentTypeValueMap.put("00","所有设备");
equipmentTypeValueMap.put("10","水表");
equipmentTypeValueMap.put("20","热量表");
equipmentTypeValueMap.put("70","阀门");
}
/**
* 读取数据失败ID列表数据
*/
private String errorDataEquipmentIdLists;
public ErrorDataEquipmentIdListsDecode(MsgDecode decode,int startLength){
this.decode = decode;
this.errorDataEquipmentIdLists = decode.getMsgInfo().substring(42 + startLength *2,decode.getMsgInfo().length());
}
public void decodeErrorDataEquipmentIdLists(){
//信息单元类型
String ieType = this.errorDataEquipmentIdLists.substring(0,2);
//长度
String length = this.errorDataEquipmentIdLists.substring(2,6);
//设备ID数量
String errorDataEquipmentIdCount = this.errorDataEquipmentIdLists.substring(6,10);
deocdeErrorDataEquipmentIdList(Integer.parseInt(errorDataEquipmentIdCount,16));
logger.info("transmissionId:" + decode.getTransmissionId() + "读取数据失败ID列表数据： 信息单元类型："+ ieType +" 长度：" + length + "读取数据失败ID列表数据：" + errorDataEquipmentIdLists.substring(10,Integer.parseInt(errorDataEquipmentIdCount,16)*16));
}
/**
* 数据解析
* @param errorDataEquipmentIdCount 设备数量
*/
public void deocdeErrorDataEquipmentIdList(int errorDataEquipmentIdCount){
String errorDataEquipmentIds = errorDataEquipmentIdLists.substring(10,errorDataEquipmentIdLists.length());
for(int i = 1; i < errorDataEquipmentIdCount + 1; i++){
String errorDataEquipmentId = errorDataEquipmentIds.substring((i-1)*16,i*16);
//厂商ID，BCD码
String manufacturersId = errorDataEquipmentId.substring(0,4);
//设备类型
String equipmentTypeValue = errorDataEquipmentId.substring(4,6);
String equipmentType = equipmentTypeValueMap.get(equipmentTypeValue);
//设备编号
String equipmentId = errorDataEquipmentId.substring(6,16);
logger.info("transmissionId:" + decode.getTransmissionId() + "读取数据失败ID列表数据:" + "厂商Id:" + manufacturersId + "设备类型:" + equipmentType + "设备编号:" + equipmentId);
}
}
}
src/main/java/com/zehong/netty/decode/InformationDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
/**
* @author gengd
* 信息单元解析
*/
public class InformationDecode {
/**
* 信息单元
*/
private MsgDecode decode;
public InformationDecode(MsgDecode decode){
this.decode = decode;
}
public void infoMsgDecode(){
//原因值
new CauseDecode(decode).decodeCause();
//日期时间
new DateTimeDecode(decode).decodeDateTime();
//分包信息
PackageInformationDecode packageInformationDecode = new PackageInformationDecode(decode);
packageInformationDecode.decodePakageInformation();
if(packageInformationDecode.isNotSaveCurrentIndex){
//热量表数据列表
HeatMeterDataListDecode heatMeterDataListDecode = new HeatMeterDataListDecode(decode);
heatMeterDataListDecode.decodeHeatMeterDataList();
int heatMeterDataListLength = heatMeterDataListDecode.getHeatMeterDataListLength;
//阀控数据列表
ValveDataListsDecode valveDataListsDecode = new ValveDataListsDecode(decode,heatMeterDataListLength);
valveDataListsDecode.decodeValueDataLists();
int valueDataListsLength = valveDataListsDecode.valueDataListsLength;
//读取数据失败ID列表
new ErrorDataEquipmentIdListsDecode(decode,heatMeterDataListLength+valueDataListsLength).decodeErrorDataEquipmentIdLists();
}
}
}
src/main/java/com/zehong/netty/decode/MsgDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
import java.util.zip.CRC32;
/**
* @author gengd
* 16进制消息串解析
*/
public class MsgDecode {
/**
* 16进制消息串
*/
private String msgStr;
/** 消息头
* Fixed Preamble 前导码：0x49 0x4f 0x54 0x40 4个字节
* Length 长度：指示后续数据的长度，高位在前、低位在后 2个字节
* Transmission ID 传输ID 1个字节
* Concentrator ID 集中器ID，高位在前、低位在后 4个字节
* Message Type 消息类型 1个字节
*/
private String msgHead;
/** 信息单元 */
private String msgInfo;
/** 消息尾
* CRC32 Check 校验码 4个字节
* Terminator 结束符 2个字节
*/
private String msgTail;
public MsgDecode(String msgStr){
this.msgStr = msgStr;
this.msgHead = msgStr.substring(0,24);
this.msgInfo = msgStr.substring(24,msgStr.length()-12);
this.msgTail = msgStr.substring(msgStr.length()-12,msgStr.length());
}
/**
* 获取传输id
* @return String
*/
public String getTransmissionId(){
return this.msgHead.substring(12,14);
}
/**
* 获取集中器id
* @return
*/
public String getConcentratorId(){
return this.msgHead.substring(14,22);
}
/**
* 获取消息类型
* @return
*/
public String getMessageType(){
return this.msgHead.substring(22,24);
}
/**
* crc32校验
* @return boolean
*/
public boolean checkCRC32Code(){
String checkStr = this.msgStr.substring(8,this.msgStr.length()-12);
CRC32 crc32 = new CRC32();
crc32.update(checkStr.getBytes());
String checkCode = Long.toHexString(crc32.getValue());
String crc32Code = this.msgTail.substring(0,8);
return checkCode.equals(crc32Code);
}
public String getMsgStr() {
return msgStr;
}
public String getMsgHead() {
return msgHead;
}
public String getMsgInfo() {
return msgInfo;
}
public String getMsgTail() {
return msgTail;
}
}
src/main/java/com/zehong/netty/decode/PackageInformationDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
import cn.hutool.core.date.DateUtil;
import com.zehong.config.NettyClientConfig;
import com.zehong.utils.HexUtils;
import com.zehong.utils.NettyClient;
import com.zehong.utils.RedisUtil;
import com.zehong.utils.SpringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.CRC32;
/**
* @author gengd
* 信息单元分包信息解析
*/
public class PackageInformationDecode {
private Logger logger = LoggerFactory.getLogger(PackageInformationDecode.class);
/**
* 上传信息解析数据
*/
private MsgDecode decode;
/**
* 分包信息
*/
private String packageInformation;
/**
* 总包数
*/
private String totalPackageCount;
/**
* 当前包数
*/
private String currentPackageIndex;
/**
* 当前包是否发送过
*/
public boolean isNotSaveCurrentIndex;
public PackageInformationDecode(MsgDecode decode){
this.decode = decode;
this.packageInformation = decode.getMsgInfo().substring(28,42);
}
public void decodePakageInformation(){
//信息单元类型
String ieType = this.packageInformation.substring(0,2);
//长度
String length = this.packageInformation.substring(2,6);
//总包数
this.totalPackageCount = this.packageInformation.substring(6,10);
//当前包数
this.currentPackageIndex = this.packageInformation.substring(10,14);
logger.info("transmissionId:" + decode.getTransmissionId() + "分包信息： 信息单元类型："+ ieType +" 长度：" + length + "总包数：" + totalPackageCount + "当前包数" + currentPackageIndex);
//缓存分包信息
packageInformationCash();
}
/**
* 缓存分包信息
*/
private void packageInformationCash(){
RedisUtil redisUtil = SpringUtil.getBean(RedisUtil.class);
List<String> cashInfo = (List<String>) redisUtil.get(decode.getTransmissionId());
//缓存信息不为空
if(null != cashInfo && !cashInfo.isEmpty()){
if(cashInfo.contains(currentPackageIndex)){
return;
}
cashInfo.add(currentPackageIndex);
isNotSaveCurrentIndex = true;
//如接受到所有分包信息，移除分包缓存
if( Integer.parseInt(totalPackageCount,16) == cashInfo.size()){
//确认消息
confirmInformation();
//移除分包缓存
redisUtil.del(decode.getTransmissionId());
return;
}
// 缓存分包信息
redisUtil.set(decode.getTransmissionId(),cashInfo,60 * 60 *6);
return;
}
isNotSaveCurrentIndex = true;
List<String> packageInfoCash = new ArrayList<>();
packageInfoCash.add(currentPackageIndex);
redisUtil.set(decode.getTransmissionId(),packageInfoCash,60 * 60 *6);
}
/**
* 确认成功接收消息
*/
public void confirmInformation(){
String head = decode.getMsgHead();
String tail = decode.getMsgTail();
String dateTime = getDateTimeHex();
CRC32 crc32 = new CRC32();
crc32.update((head.substring(8,head.length())+dateTime).getBytes());
String checkCode = Long.toHexString(crc32.getValue());
StringBuilder reqMsg = new StringBuilder(head);
reqMsg.append(dateTime)
.append(checkCode)
.append(tail.substring(8,12));
NettyClientConfig config = SpringUtil.getBean(NettyClientConfig.class);
String msg = NettyClient.nettyConnection(reqMsg.toString(),config.getHost(),config.getPort());
logger.info("transmissionId:" + decode.getTransmissionId() + "消息确认服务器回复消息：" + msg);
}
/**
* 拼接信息单元
* @return String
*/
private static String getDateTimeHex(){
String now = DateUtil.now();
String[] date =now.split(" ");
//年月日
String[] yearDate = date[0].split("-");
//时分秒
String[] time = date[1].split(":");
System.out.println("年：" + HexUtils.bytesToHex(yearDate[0].substring(0,2).getBytes()) + " 时：" + time.toString());
StringBuilder dateTime = new StringBuilder("");
dateTime.append(String.format("%02x",Integer.parseInt(yearDate[0].substring(0,2))))
.append(String.format("%02x",Integer.parseInt(yearDate[0].substring(2,4))))
.append(String.format("%02x",Integer.parseInt(yearDate[1])))
.append(String.format("%02x",Integer.parseInt(yearDate[2])))
.append(String.format("%02x",Integer.parseInt(time[0])))
.append(String.format("%02x",Integer.parseInt(time[1])))
.append(String.format("%02x",Integer.parseInt(time[2])));
return dateTime.toString();
}
}
src/main/java/com/zehong/netty/decode/ValveDataListsDecode.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.decode;
import com.zehong.entity.TControllerValuesData;
import com.zehong.service.ITControllerValuesDataService;
import com.zehong.utils.DateTimeValueUtil;
import com.zehong.utils.HexUtils;
import com.zehong.utils.SpringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
* @gengd
* 阀控数据解析
*/
public class ValveDataListsDecode {
private Logger logger = LoggerFactory.getLogger(ValveDataListsDecode.class);
private MsgDecode decode;
/**
* 阀控list数据
*/
private String valueDataLists;
/**
* 阀控数据长度
*/
public int valueDataListsLength;
public ValveDataListsDecode(MsgDecode decode,int startLength){
this.decode = decode;
this.valueDataLists = decode.getMsgInfo().substring(42 + startLength *2,decode.getMsgInfo().length());
}
/**
* 解析阀控数据
*/
public void decodeValueDataLists(){
//信息单元类型
String ieType = this.valueDataLists.substring(0,2);
//长度
String length = this.valueDataLists.substring(2,6);
//阀控数量
String valueDataCount = this.valueDataLists.substring(6,10);
//热量表数据所占字节数
this.valueDataListsLength = Integer.parseInt(valueDataCount,16) * 54 + 5;
//热量表数据
decodeValueData(Integer.parseInt(valueDataCount,16));
logger.info("transmissionId:" + decode.getTransmissionId() + "阀控数据： 信息单元类型："+ ieType +" 长度：" + length + "阀控数量：" + valueDataListsLength + "阀控数据：" + valueDataLists.substring(10,Integer.parseInt(valueDataCount,16)*108));
}
/**
* 解析阀控数据
* @param count 数量
*/
private void decodeValueData(int count){
String heatMeterDatas = valueDataLists.substring(10,valueDataLists.length());
for(int i = 1; i < count + 1; i++){
String valueData = heatMeterDatas.substring((i-1)*108,i*108);
saveValusData(valueData);
}
}
/**
* 保存阀控数据
* @param valueData 阀控数据
*/
private void saveValusData(String valueData){
ITControllerValuesDataService itControllerValuesDataService = SpringUtil.getBean(ITControllerValuesDataService.class);
TControllerValuesData tControllerValuesData = decodeValueData(valueData);
itControllerValuesDataService.insertTControllerValuesData(tControllerValuesData);
}
/**
* 解析阀控表数据
* @param valueData 阀控数据
* @return TControllerValuesData
*/
private TControllerValuesData decodeValueData(String valueData){
TControllerValuesData tControllerValuesData = new TControllerValuesData();
//厂商编号
String manufacturersId = valueData.substring(0,4);
tControllerValuesData.setManufacturersId(manufacturersId);
//阀控类型
String equipmentTypeValue = valueData.substring(4,6);
tControllerValuesData.setEquipmentTypeValue(equipmentTypeValue);
//阀控编号
String valveId = valueData.substring(6,16);
tControllerValuesData.setValueId(valveId);
//阀门操作类型
String valveOperateType = valueData.substring(18,20);
tControllerValuesData.setValveOperateType(String.valueOf(Integer.parseInt(valveOperateType,16)));
/**
* 十六进制数，高位在前、低位在后，两位小数，单位℃
* 小于20000表示温控温度范围下限，例如01 02表示0x0102除100，即2.58℃。
* 大于20000表示回水温度，例如4F 22，0x4F22=20258，（20258-20000）/100=2.58℃
* 全FF表示数据无效
*/
String lowControlTemperatureRange = valueData.substring(20,24);
int lowControlTemperatureRangeInt = Integer.parseInt(lowControlTemperatureRange,16);
if(lowControlTemperatureRangeInt > 2000){
tControllerValuesData.setLowControlTemperatureRange(new BigDecimal((lowControlTemperatureRangeInt-2000)/100));
}else{
tControllerValuesData.setLowControlTemperatureRange(new BigDecimal(lowControlTemperatureRangeInt/100));
}
//温控温度范围上限
String highControlTemperatureRange = valueData.substring(24,28);
tControllerValuesData.setHighControlTemperatureRange(new BigDecimal(Integer.parseInt(highControlTemperatureRange,16)/100));
//室内温控器向阀门上报室温最大时间周期，单位分钟，范围1到30
String indoortemperaturereportMaxTimer = valueData.substring(28,30);
tControllerValuesData.setIndoorTemperatureReportMaxTimer(String.valueOf(Integer.parseInt(indoortemperaturereportMaxTimer,16)));
//温控温度
String controlTemperature = valueData.substring(30,34);
tControllerValuesData.setControlTemperature(new BigDecimal(Integer.parseInt(controlTemperature,16)/100));
//室内温度
String indoorTemperature = valueData.substring(34,38);
tControllerValuesData.setIndoorTemperature(new BigDecimal(Integer.parseInt(indoorTemperature,16)/100));
//当前阀门开关状态
String openedPercent = valueData.substring(38,40);
tControllerValuesData.setOpenedPercent(String.valueOf(Integer.parseInt(openedPercent,16)));
//阀门关机防冻标记
String preventFrozenFlag = valueData.substring(40,42);
tControllerValuesData.setPreventFrozenFlag(String.valueOf(Integer.parseInt(preventFrozenFlag,16)));
//阀门控制器与室内温控器通信方式
String communicateType = valueData.substring(42,44);
tControllerValuesData.setCommunicateType(String.valueOf(Integer.parseInt(communicateType,16)));
//阀门控制器供电方式
String valvePowerStyle = valueData.substring(44,46);
tControllerValuesData.setValvePowerStyle(String.valueOf(Integer.parseInt(valvePowerStyle,16)));
//允许的最大挡位
String panelPowerStyle = valueData.substring(46,48);
tControllerValuesData.setPanelPowerTyle(String.valueOf(Integer.parseInt(panelPowerStyle,16)));
//对码状态
String pairingStatus = valueData.substring(48,50);
tControllerValuesData.setPairingStatus(String.valueOf(Integer.parseInt(pairingStatus,16)));
//阀门累计开时间 单位秒
String cumulativeOpenedTime = valueData.substring(50,58);
tControllerValuesData.setCumulativeOpenedTime(String.valueOf(Integer.parseInt(cumulativeOpenedTime,16)));
//阀门累计工作时间 单位秒
String cumulativeWorkingTime = valueData.substring(58,66);
tControllerValuesData.setCumulativeWorkingTime(String.valueOf(Integer.parseInt(cumulativeWorkingTime,16)));
//实时时间
String dateTimeValue = valueData.substring(66,80);
try {
tControllerValuesData.setDateTimeValue(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse( DateTimeValueUtil.getDateTimeStr(dateTimeValue)));
} catch (ParseException e) {
logger.error("阀控数据时间解析失败！");
}
//状态
String status = valueData.substring(80,84);
tControllerValuesData.setStatus("高位："+HexUtils.hexToBinary(status.substring(0,2))+" 低位：" +HexUtils.hexToBinary(status.substring(2,4)));
//累计阀开/关次数
String cumulativeOpenSndCloseTimes = valueData.substring(84,92);
tControllerValuesData.setCumulativeOpenAndCloseTimes(String.valueOf(Integer.parseInt(cumulativeOpenSndCloseTimes,16)));
//累计室温*时间（分钟）
String cumulativeIndoorTempMultiplySecond = valueData.substring(92,100);
tControllerValuesData.setCumulativeIndoorTempMultiplySecond(String.valueOf(Integer.parseInt(cumulativeIndoorTempMultiplySecond,16)));
//软件版本
String softwareVersion = valueData.substring(100,104);
tControllerValuesData.setSoftwareVersion(softwareVersion);
//频点
String freq = valueData.substring(104,106);
tControllerValuesData.setFreq(freq);
String snum = valueData.substring(106,108);
tControllerValuesData.setSnum(snum);
return tControllerValuesData;
}
}
src/main/java/com/zehong/netty/handler/TcpServerHandler.java 0 → 100644
View file @ 86fbb808
package com.zehong.netty.handler;
import com.zehong.enums.MessageTypeEnum;
import com.zehong.netty.decode.InformationDecode;
import com.zehong.netty.decode.MsgDecode;
import com.zehong.utils.HexUtils;
import com.zehong.utils.RedisUtil;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.socket.SocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.UnsupportedEncodingException;
import java.util.Date;
/**
* @author gengd
* 物联网 开启检测端口 并写入数据库
*/
@Component
@Sharable
public class TcpServerHandler extends ChannelInboundHandlerAdapter {
private Logger logger = LoggerFactory.getLogger(TcpServerHandler.class);
@Autowired
private RedisUtil redisUtil;
@Override
public void channelActive(ChannelHandlerContext ctx) {
SocketChannel channel = (SocketChannel) ctx.channel();
logger.info("链接报告开始");
logger.info("链接报告信息：有一客户端链接到本服务端");
logger.info("链接报告IP:{}", channel.localAddress().getHostString());
logger.info("链接报告Port:{}", channel.localAddress().getPort());
logger.info("链接报告完毕");
//通知客户端链接建立成功
String str = "通知客户端链接建立成功" + " " + new Date() + " " + channel.localAddress().getHostString() + "\r\n";
ctx.writeAndFlush(str);
}
/**
* 当客户端主动断开服务端的链接后，这个通道就是不活跃的。也就是说客户端与服务端的关闭了通信通道并且不可以传输数据
*/
@Override
public void channelInactive(ChannelHandlerContext ctx){
logger.info("客户端断开链接{}", ctx.channel().localAddress().toString());
}
/**
* 获取数据
* @param ctx 上下文
* @param msg 获取的数据
* @throws UnsupportedEncodingException
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg){
ByteBuf buf = (ByteBuf)msg;
byte [] msgBytes = new byte[buf.readableBytes()];
buf.readBytes(msgBytes);
//16进制消息字符串
String msgStr = HexUtils.bytesToHex(msgBytes);
logger.info("tcp上传数据为：" + msgStr);
//解析上传数据
MsgDecode decode = new MsgDecode(msgStr);
if(!MessageTypeEnum.READ_DATA_RESPONSE.value.equals(decode.getMessageType())){
logger.info("此消息类型不做处理！");
return;
}
if(!decode.checkCRC32Code()){
logger.error("上传数据校验失败！");
return;
}
//解析信息单元
new InformationDecode(decode).infoMsgDecode();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
logger.error("tcp连接报错",cause);
cause.printStackTrace();
ctx.close();
}
}
src/main/java/com/zehong/service/ITControllerValuesDataService.java 0 → 100644
View file @ 86fbb808
package com.zehong.service;
import com.github.pagehelper.PageInfo;
import com.zehong.entity.TControllerValuesData;
import java.util.List;
/**
* 阀控数据Service接口
*
* @author zehong
* @date 2022-05-07
*/
public interface ITControllerValuesDataService {
/**
* 查询阀控数据
*
* @param controllerValueId 阀控数据ID
* @return 阀控数据
*/
TControllerValuesData selectTControllerValuesDataById(Long controllerValueId);
/**
* 查询阀控数据列表
*
* @param tControllerValuesData 阀控数据
* @return 阀控数据集合
*/
List<TControllerValuesData> selectTControllerValuesDataList(TControllerValuesData tControllerValuesData);
/**
* 查询阀控数据分页列表
*
* @param tControllerValuesData 阀控数据
* @return 阀控数据分页集合
*/
PageInfo<TControllerValuesData> selectTControllerValuesDataPage(TControllerValuesData tControllerValuesData);
/**
* 新增阀控数据
*
* @param tControllerValuesData 阀控数据
* @return 结果
*/
int insertTControllerValuesData(TControllerValuesData tControllerValuesData);
/**
* 修改阀控数据
*
* @param tControllerValuesData 阀控数据
* @return 结果
*/
int updateTControllerValuesData(TControllerValuesData tControllerValuesData);
/**
* 批量删除阀控数据
*
* @param controllerValueIds 需要删除的阀控数据ID
* @return 结果
*/
int deleteTControllerValuesDataByIds(Long[] controllerValueIds);
/**
* 删除阀控数据信息
*
* @param controllerValueId 阀控数据ID
* @return 结果
*/
int deleteTControllerValuesDataById(Long controllerValueId);
}
src/main/java/com/zehong/service/ITHeatDataService.java 0 → 100644
View file @ 86fbb808
package com.zehong.service;
import com.zehong.entity.THeatData;
import com.github.pagehelper.PageInfo;
import java.util.List;
/**
* 热量数据Service接口
*
* @author zehong
* @date 2022-05-07
*/
public interface ITHeatDataService {
/**
* 查询热量数据
*
* @param heatId 热量数据ID
* @return 热量数据
*/
THeatData selectTHeatDataById(Long heatId);
/**
* 查询热量数据列表
*
* @param tHeatData 热量数据
* @return 热量数据集合
*/
List<THeatData> selectTHeatDataList(THeatData tHeatData);
/**
* 查询热量数据分页列表
*
* @param tHeatData 热量数据
* @return 热量数据分页集合
*/
PageInfo<THeatData> selectTHeatDataPage(THeatData tHeatData);
/**
* 新增热量数据
*
* @param tHeatData 热量数据
* @return 结果
*/
int insertTHeatData(THeatData tHeatData);
/**
* 修改热量数据
*
* @param tHeatData 热量数据
* @return 结果
*/
int updateTHeatData(THeatData tHeatData);
/**
* 批量删除热量数据
*
* @param heatIds 需要删除的热量数据ID
* @return 结果
*/
int deleteTHeatDataByIds(Long[] heatIds);
/**
* 删除热量数据信息
*
* @param heatId 热量数据ID
* @return 结果
*/
int deleteTHeatDataById(Long heatId);
}
src/main/java/com/zehong/service/impl/TControllerValuesDataServiceImpl.java 0 → 100644
View file @ 86fbb808
package com.zehong.service.impl;
import cn.hutool.core.date.DateUtil;
import com.github.pagehelper.PageInfo;
import com.zehong.dao.TControllerValuesDataDao;
import com.zehong.entity.TControllerValuesData;
import com.zehong.service.ITControllerValuesDataService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
/**
* 阀控数据Service业务层处理
*
* @author zehong
* @date 2022-05-07
*/
@Service
public class TControllerValuesDataServiceImpl implements ITControllerValuesDataService {
@Resource
private TControllerValuesDataDao tControllerValuesDataDao;
/**
* 查询阀控数据
*
* @param controllerValueId 阀控数据ID
* @return 阀控数据
*/
@Override
public TControllerValuesData selectTControllerValuesDataById(Long controllerValueId){
return tControllerValuesDataDao.selectTControllerValuesDataById(controllerValueId);
}
/**
* 查询阀控数据列表
*
* @param tControllerValuesData 阀控数据
* @return 阀控数据
*/
@Override
public List<TControllerValuesData> selectTControllerValuesDataList(TControllerValuesData tControllerValuesData) {
return tControllerValuesDataDao.selectTControllerValuesDataList(tControllerValuesData);
}
/**
* 查询阀控数据分页列表
*
* @param tControllerValuesData 阀控数据
* @return 阀控数据
*/
@Override
public PageInfo<TControllerValuesData> selectTControllerValuesDataPage(TControllerValuesData tControllerValuesData) {
return new PageInfo(tControllerValuesDataDao.selectTControllerValuesDataList(tControllerValuesData));
}
/**
* 新增阀控数据
*
* @param tControllerValuesData 阀控数据
* @return 结果
*/
@Override
public int insertTControllerValuesData(TControllerValuesData tControllerValuesData){
tControllerValuesData.setCreateTime(DateUtil.date());
return tControllerValuesDataDao.insertTControllerValuesData(tControllerValuesData);
}
/**
* 修改阀控数据
*
* @param tControllerValuesData 阀控数据
* @return 结果
*/
@Override
public int updateTControllerValuesData(TControllerValuesData tControllerValuesData){
return tControllerValuesDataDao.updateTControllerValuesData(tControllerValuesData);
}
/**
* 批量删除阀控数据
*
* @param controllerValueIds 需要删除的阀控数据ID
* @return 结果
*/
@Override
public int deleteTControllerValuesDataByIds(Long[] controllerValueIds){
return tControllerValuesDataDao.deleteTControllerValuesDataByIds(controllerValueIds);
}
/**
* 删除阀控数据信息
*
* @param controllerValueId 阀控数据ID
* @return 结果
*/
@Override
public int deleteTControllerValuesDataById(Long controllerValueId){
return tControllerValuesDataDao.deleteTControllerValuesDataById(controllerValueId);
}
}
src/main/java/com/zehong/service/impl/THeatDataServiceImpl.java 0 → 100644
View file @ 86fbb808
package com.zehong.service.impl;
import cn.hutool.core.date.DateUtil;
import com.github.pagehelper.PageInfo;
import com.zehong.dao.THeatDataDao;
import com.zehong.entity.THeatData;
import com.zehong.service.ITHeatDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
/**
* 热量数据Service业务层处理
*
* @author zehong
* @date 2022-05-07
*/
@Service
public class THeatDataServiceImpl implements ITHeatDataService {
@Resource
private THeatDataDao tHeatDataDao;
/**
* 查询热量数据
*
* @param heatId 热量数据ID
* @return 热量数据
*/
@Override
public THeatData selectTHeatDataById(Long heatId){
return tHeatDataDao.selectTHeatDataById(heatId);
}
/**
* 查询热量数据列表
*
* @param tHeatData 热量数据
* @return 热量数据
*/
@Override
public List<THeatData> selectTHeatDataList(THeatData tHeatData){
return tHeatDataDao.selectTHeatDataList(tHeatData);
}
/**
* 查询热量数据分页列表
*
* @param tHeatData 热量数据
* @return 热量数据
*/
@Override
public PageInfo<THeatData> selectTHeatDataPage(THeatData tHeatData) {
return new PageInfo(tHeatDataDao.selectTHeatDataList(tHeatData));
}
/**
* 新增热量数据
*
* @param tHeatData 热量数据
* @return 结果
*/
@Override
public int insertTHeatData(THeatData tHeatData){
tHeatData.setCreateTime(DateUtil.date());
return tHeatDataDao.insertTHeatData(tHeatData);
}
/**
* 修改热量数据
*
* @param tHeatData 热量数据
* @return 结果
*/
@Override
public int updateTHeatData(THeatData tHeatData){
return tHeatDataDao.updateTHeatData(tHeatData);
}
/**
* 批量删除热量数据
*
* @param heatIds 需要删除的热量数据ID
* @return 结果
*/
@Override
public int deleteTHeatDataByIds(Long[] heatIds){
return tHeatDataDao.deleteTHeatDataByIds(heatIds);
}
/**
* 删除热量数据信息
*
* @param heatId 热量数据ID
* @return 结果
*/
@Override
public int deleteTHeatDataById(Long heatId){
return tHeatDataDao.deleteTHeatDataById(heatId);
}
}
src/main/java/com/zehong/utils/DateTimeValueUtil.java 0 → 100644
View file @ 86fbb808
package com.zehong.utils;
public class DateTimeValueUtil {
/**
* 时间转换
* @param dateTime 时间
* @return
*/
public static String getDateTimeStr(String dateTime){
StringBuilder dateTimeStr = new StringBuilder("");
dateTimeStr.append(Integer.parseInt(dateTime.substring(0,2),16))
.append(Integer.parseInt(dateTime.substring(2,4),16))
.append("-")
.append(Integer.parseInt(dateTime.substring(4,6),16))
.append("-")
.append(Integer.parseInt(dateTime.substring(6,8),16))
.append(" ")
.append(Integer.parseInt(dateTime.substring(8,10),16))
.append(":")
.append(Integer.parseInt(dateTime.substring(10,12),16))
.append(":")
.append(Integer.parseInt(dateTime.substring(12,14),16));
return dateTimeStr.toString();
}
}
src/main/java/com/zehong/utils/HexUtils.java 0 → 100644
View file @ 86fbb808
package com.zehong.utils;
import java.math.BigInteger;
public class HexUtils {
/**
* 字节转十六进制
* @param b 需要进行转换的byte字节
* @return 转换后的Hex字符串
*/
public static String byteToHex(byte b){
String hex = Integer.toHexString(b & 0xFF);
if(hex.length() < 2){
hex = "0" + hex;
}
return hex;
}
/**
* 字节数组转16进制
* @param bytes 需要转换的byte数组
* @return 转换后的Hex字符串
*/
public static String bytesToHex(byte[] bytes) {
StringBuffer sb = new StringBuffer();
for(int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(bytes[i] & 0xFF);
if(hex.length() < 2){
sb.append(0);
}
sb.append(hex);
}
return sb.toString();
}
/**
* Hex字符串转byte
* @param inHex 待转换的Hex字符串
* @return 转换后的byte
*/
public static byte hexToByte(String inHex){
return (byte)Integer.parseInt(inHex,16);
}
/**
* hex字符串转byte数组
* @param inHex 待转换的Hex字符串
* @return 转换后的byte数组结果
*/
public static byte[] hexToByteArray(String inHex){
int hexlen = inHex.length();
byte[] result;
if (hexlen % 2 == 1){
//奇数
hexlen++;
result = new byte[(hexlen/2)];
inHex="0"+inHex;
}else {
//偶数
result = new byte[(hexlen/2)];
}
int j=0;
for (int i = 0; i < hexlen; i+=2){
result[j]=hexToByte(inHex.substring(i,i+2));
j++;
}
return result;
}
/**
* 十六进制转单浮点
* @param hex
* @return
*/
public static float hexToFloat(String hex){
//Integer i = Integer.valueOf(hex.trim(), 16);
//return Float.intBitsToFloat(i);
return Float.intBitsToFloat(new BigInteger(hex.trim(), 16).intValue());
}
/**
* 十六进制转浮点
* @param hex
* @return
*/
public static double hexToDouble(String hex){
Long l = Long.valueOf(hex,16).longValue();
return Double.longBitsToDouble(l);
}
/**
* 十六进制转二进制
* @param hex
* @return
*/
public static String hexToBinary(String hex){
Integer num = Integer.parseInt(hex,16);
return Integer.toBinaryString(num);
}
}
src/main/java/com/zehong/utils/NettyClient.java 0 → 100644
View file @ 86fbb808
package com.zehong.utils;
import com.zehong.utils.client.NettyClientHandler;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import lombok.extern.slf4j.Slf4j;
/**
* @author gengd
* netty客户端
*/
@Slf4j
public class NettyClient {
/**
* 创建netty客户端并发送信息
* @param msg 发送消息
* @param host 地址
* @param port 端口
*/
public static String nettyConnection(String msg,String host,int port) {
NettyClientHandler nettyClientHandler = new NettyClientHandler();
EventLoopGroup group = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap()
.group(group)
//该参数的作用就是禁止使用Nagle算法，使用于小数据即时传输
.option(ChannelOption.TCP_NODELAY, true)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast("decoder", new StringDecoder());
socketChannel.pipeline().addLast("encoder", new StringEncoder());
socketChannel.pipeline().addLast(nettyClientHandler);
}
});
try {
ChannelFuture future = bootstrap.connect(host, port).sync();
log.info("客户端发送成功....");
//发送消息
future.channel().writeAndFlush(msg);
// 等待连接被关闭
future.channel().closeFuture().sync();
return nettyClientHandler.getResponseMsg();
} catch (Exception e) {
log.error("客户端Netty失败", e);
} finally {
//以一种优雅的方式进行线程退出
group.shutdownGracefully();
}
return null;
}
}
src/main/java/com/zehong/utils/RedisUtil.java 0 → 100644
View file @ 86fbb808
This diff is collapsed.
src/main/java/com/zehong/utils/SpringUtil.java 0 → 100644
View file @ 86fbb808
package com.zehong.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* Spring ApplicationContext 工具类
*/
@SuppressWarnings("unchecked")
@Component
public class SpringUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringUtil.applicationContext = applicationContext;
}
public static <T> T getBean(String beanName) {
if(applicationContext.containsBean(beanName)){
return (T) applicationContext.getBean(beanName);
}else{
return null;
}
}
public static <T> T getBean(Class beanClass) {
return (T) applicationContext.getBean(beanClass);
}
public static <T> Map<String, T> getBeansOfType(Class<T> baseType){
return applicationContext.getBeansOfType(baseType);
}
}
src/main/java/com/zehong/utils/client/NettyClientHandler.java 0 → 100644
View file @ 86fbb808
package com.zehong.utils.client;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
/**
* 接收服务器返回信息
*/
private String responseMsg;
public String getResponseMsg() {
return responseMsg;
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
log.info("客户端Active .....");
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
log.info("客户端收到消息: {}", msg.toString());
//自定义返回体
this.responseMsg = msg.toString();
ctx.close();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
log.error("netty 客户端发生错误：" + cause);
ctx.close();
}
}
src/main/resources/application-test.yml 0 → 100644
View file @ 86fbb808
# logging path
logging:
file:
path: ./logs
#mysql
spring:
datasource:
username: root
password: root@123
url: jdbc:mysql://36.148.23.59:3306/gas_db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
driver-class-name: com.mysql.jdbc.Driver
# redis 配置
redis:
# 地址
host: 36.148.23.59
# 端口，默认为6379
port: 6379
# 数据库索引
database: 6
# 密码
password: 1qaz2wsx3edc
# 连接超时时间
timeout: 10s
lettuce:
pool:
# 连接池中的最小空闲连接
min-idle: 0
# 连接池中的最大空闲连接
max-idle: 8
# 连接池的最大数据库连接数
max-active: 8
# #连接池最大阻塞等待时间（使用负值表示没有限制）
max-wait: -1ms
TCPNetty:
ports: 2496
# 分包消息接收确认
confirmClient:
host: 127.0.0.1
port: 8082
src/main/resources/application.yml 0 → 100644
View file @ 86fbb808
server:
port: 8079
servlet:
context-path: /supplyHeatDeviceDataCollection
spring:
profiles:
active: test
\ No newline at end of file
src/main/resources/logback-spring.xml 0 → 100644
View file @ 86fbb808
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="true">
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
<conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
<conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
<property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint} %clr(%X{TRANCE_ID:-}) %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(-&#45;&#45;){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
<property name="FILE_LOG_PATTERN" value="${FILE_LOG_PATTERN:-%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}} %X{TRANCE_ID:-} ${LOG_LEVEL_PATTERN:-%5p} ${PID:- } -&#45;&#45; [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
<property name="LOG_FILE" value="supplyheatdevicedatacollection.log"/>
<!-- 控制台输出配置 -->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
</encoder>
</appender>
<!-- 文件输出配置 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<encoder>
<pattern>${FILE_LOG_PATTERN}</pattern>
</encoder>
<file>${LOG_PATH}/${LOG_FILE}</file>
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!-- 分片格式以及压缩设置 -->
<fileNamePattern>${LOG_PATH}/${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz</fileNamePattern>
<!-- 单个分片文件大小，默认是10M(压缩前) -->
<maxFileSize>${LOG_FILE_MAX_SIZE:-10MB}</maxFileSize>
<!-- 日志保存的最大时间，默认是永久保存 -->
<maxHistory>${LOG_FILE_MAX_HISTORY:-30}</maxHistory>
</rollingPolicy>
</appender>
<root level="INFO">
<appender-ref ref="CONSOLE" />
<appender-ref ref="FILE" />
</root>
</configuration>
\ No newline at end of file
src/main/resources/mapper/TControllerValuesDataMapper.xml 0 → 100644
View file @ 86fbb808
This diff is collapsed.
src/main/resources/mapper/THeatDataMapper.xml 0 → 100644
View file @ 86fbb808
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment