JFinal中使用InfluxDB时序数据库

妖136

已于 2022-11-03 15:30:03 修改

阅读量739

点赞数

分类专栏： java 数据库前端文章标签： java 时序数据库 echarts

于 2022-11-03 15:29:53 首次发布

本文链接：https://blog.csdn.net/yao136/article/details/127670555

版权

java 同时被 3 个专栏收录

3 篇文章 0 订阅

订阅专栏

数据库

3 篇文章 0 订阅

订阅专栏

前端

3 篇文章 0 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

InfluxDB时序数据库是当前市场是使用率比较高的时序数据库，实现了IoTDB在JFinal中的使用，想起直接也实现InfluxDB的。使用的版本是开源的OSS单体版，其他版本有Cloud,Enterprise ，这都是付费的。

一、InfluxDB是什么？

InfluxDB是一个由InfluxData开发的开源时序型数据。它由Go写成，着力于高性能地查询与存储时序型数据。InfluxDB被广泛应用于存储系统的监控数据，IoT行业的实时数据等场景。

InfluxDB有三大特性：

Time Series （时间序列）：你可以使用与时间有关的相关函数（如最大，最小，求和等）
Metrics（度量）：你可以实时对大量数据进行计算
Eevents（事件）：它支持任意的事件数据
特点

为时间序列数据专门编写的自定义高性能数据存储。 TSM引擎具有高性能的写入和数据压缩
Golang编写，没有其它的依赖
提供简单、高性能的写入、查询 http api，Native HTTP API, 内置http支持，使用http读写
插件支持其它数据写入协议，例如 graphite、collectd、OpenTSDB
支持类sql查询语句
tags可以索引序列化，提供快速有效的查询
Retention policies自动处理过期数据
Continuous queries自动聚合，提高查询效率
schemaless(无结构)，可以是任意数量的列
Scalable可拓展
min, max, sum, count, mean,median 一系列函数，方便统计
Built-in Explorer 自带管理工具

二、使用步骤

1.引入库

<dependency>
   <groupId>com.influxdb</groupId>
   <artifactId>influxdb-client-java</artifactId>
   <version>6.3.0</version>
</dependency>

2.实现JFinal插件

public class InfluxDBPlugin implements IPlugin {

    protected InfluxDBClient client;

    protected String url;
    protected String token;
    protected String bucket;
    protected String org;

    public InfluxDBPlugin(String url,String token,String bucket,String org) {
        this.url=url;
        this.token=token;
        this.bucket=bucket;
        this.org=org;
    }

    @Override
    public boolean start() {
        if(client==null)
        {
            client= InfluxDBClientFactory.create(url,token.toCharArray());
        }
        InfluxDBUtils.init(client,bucket,org);
        return true;
    }

    @Override
    public boolean stop() {
        InfluxDBUtils.close();
        return true;
    }
}

3.InfluxDB工具类

public class InfluxDBUtils {

    public static InfluxDBClient client;
    public static String bucket;
    public static String org;

    public InfluxDBUtils() {

    }
    public static void init(InfluxDBClient _client)
    {
        if(_client==null)
        {
            throw new IllegalArgumentException("InfluxDBClient can not be null");
        }
        else
        {
            client=_client;
        }
    }
    public static void init(InfluxDBClient _client,String _bucket,String _org)
    {
        if(_client==null)
        {
            throw new IllegalArgumentException("InfluxDBClient can not be null");
        }
        else
        {
            client=_client;
            bucket=_bucket;
            org=_org;
        }
    }

    public static void close()
    {
        if(client!=null)
        {
            client.close();
        }
    }

    /**
     *  使用influxdb线路协议写入数据
     * @param data
     */
    public void writeRecord(String data)
    {
        //String data = "mem,host=host1 used_percent=23.43234543";
        WriteApiBlocking writeApi=client.getWriteApiBlocking();
        writeApi.writeRecord(bucket,org, WritePrecision.NS,data);
    }
    /**
     *  使用influxdb线路协议写入数据
     * @param datas
     */
    public static void writeRecords(List<String> datas)
    {
        //String data = "mem,host=host1 used_percent=23.43234543";
        WriteApiBlocking writeApi=client.getWriteApiBlocking();
        writeApi.writeRecords(bucket,org, WritePrecision.NS,datas);
    }

    /**
     * 使用数据插入节点
     * @param mem
     * @param tags
     * @param fields
     */
    public static void writePoint(String mem, HashMap<String,String> tags, HashMap<String,Object> fields)
    {
        Point point=Point.measurement(mem);
        if(tags!=null)
        {
            point.addTags(tags);
        }
        point.addFields(fields);
        point.time(Instant.now(),WritePrecision.NS);

        WriteApiBlocking writeApi=client.getWriteApiBlocking();
        writeApi.writePoint(bucket,org,point);
    }
    
    public static void writeMeasurement(Class<T> mem)
    {
        WriteApiBlocking writeApi=client.getWriteApiBlocking();
        writeApi.writeMeasurement(bucket,org,WritePrecision.NS,mem);
    }

    /**
     * 写入 pojo的list集合
     * @param list
     */
    public static void writeMeasurements(List<T> list)
    {
        WriteApiBlocking writeApi=client.getWriteApiBlocking();
        writeApi.writeMeasurement(bucket,org,WritePrecision.NS,list);
    }

    /**
     *  查询数据
     * @param query
     * @return
     */
    public static List<FluxTable> query(String query)
    {
        List<FluxTable> tables = client.getQueryApi().query(query, org);
        return tables;
    }

    /**
     * 查询结果影射成为POJO
     * @param T
     * @param query
     * @return
     */
    public static List<T> query(Class<T> T,String query)
    {
        /*String flux = "from(bucket: \"wxm-influx\")\n" +
                "  |> range(start: 2022-03-12T08:18:04Z,stop:2022-03-13T08:19:05Z)\n" +
                "  |> filter(fn:(r)=>(r.owner==\"wxm\"))";*/
        List<T> list = client.getQueryApi().query(query, T.class);
        //list.forEach(System.out::println);
        return list;
    }

    /**
     * 删除开始结束时间
     * @param start
     * @param stop
     */
    public static void delete(OffsetDateTime start,OffsetDateTime stop)
    {
        client.getDeleteApi().delete(start,stop,"",bucket,org);
    }
    
    /**
     *   List<FluxTable> 转 List<Record>
     * @param tables 单设备的数据集合
     * @return
     */
    public static List<Record> ToListRecord(List<FluxTable> tables){
        List<Record> list=new ArrayList<Record>();
        for (FluxTable fluxTable : tables) {
            List<FluxColumn> listCols = fluxTable.getColumns();     //数据信息
            List<FluxRecord> records = fluxTable.getRecords();
            for (FluxRecord fluxRecord : records) {
                Instant time=fluxRecord.getTime();
                Record record=new Record();
                record.set("time",time);

                String colName=fluxRecord.getField();
                Object obj = fluxRecord.getValue();
                record.set(colName,obj);

                list.add(record);
            }
        }
        return list;
    }

    /**
     *  查询出单参数的时间折线图数据集
     * @param tables    单设备的数据集合
     * @param field
     * @return
     */
    public static List<Object> ToList(List<FluxTable> tables,String field){
        List<Object> data;
        List<Object> list_data = new ArrayList<Object>();
        for (FluxTable fluxTable : tables) {
            List<FluxRecord> records = fluxTable.getRecords();
            for (FluxRecord fluxRecord : records) {
                data=new ArrayList<Object>();
                data.add(fluxRecord.getTime());
                data.add(fluxRecord.getValue());
                //System.out.println(fluxRecord.getTime() + ": " + fluxRecord.getValueByKey(field));
                list_data.add(data);
            }
        }
        return list_data;
    }

}

4.启动配置

influxdb.url=http://127.0.0.1:8086
influxdb.token=token
influxdb.bucket=adlot
influxdb.org=adlot

InfluxDBPlugin influxDBPlugin=new InfluxDBPlugin(p.get("influxdb.url")
						,p.get("influxdb.token"),p.get("influxdb.bucket"),p.get("influxdb.org"));
				plugins.add(influxDBPlugin);

查询数据并显示折线图

 String query="from(bucket: \""+bucket+"\")" +
                "  |> range(start: "+sdate+",stop:"+edate+") " +
                "  |> range(start:"+sdate+",stop:"+edate+") " +
                "  |> filter(fn:(r)=>r._measurement == \""+deviceId+"\" ";
        
        query+=" and r._field == \""+paramid+"\" ";
        query+=")";
        List<FluxTable> list= InfluxDBUtils.query(query);

总结

influxDB解决了大数据量的问题。

妖136

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JFinal中使用InfluxDB时序数据库

InfluxDB时序数据库是当前市场是使用率比较高的时序数据库，实现了IoTDB在JFinal中的使用，想起直接也实现InfluxDB的。使用的版本是开源的OSS单体版，其他版本有Cloud,Enterprise ，这都是付费的。一、InfluxDB是什么？InfluxDB是一个由InfluxData开发的开源时序型数据。它由Go写成，着力于高性能地查询与存储时序型数据。InfluxDB被广泛应用于存储系统的监控数据，IoT行业的实时数据等场景。
复制链接

扫一扫