RocksDB Java基本操作、乐观锁、事务及性能测试

RocksDB

rocksdb是一款由Facebook使用C/C++开发的嵌入式的持久化的KV数据库

基于Google的LevelDB改进而来，redis是基于内存的会存在丢失情况，而RocksDB不会丢失且性能极好（硬盘和SSD）。

属于单机数据库，且同一库只可被一个进程读取写入。（线程安全需要用事务）

适用场景

1.对写性能要求很高，同时有较大内存来缓存SST块以提供快速读的场景；

2.SSD等对写放大比较敏感以及磁盘等对随机写比较敏感的场景；

3.需要变长kv存储的场景；

4.小规模元数据的存取；

不适合场景

1.大value的场景，需要做kv分离；

2.大规模数据的存取

项目环境 maven jdk1.8 windows10
项目类型 maven项目

依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.54</version>
</dependency>
<dependency>
    <groupId>org.kevoree.mwg.plugins</groupId>
    <artifactId>rocksdb</artifactId>
    <version>6</version>
</dependency>

<dependency>
    <groupId>org.rocksdb</groupId>
    <artifactId>rocksdbjni</artifactId>
    <version>6.6.4</version>
</dependency>

还需要手动下载一个jar包引入

rockssdb-6.jar

https://www.mvnjar.com/org.kevoree.mwg.plugins/rocksdb/6/detail.html

基本操作示范类

步骤

建立连接

调用get put delete close方法即可

import org.rocksdb.Options;
import org.rocksdb.RocksDB;
import org.rocksdb.RocksDBException;

/**
 * RocksDB基本操作类
 * 由于默认操作要传入的是bytes所以做了一层封装，直接传入string操作。
 */
public class RocksDBOps {
    //数据库路径（文件夹）
    private String path;
    //rocksdb连接
    private RocksDB rocksDB;
    static {
        //加载库
        RocksDB.loadLibrary();
    }
    public RocksDBOps(String path) throws RocksDBException {
        this.path=path;
        rocksDB=RocksDB.open(path);
    }

    /**
     * 写入数据
     * @param key 键
     * @param value 值
     * @return boolean 成功与否
     */
    public boolean put(String key,String value){
        try {
            rocksDB.put(key.getBytes(),value.getBytes());
            return true;
        }catch (RocksDBException e){
            return false;
        }
    }

    /**
     * 获取数据
     * @param key 键
     * @return string 值
     */
    public String  get(String key){
        try {
            byte[] bytes=rocksDB.get(key.getBytes());
            if(bytes!=null){
                return new String(bytes);
            }
        }catch (RocksDBException e){
            e.printStackTrace();
        }
        return  null;
    }

    /**
     * 删除数据
     * @param key 键
     * @return boolean 成功与否
     */
    public boolean delete(String key){
        try {
            rocksDB.delete(key.getBytes());
            return true;
        }catch (RocksDBException e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 关闭连接
     */
    public void close(){
        if(rocksDB!=null){
            rocksDB.close();
        }
    }
    public static void main(String[] args) {
        String path="C:\\rocksdb_test.db";
        try {
            //创建连接
            RocksDBOps rocksDBOps=new RocksDBOps(path);
            String key="chen";
            //写入
            rocksDBOps.put(key,"programmer");
            //获取
            String job=rocksDBOps.get(key);
            System.out.println("job："+job);
            //删除
            boolean ret=rocksDBOps.delete(key);
            if(ret){
                System.out.println("deleted");
            }else {
                System.err.println("delete failed");
            }
            //关闭连接
            rocksDBOps.close();
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

乐观事务操作

操作步骤

建立连接，创建事务，对事务操作，提交事务，失败时回滚，最终关闭

写同一个两个事务只成功一个。

import org.rocksdb.*;

public class OptimisticTransactionTest {
    private static OptimisticTransactionDB db;
    private static final String path="C:\\rocksdb_test.db";
    private static final String key="test";

    static {
        try {
            //加载库
            RocksDB.loadLibrary();
            //创建连接
            db= OptimisticTransactionDB.open(new Options().setCreateIfMissing(true),path);
            //设置初始值（由于多次运行该程序测试，做一个初始化操作）
            db.put(key.getBytes(),"C".getBytes());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 修改某个key的乐观锁测试
     */
    public class TestThread extends Thread{
        private String name;
        private int sleep;
        public TestThread(String name,int sleep){
            super(name);
            this.name=name;
            this.sleep=sleep;
        }
        @Override
        public void run() {
            Transaction transaction=db.beginTransaction(new WriteOptions());
            try {
                transaction.put(key.getBytes(),name.getBytes());
//                Thread.sleep(sleep);
                transaction.commit();
                System.out.println(name+" success");
            }catch (Exception e){
                System.err.println(name+" failed");
                try {
                    transaction.rollback();
                }catch (Exception e1){
                    e1.printStackTrace();
                }
                e.printStackTrace();
            }
        }
    }
    public void test(){
        TestThread t1=new TestThread("A",500);
        TestThread t2=new TestThread("B",1000);
        t1.start();
        t2.start();
    }
    public static void main(String[] args) {
        new OptimisticTransactionTest().test();
    }
}

读写测速（不考虑线程安全情况）

测试类

package bean;

import com.alibaba.fastjson.JSONObject;

import java.math.BigDecimal;
import java.util.Random;

public class User {
    private Long uid;
    private String username;
    private String password;
    private Integer age;
    private BigDecimal balance;

    public Long getUid() {
        return uid;
    }

    public void setUid(Long uid) {
        this.uid = uid;
    }
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
    public static User randomUser(){
        Random random=new Random();
        int n=random.nextInt(10);
        User user=new User();
        user.setUid(123004545L*n);
        user.setAge(n);
        user.setBalance(new BigDecimal(n*1000000));
        user.setPassword("123123"+n);
        user.setUsername("hello"+n);
        return user;
    }
}

机器：i5 9500 @ 3.00GHz 6核心 16GB内存 windows （还开着挺多开发软件，但是这个单进程读写应该不会受到太多影响）

测试50万次读取写入带有5个不同类型的实例

bean概貌：
public class User {
    private Long uid;
    private String username;
    private String password;
    private Integer age;
    private BigDecimal balance;
}
结果：

读取 50万次/秒

写入 10万次/秒

测试3000万次读取写入带有5个不同类型的实例

结果：

读取26.万次/秒

写入12万次/秒