SpringBoot整合InfluxDB

简介: SpringBoot整合InfluxDB

引入依赖

在项目的 pom.xml 文件中添加以下依赖,就像是往项目里添了一些"工具",这些工具可以帮我们更方便地使用 Spring Boot 和 InfluxDB。

<!-- Spring Boot Web Starter,用于构建 Web 应用 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Configuration Processor,用于处理配置文件 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
</dependency>
<!-- InfluxDB Java 客户端,用于连接和操作 InfluxDB 数据库 -->
<dependency>
  <groupId>org.influxdb</groupId>
  <artifactId>influxdb-java</artifactId>
  <version>2.23</version>
</dependency>

创建连接信息类

下面的代码定义了一个 InfluxdbConfig 类,它用于存储连接 InfluxDB 数据库所需的信息,比如地址、用户名、密码等。

package world.xuewei.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@Component
@ConfigurationProperties("spring.influx")
public class InfluxdbConfig {
    /**
     * 请求路径:http://ip:port
     */
    private String url;
    /**
     * 用户名
     */
    private String username;
    /**
     * 密码
     */
    private String password;
    /**
     * 数据库
     */
    private String database;
    /**
     * 保留策略
     */
    private String retention;
}

创建操作类

接下来是 InfluxDBTemplate 类,这是一个用于操作 InfluxDB 的工具类。比方说,你可以往数据库里写入数据、查询数据,还能够创建或删除数据库。这个类就像是一个帮你和 InfluxDB 打交道的小助手。

package world.xuewei.component;
import world.xuewei.config.InfluxdbConfig;
import org.influxdb.InfluxDB;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.BatchPoints;
import org.influxdb.dto.Point;
import org.influxdb.dto.Query;
import org.influxdb.dto.QueryResult;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.ObjectUtils;
import java.sql.Timestamp;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@Configuration
public class InfluxDBTemplate {
    private final InfluxdbConfig influxdbConfig;
    private InfluxDB influxDB;
    @Autowired
    public InfluxDBTemplate(InfluxdbConfig influxdbConfig) {
        this.influxdbConfig = influxdbConfig;
        getInfluxDB();
    }
    /**
     * 获取连接
     */
    public void getInfluxDB() {
        if (influxDB == null) {
            influxDB = InfluxDBFactory.connect(influxdbConfig.getUrl(), influxdbConfig.getUsername(), influxdbConfig.getPassword());
            // 设置使用数据库,保证库存在
            influxDB.setDatabase(influxdbConfig.getDatabase());
            // 设置数据库保留策略,保证策略存在
            if (ObjectUtils.isEmpty(influxdbConfig.getRetention())) {
                influxDB.setRetentionPolicy(influxdbConfig.getRetention());
            }
        }
    }
    /**
     * 关闭连接
     */
    public void close() {
        if (influxDB != null) {
            influxDB.close();
        }
    }
    /**
     * 指定时间插入
     *
     * @param measurement 表
     * @param tags        标签
     * @param fields      字段
     * @param time        时间
     * @param unit        单位
     */
    public void write(String measurement, Map<String, String> tags, Map<String, Object> fields, long time, TimeUnit unit) {
        Point point = Point.measurement(measurement).tag(tags).fields(fields).time(time, unit).build();
        influxDB.write(point);
        close();
    }
    /**
     * 插入数据-自动生成时间
     *
     * @param measurement 表
     * @param tags        标签
     * @param fields      字段
     */
    public void write(String measurement, Map<String, String> tags, Map<String, Object> fields) {
        write(measurement, tags, fields, System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    /**
     * 批量插入
     *
     * @param points 批量记录 推荐 1000 条作为一个批
     */
    public void writeBatch(BatchPoints points) {
        influxDB.write(points);
        close();
    }
    /**
     * 用来执行相关操作
     *
     * @param command 执行命令
     * @return 返回结果
     */
    public QueryResult query(String command) {
        return influxDB.query(new Query(command));
    }
    /**
     * 创建数据库
     *
     * @param name 库名
     */
    public void createDataBase(String name) {
        query("create database " + name);
    }
    /**
     * 删除数据库
     *
     * @param name 库名
     */
    public void dropDataBase(String name) {
        query("drop database " + name);
    }
    /**
     * 查询返回指定对象
     *
     * @param selectCommand select 语句
     * @param clazz         类型
     * @param <T>           泛型
     * @return 结果
     */
    public <T> List<T> query(String selectCommand, Class<T> clazz) {
        return handleQueryResult(query(selectCommand), clazz);
    }
    /**
     * select 查询封装
     *
     * @param queryResult 查询返回结果
     * @param clazz       封装对象类型
     * @param <T>         泛型
     * @return 返回处理回收结果
     */
    public <T> List<T> handleQueryResult(QueryResult queryResult, Class<T> clazz) {
        // 定义保存结果集合
        List<T> lists = new ArrayList<>();
        // 获取结果
        List<QueryResult.Result> results = queryResult.getResults();
        // 遍历结果
        results.forEach(result -> {
            // 获取 series
            List<QueryResult.Series> seriesList = result.getSeries();
            // 遍历 series
            seriesList.forEach(series -> {
                // 获取的所有列
                List<String> columns = series.getColumns();
                // 获取所有值
                List<List<Object>> values = series.getValues();
                // 遍历数据 获取结果
                for (List<Object> value : values) {
                    try {
                        // 根据 clazz 进行封装
                        T instance = clazz.newInstance();
                        // 通过 spring 框架提供反射类进行处理
                        BeanWrapperImpl beanWrapper = new BeanWrapperImpl(instance);
                        HashMap<String, Object> fields = new HashMap<>();
                        for (int j = 0; j < columns.size(); j++) {
                            String column = columns.get(j);
                            Object val = value.get(j);
                            if ("time".equals(column)) {
                                beanWrapper.setPropertyValue("time", Timestamp.from(ZonedDateTime.parse(String.valueOf(val)).toInstant()).getTime());
                            } else {
                                // 保存当前列和值到 field map 中
                                // 注意: 返回结果无须在知道是 tags 还是 fields 认为就是字段和值 可以将所有字段作为 field 进行返回
                                fields.put(column, val);
                            }
                        }
                        // 通过反射完成 fields 赋值操作
                        beanWrapper.setPropertyValue("fields", fields);
                        lists.add(instance);
                    } catch (InstantiationException | IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        });
        return lists;
    }
}

使用

最后,在你需要使用 InfluxDB 的地方,通过注入 InfluxDBTemplate 来方便地进行数据库的操作。

@Service
public class DemoServiceImpl {
    
    @Autowired
    private final InfluxDBTemplate influxDBTemplate;
    // ...
}

这就好像你有了一个小助手,可以帮你方便地与 InfluxDB 打交道,进行各种操作,比如写入数据、查询数据等。

相关文章
|
5月前
|
Java 测试技术 数据库
springboot接入influxdb
springboot接入influxdb
70 1
|
6月前
|
存储 传感器 Java
整合Spring Boot和InfluxDB实现时序数据存储
整合Spring Boot和InfluxDB实现时序数据存储
|
6月前
|
Java API 时序数据库
springboot如何配置influxdb
【6月更文挑战第24天】springboot如何配置influxdb
372 0
|
7月前
|
Java API 时序数据库
InfluxData【付诸实践 02】SpringBoot 集成时序数据库 InfluxDB 应用分享(InfluxDB实例+Feign接口调用InfluxDB API)源码分享
InfluxData【付诸实践 02】SpringBoot 集成时序数据库 InfluxDB 应用分享(InfluxDB实例+Feign接口调用InfluxDB API)源码分享
173 0
|
存储 SQL Prometheus
彻底搞懂时序数据库InfluxDB,在SpringBoot整合InfluxDB
之前介绍了运维监控系统Prometheus,然后就有同鞋问我关于时序数据库的情况,所以这里总结一下时序数据库,并以InfluxDB为例,介绍时序数据库的功能特性和使用方式,希望能对大家有所帮助。
12844 4
彻底搞懂时序数据库InfluxDB,在SpringBoot整合InfluxDB
|
SQL 存储 数据采集
SpringBoot整合TICK(Telegraf+InfluxDB+Chronograf +Kapacitor)监控系列之一:InfluxDB
TICK各个模块说明如下所示: T(Telegraf):服务监控数据采集,包括服务器CPU、内存、IO、进程状态、服务状态等等; I(InfluxDB):时序型数据库,存储Telegraf采集的监控数据,每条数据都会有time序列; C(Chronograf):时间序列数据可视化展示; K(Kapacitor):可以按照预先编写好的规则,实时地订阅influxDB数据或者批量查询数据,并进行告警。
SpringBoot整合TICK(Telegraf+InfluxDB+Chronograf +Kapacitor)监控系列之一:InfluxDB
|
存储 缓存 监控
Spring Boot 2.x基础教程:使用时序数据库InfluxDB
Spring Boot 2.x基础教程:使用时序数据库InfluxDB
1166 0
|
存储 监控 Java
SpringBoot 2.0 + InfluxDB+ Sentinel 实时监控数据存储
前言 阿里巴巴提供的控制台只是用于演示 Sentinel 的基本能力和工作流程,并没有依赖生产环境中所必需的组件,比如持久化的后端数据库、可靠的配置中心等。目前 Sentinel 采用内存态的方式存储监控和规则数据,监控最长存储时间为 5 分钟,控制台重启后数据丢失。
2182 0
|
监控 Java 数据库
spring boot +RabbitMQ +InfluxDB+Grafara监控实践
本文需要有相关spring boot 或spring cloud 相关微服务框架的基础,如果您具备相关基础可以很容易的实现下述过程!!!!!!!   希望本文的所说对需要的您有所帮助   从这里我们开始进入闲聊阶段。
2860 0
|
2月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能,快速搭建前后端分离的应用框架
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能,快速搭建前后端分离的应用框架。首先,确保开发环境已安装必要的工具,然后创建并配置 Spring Boot 项目,包括添加依赖和配置 Spring Security。接着,创建后端 API 和前端项目,配置动态路由和菜单。最后,运行项目并分享实践心得,包括版本兼容性、安全性、性能调优等方面。
190 1