【HBase】HBase项目：简易微博案例

最新推荐文章于 2024-04-26 16:31:32 发布
最新推荐文章于 2024-04-26 16:31:32 发布
阅读量1.1k 收藏 20
点赞数 4
分类专栏： HBase 文章标签： hadoop linux hbase java hdfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tiezhu_Wang/article/details/114636027
版权

此文章介绍了Java连接HBase数据库实现的微博案例，以及程序的简单测试。

0 前期准备

Hadoop安装：https://blog.csdn.net/Tiezhu_Wang/article/details/113860404
HBase安装：https://blog.csdn.net/Tiezhu_Wang/article/details/114574899

1 HBase数据库表设计

需求：

  • 发布微博内容
    • 在微博内容表中 添加一条数据（发布者）
    • 在微博内容接收邮件箱表对所有粉丝用户添加数据（订阅者）
  • 添加关注用户
    • 在微博用户关系表中 添加新的好友关注(attends)
    • 从被关注用户角度来说， 新增粉丝用户（fans）
    • 微博邮件箱表添加关注用户发布的微博内容
  • 移除或者取消关注用户
    • 在微博用户关系表中 移除新的好友关注(attends)
    • 从被关注用户角度来说， 删除粉丝用户(fans)
    • 微博邮件箱表删除关注用户发布的微博内容
  • 获取关注用户发布的微博内容
    • 从微博内容邮件表中获取该用户其关注用户的微博内容的rowkey
    • 根据上面获取到的微博内容的rowkey 获取微博内容
  • 微博展示的内容信息：
    • message: 发布者ID , 时间戳 , content

1.1 user表

ROWKEY COLUMN+CELL
info
useridpasswordnickname

1.2 blog表

ROWKEY COLUMN+CELL
info
blogiduseridcontent

1.3 email表

ROWKEY COLUMN+CELL
info
emailidattendiduseridblogrowKey

1.4 relation表

ROWKEY COLUMN+CELL
info
relationiduseridattendidfanid

2 项目依赖

新建Maven项目，添加如下依赖：

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.6.5</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.6.5</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.6.5</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-it</artifactId>
            <version>1.2.0</version>
        </dependency>

3 实体类

User类的属性：userid、password、nickname
Blog类的属性：userid、date、content

4 基本工具类BaseMapper

考虑HBase数据库的命名空间、初始化、终止等，进行BaseMapper类的编写，实现的基本操作和代码如下：

package dao;

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

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

	// 1. 初始化
    public 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();
        }
    }
	
	// 2. 关闭
    public void close(){
        try{
            if(admin != null){
                admin.close();
            }
            if(null != connection){
                connection.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

	// 3. 创建表
    public void createTable(String myTableName,String[] colFamily) throws IOException {
        TableName tableName = TableName.valueOf(myTableName);
        if(admin.tableExists(tableName)){
            System.out.println("table exists!");
        }else {
            TableDescriptorBuilder tableDescriptor = TableDescriptorBuilder.newBuilder(tableName);
            for(String str:colFamily){
                ColumnFamilyDescriptor family =
                        ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(str)).build();
                tableDescriptor.setColumnFamily(family);
            }
            admin.createTable(tableDescriptor.build());
        }
    }

	// 4. 插入数据
    public void insertData(String tableName,String rowKey,String colFamily,String col,String val) throws IOException, InterruptedException {
        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();
        Thread.sleep(1);
    }

	// 5. 删除数据
    public void deleteData(String tableName, String rowKey) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        table.delete(delete);
    }

	// 6. 获取某个cell内的数据
    public String getData(String tableName,String rowKey,String colFamily, String col)throws Exception{
        Table table = connection.getTable(TableName.valueOf(tableName));
        Get get = new Get(rowKey.getBytes());
        get.addColumn(colFamily.getBytes(),col.getBytes());
        Result result = table.get(get);
        table.close();
        return new String(result.getValue(colFamily.getBytes(),col==null?null:col.getBytes()));
    }

	// 7. 获取整个表中所有数据
	// 注：由于此项目数据量较少，就使用此方法获取所需的数据
    public List<Map<String, String>> getAllData(String tableName) throws Exception {
        Table table = connection.getTable(TableName.valueOf(tableName));
        List<Map<String, String>> data = new ArrayList<Map<String, String>>();
        ResultScanner results = table.getScanner(new Scan());
        for(Result result : results){
            Map<String, String> singleData = new HashMap<String, String>();
            String rowKey = "";
            String date = "";
            for(Cell cell : result.rawCells()){
                if(rowKey.equals("")){
                    rowKey = Bytes.toString(cell.getRowArray(),cell.getRowOffset(),cell.getRowLength());
                    date = new Date(cell.getTimestamp()) + "";
                }
                String colName = Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
                String value = Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());
                singleData.put(colName,value);
            }
            singleData.put("rowKey",rowKey);
            singleData.put("date",date);
            data.add(singleData);
        }

        return data;
    }

	// 8. 获取某行数据
    public Map<String, String> getRow(String tableName, String rowKey) throws Exception {
        Table table = connection.getTable(TableName.valueOf(tableName));
        Map<String, String> data = new HashMap<String,String>();
        Get get = new Get(rowKey.getBytes());
        if(!get.isCheckExistenceOnly()){
            Result result = table.get(get);
            String date = "";
            for(Cell cell : result.rawCells()){
                if(date.equals("")){
                    date = new Date(cell.getTimestamp())+"";
                }
                String colName = Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
                String value = Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());
                data.put(colName,value);
            }
            data.put("rowKey",rowKey);
            data.put("date",date);
        }

        return data;
    }

}

5 基本操作类BlogMapper

此处的基本操作类包含需求中详细步骤的实现方法，如添加微博、添加邮件等，其中实体类Blog和User的定义略去，这个BlogMapper类继承自上述BaseMapper类。实现的方法和代码如下：

package dao;

import pojo.Blog;
import pojo.User;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class BlogMapper extends BaseMapper{

    public BlogMapper(){
        this.init();
    }

    /**
     * @param tableName
     * @param colFamily
     * @throws IOException
     */
    public void createTable(String tableName,String colFamily) throws IOException {
        this.createTable(tableName,new String[]{colFamily});
    }

    /**
     * @param userid
     * @param password
     * @param nickname
     * @throws IOException
     */
    public void addUser(String userid,String password,String nickname) throws IOException, InterruptedException {
        this.insertData("user",userid,"info","password",password);
        this.insertData("user",userid,"info","nickname",nickname);
    }

    /**
     * @param rowKey mighe be the time
     * @param userid is the userid of the one posting the blog
     * @param content is what the blog is
     * @throws IOException
     */
    public void addBlog(String rowKey,String userid,String content) throws IOException, InterruptedException {
        this.insertData("blog",rowKey,"info","userid",userid);
        this.insertData("blog",rowKey,"info","content",content);
    }

    /**
     * @param rowKey might be the time
     * @param attendid is whom the user attends
     * @param userid is the attender's fan
     * @param blogrowKey belongs to the attender
     * @throws IOException
     *
     * Thinking I have a fan named A.
     * If I post a blog, then my userid is the attendid and A's userid is the userid.
     */
    public void addEmail(String rowKey,String attendid, String userid, String blogrowKey) throws IOException, InterruptedException {
        this.insertData("email",rowKey,"info","attendid",attendid);
        this.insertData("email",rowKey,"info","userid",userid);
        this.insertData("email",rowKey,"info","blogrowKey",blogrowKey);
    }


    /**
     * @param rowKey
     * @param userid
     * @param attendid
     * @param fanid
     * @throws IOException
     *
     * The attendid and the fanid must be the same if two users attend eacher other.
     * Otherwise, one of them is none or both are none.
     */
    public void addRelation(String rowKey,String userid,String attendid,String fanid) throws IOException, InterruptedException {
        this.insertData("relation",rowKey,"info","userid",userid);
        this.insertData("relation",rowKey,"info","attendid",attendid);
        this.insertData("relation",rowKey,"info","fanid",fanid);
    }

    /**
     * @param userid
     * @param attendid is the userid of whom the user attends
     * @throws IOException
     */
    public void removeAttend(String userid,String attendid) throws Exception {
        List<Map<String, String>> relations = this.getAllData("relation");
        String rowKey = "";
        for(Map<String, String> relation : relations){
            if(relation.get("userid").equals(userid) && relation.get("attendid").equals(attendid)){
                rowKey = relation.get("rowKey");
                // set attendid none
                this.insertData("relation",rowKey,"info","attendid","");
                if(relation.get("fanid").equals("")){
                    this.deleteData("relation",rowKey);
                }
                break;
            }
        }
    }

    /**
     * @param userid
     * @param fanid is the userid of whom the user fans
     * @throws IOException
     */
    public void removeFan(String userid,String fanid) throws Exception {
        List<Map<String, String>> relations = this.getAllData("relation");
        String rowKey = "";
        for(Map<String, String> relation : relations){
            if(relation.get("userid").equals(userid) && relation.get("fanid").equals(fanid)){
                rowKey = relation.get("rowKey");
                // set fanid none
                this.insertData("relation",rowKey,"info","fanid","");
                if(relation.get("attendid").equals("")){
                    this.deleteData("relation",rowKey);
                }
                break;
            }
        }
    }

    /**
     * @param attendid is whom the user attends
     * @param userid
     * @throws IOException
     */
    public void removeEmails(String attendid,String userid) throws Exception {
        List<Map<String, String>> emails = this.getAllData("email");
        String rowKey = "";
        for(Map<String, String> email : emails){
            if(email.get("attendid").equals(attendid) && email.get("userid").equals(userid)){
                rowKey = email.get("rowKey");
                this.deleteData("email",rowKey);
            }
        }
    }

    /**
     * @param attendid is whom the user attends
     * @param userid
     * @return
     * @throws IOException
     */
    public List<String> getBlogRowKeys(String attendid, String userid) throws Exception {
        List<String> data = new ArrayList<String>();
        List<Map<String,String>> emails = this.getAllData("email");
        for(Map<String,String> email : emails){
            if(email.get("attendid").equals(attendid) && email.get("userid").equals(userid)){
                data.add(email.get("rowKey"));
            }
        }
        return data;
    }

    /**
     * @param userid
     * @return
     * @throws Exception
     */
    public List<String> getBlogRowKeysByUserid(String userid) throws Exception {
        List<String> data = new ArrayList<String>();
        List<Map<String,String>> blogs = this.getAllData("blog");
        for(Map<String,String> blog : blogs){
            if(blog.get("userid").equals(userid)){
                data.add(blog.get("rowKey"));
            }
        }
        return data;
    }

    /**
     * @param rowKey
     * @return
     * @throws IOException
     *
     * Search the blog by the rowKey
     */
    public Blog getBlog(String rowKey) throws Exception {
        Map<String, String> data = this.getRow("blog",rowKey);
        String userid = data.get("userid");
        String date = data.get("date");
        String content = data.get("content");
        Blog blog = new Blog(userid,date,content);
        return blog;
    }

    /**
     * @param userid
     * @return
     * @throws Exception
     */
    public List<String> getAllFans(String userid) throws Exception {
        List<Map<String, String>> relations = this.getAllData("relation");
        List<String> fans = new ArrayList<String>();
        for(Map<String, String> relation : relations){
            if(relation.get("userid").equals(userid)){
                fans.add(relation.get("fanid"));
            }
        }
        return fans;
    }

    /**
     * @param userid
     * @return
     * @throws Exception
     */
    public List<String> getAllAttends(String userid) throws Exception {
        List<Map<String, String>> relations = this.getAllData("relation");
        List<String> attends = new ArrayList<String>();
        for(Map<String, String> relation : relations){
            if(relation.get("userid").equals(userid)){
                attends.add(relation.get("attendid"));
            }
        }
        return attends;
    }

    /**
     * @param userid
     * @return
     * @throws Exception
     */
    public User getUserById(String userid) throws Exception {
        User user = new User();
        String password = "";
        if(null!=(password=this.getData("user",userid,"info","password"))){
            user.setUserid(userid);
            user.setPassword(password);
            user.setNickname(this.getData("user",userid,"info","nickname"));
        }
        return user;
    }

}

6 具体操作类BlogService

这里的BlogService类实现的是具体的操作，都是些业务逻辑，分别为发布微博、添加关注、取消关注和获取关注用户的微博，具体代码如下：

package service;

import dao.BlogMapper;
import pojo.Blog;
import pojo.User;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class BlogService {

    BlogMapper blogMapper;

    public BlogService() {
        this.blogMapper = new BlogMapper();
    }

    public void postBlog(String userid, String content){
        try{
            String blogRowKey = new Date().getTime()+"";
            // Add blog to blog list
            blogMapper.addBlog(blogRowKey,userid,content);
            List<String> fans = blogMapper.getAllFans(userid);
            for(String fan : fans){
                // Add email to email list
                blogMapper.addEmail(new Date().getTime()+"",userid,fan,blogRowKey);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void addAttend(String userid, String attendid) {
        try{
            // If the attender's fan doesn't contain the user
            if(!blogMapper.getAllFans(attendid).contains(userid)){
                // Add the attend to the user
                blogMapper.addRelation(new Date().getTime()+"",userid,attendid,"");
                // Add the fan to the attender
                blogMapper.addRelation(new Date().getTime()+"",attendid,"",userid);
                // If they attend eacher other
                if(blogMapper.getAllFans(userid).contains(attendid) && blogMapper.getAllFans(attendid).contains(userid)){
                    // Remover four relations
                    blogMapper.removeAttend(userid,attendid);
                    blogMapper.removeAttend(attendid,userid);
                    blogMapper.removeFan(userid,attendid);
                    blogMapper.removeFan(attendid,userid);
                    // Add attend and fan to each other
                    blogMapper.addRelation(new Date().getTime()+"",userid,attendid,attendid);
                    blogMapper.addRelation(new Date().getTime()+"",attendid,userid,userid);
                }
            }
            // Get all blogs by the attendid
            List<String> blogRowKeys = blogMapper.getBlogRowKeysByUserid(attendid);
            for(String blogRowKey : blogRowKeys){
                // Add email
                blogMapper.addEmail(new Date().getTime()+"",attendid,userid,blogRowKey);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void removeAttend(String userid, String attendid) {
        try{
            blogMapper.removeAttend(userid, attendid);
            blogMapper.removeFan(attendid,userid);
            blogMapper.removeEmails(attendid,userid);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public List<Blog> getBlogsByFanid(String userid){
        List<Blog> blogs = new ArrayList<Blog>();
        try{
            // Get all attenders of the user
            List<String> attends = blogMapper.getAllAttends(userid);
            for(String attendid : attends){
                // Get all blogRowKeys of the attender
                List<String> attendBlogsRowKey = blogMapper.getBlogRowKeysByUserid(attendid);
                for(String blogRowKey : attendBlogsRowKey){
                    // Add blogs of the attender to the list
                    blogs.add(blogMapper.getBlog(blogRowKey));
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return blogs;
    }

    public User getUserById(String userid){
        User user = null;
        try{
            user = blogMapper.getUserById(userid);
        }catch (Exception e){
            e.printStackTrace();
        }
        return user;
    }
}

7 测试类TestAll

import dao.BlogMapper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import pojo.Blog;
import service.BlogService;

import java.io.IOException;
import java.util.List;

public class TestAll {

    BlogService bs;
    BlogMapper bm;

    @Before
    public void init(){
        this.bs = new BlogService();
    }

    @Test
    public void testCreateTable() throws IOException {
        this.bm = new BlogMapper();
        bm.createTable("user","info");
        bm.createTable("blog","info");
        bm.createTable("email","info");
        bm.createTable("relation","info");
    }

    @Test
    public void testPostBlog(){
        bs.postBlog("100001","What a wonderful day!");
        bs.postBlog("100001","I love Shenyang!");
        bs.postBlog("100001","My math is really awful...");
        bs.postBlog("100001","There is an exam tommorrow!");
        bs.postBlog("100003","How wonderful!");
        bs.postBlog("100003","I hate Shenyang!");
        bs.postBlog("100004","My English is really awful...");
        bs.postBlog("100005","There is an exam today!");
    }

    @Test
    public void testAddAttend(){
        bs.addAttend("100001","100002");
        bs.addAttend("100002","100001");
        bs.addAttend("100002","100003");
        bs.addAttend("100002","100004");
        bs.addAttend("100002","100005");
    }

    @Test
    public void testRemoveAttend(){
        bs.removeAttend("100001","100002");
    }

    @Test
    public void testGetBlogByFanid(){
        List<Blog> list = bs.getBlogsByFanid("100002");
        for(Blog blog : list){
            System.out.println("User. : "+ bs.getUserById(blog.getUserid()).getNickname());
            System.out.println("Date. : "+blog.getDate());
            System.out.println("Cont. : "+blog.getContent()+"\n---");
        }
    }

}

8 测试运行

首先开启HDFS和HBase：

start-dfs.sh
start-hbase.sh

运行testCreateTable方法，先建四个表。运行后控制台会有很多输出，最后会显示建表完成：
输出

进入hbase的shell，使用list看一下：
list
四个空表已经创建完毕，下面注册几个新User：

put 'user','100001','info:nickname','Jack'
put 'user','100002','info:nickname','Mary'
put 'user','100003','info:nickname','Lucy'
put 'user','100004','info:nickname','John'
put 'user','100005','info:nickname','Tom'
put 'user','100001','info:password','123456'
put 'user','100002','info:password','123456'
put 'user','100003','info:password','123456'
put 'user','100004','info:password','123456'
put 'user','100005','info:password','123456'

按照顺序进行其余测试，输出和数据库会有更新。这里列出按顺序最后一个方法 testGetBlogByFanid 的输出：
输出
测试完毕。

搬金砖的小白
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第七章：分布式数据库HBase
07-11
1.HBase基础概念与数据模型 2.HBase的系统架构 3.HBase的安装与配置 4.HBase Shell 5.HBase的Java编程接口 6.HBase协处理器原理 7.HBase 二级索引 8.HBase Bulkload等特性 9.HBase与Hive协同工作 10.HBase Phoenix操作 11.HBase表结构设计案例
【14笔记】HBase实战--微博案例
fu-jw的博客
03-06 5075
1、需求分析 1、微博内容的浏览，数据库表设计 2、用户社交体现：关注用户，取关用户 3、拉取关注的人的微博内容 2、代码设计 1）创建命名空间以及表名的定义 2）创建微博内容表 3）创建用户关系表 4）创建用户微博内容接收邮件表 5）发布微博内容 6）添加关注用户 7）移除（取关）用户 8）获取关注的人的微博内容 9）测试 1）创建命名空间以及表名的定义 //获取配置conf priva...
hbase-api
qq_51138261的博客
07-20 197
HBase-apiHBase-api1 依赖2 java-api操作 HBase-api 1 依赖 <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-server</artifactId> <version>1.3.1</version> </dependency> <dependency>
Hbase的表设计
dmr91325的博客
09-14 179
一、应用背景 微博：用户表users、微博表weibos、用户关系表relations，和具体哪个公司的微博没关系。 微博中的用户想关注其他用户的微博，首先要维护一个特定用户的关注列表，例如张三关注了李四和王五。 为了要的得到张三应该看到的所有微博，你需要查找列表{李四、王五}，然后读出列表中每个用户的所有微博，这个信息需要保存在hbase中。 二、表模式（Schema）设计应该...
hbase项目
dci75702的博客
03-16 192
四、HBase 项目4.1、涉及概念梳理：命名空间4.1.1、命名空间的结构 1) Table：表，所有的表都是命名空间的成员，即表必属于某个命名空间，如果没有指定， 则在 default 默认的命名空间中。2) RegionServer group：一个命名空间包含了默认的 RegionServer Group。3) Permission：权限，命名空间能够让我们来定义访问控制列...
7. HBase实战之谷粒微博
weixin_45267102的博客
01-31 713
HBase实战之谷粒微博
【HBase数据开发】数据挖掘项目基石——hbase调研与集成
大壮的博客
07-17 740
一、背景 随着公司业务规模的扩大，需求的不断提升，数据量级也在不停的增长，公司其他兄弟部门也需要越来越多的数据需求。为此，我们部门有如下任务需要完成： 1.找到客户尽量多的数据，多维度分析客户，为客户建立合理的准确的数据标签 2.涉及到合法采集数据的爬虫开发，这个交给算法工程师，用python爬下来，处理一下就行了，并不用我们出马。 3.由于爬取数据格式比较混乱，所以这里计划存储到hbase中，后续由应用开发人员自行处理。 4.相当一部分业务数据，量级已经超过10亿级别，需要后续计划存储到hbas
HBase微博实战案例
TU_JCN的博客
08-10 1948
HBase微博实战案例 1 需求分析 微博内容的浏览，数据库表设计 用户社交体现：关注用户，取关用户 拉取关注的人的微博内容 2 代码实现 2.1 准备工作 第一步：创建maven工程并导入jar包 直接使用在版本确界当中创建的工程以及导入的jar包即可 第二步：拷贝三个配置文件到maven工程的下 将node01服务器的三个配置文件，分别是 core-site.xml、hdfs-site.xml、hbase-site.xml三个配置文件，拷贝到maven工程的resource
HBase应用之微博案例
weixin_42073629的博客
10-06 600
一. 需求分析 1)微博内容的浏览，数据库表设计 2)用户社交体现：关注用户，取关用户 3)拉取关注的人的微博内容 二. 代码实现 代码设计总览： 1.创建命名空间以及表名的定义 //获取配置 conf private Configuration conf = HBaseConfiguration.create(); //微博内容表的表名 private static final byte[] TABLE_CONTENT = Bytes.toBytes("ns_weibo:conten...
HBase-SparkStreaming:从HBase表读取并写入HBase表的简单Spark Streaming项目
05-13
从HBase表读取并写入HBase表的简单Spark Streaming项目 #Prereqs运行 创建一个要写入的hbase表：a）启动hbase shell $ hbase shell b）创建表create'/ user / chanumolu / sensor'，{NAME =>'data'}，{NAME =>'...
hbase-exporter:HBase Prometheus导出器
03-05
hbase-exporterHBase Prometheus导出器收集指标并中继JMX指标以供Prometheus使用由于JMX中一些重要的指标缺失或为空，因此我们另外分析了HBase主界面，例如“过渡中的过时区域” 解析“ hbase hbck”命令的输出以...
HBase视频教程下载|基于微博数据应用的HBase实战开发
01-02
课时2：HBase架构与索引算法剖析 课时3：HBase建库建表与CRUD实战 课时4：基于HBase Client API的CRUD实战 课时5：批处理与扫描器实战 课时6：使用Ganglia监控HBase 课时7：过滤器实战之比较过滤器 课时8：过滤器...
hbase-cleanup:HBase清理
05-14
HBase清理 执行 mvn全新安装 使用参数java -jar target / hbase-cleanup.jar --ttl = 12 --uri = vin-mongo.poc-vin.cloud.edmunds.com：27017 --cleanTrash = true 。 默认参数值： 参数 价值 乌里 vin-mongo.poc...
hbase-cdh5:Hbase-cloudera Docker
05-05
CDH版本：cdh5.1 java：jdk7u67（64位） HBase模式：伪分布式裸露端口动物园管理员服务器：2181 hbase-master：65000 hbase-master Web UI：65010 hbase-regionserver：65020 hbase-regionserver Web UI：65030如何...
第一章Hadoop概述
cookie的博客
04-21 1137
Hadoop Distributed File System，简称HDFS，是一个分布式文件系统。1)NameNode(nn):存储文件的元数据，如文件名，文件目录结构，文件属性(生成时间、副本数文件权限)，以及每个文件的块列表和块所在的DataNode等:2)DataNode(dn):在本地文件系统存储文件块数据，以及块数据的校验和。每隔一段时间对NameNode元数据备份。简称YARN，另一种资源协调者是Hadoop的资源管理器。
【Hadoop3.3.6】数据块副本放置策略及解析EditLog和FsImage
若兰幽竹
04-22 1196
目录一、摘要二、正文2.1 环境说明2.2 网络拓扑2.3 Hadoop副本放置策略介绍2.4 解析EditLog和Fsimage镜像文件三、小结 一、摘要 通过解析存储于NameNode节点上的日志文件EditLog和镜像文件（元数据）Fsimage来反向验证HDFS的数据块副本存放策略，其目的是希望加深对Hadoop的数据块放置策略的理解以及掌握如何查看日志文件及镜像文件的方法和理解其内容。 二、正文 2.1 环境说明 软件 说明 VMWareWorkstation 版本16.2.+
Linux多进程(五) 进程池 C++实现
最新发布
Lyajpunov的博客
04-26 579
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux 学习之路 -- 进程篇 -- 进程控制
2302_79538079的博客
04-24 1016
进程控制的简单介绍
Linux——web服务配置
Xinan_____的博客
04-23 1049
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
SyntaxError: (hbase):15: syntax error, unexpected tLCURLY
06-11
在这个错误提示中，"(hbase):15"表示在第15行出现了语法错误，"tLCURLY"表示意外地遇到了左花括号，可能是因为前面的括号没有正确匹配导致的。 你需要仔细检查代码中的括号、引号或其他符号是否匹配，特别是在代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

搬金砖的小白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值