分布式(5)数据存储 MongoDB/HBase/Redis比对与使用

最新推荐文章于 2024-04-06 22:20:19 发布
最新推荐文章于 2024-04-06 22:20:19 发布
阅读量760 收藏 1
点赞数 1
分类专栏： 分布式 文章标签： java 分布式 redis nosql
原文链接：https://www.cnblogs.com/vajoy/p/5471308.html
版权

nosql是我们在分布式开发中常用的中间件，不同类型适用于不同的业务场景，通过资料的整理对比方便我们后续开发过程中对中间件的选用

转载整理自

https://www.cnblogs.com/vajoy/p/5471308.html
https://www.cnblogs.com/RealWorld/p/9209687.html

文章目录

MongoDB/HBase/Redis应用场景场景

类型适用场景
MongoDB适用于数据读性能要求高，表结构变化大，数据规模较大、需要聚合查询的场景
HBase适用于大数据量持久化存储场景
Redis适用于读写要求高，数据量较小并且不需要持久化的场景

也可以考虑使用一些云上存储方案来解决一些数据存储的问题，比如阿里云的OSS、OTS

MongoDB

开源，无模式的文档型数据库，开发语言是C++。可用于替代传统的关系型数据库或键/值存储方式。

1.特点

1.1 数据格式
在 MongoDB 中，文档是对数据的抽象，它的表现形式就是我们常说的 BSON（Binary JSON ）。
BSON 是一个轻量级的二进制数据格式。MongoDB 能够使用 BSON，并将 BSON 作为数据的存储存放在磁盘中。
一个“文档”

{“name":"mengxiangyue","sex":"nan"}

对于文档是有一些限制的：有序、区分大小写的，所以下面的两个文档是与上面不同的：

{"sex":"nan","name":"mengxiangyue"}  
{"Name":"mengxiangyue","sex":"nan"}

另外，对于文档的字段 MongoDB 有如下的限制：
_id必须存在，如果你插入的文档中没有该字段，那么 MongoDB 会为该文档创建一个ObjectId作为其值。_id的值必须在本集合中是唯一的。
多个文档则组合为一个“集合”。在 MongoDB 中的集合是无模式的，也就是说集合中存储的文档的结构可以是不同的，比如下面的两个文档可以同时存入到一个集合中：

{"name":"mengxiangyue"}  
{"Name":"mengxiangyue","sex":"nan"}

1.2 性能
MongoDB 目前支持的存储引擎为内存映射引擎。当 MongoDB 启动的时候，会将所有的数据文件映射到内存中，然后操作系统会托管所有的磁盘操作。这种存储引擎有以下几种特点：

  • MongoDB 中关于内存管理的代码非常精简，毕竟相关的工作已经有操作系统进行托管。
  • MongoDB 服务器使用的虚拟内存将非常巨大，并将超过整个数据文件的大小。
    另外，MongoDB 提供了全索引支持：包括文档内嵌对象及数组。Mongo的查询优化器会分析查询表达式，并生成一个高效的查询计划。通常能够极大的提高查询的效率。

1.3 持久化
MongoDB 在1.8版本之后开始支持 journal，就是我们常说的 redo log，用于故障恢复和持久化。
当系统启动时，MongoDB 会将数据文件映射到一块内存区域，称之为Shared view，在不开启 journal 的系统中，数据直接写入shared view，然后返回，系统每60s刷新这块内存到磁盘，这样，如果断电或down机，就会丢失很多内存中未持久化的数据。
当系统开启了 journal 功能，系统会再映射一块内存区域供 journal 使用，称之为 private view，MongoDB 默认每100ms刷新 privateView 到 journal，也就是说，断电或宕机，有可能丢失这100ms数据，一般都是可以忍受的，如果不能忍受，那就用程序写log吧（但开启journal后使用的虚拟内存是之前的两倍）。
1.4 CAP类别
MongoDB 比较灵活，可以设置成 strong consistent （CP类型）或者 eventual consistent（AP类型）。
默认是 CP 类型

2.java使用

pom.xml

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver</artifactId>
    <version>3.12.8</version>
</dependency>

demo

public class MongoDBJDBC {
    public static void main(String args[]) {
        try {
            /**
            // 连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
            // ServerAddress()两个参数分别为 服务器地址 和 端口
            ServerAddress serverAddress = new ServerAddress("localhost", 27017);
            List<ServerAddress> addrs = new ArrayList<ServerAddress>();
            addrs.add(serverAddress);
 
            // MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
            MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());
            List<MongoCredential> credentials = new ArrayList<MongoCredential>();
            credentials.add(credential);
            // 通过连接认证获取MongoDB连接
            MongoClient mongoClient = new MongoClient(addrs, credentials);
            **/
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("172.22.25.14", 27017);
            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            // 集合创建
            mongoDatabase.createCollection("test");
            // 集合 test 选择
            MongoCollection<Document> collection = mongoDatabase.getCollection("test");
            // 插入文档
            /**
             * 1. 创建文档 org.bson.Document 参数为key-value的格式
             * 2. 创建文档集合List<Document>
             * 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>)
             * 插入单个文档可以用 mongoCollection.insertOne(Document)
             */
            Document document = new Document("title", "MongoDB").append("description", "database").append("likes", 100).append("by", "Fly");
            List<Document> documents = new ArrayList<Document>();
            documents.add(document);
            collection.insertMany(documents);
            System.out.println("文档插入成功");
             
            // 检索所有文档
            /**
             * 1. 获取迭代器FindIterable<Document>
             * 2. 获取游标MongoCursor<Document>
             * 3. 通过游标遍历检索出的文档集合
             */
            FindIterable<Document> findIterable = collection.find();
            MongoCursor<Document> mongoCursor = findIterable.iterator();
            while (mongoCursor.hasNext()) {
                System.out.println(mongoCursor.next());
            }
 
            // 更新文档 将文档中likes=100的文档修改为likes=200
            collection.updateMany(Filters.eq("likes", 100), new Document("$set", new Document("likes", 200)));
 
            // 删除符合条件的第一个文档
            collection.deleteOne(Filters.eq("likes", 200));
            // 删除所有符合条件的文档
            collection.deleteMany(Filters.eq("likes", 200));
        }
        catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }
}
3.优缺点

优势

  1. 强大的自动化shading功能，可以快速实现数据复制和节点伸缩
  2. 快速的查询，MongoDB支持二维空间索引，比如管道，因此可以快速及精确的从指定位置
    获取数据。MongoDB在启动后会将数据库中的数据以文件映射的方式加载到内存中。如果内存资源充足的话，这将极大地提高数据库的查询速度。
  3. 非结构化数据的爆发增长，增加列在有些情况下可能锁定整个数据库，或者增加负载从而
    导致性能下降，由于MongoDB的弱数据结构模式，添加1个新字段不会对旧表格有任何影响， 整个过程会非常快速。
  4. 支持动态查询，查询指令也使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。

缺点

  1. 单个文档大小限制为16M，32位系统上，不支持大于2.5G的数据；
  2. 对内存要求比较大，至少要保证热数据（索引，数据及系统其它开销）都能装进内存；
  3. 非事务机制，无法保证事件的原子性。

适用场景

  1. 适用于实时的插入、更新与查询的需求，并具备应用程序实时数据存储所需的复制及高度伸缩性。
  2. 非常适合文档化(json)格式的存储及查询。
  3. 高伸缩性的场景。
  4. 对性能的关注超过对功能的要求。

HBase

HBase 是 Apache Hadoop 中的一个子项目，属于 bigtable 的开源版本，所实现的语言为Java（故依赖 Java SDK）。HBase 依托于 Hadoop 的 HDFS（分布式文件系统）作为最基本存储基础单元。
HBase在列上实现了 BigTable 论文提到的压缩算法、内存操作和布隆过滤器。HBase的表能够作为 MapReduce 任务的输入和输出，可以通过Java API来访问数据，也可以通过REST、Avro或者Thrift的API来访问。

1. 特点

1.1 数据格式
HBash 的数据存储是基于列（ColumnFamily）的，且非常松散—— 不同于传统的关系型数据库（RDBMS），HBase 允许表下某行某列值为空时不做任何存储（也不占位），减少了空间占用也提高了读性能。
使用关系型数据库（RDBMS）和 HBase 对比：
⑴ RDBMS方案：

其中Article表格式：

Author表格式：

⑵ 等价的HBase方案：

1.2 性能
HStore存储是HBase存储的核心，它由两部分组成，一部分是MemStore，一部分是StoreFiles。
MemStore 是 Sorted Memory Buffer，用户写入的数据首先会放入MemStore，当MemStore满了以后会Flush成一个StoreFile（底层实现是HFile），当StoreFile文件数量增长到一定阈值，会触发Compact合并操作，将多个StoreFiles合并成一个StoreFile，合并过程中会进行版本合并和数据删除，因此可以看出HBase其实只有增加数据，所有的更新和删除操作都是在后续的compact过程中进行的，这使得用户的写操作只要进入内存中就可以立即返回，保证了HBase I/O的高性能。
1.3 数据版本
Hbase 还能直接检索到往昔版本的数据，这意味着我们更新数据时，旧数据并没有即时被清除，而是保留着：
Hbase 中通过 row+columns 所指定的一个存贮单元称为cell。每个 cell都保存着同一份数据的多个版本——版本通过时间戳来索引。
时间戳的类型是 64位整型。时间戳可以由Hbase(在数据写入时自动 )赋值，此时时间戳是精确到毫秒的当前系统时间。时间戳也可以由客户显式赋值。如果应用程序要避免数据版本冲突，就必须自己生成具有唯一性的时间戳。每个 cell中，不同版本的数据按照时间倒序排序，即最新的数据排在最前面。
为了避免数据存在过多版本造成的的管理 (包括存贮和索引)负担，Hbase提供了两种数据版本回收方式。一是保存数据的最后n个版本，二是保存最近一段时间内的版本(比如最近七天)。用户可以针对每个列族进行设置。
1.4 CAP类别
属于CP类型

2.java使用

HBase的相关操作可参考下表：

pom.xml

<dependency>
   <groupId>org.apache.hbase</groupId>
   <artifactId>hbase-client</artifactId>
   <version>1.3.1</version>
</dependency>
<dependency>
   <groupId>org.apache.hbase</groupId>
   <artifactId>hbase-server</artifactId>
   <version>1.3.1</version>
</dependency>
<dependency>
   <groupId>org.apache.hbase</groupId>
   <artifactId>hbase-common</artifactId>
   <version>1.3.1</version>
</dependency>

code

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import java.io.IOException;

public class ExampleForHbase {
    public static Configuration configuration;
    public static Connection connection;
    public static Admin admin;

    //主函数中的语句请逐句执行，只需删除其前的//即可，如：执行insertRow时请将其他语句注释
    public static void main(String[] args)throws IOException{
        //创建一个表，表名为Score，列族为sname,course
        //createTable("Score",new String[]{"sname","course"});

        //在Score表中插入一条数据，其行键为95001,sname为Mary（因为sname列族下没有子列所以第四个参数为空）
        //等价命令：put 'Score','95001','sname','Mary'
        insertRow("Score", "95001", "sname", "", "Mary");
        //在Score表中插入一条数据，其行键为95001,course:Math为88（course为列族，Math为course下的子列）
        //等价命令：put 'Score','95001','score:Math','88'
        //insertRow("Score", "95001", "course", "Math", "88");
        //在Score表中插入一条数据，其行键为95001,course:English为85（course为列族，English为course下的子列）
        //等价命令：put 'Score','95001','score:English','85'
        //insertRow("Score", "95001", "course", "English", "85");

        //1、删除Score表中指定列数据，其行键为95001,列族为course，列为Math
        //执行这句代码前请deleteRow方法的定义中，将删除指定列数据的代码取消注释注释，将删除制定列族的代码注释
        //等价命令：delete 'Score','95001','score:Math'
        //deleteRow("Score", "95001", "course", "Math");

        //2、删除Score表中指定列族数据，其行键为95001,列族为course（95001的Math和English的值都会被删除）
        //执行这句代码前请deleteRow方法的定义中，将删除指定列数据的代码注释，将删除制定列族的代码取消注释
        //等价命令：delete 'Score','95001','score'
        //deleteRow("Score", "95001", "course", "");

        //3、删除Score表中指定行数据，其行键为95001
        //执行这句代码前请deleteRow方法的定义中，将删除指定列数据的代码注释，以及将删除制定列族的代码注释
        //等价命令：deleteall 'Score','95001'
        //deleteRow("Score", "95001", "", "");

        //查询Score表中，行键为95001，列族为course，列为Math的值
        //getData("Score", "95001", "course", "Math");
        //查询Score表中，行键为95001，列族为sname的值（因为sname列族下没有子列所以第四个参数为空）
        //getData("Score", "95001", "sname", "");

        //删除Score表
        //deleteTable("Score");
    }

    //建立连接
    public static void init(){
        configuration  = HBaseConfiguration.create();
        configuration.set("hbase.rootdir","hdfs://localhost:9000/hbase");
        try{
            connection = ConnectionFactory.createConnection(configuration);
            admin = connection.getAdmin();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    //关闭连接
    public static void close(){
        try{
            if(admin != null){
                admin.close();
            }
            if(null != connection){
                connection.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    /**
     * 建表。HBase的表中会有一个系统默认的属性作为主键，主键无需自行创建，默认为put命令操作中表名后第一个数据，因此此处无需创建id列
     * @param myTableName 表名
     * @param colFamily 列族名
     * @throws IOException
     */
    public static void createTable(String myTableName,String[] colFamily) throws IOException {

        init();
        TableName tableName = TableName.valueOf(myTableName);

        if(admin.tableExists(tableName)){
            System.out.println("talbe is exists!");
        }else {
            HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
            for(String str:colFamily){
                HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(str);
                hTableDescriptor.addFamily(hColumnDescriptor);
            }
            admin.createTable(hTableDescriptor);
            System.out.println("create table success");
        }
        close();
    }
    /**
     * 删除指定表
     * @param tableName 表名
     * @throws IOException
     */
    public static void deleteTable(String tableName) throws IOException {
        init();
        TableName tn = TableName.valueOf(tableName);
        if (admin.tableExists(tn)) {
            admin.disableTable(tn);
            admin.deleteTable(tn);
        }
        close();
    }

    /**
     * 查看已有表
     * @throws IOException
     */
    public static void listTables() throws IOException {
        init();
        HTableDescriptor hTableDescriptors[] = admin.listTables();
        for(HTableDescriptor hTableDescriptor :hTableDescriptors){
            System.out.println(hTableDescriptor.getNameAsString());
        }
        close();
    }
    /**
     * 向某一行的某一列插入数据
     * @param tableName 表名
     * @param rowKey 行键
     * @param colFamily 列族名
     * @param col 列名（如果其列族下没有子列，此参数可为空）
     * @param val 值
     * @throws IOException
     */
    public static void insertRow(String tableName,String rowKey,String colFamily,String col,String val) throws IOException {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Put put = new Put(rowKey.getBytes());
        put.addColumn(colFamily.getBytes(), col.getBytes(), val.getBytes());
        table.put(put);
        table.close();
        close();
    }

    /**
     * 删除数据
     * @param tableName 表名
     * @param rowKey 行键
     * @param colFamily 列族名
     * @param col 列名
     * @throws IOException
     */
    public static void deleteRow(String tableName,String rowKey,String colFamily,String col) throws IOException {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(rowKey.getBytes());
        //删除指定列族的所有数据
        //delete.addFamily(colFamily.getBytes());
        //删除指定列的数据
        //delete.addColumn(colFamily.getBytes(), col.getBytes());

        table.delete(delete);
        table.close();
        close();
    }
    /**
     * 根据行键rowkey查找数据
     * @param tableName 表名
     * @param rowKey 行键
     * @param colFamily 列族名
     * @param col 列名
     * @throws IOException
     */
    public static void getData(String tableName,String rowKey,String colFamily,String col)throws  IOException{
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Get get = new Get(rowKey.getBytes());
        get.addColumn(colFamily.getBytes(),col.getBytes());
        Result result = table.get(get);
        showCell(result);
        table.close();
        close();
    }
    /**
     * 格式化输出
     * @param result
     */
    public static void showCell(Result result){
        Cell[] cells = result.rawCells();
        for(Cell cell:cells){
            System.out.println("RowName:"+new String(CellUtil.cloneRow(cell))+" ");
            System.out.println("Timetamp:"+cell.getTimestamp()+" ");
            System.out.println("column Family:"+new String(CellUtil.cloneFamily(cell))+" ");
            System.out.println("row Name:"+new String(CellUtil.cloneQualifier(cell))+" ");
            System.out.println("value:"+new String(CellUtil.cloneValue(cell))+" ");
        }
    }
}
3.优缺点

优点

  1. 存储容量大，一个表可以容纳上亿行，上百万列。
  2. 可通过版本进行检索，能搜到所需的历史版本数据。
  3. 负载高时，可通过简单的添加机器来实现水平切分扩展，跟Hadoop的无缝集成保障了其数据可靠性（HDFS）和海量数据分析的高性能（MapReduce)。
  4. 在第3点的基础上可有效避免单点故障的发生。

缺点

  1. 基于Java语言实现及Hadoop架构意味着其API更适用于Java项目；
  2. 占用内存很大，且鉴于建立在为批量分析而优化的HDFS上，导致读取性能不高。
  3. API相比其它 NoSql 的相对笨拙。

适用场景

  • bigtable类型的数据存储。
  • 对数据有版本查询需求。
  • 应对超大数据量要求扩展简单的需求。

Redis

Redis 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

1.特点

1.1 数据格式
Redis 通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Hash/Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)五种类型，操作非常方便。比如，如果你在做好友系统，查看自己的好友关系，如果采用其他的key-value系统，则必须把对应的好友拼接成字符串，然后在提取好友时，再把value进行解析，而redis则相对简单，直接支持list的存储(采用双向链表或者压缩链表的存储方式)。
我们来看下这五种数据类型。
⑴ String

  • string 是 Redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个key对应一个value。
  • string 类型是二进制安全的。意思是 Redis 的 string 可以包含任何数据。比如 jpg 图片或者序列化的对象 。
  • string 类型是 Redis 最基本的数据类型，一个键最大能存储512MB。

实例：

redis 127.0.0.1:6379> SET name zfpx
OK
redis 127.0.0.1:6379> GET name"zfpx"

在以上实例中我们使用了 Redis 的 SET 和 GET 命令。键为 name，对应的值为"zfpx"。 注意：一个键最大能存储512MB。
⑵ Hash

  • Redis hash 是一个键值对集合。
  • Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

实例：

redis 127.0.0.1:6379> HMSET user:1 username zfpx password 123
OK
redis 127.0.0.1:6379> HGETALL user:11) "username"2) "zfpx"3) "password"4) "123"

以上实例中 hash 数据类型存储了包含用户脚本信息的用户对象。 实例中我们使用了 Redis HMSET, HGETALL 命令，user:1 为键值。 每个 hash 可以存储 232 - 1 键值对（40多亿）。
⑶ List
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。
实例：

redis 127.0.0.1:6379> lpush name zfpx1
(integer) 1
redis 127.0.0.1:6379> lpush name zfpx2
(integer) 2
redis 127.0.0.1:6379> lpush name zfpx3
(integer) 3
redis 127.0.0.1:6379> lrange name 0 -11) "zfpx3"2) "zfpx2"3) "zfpx1"

列表最多可存储 232 - 1 元素 (4294967295, 每个列表可存储40多亿)。
⑷ Sets
Redis的Set是string类型的无序集合。 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
添加一个string元素到 key 对应的 set 集合中，成功返回1，如果元素已经在集合中返回0，key对应的set不存在返回错误，指令格式为

sadd key member

实例：

redis 127.0.0.1:6379> sadd school zfpx1
(integer) 1
redis 127.0.0.1:6379> sadd school zfpx1
(integer) 0
redis 127.0.0.1:6379> sadd school zfpx2
(integer) 1
redis 127.0.0.1:6379> sadd school zfpx2
(integer) 0
redis 127.0.0.1:6379> smembers school
1) "zfpx1"2) "zfpx2"

注意：以上实例中 zfpx1 添加了两次，但根据集合内元素的唯一性，第二次插入的元素将被忽略。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
⑸ sorted sets/zset
Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
zset的成员是唯一的,但分数(score)却可以重复。可以通过 zadd 命令（格式如下） 添加元素到集合，若元素在集合中存在则更新对应score

zadd key score member

实例：

redis 127.0.0.1:6379> zadd school 0 zfpx1
(integer) 1
redis 127.0.0.1:6379> zadd school 2 zfpx2
(integer) 1
redis 127.0.0.1:6379> zadd school 0 zfpx3
(integer) 1
redis 127.0.0.1:6379> zadd school 1 zfpx4
(integer) 0
redis 127.0.0.1:6379> ZRANGEBYSCORE school 0 100
1) "zfpx1"2) "zfpx3"3) "zfpx4"4) "zfpx2"

1.2 性能
Redis数据库完全在内存中，因此处理速度非常快，每秒能执行约11万集合，每秒约81000+条记录（测试数据的可参考这篇《Redis千万级的数据量的性能测试》）。
Redis的数据能确保一致性——所有Redis操作是原子性（Atomicity，意味着操作的不可再分，要么执行要么不执行）的，这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。
1.3 持久化
通过定时快照（snapshot）和基于语句的追加（AppendOnlyFile，aof）两种方式，redis可以支持数据持久化——将内存中的数据存储到磁盘上，方便在宕机等突发情况下快速恢复。
1.4 CAP类别
属于CP类型

2.java使用

redis单机-哨兵-集群云服务器环境搭建、原理说明及springboot2.0的调用

3.优缺点

优势

  1. 非常丰富的数据结构；
  2. Redis提供了事务的功能，可以保证一串 命令的原子性，中间不会被任何操作打断；
  3. 数据存在内存中，读写非常的高速，可以达到10w/s的频率。

缺点

  1. 持久化功能体验不佳——通过快照方法实现的话，需要每隔一段时间将整个数据库的数据写到磁盘上，代价非常高；而aof方法只追踪变化的数据，类似于mysql的binlog方法，但追加log可能过大，同时所有操作均要重新执行一遍，恢复速度慢；
  2. 由于是内存数据库，所以，单台机器，存储的数据量，跟机器本身的内存大小。虽然redis本身有key过期策略，但是还是需要提前预估和节约内存。如果内存增长过快，需要定期删除数据。

适用场景

  1. 适用于数据变化快且数据库大小可遇见（适合内存容量）的应用程序。
言一木
关注
专栏目录
Fabric中LevelDB转CouchDB
qq_39087834的博客
09-18 1958
介绍 在 Hyperledger Fabric 项目中，目前可以支持的状态数据库有两种： LevelDB：LevelDB 是嵌入在 Peer 中的默认键值对（key-value）状态数据库。 CouchDB：CouchDB 是一种可选的替代 LevelDB 的状态数据库。与 LevelDB 键值存储一样，CouchDB 不仅可以根据 key 进行相应的查询，还可以根据不同的应用场景需求实现复杂查询。 本文环境：centos7 实现 1、编写链码 下面使用 CouchDB 容器来实现对 CouchDB
leveldb mysql 比较_leveldb/rocksdb对比
weixin_39662462的博客
01-19 1496
本篇介绍典型的基于SStable的存储。适用于与SSD一起使用。更多存储相关见：https://segmentfault.com/a/11...。涉及到leveldb,rocksdb。基本上分布式都要单独做，重点是单机架构，数据写入，合并，ACID等功能和性能相关的。先对性能有个直观认识：mysql写入千条/s，读万应该没问题。redis 写入 万条/s 7M/s(k+v 700bytes，双核)...
在 HBase、Redis、MongoDB、Couchbase、LevelDB 五款较主流的数据库产品中，本文将主要对它们进行分析对比。
yilvyangguang520的博客
09-02 1257
在 HBase、Redis、MongoDB、Couchbase、LevelDB 五款较主流的数据库产品中，本文将主要对它们进行分析对比。 鉴于缺乏项目中的实战经验沉淀，本文内容和观点主要还是从各平台资料搜罗汇总，也不会有太多深入或底层原理探讨。 本文所引用的资料来源将示于本文尾部。所汇总的内容仅供参考，若有异议望指正。 &nb...
【图文详解】一文全面彻底搞懂HBase、LevelDB、RocksDB等NoSQL背后的存储原理：LSM-tree日志结构合并树...
AI天才研究院
11-21 9920
LSM 树广泛用于数据存储，例如 RocksDB、Apache AsterixDB、Bigtable、HBase、LevelDB、Apache Accumulo、SQLite4、Tarantool、WiredTiger、Apache Cassandra、InfluxDB和ScyllaDB等。在这篇文章中，我们将深入探讨 Log Structured Merge Tree ，又名 LSM 树：许多高...
Leveldb lmdb性能对比
wuhuaiyu的专栏
07-16 5333
测试机环境： 96G内存 433G*5SSD 内核：2.6.32_1-15-0-0 磁盘调度算法：noop 结论： 1. lmdb的数据膨胀率大约为leveldb的1.5-1.8倍之间，需与comdb对比 2. lmdb在单盘5M写入状态下仍能满足要求（leveldb不能）： Percentile Latency(max la...
聊聊MongoDB（一）：MongoDB体系结构与底层原理
热门推荐
01-07 1万+
MongoDB体系结构与底层原理前言MongoDB体系结构NoSQL 和 MongoDBMongoDB 和RDBMS(关系型数据库)对比什么是BSONBSON在MongoDB中的使用MongoDB索引Index索引类型MongoDB 索引底层实现原理分析MongoDB架构MongoDB逻辑结构MongoDB的数据模型描述数据模型如何选择数据模型MongoDB 存储引擎存储引擎概述WiredTiger存储引擎优势WiredTiger引擎包含的文件和作用WiredTiger存储引擎实现原理写请求checkpoi
数仓体系与数据治理全集
最新发布
weixin_44687655的博客
04-06 3372
数据仓库（Data Warehouse），可简写为DW或DWH。数据仓库，是为企业所有级别的决策制定过程，提供所有类型数据支持的战略集合。它出于分析性报告和决策支持目的而创建。
Redis(上)
雙馬程序猿
11-30 213
Redis(上)：1.Nosql概述、2.Redis入门、3.五大数据类型、4.三种特殊数据类型、5.事务与监控、6.Jedis
第一章 Redis基础(简介+下载和安装+基本操作)----黑马
无
05-03 382
目标1：能够说出NoSQL的概念，redis的应用场景，能够完成redis的下载安装与启动以及一些常用的配置 目标2：能够说出redis常用的5种数据类型，对应这些数据类型的基本操作，应用场景及对应的解决方案 目标3：能够说出redis中常用的一些基本指令 目标4：能够使用jedis完成客户端应用程序的开发 目标5：能够说出redis数据持久化的两种方式，各自相关的操作配置及指令，以及两种方式的优缺点比较......
程序设计-“考试系统”——数据存储问题.pptx
11-06
可以使用关系型数据库（如MySQL）或NoSQL数据库（如MongoDB）来存储这些信息，确保数据安全性和一致性。 2. **试题库管理**：试题是考试系统的核心资源，需要存储题干、选项、正确答案等信息。考虑到试题可能包含...
HBase、Redis、MongoDB、Couchbase、LevelDB对比.pdf
08-14
HBase、Redis、MongoDB、Couchbase、LevelDB对比
LevelDB、TreeDB、SQLite3性能对比测试
Fybon的专栏
07-09 4986
from : http://blog.nosqlfan.com/html/2819.html 下面性能测试对比来自LevelDB官方，由 NoSQLFan 进行翻译整理。从结果上看，这不像某些田忌赛马式的性能对比，总体来说还是比较客观全面。通过多种场景下的不同性能测试结果的对比，我们也能对这三个数据库分别擅长和适用的场合有所了解。同时对其性能调优的方法理解也有一定的帮助。 原文链接
levelDB rocksDB和tikv的优点和缺点对比
wade1010的专栏
08-10 441
综上所述，LevelDB适用于小规模的本地数据存储，RocksDB适用于较大规模的本地数据存储，TiKV适用于大规模的分布式数据存储和计算。不同的应用场景需要根据具体需求选择适合的存储引擎。
fabric中couchdb和leveldb混合使用的问题
u012504213的博客
01-25 1万+
文章目录背景分析总结 背景 ​ 在同一个通道中，同时使用couchdb和leveldb的peer，在执行多节点背书或者查询时，sdk可能会报错mismatch。 分析 ​ 起初以为是couchdb会自动修改json的字段顺序为字母顺序，当时还在心里大骂couchdb。自己写了一个客户端尝试写入kv到couchdb，查询的结果字段顺序并无变化，只能怀疑是fabric自己做了额外排序。 ​ 果不其然，fabric对json做了unmarshal。因为jsonMap是map[string]interface{}，
redis\memcahce\mongodb\leveldb总结
ws1296931325的博客
03-10 1046
redis memcache mongodb leveldb 简要介绍 Redis为单进程单线程模式，采用队列模式将并发访问变为串行访问。 Redis本身没有锁的概念，Redis对于多个客户端连接并不存在竞争， 但是在Jedis客户端对Redis进行并发访问时会发生连接超时、数据转换错误、阻塞、客户端关闭连接等问题，这些问题均是由于客户端连接混乱造...
fabric state 数据库由levelDB改为couchDB
xxzjwdnlwx的专栏
05-04 4387
CouchDB安装下面我们来说一说这个CouchDB。CouchDB是一个完全局域RESTful API的键值数据库，也就是说我们不需要任何客户端，只需要通过HTTP请求就可以操作数据库了。LevelDB是Peer的本地数据库，那么肯定是和Peer一对一的关系，那么CouchDB是个网络数据库，应该和Peer是什么样一个关系呢？在生产环境中，我们会为每个组织部署节点，而且为了高可用，可能会在一个组...
HBase、Redis、MongoDB、Couchbase、LevelDB主流 NoSQL 数据库的对比（二）
weixin_33913332的博客
11-17 259
==================================================MongoDBMongoDB 是一个高性能，开源，无模式的文档型数据库，开发语言是C++。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式。1.特点1.1 数据格式在 MongoDB 中，文档是对数据的抽象，它的表现形式就是我们常说的 BSON（Binary JSON...
Redis 内存高速缓存数据库（一）——Redis知识理解
麒麟阁
09-18 5279
NoSQL和关系型数据库区别 NoSQL非关系型数据库：Redis、MongoDB、HBase等，基于Key-Value存储，采用命令操作 关系型数据库：Oracle、MySQL、DB2、SQLServer等，基于表结构存储，采用SQL操作 Redis简介 Reidis是由意大利人 Salvatore Sanfilippo（网名：antirez）开发的一款内...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值