程序员经验分享-hwhale

Hbase对数据表的增删改查和对数据的增删改查

2023-05-16 
package hadoop42_006_hbase01;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.ResourceBundle;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableExistsException;
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.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto.MutationType;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.mapreduce.util.ResourceBundles;

public class HBaseUtil {
    private static Configuration conf;
    private static Connection con;
    private static Admin admin;
    private static ExecutorService pool;
    static{
        conf=HBaseConfiguration.create();//加载hadoop和hbase的配置文件创建配置文件对象
        //加载hbase.properties配置文件信息
        ResourceBundle rb=ResourceBundles.getBundle("hbase");
        Enumeration<String> kvs=rb.getKeys();
        while (kvs.hasMoreElements()) {
            String key=kvs.nextElement();
            String value=rb.getString(key);
            //System.out.println("key:"+key+" value:"+value);
            conf.set(key,value);//设置hbase由哪个zookeeper集群协调管理
            //通过链接工厂对象，创建hbase对象
        }
    }
    public static Connection getConn(){
        pool=Executors.newCachedThreadPool();
        try {
            con=ConnectionFactory.createConnection(conf,pool);
            return con;
        } catch (IOException e) {
            throw new RuntimeException("数据库连接失败",e);
        }

    }

    public static void close(){
        try {
            getAdmin();
            if (admin!=null) {
                admin.close();
            }
        } catch (IOException e) {
            throw new RuntimeException("关闭管理者失败。。。",e);
        }
        try {
            if (con!=null && !con.isClosed()) {
                con.close();
            }
        } catch (IOException e) {
            throw new RuntimeException("关闭连接失败",e);
        }
        try {
            if (con!=null&&!pool.isShutdown()) {
                pool.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException("关闭线程池失败",e);
        }
    }

    public static boolean createTable(String tableName,String... columnFamilies) throws TableExistsException{
        getAdmin();
        TableName tn=TableName.valueOf(tableName);
        try {
            if(!admin.tableExists(tn)){
                HTableDescriptor htd=new HTableDescriptor(tn);
                for (String cf : columnFamilies) {
                    HColumnDescriptor hcd=new HColumnDescriptor(Bytes.toBytes(cf));
                    htd.addFamily(hcd);
                }
                admin.createTable(htd);//hbase数据库管理者通过表结构对象创建表
                return true;
            }else{
                throw new TableExistsException("表已经存在。。。。");
            }
        }catch (TableExistsException e) {
            throw new TableExistsException("表已经存在!!");
        }catch (IOException e) {
            throw new RuntimeException("创建数据库表失败!!",e);
        }finally{
            close();
        }
    }
    /**
     * 对表的删除
     * @param tableName 表名
     * @return
     */
    public static boolean delTable(String tableName){
        try {
            getAdmin();
            TableName delIN=TableName.valueOf(tableName);
            if(admin.tableExists(delIN)){
                admin.disableTable(delIN);
                admin.deleteTable(delIN);
                return true;
            }else{
                throw new RuntimeException("表已经不存在。。。");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            close();
        }
    }



    public static Admin getAdmin(){
        try {
            getConn();
            admin=con.getAdmin();
            return admin;
        } catch (IOException e) {
            throw new RuntimeException("取到表的管理者失败!!",e);
        }
    }


    /**
     * 对表中数据的增  删  改
     * @param tableName 表名
     * @param mt    数据库对表的操作类型  是进行PUT 还是 DELETE
     * @param rowkey 行键值
     * @param params  3个参数是列族名    单元格修饰名 单元格的值
     *                2个参数时  列族名    单元格修饰名
     *                1个参数时  列族名
     */
    public static void doUpdate(String tableName,MutationType mt,String rowkey,String...params){
        try {
            getAdmin();
            TableName tn=TableName.valueOf(tableName);
            if(admin.tableExists(tn)){
                Table t=con.getTable(tn,pool);
                switch(mt){
                case PUT:
                    Put put=null;
                    if (params.length==3) {
                        put = new Put(Bytes.toBytes(rowkey)).addColumn(Bytes.toBytes(params[0]),
                                Bytes.toBytes(params[1]), Bytes.toBytes(params[2]));
                    }else{
                        throw new RuntimeException("参数个数为3个!!!!");
                    }
                    t.put(put);
                    break;
                case DELETE: 
                    Delete del=new Delete(Bytes.toBytes(rowkey));
                    while (params!=null  && params.length!=0) {
                        System.out.println(params.length);
                        switch (params.length) {
                        case 1:
                            del.addFamily(Bytes.toBytes(params[0]));
                            break;
                        case 2:
                            del.addColumn(Bytes.toBytes(params[0]), Bytes.toBytes(params[1]));
                        default:
                            throw new RuntimeException("最多两个参数");
                        }
                    }
                    t.delete(del);
                    break;
                default:
                    throw new RuntimeException("只能进行增删改操作");
                }
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            close();
        }
    }


    /**
     * 对表中数据的增  删  改
     * @param tableName 表名
     * @param mt    数据库对表的操作类型  是进行PUT 还是 DELETE
     * @param rowkey 行键值
     * @param params  多columnfamily String[] ...params 中string[]的参数为：
     *               3个参数是列族名    单元格修饰名 单元格的值
     *                2个参数时  列族名    单元格修饰名
     *                1个参数时  列族名
     */
    public static void doUpdate(String tableName,MutationType mt,String rowkey,String[]...params){
        try {
            getAdmin();
            TableName tn=TableName.valueOf(tableName);
            if(admin.tableExists(tn)){
                Table t=con.getTable(tn,pool);
                switch(mt){
                case PUT:
                    Put put=null;
                    put = new Put(Bytes.toBytes(rowkey));
                    for (String[] ps : params) {
                        if (params.length==3) {
                            put.addColumn(Bytes.toBytes(ps[0]),Bytes.toBytes(ps[1]), Bytes.toBytes(ps[2]));
                        }else{
                            throw new RuntimeException("参数个数为3个!!!!");
                        }
                    }
                    t.put(put);
                    break;
                case DELETE: 
                    Delete del=new Delete(Bytes.toBytes(rowkey));
                    for (String[] ps : params) {
                        if(params !=null  && ps.length !=0) {
                            switch (ps.length) {
                            case 1:
                                del.addFamily(Bytes.toBytes(ps[0]));
                                break;
                            case 2:
                                del.addColumn(Bytes.toBytes(ps[0]), Bytes.toBytes(ps[1]));
                                break;
                            default:
                                throw new RuntimeException("最多两个参数");
                            }
                        }
                    }
                    t.delete(del);
                    break;
                default:
                    throw new RuntimeException("只能进行增删改操作");
                }
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            close();
        }
    }
    /**
     * 对表中数据的增  删  改
     * @param tableName 表名
     * @param mt    数据库对表的操作类型  是进行PUT 还是 DELETE
     * @param params  多rowkey Map<String,List<String[]>> 中String的参数为：
     *                  3个参数是列族名    单元格修饰名 单元格的值
     *                2个参数时  列族名    单元格修饰名
     *                1个参数时  列族名
     */
    public static void doUpdate(String tableName,MutationType mt,Map<String,List<String[]>>params){
        try {
            getAdmin();
            TableName tn=TableName.valueOf(tableName);
            if(admin.tableExists(tn)){
                Table t=con.getTable(tn,pool);
                switch(mt){
                case PUT:
                    List<Put> puts=new ArrayList<Put>();
                    for (Entry<String,List<String[]>> entry:params.entrySet()) {
                        Put put = new Put(Bytes.toBytes(entry.getKey()));
                        if(entry.getValue()!=null){
                            for (String[] ps : entry.getValue()) {
                                if (ps.length==3) {
                                    put.addColumn(Bytes.toBytes(ps[0]),Bytes.toBytes(ps[1]), Bytes.toBytes(ps[2]));
                                }else{
                                    throw new RuntimeException("参数个数为3个!!!!");
                                }
                            }
                            puts.add(put);
                        }
                    }
                    t.put(puts);
                    break;
                case DELETE: 
                    List<Delete> dels=new ArrayList<Delete>();
                    for (Entry<String,List<String[]>> entry:params.entrySet()) {
                        Delete del=new Delete(Bytes.toBytes(entry.getKey()));
                        if(entry.getValue()!=null){
                            for (String[] ps : entry.getValue()) {
                                if(ps!=null  && ps.length!=0) {
                                    switch(ps.length) {
                                    case 1:
                                        del.addFamily(Bytes.toBytes(ps[0]));
                                        break;
                                    case 2:
                                        del.addColumn(Bytes.toBytes(ps[0]), Bytes.toBytes(ps[1]));
                                        break;
                                    default:
                                        throw new RuntimeException("最多两个参数");
                                    }
                                }
                            }
                        }
                        dels.add(del);
                    }
                    t.delete(dels);
                    break;
                default:
                    throw new RuntimeException("只能进行增删改操作");
                }
            }
        }catch (IOException e) {
            throw new RuntimeException("进行增删改操作失败");
        }finally {
            close();
        }
    }

    public static String get(String tableName,String rowKey,String columnFamily,String qualifier){
        getAdmin();
        try {
            Table t=con.getTable(TableName.valueOf(tableName));
            Get get=new Get(Bytes.toBytes(rowKey));
            get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(qualifier));
            Result r=t.get(get);
            List<Cell> cells=r.listCells();
            return Bytes.toString(CellUtil.cloneValue(cells.get(0)));
        } catch (IOException e) {
            throw new RuntimeException("获得表对象失败",e);
        }
    }

    public static Map<String,String> get(String tableName,String rowKey,String columnFamily,String ... qualifiers){
        getAdmin();
        try {
            Table t=con.getTable(TableName.valueOf(tableName));
            Get get=new Get(Bytes.toBytes(rowKey));
            if(qualifiers!=null &&qualifiers.length!=0){
                for (String qualifier : qualifiers) {
                    get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(qualifier));
                }
            }else if(columnFamily!=null){
                get.addFamily(Bytes.toBytes(columnFamily));
            }
            Result r=t.get(get);
            List<Cell> cells=r.listCells();
            Map<String,String> results=null;
            if(cells!=null && cells.size()!=0){
                results=new HashMap<String,String>();
                for (Cell cell : cells) {
                    results.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
                }
            }
            return results;
        } catch (IOException e) {
            throw new RuntimeException("获得表对象失败",e);
        }
    }

    public static <T> T get(String tableName,String rowKey,String columnFamily,Class<T>clazz){
        getAdmin();
        try {
            Table t=con.getTable(TableName.valueOf(tableName));
            Get get=new Get(Bytes.toBytes(rowKey));
            Field[] fs=clazz.getDeclaredFields();
            for (Field f : fs) {
                get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(f.getName()));
            }
            Result r=t.get(get);
            List<Cell>cells=r.listCells();
            T tobj=clazz.newInstance();
            if(cells!=null &&cells.size()!=0){
                for (Cell cell : cells) {
                    for (int i = 0; i < fs.length; i++) {
                        String valueStr=Bytes.toString(CellUtil.cloneValue(cell));
                        if(Bytes.toString(CellUtil.cloneQualifier(cell)).intern()==fs[i].getName().intern()){
                            Object value=null;
                            if(fs[i].getType().getName().intern()=="int" || fs[i].getType().getName().intern()=="java.lang.Integer"){
                                value=Integer.parseInt(valueStr);
                            }else if(fs[i].getType().getName().intern()=="double" || fs[i].getType().getName().intern()=="java.lang.Double"){
                                value=Double.parseDouble(valueStr);
                            }
                            fs[i].setAccessible(true);
                            fs[i].set(tobj, value);

                        }
                    }
                }
            }
            return tobj;
        } catch (IOException e) {
            throw new RuntimeException("获得表对象失败",e);
        }catch (Exception e) {
            throw new RuntimeException("获得对象失败",e);
        }
    }




    public static Map<String,Map<String,String>> scan(String tableName,String[]... params){
        getAdmin();
        try {
            Table t=con.getTable(TableName.valueOf(tableName));
            Scan scan=new Scan();
            if(params!=null &&params.length!=0){
                for (String[] param : params) {
                    switch (param.length) {
                    case 1:
                        scan.addFamily(Bytes.toBytes(param[0]));
                        break;
                    case 2:
                        scan.addColumn(Bytes.toBytes(param[0]), Bytes.toBytes(param[1]));
                    default:
                        throw new RuntimeException("参数只能是一个或两个");
                    }
                }

            }
            ResultScanner rScan=t.getScanner(scan);
            Map<String,Map<String,String>> results=new HashMap<String,Map<String,String>>();
            for (Result r : rScan) {
                List<Cell>  cells=r.listCells();
                Map<String,String> rs=null;
                if(cells!=null &&cells.size()!=0){
                    rs=new HashMap<String,String>();
                    for (Cell cell : cells) {
                        rs.put(Bytes.toString(CellUtil.cloneFamily(cell))+":"
                                +Bytes.toString(CellUtil.cloneQualifier(cell)), 
                                Bytes.toString(CellUtil.cloneValue(cell)));
                    }
                }
                results.put(Bytes.toString(r.getRow()), rs);

            }
            return results;

        } catch (IOException e) {
            throw new RuntimeException("获得表对象失败",e);
        }
    }





}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Hbase对数据表的增删改查和对数据的增删改查 的相关文章

  • 解决问题：windows10安装MATLAB闪退或者安装没反应

    在bin win64目录下双击运行vcredist x64 exe xff1b 在bin win64 vc90目录下双击运行vcredist x64 exe xff1b 然后重启电脑 该问题即可得到解决

  • 解决问题：libpng warning: iCCP: known incorrect sRGB profile

    我们在运行和图像相关的程序时 xff0c 有时会遇到libpng warning iCCP known incorrect sRGB profile的问题 网上的解决方法有个是 xff1a pngcrush ow rem allb redu

  • Vue组件使用入门实例及常见错误解决

    定义Vue组件名的方式有两种 xff1a 使用 kebab case Vue component 39 my component name 39 当使用 kebab case 短横线分隔命名 定义一个组件时 xff0c 必须在引用这个自定义

  • vivado中verilog里关于$readmemb和 $readmemh的使用方法

    vivado中verilog里关于 readmemb和 readmemh的使用方法 这两天学习verilog语言时 xff0c 对 readmemb和 readmemh怎么读文件里的数据产生了疑问 xff0c 网上大多数资料都是inter下

  • R语言：permutation test 置换检验

    1 生成男女生身高数据各20个 男身高 xff0c mean 61 180 sd 61 10 女身高 xff0c mean 61 178 sd 61 10 set seed 20211009 boy 61 rnorm 20 180 10 g

  • Mac系统原生支持NTFS格式硬盘

    所有的办法都是在没有办法的情况下才能找到 之前一直用的 Paragon NTFS 当然虽然是程序员有两种方式 一种就是支持自己的事业 用收费的 另一种就是发挥自己的特长 去破解 无奈承担不起Paragon NTFS每个版本更新都要重新购买的

  • 模板 template 的类型转换

    template lt typename T gt T to xff08 int n xff09 return T n double d 61 to lt double gt 3 float f 61 to lt float gt 2 还可

  • 两个C++编译错误及解决办法--does not name a type和field `XX' has incomplete type

    编译错误一 xff1a XX does not name a type 编译错误二 xff1a field 96 XX 39 has incomplete type 编译错误一 xff1a XX does not name a type x

  • vim 常用操作

    1 xff1a vim选中字符复制 剪切 粘贴 xff08 https www cnblogs com luosongchao p 3193153 html xff09 问题描述 xff1a vim 中选中指定字符 xff0c 进行复制 剪

  • oracle split去逗号，行列转换

    1 针对 39 1 39 39 2 39 39 3 39 39 4 39 39 5 39 xff08 逗号在字符串外面 xff09 SQL gt SELECT COLUMN VALUE FROM TABLE SYS ODCIVARCHAR2

  • 如何解决相机打开后显示灰色（只针对联想电脑）

    症状描述 xff1a 打开相机 xff0c 显示灰色 xff0c 中间有一个相机带斜杠的图标 我第二次被这玩意搞破了心态 xff0c 吐槽一句 xff1a 垃圾联想 xff0c 我丢 xff01 xff01 如何解决 xff1f 一步到位

  • python工程打包成可执行文件

    1 将python打包成exe的方式 python 上常见的打包方式目是通过 pyinstaller 来实现的 pip install pyinstaller 或者用镜像下载 xff1a 清华源 pip install pyinstalle

  • Debian 8安装、配置

    win10下双系统安装Debian 8 1 安装Debian 8 首先在Debian官网https www debian org CD 上下载网络安装CD或者完整DVD镜像 xff0c DVD镜像只需DVD 1即可 下载好镜像后做成U盘启动

  • Rust语法之原生数据类型（一）

    Rust语言有一些被认为是原生类型的数据类型 这意味着它们是语言内建的 Rust是这样的一种结构 xff0c 这种结构是标准库在这些类型上提供了一些有用的类型 xff0c 但是这些才是最原始的 Booleans Rust有一个内置的bool

  • WTL学习笔记——（5）工具条与状态条

    一 对第三部分的介绍 自从作为Windows 95的通用控件出现以来 xff0c 工具条和状态条就变成了很普遍的事物 由于MFC支持浮动的工具条从而使它们更受欢迎 随着通用控件的更新 xff0c Rebars 最初 被称为Coollbar

  • ESP8266调用心知天气API

    首先我们需要一个可以调用返回天气信息的API xff0c 这里以心知天气为例 xff0c 可以免费注册 xff0c 虽然功能受限 xff0c 但对于初学者来说 xff0c 足够了 心知天气api xff1a https api senive

  • 《信号量》讲解

    7 3 1 信号量 信号量及信号量上的操作是E W Dijkstra 在1965年提出的一种解决同步 互斥问题的较通用的方法 xff0c 并在很多操作系统中得以实现 xff0c Linux改进并实现了这种机制 信号量 semaphore 实

  • 【TouchDesigner学习笔记与资料】

    文章目录 基础知识常用快捷键TOP元件CHOP元件DAT 元件SOP元件COMP元件MAT元件 TouchDesigner是什么 xff1f 简单来说就是一种可视化的编程语言 TD 是一种编程语言 TD 不是一个 APP 应用程序 xff0

  • Java 枚举(enum) 详解7种常见的用法

    DK1 5引入了新的类型 枚举 在 Java 中它虽然算个 小 功能 xff0c 却给我的开发带来了 大 方便 用法一 xff1a 常量 在JDK1 5 之前 xff0c 我们定义常量都是 xff1a public static final

  • iOS 缓存文件到沙盒目录的执行文件夹下，并再次读取文件

    开发中我们经常要将一些文件缓存到沙盒路径下 xff0c 并且把指定的类型储存到指定文件夹下 xff0c 以便于方便管理 下面是以图片为例 首先显示缓存到指定文件夹下 xff0c 注释解释很详细 将图片存储到沙盒目录下存储成jpg 形式 xf

随机推荐

热门标签