hadoop hbase

已于 2022-08-21 15:20:40 修改
阅读量302 收藏
点赞数
分类专栏： hadoop 文章标签： hbase hadoop
于 2017-07-07 14:47:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/spencer_tseng/article/details/74699792
版权

个人笔记，IBM合作的一个项目做了一个简单功能部分记录下。 

package com.ibm.bi.ccb.TC_OLTP_06;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HTable;
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.mapreduce.LoadIncrementalHFiles;
import org.apache.hadoop.hbase.util.Bytes;

/**
 * 操作HBASE工具类
 * 
 * @author ZengWenfeng
 * @date 2013-03-24
 */
public class HBaseUtil
{
	/**
	 * 配置文件
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 */
	private static Configuration conf = null;

	/**
	 * 加载配置文件
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 */
	static 
	{
		conf = HBaseConfiguration.create();

		
//		<configuration>
//		  <property>
//		      <name>hbase.cluster.distributed</name>
//		      <value>true</value>
//		   </property>
//
//		   <property>
//		     <name>hbase.rootdir</name>
//		     <value>hdfs://masternode:8020/hbase</value>
//		   </property>
//
//		   <property>
//		     <name>hbase.zookeeper.quorum</name>
//		     <value>masternode</value>
//		 </property>
//		</configuration>
		
		conf.set("hbase.cluster.distributed", "true");
		conf.set("hbase.rootdir", "hdfs://masternode:8020/hbase");
		conf.set("hbase.zookeeper.quorum", "slavenode6");

//		conf.set("hbase.master", "gwnode1:8020");
//		conf.set("hbase.zookeeper.quorum", "172.16.123.210");  
//		conf.set("hbase.zookeeper.property.clientPort", "8020"); 
	}

	public void loadFiles()
	{
		try
		{
			Path hfofDir = null;
			HTable table = null;
			
			LoadIncrementalHFiles loadFiles = new LoadIncrementalHFiles(conf);
			loadFiles.doBulkLoad(hfofDir, table);
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * 创建表
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 * @param tabelNam 表名
	 * @param cfs 列族
	 * @throws IOException
	 */
	public void createTable(String tabelName, List<String> cfs) throws IOException 
	{
		HBaseAdmin admin = new HBaseAdmin(conf);

		if (admin.tableExists(tabelName)) 
		{
			System.out.println("table exist.");
		} 
		else 
		{
			HTableDescriptor tableDesc = new HTableDescriptor(tabelName);

			if (cfs.isEmpty()) 
			{
				admin.close();
				return;
			}

			for (int i = 0; i < cfs.size(); i++) 
			{
				tableDesc.addFamily(new HColumnDescriptor(cfs.get(i)));
			}

			admin.createTable(tableDesc);
		}

		admin.close();
	}

	/**
	 * 删除表
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 * @param tableName
	 * @throws IOException
	 */
	public void deleteTable(String tableName) throws IOException 
	{
		HBaseAdmin admin = new HBaseAdmin(conf);

		try 
		{
			admin.disableTable(tableName);
			admin.deleteTable(tableName);
			System.out.println("删除成功");
		} 
		catch (MasterNotRunningException e) 
		{
			e.printStackTrace();
		} 
		catch (ZooKeeperConnectionException e) 
		{
			e.printStackTrace();
		} 
		finally 
		{
			admin.close();
		}
	}

	/**
	 * 插入记录
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 * @param tableName
	 * @param cfs
	 * @throws IOException
	 */
	public void writeRow(String tableName, List<String> cfs) throws IOException 
	{
		HTable table = new HTable(conf, tableName);

		try 
		{
			Put put = new Put(Bytes.toBytes(cfs.get(0)));
			put.add(Bytes.toBytes(cfs.get(1)), Bytes.toBytes(cfs.get(2)), Bytes.toBytes(cfs.get(3)));
			table.put(put);
//			table.put(puts);
			System.out.println("插入成功");
		}
		catch (IOException e) 
		{
			e.printStackTrace();
		} 
		finally 
		{
			table.close();
		}
	}

	/**
	 * 更新记录
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 * @param tableName
	 * @param cfs
	 * @throws IOException
	 */
	public void updateRow(String tableName, List<String> cfs) throws IOException 
	{
		HTable table = new HTable(conf, tableName);

		try 
		{
			Put put = new Put(Bytes.toBytes(cfs.get(0)));
			put.add(Bytes.toBytes(cfs.get(1)), Bytes.toBytes(cfs.get(2)), Bytes.toBytes(cfs.get(3)));
			table.put(put);
			System.out.println("success");
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		finally 
		{
			table.close();
		}
	}

	/**
	 * 删除记录
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 * @param tableName
	 * @param rowkey
	 * @throws IOException
	 */
	public void deleteRow(String tableName, String rowkey) throws IOException 
	{
		HTable table = new HTable(conf, tableName);

		List<Delete> list = new ArrayList<Delete>();
		Delete d1 = new Delete(rowkey.getBytes());
		list.add(d1);
		table.delete(list);
		System.out.println("删除成功");

		table.close();
	}
	
	
	public void query(String tableName, String[] rowKeys) throws IOException
	{
		if (tableName == null || tableName.equals(tableName))
		{
			return;
		}
	}

	/**
	 * 查询
	 * 
	 * @param tableName
	 * @param rowkey
	 */
	public void selectRow(String tableName, String rowKey) throws IOException 
	{
		HTable table = new HTable(conf, tableName);
		Get g = new Get(rowKey.getBytes());
		Result rs = table.get(g);

		if (rs != null && rs.size() > 0)
		{
			for (KeyValue kv : rs.raw())
			{
				System.out.println(new String(kv.getRow()) + "|"
						+ new String(kv.getFamily()) + ":"
						+ new String(kv.getQualifier()) + "|"
						+ new String(kv.getValue()) + "|" + kv.getTimestamp());
			}
		}

		table.close();
	}

	/**
	 * 扫描表
	 * 
	 * @param tableName
	 * @throws IOException
	 */
	public void scan(String tableName) throws IOException 
	{
		HTable table = new HTable(conf, tableName);

		try 
		{
			Scan s = new Scan();
			ResultScanner rs = table.getScanner(s);
			for (Result r : rs) 
			{
				KeyValue[] kv = r.raw();
				for (int i = 0; i < kv.length; i++) 
				{
					System.out.println(new String(kv[i].getRow()) + "|"
							+ new String(kv[i].getFamily()) + ":"
							+ new String(kv[i].getQualifier()) + "|"
							+ new String(kv[i].getValue()) + "|"
							+ kv[i].getTimestamp());
				}
			}
		}
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		finally 
		{
			table.close();
		}
	}

	/**
	 * 仅供测试
	 * 
	 * @author ZengWenfeng
	 * @date 2013-03-24
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException 
	{
		HBaseUtil hu = new HBaseUtil();
		
		hu.deleteTable("zwf01");
		
//		ArrayList<String> al = new ArrayList<String>();
//		al.add("fdsafsd");
//		al.add("bbb");
//		hu.createTable("sfds", al);
		
//		StringBuffer sb = new StringBuffer();
//
//		for (String s : args) 
//		{
//			sb.append(s + " ");
//		}
//
//		System.out.println(sb.toString());
//
//		HBaseUtil hb = new HBaseUtil();
//
//		if (args.length <= 1 || args[0].equalsIgnoreCase("help")) 
//		{
//			System.out.println("--help--");
//		} 
//		else if (args[0].equalsIgnoreCase("-c") || args[0].equalsIgnoreCase("create")) 
//		{
//			List<String> strs = new ArrayList<String>();
//
//			for (int i = 2; i < args.length; i++)
//			{
//				strs.add(args[i]);
//			}
//
//			hb.createTable(args[1], strs);
//		} 
//		else if (args[0].equalsIgnoreCase("-dt") || args[0].equalsIgnoreCase("delete-table")) 
//		{
//			hb.deleteTable(args[1]);
//		}
//		else if (args[0].equalsIgnoreCase("-i") || args[0].equalsIgnoreCase("insert")) 
//		{
//			List<String> strs = new ArrayList<String>();
//			for (int i = 2; i < args.length; i++) 
//			{
//				strs.add(args[i]);
//			}
//
//			hb.writeRow(args[1], strs);
//		} 
//		else if (args[0].equalsIgnoreCase("-dr") || args[0].equalsIgnoreCase("delete-row")) 
//		{
//			hb.deleteRow(args[1], args[2]);
//		}
//		else if (args[0].equalsIgnoreCase("-qr") || args[0].equalsIgnoreCase("query-row")) 
//		{
//			hb.selectRow(args[1], args[2]);
//		}
//		else if (args[0].equalsIgnoreCase("-qa") || args[0].equalsIgnoreCase("query-all")) 
//		{
//			hb.scan(args[1]);
//		}
//		else if (args[0].equalsIgnoreCase("-u") || args[0].equalsIgnoreCase("update")) 
//		{
//			List<String> strs = new ArrayList<String>();
//
//			for (int i = 2; i < args.length; i++) 
//			{
//				strs.add(args[i]);
//			}
//
//			hb.updateRow(args[1], strs);
//		}
	}
}

package com.ibm.bi.ccb.TC_OLTP_06;

import java.io.IOException;

/**
 * @author ZengWenfeng
 * @date 2013-04-11
 */
public class Task extends Thread
{
	/**
	 * 表名
	 */
	private String tableName;
	
	/**
	 * 主键
	 */
	private String[] rowKeys;
	
	/**
	 * 构造函数
	 */
	public Task()
	{
		
	}
	
	/**
	 * 构造函数
	 */
	public Task(String tableName, String[] rowKeys)
	{
		this.tableName = tableName;
		this.rowKeys = rowKeys;
	}

	@Override
	public void run()
	{
		System.out.println(Thread.currentThread().getName());

		if (rowKeys != null && rowKeys.length > 0)
		{
			for (int i = 0; i < rowKeys.length; i++)
			{
				HBaseUtil hu = new HBaseUtil();

				try
				{
					hu.selectRow(tableName, rowKeys[i]);
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
		else
		{
			System.out.println("error");
		}
	}
	
}


package com.ibm.bi.ccb.TC_OLTP_06;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.HTable;
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.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;

import com.ibm.bi.ccb.framework.ResourceManager;

/**
 * TC_OLTP_06
 * 
 * @author ZengWenfeng
 * @date 2013-04-12
 */
public class TC_OLTP_06_Task extends Thread
{
	/**
	 * 日志
	 */
	private static final Logger logger = ResourceManager.logger(TC_OLTP_06_Task.class);

	/**
	 * 查询的表名
	 */
	private String tableName = "";

	/**
	 * 多个主键组
	 */
	private String rowKeys = "";
	
	/**
	 * 开始时间
	 */
	private long startTime = 0L;
	
	/**
	 * 查询结果集合
	 */
	public static List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

	/**
	 * 
	 */
	public TC_OLTP_06_Task(long startTime)
	{
		this.startTime = startTime;
	}

	/**
	 * 根据给定的主键以及表名执行查询
	 * 
	 * @see dev.toolkit.concurrent.Task#doTask()
	 */
	public void run()
	{
		try
		{
			ArrayList<Filter> al = new ArrayList<Filter>();

			String[] keys = rowKeys.split(",");

			for (int i = 0; i < keys.length; i++)
			{
				Filter filter = new RowFilter(CompareFilter.CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes(keys[i])));
				al.add(filter);
			}


			FilterList filterList = new FilterList(al);

			Scan scan = new Scan();
			scan.setFilter(filterList);

			Configuration conf = HBaseConfiguration.create();
			conf.set("hbase.cluster.distributed", "true");
			conf.set("hbase.rootdir", "hdfs://masternode:8020/hbase");
			conf.set("hbase.zookeeper.quorum", "slavenode6");
			
			HTable table = new HTable(conf, tableName);

			ResultScanner rs = table.getScanner(scan);
			
			list = new ArrayList<Map<String, Object>>();
			
			logger.info("Scanning " + tableName + "...");
			for (Result r : rs) 
			{
				KeyValue[] kv = r.raw();
				for (int i = 0; i < kv.length; i++) 
				{
					
					Map<String, Object> data = new HashMap<String, Object>();
					data.put("ROW", new String(kv[i].getRow()));
					data.put("FAMILY_QUALIFIER", new String(kv[i].getFamily()) + ":" + new String(kv[i].getQualifier()));
					data.put("VALUE", new String(kv[i].getValue()));
					data.put("TIME", kv[i].getTimestamp());
					list.add(data);
					
//					System.out.println(new String(kv[i].getRow()) + "|"
//							+ new String(kv[i].getFamily()) + ":"
//							+ new String(kv[i].getQualifier()) + "|"
//							+ new String(kv[i].getValue()) + "|"
//							+ kv[i].getTimestamp());
				}
			}
			rs.close();
			
			long stopTime = System.currentTimeMillis();
			logger.info("stopTime: " + stopTime + " ms");
			long executeTime = stopTime - startTime;
			logger.info("executeTime: " + executeTime + "ms");			
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}

	public String getTableName()
	{
		return tableName;
	}

	public void setTableName(String tableName)
	{
		this.tableName = tableName;
	}

	public String getRowKeys()
	{
		return rowKeys;
	}

	public void setRowKeys(String rowKeys)
	{
		this.rowKeys = rowKeys;
	}

	public long getStartTime()
	{
		return startTime;
	}

	public void setStartTime(long startTime)
	{
		this.startTime = startTime;
	}
}


/**
 * TC_OLTP_06.java
 * 
 * 俗世翩翩少年歌一曲
 * 把心声写给青山听
 */
package com.ibm.bi.ccb.TC_OLTP_06;

import java.util.ArrayList;

import org.slf4j.Logger;

import com.ibm.bi.ccb.framework.ResourceManager;

/**
 * TC_OLTP_06
 * 
 * @author ZengWenfeng
 * @date 2013-04-12
 */
public class TC_OLTP_06
{
	/**
	 * 日志
	 */
	private static final Logger logger = ResourceManager.logger(TC_OLTP_06.class);
	
	/**
	 * 线程数
	 */
	private static int threadNumber = 1;

	/**
	 * 任务数组
	 */
	private static TC_OLTP_06_Task[] tasks = null;

	/**
	 * 构造函数
	 */
	public TC_OLTP_06()
	{
		logger.info("TC_OLTP_06 initialized");
	}

	/**
	 * 主函数,仅供测试
	 * wot, 1,12,2
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-17
	 * @param args
	 */
	public static void main(String[] args)
	{
		//
		String tableName = "";
		String rowKeys = "";

		// one argument
		if (args.length == 1)
		{
			tableName = args[0];
		}
		// two arguments
		else if (args.length == 2)
		{
			tableName = args[0];
			rowKeys = args[1];
		}
		// exception
		else
		{
			System.out.println("args is null.");
			System.out.println("usage: Test <tableName> <rowKey1,rowKey2,...,rowKeyn>");
			return;
		}
		
		//执行任务
		excuteTask(tableName, rowKeys);
	}
	
	/**
	 * 执行任务
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-17
	 * @param tableName
	 * @param rowKeys
	 */
	public static void excuteTask(String tableName, String rowKeys)
	{
		// 校验表名，为空不能执行查询
		if (tableName == null || tableName.equals(""))
		{
			System.out.println("args[0] is table name. it is not null.");
			System.out.println("usage: Test <tableName> <rowKey1,rowKey2,...,rowKeyn>");
			return;
		}
		
		// 去重rowKeys
		rowKeys = removeDuplicateRecords(rowKeys);
		
		tasks = new TC_OLTP_06_Task[threadNumber];

		try
		{
			long startTime = System.currentTimeMillis();
			logger.info("startTime: " + startTime + " ms");
			for (int i = 0; i < threadNumber; i++)
			{
				TC_OLTP_06_Task task = new TC_OLTP_06_Task(startTime);
				task.setTableName(tableName);
				task.setRowKeys(rowKeys);
				task.start();
			}
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * 删除重复记录
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-11
	 * @param rowKeys
	 * @return
	 */
	public static String removeDuplicateRecords(String rowKeys)
	{
		if (rowKeys.indexOf(",") <= 0)
		{
			return rowKeys;
		}
		
		String[] keys = rowKeys.split(",");
		ArrayList<String> al = new ArrayList<String>();
		
		//
		for (int i = 0; i < keys.length; i++)
		{
			if (!al.contains(keys[i]))
			{
				al.add(keys[i]);
			}
		}
		
		//
		StringBuffer sb = new StringBuffer();
		for (int j = 0; j < al.size(); j++)
		{
			sb.append(al.get(j));
			
			if (j < al.size() - 1)
			{
				sb.append(",");
			}
		}
		return sb.toString();
	}
}


package com.ibm.bi.ccb.TC_OLTP_06;

import java.io.IOException;
import java.util.ArrayList;

import org.slf4j.Logger;

import com.ibm.bi.ccb.framework.ResourceManager;

/**
 * TC_OLTP_06
 * 
 * @author ZengWenfeng
 * @date 2013-04-10
 */
public class Test
{
	/**
	 * 日志
	 */
	private static final Logger logger = ResourceManager.logger(Test.class);

	/**
	 * 最大线程数
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-10
	 */
	private static int maxThreadNum = 30;

	/**
	 * 构造函数
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-10
	 */
	public Test()
	{
		logger.info("TC_OLTP_06 initialized");
	}
	
	/**
	 * 删除重复记录
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-11
	 * @param rowKeys
	 * @return
	 */
	public static String removeDuplicateRecords(String rowKeys)
	{
		if (rowKeys.indexOf(",") <= 0)
		{
			return rowKeys;
		}
		
		String[] keys = rowKeys.split(",");
		ArrayList<String> al = new ArrayList<String>();
		
		//
		for (int i = 0; i < keys.length; i++)
		{
			if (!al.contains(keys[i]))
			{
				al.add(keys[i]);
			}
		}
		
		StringBuffer sb = new StringBuffer();
		for (int j = 0; j < al.size(); j++)
		{
			sb.append(al.get(j));
			
			if (j < al.size() - 1)
			{
				sb.append(",");
			}
		}
		
		return sb.toString();
	}

	/**
	 * 仅供测试
	 * 
	 * @author ZengWenfeng
	 * @date 2013-04-10
	 * @param args
	 */
	public static void main(String[] args)
	{
		//
		String tableName = "";
		String rowKeys = "";

		// one argument
		if (args.length == 1)
		{
			tableName = args[0];
		}
		// two arguments
		else if (args.length == 2)
		{
			tableName = args[0];
			rowKeys = args[1];
		}
		// exception
		else
		{
			System.out.println("args is null.");
			System.out.println("usage: Test <tableName> <rowKey1,rowKey2,...,rowKeyn>");
			return;
		}

		// 校验表名，为空不能执行查询
		if (tableName == null || tableName.equals(""))
		{
			System.out.println("args[0] is table name. it is not null.");
			System.out.println("usage: Test <tableName> <rowKey1,rowKey2,...,rowKeyn>");
			return;
		}
		
		// 去重rowKeys
		rowKeys = removeDuplicateRecords(rowKeys);

		// 当查询的row不为空
		if (rowKeys != null && rowKeys.length() > 0)
		{
			//
			String regex = ",";
			int index = rowKeys.indexOf(regex);

			// 查询条件的值为多个时
			if (index > 0)
			{
				//
				String[] keys = rowKeys.split(regex);

				//
				int allTasks = keys.length;
				
				// 需要分配最大线程数
				if (allTasks > maxThreadNum)
				{
					// 83 40 2 3
					// 求余数3
					int remainder = allTasks % maxThreadNum;
					
					// 每个线程需要至少多少个任务  2
					int tasksPerThread = allTasks / maxThreadNum;
					
					// 根据最大线程数，启动多线程
					for (int i = 0; i < maxThreadNum; i++)
					{
						// 00 01 02 ... 39
						// 40 41 42 ... 79
						// 80 81 82
						int threadNum = 0;
						
						if (i < remainder)
						{
							threadNum += tasksPerThread + 1;	
						}
						else
						{
							threadNum += tasksPerThread;
						}
						
						String[] ids = new String[threadNum];
						for (int j = 0; j < threadNum; j++)
						{
							
							ids[j] = keys[i + j * maxThreadNum];
						}
						
						Task t = new Task(tableName, ids);
						t.start();
					}
				}
				// 需要分配线程小于等于最大线程数
				else
				{
					// 根据任务数，启动多线程
					for (int i = 0; i < allTasks; i++)
					{
						String[] ids = new String[1];
						ids[0] = keys[i];
						
						Task t = new Task(tableName, ids);
						t.start();
					}
				}
			}
			// 当查询条件值有且只有一个
			else
			{
				HBaseUtil hbUtil = new HBaseUtil();

				try
				{
					hbUtil.selectRow(tableName, rowKeys);
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}

			}
		}
		// 当查询条件为空，查询所有数据,执行scan 'tableName'
		else
		{
			HBaseUtil hbUtil = new HBaseUtil();

			try
			{
				hbUtil.scan(tableName);
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}
	}
}


package com.ibm.bi.ccb.TC_OLTP_06;

final class Timer 
{

	private static  Long startTime;
	private static Long endTime;

	public static Long getStartTime() 
	{
		return startTime;
	}

	public static void setStartTime(Long startTime)
	{
		Timer.startTime = startTime;
	}

	public static Long getEndTime()
	{
		return endTime;
	}

	public static void setEndTime(Long endTime)
	{
		Timer.endTime = endTime;
	}

	public static long stopTimerAndGetElapseTime() 
	{
		Long startTime =getStartTime();
		Long endTime = System.currentTimeMillis();
		
		// System.out.println("End time: " + endTime +
		// " for current thread id: "
		// + Thread.currentThread().getId());
		if (startTime == null)
		{
			return -1;
		}
		else
		{
			return endTime - startTime;
		}
	}
}

spencer_tseng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hadoop学习笔记： 分布式数据库 HBase
BigPig的博客
01-11 2212
HBase概述 HBase是一个构建在HDFS上的分布式列存储系统，是Apache Hadoop生态系统中的重要一员，主要用于海量结构化数据存储。HBase是Google Bigtable的开源实现，从逻辑上讲，HBase将数据按照表、行和列进行存储，它是一个分布式的、稀疏的、持久化存储的多维度排序表。Hbase会把数据写到HDFS文件系统中。 HBase具有以下特点：1）良好的扩展性；2）读和写...
Hadoop HBase数据库简介
01-07
HBase 是基于 Apache Hadoop 的面向列的 NoSQL 数据库，是 Google 的 BigTable 的开源实现。HBase 是一个针对半结构化数据的开源的、多版本的、可伸缩的、高可靠的、高性能的、分布式的和面向列的动态模式数据库。 ...
Hadoop之HBase基本简介
taka_is_beauty的博客
11-07 4275
目录 1.HBase的基本概念 2.HBase的工作流程 1.HBase的基本概念 1.1基本概念 HBase运行在HDFS上，所以HBase中的数据以多副本形式存放，数据也服从分布式存放，数据的恢复也可以得到保障。 HBase支持横向扩展，这就意味着如果现有服务器硬件性能出现瓶颈只需要在现有的正在运行的集群中添加新的机器节点即可。 HBase是面向列存储的非关系型数据库，每个列都单独存储，所以在HBase中列是连续存储的，而行不是，区别于关系型数据库。 HBase不支持事务，适合结构化数据
大数据基础知识-Hadoop、HBase、Hive一篇搞定
最新发布
qq_41680016的博客
05-28 2853
相应的，数据库由于规模较小，因此可以支持的数据规模较小，一般单张表中能存储百万条数据(最新版的MySQL经过优化，单表中可以存储千万条或者上亿条数据，即使是一亿条数据，也就10GB大小，且此时效率会非常低)。HBase数据存储依靠HDFS，HDFS存储数据具有一次写入，多次读取的特点，其不支持对数据进行修改，但是HBase存储数据为KV型，通过对相同的K再次写入，根据TimeStamp不可逆的特点，每次写入的数据的时间戳都比上一个数据的时间戳大，从而完成版本号的维护和数据的更新。
import org.apache.hadoop.hbase.HBaseConfiguration包导不进来
麻辣灬小笼包的博客
05-28 3222
<dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>2.1.0-cdh6.2.1</version> </dependency> <dependency> <groupId>org...
java.lang.NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration
lucky_huijun的博客
04-06 2271
IDEA打包Spark-HBase程序时缺少jar包，把spark submit到集群中运行时报错： Exception in thread “main” java.lang.NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration at SparkHbase 解决办法： 1、在hadoop安装目录下找到hadoop-env...
【hadoop】hbase的安装部署以及相关操作（图文详解）_hbase安装(1)
2401_84166497的博客
05-03 1780
因为HBase依赖于Hadoop的分布式文件系统HDFS和资源管理框架YARN，而且HBase的各个版本都会对Hadoop的版本有一定的要求。在Zookeeper中，需要配置Zookeeper集群，以支持HBase的分布式环境下的协调和管理。其中，@后面的参数是集群的名称，冒号后面的参数是目标路径。进入hbase配置文件路径，编辑hbase-env.sh配置文件，然后把以下圈起来的两行给注释掉，就不会报错了。输入以下命令，编辑/etc/hosts文件，修改ip映射，所有集群都要改，与前面修改好的ip一致。
大数据 hdfs hadoop hbase jmeter
10-23
在IT行业中，大数据处理是当前的关键技术之一，而Hadoop、HDFS和HBase则是其中的核心组件。Hadoop是一个开源框架，主要用于存储和处理大规模数据，而HDFS（Hadoop Distributed File System）是Hadoop的核心部分，是...
hadoop hbase 全jar包
05-21
Hadoop和HBase是大数据处理领域中的重要组件，它们在分布式存储和实时数据访问方面扮演着关键角色。Hadoop是一个开源框架，主要用于处理和存储大量数据，而HBase是建立在Hadoop之上的非关系型数据库，提供高可靠性、...
HDP3.1.5源码下载—hadoop hbase hive
02-17
标题中的“HDP3.1.5源码下载—hadoop hbase hive”指的是Hortonworks Data Platform（HDP）的3.1.5版本，它是一个全面的大数据解决方案，包含了对Hadoop、HBase和Hive等组件的源代码支持。这个版本是大数据开发者和...
Hadoop hbase介绍
07-24
Hadoop hbase等介绍 数据长期的积累，文件总量非常庞大，存储这些数据需要投入巨大的硬件资源，但是如果能在已有空闲磁盘集群下可以利用起来，可以不再需要大规模采集服务器存储数据或购买容量庞大的磁盘，减少了...
【hive/yarn】hive报NoSuchMethodError: org.apache.hadoop.hbase.HBaseConfiguration.createCluster
shenhaiyushitiaoyu的博客
06-26 1270
详细报错： Caused by: org.apache.hadoop.hive.ql.metadata.HiveException: java.lang.NoSuchMethodError: org.apache.hadoop.hbase.HBaseConfiguration.createClusterConf(Lorg/apache/hadoop/conf/Configuration;Ljava/lang/String;Ljava/lang/String;)Lorg/apache/hadoop/conf/
HBase出现java.lang.NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration问题
JSON_ZJS的博客
06-20 1万+
问题：Hbase在集群上运行报错：NoClassDefFoundError:org/apache/hadoop/hbase/HBaseConfiguration 需求：HBase使用Java创建表，打包成jar，提交到集群上行运行！ 在IDEA中使用Maven添加Hbase 代码： &lt;dependency&gt; &lt;groupId&gt;org.apa...
hbase java api, NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguratio
学而不思则罔,思而不学则殆！
07-14 2274
1 Java api 操作hbase代码写法如下：     Java代码   package hbase;      import java.io.IOException;   import java.util.ArrayList;   import java.util.List;      import org.apache.hadoop.conf
hadoop+hbase导致报错（NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration）
热门推荐
03-19 6万+
Exception in thread "main" java.io.IOException: Error opening job jar: ./ADReport2Hbase_0309.jar         at org.apache.hadoop.util.RunJar.main(RunJar.java:90) Caused by: java.util.zip.ZipException:
HDFS上数据保存到Hbase运行报错：NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration
yang灬仔
10-12 7843
把HDFS上数据保存到Hbase运行报错！！！！ 错误如下： Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration at com.hadoop3.hbaseapi.day03.Demo01_HdfsToHbase.main(Demo01_Hdfs...
Apache HBase Configuration
Oozie123的博客
11-11 546
Apache HBase Configuration这一章节在getting started 章节的基础上，进一步阐述HBase配置。请仔细地阅读本章节，特别是那些能够保证你的HBase测试和部署正常运行，并防止数据丢失的先决条件。
java后觉,hbase java操作代码简介和NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguratio – 后知后觉的it路 –...
weixin_39955154的博客
03-21 565
将上面代码打包后 放在hadoop上通过执行：bin/hadoop jar XX.jar 包.类执行的时候，报错如下：Exception in thread “main” java.lang.NoClassDefFoundError: org/apache/hadoop/hbase/HBaseConfiguration错误原因： hadoop2 节点无法加载到hbase包处理方式：将hbase ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值