influxdb Java新增查询操作

自动配置类

/**
 * @author chenchen
 * @description
 * @date 2023/7/6 13:49
 */
@Configuration
@ConditionalOnProperty(prefix = "support.influxdb", value = "enabled", havingValue = "true")
public class InfluxDBConfig {

    @Value("${support.influxdb.url}")
    public String url;
    @Value("${support.influxdb.userName}")
    public String userName;
    @Value("${support.influxdb.password}")
    public String password;
    @Value("${support.influxdb.database}")
    public String database;

    @Bean
    public InfluxDB influxdb() {
        InfluxDB influxDB = InfluxDBFactory.connect(url, userName, password);
        influxDB.setDatabase(database)
                .setLogLevel(InfluxDB.LogLevel.BASIC)
                .enableBatch(1, 1000 * 60, TimeUnit.MILLISECONDS);  //异步插入：enableBatch这里第一个是point的个数，第二个是时间，单位毫秒，point的个数和时间是联合使用的，如果满100条或者60 * 1000毫秒，满足任何一个条件就会发送一次写的请求。
        return influxDB;
    }
}

数据写入

/**
     * @return void
     * @description 插入
     * @author chenchen
     * @date 2023/7/6 14:14
     */
    public void insert(String measurement, Map<String, String> tags, Map<String, Object> fields) {
        insert(measurement, System.currentTimeMillis(), tags, fields);
    }

    /**
     * @description 插入, 带时间time
     * @author chenchen
     * @date 2023/7/6 14:17
     * @param measurement 表
     * @param time 毫秒值
     * @param tags 标签
     * @param fields 字段
     * @return void
     */
    public void insert(String measurement, long time, Map<String, String> tags, Map<String, Object> fields) {
        Point.Builder builder = Point.measurement(measurement);
        builder.time(time, TimeUnit.MILLISECONDS);
        builder.tag(tags);
        builder.fields(fields);
        influxDB.write(builder.build());
    }

    /**
     * @description 批量写入数据
     * @author chenchen
     * @date 2023/7/6 14:24
     * @param records 要保存的数据（调用BatchPoints.lineProtocol()可得到一条record）
     * @return void
     */
    public void insertBatchByRecords(List<Map<String, Object>> records) {
        List<String> list = new ArrayList<>();
        for (Map<String, Object> record : records) {
            list.add(buildPoint(record).lineProtocol());
        }
        influxDB.write(list);
    }

    /**
     * @description 批量写入数据
     * @author chenchen
     * @date 2023/7/6 14:49
     * @param records
     * @return void
     */
    public void insertBatchByPoints(List<Map<String, Object>> records) {
        BatchPoints batchPoints = BatchPoints.builder()
                .consistency(InfluxDB.ConsistencyLevel.ALL)
                .build();
        for (Map<String, Object> record : records) {
            batchPoints.point(buildPoint(record));
        }
        influxDB.write(batchPoints);
    }

    @SuppressWarnings("unchecked")
    private Point buildPoint(Map<String, Object> record) {
        Point.Builder builder = Point.measurement((String) record.get("measurement"));
        builder.time((long) record.get("time"), TimeUnit.MILLISECONDS);
        builder.tag((Map<String, String>) record.get("tags"));
        builder.fields((Map<String, Object>) record.get("fields"));
        return builder.build();
    }

数据查询

/**
     * @description 查询，返回map集合
     * @author chenchen
     * @date 2023/7/6 15:16
     * @param fieldKeys 查询的字段，不可为空；不可为单独的tag
     * @param measurement 度量，不可为空
     * @return java.util.List<java.util.Map < java.lang.String, java.lang.Object>>
     */
    public List<Map<String, Object>> queryRecords(String fieldKeys, String measurement) {
        return processRecords("select " + fieldKeys + " from " + measurement);
    }

    /**
     * @description 查询带排序
     * @author chenchen
     * @date 2023/7/6 15:18
     * @param fieldKeys
     * @param measurement
     * @param order
     * @return java.util.List<java.util.Map < java.lang.String, java.lang.Object>>
     */
    public List<Map<String, Object>> queryRecords(String fieldKeys, String measurement, String order) {
        return processRecords("select " + fieldKeys + " from " + measurement + " order by " + order);
    }

    /**
     * @description 时间范围查询
     * @author chenchen
     * @date 2023/7/7 11:11
     * @param measurement
     * @param devEUI
     * @param beginTime
     * @param endTime
     * @return java.util.List<java.util.Map < java.lang.String, java.lang.Object>>
     */
    public List<Map<String, Object>> queryRecords(String measurement, String devEUI, String beginTime, String endTime) {
        String command = "select * from " + measurement + " where \"devEUI\" = '" + devEUI + "'";
        if (StringUtils.isNotBlank(beginTime)) {
            command += " and time >= '" + beginTime + "'";
        }
        if (StringUtils.isNotBlank(endTime)) {
            command += " and time <= '" + endTime + "'";
        }
        command += " order by time desc";
        return processRecords(command);
    }

    /**
     * @description 查询
     * @author chenchen
     * @date 2023/7/6 14:55
     * @param command
     * @return java.util.List<java.util.Map < java.lang.String, java.lang.Object>>
     */
    public List<Map<String, Object>> processRecords(String command) {
        List<Map<String, Object>> list = new ArrayList<>();
        QueryResult queryResult = influxDB.query(new Query(command));
        List<QueryResult.Result> resultList = queryResult.getResults();
        //把查询出的结果集转换成对应的实体对象，聚合成list
        for (QueryResult.Result result : resultList) {
            List<QueryResult.Series> seriesList = result.getSeries();
            if (CollectionUtils.isNotEmpty(seriesList)) {
                for (QueryResult.Series series : seriesList) {
                    List<String> columns = series.getColumns();
                    List<List<Object>> values = series.getValues();
                    if (CollectionUtils.isNotEmpty(values)) {
                        for (List<Object> value : values) {
                            Map<String, Object> map = new HashMap<>();
                            for (int i = 0; i < columns.size(); i++) {
                                map.put(columns.get(i), value.get(i));
                            }
                            list.add(map);
                        }
                    }
                }
            }
        }
        return list;
    }