1. Toy模板网首页
  2. > Toy博客

SpringBoot 整合 InfluxDB1.x 三种方式

9月前 作者：格栅看海 分类：Toy博客 阅读(21) 违法举报

这篇具有很好参考价值的文章主要介绍了SpringBoot 整合 InfluxDB1.x 三种方式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一.SpringBoot集成InfluxDB 1.x

既然准备SpringBoot整合InfluxDB，想必你已经了解了InfluxDB的安装、配置、使用。

那么就直奔正文。

目前本人已知可以实现的方式有3种：

  1. 集成原生的InfluxDB

  1. 集成封装的InfluxDBTemplate

  1. 集成InfluxDB封装的框架

环境：

influxDB 1.8

二.集成原生的InfluxDB

  1. 导入依赖

<!-- InfluxDB 原生依赖 -->
<dependency>
  <groupId>org.influxdb</groupId>
  <artifactId>influxdb-java</artifactId>
  <version>2.18</version>
</dependency>

  1. 配置YAML文件

influxdb:
  url: http://127.0.0.1:8086
  username: root         #用户
  password: 123          #密码
  database: test         #库
  retention: autogen     #保存策略

  1. 创建InfluxDB工具类


import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.influxdb.InfluxDB;
import org.influxdb.InfluxDB.ConsistencyLevel;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.influxdb.dto.Point.Builder;

import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * InfluxDB数据库连接操作类
 */
@Data
@Component
@Slf4j
public class InfluxDbComUtil {
    // 用户名
    @Value("${influxdb.username}")
    private String username;
    // 密码
    @Value("${influxdb.password}")
    private String password;
    // 连接地址
    @Value("${influxdb.url}")
    private String openurl;
    // 数据库名称
    @Value("${influxdb.database}")
    private String dbName;
    // 保留策略
    @Value("${influxdb.retention}")
    private String retentionPolicy;
    @Autowired
    private InfluxDB influxDB;

    public InfluxDbComUtil() {
    }
    /**
     * 连接时序数据库 ，若不存在则创建
     *
     * @return
     */
    @Bean
    public InfluxDB influxDbBuild() {
        if (influxDB == null) {
            influxDB = InfluxDBFactory.connect(openurl, username, password);
        }
        try {
            if (!influxDB.databaseExists(dbName)) {
                influxDB.createDatabase(dbName);
            }
        } catch (Exception e) {
            // 该数据库可能设置动态代理，不支持创建数据库
            e.printStackTrace();
        } finally {
            influxDB.setRetentionPolicy(retentionPolicy);
        }
        influxDB.setLogLevel(InfluxDB.LogLevel.NONE);
        return influxDB;
    }
    /**
     * 测试连接是否正常
     *
     * @return true 正常
     */
    public boolean ping() {
        boolean isConnected = false;
        Pong pong;
        try {
            pong = influxDB.ping();
            if (pong != null) {
                isConnected = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return isConnected;
    }
    /**
     * 创建数据库
     *
     * @param dbName
     */
    @SuppressWarnings("deprecation")
    public void createDB(String dbName) {
        influxDB.createDatabase(dbName);
    }
    /**
     * 删除数据库
     *
     * @param dbName
     */
    @SuppressWarnings("deprecation")
    public void deleteDB(String dbName) {
        influxDB.deleteDatabase(dbName);
    }
    /**
     * 切换数据库
     */
    @SuppressWarnings("deprecation")
    public void setDB(String dbName){
        influxDB.setDatabase(dbName);
    }
    /**
     * 关闭数据库
     */
    public void close() {
        influxDB.close();
    }
    /**
     * 切换数据库策略
     * @param dataBaseName 数据库
     * @param policyName 策略名
     */
    public void updRetentionPolicy(String dataBaseName,String policyName){
        String sql=String.format("ALTER RETENTION POLICY \""+policyName+"\" ON \""+dataBaseName+"\" DEFAULT");
        query(sql);
        this.dbName=dataBaseName;
        this.retentionPolicy=policyName;
    }
    /**
     * 切换策略
     * @param policyName 策略名
     */
    public void updRetentionPolicy(String policyName){
        String sql=String.format("ALTER RETENTION POLICY \""+policyName+"\" ON \""+dbName+"\" DEFAULT");
        query(sql);
        this.retentionPolicy=policyName;
    }
    /**
     * 创建自定义保留策略
     *
     * @param policyName  策略名
     * @param days        保存天数
     * @param replication 保存副本数量
     * @param isDefault   是否设为默认保留策略
     */
    public void createRetentionPolicy(String dataBaseName, String policyName, int days, int replication, Boolean isDefault) {
        String sql = String.format("CREATE RETENTION POLICY \"%s\" ON \"%s\" DURATION %sd REPLICATION %s ", policyName,
                dataBaseName, days, replication);
        if (isDefault) {
            sql = sql + " DEFAULT";
        }
        query(sql);
    }
    /**
     * 创建默认的保留策略
     *
     * 策略名：hour，保存天数：30天，保存副本数量：1,设为默认保留策略
     */
    public void createDefaultRetentionPolicy() {
        String command = String
                .format("CREATE RETENTION POLICY \"%s\" ON \"%s\" DURATION %s REPLICATION %s DEFAULT", "hour", dbName,
                        "30d", 1);
        this.query(command);
    }

/*********************************增删查**************************************************/
    /**
     * 查询
     *
     * @param command 查询语句
     * @return
     */
    public QueryResult query(String command) {
        return influxDB.query(new Query(command, dbName));
    }
    /**
     * 插入
     *
     * @param measurement 表
     * @param tags        标签
     * @param fields      字段
     */
    public void insert(String measurement, Map<String, String> tags, Map<String, Object> fields, long time,
                       TimeUnit timeUnit) {
        Builder builder = Point.measurement(measurement);
        builder.tag(tags);
        builder.fields(fields);
        if (0 != time) {
            builder.time(time, timeUnit);
        }
        influxDB.write(dbName, retentionPolicy, builder.build());
    }
    /**
     * 删除
     *
     * @param command 删除语句
     * @return 返回错误信息
     */
    public String deleteMeasurementData(String command) {
        QueryResult result = influxDB.query(new Query(command, dbName));
        return result.getError();
    }
    /**
     * 构建Point
     * @param measurement 表
     * @param time 时间
     * @param timeUnit 延迟
     * @param tags  tags
     * @param fields
     * @return
     */
    public Point pointBuilder(String measurement, long time, TimeUnit timeUnit, Map<String, String> tags, Map<String, Object> fields) {
        Point point = Point.measurement(measurement).time(time, timeUnit).tag(tags).fields(fields).build();
        return point;
    }

    /**
     * 批量写入测点
     *
     * @param batchPoints
     */
    public void batchInsert(BatchPoints batchPoints, TimeUnit timeUnit) {
        influxDB.write(batchPoints);
        // influxDB.enableGzip();
        // influxDB.enableBatch(2000,100,timeUnit);
        // influxDB.disableGzip();
        // influxDB.disableBatch();
    }

    /**
     * 批量写入数据
     *
     * @param database        数据库
     * @param retentionPolicy 保存策略
     * @param consistency     一致性
     * @param records         要保存的数据（调用BatchPoints.lineProtocol()可得到一条record）
     */
    public void batchInsert(final String database, final String retentionPolicy, final ConsistencyLevel consistency, TimeUnit timeUnit, final List<String> records) {
        influxDB.write(database, retentionPolicy, consistency, timeUnit, records);
    }

}

  1. 使用


/**
 * 测试例子
 */
/**新增测试Util*/
InfluxDbComUtil influxDbComUtil = SpringUtils.getBean(InfluxDbComUtil.class);
Map<String, String> tags = new HashMap<>();
tags.put("tag1", "标签值");
Map<String, Object> fields = new HashMap<String, Object>();
fields.put("field1", "String类型");
// 数值型，InfluxDB的字段类型，由第一天插入的值得类型决定
fields.put("field2", 3.141592657);
// 时间使用毫秒为单位
influxDbComUtil.insert("表名", tags, fields, System.currentTimeMillis(), TimeUnit.MILLISECONDS);

/**查询*/
QueryResult result = influxDbComUtil.query("SELECT * FROM alarm_album");
QueryResult.Result oneResult=result.getResults().get(0);
if (oneResult.getSeries() != null) {
    List<List<Object>> valueList = oneResult.getSeries().stream()
                                    .map(QueryResult.Series::getValues)
                                    .collect(Collectors.toList()).get(0);
    if (valueList != null && valueList.size() > 0) {
        for (List<Object> value : valueList) {
            Map<String, String> map = new HashMap<String, String>();
            // 数据库中字段1取值
            String field1 = value.get(0) == null ? null : value.get(0).toString();
            // 数据库中字段2取值
            String field2 = value.get(1) == null ? null : value.get(1).toString();
            // TODO 用取出的字段做你自己的业务逻辑……
            System.out.println(value);
        }
    }
}

新增结果

SpringBoot 整合 InfluxDB1.x 三种方式

查询结果(数据库内仅有一条数据)

SpringBoot 整合 InfluxDB1.x 三种方式

  1. 配置实体类


@Data
@Measurement(name="terminal_heart_beat")
public class TerminalHeartBeatModel{
    @Column(name="id", tag = true)  //tag 可以理解为influxdb的索引
    private Long id;
    @Column(name="mac")
    private String mac;
}

  1. 使用原生InfluxDBMapper


InfluxDbComUtil influxDbComUtil = SpringUtils.getBean(InfluxDbComUtil.class);
influxDbComUtil.setDB(influxDbComUtil.getDbName());//讲influxdb的库设置成默认的库 你也可以自己填。
InfluxDBMapper influxDBMapper = new InfluxDBMapper(influxDbComUtil.getInfluxDB());
//根据对象进行新增或查询
Test test=new Test();
test.setId(new Long(10));
test.setMac("aa:bb:cc...");

influxDBMapper.save(test);

List<Test> testList = influxDBMapper.query(Test.class);

但是关于time列，通过原生InfluxDB：Point进行新增操作，是以long型或Number型

SpringBoot 整合 InfluxDB1.x 三种方式

三.集成Spring封装的InfluxDB Template

  1. 导入依赖

<!-- Spring封装的InfluxDB -->
<dependency>
    <groupId>plus.ojbk</groupId>
    <artifactId>influxdb-spring-boot-starter</artifactId>
    <version>1.0.2</version>
</dependency>

  1. 配置YAML

influxdb:
  url: http://127.0.0.1:8086
  username: root         #用户
  password: 123          #密码
  database: test         #库

  1. 配置实体类


@Data
@Measurement(name="terminal_heart_beat")
public class TerminalHeartBeatModel{
    @Column(name="id", tag = true)  //tag 可以理解为influxdb的索引
    private Long id;
    @Column(name="mac")
    private String mac;
    @Column(name="time")
    private LocalDateTime time;
}

  1. 使用


@Resource
private InfluxdbTemplate influxdbTemplate;

/**
     * 获取集合
     * @param map
     * @param start
     * @param end
     * @return
     */
public List<TerminalHeartBeatModel> getList(Map<String,Object> map,LocalDateTime start, LocalDateTime end){
    //类似MybatisPlus中的QueryWrapper
    QueryModel queryModel = new QueryModel();
    queryModel.setMeasurement(InfluxdbUtils.getMeasurement(TerminalHeartBeatModel.class));
    //Map<String, Object> map = new TreeMap<>();
    //map.put("mac", "00:aa:00:aa:00:00");
    queryModel.setMap(map);
    queryModel.setStart(start);
    queryModel.setEnd(end);
    queryModel.setUseTimeZone(true);  //时区
    queryModel.setOrder(Order.DESC);  //排序
    //where 条件中额外参数可放入model.setMap();
    queryModel.setWhere(Op.where(queryModel));
    return influxdbTemplate.selectList(Query.build(queryModel), TerminalHeartBeatModel.class);
}
/** 新增 */
public void save(TerminalHeartBeatModel model){
    influxdbTemplate.insert(model);
}

相较于原版，它封装了自有的Util以及Template等

对于原版Point的time列类型问题，它对number和long 型转换成了LocalDateTime类型

并且封装了更多的方法（具体自行拓展）

四.集成InfluxDB封装的框架

  1. 导入依赖

<!-- git作者个人封装的框架 -->
<dependency>
    <groupId>io.github.betacatcode</groupId>
    <artifactId>spring-boot-starter-influxdb</artifactId>
    <version>0.0.4-RELEASE</version>
</dependency>
<dependency>
    <groupId>org.influxdb</groupId>
    <artifactId>influxdb-java</artifactId>
    <version>2.18</version>
</dependency>

  1. 配置YAML

spring:
  influx:
    url: http://127.0.0.1:8086
    user: admin
    password: 123456
    mapper-location: com.github.betacatcode

  1. 配置实体类


@Data
@Measurement(database = "test",name = "student")
public class Student {
    private String id;

    @Column(name = "sname",tag = true)
    private String sname;

    @Column(name = "value")
    private Double value;

    @TimeColumn
    @Column(name = "time")
    private Instant time;
}

  1. 创建Mapper 继承InfluxDBBaseMapper接口


public interface StudentMapper extends InfluxDBBaseMapper {

    @Select(value = "select * from test.autogen.student where sname=#{sname}",
            resultType = Student.class)
    List<Student> selectByName(String sname);

    @Delete(value = "delete from student",database = "test")
    void deleteAll();

    @Insert
    void insertOne(Student student);

    @Insert
    void insertBatch(List<Student> students);

}

  1. 使用

调用即可

类似于mybatis 本人不常用，自行拓展。

本处集成框架 引用源自：spring-boot-starter-influxdb: influxDB的类mybatis ORM框架

五.总结

不论是使用哪种方式 都各有利弊 根据项目的需求 决定使用的方式

如有疑问或文中有误 可以私信文章来源地址https://www.toymoban.com/news/detail-441599.html

到了这里，关于SpringBoot 整合 InfluxDB1.x 三种方式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【SpringBoot18】SpringBoot 调用外部接口的三种方式

    【SpringBoot18】SpringBoot 调用外部接口的三种方式

    SpringBoot不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。在Spring-Boot项目开发中，存在着本模块的代码需要访问外面模块接口，或外部url链接的需求, 比如在apaas开发过程中需要封装接口在接口中调用apaas提供的接口（

    2023年04月11日
    浏览(73)

  • SpringBoot实现分页的三种方式

    一 自己封装Page对象实现 博客链接 二 使用sql实现分页 2.1 场景分析 前段传递给给后台什么参数? 当前页码 currentPage 每页显示条数 pageSize 后台给前端返回什么数据? 当前页数据 List 总记录数 totalCount 2.2 前段代码 2.3 后端代码 PageBean mapper service impl controller 三 使用PageHelper插件

    2024年02月10日
    浏览(50)
  • 在SpringBoot中对RabbitMQ三种使用方式

    在SpringBoot中对RabbitMQ三种使用方式

            1.使用AmqpAdmin定制消息发送组件          2.消息发送者发送消息              创建实体类                                  发送消息                           如图所以,如果我们直接发送的话就会报这个错,有两种解决方法,第一种是比较常用的让实体

    2024年02月13日
    浏览(31)
  • SpringBoot实现固定、动态定时任务 | 三种实现方式

    SpringBoot实现固定、动态定时任务 | 三种实现方式

    阅读完本文：🐱‍👓 知晓 SpringBoot 用注解如何实现定时任务 明白 SpringBoot 如何实现一个动态定时任务 （与数据库相关联实现） 理解 SpringBoot 实现设置时间执行定时任务 （使用 ThreadPoolTaskScheduler 实现） 用注解实现是真的简单，只要会 cron 表达式就行。🧙‍♂️ 第一步 ：

    2024年02月16日
    浏览(40)
  • SpringBoot导出Word文档的三种方式

    SpringBoot导出Word文档的三种方式

    1、直接在Java代码里创建Word文档，设置格式样式等，然后导出。（略） 需要的见：https://blog.csdn.net/qq_42682745/article/details/120867432 2、富文本转换后的HTML下载为Word文档。相当于把HTML转为Word导出 3、使用模板技术导出。固定格式、可以写入不同数据 其他： springboot版本：2.7.11 导

    2024年02月02日
    浏览(52)

  • Springboot中使用线程池的三种方式

    前言 多线程是每个程序员的噩梦,用得好可以提升效率很爽，用得不好就是埋汰的火葬场。 这里不深入介绍，主要是讲解一些标准用法，熟读唐诗三百首，不会作诗也会吟。 这里就介绍一下springboot中的多线程的使用，使用线程连接池去异步执行业务方法。 由于代码中包含详

    2024年02月08日
    浏览(46)
  • SpringBoot获取HttpServletRequest、HttpServletResponse的三种方式

    SpringBoot获取HttpServletRequest、HttpServletResponse的三种方式

    仅仅适用在controller方法上。当Spring接收到HTTP请求时，会寻找一个合适的方法来处理该请求。如果该方法参数上标注了@RequestMapping或@Get、@Post等注解，Spring就会将HttpServletRequest对象注入到该参数中。 适用于所有的bean 通过调试可以看到，注入的Reques是一个代理类，而这个被代

    2024年02月19日
    浏览(46)
  • 搭建SpringBoot项目三种方式(超详细版)

    搭建SpringBoot项目三种方式(超详细版)

    目录 一、官网下载压缩包解压 二、通过Idea脚手架搭建 三、Spring Boot项目结构 3.1 pom.xml文件 3.2 启动类 3.3 配置文件 四、通过创建Maven项目添加依赖 接下来我们搭建一个SpringBoot项目，并引入SpringMVC的功能，首先我们可以通过官网搭建项目： 1. 访问start.spring.io 然后我们可以点

    2024年02月08日
    浏览(32)

  • SpringBoot获取Request请求的三种方式

    Request对象包含了请求的各种信息，比如请求方法、请求URL、请求参数、请求内容等等，这些信息可以供服务器进行处理和响应。那么在SpringBoot中，怎么才能获取到Request对象？ 本文将介绍三种方法，并提示例参考。 一、直接在Controller方法参数上注入HttpServletRequest 这是最常用

    2024年02月04日
    浏览(56)
  • SpringBoot集成RocketMQ实现三种消息发送方式

    SpringBoot集成RocketMQ实现三种消息发送方式

    目录 一、pom文件引入依赖 二、application.yml文件添加内容 三、创建producer生产者 四、创建Consumer消费者（创建两个消费者，所属一个Topic） 五、启动项目测试 RocketMQ 支持3 种消息发送方式： 同步 （sync）、异步（async）、单向（oneway）。 同步 ：发送者向 MQ 执行发送消息API 时

    2024年02月13日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包