帮助中心Appearance
Java openPlant API
1. 介绍
该文档是Java封装操作实时数据库的说明文档，实现了操作数据库的大部分功能，简化操作流程，优化接口。
2. 设计原理
Java 使用JNI的方法实现了对新增数据类型、SQL等接口的封装，方便用户使用
3. 使用方式
1. 将对应的jar放到项目依赖里面
2. 使用方式和以前的Java操作数据基本一样，不同的是增加了新的接口，简化了操作逻辑
3、增加了订阅接口，可以订阅Realtime(实时数据),Alarm(报警数据)，Point(静态信息)表
4. 新增接口说明和代码示例（适配V5.0/V4.0）
4.1、新协议接口函数解释
新协议接口函数
1．获取连接new OPConnect()
函数示例：new OPConnect(String host, int port, int timeout, String user, String password)
所属包名和类名：com.magus.opio.net.OPConnect
返回类型：com.magus.opio.net.IOPConnect类型
host：数据库所在服务器的ip
port：数据库服务的端口
timeout：数据库超时时间以毫秒：单位
user和password分别：数据库用户名和密码
2．创建查询结构OPConnect.createTable()
函数示例：OPConnect.createTable(String tableName)
所属包名和类名：com.magus.opio.net.OPConnect
返回类型：com.magus.opio.dto.OPTable
tableName：需要查询的数据库里的表，可选参数有:
OPConst.TABLE_DATABASE:数据库
OPConst.TABLE_NODE:节点
OPConst.TABLE_POINT:点信息表
OPConst.TABLE_REALTIME:实时表
OPConst.TABLE_ARCHIVE:历史表
OPConst.TABLE_ALARM:报警表
OPConst.TABLE_AALARM:历史报警表
OPConst.TABLE_STAT:统计表
3．增加查询结构字段OPTable.addColumn()
函数示例1：OPTable.addColumn(String columnName, int type)
函数示例2：OPTable.addColumn(String columnName)
返回类型：int，是加入字段的序号
columnName：表结构字段名,可传数据库对应字段如”AV”、”DS”、”TM”、”ED”等等
type：该字段对应的数据类型,默认：OPValue.TYPE_OBJECT表示是一个Object类型，可选参数还有：
OPValue.TYPE_NULL，是一个null类型
OPValue.TYPE_BOOL，示是一个布尔类型
OPValue.TYPE_INT32，表示一个32位的整型
OPValue.TYPE_INT64，表示一个64位的整型
OPValue.TYPE_FLOAT，表示一个浮点数类型
OPValue.TYPE_DATETIME，表示一个时间类型
OPValue.TYPE_STRING，表示是一个字符串类型
OPValue.TYPE_BINARY，表示是一个二进制类型
OPValue.TYPE_OBJECT，表示是一个Object类型
4．新增要写入或者更新的记录OPTable.NewRow()
函数示例：OPTable.NewRow()
返回值类型：com.magus.opio.dto.OPRow
5．给新增的记录赋值OPRow.bind()
函数示例1：OPRow.bind(int index, Object value, int type)
函数示例2：OPRow.bind(int index, Object value)
返回值：没有返回值
index：OPTable对象里增加的字段的序号
value ：要给这条记录对应字段传入的值
type：该传入的值需要对应的数据类型,默认：OPValue.TYPE_OBJECT表示是一个Object类型，可选参数还有：
OPValue.TYPE_NULL，是一个null类型
OPValue.TYPE_BOOL，示是一个布尔类型
OPValue.TYPE_INT32，表示一个32位的整型
OPValue.TYPE_INT64，表示一个64位的整型
OPValue.TYPE_FLOAT，表示一个浮点数类型
OPValue.TYPE_DATETIME，表示一个时间类型
OPValue.TYPE_STRING，表示是一个字符串类型
OPValue.TYPE_BINARY，表示是一个二进制类型
OPValue.TYPE_OBJECT，表示是一个Object类型
6．把新增的记录增加到表数据结构OPTable.append()
函数示例：OPTable.append(OPRow row)
返回值：int类型，是增加的记录的序号
row ：创建的要插入或者更新的记录
7．插入数据到数据库OPConnect.insert()
函数示例：OPConnect.insert(OPTable table)
返回值类型：com.magus.jdbc.OPResultSet
table ：创建的要插入的记录的数据结构
8．更新数据到数据库OPConnect.update()
函数示例：OPConnect.update(OPTable table)
返回值类型：com.magus.jdbc.OPResultSet
table ：创建的要更新的记录的数据结构
9．查询数据OPConnect.find()
函数示例1：OPConnect.find(OPTable table,Object keys)
函数示例2：OPConnect.find(OPTable table)
返回值类型：com.magus.jdbc.OPResultSet
table ：创建的查询字段的结构
keys：查询的id或者点名的数组ID数组：一个int[],点名数组：String[]
10．执行SQL语句 OPConnect.execSQL()
函数示例：OPConnect.execSQL(String sql)
返回值类型：com.magus.jdbc.OPResultSet;
sql ：按照openPlant数据库的SQL规范的SQL语句
11．删除数据OPConnect.remove()
函数示例：OPConnect.remove(OPTable table,Object keys)
返回值类型：com.magus.jdbc.OPResultSet
table ：创建的需要删除的记录字段的结构
keys：需要删除记录的id或者点名的数组ID数组：一个int[],点名数组：String[]
12．查询历史数据OPConnect.findArchive()
函数示例：OPConnect.findArchive(OPTable table, Object keys, Date begin, Date end, OPConst.Archive_Model mode, int interval)
返回值类型：com.magus.jdbc.OPResultSet
keys：查询的id或者点名的数组，ID数组：一个int[]，点名数组：String[]
begin：查询历史的开始时间
end：查询历史的结束时间
mode：查询历史的方式可选参数：
OPConst.Archive_Model.raw：原始数据
OPConst.Archive_Model.span：等间距采样
OPConst.Archive_Model.plot：绘图值
OPConst.Archive_Model.flow：流量值
OPConst.Archive_Model.max：最大值
OPConst.Archive_Model.min：最小值
OPConst.Archive_Model.avg：面积平均值
OPConst.Archive_Model.mean：算数平均值
interval ：采样间隔，单位是秒，若mode：原始数据类型，interval参数必须：1
13．删除历史OPConnect.removeArchive()
函数示例：OPConnect.removeArchive(Object keys, Date begin, Date end)
返回值类型：com.magus.jdbc.OPResultSet
begin ：需要删除的历史的开始时间
end：需要删除的历史数据的结束时间
14．订阅数据 new OPSubscribe()
函数示例：new OPSubscribe(Connection conn, String tableName, ArrayList<?> keyList, SubscribeResultSet subscribeResultSet)
conn ：数据库连接，类型：java.sql.Connection，连接必须按照标准的jdbc使用方式获取
tableName ：需要订阅的表名，可选参数：
“Realtime”：表示订阅实时数据
“Alarm”:表示订阅报警数据
“Point”:表示订阅静态数据
keyList ：订阅的点的ID的数组或者点名的列表，ID：Integer的列表，点名：String的列表
subscribeResultSet：实现了这个订阅接口的对象，用来订阅接受推送的数据4.2、新协议接口代码示例
4.2.1 连接信息配置
示例中使用的类都会继承共有数据类，方便全局修改变量。
示例中类定义了使用的基本信息以及连接配置信息，还有统计的结果打印接口。
连接信息配置
package com.magus.jdbc;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
import java.text.SimpleDateFormat;
public class ExampleBase {
public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
public static String ip = "127.0.0.1";
public static int port = 8200;
public static String user = "sis";
public static String password = "openplant";
public static int timeout = 180;
public static int number = 10000;
public static int show(OPResultSet rs) throws SQLException {
int count = 0;
ResultSetMetaData rsmd = rs.getMetaData();
String formatStr = "%-20s";
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
System.out.print(String.format(formatStr, rsmd.getColumnLabel(i).toUpperCase()) + "\t");
}
System.out.print("\n");
while (rs.next()) {
StringBuffer sb = new StringBuffer();
count++;
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
if (rsmd.getColumnType(i) == Types.TIMESTAMP) {
sb.append(sdf.format(rs.getDate(i)) + "\t");
} else if (rsmd.getColumnType(i) == Types.BOOLEAN) {
sb.append(rs.getBoolean(i) + "\t");
} else {
sb.append(String.format(formatStr, rs.getString(i)) + "\t");
}
}
if (sb.length() > 0) {
System.out.println(sb.toString());
}
}
return count;
}
}4.2.1 插入数据接口 insert
详细代码示例
package com.magus.jdbc;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import com.magus.OPException;
import com.magus.opio.dto.OPConst;
import com.magus.opio.dto.OPRow;
import com.magus.opio.dto.OPTable;
import com.magus.opio.dto.OPValue;
import com.magus.opio.net.IOPConnect;
import com.magus.opio.net.OPConnect;
public class ExampleInsert extends ExampleBase {
public static void main(String[] args) throws Exception {
IOPConnect conn = new OPConnect(ip, port, 180, user, password);
Date time = conn.getServerTime();
System.out.println("database now time:" + sdf.format(time));
// insert database node
insertNode(conn);
OPTable table = conn.createTable(OPConst.TABLE_POINT);
// 设置添加的列
table.addColumn("GN", OPValue.TYPE_STRING);
table.addColumn("RT", OPValue.TYPE_INT32);
table.addColumn("ED", OPValue.TYPE_STRING);
OPRow row = null;
// 添加行
for (int i = 1; i <= number; i++) {
row = table.NewRow();
row.bind(0, "W3.AX.AX_" + i);
row.bind(1, 0, OPValue.TYPE_INT32);
row.bind(2, "this is ax point " + i);
table.append(row);
row.bind(0, "W3.DX.DX_" + i);
row.bind(1, 1, OPValue.TYPE_INT32);
row.bind(2, "this is dx point " + i);
table.append(row);
row.bind(0, "W3.I2.I2_" + i);
row.bind(1, 2, OPValue.TYPE_INT32);
row.bind(2, "this is i2 point " + i);
table.append(row);
row.bind(0, "W3.I4.I4_" + i);
row.bind(1, 3, OPValue.TYPE_INT32);
row.bind(2, "this is i4 point " + i);
table.append(row);
row.bind(0, "W3.R8.R8_" + i);
row.bind(1, 4, OPValue.TYPE_INT32);
row.bind(2, "this is r8 point " + i);
table.append(row);
row.bind(0, "W3.LONG.LONG_" + i);
row.bind(1, 5, OPValue.TYPE_INT32);
row.bind(2, "this is long point " + i);
table.append(row);
row.bind(0, "W3.TEXT.TEXT_" + i);
row.bind(1, 6, OPValue.TYPE_INT32);
row.bind(2, "this is text point " + i);
table.append(row);
row.bind(0, "W3.BLOB.BLOB_" + i);
row.bind(1, 7, OPValue.TYPE_INT32);
row.bind(2, "this is blob point " + i);
table.append(row);
}
long t = System.currentTimeMillis();
OPResultSet rs = conn.insert(table);
System.out.println("insert database point use time:" + (System.currentTimeMillis() - t));
show(rs);
rs.close();
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
insertRealtime(conn);
conn.close();
}
public static void insertNode(IOPConnect conn) throws OPException, SQLException {
OPTable table = conn.createTable(OPConst.TABLE_NODE);
// 设置添加的列
table.addColumn("GN", OPValue.TYPE_STRING);
table.addColumn("ED", OPValue.TYPE_STRING);
OPRow row = table.NewRow();
row.bind(0, "W3.AX");
row.bind(1, "AX NODE");
table.append(row);
row.bind(0, "W3.DX");
row.bind(1, "DX NODE");
table.append(row);
row.bind(0, "W3.I2");
row.bind(1, "I2 NODE");
table.append(row);
row.bind(0, "W3.I4");
row.bind(1, "I4 NODE");
table.append(row);
row.bind(0, "W3.R8");
row.bind(1, "R8 NODE");
table.append(row);
row.bind(0, "W3.LONG");
row.bind(1, "LONG");
table.append(row);
row.bind(0, "W3.TEXT");
row.bind(1, "TEXT NODE");
table.append(row);
row.bind(0, "W3.BLOB");
row.bind(1, "BLOB NODE");
table.append(row);
long t = System.currentTimeMillis();
OPResultSet rs = conn.insert(table);
show(rs);
rs.close();
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
System.out.println("insert database node user time:" + (System.currentTimeMillis() - t));
}
public static void insertRealtime(IOPConnect conn) throws OPException, SQLException, InterruptedException {
OPResultSet rs = null;
OPTable table = conn.createTable(OPConst.TABLE_REALTIME);
// 设置添加的列
table.addColumn("GN", OPValue.TYPE_STRING);
table.addColumn("AV", OPValue.TYPE_OBJECT);
OPRow row = null;
int index = 0;
int rIndex = 2;
// 添加行
while (true) {
table.clear();
long t = System.currentTimeMillis();
index++;
for (int i = 1; i <= number; i++) {
row = table.NewRow();
row.bind(0, "W3.AX.AX_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, Math.random() + index);
}
table.append(row);
row.bind(0, "W3.DX.DX_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, index % 2);
}
table.append(row);
row.bind(0, "W3.I2.I2_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, index);
}
table.append(row);
row.bind(0, "W3.I4.I4_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, index);
}
table.append(row);
row.bind(0, "W3.R8.R8_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, Math.random() + index * 10);
}
table.append(row);
row.bind(0, "W3.LONG.LONG_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, index * 10 + (int) (Math.random() * 1000));
}
table.append(row);
row.bind(0, "W3.TEXT.TEXT_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
row.bind(1, "text index " + index);
}
table.append(row);
row.bind(0, "W3.BLOB.BLOB_" + i);
if (index % rIndex == 0) {
row.bind(1, null);
} else {
// row.bind(1, ("blob index " + index).getBytes());
row.bind(1, "text index " + index);
}
table.append(row);
}
rs = conn.insert(table);
t = (System.currentTimeMillis() - t);
System.out.println("insert database realtime use time:" + t);
rs.close();
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
if ((1000 - t) > 0) {
Thread.sleep(1000 - t);
}
// show(rs);
// find(conn);
}
}
public static void find(IOPConnect conn) throws OPException, SQLException {
// insert database node
OPTable table = conn.createTable(OPConst.TABLE_REALTIME);
// 设置添加的列
table.addColumn("GN");
table.addColumn("ED");
table.addColumn("RT");
table.addColumn("AV");
table.addColumn("DS");
ArrayList<String> gns = new ArrayList<String>();
// 添加行
for (int i = 1; i <= number; i++) {
gns.add("W3.AX.AX_" + i);
gns.add("W3.DX.DX_" + i);
gns.add("W3.I2.I2_" + i);
gns.add("W3.I4.I4_" + i);
gns.add("W3.R8.R8_" + i);
gns.add("W3.LONG.LONG_" + i);
gns.add("W3.TEXT.TEXT_" + i);
gns.add("W3.BLOB.BLOB_" + i);
}
long t = System.currentTimeMillis();
OPResultSet rs = conn.find(table, gns.toArray(new String[gns.size()]));
System.out.println("find database node use time:" + (System.currentTimeMillis() - t));
show(rs);
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
rs.close();
}
}该示例中实现了添加节点、添加点、写入实时数据等功能，写其它表信息类似这种操作方式，添加写空值的函数。
4.2.2 更新数据 update
详细代码示例
package com.magus.jdbc;
import java.sql.SQLException;
import java.util.Date;
import com.magus.OPException;
import com.magus.opio.dto.OPConst;
import com.magus.opio.dto.OPRow;
import com.magus.opio.dto.OPTable;
import com.magus.opio.dto.OPValue;
import com.magus.opio.net.IOPConnect;
import com.magus.opio.net.OPConnect;
public class ExampleUpdate extends ExampleBase {
public static void main(String[] args) throws Exception {
IOPConnect conn = new OPConnect(ip, port, 180, user, password);
Date time = conn.getServerTime();
System.out.println("database now time:" + sdf.format(time));
// insert database node
updateNode(conn);
OPTable table = conn.createTable(OPConst.TABLE_POINT);
// 设置添加的列
table.addColumn("GN", OPValue.TYPE_STRING);
table.addColumn("IV", OPValue.TYPE_INT32);
table.addColumn("ED", OPValue.TYPE_STRING);
OPRow row = null;
// 添加行
for (int i = 1; i <= number; i++) {
row = table.NewRow();
row.bind(0, "W3.AX.AX_" + i);
row.bind(1, 0, OPValue.TYPE_INT32);
row.bind(2, "this is ax point " + i + Math.random());
table.append(row);
row.bind(0, "W3.DX.DX_" + i);
row.bind(1, 1, OPValue.TYPE_INT32);
row.bind(2, "this is dx point " + i + Math.random());
table.append(row);
row.bind(0, "W3.I2.I2_" + i);
row.bind(1, 2, OPValue.TYPE_INT32);
row.bind(2, "this is i2 point " + i + Math.random());
table.append(row);
row.bind(0, "W3.I4.I4_" + i);
row.bind(1, 3, OPValue.TYPE_INT32);
row.bind(2, "this is i4 point " + i + Math.random());
table.append(row);
row.bind(0, "W3.R8.R8_" + i);
row.bind(1, 4, OPValue.TYPE_INT32);
row.bind(2, "this is r8 point " + i + Math.random());
table.append(row);
row.bind(0, "W3.LONG.LONG_" + i);
row.bind(1, 5, OPValue.TYPE_INT32);
row.bind(2, "this is long point " + i + Math.random());
table.append(row);
row.bind(0, "W3.TEXT.TEXT_" + i);
row.bind(1, 6, OPValue.TYPE_INT32);
row.bind(2, "this is text point " + i + Math.random());
table.append(row);
row.bind(0, "W3.BLOB.BLOB_" + i);
row.bind(1, 7, OPValue.TYPE_INT32);
row.bind(2, "this is blob point " + i + Math.random());
table.append(row);
}
long t = System.currentTimeMillis();
OPResultSet rs = conn.update(table);
System.out.println("update database point use time:" + (System.currentTimeMillis() - t));
show(rs);
rs.close();
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
conn.close();
}
public static void updateNode(IOPConnect conn) throws OPException, SQLException {
OPTable table = conn.createTable(OPConst.TABLE_NODE);
// 设置添加的列
table.addColumn("GN", OPValue.TYPE_STRING);
table.addColumn("ED", OPValue.TYPE_STRING);
OPRow row = table.NewRow();
row.bind(0, "W3.AX");
row.bind(1, "AX NODE update");
table.append(row);
row.bind(0, "W3.DX");
row.bind(1, "DX NODE update");
table.append(row);
row.bind(0, "W3.I2");
row.bind(1, "I2 NODE update");
table.append(row);
row.bind(0, "W3.I4");
row.bind(1, "I4 NODE update");
table.append(row);
row.bind(0, "W3.R8");
row.bind(1, "R8 NODE update");
table.append(row);
row.bind(0, "W3.LONG");
row.bind(1, "LONG NODE update ");
table.append(row);
row.bind(0, "W3.TEXT");
row.bind(1, "TEXT NODE update");
table.append(row);
row.bind(0, "W3.BLOB");
row.bind(1, "BLOB NODE update");
table.append(row);
long t = System.currentTimeMillis();
OPResultSet rs = conn.update(table);
show(rs);
rs.close();
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
System.out.println("insert database node user time:" + (System.currentTimeMillis() - t));
}
}该示例将上面添加的节点和测点的基本信息修改一部分。
4.2.3 执行查询 find
详细代码示例
package com.magus.jdbc;
import java.util.ArrayList;
import java.util.Date;
import com.magus.opio.dto.OPConst;
import com.magus.opio.dto.OPTable;
import com.magus.opio.net.IOPConnect;
import com.magus.opio.net.OPConnect;
public class ExampleFind extends ExampleBase {
public static void main(String[] args) throws Exception {
IOPConnect conn = new OPConnect(ip, port, 180, user, password);
Date time = conn.getServerTime();
System.out.println("database now time:" + sdf.format(time));
// insert database node
OPTable table = conn.createTable(OPConst.TABLE_POINT);
// 设置添加的列
table.addColumn("GN");
table.addColumn("ED");
table.addColumn("RT");
ArrayList<String> gns = new ArrayList<String>();
// 添加行
for (int i = 1; i <= number; i++) {
gns.add("W3.AX.AX_" + i);
gns.add("W3.DX.DX_" + i);
gns.add("W3.I2.I2_" + i);
gns.add("W3.I4.I4_" + i);
gns.add("W3.R8.R8_" + i);
gns.add("W3.LONG.LONG_" + i);
gns.add("W3.TEXT.TEXT_" + i);
gns.add("W3.BLOB.BLOB_" + i);
}
long t = System.currentTimeMillis();
OPResultSet rs = conn.find(table, gns.toArray(new String[gns.size()]));
// show(rs);
rs.close();
table.destroy();//OPTable 使用完 必须调用destro方法释放本地内存，否则会内存泄漏
System.out.println("find database node use time:" + (System.currentTimeMillis() - t));
conn.close();
}
}该示例将上述添加和更新的点数据查询出来
4.2.4 删除数据 remove
详细代码示例
package com.magus.jdbc;
import java.util.ArrayList;
import java.util.Date;
import com.magus.opio.dto.OPConst;
import com.magus.opio.net.IOPConnect;
import com.magus.opio.net.OPConnect;
public class ExampleRemove extends ExampleBase {
public static void main(String[] args) throws Exception {
IOPConnect conn = new OPConnect(ip, port, 180, user, password);
Date time = conn.getServerTime();
System.out.println("database now time:" + sdf.format(time));
ArrayList<String> gns = new ArrayList<String>();
// 添加行
for (int i = 1; i <= number; i++) {
gns.add("W3.AX.AX_" + i);
gns.add("W3.DX.DX_" + i);
gns.add("W3.I2.I2_" + i);
gns.add("W3.I4.I4_" + i);
gns.add("W3.R8.R8_" + i);
gns.add("W3.LONG.LONG_" + i);
gns.add("W3.TEXT.TEXT_" + i);
gns.add("W3.BLOB.BLOB_" + i);
}
long t = System.currentTimeMillis();
OPResultSet rs = conn.remove(OPConst.TABLE_POINT, gns.toArray(new String[gns.size()]));
System.out.println("delete database point use time:" + (System.currentTimeMillis() - t));
show(rs);
rs.close();
gns = new ArrayList<String>();
gns.add("W3.AX");
gns.add("W3.DX");
gns.add("W3.I2");
gns.add("W3.I4");
gns.add("W3.R8");
gns.add("W3.LONG");
gns.add("W3.TEXT");
gns.add("W3.BLOB");
t = System.currentTimeMillis();
rs = conn.remove(OPConst.TABLE_NODE, gns.toArray(new String[gns.size()]));
System.out.println("delete database node use time:" + (System.currentTimeMillis() - t));
show(rs);
rs.close();
conn.close();
}
}这个示例是将添加的测点和节点删除
4.2.5 执行SQL execSQL
详细代码示例
package com.magus.jdbc;
import java.util.Date;
import com.magus.opio.net.IOPConnect;
import com.magus.opio.net.OPConnect;
public class ExampleSQL extends ExampleBase {
public static void main(String[] args) throws Exception {
IOPConnect conn = new OPConnect(ip, port, 180, user, password);
Date time = conn.getServerTime();
System.out.println("database now time:" + sdf.format(time));
String sql = "select ID,Gn,ED,RT,EU from Point where GN like 'W3.%' and RT =5";
long t = System.currentTimeMillis();
OPResultSet rs = conn.execSQL(sql);
show(rs);
rs.close();
System.out.println("sql database use time:" + (System.currentTimeMillis() - t));
conn.close();
}
}这个是使用sql的方式执行数据操作，具体SQL示例可以参考其他文档
4.2.6 订阅实时
详细代码示例
package com.magus.subscribe;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import com.magus.jdbc.net.OPSubscribe;
import com.magus.jdbc.net.SubscribeResultSet;
public class RealtimeSubscribe implements SubscribeResultSet {
public static String className = "com.magus.jdbc.Driver";
public static String url = "jdbc:openplant://192.168.2.241:8400/RTDB";
public static String user = "sis";
public static String password = "openplant";
Map<Integer, String> values = new HashMap<Integer, String>();
static final double SKEWING = 0.0005;
static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
public static void main(String[] args) throws ClassNotFoundException, SQLException {
OPSubscribe subscribe = null;
Class.forName(className);
Connection conn = DriverManager.getConnection(url, user, password);
if (conn.getAutoCommit()) {
conn.setAutoCommit(false);
}
try {
ArrayList<Integer> ids = new ArrayList<Integer>();
// for (int i = 0; i < 10; i++) {
ids.add(1025);
ids.add(1027);
// }
// ArrayList<Integer> ids = new ArrayList<Integer>();
// for (int i = 0; i < 10; i++) {
// ids.add(8574868);
// }
subscribe = new OPSubscribe(conn, "Realtime", ids, new RealtimeSubscribe());
conn.close();
// 一分钟后 添加订阅 1028,1029
Thread.sleep(1000 * 24 * 60);
ids.clear();
ids.add(1028);
ids.add(1029);
subscribe.subscription(ids);
// 一分钟后取消订阅 1028,1029
Thread.sleep(1000 * 24 * 60);
ids.clear();
ids.add(1028);
ids.add(1029);
subscribe.unsubscribe(ids);
Thread.sleep(3600 * 1000 * 24);
subscribe.close();
} catch (Exception e) {
e.printStackTrace();
conn.rollback();
}
conn.close();
System.exit(0);
}
public void onResponse(ResultSet result) throws SQLException {
// ResultSetMetaData rsmd = resultSet.getMetaData();
int i = 0;
while (result.next()) {
i++;
int ID = result.getInt(1);
String GN = result.getString(2);
double TM = result.getDouble(3);
String DS = result.getString(4);
String AV = result.getString(5);
// if (values.containsKey(ID)) {
// System.out.println("before key:" + ID + "\t" + values.get(ID));
// values.put(ID, "GN:" + GN + "\tTM:" + TM + "\tDS:" + DS + "\tAV:"
// + AV);
// System.out.println("after key:" + ID + "\t" + values.get(ID));
// } else {
// values.put(ID, "GN:" + GN + "\tTM:" + TM + "\tDS:" + DS + "\tAV:"
// + AV);
System.out.println("ID:" + ID + "\tGN:" + GN + "\tTM:" + sdf.format(TM * 1000) + "\t" + (long) (TM * 1000) + "\tDS:" + DS + "\tAV:" + AV);
// }
}
// System.out.println("current number length:" + i + "\tcurrent time:" +
// System.currentTimeMillis());
}
}4.2.7 订阅报警
详细代码示例
package com.magus.subscribe;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import com.magus.jdbc.net.OPSubscribe;
import com.magus.jdbc.net.SubscribeResultSet;
import com.magus.opio.dto.OPValue;
public class AlarmSubscribe implements SubscribeResultSet {
public static String className = "com.magus.jdbc.Driver";
// jdbc:产品系列://IP:端口/服务
// jdbc:产品系列://IP:端口/
public static String url = "jdbc:openplant://192.168.2.65:8300/RTDB";
public static String user = "sis";
public static String password = "openplant";
static final double SKEWING = 0.0005;
static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName(className);
Connection conn = DriverManager.getConnection(url, user, password);
if (conn.getAutoCommit()) {
conn.setAutoCommit(false);
}
try {
ArrayList<Integer> ids = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
ids.add(1024 + i);
}
OPSubscribe subscribe = new OPSubscribe(conn, "Alarm", ids, new AlarmSubscribe());
Thread.sleep(1000 * 3600);
subscribe.close();
} catch (Exception e) {
e.printStackTrace();
conn.rollback();
}
conn.close();
System.exit(0);
}
@Override
public void onResponse(ResultSet resultSet) throws SQLException {
System.out.println("onResponse");
ResultSetMetaData rsmd = resultSet.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println(" Column Index " + i);
System.out.println("getColumnLabel \t" + rsmd.getColumnLabel(i));
System.out.println("getColumnType \t" + rsmd.getColumnType(i));
System.out.println("getColumnTypeName \t" + rsmd.getColumnTypeName(i));
System.out.println("getColumnClassName \t" + rsmd.getColumnClassName(i));
System.out.println("++++++++++=====++++++++++++++++++");
}
System.out.print("\n");
while (resultSet.next()) {
StringBuffer sb = new StringBuffer();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
if (rsmd.getColumnType(i) == OPValue.TYPE_DATETIME) {
sb.append(sdf.format(resultSet.getDate(i)) + "\t");
} else if (rsmd.getColumnType(i) == OPValue.TYPE_BOOL) {
sb.append(resultSet.getBoolean(i) + "\t");
} else {
sb.append(resultSet.getString(i) + "\t");
}
}
System.out.println(sb.toString());
}
}
}4.2.8 订阅静态信息
详细代码示例
package com.magus.subscribe;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import com.magus.jdbc.net.OPSubscribe;
import com.magus.jdbc.net.SubscribeResultSet;
import com.magus.opio.dto.OPValue;
public class PointSubscribe implements SubscribeResultSet {
public static String className = "com.magus.jdbc.Driver";
// jdbc:浜у搧绯诲垪://IP:绔彛/鏈嶅姟
// jdbc:浜у搧绯诲垪://IP:绔彛/
public static String url = "jdbc:openplant://192.168.2.65:8300/RTDB";
public static String user = "sis";
public static String password = "openplant";
static final double SKEWING = 0.0005;
static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName(className);
Connection conn = DriverManager.getConnection(url, user, password);
if (conn.getAutoCommit()) {
conn.setAutoCommit(false);
}
try {
ArrayList<Integer> ids = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
ids.add(1024 + i);
}
OPSubscribe subscribe = new OPSubscribe(conn, "Point", ids, new PointSubscribe());
Thread.sleep(1000 * 600);
subscribe.close();
} catch (Exception e) {
e.printStackTrace();
conn.rollback();
}
conn.close();
System.exit(0);
}
@Override
public void onResponse(ResultSet resultSet) throws SQLException {
System.out.println("onResponse");
ResultSetMetaData rsmd = resultSet.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println(" Column Index " + i);
System.out.println("getColumnLabel \t" + rsmd.getColumnLabel(i));
System.out.println("getColumnType \t" + rsmd.getColumnType(i));
System.out.println("getColumnTypeName \t" + rsmd.getColumnTypeName(i));
System.out.println("getColumnClassName \t" + rsmd.getColumnClassName(i));
System.out.println("++++++++++=====++++++++++++++++++");
}
System.out.print("\n");
while (resultSet.next()) {
StringBuffer sb = new StringBuffer();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
if (rsmd.getColumnType(i) == OPValue.TYPE_DATETIME) {
sb.append(sdf.format(resultSet.getDate(i)) + "\t");
} else if (rsmd.getColumnType(i) == OPValue.TYPE_BOOL) {
sb.append(resultSet.getBoolean(i) + "\t");
} else {
sb.append(resultSet.getString(i) + "\t");
}
}
System.out.println(sb.toString());
}
}
}5、老协议接口说明（适配openPlantV3.0/V4.0）
老协议接口
1．建立连接new OPConnect(String ip,int port, int timeout, String user,String pwd)
全类名：com.magus.net.OPConnect
函数示例：new OPConnect(String ip,int port, int timeout, String user,String pwd)
ip ：数据库服务器的ip
port：数据库服务的端口
timeout：请求超时时间，单位：毫秒
user和pwd分别：数据库用户名和密码
2．获取服务系统时间戳OPConnect.getServerTime()
函数示例：OPConnect.getServerTime()
返回值：long类型
3．获取数据库metadata,OPConnect. getDataBaseMetaData()
函数示例：OPConnect. getDataBaseMetaData()
返回值类型：com.magus.net.scheme.OPDataBaseMetaData
4．批量获取测点静态信息OPConnect.getPointStaticInfos()
函数示例1：OPConnect.getPointStaticInfos(String[] names)
函数示例2：OPConnect.getPointStaticInfos(int[] ids)
返回值类型：OPStaticInfo[]
names ：需要查询的测点名的数组
ids：需要查询的测点ID的数组
获取单个测点静态信息OPConnect.getPointStaticInfo()
函数示例1：OPConnect.getPointStaticInfo(String name)
函数示例2：OPConnect.getPointStaticInfo(int id)
返回值类型：com.magus.net.OPStaticInfo
name：需要查询的测点名
id：需要查询的测点的ID
5．批量更新测点静态信息OPConnect.updatePointStaticInfos()
函数示例：OPConnect.updatePointStaticInfos(OPStaticInfo[] infos)
返回值类型：OPStaticInfo[]
infos ：需要更新的静态信息数组
6．更新单个测点静态信息OPConnect.updatePointStaticInfo()
函数示例：OPConnect.updatePointStaticInfo(OPStaticInfo info)
返回值类型：com.magus.net.OPStaticInfo
Info：需要更新的静态记录
7．批量写实时OPConnect.insertPointDynamicData()
函数示例1：OPConnect.insertPointDynamicData(String[] globalNames, OPDynamicData[] data)
函数示例2：OPConnect.insertPointDynamicData(int[] ids, OPDynamicData[] data)
返回值类型：int型，是错误码，0表示成功，具体详见数据库api错误码解析
globalNames：测点名的数组
data：实时数据的数组
ids：测点ID的数组
PS.两个参数是按照数组序号一一对应的
8．单个点写实时OPConnect.insertPointDynamicData()
函数示例：OPConnect.insertPointDynamicData(int id, OPDynamicData data)
返回值类型：int类型，是错误码
id ：测点的ID
data：需要写入的实时数据
9．更新单个点实时OPConnect.updatePointDynamicData ()
函数示例：OPConnect.updatePointDynamicData (int id, OPDynamicData data)
返回值类型：int类型，是错误码
id ：测点的ID
data：需要写入的实时数据
10．批量插入节点OPConnect.insertNodes()
函数示例：OPConnect.insertNodes(OPNode[] nodes)
返回值：OPNode[]
nodes：需要插入的节点的信息的数组
11．插入单个节点OPConnect.insertNode(OPNode node)
函数示例：OPConnect.insertNode(OPNode node)
返回值：com.magus.net.OPNode
node ：需要插入的节点的信息
12．批量插入测点OPConnect.insertPointStaticInfos()
函数示例：OPConnect.insertPointStaticInfos(OPStaticInfo[] infos)
返回值类型：OPStaticInfo[]
infos ：需要插入的测点的静态信息的数组
13．插入单个测点OPConnect.insertPointStaticInfo()
函数示例：OPConnect.insertPointStaticInfo(OPStaticInfo info)
返回值类型：com.magus.net.OPStaticInfo
info ：需要插入的测点的信息
14．创建一个测点对象OPConnect.createStaticInfo()
函数示例：OPConnect.createStaticInfo(int parentID, String name, String type)
返回值类型：com.magus.net.OPStaticInfo
parentID：该测点需要添加到的节点的ID
name ：这个测点的点名PN
type是这个静态信息的类型，可填参数：
“AX”：表示是一个模拟量
“DX”：表示是一个开关量
“I2”：表示是一个短整型
“I4”：表示是一个长整型
“R8”：表示是一个浮点数
15．创建节点对象OPConnect.createNode()
函数示例：OPConnect.createNode(int parentID, String name)
返回值类型：com.magus.net.OPNode
parentID：数据库的ID
name ：节点名PN
16．创建实时数据对象OPConnect.createDynamicData()
函数示例：OPConnect.createDynamicData(String type)
返回值类型：com.magus.net.OPDynamicData
type：测点的类型，可选参数：
“AX”：表示是一个模拟量
“DX”：表示是一个开关量
“I2”：表示是一个短整型
“I4”：表示是一个长整型
“R8”：表示是一个浮点数
17．创建历史数据对象OPConnect.createHisData()
函数示例：OPConnect.createHisData(String type)
返回值类型：com.magus.net.OPHisData
type：测点的类型，可选参数：
“AX”：表示是一个模拟量
“DX”：表示是一个开关量
“I2”：表示是一个短整型
“I4”：表示是一个长整型
“R8”：表示是一个浮点数
18．删除测点OPConnect.deletePointStaticInfos()
函数示例：OPConnect.deletePointStaticInfos(String[] pointNames)
返回值类型：int[]，是数据库错误码，0表示成功
pointNames ：测点点名的数组
19．删除单个测点OPConnect.deletePointStaticInfo()
函数示例：OPConnect.deletePointStaticInfo(String pointName)
返回值类型：int，是数据库错误码，0表示成功
pointName：测点点名
20．获取单个测点实时数据OPConnect.getPointDynamicData()
函数示例：OPConnect.getPointDynamicData(String pointName)
返回值类型：com.magus.net.OPDynamicData
pointName：测点名
21．批量获取测点实时数据OPConnect.getPointDynamicDatas()
函数示例：OPConnect.getPointDynamicDatas(String[] pointNames)
返回值类型：Map<String, OPDynamicData>
pointNames ：测点名的数组
22．批量获取测点实时数据OPConnect.getPointDynamicDatas2()
函数示例：OPConnect.getPointDynamicDatas2(String[] pointNames)
返回值类型：OPDynamicData[]
pointNames：测点名的数组
23．批量获取测点实时数据OPConnect.getPointDynamicDatasByIds()
函数示例：OPConnect.getPointDynamicDatasByIds(int[] pointIDs)
返回值类型：OPDynamicData[]
pointIds：测点ID的数组
24．查询历史数据按时间范围OPConnect.getPointHistorys()
函数示例1：OPConnect.getPointHistorys(String[] pointNames, Date from, Date to, int hisTypes, int interval)
函数示例2：OPConnect.getPointHistorys(int[] ids, Date from, Date to, int hisTypes, int interval)
返回值类型：Map<String, OPHisData[]>
Ids：测点id的数组
pointNames：点名的数组
from：开始时间
to：结束时间
hisTypes：读取历史的模式，可选参数：
OPNetConst.HISTORY_DATA_SAMPLE：历史原始值，interval需要设置：1
OPNetConst.HISTORY_DATA_SPAN：等间距取历史，时间间隔interval控制
OPNetConst.HISTORY_DATA_PLOT：绘图值取历史，会保留整体趋势及峰谷
OPNetConst.STAT_DATA_FLOW：流量统计值
OPNetConst.STAT_DATA_MAX：最大值
OPNetConst.STAT_DATA_MIN：最小值
OPNetConst.STAT_DATA_AVG：面积平均值
OPNetConst.STAT_DATA_CAVG：算数平均值
interval：取值时间点间隔，单位是秒
25．查询历史数据按时间范围OPConnect.getPointHistorys()
函数示例1：OPConnect.getPointHistorys(String[] pointNames, Date[] from, Date[] to, int hisTypes, int interval)
函数示例2：OPConnect.getPointHistorys(int[] ids, Date[] from, Date[] to, int hisTypes, int interval)
返回值类型：Map<String, OPHisData[]>
ids ：测点ID的数组
pointNames：点名的数组
from：开始时间的数组，按照下标对应ids或者pointNames数组里的点名
to：结束时间的数组，按照下标对应ids或者pointNmaes数组里面的点名
hisTypes：读取历史的模式，可选参数同2.25：
interval：取值时间点间隔，单位是秒
26．查询某个时间点历史数据OPConnect.getPointHistorys()
函数示例1：OPConnect.getPointHistorys(String[] pointNames, Date time)
函数示例2：OPConnect.getPointHistorys(int[] ids, Date time)
返回值类型：Map<String, OPHisData>
pointNames：点名的数组
ids：测点ID的数组
time：需要查询的时间点
27．查询单个测点历史数据按时间范围OPConnect.getPointHistory()
函数示例1：OPConnect.getPointHistory(String pointName, Date from, Date to, int hisType, int interval)
函数示例2：OPConnect.getPointHistory(int id, Date from, Date to, int hisType, int interval)
返回值类型：OPHisData[]
pointName：测点名
id：测点ID
from：开始时间
to：结束时间
hisType：读取历史的模式，可选参数同2.25
interval：趋势的时间间隔
28．查询单个测点某个时刻的历史值OPConnect.getPointHistoryValue()
函数示例1：OPConnect.getPointHistoryValue(String pointName, Date time)
函数示例2：OPConnect.getPointHistoryValue(int id, Date time)
返回值类型：OPHisData
id：测点ID
pointName：测点名
time：查询的时刻
29．查询测点某个时间范围内统计数据OPConnect.getPointStats()
函数示例1：OPConnect.getPointStats(String[] pointNames, Date from, Date to, int hisTypes, int interval)
函数示例2：OPConnect.getPointStats(int[] ids, Date from, Date to, int hisTypes, int interval)
返回值类型：Map<String, OPStatData[]>
pointNames：点名的数组
ids：测点ID的数组
from：开始时间
to：结束时间
hisTypes：统计的方式，可选参数：：
OPNetConst.STAT_DATA_FLOW：流量统计值
OPNetConst.STAT_DATA_MAX：最大值
OPNetConst.STAT_DATA_MIN：最小值
OPNetConst.STAT_DATA_AVG：面积平均值
OPNetConst.STAT_DATA_CAVG：算数平均值
interval：分段统计的事件间隔
30．查询单个测点某个时间范围内统计数据OPConnect.getPointStat()
函数示例1：OPConnect.getPointStat(String pointName, Date from, Date to, int hisTypes, int interval)
函数示例2：OPConnect.getPointStats(int id, Date from, Date to, int hisTypes, int interval)
pointNams：点名
id：测点ID
from：开始时间
to：结束时间
hisTypes：统计的方式，可选参数同2.30
interval：分段统计的事件间隔
31．查询测点某个时间范围内统计数据OPConnect.getPointStats()
函数示例1：OPConnect.getPointStats(String[] pointNames, Date from, Date to, int hisTypes)
函数示例2：OPConnect.getPointStats(int[] ids, Date from, Date to, int hisTypes)
返回值类型：Map<String, OPStatData[]>
ids：测点ID的数组
pointNames：点名的数组
from：开始时间
to：结束时间
hisTypes同2.30
32．查询单个测点某个时间范围内统计数据OPConnect.getPointStat()
函数示例1：OPConnect.getPointStat(String pointName, Date from, Date to, int hisTypes)
函数示例2：OPConnect.getPointStat(int id, Date from, Date to, int hisTypes)
返回值类型：OPStatData[]
pointName：测点名
id：测点ID
from：开始时间
to：结束时间
hisTypes同2.30
33．插入历史数据OPConnect.insertPointHistorys()
函数示例：OPConnect.insertPointHistorys(Map<String, OPHisData[]> pointHistorys)
返回值类型：int[]，是错误码，：0表示成功，具体查看数据库返回码
pointHistorys：点名和历史数据的键值对
34． 插入历史数据OPConnect.insertPointHistorys()
函数示例：OPConnect.insertPointHistorys(Map<String, OPHisData[]> pointHistorys, boolean cache)
返回值类型：int[]，是错误码，0表示成功
pointHistorys：点名和历史数据的键值对
cache表示是否缓存
35．通过ID插入历史数据OPConnect.insertPointHistorysByID()
函数示例：OPConnect.insertPointHistorysByID(Map<Integer, OPHisData[]> pointHistorys)
返回值类型：int[]，是错误码，0表示成功
pointHistorys：测点ID和历史数据的键值对
36．通过ID插入历史数据OPConnect.insertPointHistorysByID()
函数示例：OPConnect.insertPointHistorysByID(Map<Integer, OPHisData[]> pointHistorys, boolean cache)
返回值类型：int[],是错误码，0表示成功
pointHistorys：测点ID和历史数据的键值对
cache表示是否缓存
37．更新历史数据OPConnect.updatePointHistorys()
函数示例：OPConnect.updatePointHistorys(Map<String, OPHisData[]> map)
返回值类型：int[],是错误码，0表示成功
pointHistorys：测点名和历史数据的键值对
38．更新单个测点历史数据OPConnect.updatePointHistory()
函数示例：OPConnect.updatePointHistory(String name, OPHisData[] datas)
返回值类型：int,是错误码，0表示成功
name：测点点名
datas：历史数据
39．删除历史数据OPConnect.deletePointHistorys()
函数示例：OPConnect.deletePointHistorys(OPHisDeleteDelegate[] hiss)
返回值类型：int[],是错误码，0表示成功
hiss表示需要删除的历史数据的数组
40．删除历史的单次历史数据OPConnect.deletePointHistorys()
函数示例：OPConnect.deletePointHistorys(OPHisDeleteDelegate his)
返回值类型：int，是错误码，0表示成功
his：需要删除的历史数据
41．获取数据库对象OPConnect.getDBs()
函数示例：OPConnect.getDBs()
返回值类型：OPDB[]
42．获取数据库节点OPConnect.getAllNodesByDBName()
函数示例：OPConnect.getAllNodesByDBName(String dbName)
返回值：OPNode[]
dbName：数据库的库名
43．获取数据库节点OPConnect.getNodeByNodeName()
函数示例：OPConnect.getNodeByNodeName(String nodeName)
返回值类型：OPNode
nodeName：节点名
44．获取某个节点所有测点静态信息OPConnect.getAllPointStaticInfosByNodeName()
函数示例：OPConnect.getAllPointStaticInfosByNodeName(String nodeName)
返回值类型：OPStaticInfo[]
nodeName：节点名
45．获取某个节点下测点的ID和点名的MAP，OPConnect.getPointNamesMap()
函数示例：OPConnect.getPointNamesMap(String nodeName)
返回值类型：Map<Integer, String>
nodeName：节点的名字
46．获取某个节点下测点的点名和ID的MAP ，OPConnect.getPointIdsMap()
函数示例：OPConnect.getPointIdsMap(String nodeName)
返回值类型：Map<String, Integer>
nodeName：节点的名字
47．查询数据库报警信息OPConnect. requestAlrmRecord()
函数示例：OPConnect. requestAlrmRecord(Date beginTime, Date endTime, boolean real)
返回值类型：List<AlarmData>
beginTime：开始时间
endTime：结束时间
real表示是否是实时，当real是true的时候，开始时间和结束时间传null
48．查询某个节点下的报警信息OPConnect.requestAlrmRecord()
函数示例：OPConnect.requestAlrmRecord(int nodeID, Date beginTime, Date endTime, boolean real)
返回值类型：List<AlarmData>
nodeID：节点的ID
beginTime：开始时间
endTime：结束时间
real：是否是实时，当real是true的时候，开始时间和结束时间传null
49．查询某个节点下的报警信息OPConnect.requestAlrmRecord()
函数示例：OPConnect.requestAlrmRecord(String nodeName, Date beginTime, Date endTime, boolean real)
返回值类型：List<AlarmData>
nodeName：节点的名字
beginTime：开始时间
endTime：结束时间
real：是否是实时，当real是true的时候，开始时间和结束时间传null
50．更新测点的报警信息OPConnect.updatePointAlarm()
函数示例：OPConnect.updatePointAlarm(String[] globalNames, OPDynamicData[] data)
返回值类型：int[],是错误码，0表示成功
globalNames：测点的全点名的数组
data：需要更新的动态信息的数组，和点名数组按下标一一对应
51．更新测点的报警信息OPConnect.updatePointAlarm()
函数示例：OPConnect.updatePointAlarm(int[] ids, OPDynamicData[] data)
返回值类型：int[]，代表错误码，0表示成功
ids：测点ID的数组
data：需要更新的动态数据的数组，和ID数组按下标一一对应6. 老协议接口代码示例
6.1 基础类
基础类
package com.magus.net.eg;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
/**
* @since 2011-8-23
* @author (liwei.tang@magustek.com) 这些常量供所有示例使用，请根据需要修改连接信息、点名等
*/
public class _Example {
// 示例连接服务器的IP
public static final String IP = "192.168.2.94";
// 示例连接服务器的端口号
public static final int PORT = 8200;
// //示例连接服务器的用户名
public static final String USER_NAME = "sis";
// 示例连接服务器的密码
public static final String PASSWORD = "openplant";
// 示例数据库的ID
public static final int DB_ID = 0;
// 示例连接的数据库名
public static final String DB_NAME = "W3";
// 示例连接的节点ID
public static final int NODE_TEST_ID = 1;
// 示例连接的节点名
public static final String NODE_TEST_NAME = "TEST";
// 示例使用的AX测点名
public static final String POINT_AX_NAME = "AX";
// 示例使用的DX测点名
public static final String POINT_DX_NAME = "DX";
// 示例使用的I2测点名
public static final String POINT_I2_NAME = "I2";
// 示例使用的I4测点名
public static final String POINT_I4_NAME = "I4";
// 示例使用的R8测点名
public static final String POINT_R8_NAME = "R8";
// 示例使用的计算点测点名
public static final String POINT_CALC_NAME = "CALC";
// 节点全局名
public static final String NODE_GLOBAL_NAME = DB_NAME + "." + NODE_TEST_NAME;
// AX测点全局名
public static final String POINT_AX_GLOBAL_NAME = NODE_GLOBAL_NAME + "." + POINT_AX_NAME;
// DX测点全局名
public static final String POINT_DX_GLOBAL_NAME = NODE_GLOBAL_NAME + "." + POINT_DX_NAME;
// 示例使用的AX测点ID
public static final int POINT_AX_ID = 1025;
// 示例使用的DX测点ID
public static final int POINT_DX_ID = 1026;
// 示例使用的I2测点ID
public static final int POINT_I2_ID = 1027;
// 示例使用的I4测点ID
public static final int POINT_I4_ID = 1028;
// 示例使用的R8测点ID
public static final int POINT_R8_ID = 1029;
// 示例使用的计算点ID
public static final int POINT_CALC_ID = 1030;
public static Date FROM, TO;
// static {
// try {
// // 历史数据的起始结束时间
// FROM = DateFormat.getDateTimeInstance().parse("2019-10-28 18:00:00");
// TO = DateFormat.getDateTimeInstance().parse("2019-10-28 19:00:00");
// } catch (ParseException e) {
// e.printStackTrace();
// }
// }
}6.2建立连接
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.exception.io.UsersException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 建立数据库连接
* 注意：使用示例请先检查_Example.java中的连接信息，IP、端口、用户名、密码。
*/
public class A01_Connect extends _Example {
public static void main(String[] args) throws IOException, UsersException {
// 建立与openPlant的连接
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
System.out.println("connect success!");
// 关闭连接
conn.close();
}
}6.3获取系统时间
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.util.Date;
import com.magus.net.OPConnect;
import com.magus.net.exception.io.UsersException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 获取服务器时间 注意：其它的示例中为了代码简单易懂，简化了连接的异常处理部分。
* 请确保处理了OPException并且关闭连接的代码应写在final块中。
* 正确写法请参考请参考本示例的try、catch、finally的结构。
* 如果没有在finally块中关闭连接，可能导致由于在catch块中退出而没有关闭连接，导致连接泄露，最终服务端连接用尽的问题。
*/
public class A02_GetServerTime extends _Example {
public static void main(String[] args) {
OPConnect conn = null;
try {
// 建立连接
conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 取数据
long serverTime = conn.getServerTime();
Date ServerDate = new Date(serverTime);
System.out.println(ServerDate);
} catch (UsersException e) {
// 用户异常
e.printStackTrace();
} catch (IOException e) {
// 网络异常
e.printStackTrace();
} finally {
// 重要:在finally块中关闭连接，其它示例是简化的写法，这里是安全的写法。
// 否则连接可能在异常时被泄露最终导致服务端连接用尽。
try {
if (conn != null) {
conn.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}6.4获取scheme
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.common.Version;
import com.magus.net.exception.io.UsersException;
import com.magus.net.scheme.OPDataBaseMetaData;
import com.magus.net.scheme.OPScheme;
import com.magus.net.scheme.OPSchemeField;
import com.magus.net.scheme.OPSchemeNodeTemplate;
/**
* @author liwei.tang@magustek.com
* @since 2015年4月20日 获得元数据
*/
public class A03_GetScheme extends _Example{
public static void main(String[] args) throws UsersException, IOException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
OPDataBaseMetaData metadata=conn.getDataBaseMetaData();
//获得数据库版本
Version version=metadata.getCommProtocolVersion();
System.out.println("Version: "+version);
//获得数据库默认字符编码
String encoding=metadata.getEncoding();
System.out.println("Encoding: "+encoding);
//遍历Scheme
OPScheme scheme=metadata.getDbScheme();
Map<Integer, OPSchemeNodeTemplate> id2SchemeMap=scheme.getStaticFieldTempMap();
for(Map.Entry<Integer, OPSchemeNodeTemplate> entry:id2SchemeMap.entrySet()){
OPSchemeNodeTemplate nodeTempalte=entry.getValue();
//输出静态类型名
System.out.println(nodeTempalte.getName()+"(ID="+nodeTempalte.getId()+")");
for(Map.Entry<String, OPSchemeField> template:nodeTempalte.getFieldMap().entrySet()){
//输出结构
System.out.println("\t"+template.getValue());
}
}
conn.close();
}
}6.5查询节点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPNode;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 根据节点名访问节点
*/
public class B02_NodeByName extends _Example {
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 根据节点全局名获得节点对象
OPNode node = conn.getNodeByNodeName(DB_NAME + "." + NODE_TEST_NAME);
System.out.println("Access node by global name:" + node);
conn.close();
}
}6.6插入节点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPNode;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 插入节点
*/
public class B01_NodeInsert extends _Example {
public static void main(String[] args) throws NetException, IOException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 创建节点
OPNode node = conn.createNode(DB_ID, NODE_TEST_NAME);
// 设定属性
node.putValue("ID", NODE_TEST_ID);
// 执行插入
conn.insertNode(node);
System.out.println("finish...");
conn.close();
}
}6.7更新节点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPNode;
import com.magus.net.OPStaticInfo;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 更新节点
*/
public class B03_NodeUpdate extends _Example {
/**
* @param args
* @throws IOException
* @throws NetException
*/
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 根据节点全局名获得节点对象
OPNode node = conn.getNodeByNodeName(DB_NAME + "." + NODE_TEST_NAME);
// 设定属性
node.putValue("ED", "this is a test node...");
// 更新节点
OPStaticInfo info = OPNode.translate(node);
info = conn.updatePointStaticInfo(info);
System.out.println("Update node:" + info);
conn.close();
}
}6.8删除节点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 删除节点
*/
public class B04_NodeDelete extends _Example {
/**
* @param args
* @throws IOException
* @throws NetException
*/
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
String nodeName = DB_NAME + "." + NODE_TEST_NAME;
int result = conn.deletePointStaticInfo(nodeName);
System.out.println("delete node by name '" + nodeName + "' result: " + result + ".");
conn.close();
}
}6.9获取节点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPNode;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 列举节点
*/
public class B05_NodeList extends _Example {
/**
* @param args
* @throws IOException
* @throws NetException
*/
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 根据数据库全局名查询
OPNode[] nodes = conn.getAllNodesByDBName(DB_NAME);
// 单数据库情况下也可以按如下方式查询默认数据库下的节点
// OPNode[] nodes = conn.getAllNodesByDBName(null);
// 输出查询结果
for (OPNode node : nodes) {
System.out.println(node);
}
conn.close();
}
}6.10添加测点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPStaticInfo;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 插入测点
*/
public class C01_PointInsert extends _Example {
/**
* @param args
* @throws IOException
* @throws NetException
*/
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 创建测点对象
OPStaticInfo ax = conn.createStaticInfo(NODE_TEST_ID, POINT_AX_NAME, "AX");
OPStaticInfo dx = conn.createStaticInfo(NODE_TEST_ID, POINT_DX_NAME, "DX");
// 设定属性
ax.putValue("ID", POINT_AX_ID);
dx.putValue("ID", POINT_DX_ID);
// 构建静态信息数组
OPStaticInfo[] infos = new OPStaticInfo[] { ax, dx };
// 对静态信息数据执行插入
infos = conn.insertPointStaticInfos(infos);
// 输出插入结果
for (OPStaticInfo info : infos) {
if (info != null) {
System.out.println(info);
}
}
conn.close();
}
}6.11更新测点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.OPStaticInfo;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 更新数据
*/
public class C02_PointUpdate extends _Example {
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 构建点名数组
String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME, POINT_DX_GLOBAL_NAME };
// 根据点名查询
Map<String, OPStaticInfo> result = conn.getPointStaticInfos(pointNames);
// 输出更新前的测点静态信息
System.out.println("-------更新前的数据-------");
System.out.println(result.get(POINT_AX_GLOBAL_NAME));
System.out.println(result.get(POINT_DX_GLOBAL_NAME));
// 设定属性
OPStaticInfo ax = result.get(POINT_AX_GLOBAL_NAME);
ax.putValue("ED", "ax point");
OPStaticInfo dx = result.get(POINT_DX_GLOBAL_NAME);
dx.putValue("ED", "dx point");
// 更新测点
OPStaticInfo[] infos = new OPStaticInfo[] { ax, dx };
infos = conn.updatePointStaticInfos(infos);
// 输出更新后的测点静态信息
System.out.println("-------更新后的数据-------");
for (OPStaticInfo info : infos) {
System.out.println(info);
}
conn.close();
}
}6.12删除测点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 删除测点
*/
public class C03_PointDelete extends _Example {
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 构建点名数组
String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME, POINT_DX_GLOBAL_NAME };
// 执行静态信息删除
int[] results = conn.deletePointStaticInfos(pointNames);
// 输出删除结果
for (int i = 0; i < pointNames.length; i++) {
String pointName = pointNames[i];
int result = results[i];
System.out.println("delete '" + pointName + "' result:" + result);
}
conn.close();
}
}6.13通过节点获取测点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPStaticInfo;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author liwei.tang@magustek.com 列举节点下的测点
*/
public class C04_PointListByNode extends _Example {
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 根据节点全局名获得测点
OPStaticInfo[] infos = conn.getAllPointStaticInfosByNodeName(DB_NAME + "." + NODE_TEST_NAME);
// 输出测点信息
if (infos != null && infos.length != 0) {
for (OPStaticInfo info : infos) {
System.out.println(info);
}
} else {
System.out.println("该节点下无测点信息!");
}
conn.close();
}
}6.14通过点名或ID获取测点
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.OPStaticInfo;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 根据ID或者全局名访问测点
*/
public class C05_PointByNameOrID extends _Example {
public static void main(String[] args) throws IOException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 根据ID获得测点静态信息
System.out.println("--------By ID----------");
// 构建参数
int[] pointIDs = new int[] { POINT_AX_ID, POINT_DX_ID };
// 取数据
Map<Integer, OPStaticInfo> resultByID = conn.getPointStaticInfos(pointIDs);
// 输出获得的测点静态信息
for (Integer id : resultByID.keySet()) {
OPStaticInfo info = resultByID.get(id);
System.out.println(info);
}
// 根据点名获得测点静态信息
System.out.println("--------By NAME----------");
// 构建参数
String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME, POINT_DX_GLOBAL_NAME };
// 取数据
Map<String, OPStaticInfo> resultByName = conn.getPointStaticInfos(pointNames);
// 输出获得的测点静态信息
for (String globalName : resultByName.keySet()) {
OPStaticInfo info = resultByName.get(globalName);
System.out.println(info);
}
System.out.println("finish...!");
conn.close();
}
}6.15读实时
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.text.DateFormat;
import java.util.Date;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.OPDynamicData;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 读取实时数据
*/
public class D01_DynamicRead extends _Example {
public static void main(String[] args) throws IOException, NetException, InterruptedException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME, POINT_DX_GLOBAL_NAME };
// 循环10次，每秒一次获取实时数据
for (int i = 0; i < 10; i++) {
// 取实时
Map<String, OPDynamicData> result = conn.getPointDynamicDatas(pointNames);
// 输出获取到的数据
DateFormat df = DateFormat.getDateTimeInstance();
String time = df.format(new Date());
System.out.println("--------" + time + "--------");
for (String globalName : result.keySet()) {
OPDynamicData dynData = result.get(globalName);
System.out.println(globalName + "\t" + dynData);
}
Thread.sleep(1000);
}
System.out.println("operate success!");
conn.close();
}
}6.16写实时
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import com.magus.net.OPConnect;
import com.magus.net.OPDynamicData;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 写实时数据 注意：返回0表示写入成功，返回1可能是写入的实时数据比现有最新实时数据要旧
*/
public class D02_DynamicWrite extends _Example {
public static void main(String[] args) throws IOException, NetException {
final OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 构建AX测点的实时数据对象
OPDynamicData dyn = conn.createDynamicData("AX");
double a = 100;
double b = 0;
// 循环模拟数据
while (true) {
// 获取实时数据库时间
long serverTime = conn.getServerTime();
// 产生类似正弦曲线的数据
try {
if (b > 180) {
b = 0;
}
String v = String.valueOf(a * Math.sin(b / 180 * Math.PI));
// 设定值和时间的属性
dyn.putValue("AV", v);
dyn.putValue("TM", serverTime - 10 * 60 * 1000);
// 输出要写入的实时数据
System.out.println("Write: " + dyn + "\t" + serverTime);
// 执行写入
// int result =
// conn.insertPointDynamicData(POINT_AX_GLOBAL_NAME, dyn);
String[] pointNames = new String[] { "W3.T.XXX" };
OPDynamicData[] datas = new OPDynamicData[] { dyn };
int[] result = conn.insertPointDynamicData(pointNames, datas);
// 输出执行返回码
System.out.println("Write real time data return " + result[0] + ".");
b++;
// 等待一秒
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}6.17写历史
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.OPHisData;
import com.magus.net.OPNetConst;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-24
* @author (liwei.tang@magustek.com) 写历史
*/
public class E01_HistoryWrite extends _Example {
public static void main(String[] args) throws IOException, ParseException, NetException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 间隔时间，单位（毫秒）
long step = 1000;
OPHisData[] hiss = new OPHisData[(int) ((TO.getTime() - FROM.getTime()) / step)];
// 构建历史数据
int idx = 0;
for (long i = FROM.getTime(); i < TO.getTime(); i += step) {
OPHisData hisData = conn.createHisData("AX");
hisData.putValue("TM", i);
hisData.putValue("AV", (float) (i / 1000L % 100));
hiss[idx++] = hisData;
}
// 写入数据
Map<String, OPHisData[]> hissMap = new HashMap<String, OPHisData[]>();
hissMap.put(POINT_AX_GLOBAL_NAME, hiss);
int[] results = conn.insertPointHistorys(hissMap);
System.out.println("write history return " + results[0]);
// 读取已写入的数据
OPHisData[] hissResult = conn.getPointHistory(POINT_AX_GLOBAL_NAME, FROM, TO, OPNetConst.HISTORY_DATA_SPAN, 1);
for (OPHisData his : hissResult) {
System.out.println(his);
}
System.out.println("finish...");
conn.close();
}
}6.18读历史
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import com.magus.net.OPConnect;
import com.magus.net.OPHisData;
import com.magus.net.OPNetConst;
import com.magus.net.exception.NetException;
/**
* @since 2011-9-15
* @author (liwei.tang@magustek.com) 读历史
*/
public class E02_HistoryRead extends _Example {
public static void main(String[] args) throws IOException, NetException, ParseException {
OPConnect conn = new OPConnect("192.168.2.41", PORT, 6000, USER_NAME, PASSWORD);
// String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME };
//
// // 获取历史数据
// Map<String, OPHisData[]> pn2HisMap =
// conn.getPointHistorys(pointNames, FROM, TO,
// OPNetConst.HISTORY_DATA_SPAN, 1);
//
// // 输出获取到的数据
// for (Map.Entry<String, OPHisData[]> entry : pn2HisMap.entrySet()) {
// String pn = entry.getKey();
// OPHisData[] hiss = entry.getValue();
// System.out.println(pn);
// for (OPHisData his : hiss) {
// System.out.println("\t" + his);
// }
// }
// 获取历史数据
FROM = DateFormat.getDateTimeInstance().parse("2019-10-28 18:00:00");
TO = DateFormat.getDateTimeInstance().parse("2019-10-28 19:00:00");
OPHisData[] hisData = conn.getPointHistory(POINT_AX_GLOBAL_NAME, FROM, TO, OPNetConst.HISTORY_DATA_SAMPLE, 1);
// 输出获取到的数据
for (OPHisData his : hisData) {
System.out.println("\t" + his);
}
System.out.println("finish...");
conn.close();
}
}6.19历史统计
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.text.ParseException;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.OPNetConst;
import com.magus.net.OPStatData;
import com.magus.net.exception.io.UsersException;
/**
* @author liwei.tang@magustek.com
* @since 2015年4月17日 取统计
*/
public class E03_HistoryStat extends _Example {
public static void main(String[] args) throws UsersException, IOException, ParseException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME };
// 可用的统计类型:STAT_DATA_AVG, STAT_DATA_MIN, STAT_DATA_MAX, STAT_DATA_FLOW
// 执行统计
Map<String, OPStatData[]> pn2StatMap = conn.getPointStats(pointNames, FROM, TO, OPNetConst.STAT_DATA_AVG, 5);
// 输出获取到的数据
for (Map.Entry<String, OPStatData[]> entry : pn2StatMap.entrySet()) {
String pn = entry.getKey();
OPStatData[] hiss = entry.getValue();
// 输出点名
System.out.println(pn);
// 输出数据
for (OPStatData his : hiss) {
System.out.println("\t" + his);
}
}
System.out.println("finish...");
conn.close();
}
}6.20历史统计
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.util.Map;
import com.magus.net.OPConnect;
import com.magus.net.OPNetConst;
import com.magus.net.OPStatData;
import com.magus.net.OPSumStatData;
import com.magus.net.exception.io.UsersException;
/**
* @author liwei.tang@magustek.com
* @since 2015年4月17日 取统计所有类型 注意:
* OPSumStatData.getMaxTime()和OPSumStatData.getMinTime
* ()是从服务端获得的最大最小值的时间点，但最大最小值时间可能实际上是时间延续。
*/
public class E04_HistoryStatAll extends _Example {
public static void main(String[] args) throws UsersException, IOException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
String[] pointNames = new String[] { POINT_AX_GLOBAL_NAME };
// 取统计
Map<String, OPStatData[]> pn2StatMap = conn.getPointStats(pointNames, FROM, TO, OPNetConst.STAT_DATA_SUMSTAT, 5);
// 输出获得的统计数据
for (Map.Entry<String, OPStatData[]> entry : pn2StatMap.entrySet()) {
String pn = entry.getKey();
OPStatData[] stats = entry.getValue();
// 输出点名
System.out.println(pn);
// 输出数据
for (OPStatData stat : stats) {
OPSumStatData statAll = (OPSumStatData) stat;
System.out.println("\t" + statAll);
}
}
System.out.println("finish...");
conn.close();
}
}6.21获取报警实时
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.util.List;
import com.magus.net.AlarmData;
import com.magus.net.OPConnect;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-19
* @author (liwei.tang@magustek.com) 取实时报警
* 注意：需要设置NODE的LC=1（即开启节点报警），并勾选测点报警属性设定报警高低限值，再写入实时数据后才会有报警数据产生。
*/
public class F01_AlarmRealtime extends _Example {
public static void main(String[] args) throws NetException, InterruptedException, IOException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 取报警
List<AlarmData> alarms = conn.requestAlrmRecord(null, null, true);
// 输出报警
for (AlarmData alarm : alarms) {
F02_AlarmHistory.showAlarm(alarm);
}
}
}6.22获取报警历史
详细代码示例
package com.magus.net.eg;
import java.io.IOException;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.List;
import com.magus.net.AlarmData;
import com.magus.net.OPConnect;
import com.magus.net.exception.NetException;
/**
* @since 2011-8-12
* @author (liwei.tang@magustek.com) 取报警历史
*/
public class F02_AlarmHistory extends _Example {
public static void main(String[] args) throws IOException, NetException, ParseException {
OPConnect conn = new OPConnect(IP, PORT, 6000, USER_NAME, PASSWORD);
// 取历史报警
List<AlarmData> alarms = conn.requestAlrmRecord(FROM, TO, false);
// 输出报警
for (AlarmData alarm : alarms) {
showAlarm(alarm);
}
conn.close();
}
static DateFormat df = DateFormat.getDateTimeInstance();
static DecimalFormat nf = new DecimalFormat("0.###");
static void showAlarm(AlarmData alarm) {
System.out.println(nf.format(alarm.getValue()) + "\t" + alarm.getAlarmStatus() + "\t" + df.format(alarm.getDate()) + "\t" + df.format(alarm.getT1()) + "\t" + df.format(alarm.getT2()) + "\t" + "IsAlarm:" + alarm.isAlarm() + "\t" + "IsAlarm2:" + alarm.isLevel2() + "\t" + "IsHeigh:" + alarm.isHeigh() + "\t" + "IsLow:" + alarm.isLow());
}
}