JFinal中使用IoTDB时序数据库

已于 2022-10-24 22:06:33 修改
阅读量1.6k 收藏 2
点赞数
分类专栏： 数据库 java 文章标签： 1024程序员节 java iot 时序数据库
于 2022-10-24 15:14:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yao136/article/details/127493120
版权

文章目录

前言

使用步骤

1.引入库

2.JFinal自定义一个IoTDB的插件

3.插件启动配套的工具类：IoTDBUtils

4.JFinal插件启动

5.IoTDB的数据插入

6.IoTDB的数据查询

总结

前言

随着科技的快速发展，物联网已经变成了生活中处处存在的技术，物联网的存在必然会产生数据，而且物联网中的各种传感器数据量是大量的，时序性的，这就需要时序数据库，本实例使用的的是JFinal极速 web 开发框架，时序数据库IoTDB 是清华大学主导的 Apache 孵化项目，是一款专为物联网时序数据打造的数据库，提供数据采集、存储、分析的功能。

使用步骤

1.引入库

<!-- IoTDB时序数据库 -->
        <dependency>
            <groupId>org.apache.iotdb</groupId>
            <artifactId>iotdb-session</artifactId>
            <version>0.13.2</version>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2.JFinal自定义一个IoTDB的插件

public class IoTDBPlugin implements IPlugin {

    private static final Logger log = Logger.getLogger(IoTDBPlugin.class);

    protected String host;
    protected int port;
    protected List<String> nodeUrls;
    protected int fetchSize=-1;
    protected String username;
    protected String password;
    protected int thriftDefaultBufferSize;
    protected int thriftMaxFrameSize;
    protected boolean enableCacheLeader;
    protected Version version;

    protected Session session;

    public IoTDBPlugin() {

    }

    public IoTDBPlugin(String host,int port) {
        this.host=host;
        this.port=port;
    }

    public IoTDBPlugin(List<String> nodeUrls) {
        this.nodeUrls=nodeUrls;
    }

    public IoTDBPlugin(String host,int port,String username,String password,
                       int fetchSize,int thriftDefaultBufferSize,
                       int thriftMaxFrameSize,boolean enableCacheLeader,Version version) {
        this.host=host;
        this.port=port;
        this.username=username;
        this.password=password;
        this.fetchSize=fetchSize;
        this.thriftDefaultBufferSize=thriftDefaultBufferSize;
        this.thriftMaxFrameSize=thriftMaxFrameSize;
        this.enableCacheLeader=enableCacheLeader;
        this.version=version;
    }

    @Override
    public boolean start() {
        if(this.host!=null)
        {
            // 指定一个可连接节点
            session =
                    new Session.Builder()
                            .host(this.host)
                            .port(this.port)
                            .build();
        }
        else if(this.nodeUrls!=null)
        {
            // 指定多个可连接节点
            session =
                    new Session.Builder()
                            .nodeUrls(this.nodeUrls)
                            .build();
        }
        else if(this.fetchSize!=-1)
        {
            // 其他配置项
            session =
                    new Session.Builder()
                            .fetchSize(this.fetchSize)
                            .username(this.username)
                            .password(this.password)
                            .thriftDefaultBufferSize(this.thriftDefaultBufferSize)
                            .thriftMaxFrameSize(this.thriftMaxFrameSize)
                            .enableCacheLeader(this.enableCacheLeader)
                            .version(this.version)
                            .build();
        }
        else
        {
            // 全部使用默认配置
            session = new Session.Builder().build();
        }

        try {
            session.open();
            log.info("iotdb连接成功~");
            // 设置时区
            session.setTimeZone("+08:00");
        } catch (IoTDBConnectionException e) {
            e.printStackTrace();
        } catch (StatementExecutionException e) {
            e.printStackTrace();
        }
        IoTDBUtils.AddSession(session);
        return true;
    }

    @Override
    public boolean stop() {
        try {
            this.session.close();
            IoTDBUtils.close();
        } catch (IoTDBConnectionException e) {
            e.printStackTrace();
        }
        return false;
    }
}

3.插件启动配套的工具类：IoTDBUtils

public class IoTDBUtils {

    static String key;

    public IoTDBUtils() {
    }

    /**
     *  root.adlot.
     * @param _key
     */
    public static IoTDBUtils use(String _key) {
        key=_key;
        return new IoTDBUtils();
    }

    private static final Logger log = Logger.getLogger(IoTDBUtils.class);

    static Session session;

    /**
     * 初始化Session
     * @param _session
     */
    public static void AddSession(Session _session) {
        if (_session == null) {
            throw new IllegalArgumentException("IoTDB Session can not be null");
        } else {
            session = _session;
        }
    }

    /**
     *  关闭Session
     * @throws IoTDBConnectionException
     */
    public static void close() throws IoTDBConnectionException {
        if (session != null) {
            session.close();
        }
    }

    /**
     *  获取Session
     * @return
     */
    public static Session getSession() {
        return session;
    }

    /**
     * description: 带有数据类型的添加操作 - insertRecord没有指定类型
     *
     * @param * @param deviceId:节点路径如：root.a1eaKSRpRty.CA3013A303A25467
     *          time:时间戳
     *          measurementsList：物理量 即：属性
     *          type：数据类型： BOOLEAN((byte)0), INT32((byte)1),INT64((byte)2),FLOAT((byte)3),DOUBLE((byte)4),TEXT((byte)5),VECTOR((byte)6);
     *          valuesList：属性值 --- 属性必须与属性值一一对应
     * @return
     */
    public static void insertRecordType(String deviceId, Long time, List<String> measurementsList, TSDataType type, List<Object> valuesList) throws StatementExecutionException, IoTDBConnectionException, ServerException {
        if (measurementsList.size() != valuesList.size()) {
            throw new ServerException("measurementsList 与 valuesList 值不对应");
        }
        List<TSDataType> types = new ArrayList<>();
        measurementsList.forEach(item -> {
            types.add(type);
        });
        session.insertRecord(deviceId, time, measurementsList, types, valuesList);
    }

    /**
     * description: 带有数据类型的添加操作 - insertRecord没有指定类型
     *
     * @param deviceId:节点路径如：root.a1eaKSRpRty.CA3013A303A25467
     * @param time:时间戳
     * @param measurementsList：物理量                             即：属性
     * @param valuesList：属性值                                   --- 属性必须与属性值一一对应
     * @return
     */
    public static void insertRecord(String deviceId, Long time, List<String> measurementsList, List<String> valuesList)
            throws StatementExecutionException, IoTDBConnectionException, ServerException {
        if (measurementsList.size() == valuesList.size()) {
            session.insertRecord(deviceId, time, measurementsList, valuesList);
        } else {
            log.error("measurementsList 与 valuesList 值不对应");
        }
    }

    /**
     * description: 批量插入
     */
    public static void insertRecords(List<String> deviceIdList, List<Long> timeList, List<List<String>> measurementsList, List<List<String>> valuesList) throws StatementExecutionException, IoTDBConnectionException, ServerException {
        if (measurementsList.size() == valuesList.size()) {
            session.insertRecords(deviceIdList, timeList, measurementsList, valuesList);
        } else {
            log.error("measurementsList 与 valuesList 值不对应");
        }
    }

    /**
     * description: 插入操作
     *
     * @param deviceId:节点路径如：root.a1eaKSRpRty.CA3013A303A25467
     * @param time:时间戳
     * @param schemaList:                                      属性值 + 数据类型 例子： List<MeasurementSchema> schemaList = new ArrayList<>();  schemaList.add(new MeasurementSchema("breath", TSDataType.INT64));
     * @param maxRowNumber：
     * @return
     */
    public static void insertTablet(String deviceId, Long time, List<MeasurementSchema> schemaList, List<Object> valueList, int maxRowNumber) throws StatementExecutionException, IoTDBConnectionException {

        Tablet tablet = new Tablet(deviceId, schemaList, maxRowNumber);
        // 向iotdb里面添加数据
        int rowIndex = tablet.rowSize++;
        tablet.addTimestamp(rowIndex, time);
        for (int i = 0; i < valueList.size(); i++) {
            tablet.addValue(schemaList.get(i).getMeasurementId(), rowIndex, valueList.get(i));
        }
        if (tablet.rowSize == tablet.getMaxRowNumber()) {
            session.insertTablet(tablet, true);
            tablet.reset();
        }
        if (tablet.rowSize != 0) {
            session.insertTablet(tablet);
            tablet.reset();
        }
    }

    /**
     * description: 根据SQL查询
     */
    public static SessionDataSet query(String sql) throws StatementExecutionException, IoTDBConnectionException {
        return session.executeQueryStatement(sql);
    }

    /**
     * description: 删除分组 如 root.a1eaKSRpRty
     *
     * @param groupName：分组名称
     * @return
     */
    public static void deleteStorageGroup(String groupName) throws StatementExecutionException, IoTDBConnectionException {
        session.deleteStorageGroup(groupName);
    }

    /**
     * description: 根据Timeseries删除  如：root.a1eaKSRpRty.CA3013A303A25467.breath  （个人理解：为具体的物理量）
     */
    public static void deleteTimeseries(String timeseries) throws StatementExecutionException, IoTDBConnectionException {
        session.deleteTimeseries(timeseries);
    }

    /**
     * description: 根据Timeseries批量删除
     */
    public static void deleteTimeserieList(List<String> timeseriesList) throws StatementExecutionException, IoTDBConnectionException {
        session.deleteTimeseries(timeseriesList);
    }

    /**
     * description: 根据分组批量删除
     */
    public static void deleteStorageGroupList(List<String> storageGroupList) throws StatementExecutionException, IoTDBConnectionException {
        session.deleteStorageGroups(storageGroupList);
    }

    /**
     * description: 根据路径和结束时间删除 结束时间之前的所有数据
     */
    public static void deleteDataByPathAndEndTime(String path, Long endTime) throws StatementExecutionException, IoTDBConnectionException {
        session.deleteData(path, endTime);
    }

    /**
     * description: 根据路径集合和结束时间批量删除 结束时间之前的所有数据
     */
    public static void deleteDataByPathListAndEndTime(List<String> pathList, Long endTime) throws StatementExecutionException, IoTDBConnectionException {
        session.deleteData(pathList, endTime);
    }

    /**
     * description: 根据路径集合和时间段批量删除
     */
    public static void deleteDataByPathListAndTime(List<String> pathList, Long startTime, Long endTime)
            throws StatementExecutionException, IoTDBConnectionException {
        session.deleteData(pathList, startTime, endTime);
    }

    /**
     *  执行语句无返回值
     * @param sql
     * @throws IoTDBConnectionException
     * @throws StatementExecutionException
     */
    public static void exesql(String sql) throws IoTDBConnectionException, StatementExecutionException {
        session.executeNonQueryStatement(sql);
    }

    /**
     *   SessionDataSet 转 List<Record>
     * @param deviceid
     * @param sessionDataSet
     * @return
     * @throws IoTDBConnectionException
     * @throws StatementExecutionException
     */
    public static List<Record> ToListRecord(String deviceid,SessionDataSet sessionDataSet) throws IoTDBConnectionException, StatementExecutionException {
        List<Record> list=new ArrayList<Record>();
        List<String> listcols = sessionDataSet.getColumnNames();    //字段信息
        sessionDataSet.setFetchSize(1); // 只一个一个的获取
        int fetchSize = sessionDataSet.getFetchSize();
        int nextNum = 0;
        while(sessionDataSet.hasNext()) {
            RowRecord next = sessionDataSet.next(); // 如果获取的数据量
            List<Field> listRes = next.getFields();     //数据信息
            Record record=new Record();
            record.set("time",next.getTimestamp());
            for (int i = 0; i < listRes.size(); i++) {
                String colname=listcols.get(i+1);
                colname = colname.substring(colname.indexOf(deviceid.replaceAll("-","_"))+deviceid.length()+1);
                Field field = listRes.get(i);
                if(field.getDataType()!=null)
                {
                    if(field.getDataType()==TSDataType.DOUBLE)
                    {
                        record.set(colname,field.getDoubleV());
                    }
                    else if(field.getDataType()==TSDataType.FLOAT)
                    {
                        record.set(colname,field.getFloatV());
                    }
                    else if(field.getDataType()==TSDataType.INT32||field.getDataType()==TSDataType.INT64)
                    {
                        record.set(colname,field.getIntV());
                    }
                    else if(field.getDataType()==TSDataType.BOOLEAN)
                    {
                        record.set(colname,field.getBoolV());
                    }
                    else if(field.getDataType()==TSDataType.TEXT)
                    {
                        record.set(colname,field.getStringValue());
                    }
                    else
                    {
                        record.set(colname,field.getStringValue());
                    }
                }
                else
                {
                    record.set(colname,null);
                }
            }
            list.add(record);
            nextNum++;
        }
        sessionDataSet.closeOperationHandle();
        return list;
    }

    /**
     *  查询出单参数的时间折线图数据集
     * @param deviceid
     * @param sessionDataSet
     * @return
     * @throws IoTDBConnectionException
     * @throws StatementExecutionException
     */
    public static List<Object> ToList(String deviceid,SessionDataSet sessionDataSet) throws IoTDBConnectionException, StatementExecutionException {

        List<Object> data;
        List<Object> list_data = new ArrayList<Object>();

        List<String> listcols = sessionDataSet.getColumnNames();    //字段信息
        sessionDataSet.setFetchSize(1); // 只一个一个的获取
        int fetchSize = sessionDataSet.getFetchSize();
        int nextNum = 0;
        while(sessionDataSet.hasNext()) {
            RowRecord next = sessionDataSet.next(); // 如果获取的数据量
            List<Field> listRes = next.getFields();     //数据信息
            data=new ArrayList<Object>();
            data.add(next.getTimestamp());              //时间
            for (int i = 0; i < listRes.size(); i++) {
                String colname=listcols.get(i+1);
                colname = colname.substring(colname.indexOf(deviceid.replaceAll("-","_"))+deviceid.length()+1);
                Field field = listRes.get(i);
                if(field.getDataType()!=null)
                {
                    if(field.getDataType()==TSDataType.DOUBLE)
                    {
                        data.add(field.getDoubleV());
                    }
                    else if(field.getDataType()==TSDataType.FLOAT)
                    {
                        data.add(field.getFloatV());
                    }
                    else if(field.getDataType()==TSDataType.INT32||field.getDataType()==TSDataType.INT64)
                    {
                        data.add(field.getIntV());
                    }
                }
                else
                {
                    data.add(null);
                }
            }
            list_data.add(data);
            nextNum++;
        }
        sessionDataSet.closeOperationHandle();
        return list_data;
    }
}

4.JFinal插件启动

jfinal的继承“JFinalConfig”的类文件的“configPlugin(Plugins plugins)”添加插件，启动之后即可连接到IoTDB，我使用的是默认连接，IoTDB只使用地址和端口：

IoTDBPlugin ioTDBPlugin=new IoTDBPlugin(p.get("iotdb.host"),p.getInt("iotdb.port"));
plugins.add(ioTDBPlugin);

5.IoTDB的数据插入

List<String> measurementsList = new ArrayList<>();
            List<Double> valuesList = new ArrayList<>();
            String deviceId ="root.demo.group.deviceId";

            measurementsList.add("temperature");
            valuesList.add(30.3);
            
            try {
                IoTDBUtils.insertRecord(deviceId,new Date().getTime(), measurementsList, valuesList);
            } catch (StatementExecutionException e) {
                e.printStackTrace();
            } catch (IoTDBConnectionException e) {
                e.printStackTrace();
            } catch (ServerException e) {
                e.printStackTrace();
            }

6.IoTDB的数据查询

String sql="select temperature from root.demo.group.deviceid where time>=2020-10-10 12:00:00 and time <=2020-10-11 12:00:00";
SessionDataSet sessionDataSet = null;
        try {
            sessionDataSet = IoTDBUtils.query(sql);
            return sessionDataSet;
        } catch (StatementExecutionException e) {
            e.printStackTrace();
        } catch (IoTDBConnectionException e) {
            e.printStackTrace();
        }

解析“SessionDataSet”即可，可以参考IoTDBUtils方法中的ToList，生成类似如下的折线图。（我做的是多轴的）

总结

IoTDB我自测程序不断写入，上百万的参数数据，查询无压力。解决了当前的物联网项目中的大量数据的存储和查询问题。

妖136
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JFinal连接SQL Server 2008 R2数据库
scott_yes的博客
01-06 3584
JFinal连接SQL Server 2008 R2数据库
Android 开发中使用 SQLite 数据库
01-29
总结，Android 开发中使用 SQLite 数据库涉及到创建数据库和表、执行 SQL 命令、管理数据版本以及通过 `ContentProvider` 进行数据共享。虽然 SQLite 的功能与传统 SQL 数据库有所不同，但其灵活性和轻量级特性使其...
要将IoTDB查询结果以List的形式返回，你可以将每一行的结果存储在一个List中
weixin_36873225的博客
09-25 85
【代码】要将IoTDB查询结果以List的形式返回，你可以将每一行的结果存储在一个List中。
给JFinal添加 Sqlite 数据库支持
weixin_34068198的博客
07-31 139
2019独角兽企业重金招聘Python工程师标准>>> ...
Apache IoTDB源码解析（0.11.2版本）：Session执行executeQueryStatement的源码解析
编程学习者的博客
06-11 524
IoTDB 0.11.2
SpringBoot集成时序数据库IoTDB(IotDB-Session方式)
最新发布
无聊写点东西
06-28 204
说明：项目需使用时序数据库，后经调研选用了IoTDB数据库，因此需要在SpringBoot框架内集成该数据库，来进行数据查询、插入操作。根据官方文档Java可采用多种方式访问数据库，分别是Java原生接口、JDBC(不推荐)和REST API，下面选用Java原生接口和MyBatis的方式操作数据库。实际应用中需要高性能吞吐则使用Java原生接口的方式，但一些小量级的增删查可以使用MyBatis的方式。前提：已部署安装IoTDB数据库，具体安装部署流程可查看官网文档。
记录一次springboot连接测试iotdb
weixin_56855949的博客
04-02 994
我采用docker安装iotdb #拉取镜像 docker pull apache/iotdb:latest #启动容器 docker run -d --name iotdb -p 6667:6667 \ -v /data/iotdb:/iotdb/data \ -v /data/iotdb:/iotdb/logs \ apache/iotdb:latest /iotdb/bin/start-server.sh 引入maven原生接口 &
java中final关键字使用示例详解
09-04
Java中的`final`关键字是一个非常关键的特性，它在编程中起到了不可变性的角色，确保了某些元素在声明后不会改变。以下是对`final`关键字的深入解释和使用示例。 1. **final变量** - `final`变量一旦被初始化，就...
Java中final变量使用总结
09-03
Java中的`final`关键字在编程中扮演着至关重要的角色，它是Java语言中用来定义不可变性的关键字。当我们在声明变量时使用`final`，我们确保该变量的值一旦被赋值，就不能再次改变。这使得`final`变量成为常量，它们...
final关键字的使用.mp4
04-23
final关键字的使用f
java中final修饰符的使用方法
08-30
在Java编程语言中，`final`关键字是一种非常重要的修饰符，它可以用来限制变量、方法和类的可变性。理解并正确使用`final`对于编写安全、稳定的代码至关重要。下面我们将详细探讨`final`修饰符的用法及其背后的原理...
Spring Boot中使用MongoDB数据库的方法
09-09
总的来说，Spring Boot 结合 MongoDB 提供了一套强大的工具集，让开发者能够快速地在应用中集成和操作 MongoDB 数据库，无需关心底层连接和数据序列化的细节。无论是简单的文档存储还是复杂的查询，都可以借助 ...
java中final与finally的使用介绍
09-05
`finally` 块中的代码是必不可少的，特别是在处理资源关闭（如文件流、数据库连接等）时，以确保资源得到正确释放。 - 当一个方法中包含 `try-catch-finally` 结构时，程序会首先执行 `try` 块中的代码。如果在 `...
Java中final关键字的使用与注意总结
08-24
Java中final关键字的使用与注意总结 Java中final关键字的使用与注意总结主要给大家介绍了关于Java中final关键字的相关资料，对大家的学习或者使用Java具有一定的参考学习价值。下面我们将详细介绍final关键字的...
final关键字的使用思维导图
05-09
关于final关键字的使用思维导图，可使用freemind软件打开，该软件为免费软件，下载后可自由进行修改
JFinal框架时间相关的使用
zhaogui_2的博客
09-29 191
JFinal框架时间相关的
jfinal-mysql时间类型映射到LocalDateTime
pfjia的博客
03-07 2836
背景介绍 问题 如何生成时间类型为java.time.LocalDateTime的BaseModel类代码? 如何将ResultSet中的JDBC类型转换java.time.LocalDateTime? renderJson()时如何正确显示java.time.LocalDateTime? getBean()如何将前端传的参数转为java.time.LocalDateTime? 总结 参...
时序数据库-4-[IoTDB]的python3操作
qq_20466211的博客
11-07 2222
python3操作IoTDB
Iotdb 数据库安装和启动
Tongyao
06-15 2498
https://iotdb.apache.org/zh/UserGuide/V0.13.x/QuickStart/QuickStart.htmlIoTDB 是针对时间序列数据收集、存储与分析一体化的数据管理引擎。它具有体量轻、性能高、易使用的特点，完美对接 Hadoop 与 Spark 生态，适用于工业物联网应用中海量时间序列数据高速写入和复杂分析查询的需求。https://iotdb.apache.org/zh/Download/ 翻译过来，如下图 1、前提下版本 2、下载好的zip压缩包，解压到相应目录
Android中使用Sqlite创建数据库代码例子
04-12
好的，以下是一个Android中使用Sqlite创建数据库的代码例子： ``` public class MyDatabaseHelper extends SQLiteOpenHelper { private static final String DB_NAME = "mydatabase.db"; //数据库名称 private ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值