森数据DIX说明文档

# 数据库相关

# 数据库连接池

简述

适用于与数据库交互频率较高的场景，对于交互频率不高的场景推荐使用JDBC方式。

在使用数据库连接池进行CRUD操作的时候，都需要进行数据源的初始化，目前支持的数据库类型有。

  • MYSQL
  • ORACLE
  • DB2
  • SYBASE
  • SQLSERVER
  • POSTGRESQL
  • DM
  • HIVE 正式发行版本中，不包含此驱动包，若项目有需求，联系DIX

# 初始化数据源

参数名 必选/可选 参数类型 参数说明
dbType 必选 String 数据库类型(MYSQL/ORACLE/DB2/SYBASE/SQLSERVER/POSTGRESQL/DM)
username 必选 String 用户名
password 必选 String 密码
url 必选 String 连接路径
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");

var dbType1 = "MYSQL";
var username1 = "username1";
var password1 = "password1";
var url1 = "jdbc:mysql://0.0.0.0:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2b8";
var dbUtil1 = new DbUtil(dbType1, username1, password1, url1);

var dbType2 = "ORACLE";
var username2 = "username2";
var password2 = "password2";
var url2 = "jdbc:oracle:thin:@localhost:1521:orcl";
var dbUtil2 = new DbUtil(dbType2, username2, password2, url2);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Query

参数名 必选/可选 参数类型 参数说明
sql 必选 String 需要执行的sql
params 非必选 可动态扩展的参数 动态参数的顺序与sql中?占位符的顺序保持一致，动态参数类型与表字段类型一致
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");

var dbType = "MYSQL";
var username = "root";
var oassword = "root";
var url = "jdbc:mysql://0.0.0.0:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2b8";
var DbUtil_VMDB = new DbUtil(dbType, username, oassword, url);

//有参数据查询
var sql = "select node,KPINAME,VALUE,TIME FROM g_perf where node = ? and value= ?";
var node = "0.0.0.0";
var value = 12;
var sourcePerfList = DbUtil_VMDB.query(sql,node,value);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Insert

参数名 必选/可选 参数类型 参数说明
sql 必选 String 需要执行的sql
params 必选 Map 参数列表
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");
var DbUtil_VMDB = new DbUtil("MYSQL", "uinnova", "uinnova", "jdbc:mysql://0.0.0.0:1541/db_vmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8");
//插入操作
var IntMap = new java.util.HashMap();
IntMap.put(1,"参数1");
IntMap.put(2,"参数2");
IntMap.put(3,"参数3");
DbUtil_VMDB.update("insert into student values(?,?,?)", IntMap);
1
2
3
4
5
6
7
8

# Update

参数名 必选/可选 参数类型 参数说明
sql 必选 String 需要执行的sql
param 必选 Map 参数列表
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");
var DbUtil_VMDB = new DbUtil("MYSQL", "uinnova", "uinnova", "jdbc:mysql://0.0.0.0:1541/db_vmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8");
//更新操作示例
var UpdateMap = new java.util.HashMap();
UpdateMap.put(1, '参数1');
UpdateMap.put(2, '参数2');
DbUtil_VMDB.update("update student set sn_ame=? where id=?", UpdateMap);
1
2
3
4
5
6
7

# Delete

参数名 必选/可选 参数类型 参数说明
sql 必选 String 需要执行的sql
param 必选 Map 参数列表
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");
var DbUtil_VMDB = new DbUtil("MYSQL", "uinnova", "uinnova", "jdbc:mysql://0.0.0.0:1541/db_vmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8");
//删除操作
var DelMap = new java.util.HashMap();
DelMap.put(1, '参数1');
DbUtil_VMDB.update("delete from student where id=?", DelMap);
1
2
3
4
5
6

# executeBatch批量保存

参数名 必选/可选 参数类型 参数说明
sql 必选 String 需要执行的sql
datas 必选 List<Map<Integer, Object>> 参数列表
batch 必选 Integer 每个批次的数据量
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");
var DbUtil_VMDB = new DbUtil("MYSQL", "uinnova", "uinnova", "jdbc:mysql://0.0.0.0:1541/db_vmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8");
//批量保存
var paramList = new java.util.ArrayList();
for(var i=0; i<1000; i++){
    var IntMap = new java.util.HashMap();
    IntMap.put(1,"参数" + i);
    IntMap.put(2,"参数" + (i+1));
    IntMap.put(3,"参数" + (i+2));
    paramList.add(IntMap);
}
DbUtil_VMDB.executeBatch("insert into student values(?,?,?)", paramList, 500);
1
2
3
4
5
6
7
8
9
10
11
12

# executeBatchByTable批量保存

参数名 必选/可选 参数类型 参数说明
tableName 必选 String 表名
datas 必选 List<Map<String, Object>> 参数列表
batch 必选 Integer 每个批次的数据量
var DbUtil = Java.type("com.uinnova.di.dicom.util.DbUtil");
var DbUtil_VMDB = new DbUtil("MYSQL", "uinnova", "uinnova", "jdbc:mysql://0.0.0.0:1541/db_vmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8");
// 主键生成器
var IdGenerator = Java.type("com.uinnova.di.dicom.util.IdGenerator");
//批量保存
var paramList = new java.util.ArrayList();
var idGenerator = IdGenerator.createGenerator();
for (var i = 0; i < 1000; i++) {
    var IntMap = new java.util.HashMap();
    IntMap.put("id", idGenerator.generate());
    IntMap.put("name", "TZ" + (i + 1));
    IntMap.put("age", i);
    paramList.add(IntMap);
}
var tableName = "user";
var result = DbUtil_VMDB.executeBatchByTable(tableName, paramList, 500);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16




# JDBC单次查询

简述

JDBC单次查询适用于对于查询频率不高的场景，若查询频率较高推荐使用连接池方式。

# Mysql数据库

var MysqlJdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.MysqlJdbcAdapter");

while (true) {
    try {
        var adapter = new MysqlJdbcAdapter("jdbc:mysql://0.0.0.0:3306/database?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8", "root", "root");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# SqlServer数据库

var SqlServerJdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.SqlServerJdbcAdapter");

while (true) {
    try {
        var adapter = new SqlServerJdbcAdapter("jdbc:jtds:sqlserver://0.0.0.0:1433;DatabaseName=database", "sa", "admin");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# Oracle数据库

var OracleJdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.OracleJdbcAdapter");

while (true) {
    try {
        /**
          @param url      连接地址("jdbc:oracle:thin:@主机地址:端口号:SID")
          @param username 用户名
          @param password 密码
        */
        var adapter = new OracleJdbcAdapter("jdbc:oracle:thin:@host:port:SID", "orcl", "admin");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# DB2数据库

var DB2JdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.DB2JdbcAdapter");

while (true) {
    try {
        var adapter = new DB2JdbcAdapter("jdbc:db2://0.0.0.0:50000/sid", "sa", "admin");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# SybaseJtds数据库

var SybaseJdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.SybaseJdbcAdapter");

while (true) {
    try {
        var adapter = new SybaseJdbcAdapter("jdbc:jtds:sybase://0.0.0.0:5001/database", "sa", "admin");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# SybaseJconn3数据库

var SybaseJconn3Adapter = Java.type("com.uinnova.di.dicom.jdbc.SybaseJconn3Adapter");

while (true) {
    try {
        var adapter = new SybaseJconn3Adapter("jdbc:jtds:sybase://0.0.0.0:5001/database", "sa", "admin", "0000", "test");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# Postgresql数据库

var PostgreSqlJdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.PostgreSqlJdbcAdapter");

while (true) {
    try {
        var adapter = new PostgreSqlJdbcAdapter("jdbc:postgresql://0.0.0.0:5432/database", "postgres", "admin");
        var data = adapter.getDataByTable("select * from ...");
        heartBeat.addInCount(data.size());

        sleep(60000);
    } catch (error) {
        logger.error("脚本执行错误：" + error.message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13




# Mongo

简述

MongoDao工具类，是针对MongoDB封装的一个CRUD的工具类，可以满足常规的数据查询，数据写入，数据修改，数据删除操作(v5.12.0版本新增)。

在使用之前，需要简单认识几个概念：

  • Document：mongo数据需要用到对象，当做一个Map使用就可以。
  • Filters：mongo需要用到的条件过滤组件(包含等于，大于，小于，in，and，or 等等)。
var MongoDao = Java.type("com.uinnova.di.dicom.util.MongoDao");  //引入MongoDao类
var Document = Java.type("org.bson.Document");  // mongo需要用到对象， 当做一个Map使用就可以
var Filters = Java.type("com.mongodb.client.model.Filters"); //mongo需要用到的条件过滤组件
var ArrayList = Java.type("java.util.ArrayList"); //引入java后台集合类

/**
 * @Title 针对在JS脚本中使用 MongoDB工具的调用方式
 */
function run() {
    /**
     * 无认证初始化连接
     * @param String url（多个用逗号隔开）
     * @param String database
     */
    var DBUTIL = new MongoDao("192.168.1.1:27017", "local");


    /**
     * 有认证初始化连接
     * @param String url（多个用逗号隔开）
     * @param String database
     * @param String username
     * @param String password
     */
    // var DBUTIL = new MongoDao("192.168.1.1:27017", "local", "username", "password");


    /**
     * 根据id查询
     * @param String collection
     * @param String id
     *
     * @return Map<String, Object>
     */
    var ret1 = DBUTIL.queryByID("dix", "hhh0");
    logger.info(ret1);


    /**
     * 根据document查询
     * @param String collection
     * @param Document document
     *
     * @return List<Map<String, Object>>
     */
    var doc = new Document();
    doc.put("name", "asdf0");
    var ret2 = DBUTIL.queryByDoc("dix", doc);
    logger.info(ret2);


    /**
     * 根据Filters按条件过滤查询in or  and 等
     * @param String collection
     * @param Filters 过滤条件
     *
     * @return List<Map<String, Object>>
     */
    var ret3 = DBUTIL.queryByFilters("dix", Filters.in("name", "hhh1", "hhh2", "hhh3"));
    logger.info(ret3);


    /**
     * 根据Filters按条件过滤查询in or  and 等
     * @param String collection
     * @param Filters 过滤条件
     * @param int page
     * @param int pageSize 
     *
     * @return List<Map<String, Object>>
     */
    var ret4 = DBUTIL.queryByFilters("dix", Filters.in("name", "hhh1", "hhh2", "hhh3"), 0, 200);
    logger.info(ret4);


    /**
     * 查询全部
     * @param String collection
     *
     * @return List<Map<String, Object>>
     */
    var ret5 = DBUTIL.queryAll("dix");
    logger.info(ret5);


    /**
     * 分页查询全部
     * @param String collection
     * @param int page
     * @param int pageSize
     *
     * @return List<Map<String, Object>>
     */
    var ret6 = DBUTIL.queryAll("dix", 1, 10);
    logger.info(ret6);


    /**
     * 聚合查询，推荐使用
     * @param String collection
     * @param List<Document> queryList
     *
     * @return List<Map<String, Object>>
     */
    var queryList = new ArrayList();
    var match = new Document("name", "hhh3");
    var queryDoc = new Document();
    queryDoc.put("$match", match);
    queryList.add(queryDoc);
    var ret7 = DBUTIL.queryByAggregate("dix", queryList);
    logger.info(ret7);


    /**
     * 插入单条数据
     * @param String collection
     * @param Document insertDoc
     *
     * @return Boolean
     */
    var insertDoc = new Document();
    insertDoc.put("name", "hello");
    insertDoc.put("age", 12);
    var ret8 = DBUTIL.insert("dix", insertDoc);
    logger.info(ret8);


    /**
     * 插入多条数据
     * @oaram String collection
     * @param List<Document> insertList
     * @param int num(每个批次大小)
     *
     * @return Boolean
     */
    var insertList = new ArrayList();
    for (var i = 0; i < 50; i++) {
        var temp = new Document();
        temp.put("name", "hasdfhh" + i);
        temp.put("age", i);
        insertList.add(temp);
    }
    var ret9 = DBUTIL.insertMany("dix", insertList, 500);
    logger.info(ret9);


    /**
     * 保存并更新数据(主键存在时更新， 不存在时插入, 推荐使用)
     * @param String collection
     * @param String 集合主键
     * @param List<Document> saveList
     *
     * @return String
     */
    var saveList = new ArrayList();
    for (var j = 0; j < 500; j++) {
        var single = new Document();
        single.put("_id", "hh" + j);
        single.put("name", "f" + j);
        single.put("age", j * 2);
        saveList.add(single);
    }
    var ret10 = DBUTIL.saveOrUpdate("dix", "_id", saveList);
    logger.info(ret10);


    /**
     * 根据条件删除一条数据（return boolean）
     * @param String collection
     * @param Filters 过滤条件
     *
     * @return Boolean
     */
    var ret11 = DBUTIL.deleteOne("dix", Filters.eq("_id", "hhh0"));
    logger.info(ret11);


    /**
     * 根据条件批量删除
     * @param String collection
     * @param List delList
     *
     * @return String
     */
    var delList = new ArrayList();
    delList.add("hhh1");
    delList.add("hhh5");
    delList.add("hhh7");
    var ret12 = DBUTIL.deleteMany("dix", Filters.in("_id", delList));
    logger.info(ret12);


    /**
     * 更新一条数据
     * @param String collection
     * @param Document document
     * @param Document document
     *
     * @return Boolean
     */
    var old = new Document();
    old.put("name", "asdf");

    var upd = new Document();
    upd.put("name", "777");
    var ret13 = DBUTIL.updateOne("dix", old, upd);
    logger.info(ret13);


    /**
     * 根据条件更新数据
     * @param String collection
     * @param Filters 过滤条件
     * @param Document document
     *
     * @return Boolean
     */
    var ret14 = DBUTIL.updateOne("dix", Filters.eq("name", "6666"), upd);
    logger.info(ret14);


    /**
     * 根据条件更新多条
     * @param String collection
     * @param Filters 过滤条件
     * @param Document document
     *
     * @return String
     */
    var upd2 = new Document();
    upd2.put("name", "888");
    var ret15 = DBUTIL.updateManny("dix", Filters.in("name", "hhh1", "hhh2", "hhh3"), upd2);
    logger.info(ret15);


    /**
     * 删除集合
     * @param String collection
     */
    DBUTIL.dropCol("collection");


    /**
     * 创建集合
     * @param String collection
     */
    DBUTIL.createCol("collection");


    /**
     * 高阶使用
     * 
     * 直接返回DB对象
     * 适用于在现有封装方法无法满足查询需求时, 可以使用返回的连接池对象自定义编写方法查询
     */
    //如下示例 投影查询
    var FindIterable = Java.type("com.mongodb.client.FindIterable");
    var MongoCollection = Java.type("com.mongodb.client.MongoCollection");

    var document11_1 = new Document();
    document11_1.put("_id",3);
    var document11_2 = new Document();
    document11_2.put("_id",0);
    document11_2.put("name",1);
    document11_2.put("age",1);

    var dbInstance = DBUTIL.getDB(); //通过该方法返回连接池实例
    var collection = dbInstance.getCollection("dix");
    var iterable11 = collection.find(document11_1).projection(document11_2);//projection方法查询指定字段
    logger.info(iterable11);  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

# Redis

简述

RedisClientUtil工具类，是针对Redis封装的一个工具类，可以满足常规的数据查询，数据写入，数据修改， 支持单点和集群操作，具体操作请参考下方示例:

# Redis单点初始化

//引入RedisClientUtil工具类
var RedisClientUtil = Java.type("com.uinnova.di.dicom.util.redis.RedisClientUtil");
function run() {
    /**
    * 初始化
    * @param ip:port
    * @param password 密码(若不需要密码, 该参数可直接省略)
    * @exp  var redisUtil = RedisClientUtil.getInstance("0.0.0.0:0000");
    */
    var redisUtil = RedisClientUtil.getInstance("ip:port", password);  
}
1
2
3
4
5
6
7
8
9
10
11

# Redis集群初始化

//引入RedisClientUtil工具类
var RedisClientUtil = Java.type("com.uinnova.di.dicom.util.redis.RedisClientUtil");
var HashMap = Java.type("java.util.HashMap");
function run() {
    var hostAndPort = new HashMap();
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    /**
    * 初始化
    * @param hostAndPort  ip,port组成的集合 类型为java.util.HashMap
    * @param password 密码(若不需要密码, 该参数可直接省略)
    * @exp  var redisUtil = RedisClientUtil.getInstance(hostAndPort);
     */
    var redisUtil = RedisClientUtil.getInstance(hostAndPort, password);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Redis增删改查


    /**
     * 保存字符类型数据
     * @param key
     * @param value
     */
     redisUtil.saveString("key", "value");

    /**
    * 保存字符类型数据并设置过期时间
    * @param key
    * @param value
    * @param Second
    */
     redisUtil.saveString("key", "value", 5);


    /**
    * 保存字符类型数据, 当key不存在时保存成功
    * @param key
    * @param value
    * @param Second
    */
     redisUtil.saveNX("key", "value");


    /**
    * 将数据存入set集合中
    * @param key
    * @param value
    */
     redisUtil.saveToSet("key", "value");


    /**
    * 将数据存入hash集合中
    * @param hName
    * @param key
    * @param value
    */
     redisUtil.hashSet("hName", "key", "value");


    /**
     * 将数据存入队列中
     * @param qNmae
     * @param value
     * @param size 队列大小(0 不限制)
     */
    redisUtil.saveToQueue("queueName", "test", 0);


    /**
     * 向sorted set中追加一个值
     * @param key  set名
     * @param score  分数
     * @param member 成员名称
     */
    redisUtil.saveToSortedset("setNmae", 10, "key");


    /**
     * 将自增变量存入缓存
     * @param key 
     * @param seqNo  自增量初始值
     */
    redisUtil.saveSeq("key", 1);


    /**
     * 将递增浮点数存入缓存
     * @param key 
     * @param seqNo  浮点数初始值
     */
    redisUtil.savetoFloat("key", 1.5);


    /**
     * 保存复杂类型数据到缓存
     * @param key
     * @param obj
     */
    redisUtil.saveBean("key", obj);


    /**
     * 保存复杂类型数据到缓存（并设置失效时间）
     *
     * @param key
     * @param obj
     * @param seconds
     */
    redisUtil.saveBean("key", obj, 5);


    /**
    * 从缓存中取得字符串数据
    * @param key
    */
    var ret = redisUtil.getString("haha");
    logger.info(ret);


    /**
    * 从队列中取得数据
    * @param qName
    * @param size 长度默认0 不限制
    */
    var ret = redisUtil.getFromQueue("queueName", 0);
    logger.info(ret);


    /**
     * 返回存储在 key 里的list的长度。 如果 key 不存在，那么就被看作是空list，并且返回长度为 0
     *
     * @param key
     */
    var ret = redisUtil.llen("key");
    logger.info(ret);



    /**
     * 功能: 从指定队列里取得数据<br />
     *
     * @param key
     */
    var ret = redisUtil.popQueue("queueName");
    logger.info(ret);


    /**
     * 返回存储在 key 的列表里指定范围内的元素。 start 和 end
     * 偏移量都是基于0的下标，即list的第一个元素下标是0（list的表头），第二个元素下标是1，以此类推
     * @param key
     * @param start 
     * @param end
     */
    var ret = redisUtil.lrange("key", start, end);
    logger.info(ret);


    /**
    * 从hash集合中取得数据
    * @param hName
    * @param key
    */
    var ret = redisUtil.hashGet("hName", "key");
    logger.info(ret);

     /**
     * 功能: 从hash中取得全部key对应所有field
     *
     * @param key hash集合的名称
     */
    redisUtil.hashGetAll("key");


     /**
     * 从hash集合里取得复杂类型数据
     *
     * @param hName
     * @param key
     * @param clazz 类型， 如HashMap.class
     */
    var ret = redisUtil.hashGet("hName", "key", clazz)


    /**
    * 判断hash集合中是否缓存了数据
    * @param hName
    * @param key
    */
    var ret = redisUtil.hashCached("hash", "key");
    logger.info(ret);


    /**
     * 判断是否缓存在指定的集合中
     *
     * @param key 数据KEY
     * @param val 数据
     */
    var ret = redisUtil.isMember("key", val);
    logger.info(ret);


    /**
     * 列出set中所有成员
     * @param setName
     */
    var ret = redisUtil.listSet("setName");
    logger.info(ret);


    /**
     * 逆序列出sorted set包括分数的set列表
     * @param key   set名
     * @param start 开始位置
     * @param end   结束位置
     */
    var ret = redisUtil.listSortedsetRev("key", 0, 20);
    logger.info(ret);


    /**
     * 正序列出sorted set包括分数的set列表
     * @param key   set名
     * @param start 开始位置
     * @param end   结束位置
     */
    var ret = redisUtil.listSortedset("key", 0, 20);
    logger.info(ret);


     /**
     * 逆序取得sorted sort排名
     *
     * @param key    set名
     * @param member 成员名
     */
    var ret = redisUtil.getRankRev("key", member);
    logger.info(ret);


    /**
     * 根据成员名取得sorted sort分数
     *
     * @param key    set名
     * @param member 成员名
     */
    var ret = redisUtil.getMemberScore("key", member);
    logger.info(ret);


    /**
     * 取得复杂类型数据
     *
     * @param key
     * @param clazz 类型， 如HashMap.class
     */
    var ret = redisUtil.getBean("key", Object.class);
    logger.info(ret);
    

    /**
     * 取得序列值的下一个
     *
     * @param key
     * @param by 增量值
     */
    var ret = redisUtil.getSeqNext("key", incr);
    logger.info(ret);


    /**
     * 从缓存中删除数据
     *
     */
    var ret = redisUtil.delString("key");
    logger.info(ret);


    /**
     * 从hashmap中删除一个值
     *
     * @param key   map名
     * @param field 成员名称
     */
    redisUtil.delFromMap("key", field);

    /**
     * 从sorted set删除一个值
     *
     * @param key    set名
     * @param member 成员名称
     */
    redisUtil.delFromSortedset("key", member);


    /**
     * 设置超时时间
     *
     * @param key
     * @param seconds
     */
    redisUtl.expire("key", 10);

    /**
     * 将序列值回退一个
     *
     * @param key
     */
    redisUtil.getSeqBack("key");


    /**
     * 增加浮点数的值
     *
     * @param key
     * @param incrBy 增量值 float类型
     */
    redisUtil.incrFloat("key", 5.1)

     /**
     * 根据key增长 ，计数器
     *
     * @param key
     */
    var ret = redisUtil.incr("key");
    logger.info(ret);


    /**
     * 获取所有匹配的key
     * @param pattern 表达式 (dix* 匹配所有dix的key, * 匹配所有key)
     */
    var ret = redisUtil.getAllKeys("*");
    logger.info(ret);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320

# Redis发布订阅

发布订阅是指通过redis当做消息队列来使用，发送端向指定的channel发送消息，接收端订阅channel来实现数据接收。

# 接收数据

    //引入RedisClientUtil工具类（RedisClientUtil的单点、集群这两种方式不可在同一脚本中进行初始化）
    var RedisClientUtil = Java.type("com.uinnova.di.dicom.util.redis.RedisClientUtil");

    /**
    * 初始化(单点)
    * @param ip:port
    * @param password 密码(若不需要密码, 该参数可直接省略)
    * @exp  var redisUtil = RedisClientUtil.getInstance("0.0.0.0:0000");
    */
    var redisUtil = RedisClientUtil.getInstance("0.0.0.0:0000", "password...");
    

    /**
    * 初始化(集群)
    * @param hostAndPort  ip,port组成的集合 类型为java.util.HashMap
    * @param password 密码(若不需要密码, 该参数可直接省略)     
    */
    var HashMap = Java.type("java.util.HashMap");
    var hostAndPort = new HashMap();
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    var redisUtil = RedisClientUtil.getInstance(hostAndPort, "password...");
    


    /**
    * 订阅 (可以同时订阅多个)
    * @param channel名称, 多个用逗号隔开
    */
    redisUtil.subscribeMessage("channel01");

    // 接收消息
    while(true){
        var data = redisUtil.getData();
        logger.info("------" + data);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 发送数据

    //引入RedisClientUtil工具类（RedisClientUtil的单点、集群这两种方式不可在同一脚本中进行初始化）
    var RedisClientUtil = Java.type("com.uinnova.di.dicom.util.redis.RedisClientUtil");

    /**
    * 初始化(单点)
    * @param ip:port
    * @param password 密码(若不需要密码, 该参数可直接省略)
    * @exp  var redisUtil = RedisClientUtil.getInstance("0.0.0.0:0000");
    */
    var redisUtil = RedisClientUtil.getInstance("0.0.0.0:0000", "password...");
    

    /**
    * 初始化(集群)
    * @param hostAndPort  ip,port组成的集合 类型为java.util.HashMap
    * @param password 密码(若不需要密码, 该参数可直接省略)     
    */
    var HashMap = Java.type("java.util.HashMap");
    var hostAndPort = new HashMap();
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    hostAndPort.put("0.0.0.0", 0000);
    var redisUtil = RedisClientUtil.getInstance(hostAndPort, "password...");
    

    /**
     * 发布消息
     * @param channel名称
     * @param 具体的消息
     */
    redisUtil.publishMessage("channel01", "your message");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34




# LDAP

LDAP代表轻型目录访问协议(Lightweight Directory Access Protocol)。DIX支持从LDAP服务中获取指定的数据。
使用方式：在JavaScript类型DIP侧边菜单中点击 用户信息处理 -> 获取LDAP数据，即可生成如下代码模板。

function run() {
    var Hashtable = Java.type("java.util.Hashtable");
    var Context = Java.type("javax.naming.Context");
    var InitialDirContext = Java.type("javax.naming.directory.InitialDirContext");
    var SearchControls = Java.type("javax.naming.directory.SearchControls");
    /**
     *  @param host LDAP服务地址
     *  @param port LDAP服务端口
     *  @param USER_DN  LDAP服务的连接账号
     *  @param PRINCIPAL LDAP服务的连接账号的密码
     *  @param LDAP_BASEDN 将查询该范围下信息
     *  @param filter 过滤规则，过滤符合条件的数据
     * */
    var host = "";
    var port = "";
    var USER_DN = "";
    var PRINCIPAL = "";
    var LDAP_BASEDN = "";
    var uname = "xiaoming*";
    var filter = "(&(cn=" + uname + ")(objectClass=*))";

    var env = new Hashtable();
    var LDAP_URL = "ldap://" + host + ":" + port;
    env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
    env.put(Context.PROVIDER_URL, LDAP_URL);
    env.put(Context.SECURITY_AUTHENTICATION, "simple");
    env.put(Context.SECURITY_PRINCIPAL, USER_DN);
    env.put(Context.SECURITY_CREDENTIALS, PRINCIPAL);
    env.put("java.naming.ldap.attributes.binaery", "objectGgid");
    var dirContext = null;
    try {
        dirContext = new InitialDirContext(env);
        logger.info("Init DirContext Authentication Successed");
    } catch (e) {
        logger.error("Init DirContext Authentication Failed:" + e);
    }

    var controls = new SearchControls();
    //earchControls.OBJECT_SCOPE; 只搜索LDAP_BASEDN
    //SearchControls.ONELEVEL_SCOPE; 搜索LDAP_BASEDN直接下级
    //SearchControls.SUBTREE_SCOPE 搜索LDAP_BASEDN全部下级
    controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
    var enumertion = null;
    try {
        enumertion = dirContext.search(LDAP_BASEDN, filter, controls);
        while (enumertion != null && enumertion.hasMore()) {
            var sr = enumertion.next();
            var attrs = sr.getAttributes();
            var firstName = attrs.get("givenName");
            var email = attrs.get("mail");
            var phone = attrs.get("telephonenumber");
        }

    } catch (e) {
        logger.error("get data error:" + e);
    }
    if (this.dirContext != null) {
        try {
            this.dirContext.close();
            logger.info("dirContext close()");
        } catch (e) {
            logger.error("dirContext failed:" + e);
        }
    }

    function getValue(str) {
        var splits = str.toString().split(':');
        return splits[1].trim();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# 数据库字段加密

在哪里加密?在所有的可以写脚本的DIP中，都有一个字段加密的按钮，点击按钮输入需要加密的数据，然后点击加密，就可以得到加密后的数据。如下图：

加密前

加密后

# 加密字符在代码中使用

在下面代码片段第6行中，我们分别对数据库用户名，密码进行了加密并使用。






 









function run() {
    var MysqlJdbcAdapter = Java.type("com.uinnova.di.dicom.jdbc.MysqlJdbcAdapter");
    while (true) {
        try {
            // dburl, username, password
            var adapter = new MysqlJdbcAdapter("jdbc:mysql://0.0.0.0:3306/db_vmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8", "ENC(hZDq0G9lui+VtrUy/ZMLZQ==)", "ENC(1/qJ/2pJB7YkxI5J8GhhSbhECXj8Iixw)");
            var data = adapter.getDataByTable("select * from mon_eap_event_memory");
            logger.info(data);
            heartBeat.addInCount(data.size());
            sleep(60000);
        } catch (error) {
            logger.error("脚本执行错误：" + error.message);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
上次更新时间: 2/3/2023, 1:23:58 PM

← 工具插件 →