InfluxdbUtil 工具类

@Component
@Slf4j
public class InfluxdbUtil<T> {

    @Value("${influxdb.url}")
    private String url;

    private InfluxDB influxdb;

    @PostConstruct
    public void init() {
        influxdb = InfluxDBFactory.connect(url);
        if (!influxdb.isBatchEnabled()) {
            influxdb.enableBatch(2000, 3000, TimeUnit.MILLISECONDS, Executors.defaultThreadFactory(),
                    (points, throwable) -> log.error("【初始化influxdb失败】 原因： " + throwable.getMessage()));
        }
    }

    //创建数据库
    public void createDatabase(String dbName) {
        QueryResult result = influxdb.query(new Query("show databases"));
        List<List<Object>> databases = result.getResults().get(0).getSeries().get(0).getValues();
        List<String> nameList = databases.stream().map(e -> e.get(0).toString()).collect(Collectors.toList());
        if (!nameList.contains(dbName)) {
            influxdb.query(new Query("create database " + dbName));
            influxdb.setDatabase(dbName);
            log.info("创建influxdb 数据库{}成功", dbName);
        }
    }

    public QueryResult query(String database, String command, TimeUnit unit) {
        try {
            return influxdb.query(new Query(command, database), unit);
        } catch (Exception e) {
            return null;
        }
    }

    public List<Map<String, Object>> queryGetList(String dbName, String command) {
        try {
            QueryResult result = influxdb.setDatabase(dbName).query(new Query(command));
            List<QueryResult.Series> series = result.getResults().get(0).getSeries();
            if (CollectionUtils.isNotEmpty(series)) {
                QueryResult.Series data = series.get(0);
                return composeValues(data);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Collections.emptyList();
    }


    public List<Map<String, Object>> composeValues(QueryResult.Series series) {
        List<Map<String, Object>> list = new ArrayList<>();
        for (List<Object> value : series.getValues()) {
            Map<String, Object> map = new HashMap<>();
            List<String> key = series.getColumns();
            for (int i = 0; i < key.size(); i++) {
                map.put(key.get(i), value.get(i));
            }
            list.add(map);
        }
        return list;
    }

    public List<T> query(String dbName, String command, Class<T> clazz) {
        List<T> list = new ArrayList<>();
        try {
            QueryResult result = influxdb.setDatabase(dbName).query(new Query(command));
            List<QueryResult.Series> series = result.getResults().get(0).getSeries();
            if (CollectionUtils.isNotEmpty(series)) {
                QueryResult.Series data = series.get(0);
                for (List<Object> value : data.getValues()) {
                    T instance = clazz.newInstance();
                    List<String> key = data.getColumns();
                    for (int i = 0; i < key.size(); i++) {
                        Field field = ReflectUtil.getField(clazz, key.get(i));
                        if (field != null) {
                            Method setMethod = ReflectUtil.getMethodByNameIgnoreCase(clazz, "set" + field.getName());
                            //time类型特殊处理
                            if ("time".equals(field.getName())) {
                                ReflectUtil.invoke(instance, setMethod, handleTimeType(value.get(i).toString()));
                            } else {
                                ReflectUtil.invoke(instance, setMethod, value.get(i));

                            }
                        }
                    }
                    list.add(instance);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * influxdb 默认返回rfc3339格式的时间
     * 这里可以进行处理转换成LocalDateTime
     *
     * @param time
     */
    private LocalDateTime handleTimeType(String time) {
        Date date = new DateTime(time);
        Instant instant = date.toInstant();
        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
    }


    public void insertBatch(String database, BatchPoints points) {
        influxdb.setDatabase(database).write(points);
    }
}