使用hbase shell完成以下操作： 1.建表userfllower 2.用户Mary有一个粉丝Alice，Alice关注列表中也存在Mary 3.用户Jack有两个粉丝Bob和Ben 4.Jack还关注了Mary 5.查看Jack被哪些人关注，Jack关注了谁 6.Bob取关了Jack 7.扫描全表数据

以下是使用hbase shell完成上述操作的命令：

1. 创建表userfllower：

create 'userfllower', 'f'

2. 添加Mary的粉丝Alice和Alice的关注列表中也存在Mary：

put 'userfllower', 'Mary', 'f:follower', 'Alice'
put 'userfllower', 'Alice', 'f:following', 'Mary'

3. 添加Jack的两个粉丝Bob和Ben，以及Jack关注了Mary：

put 'userfllower', 'Jack', 'f:follower', 'Bob'
put 'userfllower', 'Jack', 'f:follower', 'Ben'
put 'userfllower', 'Jack', 'f:following', 'Mary'

4. 查看Jack被哪些人关注，以及Jack关注了谁：

get 'userfllower', 'Jack', {COLUMN=>'f:follower'}
get 'userfllower', 'Jack', {COLUMN=>'f:following'}

5. Bob取关了Jack：

delete 'userfllower', 'Bob', 'f:following', 'Jack'

6. 扫描全表数据：

scan 'userfllower'

相关问题

如何通过hbase通过idea操作api实现完成以下任务：假设你是用户部门员工，现需一张表用于存放用户粉丝数据。表：userfollow 存：follower粉丝有谁，followed关注谁。完成以下功能：1.建表userfollower 2.用户 Mary 有一个粉丝 Alice 3.用户Jack 有两个粉丝 Bob和Ben 4. Jack 还关注了 Mary 5.查看Jack 被那些人关注，关注了谁 6.Bob 取关了 Jack 7.扫描全表数据

好的，我会尽力回答您的问题。首先需要安装 HBase 和 Apache Maven，然后在 IntelliJ IDEA 中创建一个 Maven 项目。接下来，您需要在 Maven 项目中添加 HBase 依赖项，以便可以使用 HBase API 进行操作。可以通过在 pom.xml 文件中添加以下依赖项来实现：

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

其中 `{version}` 是您使用的 HBase 版本号。

接下来，您可以按照以下步骤完成您的需求：

1. 建表 userfollower：

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.TableDescriptor;
import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection(HBaseConfiguration.create());

        // 创建表描述符
        TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(TableName.valueOf("userfollower"))
                .build();

        // 获取管理员实例
        Admin admin = connection.getAdmin();

        // 创建表
        admin.createTable(tableDescriptor);

        // 关闭连接
        connection.close();
    }
}

2. 用户 Mary 有一个粉丝 Alice：

import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection();

        // 获取表实例
        Table table = connection.getTable(TableName.valueOf("userfollower"));

        // 创建 Put 对象
        Put put = new Put(Bytes.toBytes("Mary"));

        // 添加列族为 follower，列名为 Alice，值为 true
        put.addColumn(Bytes.toBytes("follower"), Bytes.toBytes("Alice"), Bytes.toBytes("true"));

        // 插入数据
        table.put(put);

        // 关闭连接
        connection.close();
    }
}

3. 用户 Jack 有两个粉丝 Bob 和 Ben：

import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection();

        // 获取表实例
        Table table = connection.getTable(TableName.valueOf("userfollower"));

        // 创建 Put 对象
        Put put = new Put(Bytes.toBytes("Jack"));

        // 添加列族为 follower，列名为 Bob，值为 true
        put.addColumn(Bytes.toBytes("follower"), Bytes.toBytes("Bob"), Bytes.toBytes("true"));

        // 添加列族为 follower，列名为 Ben，值为 true
        put.addColumn(Bytes.toBytes("follower"), Bytes.toBytes("Ben"), Bytes.toBytes("true"));

        // 插入数据
        table.put(put);

        // 关闭连接
        connection.close();
    }
}

4. Jack 还关注了 Mary：

import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection();

        // 获取表实例
        Table table = connection.getTable(TableName.valueOf("userfollower"));

        // 创建 Put 对象
        Put put = new Put(Bytes.toBytes("Jack"));

        // 添加列族为 followed，列名为 Mary，值为 true
        put.addColumn(Bytes.toBytes("followed"), Bytes.toBytes("Mary"), Bytes.toBytes("true"));

        // 插入数据
        table.put(put);

        // 关闭连接
        connection.close();
    }
}

5. 查看 Jack 被那些人关注，关注了谁：

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection();

        // 获取表实例
        Table table = connection.getTable(TableName.valueOf("userfollower"));

        // 创建 Get 对象
        Get get = new Get(Bytes.toBytes("Jack"));

        // 获取数据
        Result result = table.get(get);

        // 打印 follower 列族下的所有列
        System.out.println("Jack 被以下人关注：");
        for (Cell cell : result.getColumnCells(Bytes.toBytes("follower"), Bytes.toBytes("*"))) {
            String follower = Bytes.toString(CellUtil.cloneQualifier(cell));
            System.out.println(follower);
        }

        // 打印 followed 列族下的所有列
        System.out.println("Jack 关注了以下人：");
        for (Cell cell : result.getColumnCells(Bytes.toBytes("followed"), Bytes.toBytes("*"))) {
            String followed = Bytes.toString(CellUtil.cloneQualifier(cell));
            System.out.println(followed);
        }

        // 关闭连接
        connection.close();
    }
}

6. Bob 取关了 Jack：

import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection();

        // 获取表实例
        Table table = connection.getTable(TableName.valueOf("userfollower"));

        // 创建 Delete 对象
        Delete delete = new Delete(Bytes.toBytes("Bob"));

        // 删除 follower 列族下的 Jack 列
        delete.addColumn(Bytes.toBytes("follower"), Bytes.toBytes("Jack"));

        // 执行删除操作
        table.delete(delete);

        // 关闭连接
        connection.close();
    }
}

7. 扫描全表数据：

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseExample {
    public static void main(String[] args) throws Exception {
        // 创建 HBase 连接
        Connection connection = ConnectionFactory.createConnection();

        // 获取表实例
        Table table = connection.getTable(TableName.valueOf("userfollower"));

        // 创建 Scan 对象
        Scan scan = new Scan();

        // 扫描全表数据
        ResultScanner scanner = table.getScanner(scan);

        // 遍历结果集
        for (Result result : scanner) {
            String rowKey = Bytes.toString(result.getRow());

            // 打印 follower 列族下的所有列
            System.out.println(rowKey + " 被以下人关注：");
            for (Cell cell : result.getColumnCells(Bytes.toBytes("follower"), Bytes.toBytes("*"))) {
                String follower = Bytes.toString(CellUtil.cloneQualifier(cell));
                System.out.println(follower);
            }

            // 打印 followed 列族下的所有列
            System.out.println(rowKey + " 关注了以下人：");
            for (Cell cell : result.getColumnCells(Bytes.toBytes("followed"), Bytes.toBytes("*"))) {
                String followed = Bytes.toString(CellUtil.cloneQualifier(cell));
                System.out.println(followed);
            }
        }

        // 关闭连接
        connection.close();
    }
}

以上就是通过 HBase API 在 IntelliJ IDEA 中操作 HBase 完成您的需求的示例代码。请根据您的实际情况进行修改和调整。

用Hbase设计一个：假设你是用户部门员工，现需一张表用于存放用户粉丝数据，表：userfollow；存：follower粉丝有谁；followed关注谁。实现以下功能：1.建表userfollow2.用户Mary有一个粉丝Alice3.用户Jack有两个粉丝Bob和Ben4.Jack还关注了Mary5.查看Jack被哪些人关注，关注了谁6.Bob取关了Jack7.扫描了全表数据

好的，以下是用HBase设计的用户粉丝数据表userfollow的建表、插入数据和查询操作的代码实现：

1. 建表

首先需要创建一个Java项目，并导入HBase的相关依赖包。

然后可以使用HBaseAdmin类创建表：

Configuration conf = HBaseConfiguration.create();
HBaseAdmin admin = new HBaseAdmin(conf);

HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf("userfollow"));
tableDesc.addFamily(new HColumnDescriptor("follower"));
tableDesc.addFamily(new HColumnDescriptor("followed"));

admin.createTable(tableDesc);

这里定义了一个名为“userfollow”的表，包含两个列族“follower”和“followed”。

2. 插入数据

接下来可以使用HBase的Put类插入数据：

Configuration conf = HBaseConfiguration.create();
HTable table = new HTable(conf, "userfollow");

// 用户Mary有一个粉丝Alice
Put put1 = new Put(Bytes.toBytes("Mary"));
put1.add(Bytes.toBytes("follower"), Bytes.toBytes("Alice"), Bytes.toBytes("1"));
table.put(put1);

// 用户Jack有两个粉丝Bob和Ben
Put put2 = new Put(Bytes.toBytes("Jack"));
put2.add(Bytes.toBytes("follower"), Bytes.toBytes("Bob"), Bytes.toBytes("1"));
put2.add(Bytes.toBytes("follower"), Bytes.toBytes("Ben"), Bytes.toBytes("1"));
table.put(put2);

// Jack还关注了Mary
Put put3 = new Put(Bytes.toBytes("Jack"));
put3.add(Bytes.toBytes("followed"), Bytes.toBytes("Mary"), Bytes.toBytes("1"));
table.put(put3);

这里使用了Put类的add方法，将数据插入到表中。

3. 查询操作

可以使用HBase的Get类和Scan类来进行查询操作。

(1) 查看Jack被哪些人关注，关注了谁

Configuration conf = HBaseConfiguration.create();
HTable table = new HTable(conf, "userfollow");

// 查看Jack被哪些人关注
Get get1 = new Get(Bytes.toBytes("Jack"));
Result result1 = table.get(get1);
byte[] followed = result1.getValue(Bytes.toBytes("followed"), Bytes.toBytes("Mary"));
if (followed != null) {
    System.out.println("Jack关注了Mary");
}

// 查看Jack有哪些粉丝
Scan scan = new Scan();
scan.addColumn(Bytes.toBytes("follower"), Bytes.toBytes(""));
scan.setFilter(new PrefixFilter(Bytes.toBytes("Jack")));
ResultScanner scanner = table.getScanner(scan);
for (Result result2 : scanner) {
    byte[] follower = result2.getRow();
    System.out.println(Bytes.toString(follower) + "关注了Jack");
}
scanner.close();

这里使用了Get类和Scan类，分别查询了Jack被哪些人关注和Jack有哪些粉丝。

(2) Bob取关了Jack

Configuration conf = HBaseConfiguration.create();
HTable table = new HTable(conf, "userfollow");

Delete delete = new Delete(Bytes.toBytes("Jack"));
delete.deleteColumns(Bytes.toBytes("follower"), Bytes.toBytes("Bob"));
table.delete(delete);

这里使用了Delete类，将Bob从Jack的粉丝列表中删除。

(3) 扫描全表数据

Configuration conf = HBaseConfiguration.create();
HTable table = new HTable(conf, "userfollow");

Scan scan = new Scan();
ResultScanner scanner = table.getScanner(scan);
for (Result result : scanner) {
    byte[] row = result.getRow();
    byte[] follower = result.getValue(Bytes.toBytes("follower"), null);
    byte[] followed = result.getValue(Bytes.toBytes("followed"), null);
    System.out.println(Bytes.toString(row) + "的粉丝：" + Bytes.toString(follower) + "，关注：" + Bytes.toString(followed));
}
scanner.close();

这里使用了Scan类，扫描了全表数据并输出结果。

以上就是用HBase设计用户粉丝数据表userfollow的建表、插入数据和查询操作的代码实现。