HBase Java API编程：源码详解

示例源码1：

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
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;



public class HBaseJavaAPIDemo 
{
	public static void main(String args[]) throws IOException
	{	
		//	Configuration configuration = new Configuration();//不采用这个构造方法
		Configuration configuration = HBaseConfiguration.create();//HBaseConfiguration类继承了Configuration类，调用子类HBaseConfiguration的create静态方法，创建一个拥有HBase资源的父类对象
		//configuration.addResource(file);
		
		System.out.println(configuration.toString());//列出配置类中的配置文件，其中hbase-default.xml是默认配置文件，包含HBase所有的默认配置参数，位置在hbase-1.2.0-cdh5.7.0/hbase-common/src/main/resources/hbase-default.xml
		

		configuration.set("hbase.zookeeper.quorum", "hadoop");加载需要连接HBase的各项配置参数，记得在开发机win7的hosts文件中增加虚拟机的主机名hadoop和IP地址的映射
//        configuration.set("hbase.zookeeper.property.clientPort", "2181");
//		configuration.set("hbase.rootdir", "hdfs://hadoop:8020/hbase");	
		
		System.out.println(configuration.get("hbase.zookeeper.quorum"));//根据参数名获得参数值	
		System.out.println(configuration.get("hbase.rootdir"));


//		Connection  connection = new Connection();//Connection是一个接口，接口不能实例化
		Connection  connection = ConnectionFactory.createConnection(configuration);//接口不可以被实例化,但是接口变量可以引用它的实现类的对象;  Connection是一个接口interface，createConnection方法返回一个对象，接口变量connection能引用一个对象
		System.out.println(connection.getClass().getName());
		
		TableName tableName  = TableName.valueOf("students1");//调用TableName类的valueOf静态方法，得到一个TableName类的对象，tableName对象封装了表名
	
//		Admin admin = new Admin();//Admin是一个接口，接口不能实例化
		Admin admin = connection.getAdmin();//调用connection的getAdmin方法，获取一个Admin接口的实现类HBaseAdmin对象，
	
		boolean isTableExists = admin.tableExists(tableName);
		
		System.out.println(isTableExists);
	}	
}

示例源码2：

Java语法点：“接口引用可以指向其实现类的对象”

interface Running //定义一个接口Running
{
	void run();//声明一个接口方法
}

class Dog implements Running  //定义一个类Dog，实现接口Running
{
	 public void run() //实现Running接口中的run()方法
	{
		System.out.println("dog is running");
	}
}

class Horse implements Running  //定义一个类Horse，实现接口Running
{
	 public void run() //实现Running接口中的run()方法
	{
		System.out.println("horse is running");
	}
}


public class testInterface 
{
	public static void main(String args[]) 
	{
		Running  running;//声明一个Running接口的引用变量
//		Dog dog = new Dog();//实例化Dog类的对象dog
//		running = dog; //将Running接口的引用变量，指向其实现类Dog的对象dog
		running = new Dog();
		running.run();//通过Running接口的引用对象，调用dog对象的run()方法
		
//		Horse horse = new Horse();//实例化Horse类的对象horse
//		running = horse; //将Running接口的引用变量，指向其实现类Horse的对象horse
		running = new Horse();
		running.run();//通过Running接口的引用对象，调用dog对象的run()方法
		
	}	
}

//为什么要用接口变量指向实现类的对象？这种写法其实Java多态性的表现形式
//多态的定义：指允许不同类的对象对同一调用方式做出不同响应，即根据发送对象的不同而采用不同的行为方式。
//问题就在于Running接口有多个实现类，如 Dog或者Horse等，现在你用的是Horse，也许哪一天你需要换成其它的实现类Dog呢？
//这时你只要改变这一行就行了：Running  running = new Horse(); 其它使用了running地方的代码根本不需要改动。
//假设你开始用 Horse horse = new Horse(), 这下你有的改了;,最好使用Running  running = new Horse(); ,
//便于程序代码的复用. 这就是面向接口编程的好处

进行代码重构，提高代码复用性和可读性：

第1步：把main方法中的业务代码提炼成一个方法

第2步：把Configuration相关的代码放置到Java静态代码块中（主类加载后只被执行一次）

第3步：把Connection相关的代码放置到Java静态代码块中（主类加载后只被执行一次）

第4步：把Admin相关的代码放置到Java静态代码块中（主类加载后只被执行一次）

第5步：把与Configuration, Connection, Admin相关的代码全都放到一个静态的初始化方法init()中

第6步：数据库操作结束后，把与关闭数据库连接的所有操作统一放到一个静态的关闭方法close()中

示例源码3：

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
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;

public class HBaseJavaAPIDemo 
{
	public static Configuration configuration;
	public static Connection connection;
	public static Admin admin;
	
//	static //Java静态代码块,在类被加载的时候执行且仅会被执行一次
//	{
//		configuration = HBaseConfiguration.create();
//		configuration.set("hbase.zookeeper.quorum", "hadoop");
//		try 
//		{
//			connection = ConnectionFactory.createConnection(configuration);	
//			admin = connection.getAdmin();
//		}
//		catch(IOException e)
//		{
//            e.printStackTrace();
//        }	
//	}
	
	public static void init() //执行数据库操作之前，把与创建configuration, Connection, Admin相关的代码统一放到静态的初始化方法init()中
	{
		configuration = HBaseConfiguration.create();
		configuration.set("hbase.zookeeper.quorum", "hadoop");
		try 
		{
			connection = ConnectionFactory.createConnection(configuration);	
			admin = connection.getAdmin();
		}
		catch(IOException e)
		{
            e.printStackTrace();
        }
	}
	
	public static void close() //数据库操作结束后，将与关闭数据库连接的所有操作统一放到一个静态的关闭方法close()中
	{	
		try 
		{
			admin.close();
			connection.close();			
		}
		catch(IOException e)
		{
            e.printStackTrace();
        }
	}
	
	public static boolean isTableExist(String strTableName) throws IOException
	{	
//		Connection connection = ConnectionFactory.createConnection(configuration);		
		TableName tableName  = TableName.valueOf(strTableName);
//		Admin admin = connection.getAdmin();	
		boolean isTableExists = admin.tableExists(tableName);	
		System.out.println(isTableExists);	
		return isTableExists;
	}	
	
	public static void main(String args[]) throws IOException
	{	
		init();
		
		boolean isExists = isTableExist("students");
		if(isExists) 
		{
			System.out.println("Table exists");
		}
		else 
		{
			System.out.println("Table dose not exists");
		}
		
		close();
	}
}

第7步：把数据库初始化，各种数据库操作的方法，关闭连接的方法都封装到一个统一的HBase Java API工具类中，进一步提升代码复用性，降低代码耦合性，提高代码可维护性

示例源码4：

class HBaseJavaAPIUtils //把数据库初始化，各种数据库操作的方法，关闭连接的方法都封装到一个HBase工具类中，方便维护，进一步提升代码复用性，降低代码耦合性
{
	public static Configuration configuration;
	public static Connection connection;
	public static Admin admin;
	
	public static void init() //执行数据库操作之前，把与创建configuration, Connection, Admin相关的代码统一放到静态的初始化方法init()中
	{
		configuration = HBaseConfiguration.create();
		configuration.set("hbase.zookeeper.quorum", "hadoop");
		try 
		{
			connection = ConnectionFactory.createConnection(configuration);	
			admin = connection.getAdmin();
		}
		catch(IOException e)
		{
            e.printStackTrace();
        }
	}
	
	public static void close() //数据库操作结束后，将与关闭数据库连接的所有操作统一放到一个静态的关闭方法close()中
	{	
		try 
		{
			admin.close();
			connection.close();			
		}
		catch(IOException e)
		{
            e.printStackTrace();
        }
	}
	
	public static boolean isTableExist(String strTableName) throws IOException
	{			
		TableName tableName  = TableName.valueOf(strTableName);
		boolean isTableExists = admin.tableExists(tableName);	
		System.out.println(isTableExists);	
		return isTableExists;
	}	
}

第8步：把所有调用了HBase Java API的，与数据库访问操作相关的代码都封装成一个HBase工具类HBaseJavaAPIUtils，并单独放到一个Java源码文件中来专门维护；而HBaseJavaAPIDemo类只负责调用工具类提供的数据库操作方法，无需要关心具体怎么调用HBase Java API，而是聚焦于上层业务逻辑的开发；体现了软件工程的代码解耦合、代码复用等思想、进一步提高了代码的可维护性，更不容易产生bug

HBase工具类文件HBaseJavaAPIUtils.java的源码如下，所有编写的HBase Java API的DDL操作方法全都放到这里

示例源码5：

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.NamespaceDescriptor;
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;

public class HBaseJavaAPIUtils //HBase操作工具类
{
	public static Configuration configuration;
	public static Connection connection;
	public static Admin admin;
	
		/**
	* 执行数据库操作之前，把与创建configuration, Connection, Admin相关的代码统一放到静态的初始化方法init()中
	* @parameter 无
	* @return void 
	*/
	public static void init() throws IOException  
	{
		configuration = HBaseConfiguration.create();		
		configuration.set("hbase.zookeeper.quorum", "hadoop");	
	
		connection = ConnectionFactory.createConnection(configuration);	//实质得到是Connection接口的间接实现类HConnectionImplementation的一个实例		
		admin = connection.getAdmin();//实质得到是Admin接口的直接接实现类HBaseAdmin的一个实例				
	}

	/**
	* 数据库操作结束后，将与关闭数据库连接的所有操作统一放到一个静态的关闭方法close()中
	* @parameter 无
	* @return 无 
	*/
	public static void close() throws IOException
	{
		connection.close();
		admin.close();
	}

   /**
	 * 将检查表名格式是否正确的代码提炼成一个方法供其他方法调用，提高代码的复用性
	* 检查输入参数的表名字符串的格式是否正确，只有TableName(缺省default名字空间)或NameSpace:TableName两种格式，正确则返回true，不正确则返回fase
	* @parameter String  strTableName 表名
	* @return boolean 
	*/
	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(":") || 
		   strTable