记录一下使用SpringBoot+Mybatis整合TDengine数据库和Mysql数据库的Demo，并且同时支持分页返回查询数据

在物联网的系统中，mysql存储物联网数据单表达到几千万条或者达到一亿多条数据后，根据时间来查询当日的某个设备数据会存在十分明显缓慢的问题，如果查询条件选择查询好几天好几个月的数据，那很明显直接卡死，甚至导致系统崩溃

例如某个传感器的数据

对该设备查询当日 大概是600多条
myyhtw
对该设备查询当月 大概15000条
myyhtw
对该设备查询一年多的数据 24万多条
myyhtw
看似这个设备的数据不多，如果放在mysql的表里，上千上万个设备呢？对于单表日志来说就不可能实现秒开
所以这类数据使用tdengine时序数据库最好不过，一个设备可以建立一张子表，或者一类设备建立一张子表，效率大大提升

但是有时候限制于成本考虑，mysql和tdengine仅仅部署在4核8G或者2核4G的服务器上，java的应用启动太多太占用内存了，最好的优化就是多数据源方式，mysql和tdengine同在一个jar里，这样查询倒也方便

先看效果
这是查询mysql数据库分页数据的接口返回
myyhtw

这是查询tdengine数据库日志数据的接口返回
myyhtw

记录下demo代码，实际就是参考这2篇文章整合而来：

SpringBoot+Mybatis整合TDengine数据库的Demo

SpringBoot+Mybatis整合Mysql数据库的Demo

首先是对mysql和tdengine创建对应的数据库和数据表信息，上面2篇文章里已经存在(并且有些类和对象也是存在的，下面的代码没有过多体现)

pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>boot.example</groupId>
    <artifactId>boot-example-mybatis-tdengine-mysql-2.0.5</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot-example-mybatis-tdengine-mysql-2.0.5</name>
    <description>boot-example-mybatis-tdengine-mysql-2.0.5</description>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.1</version>
        </dependency>
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
            <version>3.2.8</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.17</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.yml</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.yml</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>

        </resources>

        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.5.8</version>
            </plugin>
        </plugins>
    </build>

</project>

application.properties



server.port=8060
spring.application.name=boot-example-mybatis-demo

spring.datasource.mysql-server.type=com.zaxxer.hikari.HikariDataSource
#spring.datasource.mysql-server.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.mysql-server.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.mysql-server.jdbc-url=jdbc:mysql://192.168.1.6:3306/boot_example?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.mysql-server.username=sysroot
spring.datasource.mysql-server.password=xdX.12345678

#spring.datasource.mysql-server.pool-name=mysqlData
#spring.datasource.mysql-server.minimum-idle=5
#spring.datasource.mysql-server.maximum-pool-size=10
#spring.datasource.mysql-server.idle-timeout=600000
#spring.datasource.mysql-server.max-lifetime=1800000
#spring.datasource.mysql-server.connection-timeout=30000
#spring.datasource.mysql-server.connection-test-query=SELECT 1


spring.datasource.taos-server.type=com.zaxxer.hikari.HikariDataSource
#spring.datasource.taos-server.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.taos-server.driver-class-name=com.taosdata.jdbc.TSDBDriver
spring.datasource.taos-server.jdbc-url=jdbc:TAOS://192.168.1.6:6030/td_device_log?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8
spring.datasource.taos-server.username=root
spring.datasource.taos-server.password=taosdata

#spring.datasource.taos-server.pool-name=taosData
#spring.datasource.taos-server.minimum-idle=5
#spring.datasource.taos-server.maximum-pool-size=10
#spring.datasource.taos-server.idle-timeout=600000
#spring.datasource.taos-server.max-lifetime=1800000
#spring.datasource.taos-server.connection-timeout=30000
#spring.datasource.taos-server.connection-test-query=show databases

# Invalid and unavailable
# mybatis.config-location=classpath:mybatis/mybatis-config-mysql.xml

Tdengine的 DeviceEnvImeiMapper.xml

<?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="boot.example.data.dao.taos.DeviceEnvImeiMapper">

    <resultMap id="baseResultMap" type="boot.example.data.domain.DeviceEnvImei">
        <id column="time_stamp" property="timeStamp"/>
        <result column="imei" property="imei"/>
        <result column="temp" property="temp"/>
        <result column="hum" property="hum"/>
    </resultMap>

    <insert id="insertDeviceEnvImei" parameterType="boot.example.data.domain.DeviceEnvImei">
        INSERT INTO imei#{imei} USING device_env_imei (imei_point) TAGS (#{imei}) VALUES (#{timeStamp},#{imei},#{temp},#{hum})
    </insert>

    <insert id="insertBatchDeviceEnvImei" parameterType="java.util.List">
        INSERT INTO
        <foreach separator=" " collection="list" item="item" index="index">
            imei#{item.imei} USING device_env_imei (imei_point) TAGS (#{item.imei}) VALUES (#{item.timeStamp},#{item.imei},#{item.temp},#{item.hum})
        </foreach>
    </insert>

    <select id="countDeviceEnvImei" parameterType="boot.example.data.domain.DeviceEnvImeiRequestVo" resultType="int">
        select count(*) from imei#{imei}
        <trim prefix="where" prefixOverrides="where" suffixOverrides="and">
            <if test="startStamp != 0"><![CDATA[time_stamp > #{startStamp} and]]></if>
            <if test="endStamp != 0"><![CDATA[time_stamp <= #{endStamp} and]]></if>
        </trim>
    </select>

    <select id="listPageDeviceEnvImei" parameterType="boot.example.data.domain.DeviceEnvImeiRequestVo" resultMap="baseResultMap">
        select time_stamp, imei, temp, hum from imei#{imei}
        <trim prefix="where" prefixOverrides="where" suffixOverrides="and">
            <if test="startStamp != 0"><![CDATA[time_stamp > #{startStamp} and]]></if>
            <if test="endStamp != 0"><![CDATA[time_stamp <= #{endStamp} and]]></if>
        </trim>
        order by time_stamp desc limit #{limit,jdbcType=INTEGER} offset #{offset,jdbcType=INTEGER}
    </select>

    <select id="listDeviceEnvImei" parameterType="boot.example.data.domain.DeviceEnvImeiRequestVo" resultMap="baseResultMap">
        select time_stamp, imei, temp, hum from imei#{imei}
        <trim prefix="where" prefixOverrides="where" suffixOverrides="and">
            <if test="startStamp != 0"><![CDATA[time_stamp > #{startStamp} and]]></if>
            <if test="endStamp != 0"><![CDATA[time_stamp <= #{endStamp} and]]></if>
        </trim>
        order by time_stamp desc
    </select>

    <update id="dropTableDeviceEnvImei" parameterType="String">
        drop table if exists imei#{imei}
    </update>

</mapper>

Mysql的xml BootUserMapper.xml

<?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="boot.example.data.dao.mysql.BootUserMapper" >

    <resultMap id="userResultMap" type="boot.example.data.domain.BootUser" >
        <id column="user_id" property="userId"/>
        <result column="user_name" property="userName"/>
        <result column="user_nickname" property="userNickname"/>
        <result column="user_password" property="userPassword"/>
        <result column="user_sex" property="userSex" />
        <result column="user_create_time" property="userCreateTime" />
    </resultMap>

    <sql id="selectUserVo" >
        select user_id, user_name, user_nickname, user_password, user_sex, user_create_time from boot_user
    </sql>

    <!-- 查询user列表 -->
    <select id="selectUserList" resultMap="userResultMap"  >
        <include refid="selectUserVo" /> order by user_id desc
    </select>

    <!-- 根据userId查询 -->
    <select id="selectUserByUserId" parameterType="integer" resultMap="userResultMap" >
        <include refid="selectUserVo" /> where user_id =#{userId}
    </select>

    <!-- 新增user -->
    <insert id="insertUser" parameterType="boot.example.data.domain.BootUser" useGeneratedKeys="true" keyProperty="userId">
        insert into boot_user
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="userName != null and userName != ''">user_name,</if>
            <if test="userNickname != null and userNickname != ''">user_nickname,</if>
            <if test="userPassword != null and userPassword != ''">user_password,</if>
            <if test="userSex != null">user_sex,</if>
            user_create_time,
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="userName != null and userName != ''">#{userName},</if>
            <if test="userNickname != null and userNickname != ''">#{userNickname},</if>
            <if test="userPassword != null and userPassword != ''">#{userPassword},</if>
            <if test="userSex != null">#{userSex},</if>
            sysdate(),
        </trim>
    </insert>

    <!-- 更新user -->
    <update id="updateUser" parameterType="boot.example.data.domain.BootUser" >
        update boot_user
        <trim prefix="SET" suffixOverrides=",">
            <if test="userName != null and userName != ''">user_name = #{userName},</if>
            <if test="userNickname != null and userNickname != ''">user_nickname = #{userNickname},</if>
            <if test="userPassword != null and userPassword !=''">user_password = #{userPassword},</if>
            <if test="userSex != null">user_sex = #{userSex},</if>
        </trim>
        where user_id =#{userId}
    </update>

    <delete id="deleteUser" parameterType="integer" >
        delete from boot_user where user_id =#{userId}
    </delete>

</mapper>

mysql和tdengine(taos)在resources里的存放位置，至于mybatis-config.xml的配置，稍微有些研究的地方，好像是全局的，尝试了分别配置，但都没有结果，后面的代码里会体现出来
myyhtw
mysql数据源配置
DataSourceMysqlConfig.java

package boot.example.data.config;

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.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;


@Configuration
//@MapperScan(basePackages = {"boot.example.data.dao.mysql"}, sqlSessionTemplateRef  = "mysqlSqlSessionTemplate")
@MapperScan(basePackages = {"boot.example.data.dao.mysql"}, sqlSessionFactoryRef = "mysqlSqlSessionFactory")
public class DataSourceMysqlConfig {

    @Bean(name = "mysqlDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.mysql-server")
    @Primary
    public DataSource mysqlDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "mysqlSqlSessionFactory")
    @Primary
    public SqlSessionFactory mysqlSqlSessionFactory(@Qualifier("mysqlDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);

        //  方式1
//        // 设置 MyBatis 配置文件位置 设置后 mysql的配置生效，tdengine也似乎会生效 原因是mybatis.config-location是一个全局配置，它不会区分不同的数据源(没具体研究)
//        直接在application.properties里配置mybatis.config-location=classpath:mybatis/mybatis-config-mysql.xml  但是多数据源的情况下失效
//        Resource configLocation = new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mybatis-config.xml")[0];
//        bean.setConfigLocation(configLocation);

        //  方式2  用路径来区分在mysql和taos目录各配置一个 按照这个配置之后，tdengine同样也会生效的，
        //  可能真的是mybatis.config-location是一个全局配置，它不会区分不同的数据源 或许也是当前springboot和mybatis版本的关系 也不知道是不是特意把@Primary注解到mysql数据源上
        bean.setConfigLocation(new PathMatchingResourcePatternResolver().getResource("classpath:mybatis/mysql/mybatis-config-mysql.xml"));

        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mysql/mapper/*.xml"));

        return bean.getObject();
    }

    @Bean(name = "mysqlTransactionManager")
    @Primary
    public DataSourceTransactionManager mysqlTransactionManager(@Qualifier("mysqlDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

//    @Bean(name = "mysqlSqlSessionTemplate")
//    @Primary
//    public SqlSessionTemplate mysqlSqlSessionTemplate(@Qualifier("mysqlSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
//        return new SqlSessionTemplate(sqlSessionFactory);
//    }


}

Tdengine的数据源配置
DataSourceTaosConfig.java

package boot.example.data.config;

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.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;


@Configuration
//@MapperScan(basePackages = {"boot.example.data.dao.taos"}, sqlSessionTemplateRef  = "taosSqlSessionTemplate")
@MapperScan(basePackages = {"boot.example.data.dao.taos"}, sqlSessionFactoryRef = "taosSqlSessionFactory")
public class DataSourceTaosConfig {

    @Bean(name = "taosDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.taos-server")
    public DataSource taosDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "taosSqlSessionFactory")
    public SqlSessionFactory taosSqlSessionFactory(@Qualifier("taosDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/taos/mapper/*.xml"));

//        //  配置后似乎没起啥作用  因此可配置可不配，会在mysql数据源的那个起作用
//        bean.setConfigLocation(new PathMatchingResourcePatternResolver().getResource("classpath:mybatis/taos/mybatis-config-taos.xml"));
        return bean.getObject();
    }

    @Bean(name = "taosTransactionManager")
    public DataSourceTransactionManager taosTransactionManager(@Qualifier("taosDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

//    @Bean(name = "taosSqlSessionTemplate")
//    public SqlSessionTemplate taosSqlSessionTemplate(@Qualifier("taosSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
//        return new SqlSessionTemplate(sqlSessionFactory);
//    }

}

这2部分特别重要 关键点儿

BootUserMapper.java

package boot.example.data.dao.mysql;


import boot.example.data.domain.BootUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;

@Mapper
public interface BootUserMapper {

    public List<BootUser> selectUserList();

    public BootUser selectUserByUserId(@Param("userId") Integer userId);

    public int insertUser(BootUser user);

    public int updateUser(BootUser user);

    public int deleteUser(Integer userId);


}

BootUserService.java

package boot.example.data.service;

import boot.example.data.domain.BootUser;
import boot.example.data.domain.Response;

import java.util.List;




public interface BootUserService {

    public Response selectUserListService(int page, int size);

    public List<BootUser> selectUserListService();

    public BootUser selectUserByUserIdService(Integer userId);

    public int insertUserService(BootUser user);

    public int updateUserService(BootUser user);

    public int deleteUserService(Integer userId);
}

BootUserServiceImpl.java

package boot.example.data.service;


import boot.example.data.dao.mysql.BootUserMapper;
import boot.example.data.domain.BootUser;
import boot.example.data.domain.Response;
import boot.example.data.domain.ResponseCode;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


/*
    @Transactional(transactionManager = "mysqlSqlSessionFactory") 可配
 */

@Service
//@Transactional(transactionManager = "mysqlSqlSessionFactory")
public class BootUserServiceImpl implements BootUserService{

    @Autowired
    private BootUserMapper bootUserDao;

    @Override
    public Response selectUserListService(int page, int size) {
        PageHelper.startPage(page, size);
        List<BootUser> bootUserList = bootUserDao.selectUserList();
        PageInfo<BootUser> pageInfo = new PageInfo<>(bootUserList);
        return ResponseCode.successResponse(pageInfo);
    }

    @Override
    public List<BootUser> selectUserListService() {
        return bootUserDao.selectUserList();
    }

    @Override
    public BootUser selectUserByUserIdService(Integer userId) {
        return bootUserDao.selectUserByUserId(userId);
    }

    @Override
    public int insertUserService(BootUser user) {
        bootUserDao.insertUser(user);
        if(null != user) {
            return 1;
        }
        return 0;
    }

    @Override
    public int updateUserService(BootUser user) {
        return bootUserDao.updateUser(user);
    }

    @Override
    public int deleteUserService(Integer userId) {
        return bootUserDao.deleteUser(userId);
    }

}

BootUserController.java

package boot.example.data.controller;


import boot.example.data.domain.BootUser;
import boot.example.data.domain.Response;
import boot.example.data.service.BootUserService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;

@RestController
public class BootUserController {

    @Resource
    BootUserService bootUserService;

    @PostMapping("/api/userPage/{page}/{size}")
    public Response selectUserListPageController(@PathVariable("page") int page, @PathVariable("size") int size){
        return bootUserService.selectUserListService(page, size);
    }

    @RequestMapping(value = "/api/user", method = RequestMethod.GET)
    public List<BootUser> selectUserListController(){
        return bootUserService.selectUserListService();
    }

    @RequestMapping(value = "/api/user/{id}", method = RequestMethod.GET)
    public BootUser selectUserByUserIdController(@PathVariable("id") Integer userId) {
        return bootUserService.selectUserByUserIdService(userId);
    }

    @RequestMapping(value = "/api/user", method = RequestMethod.POST)
    public int insertUserController(@RequestBody BootUser user) {
        return bootUserService.insertUserService(user);
    }

    @RequestMapping(value = "/api/user", method = RequestMethod.PUT)
    public int updateUserController(@RequestBody BootUser user) {
        return bootUserService.updateUserService(user);
    }

    @RequestMapping(value = "/api/user/{id}", method = RequestMethod.DELETE)
    public int deleteUserController(@PathVariable("id") Integer userId) {
        return bootUserService.deleteUserService(userId);
    }

}

Tdengine的代码
DeviceEnvImeiMapper.java

package boot.example.data.dao.taos;

import boot.example.data.domain.DeviceEnvImei;
import boot.example.data.domain.DeviceEnvImeiRequestVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;


@Mapper
public interface DeviceEnvImeiMapper {

    public void insertDeviceEnvImei(DeviceEnvImei deviceEnvImei);

    public void insertBatchDeviceEnvImei(List<DeviceEnvImei> deviceEnvImeiList);

    public List<DeviceEnvImei> listPageDeviceEnvImei(DeviceEnvImeiRequestVo deviceEnvImeiRequestVo);

    public List<DeviceEnvImei> listDeviceEnvImei(DeviceEnvImeiRequestVo deviceEnvImeiRequestVo);

    public int countDeviceEnvImei(DeviceEnvImeiRequestVo deviceEnvImeiRequestVo);

    public void dropTableDeviceEnvImei(@Param("imei") String imei);




}

DeviceEnvImeiService.java

package boot.example.data.service;


import boot.example.data.domain.Response;
import boot.example.data.domain.ResponseCode;
import com.github.pagehelper.PageInfo;
import boot.example.data.dao.taos.DeviceEnvImeiMapper;
import boot.example.data.domain.DeviceEnvImei;
import boot.example.data.domain.DeviceEnvImeiRequestVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;


@Service
@Transactional(transactionManager = "taosTransactionManager")
public class DeviceEnvImeiServiceImpl implements DeviceEnvImeiService {

    private final Logger log =  LoggerFactory.getLogger(this.getClass());

    @Resource
    private DeviceEnvImeiMapper deviceEnvImeiMapper;


    @Async
    @Override
    public void insertDeviceEnvImeiService(DeviceEnvImei deviceEnvImei) {
        try {
            deviceEnvImeiMapper.insertDeviceEnvImei(deviceEnvImei);
        } catch (Exception e){
            log.error(e.toString());
        }
    }

    @Override
    public Response listDeviceEnvImeiService(int page, int size, DeviceEnvImeiRequestVo deviceEnvImeiRequestVo) {
        long total = deviceEnvImeiMapper.countDeviceEnvImei(deviceEnvImeiRequestVo);
        deviceEnvImeiRequestVo.setLimit(size);
        deviceEnvImeiRequestVo.setOffset((page-1)*size);
        List<DeviceEnvImei> eventList = deviceEnvImeiMapper.listPageDeviceEnvImei(deviceEnvImeiRequestVo);
        PageInfo<DeviceEnvImei> pageInfo = new PageInfo<>(eventList);
        pageInfo.setTotal(total);
        return ResponseCode.successResponse(pageInfo);
    }

    @Override
    public Response listDeviceEnvImeiService(DeviceEnvImeiRequestVo deviceEnvImeiRequestVo) {
        List<DeviceEnvImei> eventList = deviceEnvImeiMapper.listDeviceEnvImei(deviceEnvImeiRequestVo);
        if(!eventList.isEmpty()) {
            return ResponseCode.successResponse(eventList);
        }
        return ResponseCode.successEmptyResponse();
    }

    @Async
    @Override
    public void insertListDeviceEnvImeiService(List<DeviceEnvImei> list) {
        try {
            for(DeviceEnvImei unified : list) {
                deviceEnvImeiMapper.insertDeviceEnvImei(unified);
            }
        } catch (Exception e){
            log.error(list.toString());
            log.error(e.toString());
        }
    }

    @Override
    public void insertBatchDeviceEnvImei(List<DeviceEnvImei> deviceEnvImeiList) {
        try {
            deviceEnvImeiMapper.insertBatchDeviceEnvImei(deviceEnvImeiList);
        } catch (Exception e){
            log.error(e.toString());
        }
    }

    @Override
    public void dropDeviceEnvImeiService(String imei) {
        deviceEnvImeiMapper.dropTableDeviceEnvImei(imei);
    }



}

DeviceEnvImeiController.java

package boot.example.data.controller;

import boot.example.data.domain.DeviceEnvImei;
import boot.example.data.domain.DeviceEnvImeiRequestVo;
import boot.example.data.domain.Response;
import boot.example.data.domain.ResponseCode;
import boot.example.data.service.DeviceEnvImeiService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;


@RequestMapping("/deviceEnv")
@Controller
public class DeviceEnvImeiController {

    @Resource
    private DeviceEnvImeiService deviceEnvImeiService;

    @PostMapping("/listPage/{page}/{size}")
    @ResponseBody
    public Response listPageDeviceEnvImeiService(@PathVariable("page") int page, @PathVariable("size") int size, @RequestBody DeviceEnvImeiRequestVo deviceEnvImeiRequestVo){
        if(page-1 >= 0 && deviceEnvImeiRequestVo.getImei() != null){
            return deviceEnvImeiService.listDeviceEnvImeiService(page, size, deviceEnvImeiRequestVo);
        }
        return ResponseCode.lackParameterResponse();
    }

    @PostMapping("/list")
    @ResponseBody
    public Response listDeviceEnvImeiService(@RequestBody DeviceEnvImeiRequestVo deviceEnvImeiRequestVo){
        if(deviceEnvImeiRequestVo.getImei() != null){
            return deviceEnvImeiService.listDeviceEnvImeiService(deviceEnvImeiRequestVo);
        }
        return ResponseCode.lackParameterResponse();
    }

    @PostMapping("/drop/{imei}")
    @ResponseBody
    public Response dropDeviceEnvImeiService(@PathVariable("imei") String imei) {
        deviceEnvImeiService.dropDeviceEnvImeiService(imei);
        return ResponseCode.successResponse();
    }

    @PostMapping("/testData")
    @ResponseBody
    public Response test() {
        DeviceEnvImei deviceEnvImei = new DeviceEnvImei();
        deviceEnvImei.setTimeStamp(System.currentTimeMillis());
        deviceEnvImei.setImei("90641");
        deviceEnvImei.setTemp("18.88");
        deviceEnvImei.setHum("45.6");

        DeviceEnvImei deviceEnvImei2 = new DeviceEnvImei();
        deviceEnvImei2.setTimeStamp(System.currentTimeMillis());
        deviceEnvImei2.setImei("90641");
        deviceEnvImei2.setTemp("18.88");
        deviceEnvImei2.setHum("45.6");

        List<DeviceEnvImei> list = new ArrayList<>();
        list.add(deviceEnvImei);
        list.add(deviceEnvImei2);
        deviceEnvImeiService.insertBatchDeviceEnvImei(list);

        DeviceEnvImei deviceEnvImei3 = new DeviceEnvImei();
        deviceEnvImei3.setTimeStamp(System.currentTimeMillis());
        deviceEnvImei3.setImei("90642");
        deviceEnvImei3.setTemp("28.88");
        deviceEnvImei3.setHum("65.6");

        deviceEnvImeiService.insertDeviceEnvImeiService(deviceEnvImei3);

        return ResponseCode.successResponse();
    }




}

代码结构目录
myyhtw

这个demo还是不够完整的，总体来说功能是没问题的，实际运用缺少

总体来说还是存在代码或者说是底层理解的问题，只是实现功能，并不是研究代码的东西
比如 不需要@Transactional(transactionManager = “taosTransactionManager”)这个也能执行 Service层这个它是怎么去区分mysql数据源的，还是tdengine数据源的没去弄清楚，只要能用，比啥都重要。

# tdengine # spring boot # mysql
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

KingbaseES数据库：医疗信创潮涌沅江，国产化信创打造医疗新质生产力

avatar DAMO开发者矩阵
cover

告别迁移焦虑：金仓KDMS V4带你轻松搞定数据库国产化替代

avatar DAMO开发者矩阵
cover

KingbaseES数据库在常德二院全栈国产化信创中产生新质生产力,医疗信创的部署如何实现，如何操作？

avatar DAMO开发者矩阵