基于JAVA API编程接口的HBase Shell交互式命令行终端模拟程序（简要实现）

最新推荐文章于 2023-04-26 18:00:25 发布
最新推荐文章于 2023-04-26 18:00:25 发布
阅读量1.2k 收藏 8
点赞数 4
文章标签： hbase java hadoop eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53086187/article/details/120922226
版权

一、环境搭建

集群规划：

Master：192.168.76.11

Slave1：192.168.76.12

Slave2：192.168.76.13

操作系统：RedHat Linux7

对三台虚拟机进行，修改主机名，配置域名映射，关闭防火墙，配置免密登录操作，上传安装包，创建安装目录操作。本项目选择配置Hadoop完全分布式、Zookeeper集群模式和HBase完全分布式。

  1. Hadoop集群部署（仅在master执行）

安装jdk

解压jdk-1.8的压缩包到安装目录

配置全局环境变量（vim /etc/profile）

#jdk

export JAVA_HOME=/lx/bigdata/jdk

export PATH=$PATH:$JAVA_HOME/bin

将jdk安装目录分发给另外两台虚拟机，然后刷新环境变量

安装hadoop

解压hadoop-2.7.1压缩包到安装目录

去到安装目录下的/etc/Hadoop，修改core-site.xml、hadoop-env.sh、hdfs-  site.xml、mapred-site.xml、yarn-site.xml、yarn-env.sh、slaves

core-site.xml

<configuration>

 <property>

 <name>fs.defaultFS</name>

 <value>hdfs://master:8020</value>

 </property>

 <property>

 <name>hadoop.tmp.dir</name>

 <value>/var/log/hadoop/tmp</value>

 </property>

</configuration>

hadoop-env.sh

export JAVA_HOME=/usr/jdk

hdfs-site.xml

<configuration>

<property>

 <name>dfs.namenode.name.dir</name>

 <value>file:///data/hadoop/hdfs/name</value>

</property>

<property>

 <name>dfs.datanode.data.dir</name>

 <value>file:///data/hadoop/hdfs/data</value>

</property>

<property>

 <name>dfs.namenode.secondary.http-address</name>

 <value>master:50090</value>

</property>

<property>

 <name>dfs.replication</name>

 <value>3</value>

</property>

</configuration>

mapred-site.xml

默认系统中没有这个配置文件，但是有它的模板我们复制一份

cp mapred-site.xml.template mapred-site.xml

<configuration>

<property>

<name>mapreduce.framework.name</name>

<value>yarn</value>

</property>

<!-- jobhistory properties -->

<property>

<name>mapreduce.jobhistory.address</name>

<value>master:10020</value>

</property>

<property>

<name>mapreduce.jobhistory.webapp.address</name>

<value>master:19888</value>

</property>

</configuration>

yarn-site.xml

<configuration>

 <property>

 <name>yarn.resourcemanager.hostname</name>

 <value>master</value>

 </property>

 <property>

 <name>yarn.resourcemanager.address</name>

 <value>${yarn.resourcemanager.hostname}:8032</value>

 </property>

 <property>

 <name>yarn.resourcemanager.scheduler.address</name>

 <value>${yarn.resourcemanager.hostname}:8030</value>

 </property>

 <property>

 <name>yarn.resourcemanager.webapp.address</name>

 <value>${yarn.resourcemanager.hostname}:8088</value>

 </property>

 <property>

 <name>yarn.resourcemanager.webapp.https.address</name>

 <value>${yarn.resourcemanager.hostname}:8090</value>

 </property>

 <property>

 <name>yarn.resourcemanager.resource-tracker.address</name>

 <value>${yarn.resourcemanager.hostname}:8031</value>

 </property>

 <property>

 <name>yarn.resourcemanager.admin.address</name>

 <value>${yarn.resourcemanager.hostname}:8033</value>

 </property>

 <property>

 <name>yarn.nodemanager.local-dirs</name>

 <value>/data/hadoop/yarn/local</value>

 </property>

 <property>

 <name>yarn.log-aggregation-enable</name>

 <value>true</value>

 </property>

 <property>

 <name>yarn.nodemanager.remote-app-log-dir</name>

 <value>/data/tmp/logs</value>

 </property>

<property>

<name>yarn.log.server.url</name>

<value>http://master:19888/jobhistory/logs/</value>

<description>URL for job history server</description>

</property>

<property>

 <name>yarn.nodemanager.vmem-check-enabled</name>

 <value>false</value>

 </property>

<property>

 <name>yarn.nodemanager.aux-services</name>

 <value>mapreduce_shuffle</value>

 </property>

 <property>

 <name>yarn.nodemanager.aux-services.mapreduce.shuffle.class</name>

 <value>org.apache.hadoop.mapred.ShuffleHandler</value>

 </property>

<property>

 <name>yarn.nodemanager.resource.memory-mb</name>

 <value>2048</value>

</property>

<property>

 <name>yarn.scheduler.minimum-allocation-mb</name>

 <value>512</value>

</property>

<property>

 <name>yarn.scheduler.maximum-allocation-mb</name>

 <value>4096</value>

</property>

<property>

 <name>mapreduce.map.memory.mb</name>

 <value>2048</value>

</property>

<property>

 <name>mapreduce.reduce.memory.mb</name>

 <value>2048</value>

</property>

<property>

 <name>yarn.nodemanager.resource.cpu-vcores</name>

 <value>1</value>

</property>

</configuration>

yarn-env.sh

export JAVA_HOME=/usr/jdk

slaves

删除原有内容添加

slave1

slave2

然后vim /etc/profile 写入

#hadoop

export HADOOP_HOME=/lx/bigdata/hadoop

export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

最后将修改的文件分发给slave、slave2，在三台虚拟机上刷新环境变量

格式化namenode

hdfs namenode -format

Zookeper的安装（仅在master操作）

解压zookeeper-3.4到安装目录

修改/etc/profile，写入

#zookeeper

export ZOOKEEPER_HOME=/lx/bigdata/zookeeper

export PATH=$PATH:$ZOOKEEPER_HOME/bin

进入安装目录下的conf目录

修改zoo.cgf，系统默认也是没有的，所以复制一份

cp zoo_sample.cfg zoo.cfg

zoo.cfg

修改dataDir参数，改为自己使用的目录（默认可以不用修改），在文件末尾加入

server.1=192.168.76.11:2888:3888

server.2=192.168.76.12:2888:3888

server.3=192.168.76.13:2888:3888

然后创建目录（就是dataDir设置的目录）

最后将修改的文件分发给slave、slave2，在三台虚拟机上刷新环境变量

在三台虚拟机上分别进入刚刚创建的目录，执行

Master

echo 1 >  myid

Slave1

echo 2 >  myid

Slave3

echo 3 >  myid

HBase安装（仅在master操作）

将hbase-1.4.13解压到安装目录

进入安装目录下的conf目录，修改配置文件

hbase-site.xml

<configuration>

<property>

<name>hbase.rootdir</name>

<value>hdfs://master:8020/hbase</value>

</property>

<property>

<name>hbase.master</name>

<value>master</value>

</property>

<property>

<name>hbase.cluster.distributed</name>

<value>true</value>

</property>

<property>

<name>hbase.zookeeper.property.clientPort</name>

<value>2181</value>

</property>

<property>

<name>hbase.zookeeper.quorum</name>

<value>slave1,slave2</value>

</property>

<property>

<name>zookeeper.session.timeout</name>

<value>60000000</value>

</property>

<property>

<name>dfs.support.append</name>

<value>true</value>

</property>

</configuration>

hbase-env.sh

注释下面两行内容

export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"

export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"

写入以下内容

export HBASE_CLASSPATH=/lx/bigdata/hadoop/etc/hadoop

export JAVA_HOME=/lx/bigdata/jdk

export HBASE_MANAGES_ZK=false

系统默认使用内置zookeeper，改为false意思为使用外置zookeeper

修改/etc/profile，写入

#hbase

export HBASE_HOME=/lx/bigdata/hbase

export PATH=$PATH:$HBASE_HOME/bin

最后将修改的文件分发给slave、slave2，在三台虚拟机上刷新环境变量

最后开启集群

Start-all.sh（只需在master执行）

zkServer.sh start（三台都要执行）

start-hbase.sh（只需在master执行）

查看进程(jps)

Master:

Slave1:

Slave2:

二、代码部分

导入jar包（jar包为hbase安装目录下lib目录的所有jar包）

hbaseutils



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;

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

    public static void init() throws IOException  //执行数据库操作之前，把与创建configuration, Connection, Admin相关的代码统一放到静态的初始化方法init()中
    {
        configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum", "master");
        connection = ConnectionFactory.createConnection(configuration);	//实质得到是Connection接口的间接实现类HConnectionImplementation的一个实例
        admin = connection.getAdmin();//实质得到是Admin接口的直接接实现类HBaseAdmin的一个实例
        System.out.println("Hbase Init Success");
    }

    public static void close() throws IOException
    {
        connection.close();
        admin.close();
    }
    
    
    
    
    //help
    public static void helpinfo() {
    	System.out.println("command"+"\t\t\t"+"sample code");
        System.out.println("list:"+"\t\t\t"+"list");
        System.out.println("exists:"+"\t\t\t"+"exists t1");
        System.out.println("disable:"+"\t\t"+"disable t1");
        System.out.println("desc:"+"\t\t\t"+"desc t1");
        System.out.println("create:"+"\t\t\t"+"create t1 f1");
        System.out.println("alter:"+"\t\t\t"+"alter t1 f1");
        System.out.println("delete:"+"\t\t\t"+"delete t1");
        System.out.println("put:"+"\t\t\t"+"put t1 r1 f1 q1 v1");
        System.out.println("getr:"+"\t\t\t"+"getr t1 r1");
        System.out.println("getc:"+"\t\t\t"+"getc t1 r1 f1 q1");
        System.out.println("scant:"+"\t\t\t"+"scant t1");
        System.out.println("scanf:"+"\t\t\t"+"scanf t1 f1");
        System.out.println("deleter:"+"\t\t"+"deleter t1 r1");
        System.out.println("deletec:"+"\t\t"+"deletec t1 r1 f1 q1");
        System.out.println("listNameSpaces:"+"\t\t"+"listNameSpaces");
        System.out.println("listTables:"+"\t\t"+"listTables namespace");
        System.out.println("createNameSpace:"+"\t"+"createNameSpace namespace");
        System.out.println("help:"+"\t\t\t"+"help");
    }

    
    
    
    
    
    
    //list
    public static void listTables() throws IOException//实现列出所有的表名
    {
        //通过TableName类获取表名
        TableName[] tableNames = admin.listTableNames();
        for(TableName tableName : tableNames)
        {
            System.out.println(new String(tableName.getName()));//把字节数组byte[]转换成String
        }
    }

    
    
    
    
    
    
    //exists
    public static boolean isTableExist(String strTableName) throws IOException//判断表是否存在
    {
        //处理不合法的情况，直接return
        if(!isTableNameFormatCorrect(strTableName))
        {
            return false;
        }

        TableName tableName  = TableName.valueOf(strTableName);
        return admin.tableExists(tableName);
    }
    public static boolean isTableNameFormatCorrect(String strTableName)
    {
//        System.out.println(strTableName.indexOf(":"));
//        System.out.println(strTableName.lastIndexOf(":"));
//        System.out.println(strTableName.length());
        //输入参数的合法性检查，提高方法代码的健壮性
        //包含不只1个冒号||第一个字符是冒号||最后一个字符是冒号
        if(strTableName.indexOf(":") != strTableName.lastIndexOf(":") || //第一个字符是冒号
                strTableName.indexOf(":")==0 || //最后一个字符是冒号
                strTableName.indexOf(":")==strTableName.length()-1)//包含不只1个冒号|
        {
            System.out.println("Input parameter format incorrect");
            return false;
        }
        return true;
    }
    
    
    
    
    
    
    
    
  //desc
    public static void descTable(String strTableName) throws IOException//描述指定表的属性信息
    {
        //处理不合法的情况，直接返回false
        if (!isTableNameFormatCorrect(strTableName)) {
            return;
        }
        if(!isTableExist(strTableName)) //表不允许被删除返回false
		{
			System.out.println("Table dose not exists");
			return ;
		}

        TableName tableName = TableName.valueOf(strTableName);//获取表名对象

        if (admin.isTableEnabled(tableName)) //判断表是否可用
        {
            System.out.println("Table " + strTableName + " is ENABLED");
        } else {
            System.out.println("Table " + strTableName + " is DISABLED");
        }
        HTableDescriptor tableDescriptor = admin.getTableDescriptor(tableName);
//        System.out.println(strTableName);
        HColumnDescriptor[] hcds = tableDescriptor.getColumnFamilies();
        System.out.println("COLUMN FAMILIES DESCRIPTION");
        for (HColumnDescriptor hcd : hcds) {
            System.out.println("{NAME => " + hcd.getNameAsString() + ", " +
                    "BLOOMFILTER => " + hcd.getBloomFilterType() + ", " +
                    "VERSIONS => " + hcd.getMaxVersions() + ", " +
                    "IN_MEMORY => " + hcd.isInMemory() + ", " +
                    "KEEP_DELETED_CELLS => " + hcd.getKeepDeletedCells() + ", " +
                    "DATA_BLOCK_ENCODING => " + hcd.getDataBlockEncoding().name() + ", " +
                    "TTL => " + hcd.getTimeToLive() + ", " +
                    "COMPRESSION => " + hcd.getCompression().getName() + ", " +
                    "MIN_VERSIONS => " + hcd.getMinVersions() + ", " +
                    "BLOCKCACHE => " + hcd.isBlockCacheEnabled() + ", " +
                    "BLOCKSIZE => " + hcd.getBlocksize() + ", " +
                    "REPLICATION_SCOPE => " + hcd.getDFSReplication() + "}"
            );//获取列族名称
        }
    }
    
    
    
    //create
    public static void createTable(String strTableName, String strColumnFamilyName) throws IOException
	{
    	if(!isTableNameFormatCorrect(strTableName)) //判断表是否允许创建
    	{
    		return;
    	}
    	if(isTableExist(strTableName)) //如果表存在则直接返回
		{
			
			System.out.println("Table " + strTableName + " does exist");
			return;
		}
    	
    	TableName tableName = TableName.valueOf(strTableName);
		HTableDescriptor tableDescriptor = new HTableDescriptor(tableName);
		HColumnDescriptor columnDescriptor = new HColumnDescriptor(strColumnFamilyName);
		tableDescriptor.addFamily(columnDescriptor);		
		admin.createTable(tableDescriptor);		
	}
    
    
    
    
    
    
    
    
    //alter
    public static void alterTable(String strTableName, String newColumnFamily) throws IOException
	{    
		if(!isTableExist(strTableName)) //表不存在则返回false
		{
			System.out.println("Table dose not exists");
			return;
		}
	
		TableName tableName = TableName.valueOf(strTableName);//获取表名对象	    	
		HTableDescriptor tableDescriptor = admin.getTableDescriptor(tableName);//获取表的描述器		
		
		if(isColumnFamilyExists(tableDescriptor, newColumnFamily)) //如果表的列族已存在，则直接返回
		{
			return;
		}
		
		HColumnDescriptor columnDescriptor = new HColumnDescriptor(newColumnFamily);//创建一个新的列族描述器			
		tableDescriptor.addFamily(columnDescriptor);//添加新列族描述器到表描述器		
		admin.modifyTable(tableName, tableDescriptor);	//提交修改表的操作
	 }
    
    public static boolean isColumnFamilyExists(HTableDescriptor tableDescriptor, String strFamiliyName) throws IOException//实现列出所有的表名
	{
		HColumnDescriptor[] hColumnDescriptors = tableDescriptor.getColumnFamilies();
		for(HColumnDescriptor hColumnDescriptor: hColumnDescriptors) 
		{
			if(hColumnDescriptor.getNameAsString().equals(strFamiliyName))
			{
//				System.out.println("Column Family already exists");
				return true;
			}
		}
		return false;	
	}
    
    
    
    //delete
    public static void dropTable(String strTableName) throws IOException
   	{
   		if(!isTableAllowDrop(strTableName)) //返回false，表不允许删除
   		{
   			System.out.println("Table dose not allow to be dropped");
   			return;
   		}  	
   		TableName tableName = TableName.valueOf(strTableName);
   		admin.deleteTable(tableName);
   		System.out.println("Table deleted successfully");
   	} 
    public static boolean isTableAllowDrop(String strTableName) throws IOException//判断表是否存在
	{	
		if(!isTableExist(strTableName)) //表不允许被删除返回false
		{
			System.out.println("Table dose not exists");
			return false;
		}	
		TableName tableName = TableName.valueOf(strTableName);
		if(admin.isTableEnabled(tableName)) //判断表是否被禁用，如果是enabled，返回true
		{
			admin.disableTable(tableName);//删除前先将表禁用 ，使其off-line
		}
		return true;
	}
    
    public static void scanTable(String strTableName) throws IOException
   	{	
   		if(!isTableExist(strTableName)) //如果表不存在则直接返回
   		{
   			System.out.println("Table dose not exists");
   			return;
   		}
   		
       	TableName tableName = TableName.valueOf(strTableName); //获取表名对象	
       	Scan scan = new Scan(); //创建扫描器对象   	
       	Table table =  connection.getTable(tableName);//获取操作表的Table对象   	
       	ResultScanner resultScanner = table.getScanner(scan);//获得用于检索数据的ResultScanner对象
       	
       	printScanResult(resultScanner);//输出扫描结果
   	} 
    public static void printScanResult(ResultScanner resultScanner) throws IOException
	{
        for (Result result : resultScanner) 
        { 
//        	System.out.println(result);
        	Cell[] cells = result.rawCells();//返回单元格Cell的数组     	
        	printCellValue(cells);//输出单元格Cell数组的内容
        }
	}
    public static void printCellValue(Cell[] cells) throws IOException//实现列出所有的表名
	{
        for (Cell cell : cells) 
        { 
            System.out.println("rowkey:" + Bytes.toString(CellUtil.cloneRow(cell)) + 
            		         " | column family:" + Bytes.toString(CellUtil.cloneFamily(cell)) + 
            		         " | column:" + Bytes.toString(CellUtil.cloneQualifier(cell)) + 
            		         " | timestamp:" + cell.getTimestamp() +
            		         " | cell value:" + Bytes.toString(CellUtil.cloneValue(cell)));
        }
	}
    
    
    
    //put
    public static void putACellValue(String strTableName, String rowKey, String columnFamily, String column, String value) throws IOException
	{
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
    	
		TableName tableName = TableName.valueOf(strTableName);//获取表名对象 		
		if(!isColumnFamilyExists(admin.getTableDescriptor(tableName), columnFamily)) //如果列族不存在则直接返回
		{
			System.out.println("Column Family does not exists");
			return;
		}
    	
    	Table table = connection.getTable(tableName);//获取操作表的Table对象
    	Put put = new Put(Bytes.toBytes(rowKey));//创建一个Put对象，指定行键rowKey
    	put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));//增加一列，指定列族、列修饰符、单元格值
    	table.put(put);	//执行put方法，插入一列
	}
    
    
    
    
    
    
    //getr
    public static void getCellValue(String strTableName, String rowKey) throws IOException
	{	
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
    	
    	TableName tableName = TableName.valueOf(strTableName); //获取表名对象
    	Table table = connection.getTable(tableName);//获取操作表的Table对象    	
    	Get get = new Get(Bytes.toBytes(rowKey));//创建一个Get对象，指定行键rowKey 	
    	Result result = table.get(get);//执行get方法，获得指定列的指，返回结果
    	Cell[] cells = result.rawCells();//获取单元格对象的数组
    	
    	printCellValue(cells);//输出单元格数组的内容
	}
    
    //getc
    public static void getCellValue(String strTableName, String rowKey, String columnFamily, String column) throws IOException
	{	
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
  	
    	TableName tableName = TableName.valueOf(strTableName); //获取表名对象		
    	if(!isColumnFamilyExists(admin.getTableDescriptor(tableName), columnFamily)) //如果列族不存在则直接返回
		{
			System.out.println("Column Family does not exists");
			return;
		}
    	
    	Table table = connection.getTable(tableName);//获取操作表的Table对象    	
    	Get get = new Get(Bytes.toBytes(rowKey));//创建一个Get对象，指定行键rowKey
    	get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column));//加入列族名和列名作为查询条件
    	Result result = table.get(get);//执行get方法，获得指定列的指，返回结果
    	Cell[] cells = result.rawCells();//获取单元格对象的数组
    	
    	printCellValue(cells);//输出单元格数组的内容
	}
   
    
    
    //scant
//    public static void scanTable(String strTableName) throws IOException
//   	{	
//   		if(!isTableExist(strTableName)) //如果表不存在则直接返回
//   		{
//   			System.out.println("Table dose not exists");
//   			return;
//   		}
//   		
//       	TableName tableName = TableName.valueOf(strTableName); //获取表名对象	
//       	Scan scan = new Scan(); //创建扫描器对象   	
//       	Table table =  HBaseJavaAPIUtils.connection.getTable(tableName);//获取操作表的Table对象   	
//       	ResultScanner resultScanner = table.getScanner(scan);//获得用于检索数据的ResultScanner对象
//       	
//       	printScanResult(resultScanner);//输出扫描结果
//   	} 
    
  //scanf
    public static void scanTable(String strTableName, String columnFamily) throws IOException
	{	
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
		
    	TableName tableName = TableName.valueOf(strTableName); //获取表名对象	
    	if(!isColumnFamilyExists(admin.getTableDescriptor(tableName), columnFamily)) //如果列族不存在则直接返回
		{
			System.out.println("Column Family does not exists");
			return;
		}
    	Scan scan = new Scan(); //创建扫描器对象   	
    	scan.addFamily(Bytes.toBytes(columnFamily));//把要扫描的一个列族增加到扫描器中
    	Table table = connection.getTable(tableName);//获取操作表的Table对象   	
    	ResultScanner resultScanner = table.getScanner(scan);//获得用于检索数据的ResultScanner对象
    	
    	printScanResult(resultScanner);//输出扫描结果
	} 
   
    
    
    
    
    
    //deleter
    public static void deleteCellValue(String strTableName, String rowKey) throws IOException
	{
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
    	
		TableName tableName = TableName.valueOf(strTableName); //获取表名对象   	

		Table table = connection.getTable(tableName);//获取操作表的Table对象
    	Delete delete = new Delete(Bytes.toBytes(rowKey));//创建一个Delete对象，指定要删除列的行键rowKey
    	table.delete(delete);//执行delete方法，删除该列
	}
    
    
    
    
    
    
    
   //deletec
    public static void deleteCellValue(String strTableName, String rowKey, String columnFamily, String column) throws IOException
	{
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
    	
		TableName tableName = TableName.valueOf(strTableName); //获取表名对象
    	
		if(!isColumnFamilyExists(admin.getTableDescriptor(tableName), columnFamily)) //如果列族不存在则直接返回
		{
			System.out.println("Column Family does not exists");
			return;
		}
    	
		Table table =connection.getTable(tableName);//获取操作表的Table对象
    	Delete delete = new Delete(Bytes.toBytes(rowKey));//创建一个Delete对象，指定要删除列的行键rowKey
    	delete.addColumns(Bytes.toBytes(columnFamily), Bytes.toBytes(column));//在Delete对象中增加要删除的列，指定列族和列名
    	table.delete(delete);//执行delete方法，删除该列
	}
    
   //listNameSpaces
    public static void listNameSpaces() throws IOException//实现列出所有的表名
	{
		NamespaceDescriptor[] namespaceDescriptors = admin.listNamespaceDescriptors();
		for(NamespaceDescriptor namespaceDescriptor: namespaceDescriptors) 
		{
			System.out.println(namespaceDescriptor.getName());//获取名字空间名称的字符串
		}	
	}
  
    
    //查看指定名字空间的表
    public static void listTables(String strNameSpace) throws IOException//实现列出所有的表名
	{	
		//检查名字空间是否存在
		if(!isNameSpacesExists(strNameSpace)) //不存在则直接返回
		{
			return;
		}
				
		TableName[] tableNames = admin.listTableNamesByNamespace(strNameSpace);		
		listTables(tableNames);
	}
    public static boolean isNameSpacesExists(String strNameSpace) throws IOException//实现列出所有的表名
	{
		NamespaceDescriptor[] namespaceDescriptors = admin.listNamespaceDescriptors();
		for(NamespaceDescriptor namespaceDescriptor: namespaceDescriptors) 
		{
			if(namespaceDescriptor.getName().equals(strNameSpace))//判断名字空间名称的字符串是否相等
			{
				return true;
			}
		}
//		System.out.println("NameSpace does not exists");
		return false;
	}
    public static void listTables(TableName[] tableNames) throws IOException//实现列出所有的表名
	{	
		 for(TableName tableName : tableNames)
		 {	
			 System.out.println(tableName.getNameAsString());
		 }
	}	
    
    //createNameSpace
    public static void createNameSpace(String strNameSpace) throws IOException//实现列出所有的表名
	{
		if(isNameSpacesExists(strNameSpace))//如果名字空间存在
		{
			System.out.println("NameSpace already exists");
			return;
		}
		
//		NamespaceDescriptor namespaceDescriptor = new NamespaceDescriptor();//构造方法是私有的，不能直接调用
		NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create(strNameSpace).build();
		admin.createNamespace(namespaceDescriptor);
	}

	public static void disable(String strTableName) throws IOException {
		if(!isTableExist(strTableName)) //如果表不存在则直接返回
		{
			System.out.println("Table dose not exists");
			return;
		}
		TableName tableName = TableName.valueOf(strTableName);
		
		if(admin.isTableEnabled(tableName)) //判断表是否被禁用，如果是enabled，返回true
		{
			admin.disableTable(tableName);//删除前先将表禁用 ，使其off-line
		}
		return ;
		
	}
    
}

 hbaseshell


import java.io.IOException;
import java.util.Scanner;

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

        hbaseutils.init();//执行数据库操作之前，先 初始化，生成配置，建立连接
        String input = "";
        String[] param = {};
        
        while (true) {
            System.out.print("HbaseShell>");
            Scanner scan = new Scanner(System.in);
            input = scan.nextLine();//获取终端的下一行输入，nextLine()回车结束，不会以空格结束
            String tmp="";
            if(input.length()>0) {
            	tmp+=input.charAt(0);
            }
            
          //将各参数之间的多个空格去除，仅保留一个空格
    		for(int i=1;i<input.length();i++) {
    			if(input.charAt(i-1)==' '&&input.charAt(i)==' ') {
    				continue;
    			}
    			tmp+=input.charAt(i);
    		}
    		
            input = tmp.trim();//去掉首尾空格字符
            param = input.split(" ");//对输入按空格分隔，返回字符串列表
          
            if (param.length < 1) {//没有任何输出则跳过
                continue;
            }
   
            switch (param[0]) {
            
                case "help":
                    doCmd(param, 1);
                    break;
                case "list":
                    doCmd(param, 1);
                    break;
                case "exists":
                    doCmd(param, 2);
                    break;
                case "desc":
                    doCmd(param, 2);
                    break;
                case "create":
                    doCmd(param, 3);
                    break;
                case "alter":
                    doCmd(param, 3);
                    break;
                case "delete":
                    doCmd(param, 2);
                    break;
                case "put":
                    doCmd(param, 6);
                    break;
                case "getr":
                    doCmd(param, 3);
                    break;
                case "getc":
                    doCmd(param, 5);
                    break;
                case "scant":
                    doCmd(param, 2);
                    break;
                case "scanf":
                    doCmd(param, 3);
                    break;
                case "deleter":
                    doCmd(param, 3);
                    break;
                case "deletec":
                    doCmd(param, 5);
                    break;
                case "listTables":
                    doCmd(param,2);
                    break;
                case "disable":
                    doCmd(param,2);
                    break;    
                case "listNameSpaces":
                    doCmd(param, 1);
                    break;
                case "createNameSpace":
                    doCmd(param, 2);
                    break;
                case "quit":
                    hbaseutils.close();//执行数据库操作之后，关闭连接，释放资源
                    return;
                case "":
                    break;
                default:
                    System.out.println("invalid command");
            }
        }
    }

    //根据终端输入的不同参数，执行不同的命令
    static void doCmd(String[] param, int len) throws IOException {
        if (param.length == len && len == 1) {
            if (param[0].equals("help")) {
            	hbaseutils.helpinfo();//显示帮助信息
            }
            if (param[0].equals("listNameSpaces")) {
            	hbaseutils.listNameSpaces();//显示帮助信息
            }
            if (param[0].equals("list")) {
                hbaseutils.listTables();//列出默认名字空间default的所有表名
            }
        } else if (param.length == len && len == 2) {
            
            if (param[0].equals("exists")) {
                if (hbaseutils.isTableExist(param[1])) {
                    System.out.println("Table " + param[1] + " does exist");
                } else {
                    System.out.println("Table " + param[1] + " does not exist");
                }
            }
            if (param[0].equals("desc")) {
                hbaseutils.descTable(param[1]);
            }
            if (param[0].equals("listTables")) {
                hbaseutils.listTables(param[1]);
            }
            if (param[0].equals("disable")) {
                hbaseutils.disable(param[1]);
            }
            if (param[0].equals("createNameSpace")) {
                hbaseutils.createNameSpace(param[1]);
            }
            if (param[0].equals("scant")) {
                hbaseutils.scanTable(param[1]);
            }
            if(param[0].equals("delete")) {
            	hbaseutils.dropTable(param[1]);
            }
        } else if (param.length == len && len == 3) {
        	 if (param[0].equals("create")) {
        		 hbaseutils.createTable(param[1], param[2]);
        	 }
        	 if(param[0].equals("alter")) {
        		 hbaseutils.alterTable(param[1], param[2]);
        	 }
        	 if (param[0].equals("scanf")) {
                 hbaseutils.scanTable(param[1],param[2]);
             }
        	 if(param[0].equals("deleter")) {
             	hbaseutils.deleteCellValue(param[1], param[2]);
             }
        	 if(param[0].equals("getr")) {
             	hbaseutils.getCellValue(param[1], param[2]);
             }
        } else if (param.length == len && len == 4) {
        	
        } else if (param.length == len && len == 5) {
        	if(param[0].equals("getc")) {
            	hbaseutils.getCellValue(param[1], param[2], param[3], param[4]);
            }
        	if(param[0].equals("deletec")) {
            	hbaseutils.deleteCellValue(param[1], param[2], param[3], param[4]);
            }
        } else if (param.length == len && len == 6) {
        	if(param[0].equals("put")) {
            	hbaseutils.putACellValue(param[1], param[2], param[3], param[4], param[5]);
            }
        } else {
            System.out.println("invalid format");
        }
    }

    
}

用一个命令来展示一下效果

钟爱陈奕迅
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java实现正向Shell(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-18 167
java实现正向Shell(附完整源码)
HBase高手之路5—HBase的JavaAPI编程
W_chuanqi的博客
04-10 2601
关闭所有的项目，在Idea的启动页。
hbase 上传下载文件
既认准这条路，又何必在意要走多久
03-16 7589
hbase 是高读的，虽然写的速度不很乐观，但是有时候也需要往里面存一些文件。（一般建议存放在hdfs上），这里讲一下怎么把文件存储到hbase上 首先大家都知道的，hbase 只支持 byte 的存储，所以我们首先要做的是吧文件变换为byte 以下就用代码来描述这些： 这里用了spring-data 的hbasetemplate sring的配置如下 <beans xmlns
HBase2.2.2编程实践
最後の後悔的博客
04-26 534
解决WARN [main] util.NativeCodeLoader (NativeCodeLoader.java:(62)) - Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
shell 跟java 相互调用和获取结果
webdev2008的专栏
11-08 308
被调用的shell a.sh #!/bin/bash echo 111 exit 8  java 代码 public static void main(String[] args) throws IOException { Process p = Runtime.getRuntime().exec(command); InputStream is = p.getInput...
HBase与MapReduce处理操作（基于JavaAPI）
05-30
该案例中主要使用MapReduce作为处理组件进行数据处理，实现的案例有如通过javaapi实现hbase数据写入hdfs、hbase表数据复制到另一个表中等操作 对应（《HBase分布式存储系统应用》胡鑫喆 张志刚著）教材中案例
利用java api读取hbase数据遇到的一些坑及解决方法
01-20
java.lang.RuntimeException: org.apache.hadoop.hbase.client.RetriesExhaustedException: Failed after attempts=36, exceptions: Fri Feb 14 10:30:36 CST 2020, null, java.net.SocketTimeoutException: ...
使用Java API连接虚拟机HBase并进行数据库操作，Java源代码
05-21
通过Java API，我们可以方便地与HBase交互，实现数据的增、删、改、查等操作。 首先，确保你的开发环境已经配置了HBase的Java客户端库。这通常可以通过在`pom.xml`（如果你使用的是Maven）或`build.gradle`（如果你...
11-HBase Java API编程实践1
08-08
HBase Java API 编程实践 在本实践中，我们将使用 Eclipse 编写 Java 程序，来对 HBase 数据库进行增删改查等操作。首先，我们需要启动 Hadoop 和 HBase，然后新建一个 Java 项目并导入 HBase 的 jar 包。接着，...
HBase常用Java API
01-07
本节介绍与 HBase 数据存储管理相关的 Java API（基于 HBase 版本 1.2.3）。 HBase 的常用Java API HBase 主要包括 5 大类操作：HBase 的配置、HBase 表的管理、列族的管理、列的管理、数据操作等。 1）org.apache....
java实现的简易xshell终端
04-28
java调用JSch实现的简易的命令行Xshell(运行jar包时，执行ls命令乱码(开发环境运行正常)，改用sudo ls运行正常)
JediTerm纯Java终端模拟器。适用于SSH和PTY。
08-08
JediTerm 提供了一个纯 Java 的终端部件可轻松的嵌入到集成开发环境中。支持 SSH 终端会话和 OS X、Linux 和 Windows 上的 PTY。
java shell 交互命令_使用processBuilder执行shell命令并与之交互
weixin_39612554的博客
03-02 743
小编典典“(实际上是“ ls”，但它应该以完全相同的方式工作)”不它不是。因为“ ls”过程在调用后立即返回。另一方面，您的omixplayer是交互式的，将在运行时接受命令。您要做的是：创建一个实现Runnable的类，并让该类从prs.getInputStream()中读取。您将需要这样做，因为.read()将阻塞并等待读取新数据。获取Process对象的输出流(prs.getOutputSt...
HBase Shell命令行实验
小忐忑的博客
04-28 2289
第1题 创建一个名称为eshop的名字空间，并列出所有名字空间 create_namespace 'eshop' list_namespace 第2题 在eshop名字空间中创建一张新的数据表，表名为shopping，包含1个列族customer；再列出HBase的所有数据表。 create 'eshop:shopping','customer' list 第3题 给eshop名字空间中的shopping表增加两个新的列族order和item alter 'eshop:shopping', NAME
HbaseJAVA开发API导入jar包以及实现操作命令
master_hunter的博客
10-19 4777
前言 上一篇：常用的HBase Shell操作 提示：以下是本篇文章正文内容，下面案例可供参考 一、HbaseLibrary设置 因为以后经常使用Hbase都是用JAVA进行开发，很常用JAVA中的APIHbase包，所以我们直接创建一个Library。以后使用方便 。 点击Configure Build Path： 点击Add Library 创建一个你想要的Library，比如创建一个Hbasejar包库。 我们hbase的jar包在lib里面，全选...
终端模拟器 java_程序员必备之终端模拟器，让你的终端世界多一抹“颜色”
weixin_31437143的博客
02-13 746
当你逐渐厌倦了 cmd 的枯燥黑屏、powershell 的单调蓝底，可以来尝试一下使用可定制性更高的终端模拟器。下面是 HelloGitHub 从 GitHub 上收集的一些开源终端模拟器，它们功能丰富，界面美观，可以完美替代掉系统自带的普通终端。萝卜白菜各有所爱，挑挑看有没有让你眼前一亮，整篇文章最靓的那个“仔”。1. Windows TerminalGitHub 项目：https://git...
【HBase】Java 操作 HBase 超详细示例（转）
A minor
01-27 2636
原文链接：http://blog.csdn.net/u010967382/article/details/37878701。本文做了一些简单补充和排版。 对于建表，和 RDBMS 类似，HBase 也有 namespace 的概念，可以指定表空间创建表，也可以直接创建表，进入 default 表空间。对于数据操作，HBase 支持四类主要的数据操作，分别是： Put：增加一行，修改一行； Delete：删除一行，删除指定列族，删除指定 column 的多个版本，删除指定 column 的制定版本等； .
java 交互式 shell_Java9 Shell工具(JShell)
weixin_29809927的博客
02-26 559
Java Shell工具(JShell)它是一个交互式Java Shell工具，它使我们能够从Shell中执行Java代码并立即显示输出。 JShell是一个REPL(读取评估打印循环)工具，可从命令行运行。JShell的优点Jshell减少了运行Java程序和测试业务逻辑所需的所有工作。如果我们不使用Jshell，则创建Java程序涉及以下步骤。打开编辑器并编写程序保存程序编译程序编辑是否存在编...
java cmd 交互_java交互式命令行调研
weixin_34296646的博客
02-23 452
jline jar ，好像是 hive 的命令行 也使用了，http://jline.sourceforge.net以下是引用别人的信息：OverviewJLine 是一个用来处理控制台输入的Java类库，目前最新的版本是0.9.94。其官方网址是http://jline.sourceforge.net。在介绍JLine之前，首先还是介绍一下Java 6中的Console类，以便进行对比...
开发一个模拟HBase Shell命令行终端的应用程序实现其DDL分组和DML分组的常用操作命令。
最新发布
05-24
好的，以下是一个简单的模拟HBase Shell命令行终端的应用程序，可以实现DDL分组和DML分组的常用操作命令： ```python class HBaseShell: def __init__(self): self.tables = {} # 存储所有表的数据 self.current...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

钟爱陈奕迅

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

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

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

打赏作者

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

抵扣说明：

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

余额充值