hbase中java客户端操作

最新推荐文章于 2025-03-22 15:18:30 发布

火焰蓝

最新推荐文章于 2025-03-22 15:18:30 发布

阅读量332

点赞数

分类专栏： HBase

本文链接：https://blog.youkuaiyun.com/LEOZHYD/article/details/107419132

版权

HBase 专栏收录该内容

5 篇文章

订阅专栏

java操作hbase的配置文件


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>doit15-hbase</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>2.0.4</version>
        </dependency>
        <!-- 使用mr程序操作hbase 数据的导入 -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-mapreduce</artifactId>
            <version>2.0.4</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
        <!-- phoenix 凤凰 用来整合Hbase的工具 -->
        <dependency>
            <groupId>org.apache.phoenix</groupId>
            <artifactId>phoenix-core</artifactId>
            <version>5.0.0-HBase-2.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
 
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <!-- bind to the packaging phase -->
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
 
        </plugins>
    </build>
</project>

获取客户端数据

package doit01;

import Utils.HbaseUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;

import java.io.IOException;

public class GatDt {
    public static void main(String[] args) throws IOException {
        //配置对象
        Configuration conf = HBaseConfiguration.create();
        //设置zk集群信息,第一个是加载zookeeper信息
        conf.set("hbase.zookpeer.quorum","linux01:2181,linux02:2181,linux03:2181");

        //基于配置信息,获取hbase的连接对象
        //ConnectionFactory 是hbase的一个客户端
        //createConnection()  表示创建一个连接一个对象
        Connection conn = ConnectionFactory.createConnection(conf);
        // TableName tableName = new TableName();  TableName里面是一个private方法不能在外面new
        // 但是,可以在外面使用


        //这样就拿到了表名
        TableName tb_user = TableName.valueOf("tb_user");
        Table user = conn.getTable(tb_user);//通过连接对象获取表名
        //获取表对象,代表user表

        //创建get对象,代表一行的数据,
        //取第一行数据,每一行的数据以字节的形式存储
        Get get = new Get("rk001".getBytes());//表示hbase的客户端

        //表中获取一行数据,一行数据里面包括
        // 行键   列族s  属性s
        Result result = user.get(get);
        HbaseUtils.showData(result);
        //getTable()  里面要传一个tableName,getTable里面没有table,必须要new一个tableName
        //Table tb_user = conn.getTable("tb_user".getBytes());

        //result.advance()  表示是否有下一个单元格
        //result.current当前单元格书否存在
        while (result.advance()){
            //单元格  行键  :列族  属性  v:值
            Cell cell = result.current();
            /*byte[] rowArray = cell.getRowArray();//行键
            byte[] familyArray = cell.getFamilyArray();//列族
            byte[] qualifierArray = cell.getQualifierArray();//属性

            byte[] valueArray = cell.getValueArray();//值*/
            //如果这样直接打印的话,会出现乱码现象为了解决这一问题,CellUtil 可以解析这些类
            byte[] family = CellUtil.cloneFamily(cell);//列族
            byte[] qualifier = CellUtil.cloneQualifier(cell);//属性
            byte[] value = CellUtil.cloneValue(cell);//值
            byte[] row = CellUtil.cloneRow(cell);//行键
            System.out.println(new String(qualifier)+"----"+new String(value)+new String(family)+new String(row));


        }
        user.close();
        conn.close();


    }
}

java客户端在hbase里面取值,

1.获取配置文件

2.连接zookpeer

3.基于配置文件和zk,创建连接对象

4.调用一个表名,应该是把表名调到每一个存储空间

5.然后再创建连接对象后,通过连接对象,获取该表

6.通过该表调用里面一行数据,一行用rowkey表示,

7.把这一行数据取出来,返回一个result

8.这个result就表示这一行数据,

9.如果下一行存在,就调用该行数据返回一个单元格

10.解析单元格里面的内容,调用里面的内容

11.打印

package doit16;

import Utils.HbaseUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;

import java.io.IOException;

public class GetTableData {
    public static void main(String[] args) throws IOException {

        //第一步获取配置文件信息
        Configuration conf = HBaseConfiguration.create();
        //连接zookpeer
        conf.set("hbase.zookeeper.quorum", "linux01:2181,linux02:2181,linux03:2181");

        //基于配置信息,创建hbase连接对象
        Connection conn = ConnectionFactory.createConnection(conf);
        //api里面有一个tableName,被私有化不能创建,但是可以直接调用,把对应的 表调用出来,
        TableName tb_user = TableName.valueOf("tb_user");
        //hbase创建了连接对象,连接到hbase 然后再调用getTable调用hbase里面对应的表,
        Table user = conn.getTable(tb_user);
        //表在调用里面的一行
        Get get = new Get("rk002".getBytes());
        //通过get吧这一行内容取出来
        
        Result result = user.get(get);
        //HbaseUtils.showData(result);
        //通过p判断是否存在下一行,如果有 则调用本行 返回单元格cell
        //通过CellUtil解析单元格里面的内容,在返回字节数组
        //打印出来
        while(result.advance()){
            // 单元格  K 行键:列族:属性    V:值
            Cell cell = result.current();
            byte[] row = CellUtil.cloneRow(cell); // 行键
            byte[] family = CellUtil.cloneFamily(cell);  // 列族
            byte[] qua = CellUtil.cloneQualifier(cell); // 属性
            byte[] v = CellUtil.cloneValue(cell); // 值
            System.out.println(new String(qua)+"--"+new String(v));
        }
        user.close();
        conn.close();

    }
}

创建表

import Utils.HbaseUtils;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
/**
 *如果创建一个表,
 * 1.先获取表的管理对象
 * 2.创建表的构建器,在构建器里面把表的名字放进去,在通过标的构建器创建表
 * 3.表的构建器和表都构造完成后,再创建列族构造器,然后再创建列族,把创建好的,族放进表中,
 * 4.开始构建表,管理构建的表
 */
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
//admin:管理表的对象,表  名称空间  快照
//table 表的数据有关  get  scan  put
public class TableDemo {
    public static void main(String[] args) throws Exception {
        //获取表的管理对象
        Admin admin = HbaseUtils.getHbaseAdmin();

        //表的构建器   stu就是一个表的构建器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("tb_stu"));

        //列族构建器
        ColumnFamilyDescriptorBuilder familyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("cf1"));

        //在列族对象里面设置一些属性
        familyDescriptorBuilder.setMaxVersions(5);
        familyDescriptorBuilder.setTimeToLive(240);

        //列族对象
        ColumnFamilyDescriptor columnFamilyDescriptor = familyDescriptorBuilder.build();
        //把列族对象放进表的构建器里面
        tableDescriptorBuilder.setColumnFamily(columnFamilyDescriptor);

        //开始构建表
        TableDescriptor tableDescriptor = tableDescriptorBuilder.build();  //tableDescriptor就是一个表
        //列族的构建器

        //建表语句
        admin.createTable(tableDescriptor);  //管理所创建的一个表
        admin.close();


    }


}

预分表对象

 public static void main(String[] args) throws Exception {
        //创建表的管理对象
        Admin admin = HbaseUtils.getHbaseAdmin();
       // CreateTable(admin);

      //  admin.close();

        //预分region表对象
        //1.创建表的构造器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("tb_stu3"));

        //创建一个列族构造器
        ColumnFamilyDescriptorBuilder familyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("cf3"));

        //设置一些属性
        familyDescriptorBuilder.setMaxVersions(5);

        //创建一个列族
        ColumnFamilyDescriptor familyDescriptor = familyDescriptorBuilder.build();

        //把列族放进表构造器里面
        tableDescriptorBuilder.setColumnFamily(familyDescriptor);

        //建表
        TableDescriptor build = tableDescriptorBuilder.build();

        //预分region表对象
        //用一个二维数组,放置切割后的region
        byte[][] keys =  new byte[][] {"rk025".getBytes(),"rk051".getBytes()};

        admin.createTable(build,keys);
        admin.close();





    }

预分region,也就是当一个数据表非常大的时候,如果同时插入到一个region里面就会出现热点问题,解决办法就是,把数据表切分成多分,通过rowkey来划分,,如果 rk025 rk051 rk075 这样就可以划分为四数据块分别存到不同的四个region里面,

create "tb_user" , "cf", SPLITS=>[' rk026 ' , ' rk051 ' , ' rk076 '] 进行分块的语法查看分块的 list_region "tb_user"

删除表操作

public static void main(String[] args) throws Exception {
        //创建表的管理对象
        Admin admin = HbaseUtils.getHbaseAdmin();
       // CreateTable(admin);
        //  admin.close();

       //执行删除表的操作
        //在执行删除操作时,先禁用该表,
        TableName tb_stu = TableName.valueOf("tb_stu2");

        if(admin.tableExists(tb_stu)){
            admin.disableTable(tb_stu);
            if(admin.isTableDisabled(tb_stu)){
                //删除表
                admin.deleteTable(tb_stu);
            }else {
                System.out.println("请先禁用表");
            }
        }else {
            System.out.println("表不存在");
        }
        admin.close();

    }

表的简建立,修改,查询,删除操作的封装操作

package doit16;

import Utils.HbaseUtils;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
/**
 *如果创建一个表,
 * 1.先获取表的管理对象
 * 2.创建表的构建器,在构建器里面把表的名字放进去,在通过标的构建器创建表
 * 3.表的构建器和表都构造完成后,再创建列族构造器,然后再创建列族,把创建好的,族放进表中,
 * 4.开始构建表,管理构建的表
 */
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
//admin:管理表的对象,表  名称空间  快照
//table 表的数据有关  get  scan  put
public class TableDemo {
    public static void main(String[] args) throws Exception {
        //创建表的管理对象
        Admin admin = HbaseUtils.getHbaseAdmin();
        ChangeTableContain(admin);


    }

    private static void ChangeTableContain(Admin admin) throws IOException {
        // CreateTable(admin);
        //  admin.close();
        // DeleteTable(admin);
       /*
       //方法一:直接通过创建表的构造器,和表,然后创建列族构造器和列族,然后把列族放进表的构造器里面,最后创建完成表,然后用admin修改标的列族
       //获取表的连接对象
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("tb_user"));
        //创建列族构造器
        ColumnFamilyDescriptorBuilder familyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder("cf4".getBytes());
        //创建列族
        ColumnFamilyDescriptor familyDescriptor = familyDescriptorBuilder.build();
        //把列族放进表的构造器里面
        tableDescriptorBuilder.setColumnFamily(familyDescriptor);
        //创建表
        TableDescriptor build = tableDescriptorBuilder.build();
        //修改表
        admin.modifyTable(build);
        admin.close();
        //成功修改了列族的属性*/
/**
 * 对于在Linux01上已经存在的表,就不需要创建表如果修改里面的属性或值,可以直接创建一个列族构造器,用列族构造器,创建一个列族,通过admin调用表以及列族
 * 这样就可以,调用表和列族,从而实现修改的目的
 */
        //获取表的名称
        TableName tb_user = TableName.valueOf("tb_user");

        //创建一个列族构造器
        ColumnFamilyDescriptorBuilder cfb = ColumnFamilyDescriptorBuilder.newBuilder("cf4".getBytes());//这个只能修改已经存在的列族
        //修改列族里面的属性
        cfb.setMaxVersions(5);
        cfb.setTimeToLive(240);

        //构造列族
        ColumnFamilyDescriptor cfd = cfb.build();

        admin.modifyColumnFamily(tb_user,cfd);
    }

    private static void DeleteTable(Admin admin) throws IOException {
        //执行删除表的操作
        //在执行删除操作时,先禁用该表,
        TableName tb_stu = TableName.valueOf("tb_stu2");

        if(admin.tableExists(tb_stu)){
            admin.disableTable(tb_stu);
            if(admin.isTableDisabled(tb_stu)){
                //删除表
                admin.deleteTable(tb_stu);
            }else {
                System.out.println("请先禁用表");
            }
        }else {
            System.out.println("表不存在");
        }
    }

    private static void CreateRegionTable(Admin admin) throws IOException {
        //预分region表对象
        //1.创建表的构造器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("tb_stu3"));

        //创建一个列族构造器
        ColumnFamilyDescriptorBuilder familyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("cf3"));

        //设置一些属性
        familyDescriptorBuilder.setMaxVersions(5);

        //创建一个列族
        ColumnFamilyDescriptor familyDescriptor = familyDescriptorBuilder.build();

        //把列族放进表构造器里面
        tableDescriptorBuilder.setColumnFamily(familyDescriptor);

        //建表
        TableDescriptor build = tableDescriptorBuilder.build();

        //预分region表对象
        //用一个二维数组,放置切割后的region
        byte[][] keys =  new byte[][] {"rk025".getBytes(),"rk051".getBytes()};

        admin.createTable(build,keys);
    }

    private static void CreateTable(Admin admin) throws IOException {
        //表的构建器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("tb_stu2"));

        //列族的构建器
        ColumnFamilyDescriptorBuilder familyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("fc2"));

        //在列族里面放一些属性值
        familyDescriptorBuilder.setMaxVersions(5);
        familyDescriptorBuilder.setTimeToLive(240);

        //构建列族
        ColumnFamilyDescriptor columnFamilyDescriptor = familyDescriptorBuilder.build();

        //把列族放进表中
        tableDescriptorBuilder.setColumnFamily(columnFamilyDescriptor);

        //构建表
        TableDescriptor tableDescriptor = tableDescriptorBuilder.build();


        admin.createTable(tableDescriptor);
    }


}