code-image-backup-public/fastbee
1
0
Fork 0
mirror of https://gitee.com/beecue/fastbee.git synced 2025-12-17 08:25:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

!32 增加时序数据库TDengine支持

Browse Source 
Merge pull request !32 from xxmfl/master
This commit is contained in:
随遇而安
2022-05-23 03:40:19 +00:00
committed by Gitee
parent 7e00d8c0d6 c43459e987
commit 8fb4f017e5
16 changed files with 834 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
springboot/wumei-admin/src/main/resources/application-druid.yml
View File

@@ -16,6 +16,16 @@ spring:
url:
username:
password:
#TDengine数据库
tdengine-server:
enabled: true
driverClassName: com.taosdata.jdbc.TSDBDriver
url: jdbc:TAOS://127.0.0.1:6030/wumei_smart_log?timezone=Asia/Beijing&charset=utf-8
username: root
password: taosdata
dbName: wumei_smart_log
# 初始连接数
initialSize: 5
# 最小连接池数量

54
springboot/wumei-framework/src/main/java/com/ruoyi/framework/config/MyBatisConfig.java
View File

@@ -1,18 +1,34 @@
package com.ruoyi.framework.config;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.*;
import javax.servlet.*;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
import com.alibaba.druid.util.Utils;
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.config.properties.DruidProperties;
import com.ruoyi.framework.datasource.DynamicDataSource;
import org.apache.ibatis.io.VFS;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.annotation.Order;
import org.springframework.core.env.Environment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
@@ -21,17 +37,18 @@ import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.util.ClassUtils;
import com.ruoyi.common.utils.StringUtils;
/**
* Mybatis支持*匹配扫描包
*
*
* @author ruoyi
*/
@Configuration
public class MyBatisConfig
{
@MapperScan(basePackages = {"com.ruoyi.iot.mapper", "com.ruoyi.system.mapper", "com.ruoyi.quartz.mapper", "com.ruoyi.generator.mapper"}, sqlSessionTemplateRef = "mysqlSqlSessionTemplate")
public class MyBatisConfig {
@Autowired
private Environment env;
@@ -113,11 +130,13 @@ public class MyBatisConfig
return resources.toArray(new Resource[resources.size()]);
}
@Bean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception
@Bean(name = "mysqlSessionFactory")
@Primary
public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dataSource) throws Exception
{
String typeAliasesPackage = env.getProperty("mybatis.typeAliasesPackage");
String mapperLocations = env.getProperty("mybatis.mapperLocations");
String typeAliasesPackage = "com.ruoyi.**.domain";//env.getProperty("mybatis.typeAliasesPackage");
String mapperLocations = "classpath:mapper/iot/*Mapper.xml,classpath:mapper/system/*Mapper.xml,classpath:mapper/quartz/*Mapper.xml";
// String typeAliasesPackage = "com.ruoyi.**.domain";
String configLocation = env.getProperty("mybatis.configLocation");
typeAliasesPackage = setTypeAliasesPackage(typeAliasesPackage);
VFS.addImplClass(SpringBootVFS.class);
@@ -129,4 +148,17 @@ public class MyBatisConfig
sessionFactory.setConfigLocation(new DefaultResourceLoader().getResource(configLocation));
return sessionFactory.getObject();
}
@Bean(name = "mysqlTransactionManager")
@Primary
public DataSourceTransactionManager mysqlTransactionManager(@Qualifier("dynamicDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
@Bean(name = "mysqlSqlSessionTemplate")
@Primary
public SqlSessionTemplate mysqlSqlSessionTemplate(@Qualifier("mysqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
}

9
springboot/wumei-iot/pom.xml
View File

@@ -89,6 +89,15 @@
</dependency>
<!-- TDengine连接 START-->
<dependency>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.38</version>
</dependency>
<!-- TDengine连接 END-->
</dependencies>
</project>

15
springboot/wumei-iot/src/main/java/com/ruoyi/iot/domain/DeviceLog.java
View File

@@ -5,9 +5,11 @@ import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;
import java.util.Date;
/**
* 设备日志对象 iot_device_log
*
*
* @author kerwincui
* @date 2022-01-13
*/
@@ -15,6 +17,8 @@ public class DeviceLog extends BaseEntity
{
private static final long serialVersionUID = 1L;
@Excel(name = "时间戳")
private Date ts;
/** 设备日志ID */
private Long logId;
@@ -46,6 +50,15 @@ public class DeviceLog extends BaseEntity
@Excel(name = "是否监测数据", readConverterExp = "1==是，0=否")
private Integer isMonitor;
public Date getTs() {
return ts;
}
public void setTs(Date ts) {
this.ts = ts;
}
public String getSerialNumber() {
return serialNumber;
}

76
springboot/wumei-iot/src/main/java/com/ruoyi/iot/init/ApplicationStarted.java Normal file
View File

@@ -0,0 +1,76 @@
package com.ruoyi.iot.init;
//import com.ruoyi.mysql.config.TDengineConfig;
//import com.ruoyi.iot.tdengine.config.TDengineConfig;
import com.alibaba.druid.pool.DruidDataSource;
import com.ruoyi.iot.tdengine.config.TDengineConfig;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.mapper.DeviceMapper;
import com.ruoyi.iot.tdengine.mapper.TDDeviceLogMapper;
import org.mybatis.spring.SqlSessionTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
import java.util.Date;
/**
* 类名: ApplicationStarted
* 描述: TODO
* 时间: 2022/5/18,0018 1:41
* 开发人: wxy
*/
@Component
public class ApplicationStarted implements ApplicationRunner {
private static final Logger LOGGER = LoggerFactory.getLogger(ApplicationStarted.class);
@Autowired
private TDengineConfig dengineConfig;
@Autowired
private TDDeviceLogMapper deviceLogMapper;
@Autowired
private DeviceMapper deviceMapper;
@Override
public void run(ApplicationArguments args) {
deviceMapper.selectDeviceByDeviceId(0L);
System.out.println("初始化MySql链接成功");
initTDengine();
System.out.println("初始化TDengine链接成功");
}
/**
* @Method
* @Description 开始初始化加载系统参数,创建数据库和超级表
* @Param null
* @return
* @date 2022/5/22,0022 14:27
* @author wxy
*
*/
public void initTDengine() {
try {
String dbName = dengineConfig.getDbName();
int db = deviceLogMapper.createDB(dbName);
deviceLogMapper.createSTable(dbName);
System.out.println(db);
} catch (Exception e) {
e.printStackTrace();
System.out.println("ERROR");
}
}
}

25
springboot/wumei-iot/src/main/java/com/ruoyi/iot/log/service/ILogService.java Normal file
View File

@@ -0,0 +1,25 @@
package com.ruoyi.iot.log.service;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.model.MonitorModel;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
* @package iot.iot.log
* 类名: LogService
* 描述: 设备日志记录接口
* 时间: 2022/5/19,0019 18:04
* 开发人: admin
*/
public interface ILogService {
int saveDeviceLog(DeviceLog deviceLog);
List<DeviceLog> selectDeviceLogList(DeviceLog deviceLog);
List<MonitorModel> selectMonitorList(DeviceLog deviceLog);
}

74
springboot/wumei-iot/src/main/java/com/ruoyi/iot/log/service/factory/LogServiceFactory.java Normal file
View File

@@ -0,0 +1,74 @@
package com.ruoyi.iot.log.service.factory;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.framework.config.MyBatisConfig;
import com.ruoyi.iot.log.service.impl.MySqlLogServiceImpl;
import com.ruoyi.iot.log.service.impl.TdengineLogServiceImpl;
import com.ruoyi.iot.model.MonitorModel;
import com.ruoyi.iot.tdengine.config.TDengineConfig;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.log.service.ILogService;
import com.ruoyi.iot.mapper.DeviceLogMapper;
import com.ruoyi.iot.tdengine.mapper.TDDeviceLogMapper;
import com.ruoyi.iot.util.SnowflakeIdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.lang.Nullable;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* 类名: DeviceLogServiceImpl
* 描述: TODO
* 时间: 2022/5/19,0019 18:09
* 开发人: wxy
*/
@Component
public class LogServiceFactory {
@Autowired
private ApplicationContext applicationContext;
@Bean
public ILogService getLogService() {
//先获取TDengine的配置，检测TDengine是否已经配置
if (containBean(TDengineConfig.class)) {
TDengineConfig tDengineConfig = applicationContext.getBean(TDengineConfig.class);
TDDeviceLogMapper tDDeviceLogMapper = applicationContext.getBean(TDDeviceLogMapper.class);
ILogService logService = new TdengineLogServiceImpl(tDengineConfig, tDDeviceLogMapper);
return logService;
} else if (containBean(MyBatisConfig.class)) {
//没有配置TDengine，那么使用MySQL的日志配置
DeviceLogMapper deviceLogMapper = applicationContext.getBean( DeviceLogMapper.class);
ILogService logService = new MySqlLogServiceImpl(deviceLogMapper);
return logService;
} else {
return null;
}
}
/**
* @Method containBean
* @Description 根据类判断是否有对应bean
* @Param 类
* @return
* @date 2022/5/22,0022 14:12
* @author wxy
*
*/
private boolean containBean(@Nullable Class<?> T) {
String[] beans = applicationContext.getBeanNamesForType(T);
if (beans == null || beans.length == 0) {
return false;
} else {
return true;
}
}
}

38
springboot/wumei-iot/src/main/java/com/ruoyi/iot/log/service/impl/MySqlLogServiceImpl.java Normal file
View File

@@ -0,0 +1,38 @@
package com.ruoyi.iot.log.service.impl;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.log.service.ILogService;
import com.ruoyi.iot.mapper.DeviceLogMapper;
import com.ruoyi.iot.model.MonitorModel;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 类名: MySqlLogServiceImpl
* 描述: MySQL存储日志实现类
* 时间: 2022/5/22,0022 13:37
* 开发人: admin
*/
public class MySqlLogServiceImpl implements ILogService {
private DeviceLogMapper deviceLogMapper;
public MySqlLogServiceImpl(DeviceLogMapper _deviceLogMapper){
this.deviceLogMapper=_deviceLogMapper;
}
@Override
public int saveDeviceLog(DeviceLog deviceLog) {
return deviceLogMapper.insertDeviceLog(deviceLog);
}
@Override
public List<DeviceLog> selectDeviceLogList(DeviceLog deviceLog) {
return deviceLogMapper.selectDeviceLogList(deviceLog);
}
@Override
public List<MonitorModel> selectMonitorList(DeviceLog deviceLog) {
return deviceLogMapper.selectMonitorList(deviceLog);
}
}

57
springboot/wumei-iot/src/main/java/com/ruoyi/iot/log/service/impl/TdengineLogServiceImpl.java Normal file
View File

@@ -0,0 +1,57 @@
package com.ruoyi.iot.log.service.impl;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.log.service.ILogService;
import com.ruoyi.iot.model.MonitorModel;
import com.ruoyi.iot.tdengine.config.TDengineConfig;
import com.ruoyi.iot.tdengine.mapper.TDDeviceLogMapper;
import com.ruoyi.iot.util.SnowflakeIdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 类名: TdengineLogServiceImpl
* 描述: TDengine存储日志数据实现类
* 时间: 2022/5/22,0022 13:38
* 开发人: admin
*/
public class TdengineLogServiceImpl implements ILogService {
private ApplicationContext applicationContext;
private TDDeviceLogMapper tdDeviceLogMapper;
private TDengineConfig tDengineConfig;
private SnowflakeIdWorker snowflakeIdWorker;
private String dbName;
public TdengineLogServiceImpl(TDengineConfig _tDengineConfig,TDDeviceLogMapper _tdDeviceLogMapper) {
this.tdDeviceLogMapper = _tdDeviceLogMapper;
this.tDengineConfig = _tDengineConfig;
snowflakeIdWorker=new SnowflakeIdWorker(1);
this.dbName=_tDengineConfig.getDbName();
}
@Override
public int saveDeviceLog(DeviceLog deviceLog) {
long logId = snowflakeIdWorker.nextId();
deviceLog.setLogId(logId);
return tdDeviceLogMapper.save(dbName,deviceLog);
}
@Override
public List<DeviceLog> selectDeviceLogList(DeviceLog deviceLog) {
return tdDeviceLogMapper.selectDeviceLogList(dbName,deviceLog);
}
@Override
public List<MonitorModel> selectMonitorList(DeviceLog deviceLog) {
return tdDeviceLogMapper.selectMonitorList(dbName,deviceLog);
}
}

9
springboot/wumei-iot/src/main/java/com/ruoyi/iot/mqtt/EmqxService.java
View File

@@ -3,6 +3,7 @@ package com.ruoyi.iot.mqtt;
import com.alibaba.fastjson.JSON;
import com.ruoyi.iot.domain.Device;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.log.service.ILogService;
import com.ruoyi.iot.model.NtpModel;
import com.ruoyi.iot.model.ThingsModels.IdentityAndName;
import com.ruoyi.iot.model.ThingsModels.ThingsModelValueItem;
@@ -32,8 +33,11 @@ public class EmqxService {
@Autowired
private IDeviceService deviceService;
// @Autowired
// private IDeviceLogService deviceLogService;
@Autowired
private IDeviceLogService deviceLogService;
private ILogService logService;
/**
* 订阅的主题
@@ -190,7 +194,8 @@ public class EmqxService {
deviceLog.setIdentity(thingsModelValueRemarkItems.get(i).getId());
deviceLog.setLogType(3);
deviceLog.setIsMonitor(0);
deviceLogService.insertDeviceLog(deviceLog);
// deviceLogService.insertDeviceLog(deviceLog);
logService.saveDeviceLog(deviceLog);
}
} catch (Exception e) {
logger.error("接收事件，解析数据时异常 message={}", e.getMessage());

113
springboot/wumei-iot/src/main/java/com/ruoyi/iot/tdengine/config/TDengineConfig.java Normal file
View File

@@ -0,0 +1,113 @@
package com.ruoyi.iot.tdengine.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.iot.tdengine.mapper.TDDeviceLogMapper;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import javax.sql.DataSource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 类名: TDengineConfig
* 描述: TDengine配置类
* 时间: 2022/5/13,0016 1:14
* 开发人: wxy
*/
@Configuration
@MapperScan(basePackages = {"com.ruoyi.iot.tdengine.mapper"}, sqlSessionTemplateRef = "tdengineSqlSessionTemplate")
@ConditionalOnProperty(name = "spring.datasource.druid.tdengine-server.enabled", havingValue = "true")
public class TDengineConfig {
@Autowired
private TDDeviceLogMapper deviceLogMapper;
@Value("${spring.datasource.druid.tdengine-server.dbName}")
private String dbName;
@Bean(name = "tDengineDataSource")
@ConfigurationProperties(prefix = "spring.datasource.druid.tdengine-server")
public DataSource tdengineDataSource() {
return new DruidDataSource();
}
@Bean(name = "tDengineSqlSessionFactory")
public SqlSessionFactory tDengineSqlSessionFactory(@Qualifier("tDengineDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setMapperLocations(resolveMapperLocations(StringUtils.split("classpath:mapper/tdengine/*Mapper.xml", ",")));
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean.getObject();
}
@Bean(name = "tdengineSqlSessionTemplate")
public SqlSessionTemplate tdengineSqlSessionTemplate(@Qualifier("tDengineSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
// @Bean
// @ConditionalOnProperty(name = "spring.datasource.druid.tdengine-server.enabled", havingValue = "true")
// public TDDeviceLogMapper genTdengineLogMapper(@Qualifier("tDengineDataSource") TDDeviceLogMapper mapper) {
// if(this.deviceLogMapper==null){
// this.deviceLogMapper=mapper;
// }
// return this.deviceLogMapper;
// }
public TDDeviceLogMapper getTDengineLogMapper() {
return deviceLogMapper;
}
public String getDbName() {
return dbName;
}
public void setDbName(String dbName) {
this.dbName = dbName;
}
public Resource[] resolveMapperLocations(String[] mapperLocations)
{
ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
List<Resource> resources = new ArrayList<Resource>();
if (mapperLocations != null)
{
for (String mapperLocation : mapperLocations)
{
try
{
Resource[] mappers = resourceResolver.getResources(mapperLocation);
resources.addAll(Arrays.asList(mappers));
}
catch (IOException e)
{
// ignore
}
}
}
return resources.toArray(new Resource[resources.size()]);
}
}

25
springboot/wumei-iot/src/main/java/com/ruoyi/iot/tdengine/mapper/DatabaseMapper.java Normal file
View File

@@ -0,0 +1,25 @@
package com.ruoyi.iot.tdengine.mapper;
import org.springframework.stereotype.Repository;
/**
* @package com.ruoyi.mysql.mysql.tdengine
* 类名: DatabaseMapper
* 描述: TODO
* 时间: 2022/5/16,0016 1:27
* 开发人: wxy
*/
@Repository
public interface DatabaseMapper {
int createDB();
int dropDatabase();
int useDatabase();
int createTable();
}

42
springboot/wumei-iot/src/main/java/com/ruoyi/iot/tdengine/mapper/TDDeviceLogMapper.java Normal file
View File

@@ -0,0 +1,42 @@
package com.ruoyi.iot.tdengine.mapper;
import com.ruoyi.iot.domain.DeviceLog;
import com.ruoyi.iot.model.MonitorModel;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.lang.management.MonitorInfo;
import java.util.Date;
import java.util.List;
/**
* @package com.ruoyi.mysql.mysql.tdengine
* 类名: DatabaseMapper
* 描述: TODO
* 时间: 2022/5/16,0016 1:27
* 开发人: wxy
*/
@Repository
public interface TDDeviceLogMapper {
int createDB( String database);
int createSTable(String database);
int createTable(String database,String deviceId);
int save(@Param("database") String database,@Param("device") DeviceLog deviceLog);
List<DeviceLog> selectSTable(String database,DeviceLog deviceLog);
int delete(String dbName, DeviceLog deviceLog);
// List<DeviceLog> selectLogListByPage(String dbName, Integer pageSize, Integer pageNum, String deviceNum, Date beginDate, Date endDate);
List<DeviceLog> selectLogList(String dbName, Long deviceId, String serialNumber, Long isMonitor, Long logType, Date beginDate, Date endDate);
List<MonitorModel> selectMonitorList(@Param("database") String database, @Param("device") DeviceLog deviceLog);
List<DeviceLog> selectDeviceLogList(@Param("database") String database,@Param("device") DeviceLog deviceLog);
}

104
springboot/wumei-iot/src/main/java/com/ruoyi/iot/util/SnowflakeIdWorker.java Normal file
View File

@@ -0,0 +1,104 @@
package com.ruoyi.iot.util;
public class SnowflakeIdWorker {
/**
* 开始时间：2020-01-01 00:00:00
*/
private final long beginTs = 1577808000000L;
private final long workerIdBits = 10;
/**
* 2^10 - 1 = 1023
*/
private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
private final long sequenceBits = 12;
/**
* 2^12 - 1 = 4095
*/
private final long maxSequence = -1L ^ (-1L << sequenceBits);
/**
* 时间戳左移22位
*/
private final long timestampLeftOffset = workerIdBits + sequenceBits;
/**
* 业务ID左移12位
*/
private final long workerIdLeftOffset = sequenceBits;
/**
* 合并了机器ID和数据标示ID，统称业务ID，10位
*/
private long workerId;
/**
* 毫秒内序列，12位，2^12 = 4096个数字
*/
private long sequence = 0L;
/**
* 上一次生成的ID的时间戳，同一个worker中
*/
private long lastTimestamp = -1L;
public SnowflakeIdWorker(long workerId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("WorkerId必须大于或等于0且小于或等于%d", maxWorkerId));
}
this.workerId = workerId;
}
public synchronized long nextId() {
long ts = System.currentTimeMillis();
if (ts < lastTimestamp) {
throw new RuntimeException(String.format("系统时钟回退了%d毫秒", (lastTimestamp - ts)));
}
// 同一时间内，则计算序列号
if (ts == lastTimestamp) {
// 序列号溢出
if (++sequence > maxSequence) {
ts = tilNextMillis(lastTimestamp);
sequence = 0L;
}
} else {
// 时间戳改变，重置序列号
sequence = 0L;
}
lastTimestamp = ts;
// 0 - 00000000 00000000 00000000 00000000 00000000 0 - 00000000 00 - 00000000 0000
// 左移后，低位补0，进行按位或运算相当于二进制拼接
// 本来高位还有个0<<63，0与任何数字按位或都是本身，所以写不写效果一样
return (ts - beginTs) << timestampLeftOffset | workerId << workerIdLeftOffset | sequence;
}
/**
* 阻塞到下一个毫秒
*
* @param lastTimestamp
* @return
*/
private long tilNextMillis(long lastTimestamp) {
long ts = System.currentTimeMillis();
while (ts <= lastTimestamp) {
ts = System.currentTimeMillis();
}
return ts;
}
public static void main(String[] args) {
SnowflakeIdWorker snowflakeIdWorker = new SnowflakeIdWorker(7);
for (int i = 0; i < 10; i++) {
long id = snowflakeIdWorker.nextId();
System.out.println(id);
}
}
}

58
springboot/wumei-iot/src/main/resources/mapper/tdengine/DatabaseMapper.xml Normal file
View File

@@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.iot.tdengine.mapper.DatabaseMapper">
<!-- 创建数据库-->
<update id="createDB" parameterType="java.lang.String">
create database if not exists ${dbName};
</update>
<!-- 删除数据库-->
<update id="dropDatabase" parameterType="java.lang.String">
DROP database if exists ${dbName};
</update>
<!-- 使用数据库-->
<update id="useDatabase" parameterType="java.lang.String">
use ${dbName};
</update>
<update id="createsTable">
create stable if not exists ${tableName}
(ts timestamp,
log_id BIGINT,
identity NCHAR(100),
log_type NCHAR(20),
log_value NCHAR(100),
device_id BIGINT,
device_name NCHAR(100),
serial_number NCHAR(100),
is_monitor int,
create_by NCHAR(100),
create_time timestamp,
remark NCHAR(1000),
);
</update>
<update id="createTable">
create stable if not exists ${tableName}
(ts timestamp,
log_id BIGINT,
identity NCHAR(100),
log_type NCHAR(20),
log_value NCHAR(100),
device_id BIGINT,
device_name NCHAR(100),
serial_number NCHAR(100),
is_monitor int,
create_by NCHAR(100),
create_time timestamp,
remark NCHAR(1000),
);
</update>
</mapper>

139
springboot/wumei-iot/src/main/resources/mapper/tdengine/TDDeviceLogMapper.xml Normal file
View File

@@ -0,0 +1,139 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.iot.tdengine.mapper.TDDeviceLogMapper">
<resultMap id="BaseResultMap" type="com.ruoyi.iot.domain.DeviceLog">
<id column="ts" property="ts"/>
<result column="log_id" property="logId"/>
<result column="device_name" property="deviceName"/>
<result column="serial_number" property="serialNumber"/>
<result column="log_type" property="logType"/>
<result column="log_value" property="logValue"/>
<result column="identity" property="identity"/>
<result column="is_monitor" property="isMonitor"/>
<result column="create_by" property="createBy"/>
<result column="create_time" property="createTime"/>
<result column="remark" property="remark"/>
</resultMap>
<resultMap type="com.ruoyi.iot.model.MonitorModel" id="MonitorResult">
<result property="value" column="log_value" />
<result property="time" column="create_time" />
</resultMap>
<resultMap type="com.ruoyi.iot.domain.DeviceLog" id="DeviceLogResult">
<result property="logId" column="log_id" />
<result property="logType" column="log_type" />
<result property="logValue" column="log_value" />
<result property="deviceId" column="device_id" />
<result property="deviceName" column="device_name" />
<result property="serialNumber" column="serial_number" />
<result property="identity" column="identity" />
<result property="createBy" column="create_by" />
<result property="isMonitor" column="is_monitor" />
<result property="createTime" column="create_time" />
<result property="remark" column="remark" />
</resultMap>
<update id="createDB">
create database if not exists ${database};
</update>
<update id="createSTable">
create STABLE if not exists ${database}.device_log
(
ts timestamp,
log_id BIGINT,
log_type TINYINT,
`identity` BINARY(100),
`log_value` BINARY(100),
is_monitor TINYINT,
create_by BINARY(100),
create_time timestamp,
remark BINARY(500)
)
TAGS(
device_id BIGINT,
device_name BINARY(100),
serial_number BINARY(50));
</update>
<update id="createTable">
create TABLE if not exists ${database}.${tableName}
USING ${database}.device_${deviceId} TAGS(log_type,is_monitor,create_by,create_time,remark)
(ts2 timestamp,
log_type BINARY(100)
);
</update>
<select id="selectSTable" resultMap="BaseResultMap">
select
*
from ${database}.device_log
order by ts desc
</select>
<insert id="save" parameterType="com.ruoyi.iot.domain.DeviceLog">
INSERT INTO ${database}.device_${device.serialNumber} USING device_log
TAGS (#{device.deviceId},#{device.deviceName},#{device.serialNumber})
VALUES (now, #{device.logId}, #{device.logType},#{device.identity},#{device.logValue},#{device.isMonitor},#{device.createBy},now,#{device.remark} );
</insert>
<delete id="delete" parameterType="com.ruoyi.iot.domain.DeviceLog">
delete from ${database}.device_${device.serialNumber}
<where>
<if test="logId !=null">
log_id = #{logId}
</if>
<if test="deviceId !=null and deviceId!=''">
device_id = #{deviceId}
</if>
<if test="serialNumber !=null and serialNumber!=''">
serial_number = #{serialNumber}
</if>
</where>
</delete>
<select id="selectLogList" resultMap="BaseResultMap">
select * from ${database}.device_log
<where>
<if test="deviceId != null "> and device_id = #{deviceId}</if>
<if test="serialNumber != null and serialNumber!=''"> and serial_number = #{serialNumber}</if>
<if test="isMonitor != null "> and is_monitor = #{isMonitor}</if>
<if test="logType != null "> and log_type = #{logType}</if>
<if test="beginDate != null "> and create_time &lt;= #{beginDate}</if>
<if test="endDate != null "> and create_time &gt;= #{endDate}</if>
</where>
order by ts desc
</select>
<select id="selectMonitorList" parameterType="com.ruoyi.iot.domain.DeviceLog" resultMap="MonitorResult">
select log_value, create_time from ${database}.device_log
<where>
is_monitor=1
<if test="device.deviceId!=null"> and device_id = #{device.deviceId} </if>
<if test="device.identity != null and device.identity != ''"> and identity like concat('%', #{device.identity}, '%')</if>
order by ts desc
limit 2000
</where>
</select>
<select id="selectDeviceLogList" parameterType="com.ruoyi.iot.domain.DeviceLog" resultMap="DeviceLogResult">
select * from ${database}.device_log
<where>
is_monitor !=1
<if test="device.deviceId!=null"> and device_id = #{device.deviceId} </if>
<if test="device.logType != null "> and log_type = #{device.logType}</if>
<if test="device.identity != null and device.identity != ''"> and identity like concat('%', #{device.identity}, '%')</if>
</where>
order by ts desc
</select>
</mapper>