sequoiadb数据库5.0.1的java使用和示例_sequoiadb5.0.1数据库下载

---

前言

参考时间：2023-11-11
服务器版本：CentOS 7.6
数据库版本：5.0.1
官网地址：https://www.sequoiadb.com/
下载地址：https://download.sequoiadb.com/cn/
1
2
3
4
5

---

1，添加依赖

在pom里引入sequoiadb5.0.1驱动依赖

<!--sequoiadb驱动-->
<dependency>
    <groupId>com.sequoiadb</groupId>
    <artifactId>sequoiadb-driver</artifactId>
    <version>5.0.1</version>
</dependency>
1
2
3
4
5
6

2，设置连接参数

在配置文件里添加链接参数

##sequoiadb链接配置，集群地址可用;分割
sequoiadb.serverlist=127.0.0.1:11810
sequoiadb.username=username
sequoiadb.password=password
##创建链接超时时间
sequoiadb.connectTimeout=500
##建连失败后重试时间
sequoiadb.maxAutoConnectRetry=0
##连接池最多能提供的连接数
sequoiadb.maxCount=50
##每次增加的连接数
sequoiadb.deltaIncCount=20
##连接池空闲时保留的连接数
sequoiadb.maxIdleCount=20
##池中空闲连接存活时间,单位:毫秒,0表示不关心连接隔多长时间没有收发消息
sequoiadb.keepAliveTimeout=0
##每隔 60s 将连接池中多于 MaxIdleCount 限定的空闲连接关闭，并将存活时间过长（连接已停止收发超过 keepAliveTimeout 时间）的连接关闭
sequoiadb.checkInterval=60000
##向 catalog 同步 coord 地址的周期，单位:毫秒,0 表示不同步
sequoiadb.syncCoordInterval=0
##连接出池时，是否检测连接的可用性，默认不检测
sequoiadb.validateConnection=false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3，设置数据库数据源配置类

在项目里添加数据库数据源配置类

import com.sequoiadb.base.ConfigOptions;
import com.sequoiadb.datasource.ConnectStrategy;
import com.sequoiadb.datasource.DatasourceOptions;
import com.sequoiadb.datasource.SequoiadbDatasource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

@Component
public class SequoiadbConfig {
    @Value("${sequoiadb.connectTimeout}")
    private int connectTimeout;
    @Value("${sequoiadb.maxAutoConnectRetry}")
    private int maxAutoConnectRetry;
    @Value("${sequoiadb.maxCount}")
    private int maxCount;
    @Value("${sequoiadb.deltaIncCount}")
    private int deltaIncCount;
    @Value("${sequoiadb.maxIdleCount}")
    private int maxIdleCount;
    @Value("${sequoiadb.keepAliveTimeout}")
    private int keepAliveTimeout;
    @Value("${sequoiadb.checkInterval}")
    private int checkInterval;
    @Value("${sequoiadb.syncCoordInterval}")
    private int syncCoordInterval;
    @Value("${sequoiadb.validateConnection}")
    private boolean validateConnection;

    @Value("${sequoiadb.username}")
    private String username;
    @Value("${sequoiadb.password}")
    private String password;
    @Value("${sequoiadb.serverlist}")
    private String serverlist;


    @Bean(name = "sdbDataSource")
    @Autowired
    public SequoiadbDatasource sequoiadbDatasource(@Qualifier("sdb.datasource.configOptions") ConfigOptions configOptions,
                                                   @Qualifier("sdb.datasource.datasourceOptions") DatasourceOptions datasourceOptions) {
        List<String> serverList = Arrays.asList(serverlist.split(";"));
        return new SequoiadbDatasource(serverList, username, password, configOptions, datasourceOptions);
    }

    @Bean(name = "sdb.datasource.configOptions")
    public ConfigOptions configOptions() {
        ConfigOptions configOptions = new ConfigOptions();
        configOptions.setConnectTimeout(connectTimeout);
        configOptions.setMaxAutoConnectRetryTime(maxAutoConnectRetry);
        return configOptions;
    }

    @Bean(name = "sdb.datasource.datasourceOptions")
    public DatasourceOptions datasourceOptions() {
        DatasourceOptions datasourceOptions = new DatasourceOptions();
        datasourceOptions.setMaxCount(maxCount);                     // 连接池最多能提供50个连接。
        datasourceOptions.setDeltaIncCount(deltaIncCount);           // 每次增加20个连接。
        datasourceOptions.setMaxIdleCount(maxIdleCount);             // 连接池空闲时，保留20个连接。
        datasourceOptions.setKeepAliveTimeout(keepAliveTimeout);     // 池中空闲连接存活时间。单位:毫秒。 0表示不关心连接隔多长时间没有收发消息。
        datasourceOptions.setCheckInterval(checkInterval);          // 每隔60秒将连接池中多于MaxIdleCount限定的空闲连接关闭.并将存活时间过长（连接已停止收发超过keepAliveTimeout时间）的连接关闭。
        datasourceOptions.setSyncCoordInterval(syncCoordInterval);     // 向catalog同步coord地址的周期。单位:毫秒。
        datasourceOptions.setValidateConnection(validateConnection);     // 连接出池时，是否检测连接的可用性，默认不检测。0表示不同步。
        datasourceOptions.setConnectStrategy(ConnectStrategy.BALANCE); // 默认使用coord地址负载均衡的策略获取连接。
        return datasourceOptions;
    }
}
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

4，使用

在需要使用数据库的地方，使用@Autowired注入SequoiadbDatasource即可。

@Autowired
private SequoiadbDatasource sequoiadbDatasource;
1
2

5，创建集合空间和集合

//集合空间名
String cs="test_cs";
//集合名
String cl="test_cl";
1
2
3
4

创建集合空间（库）

//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //在数据库里创建CS
    sequoiadb.createCollectionSpace(cs);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
1
2
3
4
5
6
7
8
9
10
11

创建集合（表）

//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //在CS里创建CL
    DBCollection dbCollection = collectionSpace.createCollection(cl);
    //在CL里创建索引:索引名、默认排序规则、是否唯一、是否稀疏索引
    dbCollection.createIndex("pk_id", new BasicBSONObject().append("id", -1), true, false);
    dbCollection.createIndex("idx_parentId", new BasicBSONObject().append("parent_id", 1), false, false);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6，插入数据

List<User> userList = Lists.newArrayList(new User(1L, "张三", 18), new User(2L, "李四", 20), new User(3L, "王五", 22));
//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //获得CL对象
    DBCollection dbCollection = collectionSpace.getCollection(cl);
    //把对象集合转成BSONObject集合
    List<BSONObject> bsonObjects = Lists.newArrayList();
    for (User user : userList) {
        bsonObjects.add(BasicBSONObject.typeToBson(user));
    }
    //批量插入
    dbCollection.insert(bsonObjects);//这个方法支持单条和批量插入
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7，查询数据

查询一条数据

//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //获得CL对象
    DBCollection dbCollection = collectionSpace.getCollection(cl);
    //查询数据
    BSONObject bsonObject = dbCollection.queryOne();
    log.info("一条数据:{}", bsonObject);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

查询全部数据

List<User> userList = Lists.newArrayList();
//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //获得CL对象
    DBCollection dbCollection = collectionSpace.getCollection(cl);
    //查询数据到游标里
    DBCursor dbCursor = dbCollection.query();
    //循环游标里的数据
    while (dbCursor.hasNext()) {
        //获取游标里的数据
        BSONObject bsonObject = dbCursor.getNext();
        //把数据转成User对象
        User user = bsonObject.as(User.class);
        //添加到集合里
        userList.add(user);
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
log.info("全部数据:{}", userList);
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

查询分页数据

List<User> userList = Lists.newArrayList();
//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //获得CL对象
    DBCollection dbCollection = collectionSpace.getCollection(cl);
    //封装搜索条件
    BasicBSONObject matcher = new BasicBSONObject();
    //查询id不等于1的数据
    matcher.append("id", new BasicBSONObject().append("$ne", 1L));
    //封装展示字段
    BasicBSONObject selector = new BasicBSONObject();
    selector.append("id", null);
    selector.append("name", null);
    //封装排序规则
    BasicBSONObject orderBy = new BasicBSONObject();
    //根据age升序排序
    orderBy.append("age", -1);
    //跳过条数，类似mysql的limit
    long skipRows = 0;
    //查询数量
    long size = 10;
    DBCursor dbCursor = dbCollection.query(matcher, selector, orderBy, null, skipRows, size, 0);
    //循环游标里的数据
    while (dbCursor.hasNext()) {
        //获取游标里的数据
        BSONObject bsonObject = dbCursor.getNext();
        //把数据转成User对象
        User user = bsonObject.as(User.class);
        //添加到集合里
        userList.add(user);
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
log.info("分页数据:{}", userList);
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

8，修改数据

//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //获得CL对象
    DBCollection dbCollection = collectionSpace.getCollection(cl);
    //封装修改条件
    BSONObject matcher = new BasicBSONObject();
    //修改id=1的数据
    matcher.put("id", 1L);
    //封装修改字段
    BSONObject modifier = new BasicBSONObject();
    //修改age字段为30
    modifier.put("age", 30);
    //执行修改，这里有个【$set】要注意，类似mysql的set。
    dbCollection.update(matcher, new BasicBSONObject().append("$set", modifier), null);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放数据库链接
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

9，事务操作

//得到数据库链接
Sequoiadb sequoiadb = sequoiadbDatasource.getConnection();
try {
    //开始事务
    sequoiadb.beginTransaction();
    //获得CS对象
    CollectionSpace collectionSpace = sequoiadb.getCollectionSpace(cs);
    //获得CL对象
    DBCollection dbCollection = collectionSpace.getCollection(cl);

    //保存数据
    User user = new User(4L, "董六", 33);
    dbCollection.save(user);

    //封装修改条件
    BSONObject matcher = new BasicBSONObject();
    //修改id=2的数据
    matcher.put("id", 2L);
    //封装修改字段
    BSONObject modifier = new BasicBSONObject();
    //修改age字段为40
    modifier.put("age", 40);
    //执行修改，这里有个【$set】要注意，类似mysql的set。
    dbCollection.update(matcher, new BasicBSONObject().append("$set", modifier), null);

    //提交事务
    sequoiadb.commit();
} catch (Exception e) {
    e.printStackTrace();
    //回滚事务
    sequoiadb.rollback();
} finally {
    sequoiadbDatasource.releaseConnection(sequoiadb);
}
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

10，更多操作命令以及工具

更详细的代码例子请参考我的demo。
demo中封装了一个工具类，可以直接注入到需要使用的类中，可根据自己需求进行修改。

@Autowired
private SequoiadbUtil sequoiadbUtil;
1
2

demo的test目录下有三个测试类

CreateTest.java：是集合空间的操作样例。
DataTest.java：是数据操作的样例。
UtilTest.java：是个人工具的样例。
1
2
3

demo的地址：https://gitee.com/zfxxc/sequoiadb-test-demo

更多操作命令可以参考官方的参考手册。
项目运行中的错误可参考官方的错误码。