初识-LevelDB

简介

  • Leveldb是一个google实现的非常高效的kv数据库
  • 能够支持billion级别的数据量了
  • LevelDb不会像Redis一样狂吃内存，而是将大部分数据存储到磁盘上。
  • LevelDb在存储数据时，是根据记录的key值有序存储的，就是说相邻的key值在存储文件中是依次顺序存储的，而应用可以自定义key大小比较函数，LevelDb会按照用户定义的比较函数依序存储这些记录。
  • LevelDb的操作接口很简单，基本操作包括写记录，读记录以及删除记录。也支持针对多条操作的原子批量操作。
  • LevelDb支持数据快照(snapshot)功能，使得读取操作不受写操作影响，可以在读操作过程中始终看到一致的数据。
  • LevelDb还支持数据压缩等操作，这对于减小存储空间以及增快IO效率都有直接的帮助。
  • 官方网站报道其随机写性能达到40万条记录每秒，而随机读性能达到6万条记录每秒。总体来说，LevelDb的写操作要大大快于读操作，而顺序读写操作则大大快于随机读写操作。

局限

  • 只能算作一个内存数据库，它里面装的数据无法跨进程跨机器共享。（这就需要靠包装技术了，在 LevelDB 内存数据库的基础上包装一层网络 API。当不同机器上不同的进程要来访问它时，都统一走网络 API 接口。这样就形成了一个简易的数据库。如果在网络层我们使用 Redis 协议来包装，那么使用 Redis 的客户端就可以读写这个数据库了）
  • 不支持索引
  • 不支持事务
  • 没有内置的C/S架构，但开发者可以使用LevelDB库自己封装一个server
  • 不具备“分布式”集群架构能力
  • 一次只允许一个进程访问一个特定的数据库
  • key和value数据尺寸不能太大，在KB级别，如果存储较大的key或者value，将对leveld的读写性能都有较大的影响。每个key所对应的内容不宜太大，超过32KB性能就会下降很快

JAVA使用LEVELDB

  • LevelDB 需要的依赖
    // https://mvnrepository.com/artifact/org.iq80.leveldb/leveldb
    compile group: 'org.iq80.leveldb', name: 'leveldb', version: '0.12'
    // https://mvnrepository.com/artifact/org.iq80.leveldb/leveldb-api
    compile group: 'org.iq80.leveldb', name: 'leveldb-api', version: '0.12'

LevelDB相关的操作

  • 小编我本地的磁盘路径(F:/LevelDBDemo/LevelDB1) 这路径后面代码上有用得到的


    image.png
写入操作
  • put(byte[] key, byte[] value)
  
    private static final Charset CHARSET = Charset.forName("utf-8");
    
    public static void main(String[] args) {
        //小编这里插入一条 key为LevelDBTest  values为LevelValues的数据
        put("LevelDBTest", "LevelValues", "F:/LevelDBDemo/LevelDB1");
    }

    /**
     * 写入磁盘
     * 
     * @param key
     * @param values
     * @param path 磁盘路径
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void put(String key, String values, String path) {
        DBFactory factory = new Iq80DBFactory();
        // 默认如果没有则创建
        Options options = new Options();
        File file = new File(path);
        DB db = null;
        try {
            db = factory.open(file, options);
            byte[] keyByte = key.getBytes(CHARSET);
            byte[] valuesBytes = values.getBytes(CHARSET);
            // 会写入磁盘中
            db.put(keyByte, valuesBytes);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

写入磁盘之后，看磁盘文件夹(本来空的文件夹多了几个文件)


image.png
获取数据
  • byte[] get(byte[] key)
    private static final Charset CHARSET = Charset.forName("utf-8");
    
    public static void main(String[] args) {
        //读取刚刚写入磁盘的数据
        String getValues = get("LevelDBTest","F:/LevelDBDemo/LevelDB1");
        System.err.println("getValues = "+getValues);
    }

    /**
     * 读取磁盘存储的数据
     * 
     * @param key
     * @param path 磁盘的路径
     * @return
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static String get(String key, String path) {
        DBFactory factory = new Iq80DBFactory();
        // 默认如果没有则创建
        Options options = new Options();
        File file = new File(path);
        DB db = null;
        try {
            db = factory.open(file, options);
            byte[] values = db.get(key.getBytes(CHARSET));
            if (null == values) {
                return null;
            }
            return new String(values, CHARSET);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
image.png
读取快照的数据

Snapshot snapshot = db.getSnapshot();

    private static final Charset CHARSET = Charset.forName("utf-8");
    
    public static void main(String[] args) {
        //用快照方式读取磁盘的数据
        readFromSnapshot("F:/LevelDBDemo/LevelDB1");
    }
    /**
     * 读取快照的数据
     * 
     * @param path 读取数据的磁盘路径
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void readFromSnapshot(String path) {
        DBFactory factory = new Iq80DBFactory();
        File file = new File(path);
        Options options = new Options();
        DB db = null;
        try {
            db = factory.open(file, options);
            // 读取当前快照，重启服务仍能读取，说明快照持久化至磁盘，
            // getSnapshot() 获取快照的方法 调用getSnapshot方法之后写入的数据，快照是没办法获取得到的
            Snapshot snapshot = db.getSnapshot();
            // 读取操作
            ReadOptions readOptions = new ReadOptions();
            readOptions.fillCache(false);// 读取的数据是否保存到memtable中 这里设置为false表示不保存memtable中
            // 默认snapshot为当前
            readOptions.snapshot(snapshot);
            DBIterator it = db.iterator(readOptions);
            while (it.hasNext()) {
                Map.Entry<byte[], byte[]> entry = (Map.Entry<byte[], byte[]>) it.next();
                String key = new String(entry.getKey(), CHARSET);
                String value = new String(entry.getValue(), CHARSET);
                System.err.println("snapshot_key = " + key + " snapshot_value =" + value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
image.png
读取快照的特点

Snapshot getSnapshot()
getSnapshot() 获取快照的方法 调用getSnapshot方法之后写入的数据，快照是没办法获取得到的

    private static final Charset CHARSET = Charset.forName("utf-8");
    
    public static void main(String[] args) {
        snapshot("F:/LevelDBDemo/LevelDB1");
    }
    /**
     * ReadOptions - Snapshot </BR>
     * 快照 数据存储获取(getSnapshot之前put的值，之后的无法获取，即读取期间数据的变更，不会反应出来)
     * 
     * @param path 读取的磁盘路径
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void snapshot(String path) {

        DBFactory factory = new Iq80DBFactory();
        Options options = new Options();
        DB db = null;
        File file = new File(path);
        try {
            db = factory.open(file, options);
            db.put("LevelDBTest-01".getBytes(CHARSET), "LevelValues-01".getBytes(CHARSET));
            // 只能之前到getSnapshot之前put的值，之后的无法获取，即读取期间数据的变更，不会反应出来
            Snapshot snapshot = db.getSnapshot();
            //小编在插入一条数据 明确getSnapshot之后插入的数据没办法获取的
            db.put("LevelDBTest-02".getBytes(CHARSET), "LevelDBTest-02".getBytes(CHARSET));
            ReadOptions readOptions = new ReadOptions();
            readOptions.fillCache(false);// 是否填充到缓存
            readOptions.snapshot(snapshot);
            DBIterator it = db.iterator(readOptions);
            while (it.hasNext()) {
                Map.Entry<byte[], byte[]> entry = (Map.Entry<byte[], byte[]>) it.next();
                String key = new String(entry.getKey(), CHARSET);
                String value = new String(entry.getValue(), CHARSET);
                System.err.println("key=" + key + " value=" + value);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
image.png
  • 明确了一点 key为LevelDBTest-02的数据是没有读取到的。
ReadOptions 读取数据

byte[] get(byte[] key, ReadOptions options)


    private static final Charset CHARSET = Charset.forName("utf-8");
    
    private static final String PATH="F:/LevelDBDemo/LevelDB1";
    
    public static void main(String[] args) {
        //小编在这里读取的是上面没有读取到的数据哦
        String readOptions = readOptionsTest("LevelDBTest-02", PATH);
        System.err.println("readOptions = "+readOptions); 
    }
     /**
     * ReadOptions 方式读取操作
     * 
     * @param key 
     * @param path 磁盘路径
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static String readOptionsTest(String key,String path) {
        DBFactory factory = new Iq80DBFactory();
        Options options = new Options();
        DB db = null;
        File file = new File(path);
        try {
            db = factory.open(file, options);
            ReadOptions readOptions = new ReadOptions();
            readOptions.fillCache(false);// 是否填充到缓存
            byte[] values = db.get(key.getBytes(CHARSET), readOptions);
            if(null == values) {
                return null;
            }
            return new String(values, CHARSET);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
image.png
WriteOptions方式写入操作

Snapshot put(byte[] key, byte[] value, WriteOptions options)

    /**
     * WriteOptions方式写入操作
     * 
     * @param key 
     * @param values 
     * @param path 写入的磁盘路径
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void writeOptionsTest(String key,String values,String path) {
        DBFactory factory = new Iq80DBFactory();
        Options options = new Options();
        DB db = null;
        File file = new File(path);
        try {
            db = factory.open(file, options);
            WriteOptions writeOptions = new WriteOptions().sync(true); // 线程安全
            db.put(key.getBytes(CHARSET), values.getBytes(CHARSET), writeOptions);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
删除方法

void delete(byte[] key)
这个删除方法有点坑的地方，它不是真实的磁盘删除，只是添加一个标识而已！

    /**
     * delete
     * 
     * @param key
     * @param path 磁盘路径
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void deleteTest(String key, String path) {
        DBFactory factory = new Iq80DBFactory();
        Options options = new Options();
        DB db = null;
        File file = new File(path);
        try {
            db = factory.open(file, options);
            // 存在会删除，之后查询不出，根据说明可能不是真删除，而是添加一个标记，待测试（大量数据之后删除，文件大小是否明显变化）
            db.delete(key.getBytes(CHARSET));
            // 不存在不会报错
            db.delete(key.getBytes(CHARSET));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
批量的修改和写入

WriteBatch put(byte[] key, byte[] value);
void write(WriteBatch updates)；

    /**
     * WriteBatch（批量操作-写入、修改）
     * 
     * @param path 操作的磁盘
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void writeBatchTest(String path) {
        DBFactory factory = Iq80DBFactory.factory;
        Options options = new Options();
        DB db = null;
        File file = new File(path);
        try {
            db = factory.open(file, options);
            // 批量保存，批量修改
            WriteBatch writeBatch = db.createWriteBatch();
            writeBatch.put("LevelDBTest-03".getBytes(CHARSET), "LevelValues-03".getBytes(CHARSET));
            writeBatch.put("LevelDBTest-04".getBytes(CHARSET), "LevelValues-03".getBytes(CHARSET));
            writeBatch.put("LevelDBTest-05".getBytes(CHARSET), "LevelValues-03".getBytes(CHARSET));
            // 这里也可以添加writeOptions
            db.write(writeBatch);
            writeBatch.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
批量删除操作

WriteBatch delete(byte[] key);
void write(WriteBatch updates)；

    /**
     * WriteBatch（批量操作-删除）
     * 
     * @param path
     * @bk https://home.cnblogs.com/u/huanuan/
     * @Author 六月星辰
     * @Date 2019年12月28日
     */
    public static void writeBatchDeleteTest(String path) {
        DBFactory factory = Iq80DBFactory.factory;
        Options options = new Options();
        DB db = null;
        File file = new File(path);
        try {
            db = factory.open(file, options);
            WriteBatch writeBatch = db.createWriteBatch();
            writeBatch.delete("LevelDBTest-03".getBytes(CHARSET));
            writeBatch.delete("LevelDBTest-04".getBytes(CHARSET));
            db.write(writeBatch);
            writeBatch.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (db != null) {
                try {
                    db.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

小编就写到这里了，希望能对你有用哦！

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • oracle错误集合
    ORA-00001: 违反唯一约束条件 (.) 错误说明：当在唯一索引所对应的列上键入重复值时，会触发此异常。 O...
    我想起个好名字阅读 5,500评论 0赞 9
  • [译]Bitcoin 之 levelDB
    Jeff Dean, Sanjay Ghemawat leveldb库提供了一个持久性的键值存储。 键和值是任意字...
    wolf4j阅读 2,190评论 0赞 2
  • Btcd区块的存取之ffldb
    介绍完BoltDB后，我们回到btcd/database[https://github.com/btcsuite/...
    oceanken阅读 1,706评论 0赞 5
  • 无标题文章
    # LevelDB简单介绍 ------ LevelDB是Google开源的持久化KV单机数据库，具有很高的随机写...
    ClimbYang阅读 571评论 0赞 0
  • 感恩180125
    1，我很感激，重新听了昨天的晚课回想昨天的聚会，我越来越确信：意识的创造力。 谢谢！谢谢！谢谢！ 2，我很感激，身...
    by_10阅读 219评论 0赞 1