Influxdb系列（三）java语言往influxdb中插入数据

已于 2024-01-25 15:29:48 修改
阅读量1.7k 收藏 10
点赞数 13
分类专栏： influxdb 文章标签： java python 开发语言 时序数据库
于 2024-01-25 15:27:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35349982/article/details/135845706
版权

java语言往infxludb插入数据，主要是看官网示例：
https://github.com/influxdata/influxdb-client-java/tree/master/client#management-api

一、前期准备

1. 引入maven驱动

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.22</version>
        </dependency>
        <dependency>
            <groupId>com.influxdb</groupId>
            <artifactId>influxdb-client-java</artifactId>
            <version>6.10.0</version>
        </dependency>

2. influxdb属性实体类

@Data
public class InfluxDbConfig {
    private String dbUrl;
    private char[] token;
    private String bucket;
    private String org;
    private int dataBatchSize;
    private int bufferLimit;
}

3. SqlEntity实体类

package com.dameng.sql_realtime_parse_tool.domain.echarts.sql;

import com.influxdb.annotations.Column;
import com.influxdb.annotations.Measurement;
import lombok.Data;

import java.time.Instant;




@Data
@Measurement(name = "SqlEntity")
public class SqlEntity {
    @Column(tag = true)
    private String execSqlType;
    @Column  (tag = true)
    private String execSqlExecTimeRange;
    @Column(timestamp = true)
    private Instant sqlRecordTime;
    @Column
    private String sessStr;
    @Column
    private String thrdStr;
    @Column
    private String userStr;
    @Column
    private String trxIdStr;
    @Column
    private String stmtStr;
    @Column
    private String ipStr;
    //@Column //(tag = true) //判断是参数类型 还是SQL语句
    //private String entityType;
    @Column  //这个ID是编码后的唯一ID
    private String execSqlId;
    @Column
    private String appnameStr;
    @Column
    private String execSqlStr;
    @Column
    private String paramsId;
    @Column
    private String paramsStr;
    @Column //判断参数状态
    private Boolean paramsStatus;
    @Column//sql影响行数
    private int sqlRowCount;
    @Column
    private int execSqlExecTime;

}

4. InfluxdbApi接口类

@Service
public class InfluxdbApi  implements IInfluxApi {

    @Autowired
    private InfluxDbConfig influxDbConfig;


    @Override
    public List<BucketInfo> getBucketList() {
        List<BucketInfo> bucketList = new ArrayList<>();
        try {
            String bucketUrl= influxDbConfig.getDbUrl()+"/api/v2/buckets";
            String result2 = HttpRequest.get(bucketUrl)
                    .header("Authorization", "Token "+  new String((influxDbConfig.getToken())))
                    .header("Accept","application/json")
                    .header("Content-Type","application/json")
                    .execute().body();
            JSONObject jsonObject = JSONUtil.parseObj(result2);
            JSONArray buckets = jsonObject.getJSONArray("buckets");
            for (int i = 0; i < buckets.size(); i++) {
                BucketInfo bucketInfo = new BucketInfo();
                JSONObject entries = new JSONObject(buckets.get(i));
                bucketInfo.setName((String)entries.get("name"));
                bucketInfo.setOrgID((String)entries.get("orgID"));
                bucketInfo.setId((String)entries.get("id"));
                bucketList.add(bucketInfo);
            }
        }catch (Exception e){
            StaticLog.error(e,"get bucket list error ");
        }

        return bucketList;
    }

    @Override
    public BucketInfo getBucketInfoByName(String bucketName) {

        try {
            String bucketUrl= influxDbConfig.getDbUrl()+"/api/v2/buckets?name="+bucketName;
            String result2 = HttpRequest.get(bucketUrl)
                    .header("Authorization", "Token "+  new String((influxDbConfig.getToken())))
                    .header("Accept","application/json")
                    .header("Content-Type","application/json")
                    .execute().body();
            JSONObject jsonObject = JSONUtil.parseObj(result2);
            JSONArray buckets = jsonObject.getJSONArray("buckets");
            for (int i = 0; i < buckets.size(); i++) {
                BucketInfo bucketInfo = new BucketInfo();
                JSONObject entries = new JSONObject(buckets.get(i));
                bucketInfo.setName((String)entries.get("name"));
                bucketInfo.setOrgID((String)entries.get("orgID"));
                bucketInfo.setId((String)entries.get("id"));
                return bucketInfo;
            }
        }catch (Exception e){
            StaticLog.error(e,"get bucket list error ");
        }

        return null;
    }

    @Override
    public void createBucketInfoByName(String bucketName) {

        try {
            //获取orgid
            BucketInfo bucketInfoByName = getBucketInfoByName("_monitoring");
            RetentionRules expire = RetentionRules.builder().type("expire").everySeconds(RetentionTime_30_DAY).shardGroupDuration(0).build();
            List<RetentionRules> retentionRules = new ArrayList<>();
            retentionRules.add(expire);

            BucketInfo bucketInfo = BucketInfo.builder().name(bucketName).description("api create bucket").orgID(bucketInfoByName.getOrgID()).retentionRules(retentionRules).build();

            String bucketUrl= influxDbConfig.getDbUrl()+"/api/v2/buckets";
            String result2 = HttpRequest.post(bucketUrl)
                    .header("Authorization", "Token "+  new String((influxDbConfig.getToken())))
              
                    .header("Content-Type","application/json")
                    .body(JSONUtil.toJsonStr(bucketInfo))
                    .timeout(20000)//超时，毫秒
                    .execute().body();
            JSONObject jsonObject = JSONUtil.parseObj(result2);
            StaticLog.info("create bucket {} success",bucketName);
        }catch (Exception e){
            StaticLog.error(e,"get bucket list error ");
        }

    }
}

5. InfluxDBConnection工具类

package com.dameng.sql_realtime_parse_tool.core.engine.influxdb;

import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.StaticLog;
import com.dameng.sql_realtime_parse_tool.constant.CommonConstant;
import com.dameng.sql_realtime_parse_tool.constant.sql.SqlConstant;
import com.dameng.sql_realtime_parse_tool.domain.DateRange;
import com.dameng.sql_realtime_parse_tool.domain.TableDataBean;
import com.dameng.sql_realtime_parse_tool.domain.TableParamBean;
import com.dameng.sql_realtime_parse_tool.domain.dbms.SqlStatsBean;
import com.dameng.sql_realtime_parse_tool.domain.influxdb.InfluxDbConfig;
import com.dameng.sql_realtime_parse_tool.tool.core.DateTimeUtils;
import com.influxdb.client.*;
import com.influxdb.client.domain.InfluxQLQuery;
import com.influxdb.client.domain.WritePrecision;
import com.influxdb.client.write.events.WriteErrorEvent;
import com.influxdb.client.write.events.WriteSuccessEvent;
import com.influxdb.query.InfluxQLQueryResult;

import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;

/**
 * InfluxDB数据库连接操作类
 * <p>
 * https://github.com/influxdata/influxdb-client-java/tree/master/client#asynchronous-non-blocking-api
 *
 */

public class InfluxDBConnection {

    private static String dbUrl;

    private static char[] dbToken;

    private static String dbOrg;

    private static String dbBucket;

    private static int dataBatchSize;

    private static int bufferLimit;

    private static InfluxDBClient influxDBClient;

    private static WriteApi writeApi;

    public InfluxDBConnection(String dbUrl, char[] dbToken, String dbOrg, String dbBucket) {
        this.dbUrl = dbUrl;
        this.dbToken = dbToken;
        this.dbOrg = dbOrg;
        this.dbBucket = dbBucket;
    }


    /**
     * 测试连接是否正常
     *
     * @return true 正常
     */
    public static boolean ping() {

        try {
            return influxDBClient.ping();
        } catch (Exception e) {
            StaticLog.error("influxdb connect error", e.getMessage());
            return false;
        }
    }

    public static boolean pingAndCloseClient(InfluxDbConfig influxDbConfig) {
        InfluxDBClient influxDbClient = null;
        try {
            influxDbClient = getInfluxDbClient(influxDbConfig);
            return influxDbClient.ping();
        } catch (Exception e) {
            StaticLog.error("influxdb connect error", e.getMessage());
            return false;
        } finally {
            if (influxDbClient != null) {
                influxDbClient.close();
            }
        }
    }


    public static InfluxDBClient getInfluxDbClient(InfluxDbConfig influxDbConfig) {
        return InfluxDBClientFactory.create(influxDbConfig.getDbUrl(), influxDbConfig.getToken(), influxDbConfig.getOrg(), influxDbConfig.getBucket());
    }


    public static boolean initInfluxDbClient(InfluxDbConfig influxDbConfig) {

        try {
            //判断链接是否存活,没有问题的话，直接返回
            if (influxDBClient != null && ping()) {
                return true;
            }
            // 此方法仅是创建连接,并不会对连接进行探活
            influxDBClient = getInfluxDbClient(influxDbConfig);
            // 对连接进行探活
            if (!ping()) {
                return false;
            }

            dbUrl = influxDbConfig.getDbUrl();
            dbToken = influxDbConfig.getToken();
            dbOrg = influxDbConfig.getOrg();
            dbBucket = influxDbConfig.getBucket();
            dataBatchSize = influxDbConfig.getDataBatchSize();
            bufferLimit = influxDbConfig.getBufferLimit();

        } catch (Exception e) {
            StaticLog.error(e, "create influxDb conn fail,");
            return false;
        }
        return true;
    }


    /* 获取writeApi对象*/
    public static WriteApi getWriteApi() {

        if (writeApi == null) {
            //设置属性
            WriteOptions build = WriteOptions.builder().batchSize(dataBatchSize).bufferLimit(bufferLimit).build();

            writeApi = influxDBClient.makeWriteApi(build);

            //写入成功后的回调
            writeApi.listenEvents(WriteSuccessEvent.class, event -> {
                //  String data = event.getLineProtocol();
                StaticLog.info("batch size write influxdb success");
            });

            //写入失败后的回调
            writeApi.listenEvents(WriteErrorEvent.class, event -> {
                Throwable exception = event.getThrowable();
                StaticLog.error(exception, "batch size write influxdb error");
            });

            return writeApi;

        } else {
            return writeApi;

        }
    }


    /**
     * 异步写入
     */
    public static void writeDataByAsync(Object SqlEntity) {
        WriteApi writeApi = getWriteApi();
        try {
            writeApi.writeMeasurement(WritePrecision.NS, SqlEntity);
        } catch (Exception e) {
            StaticLog.error(e, "write measurement error");
        }

    }

    /**
     * 通知刷盘所有数据
     */
    public static void flush() {
        //刷新数据，避免关闭连接时还未刷盘的情况
        //writeApi flushInterval属性 默认值是1S
        try {
            if (writeApi != null) {
                writeApi.flush();
                Thread.sleep(CommonConstant.SLEEP_THREAD_TIME);
            }
        } catch (Exception e) {
            StaticLog.error(e, "influxdb client flush data error");
        }

    }

    /**
     * 关闭Client
     */
    public static void closeClient() {
        try {
            if (writeApi != null) {
                flush();
                writeApi.close();
                writeApi = null;
            }
            if (influxDBClient != null) {
                influxDBClient.close();
                influxDBClient = null;
            }
        } catch (Exception e) {
            StaticLog.error(e, "clost influxdb client error");
        }


    }


    /**
     * 查询
     */
    public static List<TableDataBean> queryDataBySql(InfluxDBClient influxDbClient, String sqlStr, String databaseStr) {



        InfluxQLQueryApi queryApi = influxDbClient.getInfluxQLQueryApi();

        // send request
        InfluxQLQueryResult result = queryApi.query(new InfluxQLQuery(sqlStr, databaseStr).setPrecision(InfluxQLQuery.InfluxQLPrecision.MILLISECONDS),
                (columnName, rawValue, resultIndex, seriesName) -> {
                    // convert columns
                    switch (columnName) {
                        case "time":
                            return Instant.ofEpochMilli(Long.parseLong(rawValue));
                        case "first":
                            return new BigDecimal(rawValue);
                        case "execSqlStr":
                            return rawValue;
                        case "paramsStr":
                            return new String(rawValue);
                        case "sessStr":
                            return new String(rawValue);
                        case "thrdStr":
                            return new String(rawValue);
                        case "trxIdStr":
                            return new String(rawValue);
                        case "userStr":
                            return new String(rawValue);
                        case "stmtStr":
                            return new String(rawValue);
                        case "ipStr":
                            return new String(rawValue);
                        case "setParamsStr":
                            return new Boolean(rawValue);
                        case "execSqlExecTime":
                            return new String(rawValue);
                        case "appnameStr":
                            return new String(rawValue);
                        case "paramsStatus":
                            return rawValue;
                        case "execSqlId":
                            return rawValue;
                        case "paramsId":
                            return rawValue;

                        case "sqlRowCount":
                            return rawValue;
                        case "DATA_COUNT":
                            return new String(rawValue);
                        default:
                            StaticLog.error("SQL查询未找到字段 {}", rawValue);
                            return null;
                            //throw new IllegalArgumentException("unexpected column " + columnName);
                    }
                });

        List<TableDataBean> tableDataBeanList = new ArrayList<>();
        if(result==null||result.getResults().isEmpty() || result.getResults().get(0).getSeries().isEmpty()){
            return tableDataBeanList;
        }
        for (InfluxQLQueryResult.Result resultResult : result.getResults()) {
            for (InfluxQLQueryResult.Series series : resultResult.getSeries()) {
                for (InfluxQLQueryResult.Series.Record record : series.getValues()) {
                    TableDataBean tableDataBean = new TableDataBean();
                    tableDataBean.setExecSqlId((String) record.getValueByKey("execSqlId"));
                    tableDataBean.setParamsId((String) record.getValueByKey("paramsId"));
                    tableDataBean.setSessStr((String) record.getValueByKey("sessStr"));
                    tableDataBean.setThrdStr((String) record.getValueByKey("thrdStr"));
                    tableDataBean.setUserStr((String) record.getValueByKey("userStr"));
                    tableDataBean.setTrxIdStr((String) record.getValueByKey("trxIdStr"));
                    tableDataBean.setExecSqlStr((String) record.getValueByKey("execSqlStr"));
                    tableDataBean.setStmtStr((String) record.getValueByKey("stmtStr"));
                    tableDataBean.setIpStr((String) record.getValueByKey("ipStr"));
                    tableDataBean.setParamsStatus((String) record.getValueByKey("paramsStatus"));
                    tableDataBean.setParamsStr((String) record.getValueByKey("paramsStr"));
                    tableDataBean.setSqlRecordTime(DateTimeUtils.convertToEasternEightZoneString((Instant)record.getValueByKey("time")));
                    tableDataBean.setExecSqlExecTime(Integer.parseInt((String) record.getValueByKey("execSqlExecTime")));

                    if(StrUtil.isNotBlank((CharSequence) record.getValueByKey("sqlRowCount"))){
                        tableDataBean.setSqlRowCount(Integer.parseInt((String) record.getValueByKey("sqlRowCount")));
                    };
                    tableDataBeanList.add(tableDataBean);
                }
            }
        }
        return tableDataBeanList;
    }




    public static SqlStatsBean querySqlDetailedList(InfluxDBClient influxDbClient, String sqlStr, TableParamBean tableParamBean) {

        InfluxQLQueryApi queryApi = influxDbClient.getInfluxQLQueryApi();
        SqlStatsBean sqlStatsBean = new SqlStatsBean();
        // send request
        InfluxQLQueryResult result = queryApi.query(new InfluxQLQuery(sqlStr, tableParamBean.getExecSqlDbName()).setPrecision(InfluxQLQuery.InfluxQLPrecision.MILLISECONDS),
                (columnName, rawValue, resultIndex, seriesName) -> {
                    // convert columns
                    switch (columnName) {
                        case "time":
                            return Instant.ofEpochMilli(Long.parseLong(rawValue));
                        case "SQL_CNT":
                            return new String(rawValue);
                        case "MAX_EXECTIME":
                            return new String(rawValue);
                        case "MIN_EXECTIME":
                            return new String(rawValue);
                        case "MEAN_EXECTIME":
                            return new String(rawValue);
                        default:
                            StaticLog.error("SQL查询未找到字段 {}", rawValue);
                            return null;
                    }
                });

        List<SqlStatsBean> sqlStatsBeanList = new ArrayList<>();
        if(result==null||result.getResults().isEmpty() || result.getResults().get(0).getSeries().isEmpty()){
            return null;
        }
        for (InfluxQLQueryResult.Result resultResult : result.getResults()) {
            for (InfluxQLQueryResult.Series series : resultResult.getSeries()) {
                for (InfluxQLQueryResult.Series.Record record : series.getValues()) {
                    sqlStatsBean.setSqlRecordTimeStr(DateTimeUtils.convertToEasternEightZoneString((Instant)record.getValueByKey("time")));
                    sqlStatsBean.setExecSqlId(tableParamBean.getExecSqlId());
                    sqlStatsBean.setParamsId(tableParamBean.getParamsId());
                    sqlStatsBean.setCnt(parseStringToInt((String)record.getValueByKey("SQL_CNT")));
                    sqlStatsBean.setMaxExectime(parseStringToInt((String)record.getValueByKey("MAX_EXECTIME")));
                    sqlStatsBean.setMinExectime(parseStringToInt((String)record.getValueByKey("MIN_EXECTIME")));
                    sqlStatsBean.setAvgExectime(parseStringToInt((String)record.getValueByKey("MEAN_EXECTIME")));
                    sqlStatsBeanList.add(sqlStatsBean);
                }
            }
        }
        return sqlStatsBean;
    }

    public static int parseStringToInt(String str) {

        return (int)Float.parseFloat(str);

/*
        int intValue = 0;
        if (str != null && !str.isEmpty()) {
            int dotIndex = str.indexOf(".");
            if (dotIndex != -1) {
                String intPart = str.substring(0, dotIndex);
                try {
                    intValue = Integer.parseInt(intPart);
                } catch (NumberFormatException e) {
                    StaticLog.error(e,"influxdb value convert fail, value is {}", str);
                    return 0;
                }
            }
        }
        return intValue;*/
    }

    public static int queryCountDataBySql(InfluxDBClient influxDbClient, String sqlStr, String databaseStr) {


        InfluxQLQueryApi queryApi = influxDbClient.getInfluxQLQueryApi();

        // send request
        InfluxQLQueryResult result = queryApi.query(new InfluxQLQuery(sqlStr, databaseStr).setPrecision(InfluxQLQuery.InfluxQLPrecision.MILLISECONDS),
                (columnName, rawValue, resultIndex, seriesName) -> {
                    // convert columns
                    switch (columnName) {
                        case "time":
                            return Instant.ofEpochMilli(Long.parseLong(rawValue));
                        case "DATA_COUNT":
                            return rawValue;
                        default:
                            throw new IllegalArgumentException("unexpected column " + columnName);
                    }
                });

        List<TableDataBean> tableDataBeanList = new ArrayList<>();
        if(result==null||result.getResults().isEmpty() || result.getResults().get(0).getSeries().isEmpty()){
            return 0;
        }
        for (InfluxQLQueryResult.Result resultResult : result.getResults()) {
            for (InfluxQLQueryResult.Series series : resultResult.getSeries()) {
                for (InfluxQLQueryResult.Series.Record record : series.getValues()) {
                  return  Integer.parseInt((String) record.getValueByKey("DATA_COUNT")) ;
                }
            }
        }
        return 0;
    }



    public static List<String> queryDbNameDataBySql(InfluxDBClient influxDbClient, String sqlStr, String databaseStr) {

        InfluxQLQueryApi queryApi = influxDbClient.getInfluxQLQueryApi();

        // send request
        InfluxQLQueryResult result = queryApi.query(new InfluxQLQuery(sqlStr, databaseStr).setPrecision(InfluxQLQuery.InfluxQLPrecision.MILLISECONDS),
                (columnName, rawValue, resultIndex, seriesName) -> {
                    // convert columns
                    switch (columnName) {
                        case "time":
                            return Instant.ofEpochMilli(Long.parseLong(rawValue));
                        default:
                            return rawValue;
                    }
                });

        List<String> tableNameList = new ArrayList<>();

        for (InfluxQLQueryResult.Result resultResult : result.getResults()) {
            for (InfluxQLQueryResult.Series series : resultResult.getSeries()) {
                for (InfluxQLQueryResult.Series.Record record : series.getValues()) {
                    if (record.getValues()[0].toString().startsWith(SqlConstant.INFLUXDB_BUCKET_PREFIX)) {
                        tableNameList.add(record.getValues()[0].toString());
                    }
                }
            }
        }
        return tableNameList;
    }

}

二、获取bucket列表

    void getBucketList() {
        List<String> stringList = new ArrayList<>();
        String bucketUrl= influxDbConfig.getDbUrl()+"/api/v2/buckets";
        String result2 = HttpRequest.get(bucketUrl)
                .header("Authorization", "Token "+  new String((influxDbConfig.getToken())))
                .header("Accept","application/json")
                .header("Content-Type","application/json")
                .execute().body();
        JSONObject jsonObject = JSONUtil.parseObj(result2);
        JSONArray buckets = jsonObject.getJSONArray("buckets");

        for (int i = 0; i < buckets.size(); i++) {
            JSONObject entries = new JSONObject(buckets.get(i));
            String name = (String)entries.get("name");
            stringList.add(name);
        }

        System.out.println(stringList);

    }

三、创建bucket桶

    void createBucket() {

        //获取orgid
        BucketInfo bucketInfoByName = influxdbApi.getBucketInfoByName(influxDbConfig.getBucket());

        RetentionRules expire = RetentionRules.builder().type("expire").everySeconds(RetentionTime_30_DAY).shardGroupDuration(0).build();
        List<RetentionRules> retentionRules = new ArrayList<>();
        retentionRules.add(expire);

        BucketInfo bucketInfo = BucketInfo.builder().name("sqllog_20240118").description("testsss").orgID(bucketInfoByName.getOrgID()).retentionRules(retentionRules).build();

        List<String> stringList = new ArrayList<>();
        String bucketUrl= influxDbConfig.getDbUrl()+"/api/v2/buckets";
        String result2 = HttpRequest.post(bucketUrl)
                .header("Authorization", "Token "+  new String((influxDbConfig.getToken())))
               // .header("Accept","application/json")
                .header("Content-Type","application/json")
                .body(JSONUtil.toJsonStr(bucketInfo))
               // .form()
                .timeout(20000)//超时，毫秒
                .execute().body();
        JSONObject jsonObject = JSONUtil.parseObj(result2);
        JSONArray buckets = jsonObject.getJSONArray("buckets");


        System.out.println(buckets);

    }

四、select语句查询数据（分页+时区）

拼接sql语句，注意后缀的时区+分页逻辑

String fluxSql = handleFluxDbSql(tableParamBean, SQLTYPE_DATASQL);
List<TableDataBean> tableDataBeanList = InfluxDBConnection.queryDataBySql(influxDbClient, fluxSql, tableParamBean.getExecSqlDbName());


//拼接SQL语句逻辑
    private String handleFluxDbSql(TableParamBean tableParamBean, int sqlType) {
        //拼接SQL语句进行
        //fluxSql = " execSqlType = 'SEL' and execSqlExecTime > 0 and time >= '2023-10-18 12:11:30.866' and time <= '2023-10-18 13:11:30.890'  LIMIT "+tableParamBean.getLimit();
        StringBuilder stringBuilder = new StringBuilder();
        if (SQLTYPE_DATASQL == sqlType) {
            stringBuilder.append("select execSqlStr,execSqlExecTime,sessStr,thrdStr,userStr,trxIdStr,stmtStr,ipStr,paramsStatus,time,execSqlId,paramsId,paramsStr,sqlRowCount from SqlEntity where");
        } else if (SQLTYPE_COUNTSQL == sqlType) {
            stringBuilder.append("select count(execSqlId) AS DATA_COUNT from SqlEntity where");
        }
        String beginSearchTime = DateUtil.formatDateTime(tableParamBean.getBeginSearchTime());
        String endSearchTime = DateUtil.formatDateTime(tableParamBean.getEndSearchTime());
    /*
            beginSearchTime = "2023-10-18 12:11:30.866";
            endSearchTime = "2023-10-18 13:11:30.890";
    */

        stringBuilder.append(" time >= '").append(beginSearchTime).append("'");
        stringBuilder.append(" and  time <= '").append(endSearchTime).append("'");

        //处理其他条件
        String whereStr = HandleData.handleCommonParams(tableParamBean);
        if (StrUtil.isNotEmpty(whereStr)) {
            stringBuilder.append(whereStr);
        }


        //分页条件
        //假设前台传过来的页数字段是page，每页条数字段是rows，那么查询指定页指定条数可以这样写：
        //SELECT time,Field列 FROM measurement WHERE 时间范围 LIMIT rows OFFSET (page - 1)*rows
        if (SQLTYPE_DATASQL == sqlType) {
            stringBuilder.append("  LIMIT ").append(tableParamBean.getLimit());
            stringBuilder.append("  OFFSET ").append((tableParamBean.getPage() - 1) * tableParamBean.getLimit());
        }


        //添加时区
        stringBuilder.append(" tz('Asia/Shanghai') ");

        StaticLog.debug("bucket is {},search sql is {}", tableParamBean.getExecSqlDbName(), stringBuilder.toString());
        return stringBuilder.toString();

    }

五、写入数据

# SqlEntity为自定义封装实体类
SqlEntity sqlEntity = ParseLineBeanToSQLEntity.doTryParse(stmtGroup, parseLogConfig, filterCond);
InfluxDBConnection.writeDataByAsync(sqlEntity);
飞奔的屎壳郎
关注
  • 13
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
influxdb 插入数据_向InfluxDB写入数据
weixin_39572442的博客
12-19 1876
简单用法在InfluxDB中的数据是通过“时间序列组织的“，包含一个测量变量，比如cpu_load或者温度。时间序列有无数的点，每个点都是metric的离散采样。点包含time(一个时间戳)、一个measurement测量变量(比如是cpu_load)，至少一个kv键值对field(测量变量的值，比如”value=0.64”，或者”temperature=21.2”)，很多的kv键值对tags(包...
influxdb 插入数据_influxdb写入数据
weixin_39855634的博客
12-19 3124
influxdb写入数据上一节课，学习了使用命令行写入数据，这节课，我们学习使用Rest接口写入数据。Rest接口比较简单，大家按照我们的方式做就可以了。但是必须确保，你自己安装了Influxdb，如果没有安装，请查看InfluxDb的简单安装使用HTTP接口创建数据库使用POST方式发送到URL的/query路径，参数q为CREATE DATABASE ，下面的例子发送一个请求到本地运行的Inf...
influxDB的增删改查操作，全部测试通过了
03-27
influxDB的增删改查操作，全部测试通过了 安装详解在这： https://blog.csdn.net/qq_27026603/article/details/79710465
InfluxDB使用教程：Java版InfluxDB工具类
热门推荐
五道口
10-20 4万+
本节开始介绍Influx在Java中的使用，先提供一个InfluxDB Java API 封装的工具类，方便大家直接上手使用。 1.InfluxDB工具类 先奉上工具类，接下来介绍使用方法。
探索未来数据存储的无限可能：InfluxDB-Client-Java 开源库
最新发布
gitblog_00082的博客
05-23 296
探索未来数据存储的无限可能：InfluxDB-Client-Java 开源库 项目地址:https://gitcode.com/influxdata/influxdb-client-java InfluxDB 是一款高性能的时间序列数据库，而 InfluxDB-Client-Java 则是专为该数据库设计的一款强大且易用的 Java 客户端库。这款客户端不仅支持最新的 InfluxDB 2.x 版...
influxdb-client-java使用范例
MY BLOG
05-09 841
【代码】influxdb-client-java使用范例。
java 写入数据到influxdb,并通过grafana展示实时数据
weixin_43952332的博客
03-02 543
influxdb显示筛选数据,并展示结果。运行后在3000端口。
JAVA操作Influxdb
tianlong1569的专栏
04-23 1097
influxdb中measurement类似于关系形数据库中的表，tag为列，有索引，可以进行快速查询，field列没有索引不能进行快速查询，但field可以进行运算。命名：measurement通过一个唯一的字符串名称来标识，通常反映其所代表的数据（如 cpu_usage、temperature、server_metrics）。它们定义了所存储数据的上下文，并作为查询InfluxDB中数据的主要入口点。Measurement 定义了所收集数据的上下文和类别，类似于关系型数据库中的一个表。
（十一）JAVA操作InfluxDB
卷心菜投手
07-26 6050
这里是将写入的时间精度确定为了毫秒，如果你传入了一个纳秒时间戳，但精度指明了毫秒，那超出毫秒的部分会被直接截断。2、influxdb-client-java为我们提供了一个WriteOption对象，调用makeWriteApi时可以传入这个对象，通过上图的提示我们可以看到，缓冲区的大小，批的大小，刷写的间隔我们都是可以进行明确指定的。3、两个方法各有很多不同的实现，其中一大部分是用来制定连接参数的，比如你创建连接对象的时候没有制定org和bucket，那么可以延迟到调用具体api的时候再指定。
influxdb 插入数据
tmlige的博客
04-27 9075
a,下面给出一个简单的实例 insert add_test,name=YiHui,phone=110 user_id=20,email="bangzewu@126.com" 新增一条数据，measurement为add_test, tag为name,phone, field为user_id,email 从上面的输出，简单小结一下插入的语句写法 insert + measurement + "," + tag=value,tag=value + 空格 + field=value,field=va
InfluxDB之java调用
weixin_41827053的博客
06-20 843
【代码】InfluxDB之java调用。
如何使用Java操作InfluxDB
xiaocxyczh的博客
07-22 1143
/ 连接到InfluxDB实例。// 创建数据库（如果不存在）// 写入单个点数据。// 批量写入点数据。
java使用influxDB数据库的详细代码
08-27
在本文中，我们将详细介绍 Java 使用 InfluxDB 数据库的详细代码，包括如何在 Maven 项目中引入 InfluxDB 依赖项，编写 InfluxDB 工具类，连接 InfluxDB 数据库，创建保留策略等。 pom.xml 中引入 InfluxDB 依赖项 ...
influxdb_c_influxdbc++11_influxDBC++_influxdb_influxdb接口c_C++_
09-29
InfluxDB是一款开源的时间序列数据库，专为处理大量的实时数据而设计，广泛应用于监控、物联网(IoT)、性能分析...在实际项目中，理解InfluxDB的数据模型和查询语言，以及如何利用C++接口的特性和功能，将是成功的关键。
influxdb-demo_influxdb_forgetxbi_batch_源码
10-02
在本教程中，我们将重点探讨如何使用InfluxDB的Java API进行数据的插入、创建、删除、查询及批量保存等操作，以`influxdb-demo_influxdb_forgetxbi_batch_源码`为例，深入理解InfluxDB的实践应用。 首先，我们需要...
tsdb:从kafka获取源链主从同步接时序数据库InfluxDB
05-18
数据处理data-handling连接kafka服务器从其中获取数据，处理数据之后调用代理网关influxdb-proxy将数据插入数据库。查询代理query预处理查询语句，过滤危险查询代码，调用查询InfluxDB数据库。公用模块common变量、...
JAVA整合 influxdb2.0 简单使用
呼啦呼啦嘞的博客
09-08 4125
JAVA整合 influxdb2.0 简单使用。
Java操作Influxdb2.x
自能生羽翼，何必仰云梯
09-15 2142
经过测试发现了问题，注意这个TOKEN是数据库配置的TOKEN虽然可以连接到数据库并成功插入数据，但是并不具备访问的权限的，也就是说只能保存不能进行其他操作。这四个key的值就对应的是JAVA应用程序中yaml中的配置的四个属性值，分别是url、token、org、bucket。应用程序通过依赖中的API来访问的库，报错的原因其实就是缺少了最重要的API访问权限配置，网上的资料里没讲这块，贼坑。点击创建后，会弹出生成的API访问的TOKENS，该TOKENS直接替换掉yaml配置文件中的token即可。
influxdb 插入数据_InfluxDB 插入数据 “数据丢失”
05-19
在 InfluxDB 中插入数据时，可能会遇到数据丢失的情况。以下是可能导致数据丢失的一些常见原因： 1. 数据写入频率过高，超过了 InfluxDB 的处理能力。 2. 写入数据时出现了网络问题或者服务器崩溃等异常情况。 3. 写入数据时没有使用正确的时间戳格式。 为了避免数据丢失，可以采取以下措施： 1. 调整数据写入的频率，避免超过 InfluxDB 的处理能力。 2. 在写入数据时使用正确的时间戳格式，并确保数据的时间戳与 InfluxDB 的时间戳保持一致。 3. 在写入数据时使用 InfluxDB 的客户端库，而不是手动编写 HTTP 请求，以确保请求的正确性和完整性。 4. 对于关键数据，可以采取备份和恢复的措施，以防止数据丢失。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值