SpringBoot+Mybatis整合TDengine数据库的Demo

已于 2025-02-28 17:08:44 修改
阅读量1k 收藏 18
点赞数 15
分类专栏： SpringBoot+Demo 文章标签： 数据库 spring boot mybatis tdengine分页查询 tdengine连接使用 java整合tdengine
于 2025-02-12 08:20:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myyhtw/article/details/145393768
版权

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

demo代码

分页查询
myw
myw
模拟插入数据 批量插入和单条插入数据
myw
TDengine Database 数据库查询数据

myw

在使用之前，需要先安装好TDengine Datavase

Ubuntu系统安装TDengine Database

Centos系统安装TDengine Database

首先进入TDengine数据库，创建数据库和超级表，这里使用的是按照设备的imei来存储温湿度值(物联网方式)

[root@192 ~]# taos
Welcome to the TDengine Command Line Interface, Client Version:3.2.3.0
Copyright (c) 2023 by TDengine, all rights reserved.

  ********************************  Tab Completion  ************************************
  *   The TDengine CLI supports tab completion for a variety of items,                 *
  *   including database names, table names, function names and keywords.              *
  *   The full list of shortcut keys is as follows:                                    *
  *    [ TAB ]        ......  complete the current word                                *
  *                   ......  if used on a blank line, display all supported commands  *
  *    [ Ctrl + A ]   ......  move cursor to the st[A]rt of the line                   *
  *    [ Ctrl + E ]   ......  move cursor to the [E]nd of the line                     *
  *    [ Ctrl + W ]   ......  move cursor to the middle of the line                    *
  *    [ Ctrl + L ]   ......  clear the entire screen                                  *
  *    [ Ctrl + K ]   ......  clear the screen after the cursor                        *
  *    [ Ctrl + U ]   ......  clear the screen before the cursor                       *
  **************************************************************************************

Server is Community Edition.

taos>

创建数据库 两种格式，其中第二种支持不存在才创建

create database td_device_log;

create database if not exists td_device_log;

taos> create database td_device_log;
Create OK, 0 row(s) affected (0.959227s)

taos> create database if not exists td_device_log;
Create OK, 0 row(s) affected (0.002038s)

创建超级表，时间戳 imei唯一的编码(可看一类数据的或者某个设备的成唯一ID)，temp和hum是温湿度的字段

taos> use td_device_log;
Database changed.

taos> CREATE STABLE device_env_imei(time_stamp TIMESTAMP, imei varchar(64), temp varchar(64), hum varchar(64)) TAGS (imei_point varchar(64));
Create OK, 0 row(s) affected (0.014501s)

taos>

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.mybatis.tdengine</groupId>
    <artifactId>boot-example-mybatis-tdengine</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot-example-mybatis-tdengine</name>
    <description>boot-example-mybatis-tdengine</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>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>

关键点，需要与TDengine版本匹配，否则可能出现错误

 <dependency>
     <groupId>com.taosdata.jdbc</groupId>
     <artifactId>taos-jdbcdriver</artifactId>
     <version>3.2.8</version>
 </dependency>

application.properties(这里直接使用的6030，需要客户端驱动的原生链接方式)

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

spring.datasource.driver-class-name=com.taosdata.jdbc.TSDBDriver
spring.datasource.url=jdbc:TAOS://192.168.1.6:6030/td_device_log?charset=UTF-8&locale=en_US.UTF-8&timezone=UTC-8
spring.datasource.username=root
spring.datasource.password=taosdata

DeviceEnvImei.java

package boot.example.tdengine.domain;

import lombok.Data;

@Data
public class DeviceEnvImei {

    private long timeStamp;

    private String imei;

    private String temp;

    private String hum;
    
}

DeviceEnvImeiRequestVo.java

package boot.example.tdengine.domain;


import lombok.Data;

@Data
public class DeviceEnvImeiRequestVo {

    private long startStamp;

    private long endStamp;

    private String imei;


    private Long limit;

    private Long offset;

}

Response.java

package boot.example.tdengine.domain;


import com.fasterxml.jackson.annotation.JsonInclude;


@JsonInclude(JsonInclude.Include.NON_NULL)
public class Response {

    private boolean state;

    private int code;

    private String msg;

    private Object data;

    private long timestamp;

    public Response() {}

    public Response(boolean state, int code, String msg) {
        this.state = state;
        this.code = code;
        this.msg = msg;
        this.timestamp = System.currentTimeMillis()/1000;
    }

    public Response(boolean state, int code, String msg, Object data) {
        this.state = state;
        this.code = code;
        this.msg = msg;
        this.data = data;
        this.timestamp = System.currentTimeMillis()/1000;
    }

    public boolean isState() {
        return state;
    }

    public void setState(boolean state) {
        this.state = state;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }

    @Override
    public String toString() {
        return "Response{" +
                "state=" + state +
                ", code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                ", timestamp=" + timestamp +
                '}';
    }
}

ResponseCode.java

package boot.example.tdengine.domain;


public class ResponseCode {

    private static final boolean STATE_TRUE = true;

    private static final boolean STATE_FALSE = false;


    private static final int CODE_200 = 200;     //操作资源成功

    private static final int CODE_201 = 201;     //资源为空


    private static final int CORE_101 = 101;     //缺少必要参数


    private static final String MSG_ALL_SUCCESS = "操作资源成功";

    private static final String MSG_PARAMETER_LACK = "缺少必要参数";

    private static final String MSG_RESOURCES_EMPTY = "资源为空";


    //  缺少必要参数返回
    public static Response lackParameterResponse(){
        return new Response(STATE_FALSE, CORE_101, MSG_PARAMETER_LACK);
    }



    //  通用success返回
    public static Response successResponse(){
        return new Response(STATE_TRUE,CODE_200,MSG_ALL_SUCCESS);
    }

    public static Response successResponse(Object data){
        return new Response(STATE_TRUE,CODE_200,MSG_ALL_SUCCESS, data);
    }


    public static Response successEmptyResponse(){
        return new Response(STATE_TRUE,CODE_201,MSG_RESOURCES_EMPTY);
    }

}

DeviceEnvImeiMapper.java

package boot.example.tdengine.dao;

import boot.example.tdengine.domain.DeviceEnvImei;
import boot.example.tdengine.domain.DeviceEnvImeiRequestVo;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;


@Repository
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);

}

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.tdengine.dao.DeviceEnvImeiMapper">

    <resultMap id="baseResultMap" type="boot.example.tdengine.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.tdengine.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.tdengine.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.tdengine.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=BIGINT} offset #{offset,jdbcType=BIGINT}
    </select>

    <select id="listDeviceEnvImei" parameterType="boot.example.tdengine.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>

DeviceEnvImeiService.java

package boot.example.tdengine.service;


import boot.example.tdengine.domain.DeviceEnvImei;
import boot.example.tdengine.domain.DeviceEnvImeiRequestVo;
import boot.example.tdengine.domain.Response;

import java.util.List;


public interface DeviceEnvImeiService {


    public void insertDeviceEnvImeiService(DeviceEnvImei deviceEnvImei);

    public Response listDeviceEnvImeiService(Long page, Long size, DeviceEnvImeiRequestVo deviceEnvImeiRequestVo);

    public Response listDeviceEnvImeiService(DeviceEnvImeiRequestVo deviceEnvImeiRequestVo);

    public void insertListDeviceEnvImeiService(List<DeviceEnvImei> list);

    public void insertBatchDeviceEnvImei(List<DeviceEnvImei> deviceEnvImeiList);

    public void dropDeviceEnvImeiService(String imei);


}

DeviceEnvImeiServiceImpl.java

package boot.example.tdengine.service;


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


@Service
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(Long page, Long 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(DeviceEnvImeiList.toString());
            log.error(e.toString());
        }
    }

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



}

DeviceEnvImeiController.java

package boot.example.tdengine.controller;

import boot.example.tdengine.domain.DeviceEnvImei;
import boot.example.tdengine.domain.DeviceEnvImeiRequestVo;
import boot.example.tdengine.domain.Response;
import boot.example.tdengine.domain.ResponseCode;
import boot.example.tdengine.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") Long page, @PathVariable("size") Long size, @RequestBody DeviceEnvImeiRequestVo deviceEnvImeiRequestVo){
        if(page != null && 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();
    }

}

BootTdengineDemoMybatisApplication.java

package boot.example.tdengine;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan(basePackages = {"boot.example.tdengine.dao"})
@SpringBootApplication
public class BootTdengineDemoMybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootTdengineDemoMybatisApplication.class, args);
    }

    //   创建数据库
    //   create database td_device_log

    //  创建超级表
    //  CREATE STABLE device_env_imei(time_stamp TIMESTAMP, imei varchar(64), temp varchar(64), hum varchar(64)) TAGS (imei_point varchar(64));


}

AsyncPoolTaskConfig.java

package boot.example.tdengine.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.ThreadPoolExecutor;


@EnableAsync
@Configuration
public class AsyncPoolTaskConfig {
    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(30);
        taskExecutor.setMaxPoolSize(50 * 2);
        taskExecutor.setQueueCapacity(200);
        taskExecutor.setKeepAliveSeconds(30);
        taskExecutor.setThreadNamePrefix("ThreadPoolTaskExecutor-");
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        taskExecutor.setAwaitTerminationSeconds(60);
        taskExecutor.initialize();
        return taskExecutor;
    }
}

SwaggerConfig.java

package boot.example.tdengine.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;
import java.util.List;


@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        String defaultToken = "myyhtw";
        ParameterBuilder headerToken = new ParameterBuilder();
        List<Parameter> pars = new ArrayList<>();
        headerToken.name("token").description("token验证").modelRef(new ModelRef("string")).scalarExample(defaultToken).parameterType("header").required(false).build();
        pars.add(headerToken.build());
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
                .paths(Predicates.not(PathSelectors.regex("/error.*")))
                .paths(PathSelectors.regex("/.*"))
                .build().globalOperationParameters(pars).apiInfo(apiInfo());
    }


    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("boot-example-mybatis-tdengine-接口")
                .description("API接口文档")
                .version("0.01")
                .build();
    }


}

目录结构

│ pom.xml
│
└─src
├─main
│ ├─java
│ │ └─boot
│ │ └─example
│ │ └─tdengine
│ │ │ BootTdengineDemoMybatisApplication.java
│ │ │
│ │ ├─config
│ │ │ AsyncPoolTaskConfig.java
│ │ │ BeanConfig.java
│ │ │ SwaggerConfig.java
│ │ │
│ │ ├─controller
│ │ │ DeviceEnvImeiController.java
│ │ │
│ │ ├─dao
│ │ │ DeviceEnvImeiMapper.java
│ │ │ DeviceEnvImeiMapper.xml
│ │ │
│ │ ├─domain
│ │ │ DeviceEnvImei.java
│ │ │ DeviceEnvImeiRequestVo.java
│ │ │ Response.java
│ │ │ ResponseCode.java
│ │ │
│ │ └─service
│ │ DeviceEnvImeiService.java
│ │ DeviceEnvImeiServiceImpl.java
│ │
│ └─resources
│ application.properties
│ logback-spring.xml
│
└─test
└─java
└─boot
└─example
└─tdengine
BootTdengineDemoMybatisApplicationTest.java

【项目实战】Spring Boot整合TDEngine、MybatisPlus的基本步骤
本本本添哥
11-25 3607
TDEngine是一款专为物联网、车联网、工业互联网等行业设计的开源时序数据库，支持高效地存储和查询时序数据。
5-TDengine集成SpringBoot，MyBatis，MyBatisPlus
2401_83915450的博客
05-14 1307
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
springboot：整合TDengine
热门推荐
拒绝熬夜啊的博客
04-14 1万+
springboot：整合TDengine
Spring Boot 与 TDengine 的深度集成实践（二）
最新发布
qq_42190530的博客
04-04 1173
Spring Boot 与 TDengine 的深度集成实践（二）
SpringBoot集成TDengine程序Demo.zip
08-24
SpringBoot集成TDengine程序Demo 数据库连接池使用Druid，项目包含库表及相关增删改查的操作; Maven项目构建，非常适合快速学习与开发实践！
springboot集成Tdengine
11-15
springboot集成tdengine中连接区分，可直接运行
SpringBoot整合Mybatis实现增删改查功能
分享学习
05-30 1761
Spring Boot 整合 MyBatis 是一个相对直接的过程，主要涉及添加依赖、配置数据源、配置 MyBatis、创建实体类、Mapper 接口和映射文件、以及编写服务层来实现增删改查功能。下面我将一步步指导你完成整个集成过程。
开源一款针对IOT应用基于Springboot+Emqx+Tdengine的框架SET
zhaoenweiex的博客
11-06 3685
前言 最近物联网相关技术还是很火的， 正好EMQX以及TDengine都涉及物联网领域，而且都提供开源版本 实际上Emqx的企业版是支持自动向TDengine灌入数据的， 但开源版这个功能被阉割了 TDengine的收费版更侧重于运维相关的，规模没有到一定程度暂时还用不到 因此我们做了这个项目基于Springboot搭建一个订阅Emqx消息并写入TDengine的框架，都是利用的开源版本的特性因此可以放心大胆的使用。 AGPL 话说TDengine的云服务版本还是挺贵的 基本架构 核心代码 ...
springboot2.x整合mybatis-plus,mysql实现多数据源
蚂蚁呀嘿的博客
09-23 863
怎么新建springboot项目我在这里就不介绍了，首先我们先来看一下需要引入哪些主要的jar 1：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/XMLSch...
SpringBoot集成TDengine程序Demo
08-24
SpringBoot集成TDengine程序Demo 数据库连接池使用Druid，项目包含库表及相关增删改查的操作; Maven项目构建，非常适合快速学习与开发实践！
SpringBoot+Mybatis整合TDengine数据库和Mysql数据库的Demo
蚂蚁舞
03-24 1760
记录一下使用SpringBoot+Mybatis整合TDengine数据库和Mysql数据库的Demo，并且同时支持分页返回查询数据
springboot整合TDengine实现数据订阅——多线程快速消费
少年Dream
09-12 3950
package com . zhmsky . springboottdengine . 数据订阅 . 消费者多线程消费;import com . zhmsky . springboottdengine . 数据订阅 . pojo . Meters;/**//消息队列消息拉取是否开启 private boolean active = true;
springboot sharding分库+TDengine多数据源整合
Thesmallwhiteah的博客
07-24 504
基于springboot 实现sharding读写分离和多数据源切换
TDengine SpringBoot操作
王小工小工历程
12-11 1429
TDengine是由涛思数据开发的一款高性能、分布式的物联网、工业大数据平台，其核心模块是高性能、集群开源、云原生、极简的时序数据库。TDengine专为物联网、工业互联网、电力、IT运维等场景设计并优化，具有极强的弹性伸缩能力。同时，它还带有内建的缓存、流式计算、数据订阅等系统功能，能大幅减少系统设计的复杂度，降低研发和运营成本。Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。
Springboot整合TDengine3.0
worldTi6的博客
09-10 4119
springboot整合TDengine3.0
springboot mybatis-plus tdengine 创建超级表，动态创建子表，动态查询子表
qq_37084490的博客
12-23 3457
springboot mybatis-plus tdengine 创建超级表，动态创建子表，动态查询子表mybatis-plus do not support TDengine, use postgresql Dialect paginationInterceptor . setDialectType("postgresql");}
SpringBoot + Mybatis整合Druid和Mysql基础DEMO
标题中提到了“springboot+mybatis+druid+mysql”，这些是现代Java Web开发中常用的技术组件。Spring Boot是一个开源的Java基础框架，旨在简化新Spring应用的初始搭建以及开发过程。它使用了特定的方式来进行配置，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值