Java操作Influxdb2.x

已于 2023-09-15 18:04:13 修改
阅读量2.3k 收藏 8
点赞数 2
分类专栏： Influxdb2.x 文章标签： java 时序数据库
于 2023-09-15 18:01:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stubborn_bull/article/details/132606611
版权

本片文章不讲怎么安装，只讲安装后如何用JAVA代码操作库表

1.创建数据库

Influxdb2.x是有管理界面平台的，以本地为例，游览器访问 ：http://127.0.0.1:8086，登录后，即可看到该界面，根据图片顺序操作即可

在这里插入图片描述

这里的bucket（桶）就是数据库

在这里插入图片描述

选择（配置）数据库数据保存策略

在这里插入图片描述

2.为bucket添加TELEGRAF配置

在这里插入图片描述

这里选择第1步创建的数据库

在这里插入图片描述

来源这里数据sys后会自动筛选，点击即可

在这里插入图片描述

点击后，右下角的创建按钮会亮起，点击按钮进行配置

在这里插入图片描述

数据库的配置文件名称后，点击保存和测试，配置内容不需要自己填写会自动生成

在这里插入图片描述

保存后出现该界面代表创建完成，会返回给两个配置信息：export INFLUX_TOKEN 和 telegraf --config
点击后关闭界面

在这里插入图片描述

点击配置文件名称会打开配置文件的内容

在这里插入图片描述

配置内容如下：

# Configuration for telegraf agent
[agent]
  ## Default data collection interval for all inputs
  interval = "10s"
  ## Rounds collection interval to 'interval'
  ## ie, if interval="10s" then always collect on :00, :10, :20, etc.
  round_interval = true

  ## Telegraf will send metrics to outputs in batches of at most
  ## metric_batch_size metrics.
  ## This controls the size of writes that Telegraf sends to output plugins.
  metric_batch_size = 1000

  ## Maximum number of unwritten metrics per output.  Increasing this value
  ## allows for longer periods of output downtime without dropping metrics at the
  ## cost of higher maximum memory usage.
  metric_buffer_limit = 10000

  ## Collection jitter is used to jitter the collection by a random amount.
  ## Each plugin will sleep for a random time within jitter before collecting.
  ## This can be used to avoid many plugins querying things like sysfs at the
  ## same time, which can have a measurable effect on the system.
  collection_jitter = "0s"

  ## Default flushing interval for all outputs. Maximum flush_interval will be
  ## flush_interval + flush_jitter
  flush_interval = "10s"
  ## Jitter the flush interval by a random amount. This is primarily to avoid
  ## large write spikes for users running a large number of telegraf instances.
  ## ie, a jitter of 5s and interval 10s means flushes will happen every 10-15s
  flush_jitter = "0s"

  ## By default or when set to "0s", precision will be set to the same
  ## timestamp order as the collection interval, with the maximum being 1s.
  ##   ie, when interval = "10s", precision will be "1s"
  ##       when interval = "250ms", precision will be "1ms"
  ## Precision will NOT be used for service inputs. It is up to each individual
  ## service input to set the timestamp at the appropriate precision.
  ## Valid time units are "ns", "us" (or "µs"), "ms", "s".
  precision = ""

  ## Log at debug level.
  # debug = false
  ## Log only error level messages.
  # quiet = false

  ## Log target controls the destination for logs and can be one of "file",
  ## "stderr" or, on Windows, "eventlog".  When set to "file", the output file
  ## is determined by the "logfile" setting.
  # logtarget = "file"

  ## Name of the file to be logged to when using the "file" logtarget.  If set to
  ## the empty string then logs are written to stderr.
  # logfile = ""

  ## The logfile will be rotated after the time interval specified.  When set
  ## to 0 no time based rotation is performed.  Logs are rotated only when
  ## written to, if there is no log activity rotation may be delayed.
  # logfile_rotation_interval = "0d"

  ## The logfile will be rotated when it becomes larger than the specified
  ## size.  When set to 0 no size based rotation is performed.
  # logfile_rotation_max_size = "0MB"

  ## Maximum number of rotated archives to keep, any older logs are deleted.
  ## If set to -1, no archives are removed.
  # logfile_rotation_max_archives = 5

  ## Pick a timezone to use when logging or type 'local' for local time.
  ## Example: America/Chicago
  # log_with_timezone = ""

  ## Override default hostname, if empty use os.Hostname()
  hostname = ""
  ## If set to true, do no set the "host" tag in the telegraf agent.
  omit_hostname = false
[[outputs.influxdb_v2]]
  ## The URLs of the InfluxDB cluster nodes.
  ##
  ## Multiple URLs can be specified for a single cluster, only ONE of the
  ## urls will be written to each interval.
  ##   ex: urls = ["https://us-west-2-1.aws.cloud2.influxdata.com"]
  urls = ["http://127.0.0.1:8086"]

  ## Token for authentication.
  token = "$INFLUX_TOKEN"

  ## Organization is the name of the organization you wish to write to; must exist.
  organization = "org"

  ## Destination bucket to write into.
  bucket = "db2"

  ## The value of this tag will be used to determine the bucket.  If this
  ## tag is not set the 'bucket' option is used as the default.
  # bucket_tag = ""

  ## If true, the bucket tag will not be added to the metric.
  # exclude_bucket_tag = false

  ## Timeout for HTTP messages.
  # timeout = "5s"

  ## Additional HTTP headers
  # http_headers = {"X-Special-Header" = "Special-Value"}

  ## HTTP Proxy override, if unset values the standard proxy environment
  ## variables are consulted to determine which proxy, if any, should be used.
  # http_proxy = "http://corporate.proxy:3128"

  ## HTTP User-Agent
  # user_agent = "telegraf"

  ## Content-Encoding for write request body, can be set to "gzip" to
  ## compress body or "identity" to apply no encoding.
  # content_encoding = "gzip"

  ## Enable or disable uint support for writing uints influxdb 2.0.
  # influx_uint_support = false

  ## Optional TLS Config for use on HTTP connections.
  # tls_ca = "/etc/telegraf/ca.pem"
  # tls_cert = "/etc/telegraf/cert.pem"
  # tls_key = "/etc/telegraf/key.pem"
  ## Use TLS but skip chain & host verification
  # insecure_skip_verify = false
# Read metrics about system load & uptime
[[inputs.system]]
  # no configuration

3.TELEGRAF配置参数说明

在这里插入图片描述

这四个key的值就对应的是JAVA应用程序中yaml中的配置的四个属性值，分别是url、token、org、bucket
注意：2.x版本是通过这四个属性来访问的，不再是账号和密码了
其中token需要提一嘴，token的值就是第二步创建完配置文件后返回的两个配置文件中的 export INFLUX_TOKEN

得到这四个配置属性后就可以操作数据库了吗 ？？？
NONONO，网上的资料比较杂乱，很多文章并没有讲到这一步，我是在这一步踩坑了，继续往看

经过测试发现了问题，注意这个TOKEN是数据库配置的TOKEN虽然可以连接到数据库并成功插入数据，但是并不具备访问的权限的，也就是说只能保存不能进行其他操作。查询报错：HTTP status code: 404; Message: failed to initialize execute state: could not find bucket “XX”

应用程序通过依赖中的API来访问的库，报错的原因其实就是缺少了最重要的API访问权限配置，网上的资料里没讲这块，贼坑

4.配置数据库的访问权限API TOKENS

在这里插入图片描述

勾选需要通过API访问的库和库的配置文件，其他权限根据自己情况来

在这里插入图片描述
点击创建后，会弹出生成的API访问的TOKENS，该TOKENS直接替换掉yaml配置文件中的token即可
在这里插入图片描述

5.JAVA代码操作库表

5.1 yaml

#influx配置
influx2:
  url: http://127.0.0.1:8086
  token: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX==写自己的
  org: org
  bucket: db2

5.2 pom依赖

这里我没选择高版本依赖是因为和项目中的依赖存在冲突，高版本依赖提供了对2.x以上版本的兼容API
高版本和低版本的依赖都可以操作2.x版本，这里根据自己的实际情况来决定即可

        <!--InfluxDB-->
        <dependency>
            <groupId>com.influxdb</groupId>
            <artifactId>influxdb-client-java</artifactId>
            <!--<version>6.9.0</version>-->
            <version>3.0.1</version>
        </dependency>

5.3 config

package net.influx.com.config;


import com.influxdb.client.InfluxDBClient;
import com.influxdb.client.InfluxDBClientFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author luo zhuo tao
 * @create 2023/8/29
 */
@Configuration
@ConfigurationProperties(prefix = "influx2")
public class InfluxdbConfig {

    private static final Logger logger = LoggerFactory.getLogger(InfluxdbConfig.class);

    private String url;
    private String token;
    private String org;
    private String bucket;

    @Bean
    public InfluxDBClient influxDBClient(){
        InfluxDBClient influxDBClient = InfluxDBClientFactory.create(url,token.toCharArray(),org,bucket);
        //日志级别可用可不用
        influxDBClient.setLogLevel(LogLevel.BASIC);
        if (influxDBClient.ping()){
            logger.info("InfluxDB时序数据库2.x---------------------------------------------连接成功!");
        }else {
            logger.info("InfluxDB时序数据库2.x---------------------------------------------连接失败!");
        }
        return influxDBClient;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public void setOrg(String org) {
        this.org = org;
    }

    public void setBucket(String bucket) {
        this.bucket = bucket;
    }
}

5.4 controller

package net.influx.com.controller;

import com.alibaba.fastjson.JSON;
import com.influxdb.client.*;
import com.influxdb.client.domain.InfluxQLQuery;
import com.influxdb.client.domain.WritePrecision;
import com.influxdb.client.write.Point;
import com.influxdb.query.FluxTable;
import com.influxdb.query.InfluxQLQueryResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.util.List;
import java.util.UUID;

/**
 * @author luo zhuo tao
 * @create 2023/8/29
 */

@RestController
@RequestMapping("influxdb")
public class InfluxdbController {

    private static final Logger logger = LoggerFactory.getLogger(InfluxdbController.class);

    @Resource
    private InfluxDBClient influxDBClient;

    @Value("${influx2.org:''}")
    private String org;

    @Value("${influx2.bucket:''}")
    private String bucket;

    private String table = "test1";

    @GetMapping("test")
    public String test() {
        /**
         * 写入：WriteApiBlocking 同步写入API WriteApi 异步写入API
         */
        if (false) {
            WriteApiBlocking writeApiBlocking = influxDBClient.getWriteApiBlocking();
            Point point = Point
                    .measurement(table)
                    .addField(String.valueOf(System.currentTimeMillis()), UUID.randomUUID().toString())
                    .time(Instant.now(), WritePrecision.NS);
            writeApiBlocking.writePoint(point);
        }

        /**
         * 查询：QueryApi 同步查询API InfluxQLQueryApi SQL查询API
         */
        if (false){
            InfluxQLQueryApi influxQLQueryApi = influxDBClient.getInfluxQLQueryApi();
            InfluxQLQuery influxQLQuery = new InfluxQLQuery("SELECT * FROM test1", bucket);
            InfluxQLQueryResult query = influxQLQueryApi.query(influxQLQuery);
            logger.info("query:{}", JSON.toJSONString(query));
            findAll();
        }

        /**
         * 删除
         */
        DeleteApi deleteApi = influxDBClient.getDeleteApi();
        deleteApi.delete(OffsetDateTime.now(), OffsetDateTime.now(),"",bucket,org);
        return "查询成功";
    }




    /**
     * @param measurement 表名
     */
    public void save(String measurement) {
        WriteOptions writeOptions = WriteOptions.builder()
                .batchSize(5000)
                .flushInterval(1000)
                .bufferLimit(10000)
                .jitterInterval(1000)
                .retryInterval(5000)
                .build();
        try (WriteApi writeApi = influxDBClient.getWriteApi(writeOptions)) {
            Point point = Point
                    .measurement(measurement)
                    .addField("MMSI".concat(UUID.randomUUID().toString()), UUID.randomUUID().toString())
                    .time(Instant.now(), WritePrecision.NS);
            writeApi.writePoint(bucket, org, point);
        }
    }


    public List<FluxTable> findAll() {
        String flux = "from(bucket: \"db3\")\n" +
                "  |> range(start:0)\n" +
                "  |> filter(fn: (r) => r[\"_measurement\"] == \"test1\")\n" +
                "  |> yield(name: \"mean\")";
        QueryApi queryApi = influxDBClient.getQueryApi();
        List<FluxTable> tables = queryApi.query(flux, org);
        logger.info("tables:{}", JSON.toJSONString(tables));
        return tables;
    }
}

5.5 查询方法、结果集提取方法

这里用了两种方式查询，一个是直接通过key查、一个是根据时间维度查询，具体的自己去研究flux语法这里不详细讲

package net.superlucy.departure.monitor.app.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.influxdb.client.InfluxDBClient;
import com.influxdb.client.QueryApi;
import com.influxdb.client.WriteApi;
import com.influxdb.client.WriteOptions;
import com.influxdb.client.domain.WritePrecision;
import com.influxdb.client.write.Point;
import com.influxdb.query.FluxRecord;
import com.influxdb.query.FluxTable;
import net.superlucy.departure.monitor.app.service.InfluxdbService;
import net.superlucy.departure.monitor.app.util.CommonUtil;
import net.superlucy.departure.monitor.dto.enums.InfluxdbEnum;
import net.superlucy.departure.monitor.dto.model.DepartureShipPosition;
import org.apache.commons.compress.utils.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.Instant;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author luo zhuo tao
 * @create 2023/9/4
 */
@Service
public class InfluxdbServiceImpl implements InfluxdbService {

    private static final Logger logger = LoggerFactory.getLogger(InfluxdbServiceImpl.class);

    /**
     * 通过MMSI号查询SQL：响应单条数据
     */
    private String queryValueFluxOne = "from(bucket: \"%s\") " +
            "|> range(start: %s) " +
            "|> filter(fn: (r) => r._measurement == \"%s\" and r._field == \"%s\")" +
            "" +
            "";

    /**
     * 通过时间范围查询SQL:响应多条数据
     */
    private String queryValueFluxTwo = "from(bucket: \"%s\") " +
            "|> range(start: %s) " +
            "|> filter(fn: (r) => r._measurement == \"%s\")" +
            "" +
            "";

    @Resource
    private InfluxDBClient influxDBClient;

    @Value("${influx2.org:''}")
    private String org;

    @Value("${influx2.bucket:''}")
    private String bucket;


    @Override
    public Map<String, Object> findOne(InfluxdbEnum influxdbEnum, String mmsi) {
        String flux = String.format(queryValueFluxOne, bucket, 0, influxdbEnum.getValue(), mmsi);
        QueryApi queryApi = influxDBClient.getQueryApi();
        List<FluxTable> tables = queryApi.query(flux, org);
        return qryVal(tables);
    }

    public Map<String, Object> qryVal(List<FluxTable> tables) {
        Map<String, Object> map = new HashMap<>();
        if (CollectionUtil.isNotEmpty(tables)) {
            for (FluxTable table : tables) {
                List<FluxRecord> records = table.getRecords();
                for (FluxRecord fluxRecord : records) {
                    map.put("value", fluxRecord.getValue().toString());
                    map.put("field", fluxRecord.getField());
                    map.put("valueTime", Date.from(fluxRecord.getTime()));
                }
            }
        }
        return map;
    }

    @Override
    public List<Map<String, Object>> findList(InfluxdbEnum influxdbEnum, String date) {
        String flux = String.format(queryValueFluxTwo, bucket, date, influxdbEnum.getValue());
        QueryApi queryApi = influxDBClient.getQueryApi();
        List<FluxTable> tables = queryApi.query(flux, org);
        return qryValList(tables);
    }

    @Override
    public Map<String, DepartureShipPosition> getDynamicList(InfluxdbEnum influxdbEnum, String date) {
        String flux = String.format(queryValueFluxTwo, bucket, date, influxdbEnum.getValue());
        QueryApi queryApi = influxDBClient.getQueryApi();
        List<FluxTable> tables = queryApi.query(flux, org);
        return dynamicList(tables);
    }

    /**
     * 查询所有船舶最新位置信息
     * @param tables
     * @return
     */
    private Map<String, DepartureShipPosition> dynamicList(List<FluxTable> tables) {
        Map<String, DepartureShipPosition> map = new HashMap<>();
        if (CollectionUtil.isNotEmpty(tables)) {
            for (FluxTable table : tables) {
                List<FluxRecord> records = table.getRecords();
                //直接用时间维度查询，会出
                // 现同一个Field多条数据的情况，这里只需要最新的数据，时间的排序是从远到近的，所以直接拿最后一条即可
                FluxRecord fluxRecord = records.get(records.size() - 1);
                DepartureShipPosition position = new DepartureShipPosition();
                String mmsi = fluxRecord.getField();
                String value = fluxRecord.getValue().toString();
                /**
                 * 动态格式转换方法是我自己业务里面的方法，不用管
                 * String mmsi = fluxRecord.getField();
                 * String value = fluxRecord.getValue().toString();
                 * 这两个get方法是已经获取到存储的数据结果了，后续处理根据自己业务需求来即可
                 */
                // 动态格式转换
                DepartureShipPosition dynamic = CommonUtil.dynamic(position, value);
                map.put(mmsi,dynamic);
            }
        }
        return map;
    }


    /**
     *
     * @param tables
     * @return
     */
    public List<Map<String, Object>> qryValList(List<FluxTable> tables) {
        List<Map<String, Object>> mapList = Lists.newArrayList();
        if (CollectionUtil.isNotEmpty(tables)) {
            for (FluxTable table : tables) {
                List<FluxRecord> records = table.getRecords();
                //直接用时间维度查询，会出现同一个Field多条数据的情况，这里只需要最新的数据，时间的排序是从远到近的，所以直接拿最后一条即可
                FluxRecord fluxRecord = records.get(records.size() - 1);
                Map<String, Object> map = new HashMap<>(1);
                    map.put("value", fluxRecord.getValue().toString());
                    map.put("field", fluxRecord.getField());
                    map.put("valueTime", Date.from(fluxRecord.getTime()));
                    mapList.add(map);
            }
        }
        return mapList;
    }


    /**
     * @param measurement 表名
     * @param k           MMSI号
     * @param v           ASI数据
     */
    @Override
    public void save(String measurement, String k, String v) {
        WriteOptions writeOptions = WriteOptions.builder()
                .batchSize(5000)
                .flushInterval(1000)
                .bufferLimit(10000)
                .jitterInterval(1000)
                .retryInterval(5000)
                .build();
        try (WriteApi writeApi = influxDBClient.getWriteApi(writeOptions)) {
            Point point = Point
                    .measurement(measurement)
                    .addField(k, v)
                    .time(Instant.now(), WritePrecision.NS);
            writeApi.writePoint(bucket, org, point);
        }
    }
}
九宫格输入法
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
InfluxDB2.x数据写入和查询
L
05-16 4775
目录 新建bucket 准备数据 数据写入 UI方式写入 InfluxDB API方式写入 Influx CLI方式写入 数据查询 使用Flux查询 InfluxQL查询数据 执行查询 UI执行Flux Influx CLI执行Flux InfluxDB API执行Flux REPL执行Flux 新建bucket influx bucket create --name test 准备数据 test.line文件内容如下： myMeasurement,tag
InfluxDB2.x的行协议Line protocol
L
05-16 1632
目录 行协议组成 度量（measurement） 标签集（Tag set） 字段集（Field set） 时间戳（Timestamp） 注释 命名限制 重复数据点 InfluxDB使用行协议写入数据点。它是一种基于文本的格式，提供了数据点（data point）的度量（measurement）、标记集（tag set）、字段集（field set）和时间戳（timestamp）。 语法 <measurement>[,<tag_key>=<tag_va
SpringBoot整合InfluxDB2.x
Mgg9702的博客
08-11 2769
最近工作中使用到InfluxDB2.x版本，在这里做一下学习记录。网上大多数教程都是基于InfluxDB1.x的，而2.x以后查询语句由原来的InfluxQL语句改为Flux语句，差别是特别大的。
influxdb-java
05-06
InfluxDB的Java 这是Java客户端库，仅与InfluxDB 0.9和更高版本兼容。 要连接到InfluxDB 0.8.x，您需要使用influxdb-java 1.6版。 此实现是对influxdb-go软件包的Java重写。 所有低级别的REST Api调用均可用。 典型用法如下： InfluxDB influxDB = InfluxDBFactory . connect( " http://172.17.0.2:8086 " , " root " , " root " ); String dbName = " aTimeSeries " ; influxDB . createDatabase(dbName); BatchPoints batchPoints = BatchPoints .database(dbName) .tag( " async
【Java整合InfluxDB2.0】极简教程，参考官方教程，创建桶，InfluxDBClient，Line Protocol写入数据，查询和封装，配置类，自动获取连接
最新发布
qq120631157的博客
07-01 961
【Java整合InfluxDB2.0】极简教程，参考官方教程，创建桶，InfluxDBClient，Line Protocol写入数据，查询和封装，配置类，自动获取连接
JAVA操作Influxdb
tianlong1569的专栏
04-23 1570
influxdb中measurement类似于关系形数据库中的表，tag为列，有索引，可以进行快速查询，field列没有索引不能进行快速查询，但field可以进行运算。命名：measurement通过一个唯一的字符串名称来标识，通常反映其所代表的数据（如 cpu_usage、temperature、server_metrics）。它们定义了所存储数据的上下文，并作为查询InfluxDB中数据的主要入口点。Measurement 定义了所收集数据的上下文和类别，类似于关系型数据库中的一个表。
influxdb java_InfluxDB Java入门
weixin_42469243的博客
02-13 201
package com.ysl.influx;import org.influxdb.InfluxDB;import org.influxdb.dto.Point;import org.influxdb.dto.Query;import org.influxdb.dto.QueryResult;import java.util.Map;public classInfluxdbService {pr...
（十一）JAVA操作InfluxDB
卷心菜投手
07-26 6935
这里是将写入的时间精度确定为了毫秒，如果你传入了一个纳秒时间戳，但精度指明了毫秒，那超出毫秒的部分会被直接截断。2、influxdb-client-java为我们提供了一个WriteOption对象，调用makeWriteApi时可以传入这个对象，通过上图的提示我们可以看到，缓冲区的大小，批的大小，刷写的间隔我们都是可以进行明确指定的。3、两个方法各有很多不同的实现，其中一大部分是用来制定连接参数的，比如你创建连接对象的时候没有制定org和bucket，那么可以延迟到调用具体api的时候再指定。
influxdb2.x influxdb-client-java和InfluxDB 1.x influxdb-java 的区别
01-20
- influxdb-client-java支持InfluxDB 2.x的所有功能，包括数据写入、查询、聚合等操作。 因此，主要区别在于查询语言的不同和对应的Java客户端库。如果你使用的是InfluxDB 1.x版本，可以使用influxdb-java进行集成...
influxdb1.x jar包
12-27
使用influxdb1.x jar包，开发人员可以轻松地建立与InfluxDB数据库的连接，通过编写简洁的代码来实现数据的写入和查询操作。这个jar包提供了丰富的API和文档，让开发人员能够快速上手，并利用InfluxDB高效地管理时间...
java使用influxDB数据库的详细代码
08-27
主要为大家介绍了java使用influxDB数据库的详细代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
influxDB的增删改查操作，全部测试通过了
03-27
总结来说，InfluxDB的Java客户端提供了方便的API来执行CRUD操作，通过连接数据库、构造数据点、编写查询语句和处理查询结果，开发者可以轻松地管理时间序列数据。在实际项目中，确保对这些操作进行充分的测试，以...
InfluxDB使用教程：Java版InfluxDB工具类
热门推荐
五道口
10-20 4万+
本节开始介绍Influx在Java中的使用，先提供一个InfluxDB Java API 封装的工具类，方便大家直接上手使用。 1.InfluxDB工具类 先奉上工具类，接下来介绍使用方法。
InfluxDB之java调用
weixin_41827053的博客
06-20 880
【代码】InfluxDB之java调用。
Java InfluxDB 入门
qq_25211081的博客
09-24 630
Java Spring 整合 InfluxDB；InfluxDB 数据插入与查询；InfluxDB 时区问题处理，InfluxDB 注册为 Windows 服务数据丢失问题...
influxdb在java中的应用
wengjinliang419的博客
08-09 2309
influxdb的安装和语法这边不加以说明，本文主要讲解influxdb在java大数据量存储的应用。 该项目的场景是存储设备的历史数据。（针对时序数据库influxdb是个比较好的选择） 一。流程图 项目启动流程： 存储流程如下： 二，数据库及表设计 数据库： rt_necp_history 短期数据库 key_necp_history 长期数据库 表： AI_RES...
InfluxDB在Java中的使用
LHZ_CH的博客
04-10 5838
Influx在Java中的使用 依赖的Jar包： <dependency> <groupId>org.influxdb</groupId> <artifactId>influxdb-java</artifactId> <version>2.10</version> </dependency> InfluxDB工具类 package com.common.utils.influxdb;
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值