java hbase api 批量高效写入数据（线程池方式）

最新推荐文章于 2024-03-09 10:00:00 发布
最新推荐文章于 2024-03-09 10:00:00 发布
阅读量3w 收藏 65
点赞数 12
分类专栏： hbase 文章标签： hbase 批量写入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jack85986370/article/details/54098447
版权

笔者尝试各种方法写入HBase，其中使用线程池方式写入数据最为快速。

测试环境：hbase 1.2.4, hadoop 2.7 , 单条数据大小1kb，7台服务器24核48g内存千兆网卡，测试1000w数据写入 

测试结果能达到百万级每秒写入速度。

下面上代码。

pom.xml

<?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>hcg</groupId>
    <artifactId>hcg</artifactId>
    <version>1.0-SNAPSHOT</version>

    <repositories>
        <repository>
            <id>Akka repository</id>
            <url>http://repo.akka.io/releases</url>
        </repository>
        <repository>
            <id>jboss</id>
            <url>http://repository.jboss.org/nexus/content/groups/public-jboss</url>
        </repository>
        <repository>
            <id>Sonatype snapshots</id>
            <url>http://oss.sonatype.org/content/repositories/snapshots/</url>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
        <repository>
            <id>central</id>
            <url>http://repo.maven.apache.org/maven2</url>
        </repository>
    </repositories>

    <build>
        <sourceDirectory>src/</sourceDirectory>
        <testSourceDirectory>src/test/</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>

                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>reference.conf</resource>
                                </transformer>

                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                </transformer>

                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <properties>
        <hbase.version>1.2.4</hbase.version>
        <JAVA_HOME>I:/java/jdk1.7</JAVA_HOME>
    </properties>

    <dependencies>
        <!-- HBase -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>${hbase.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-common</artifactId>
            <version>${hbase.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>${hbase.version}</version>
        </dependency>

    </dependencies>

</project>

HBaseUtil.java

package cn.ngsoc.hbase.util;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.io.compress.Compression;
import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * HBase 工具类
 * Created by babylon on 2016/11/29.
 */
public class HBaseUtil {
	
	private static final Logger logger = LoggerFactory.getLogger(HBaseUtil.class);

	private static Configuration conf;
	private static Connection conn;

//	static {
//		try {
//			if (conf == null) {
//			    conf = HBaseConfiguration.create();
                conf.set("hbase.zookeeper.property.clientPort", ConfigUtil.getInstance().getConfigVal("zkport", ConstantProperties.COMMON_PROP));
//                conf.set("hbase.zookeeper.quorum", ConfigUtil.getInstance().getConfigVal("zkhost", ConstantProperties.COMMON_PROP));
//                conf.set("zookeeper.znode.parent", "/hbase");
//			}
//		} catch (Exception e) {
//			logger.error("HBase Configuration Initialization failure !");
//			throw new RuntimeException(e) ;
//		}
//	}

	public static void init(String zkHost){
		try {
			if (conf == null) {
				conf = HBaseConfiguration.create();
//                conf.set("hbase.zookeeper.property.clientPort", ConfigUtil.getInstance().getConfigVal("zkport", ConstantProperties.COMMON_PROP));
				conf.set("hbase.zookeeper.quorum", zkHost);
				conf.set("zookeeper.znode.parent", "/hbase");
			}
		} catch (Exception e) {
			logger.error("HBase Configuration Initialization failure !");
			throw new RuntimeException(e) ;
		}
	}

	/**
	 * 获得链接
	 * @return
     */
	public static synchronized Connection getConnection() {
		try {
            if(conn == null || conn.isClosed()){
                conn = ConnectionFactory.createConnection(conf);
            }
//         System.out.println("---------- " + conn.hashCode());
		} catch (IOException e) {
			logger.error("HBase 建立链接失败 ", e);
		}
		return conn;

	}

	/**
	 * 创建表
	 * @param tableName
	 * @throws Exception
     */
	public static void createTable(String tableName, String[] columnFamilies, boolean preBuildRegion) throws Exception {
		if(preBuildRegion){
			String[] s = new String[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };
			int partition = 16;
			byte[][] splitKeys = new byte[partition - 1][];
			for (int i = 1; i < partition; i++) {
				splitKeys[i - 1] = Bytes.toBytes(s[i - 1]);
			}
			createTable(tableName, columnFamilies, splitKeys);
		} else {
			createTable(tableName, columnFamilies);
		}
	}

	private static void createTable(String tableName, int pNum, boolean only) throws Exception {
		String[] s = RandCodeEnum.HBASE_CHAR.getHbaseKeys(pNum,2,only);
		byte[][] splitKeys = new byte[pNum][];
		for (int i = 1; i <= pNum; i++) {
			splitKeys[i - 1] = Bytes.toBytes(s[i - 1]);
		}
		createTable(tableName, new String[] { "events" }, splitKeys);
	}
	
	/**
	 * 建表
	 * @param tableName
	 * @param cfs
	 * @throws IOException
	 */
	private static void createTable(String tableName, String[] cfs, byte[][] splitKeys) throws Exception {
		Connection conn = getConnection();
		HBaseAdmin admin = (HBaseAdmin) conn.getAdmin();
		try {
			if (admin.tableExists(tableName)) {
				logger.warn("Table: {} is exists!", tableName);
				return;
			}
			HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));
			for (int i = 0; i < cfs.length; i++) {
				HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(cfs[i]);
				hColumnDescriptor.setCompressionType(Compression.Algorithm.SNAPPY);
				hColumnDescriptor.setMaxVersions(1);
				tableDesc.addFamily(hColumnDescriptor);
			}
			admin.createTable(tableDesc, splitKeys);
			logger.info("Table: {} create success!", tableName);
		} finally {
			admin.close();
			closeConnect(conn);
		}
	}

	/**
	 * 建表
	 * @param tableName
	 * @param cfs
	 * @throws IOException
	 */
	private static void createTable(String tableName, String[] cfs) throws Exception {
		Connection conn = getConnection();
		HBaseAdmin admin = (HBaseAdmin) conn.getAdmin();
		try {
			if (admin.tableExists(tableName)) {
				logger.warn("Table: {} is exists!", tableName);
				return;
			}
			HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));
			for (int i = 0; i < cfs.length; i++) {
				HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(cfs[i]);
				hColumnDescriptor.setCompressionType(Compression.Algorithm.SNAPPY);
				hColumnDescriptor.setMaxVersions(1);
				tableDesc.addFamily(hColumnDescriptor);
			}
			admin.createTable(tableDesc);
			logger.info("Table: {} create success!", tableName);
		} finally {
			admin.close();
			closeConnect(conn);
		}
	}

    /**
     * 删除表
     * @param tablename
     * @throws IOException
     */
	public static void deleteTable(String tablename) throws IOException {
		Connection conn = getConnection();
		HBaseAdmin admin = (HBaseAdmin) conn.getAdmin();
		try {
			if (!admin.tableExists(tablename)) {
				logger.warn("Table: {} is not exists!", tablename);
				return;
			}
			admin.disableTable(tablename);
			admin.deleteTable(tablename);
			logger.info("Table: {} delete success!", tablename);
		} finally {
			admin.close();
			closeConnect(conn);
		}
	}
	
	/**
	 * 获取  Table
	 * @param tableName 表名
	 * @return
	 * @throws IOException
	 */
	public static Table getTable(String tableName){
		try {
			return getConnection().getTable(TableName.valueOf(tableName));
		} catch (Exception e) {
			logger.error("Obtain Table failure !", e);
		}
		return null;
	}

	/**
	 * 给 table 创建 snapshot
	 * @param snapshotName 快照名称
     * @param tableName 表名
	 * @return
	 * @throws IOException
	 */
	public static void snapshot(String snapshotName, TableName tableName){
		try {
            Admin admin = getConnection().getAdmin();
            admin.snapshot(snapshotName, tableName);
		} catch (Exception e) {
			logger.error("Snapshot " + snapshotName + " create failed !", e);
		}
	}

    /**
     * 获得现已有的快照
     * @param snapshotNameRegex 正则过滤表达式
     * @return
     * @throws IOException
     */
    public static List<HBaseProtos.SnapshotDescription> listSnapshots(String snapshotNameRegex){
        try {
            Admin admin = getConnection().getAdmin();
            if(StringUtils.isNotBlank(snapshotNameRegex))
                return admin.listSnapshots(snapshotNameRegex);
            else
                return admin.listSnapshots();
        } catch (Exception e) {
            logger.error("Snapshot " + snapshotNameRegex + " get failed !", e);
        }
        return null;
    }

    /**
     * 批量删除Snapshot
     * @param snapshotNameRegex 正则过滤表达式
     * @return
     * @throws IOException
     */
    public static void deleteSnapshots(String snapshotNameRegex){
        try {
            Admin admin = getConnection().getAdmin();
            if(StringUtils.isNotBlank(snapshotNameRegex))
                admin.deleteSnapshots(snapshotNameRegex);
            else
                logger.error("SnapshotNameRegex can't be null !");
        } catch (Exception e) {
            logger.error("Snapshots " + snapshotNameRegex + " del failed !", e);
        }
    }

    /**
     * 单个删除Snapshot
     * @param snapshotName 正则过滤表达式
     * @return
     * @throws IOException
     */
    public static void deleteSnapshot(String snapshotName){
        try {
            Admin admin = getConnection().getAdmin();
            if(StringUtils.isNotBlank(snapshotName))
                admin.deleteSnapshot(snapshotName);
            else
                logger.error("SnapshotName can't be null !");
        } catch (Exception e) {
            logger.error("Snapshot " + snapshotName + " del failed !", e);
        }
    }

	/**
	 * 分页检索表数据。<br>
	 * （如果在创建表时为此表指定了非默认的命名空间，则需拼写上命名空间名称，格式为【namespace:tablename】）。
	 * @param tableName 表名称(*)。
	 * @param startRowKey 起始行键(可以为空，如果为空，则从表中第一行开始检索)。
	 * @param endRowKey 结束行键(可以为空)。
	 * @param filterList 检索条件过滤器集合(不包含分页过滤器；可以为空)。
	 * @param maxVersions 指定最大版本数【如果为最大整数值，则检索所有版本；如果为最小整数值，则检索最新版本；否则只检索指定的版本数】。
	 * @param pageModel 分页模型(*)。
	 * @return 返回HBasePageModel分页对象。
	 */
	public static HBasePageModel scanResultByPageFilter(String tableName, byte[] startRowKey, byte[] endRowKey, FilterList filterList, int maxVersions, HBasePageModel pageModel) {
		if(pageModel == null) {
			pageModel = new HBasePageModel(10);
		}
		if(maxVersions <= 0 ) {
			//默认只检索数据的最新版本
			maxVersions = Integer.MIN_VALUE;
		}
		pageModel.initStartTime();
		pageModel.initEndTime();
		if(StringUtils.isBlank(tableName)) {
			return pageModel;
		}
		Table table = null;

		try {
			table = getTable(tableName);
			int tempPageSize = pageModel.getPageSize();
			boolean isEmptyStartRowKey = false;
			if(startRowKey == null) {
				//则读取表的第一行记录
				Result firstResult = selectFirstResultRow(tableName, filterList);
				if(firstResult.isEmpty()) {
					return pageModel;
				}
				startRowKey = firstResult.getRow();
			}
			if(pageModel.getPageStartRowKey() == null) {
				isEmptyStartRowKey = true;
				pageModel.setPageStartRowKey(startRowKey);
			} else {
				if(pageModel.getPageEndRowKey() != null) {
					pageModel.setPageStartRowKey(pageModel.getPageEndRowKey());
				}
				//从第二页开始，每次都多取一条记录，因为第一条记录是要删除的。
				tempPageSize += 1;
			}

			Scan scan = new Scan();
			scan.setStartRow(pageModel.getPageStartRowKey());
			if(endRowKey != null) {
				scan.setStopRow(endRowKey);
			}
			PageFilter pageFilter = new PageFilter(pageModel.getPageSize() + 1);
			if(filterList != null) {
				filterList.addFilter(pageFilter);
				scan.setFilter(filterList);
			} else {
				scan.setFilter(pageFilter);
			}
			if(maxVersions == Integer.MAX_VALUE) {
				scan.setMaxVersions();
			} else if(maxVersions == Integer.MIN_VALUE) {

			} else {
				scan.setMaxVersions(maxVersions);
			}
			ResultScanner scanner = table.getScanner(scan);
			List<Result> resultList = new ArrayList<Result>();
			int index = 0;
			for(Result rs : scanner.next(tempPageSize)) {
				if(isEmptyStartRowKey == false && index == 0) {
					index += 1;
					continue;
				}
				if(!rs.isEmpty()) {
					resultList.add(rs);
				}
				index += 1;
			}
			scanner.close();
			pageModel.setResultList(resultList);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				table.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		int pageIndex = pageModel.getPageIndex() + 1;
		pageModel.setPageIndex(pageIndex);
		if(pageModel.getResultList().size() > 0) {
			//获取本次分页数据首行和末行的行键信息
			byte[] pageStartRowKey = pageModel.getResultList().get(0).getRow();
			byte[] pageEndRowKey = pageModel.getResultList().get(pageModel.getResultList().size() - 1).getRow();
			pageModel.setPageStartRowKey(pageStartRowKey);
			pageModel.setPageEndRowKey(pageEndRowKey);
		}
		int queryTotalCount = pageModel.getQueryTotalCount() + pageModel.getResultList().size();
		pageModel.setQueryTotalCount(queryTotalCount);
		pageModel.initEndTime();
		pageModel.printTimeInfo();
		return pageModel;
	}

	/**
	 * 检索指定表的第一行记录。<br>
	 * （如果在创建表时为此表指定了非默认的命名空间，则需拼写上命名空间名称，格式为【namespace:tablename】）。
	 * @param tableName 表名称(*)。
	 * @param filterList 过滤器集合，可以为null。
	 * @return
	 */
	public static Result selectFirstResultRow(String tableName,FilterList filterList) {
		if(StringUtils.isBlank(tableName)) return null;
		Table table = null;
		try {
			table = getTable(tableName);
			Scan scan = new Scan();
			if(filterList != null) {
				scan.setFilter(filterList);
			}
			ResultScanner scanner = table.getScanner(scan);
			Iterator<Result> iterator = scanner.iterator();
			int index = 0;
			while(iterator.hasNext()) {
				Result rs = iterator.next();
				if(index == 0) {
					scanner.close();
					return rs;
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				table.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
    /**
     * 异步往指定表添加数据
     * @param tablename  	表名
     * @param puts	 			需要添加的数据
	 * @return long				返回执行时间
     * @throws IOException
     */
	public static long put(String tablename, List<SocPut> puts) throws Exception {
		long currentTime = System.currentTimeMillis();
		Connection conn = getConnection();
		final BufferedMutator.ExceptionListener listener = new BufferedMutator.ExceptionListener() {
			@Override
			public void onException(RetriesExhaustedWithDetailsException e, BufferedMutator mutator) {
				for (int i = 0; i < e.getNumExceptions(); i++) {
					System.out.println("Failed to sent put " + e.getRow(i) + ".");
					logger.error("Failed to sent put " + e.getRow(i) + ".");
				}
			}
		};
		BufferedMutatorParams params = new BufferedMutatorParams(TableName.valueOf(tablename))
				.listener(listener);
		params.writeBufferSize(5 * 1024 * 1024);

		final BufferedMutator mutator = conn.getBufferedMutator(params);
		try {
			mutator.mutate(puts);
			mutator.flush();
		} finally {
			mutator.close();
			closeConnect(conn);
		}
		return System.currentTimeMillis() - currentTime;
	}

	/**
	 * 异步往指定表添加数据
	 * @param tablename  	表名
	 * @param put	 			需要添加的数据
	 * @return long				返回执行时间
	 * @throws IOException
	 */
	public static long put(String tablename, SocPut put) throws Exception {
		return put(tablename, Arrays.asList(put));
	}

	/**
	 * 往指定表添加数据
	 * @param tablename  	表名
	 * @param puts	 			需要添加的数据
	 * @return long				返回执行时间
	 * @throws IOException
	 */
	public static long putByHTable(String tablename, List<?> puts) throws Exception {
		long currentTime = System.currentTimeMillis();
		Connection conn = getConnection();
        HTable htable = (HTable) conn.getTable(TableName.valueOf(tablename));
		htable.setAutoFlushTo(false);
		htable.setWriteBufferSize(5 * 1024 * 1024);
		try {
			htable.put((List<Put>)puts);
			htable.flushCommits();
		} finally {
			htable.close();
			closeConnect(conn);
		}
		return System.currentTimeMillis() - currentTime;
	}
    
	/**
	 * 删除单条数据
	 * @param tablename
	 * @param row
	 * @throws IOException
	 */
	public static void delete(String tablename, String row) throws IOException {
		Table table = getTable(tablename);
        if(table!=null){
			try {
				Delete d = new Delete(row.getBytes());
				table.delete(d);
			} finally {
				table.close();
			}
        }
	}

	/**
	 * 删除多行数据
	 * @param tablename
	 * @param rows
	 * @throws IOException
	 */
	public static void delete(String tablename, String[] rows) throws IOException {
		Table table = getTable(tablename);
		if (table != null) {
			try {
				List<Delete> list = new ArrayList<Delete>();
				for (String row : rows) {
					Delete d = new Delete(row.getBytes());
					list.add(d);
				}
				if (list.size() > 0) {
					table.delete(list);
				}
			} finally {
				table.close();
			}
		}
	}

	/**
	 * 关闭连接
	 * @throws IOException
	 */
	public static void closeConnect(Connection conn){
		if(null != conn){
			try {
//				conn.close();
			} catch (Exception e) {
                logger.error("closeConnect failure !", e);
			}
		}
	}

	/**
	 * 获取单条数据
	 * @param tablename
	 * @param row
	 * @return
	 * @throws IOException
	 */
	public static Result getRow(String tablename, byte[] row) {
		Table table = getTable(tablename);
		Result rs = null;
		if(table!=null){
			try{
				Get g = new Get(row);
				rs = table.get(g);
			} catch (IOException e) {
                logger.error("getRow failure !", e);
			} finally{
				try {
					table.close();
				} catch (IOException e) {
                    logger.error("getRow failure !", e);
				}
			}
		}
		return rs;
	}

	/**
	 * 获取多行数据
	 * @param tablename
	 * @param rows
	 * @return
	 * @throws Exception
	 */
	public static <T> Result[] getRows(String tablename, List<T> rows) {
        Table table = getTable(tablename);
        List<Get> gets = null;
        Result[] results = null;
        try {
            if (table != null) {
                gets = new ArrayList<Get>();
                for (T row : rows) {
                    if(row!=null){
                        gets.add(new Get(Bytes.toBytes(String.valueOf(row))));
                    }else{
                        throw new RuntimeException("hbase have no data");
                    }
                }
            }
            if (gets.size() > 0) {
                results = table.get(gets);
            }
        } catch (IOException e) {
            logger.error("getRows failure !", e);
        } finally {
            try {
                table.close();
            } catch (IOException e) {
                logger.error("table.close() failure !", e);
            }
        }
		return results;
	}

	/**
	 * 扫描整张表，注意使用完要释放。
	 * @param tablename
	 * @return
	 * @throws IOException
	 */
	public static ResultScanner get(String tablename) {
		Table table = getTable(tablename);
		ResultScanner results = null;
		if (table != null) {
			try {
				Scan scan = new Scan();
				scan.setCaching(1000);
				results = table.getScanner(scan);
			} catch (IOException e) {
                logger.error("getResultScanner failure !", e);
			} finally {
				try {
					table.close();
				} catch (IOException e) {
                    logger.error("table.close() failure !", e);
				}
			}
		}
		return results;
	}

	/**
	 * 格式化输出结果
	 */
	public static void formatRow(KeyValue[] rs){
		for(KeyValue kv : rs){
			System.out.println(" column family  :  " + Bytes.toString(kv.getFamily()));
			System.out.println(" column   :  " + Bytes.toString(kv.getQualifier()));
			System.out.println(" value   :  " + Bytes.toString(kv.getValue()));
			System.out.println(" timestamp   :  " + String.valueOf(kv.getTimestamp()));
			System.out.println("--------------------");
		}
	}

	/**
	 * byte[] 类型的长整形数字转换成 long 类型
	 * @param byteNum
	 * @return
	 */
	public static long bytes2Long(byte[] byteNum) {
		long num = 0;
		for (int ix = 0; ix < 8; ++ix) {
			num <<= 8;
			num |= (byteNum[ix] & 0xff);
		}
		return num;
	}

}

HBaseService 实现类 HBaseServiceImpl.java

package cn.ngsoc.hbase;

import cn.ngsoc.hbase.util.HBaseUtil;
import cn.ngsoc.hbase.util.ThreadPoolUtil;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * HBaseService  实现类
 * Created by babylon on 2016/12/5.
 */
public class HBaseServiceImpl extends AbstractHBaseService{

    private static final Logger logger = LoggerFactory.getLogger(HBaseServiceImpl.class);

    private ThreadPoolUtil threadPool= ThreadPoolUtil.init();       // 初始化线程池

    @Override
    public void put(String tableName, Put put, boolean waiting) {
        batchPut(tableName, Arrays.asList(put), waiting);
     }

     /**
     * 多线程同步提交
     * @param tableName  表名称
     * @param puts  待提交参数
     * @param waiting  是否等待线程执行完成  true 可以及时看到结果, false 让线程继续执行，并跳出此方法返回调用方主程序
     */
    @Override
    public void batchPut(final String tableName, final List<Put> puts, boolean waiting) {
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    HBaseUtil.put(tableName, puts);
                } catch (Exception e) {
                    logger.error("batchPut failed . ", e);
                }
            }
        });

        if(waiting){
            try {
                threadPool.awaitTermination();
            } catch (InterruptedException e) {
                logger.error("HBase put job thread pool await termination time out.", e);
            }
        }
    }

    @Override
    public <T> Result[] getRows(String tablename, List<T> rows) {
        return HBaseUtil.getRows(tablename, rows);
    }

    @Override
    public Result getRow(String tablename, byte[] row) {
        return HBaseUtil.getRow(tablename, row);
    }

    /**
     * 多线程异步提交
     * @param tableName  表名称
     * @param puts  待提交参数
     * @param waiting  是否等待线程执行完成  true 可以及时看到结果, false 让线程继续执行，并跳出此方法返回调用方主程序
     */
    public void batchAsyncPut(final String tableName, final List<Put> puts, boolean waiting) {
        Future f = threadPool.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    HBaseUtil.putByHTable(tableName, puts);
                } catch (Exception e) {
                    logger.error("batchPut failed . ", e);
                }
            }
        });

        if(waiting){
            try {
                f.get();
            } catch (InterruptedException e) {
                logger.error("多线程异步提交返回数据执行失败.", e);
            } catch (ExecutionException e) {
                logger.error("多线程异步提交返回数据执行失败.", e);
            }
        }
    }

    /**
     * 创建表
     * @param tableName         表名称
     * @param columnFamilies   列族名称数组
     * @param preBuildRegion  是否预分配Region   true 是  ， false 否  默认 16个region，rowkey生成的时候记得指定前缀
     * @return  返回执行时间 (单位: 毫秒)
     */
    public void createTable(String tableName, String[] columnFamilies, boolean preBuildRegion) throws Exception {
        HBaseUtil.createTable(tableName, columnFamilies, preBuildRegion);
    }

}

代码使用案例  HBasePutTest.java

import cn.ngsoc.hbase.HBase;
import cn.ngsoc.hbase.util.HBaseUtil;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.Random;

/**
 * HBase 测试类
 * Created by babylon on 2016/11/29.
 */
public class HBasePutTest {

    @Before
    public void init(){
        HBaseUtil.init("zkHost");
    }

    @Test
    public void testPut()  {
        Put put = new Put(Bytes.toBytes("rowKey"));
        put.addColumn(Bytes.toBytes("events"), Bytes.toBytes("severity"), Bytes.toBytes(new Random().nextInt(10)+""));
        HBase.put("logs", Arrays.asList(new Object[]{put}), true);
    }

    @Test
    public void testGet()  {
        Result result = HBaseUtil.getRow("logs", HBase.generateRowkey("rowKey"));
        HBaseUtil.formatRow(result.raw());
    }

    @Test
    public void testCreateTable()  {
        try {
            HBaseUtil.createTable("logs", new String[]{"events"}, true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
完整代码见 Github

https://github.com/JasonBabylon/hbase-operations-with-java/tree/master

LogansCodingLife
关注
  • 12
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
利用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: ...
HBase 5种写入数据方式(java API)
YiqiangXu的博客
11-30 7267
HBase 5种写入数据方式(java API):  点击打开链接
Hbase Java API及性能优化
qq_27630677的博客
04-12 172
Hbase Java API及性能优化Hbase Java APIHive与HBase集成原理 Hbase Java API 建Maven工程 代码 TestConn.java package cn.kgc.kb11.hbase; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.HBaseConfiguration; import or
Java实战：Spring Boot 利用 ThreadPoolTaskExecutor 批量插入百万级数据
最新发布
oandy0的博客
03-09 1381
本文将详细介绍如何使用 Spring Boot 中的 ThreadPoolTaskExecutor 实现批量插入百万级数据。我们将深入探讨 Spring Boot 的线程池配置，以及如何使用 Java 中的并发编程技术提高数据插入的效率。
HBase Java API 开发：批量操作 第3关：批量导入数据至HBase
qq_61604164的博客
12-14 3144
HBase Java API 开发：批量操作 第3关：批量导入数据至HBase
java api 操作 hbase,插入数据(单行，多行，批量插入)
Shixuefeng2410的博客
02-07 7852
java api 操作 hbase （主要批量存放数据） 操作步骤如下： #创建配置对象，创建连接对象 Configuration config = HBaseConfiguration.create(); config.set("hbase.zookeeper.quorum","single01:2181 "); Connection hbaseCon=ConnectionFactory.createConnection(config); //操作对象 Admin admin=hbaseCon.get..
利用JAVA向Hbase表中批量插入数据
YYDS_emmm的博客
06-27 1804
利用JAVA向Hbase表中批量插入数据 插入数据的文件格式要求： 1.文件名格式为:命名空间名_表名_时间戳.时间戳 如：dsj_test_1624591726565.1624591726565 2.文件内格式： 第一行用于描述表结构 :行键 ，列簇名1:列名1，列簇名1:列名2，列簇名2:列名1 如：:key,cf1:name,cf2:age,cf2:pos,cf2:salary,cf3:rst 其他行为具体插入的数据 :key,cf1:name,cf2:age,cf2:pos,cf2:salar
Hbase笔记 —— 利用JavaAPI的方式操作Hbase数据库（往hbase的表中批量插入数据）
一纸春秋的博客
11-30 4246
目录直接在main函数中执行语句借助@Test来运行方法删除表修改表结构列出来所有的表插入一条数据获取一行数据创建表批量读取文件中的数据，并且批量插入表中获取一组数据的值利用CellUtil改善读取数据方式 导入依赖 <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId>
Java客户端操作HBase：插入数据（逐条插入与批量插入）代码示例
学亮编程手记
03-06 1930
Hbase笔记 —— 利用JavaAPI的方式操作Hbase数据库（往hbase的表中批量插入数据）.pdf
12-16
Hbase笔记 —— 利用JavaAPI的方式操作Hbase数据库（往hbase的表中批量插入数据）
HBase JavaAPI开发
06-21
使用JavaAPI实现HBase的ddl（创建表、删除表、修改表（添加列族等））、dml（添加数据、删除数据）、dql（查询数据（get、scan））等操作 除此之外还包含一些其他操作：命名空间的应用、快照的应用等 对应（《HBase...
Hbase调用JavaAPI实现批量导入操作
08-06
NULL 博文链接：https://787141854-qq-com.iteye.com/blog/2067818
Hbase调用JavaAPI实现批量导入操作.docx
11-17
Hbase调用JavaAPI实现批量导入操作.docx
HBase写入的各种方式总结汇总（代码）
weixin_33767813的博客
03-13 639
2019独角兽企业重金招聘Python工程师标准>>> ...
java hbase创建_大数据知识：HBase常用Java API
weixin_39825722的博客
11-22 139
本节介绍与 HBase 数据存储管理相关的 Java API（基于 HBase 版本 1.2.3）。HBase 的常用Java APIHBase 主要包括 5 大类操作：HBase 的配置、HBase 表的管理、列族的管理、列的管理、数据操作等。1）org.apache.hadoop.hbase.HBaseConfigurationHBaseConfiguration 类用于管理 HBase 的配...
分布式数据库HBase 中的增删查改基本操作
不祈求 ~ ~
04-22 8119
一、HBase介绍 HBase是一个分布式的、面向列的开源数据库,源于Google的一篇论文《BigTable：一个结构化数据的分布式存储系统》。HBase以表的形式存储数据，表有行和列组成，列划分为若干个列族/列簇(column family)。 欲了解HBase的官方资讯，请访问[HBase官方网站](http://hbase.apache.org/)。 HBase的运...
Java 数组
EIUC_Thread的博客
10-20 286
Java 数组 定义 1、数组是个容器（堆中的一块空间，需要在堆中开辟一块空间new）； 2、数组可以同时存储同一类数据的多个数据（a、多个数据；b、同一类型）； 特点 1、可以存储多个数据，但只能是同一类型； 2、数组创建完成后数组长度无法改变； 3、数组中存储的数据叫数组的元素，而数组中的每个元素都有对应的下标，下标从0开始； 数组的创建与使用方式 1、创建方式一：   数据类型[] 变量名 = new 数据类型[数组长度];（java 语法）   数据类型 变量
HBase中Java操作数据库——创建数据表
亭有枇杷树
01-17 930
创建一个学生宿舍管理系统 数据表表名：student_info 列族1：students 列族2：dormitorys 列族3：staff_members 代码如下： package myhbase; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.h...
Java API 开发Hbase 关于连接，创表，添加数据，扫描数据的操作（一）
weixin_47169067的博客
04-15 3704
通过Java API的方式对hbase进行简单的创表、插入数据、查表、查数据等操作 一、 1.1 通过Java API 方式开发hbase，需要构建一个Maven工程，所用到的依赖也是比较简单的，如下： 本次开发所用到的依赖包。 1.2 因为对hbase的连接是采用.xml文件的方式进行连接，所以要从Linux中将core-site.xml和hbase-stie.xml两个文件复制到main文件夹下的resources文件当中，如下图： //初始化Configuration对象 Confi
HBase BulkLoad批量写入数据
03-29
HBase的BulkLoad（批量加载）是一种高效的方式，可以将大量数据快速地导入到HBase表中。相比于逐条写入数据，BulkLoad可以减少网络传输、HBase服务端处理和数据文件写入的开销，从而提高数据导入的速度。 BulkLoad的实现方式是将数据先写入到一个HFile文件中，然后再将HFile文件上传到HDFS中，最后使用HBase的BulkLoad API将数据加载到HBase表中。这个过程需要以下步骤： 1. 创建HFile文件：使用HBase的HFileOutputFormat工具类可以创建一个HFile文件，将数据写入到该文件中。 2. 将HFile文件上传到HDFS：使用Hadoop的hdfs命令或者Java API将HFile文件上传到HDFS中。 3. 加载HFile文件到HBase表中：使用HBase的BulkLoad API将HFile文件加载到HBase表中。 BulkLoad的优点是可以快速地导入大量数据，但是需要注意以下几点： 1. BulkLoad需要手动编写代码实现，需要一定的编程技能。 2. BulkLoad需要将数据写入到HFile文件中，如果数据量太大可能会导致HFile文件过大，需要考虑分片等优化策略。 3. BulkLoad需要将HFile文件上传到HDFS中，如果网络传输较慢可能会影响导入速度。 总之，BulkLoad是一种高效的数据导入方式，可以加快大量数据的导入速度，但需要注意数据量、网络传输等因素对导入速度的影响。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值