hbase高性能读取数据（多线程+get（list））

最新推荐文章于 2023-07-05 22:53:52 发布
最新推荐文章于 2023-07-05 22:53:52 发布
阅读量5.5k 收藏 19
点赞数
CC 4.0 BY-SA版权
分类专栏： HBase 文章标签： hbase多线程读取数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38025219/article/details/88527499

前言：

因业务需要，对hbase的读取性能进行研究与优化，现有网上的资料良莠不齐，写的不够清晰，对于初学者而言，很难实现高性能读取habse数据，自己整合资料，耗费一个多星期，完成了hbase高性能读取数据，当然本程序依旧有很大的优化空间，java多线程这一个点就是值得深入思考的经典问题。

hbase读取数据方式：

1、依旧rowkey查找数据

 // 根据rowkey查找数据
    public static void getData(String tableName, String rowkey, String colFamily, String col) throws IOException {
//        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Get get = new Get(Bytes.toBytes(rowkey));
        // 获取指定列族数据
         get.addFamily(Bytes.toBytes(colFamily));
        // 获取指定列数据
         get.addColumn(Bytes.toBytes(colFamily),Bytes.toBytes(col));
        Result result = table.get(get);
  
        showCell(result);
        table.close();
//        close();
    }

2、给出起始行与结束行批量查询

   // 批量查找数据
    @SuppressWarnings("deprecation")
	public static ArrayList<ArrayList<Data>> scanData(String tableName, String startRow, String stopRow) throws IOException {
//        Table table = connection.getTable(TableName.valueOf(tableName));
         HTablePool pool = new HTablePool(configuration,1000);
         Scan scan = new Scan();
         scan.setStartRow(Bytes.toBytes(startRow));
         scan.setStopRow(Bytes.toBytes(stopRow));
         int Count = 0;
        ResultScanner resultScanner = pool.getTable(tableName).getScanner(scan);

        ArrayList<ArrayList<Data>> sunDatas = new ArrayList<ArrayList<Data>>(); 
        try{
        	//内存溢出
            for (Result result : resultScanner) {
//            	 result.size();行
            	ArrayList<Data> sunData = new ArrayList<Data>(); 
            	
            	//showCell(result);
            	 //列
            	Cell[] cells = result.rawCells();
            	//System.out.println(new String(CellUtil.cloneRow(cells[0])));
                for (Cell cell : cells) {
                	 Data aData = new Data();
                     aData.setColString(new String(CellUtil.cloneRow(cell)));
                     aData.setRowString(new String(CellUtil.cloneValue(cell))); 
                     sunData.add(aData);
                     aData = null;
                }
                 sunDatas.add(sunData);

            }
        }finally{
        	resultScanner.close();
        }
        
              pool.getTable(tableName).close();
              return sunDatas;
    }

3、getlist指定rowkey集合与需要查询的列（推荐，符合业务需要）

 /** 
    ArrayList<String> rowkeyList ,    rowkey集合
     String[] cols ,   需要查的列
     String tableName, 表名
     int linknum，  表格连接数量
  */
    public static ArrayList<ArrayList<String>> getlist(ArrayList<String> rowkeyList , String[] cols ,String tableName,int linknum) throws IOException{
        	List<Get> getList = new ArrayList<Get>();
        	HTable[] table = new HTable[linknum];
            for (int i = 0; i < linknum; i++) {
            	table[i] = new HTable(configuration, tableName);
            	table[i].setScannerCaching(1000);
            }		
            //connection.getTable(TableName.valueOf(tableName));// 获取表
            
            ArrayList<ArrayList<String>> list =new ArrayList<ArrayList<String>>();
            for (int i = 0 ; i < rowkeyList.size(); i++){//把rowkey加到get里，再把get装到list中
                Get get = new Get(Bytes.toBytes(rowkeyList.get(i)));
                for (int j = 0; j < cols.length; j++) {
                	get.addColumn(Bytes.toBytes("f1"),Bytes.toBytes(cols[j]));
    			}
                getList.add(get);
                int link = 0;
                int linkc = 0;
                if(i % 1000 == 0){
                	System.out.println(i);
                	//1000行批量导出一次
                	link++;
                	if(link < 10){
                		linkc = link;
                	}else if(link % 10 == 0) {
                		linkc = 10;
    				}else {
    					linkc = link % 10;
    				}
                	Result[] results = table[linkc].get(getList);//重点在这，直接查getList<Get>
                    for (Result result : results){//对返回的结果集进行操作
                    	ArrayList<String> list2 = new ArrayList<String>();
                    	for (Cell kv : result.rawCells()) {
                            String value = Bytes.toString(CellUtil.cloneValue(kv));
                            list2.add(value);
                        }
                    	list.add(list2);
                    }
                    //getlist清空
                    getList.clear();
                }else if(i == rowkeyList.size() - 1){
                	System.out.println(i);
                	Result[] results = table[linknum-1].get(getList);//重点在这，直接查getList<Get>
                    for (Result result : results){//对返回的结果集进行操作
                    	ArrayList<String> list2 = new ArrayList<String>();
                    	for (Cell kv : result.rawCells()) {
                            String value = Bytes.toString(CellUtil.cloneValue(kv));
                            list2.add(value);
                        }
                    	list.add(list2);
                    }
                    //getlist清空
                    getList.clear();
                }            
                get = null;
            }
            return list;
        	
        }

多线程实践

1、实现runnable接口（返回结果集麻烦）

package com;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.shell.Count;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.BufferedMutator;
import org.apache.hadoop.hbase.client.BufferedMutatorParams;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.HTablePool;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.client.coprocessor.AggregationClient;
import org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter;
import org.apache.hadoop.hbase.util.Bytes;
import org.jruby.RubyProcess.Sys;
import org.omg.CORBA.ARG_IN;
import org.apache.hadoop.hbase.mapreduce.RowCounter;
import org.apache.hadoop.util.StopWatch;

import com.csvreader.CsvReader;
import com.github.luben.zstd.Zstd;
import com.google.common.util.concurrent.ThreadFactoryBuilder;

public class DataReaderServer implements Runnable{
	private List<String> rowkeyList;
	private String tableName;
	private String [] cols;
	private Configuration configuration;
    private HTable table;
    ArrayList<DataStract> alldata = new ArrayList<DataStract>();
	
	public DataReaderServer(List<String> rowkeyList,String tableName,String [] cols,Configuration configuration,HTable table){
		this.rowkeyList = rowkeyList;
        this.tableName = tableName;
        this.cols = cols;
        this.configuration = configuration;
        this.table = table;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		List<Get> getList = new ArrayList<Get>();
		ArrayList<DataStract> data = new ArrayList<DataStract>();
		try {
			table = new HTable(configuration, "TB001");
			table.setScannerCaching(50);
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
        //connection.getTable(TableName.valueOf(tableName));// 获取表
        //ArrayList<ArrayList<String>> list =new ArrayList<ArrayList<String>>();
        System.out.println("rowkey "+rowkeyList.size());
		for (int i = 0 ; i < rowkeyList.size(); i++){//把rowkey加到get里，再把get装到list中
            Get get = new Get(Bytes.toBytes(rowkeyList.get(i)));
            for (int j = 0; j < cols.length; j++) {
            	get.addColumn(Bytes.toBytes("f1"),Bytes.toBytes(cols[j]));
			}
            //System.out.println(i);
            getList.add(get);
            
            if(i % 1000 == 0 && i > 0){
            	//System.out.println(i);
            	try {
    				Result[] results = table.get(getList);
//    				System.out.println("结果集"+results.length+"  "+getList.size());
    				for (Result result : results){//对返回的结果集进行操作
                    	ArrayList<String> list2 = new ArrayList<String>();
                    	for (Cell kv : result.rawCells()) {
                            String value = Bytes.toString(CellUtil.cloneValue(kv));
                            list2.add(value);
                        }
                    	//list.add(list2);
                    	//System.out.println("---");
                    	DataStract swap = new DataStract();
                    	swap.setTime(rowkeyList.get(i));
                    	swap.setDalist(list2);
                    	//System.out.println(swap.getDalist().size());
                    	data.add(swap);
                    	//System.out.println("++"+data.size());
                    }
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
                //getlist清空
                getList.clear();
                
            }else if(i == rowkeyList.size() - 1){
            	try {
            		System.out.println(i);
    				Result[] results = table.get(getList);
    				for (Result result : results){//对返回的结果集进行操作
                    	ArrayList<String> list2 = new ArrayList<String>();
                    	for (Cell kv : result.rawCells()) {
                            String value = Bytes.toString(CellUtil.cloneValue(kv));
                            list2.add(value);
                        }
                    	//list.add(list2);
                    	DataStract swap = new DataStract();
                    	swap.setTime(rowkeyList.get(i));
                    	swap.setDalist(list2);
                    	data.add(swap);
                    	
                    }
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
                //getlist清空
                getList.clear();
            }
			get = null;
        }
		//总数据容器添加
		alldata.addAll(data);
	}
   

}

主接口调用如下

 //thread多任务
 long st1 = System.currentTimeMillis();
 //创建十个表格连接
 HTable[] table = new HTable[10];
 //开五个线程，总数rowkey分成五份
 int avg = 0;  //平均
 int extra = 0; //额外余数
 int t = 0; //循环次数
 List<String> thname = new ArrayList<String>();
 if(rowkeyArrayList.size() % 5 == 0){
	 avg = rowkeyArrayList.size() / 5;
	 t = rowkeyArrayList.size() / avg;
	 for (int i = 0; i < 5; i++) {
		 //List<String> rowkeyList,String tableName,String [] cols,Configuration configuration,HTable table
		 DataReaderServer dataReaderServer = new DataReaderServer(rowkeyArrayList.subList(i*avg, (i+1)*avg),"TB001",head,configuration,table[i]);
		 Thread thread = new Thread(dataReaderServer);
		 thread.start();
		 thname.add(thread.getName());
	}
 }else {
	 //avg = rowkeyArrayList.size() / 10;
	 extra = rowkeyArrayList.size() % 5;
	 avg = (rowkeyArrayList.size() - extra) / 5;
	 t = rowkeyArrayList.size() / avg;
	 for (int i = 0; i < 6; i++) {
		 if(i<5){
			 DataReaderServer dataReaderServer = new DataReaderServer(rowkeyArrayList.subList(i*avg, (i+1)*avg),"TB001",head,configuration,table[i]);
			 Thread thread = new Thread(dataReaderServer);
    		 thread.start();
    		 thname.add(thread.getName());
		 }else {
			 DataReaderServer dataReaderServer = new DataReaderServer(rowkeyArrayList.subList(i*avg, rowkeyArrayList.size()),"TB001",head,configuration,table[i]);
			 Thread thread = new Thread(dataReaderServer);
    		 thread.start();
    		 thname.add(thread.getName());
		}
		 
	}
	 
}

2、实现callable接口（推荐，有结果集返回）

package com;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;

public class CallableGetlist implements Callable <ArrayList<DataStract>>{
	private List<String> rowkeyList;
	private String tableName;
	private String [] cols;
	private Configuration configuration;
    private HTable table;
    ArrayList<DataStract> alldata = new ArrayList<DataStract>();
    
	public CallableGetlist(List<String> rowkeyList,String tableName,String [] cols,Configuration configuration,HTable table)
	{
		this.rowkeyList = rowkeyList;
        this.tableName = tableName;
        this.cols = cols;
        this.configuration = configuration;
        this.table = table;
	}
	
	@Override
	public ArrayList<DataStract> call() throws Exception {
		// TODO Auto-generated method stub
		List<Get> getList = new ArrayList<Get>();
		ArrayList<DataStract> data = new ArrayList<DataStract>();
		
		
        //connection.getTable(TableName.valueOf(tableName));// 获取表
        //ArrayList<ArrayList<String>> list =new ArrayList<ArrayList<String>>();
        System.out.println("rowkey "+rowkeyList.size());
		for (int i = 0 ; i < rowkeyList.size(); i++){//把rowkey加到get里，再把get装到list中
            Get get = new Get(Bytes.toBytes(rowkeyList.get(i)));
            for (int j = 0; j < cols.length; j++) {
            	get.addColumn(Bytes.toBytes("f1"),Bytes.toBytes(cols[j]));
			}
            //System.out.println(i);
            getList.add(get);
            
            if(i % 1000 == 0 && i > 0){
            	//System.out.println(i);
            	try {
    				Result[] results = table.get(getList);
//    				System.out.println("结果集"+results.length+"  "+getList.size());
    				for (Result result : results){//对返回的结果集进行操作
                    	ArrayList<String> list2 = new ArrayList<String>();
                    	for (Cell kv : result.rawCells()) {
                            String value = Bytes.toString(CellUtil.cloneValue(kv));
                            list2.add(value);
                        }
                    	//list.add(list2);
                    	//System.out.println("---");
                    	DataStract swap = new DataStract();
                    	swap.setTime(rowkeyList.get(i));
                    	swap.setDalist(list2);
                    	//System.out.println(swap.getDalist().size());
                    	data.add(swap);
                    	//System.out.println("++"+data.size());
                    }
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
                //getlist清空
                getList.clear();
                
            }else if(i == rowkeyList.size() - 1){
            	try {
            		System.out.println(i);
    				Result[] results = table.get(getList);
    				for (Result result : results){//对返回的结果集进行操作
                    	ArrayList<String> list2 = new ArrayList<String>();
                    	for (Cell kv : result.rawCells()) {
                            String value = Bytes.toString(CellUtil.cloneValue(kv));
                            list2.add(value);
                        }
                    	//list.add(list2);
                    	DataStract swap = new DataStract();
                    	swap.setTime(rowkeyList.get(i));
                    	swap.setDalist(list2);
                    	data.add(swap);
                    	
                    }
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
                //getlist清空
                getList.clear();
            }
			get = null;
        }
		//总数据容器添加
		return data;
		
	}

}

主接口调用如下

//实现callable接口
         //创建十个表格连接
         long st1 = System.currentTimeMillis();
         //HTable[] table = new HTable[5];
         HTable table = null;
         try {
 			table = new HTable(configuration, "TB001");
 			table.setScannerCaching(50);
 		} catch (IOException e1) {
 			// TODO Auto-generated catch block
 			e1.printStackTrace();
 		}
         ExecutorService pool = Executors.newFixedThreadPool(5);
         final int maxRowKeySize = 1000;
         int loopSize = rowkeyArrayList.size() % maxRowKeySize == 0 ? rowkeyArrayList.size()
             / maxRowKeySize : rowkeyArrayList.size() / maxRowKeySize + 1;
         ArrayList<Future<ArrayList<DataStract>>> results = new ArrayList<Future<ArrayList<DataStract>>>();
         for (int loop = 0; loop < loopSize; loop++)
         {
        	 int end = (loop + 1) * maxRowKeySize > rowkeyArrayList.size() ? rowkeyArrayList
                     .size() : (loop + 1) * maxRowKeySize;
             List<String> partRowKeys = rowkeyArrayList.subList(loop * maxRowKeySize,
                     end);
             CallableGetlist callableGetlist = new CallableGetlist(partRowKeys,"TB001",head,configuration,table);
             synchronized (pool)
             {
                 Future<ArrayList<DataStract>> result = pool.submit(callableGetlist);
                 results.add(result);
             }
         }
         pool.shutdown();
         long et1 = System.currentTimeMillis();
         System.out.println("线程执行时间： "+(et1 - st1));
         long st2 = System.currentTimeMillis();
         ArrayList<ArrayList<DataStract>> datas = new ArrayList<ArrayList<DataStract>>();
         ArrayList<DataStract> data = new ArrayList<DataStract>();
        	 try {
        		data.clear(); 
        		for(Future<ArrayList<DataStract>> result:results){
        			ArrayList<DataStract> t = result.get();
        			data.addAll(t);
				}
        		datas.add(data);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
         System.out.println("---"+datas.get(0).get(0).getDalist().size());
         long et2 = System.currentTimeMillis();
         System.out.println("数据连接时间： "+(et2-st2));

总结

依据服务器实际测试：86400行 188列 所有数据获取需要 24秒。
以上的实现代码，有我自己写的实体类没有贴上去，有关list集合容器依据自己的实际情况进行修改。
注意：多线程的性能是受到查询的数据量、CPU性能、网络带宽的影响的，具体应该开多少个线程，怎样优化，欢迎大家讨论。

如何封装一个线程安全、可复用的 HBase 查询模板
张彦峰的博客
05-02 3万+
本文探讨了如何封装一个线程安全、可复用的 HBase 查询模板。通过引入基于 AtomicReference 的连接懒加载机制和函数式接口封装查询执行逻辑，本文提供了一种高效的 HBase 查询解决方案。文章详细阐述了 HBase 连接池的实现、查询模板的设计与优化，以及如何在实际业务中应用这些技术。通过完整的案例演示，本文帮助开发者解决 HBase 查询中的常见问题，提高系统性能和可维护性。
HBase读写性能解析以及提升性能方案
。。。。。。
03-15 4812
HBase写流程原理 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lpCulF9X-1615795053119)(C:\Users\Administrator\Pictures\Saved Pictures\QQ截图20210223163312.png)] 1）Client 先访问 zookeeper，获取 hbase:meta 表位于哪个 Region Server。 2）访问对应的 Region Server，获取 hbase:meta 表，根据读请求的 namespa
多线程 hbase
03-03
多线程 hbase
HBase性能优化方法总结（三）：读表操作
weixin_34203832的博客
03-08 193
本文主要是从HBase应用程序设计与开发的角度，总结几种常用的性能优化方法。有关HBase系统配置级别的优化，可参考：淘宝Ken Wu同学的博客。 下面是本文总结的第三部分内容：读表操作相关的优化方法。 3. 读表操作 3.1 多HTable并发读 创建多个HTable客户端用于读操作，提高读数据的吞吐量，一个例子： static final Configuration conf =...
java hbase多线程_多线程读写HBase的一个注意点
weixin_39611765的博客
02-25 978
http://www.searchtb.com/2014/03/two-hbase-bugfix.html12345678java.util.concurrent.ExecutionException:java.lang.RuntimeException: java.lang.OutOfMemoryError: unable tocreate new nativethreadatjava.util...
Java HBase 多线程
conanswp的专栏
08-09 6281
Java多线程是一个很麻烦的东西，为了简化开发加快速度封装了HBase多线程操作，包括常用的Scan，Get，Put，Delete四种操作。经过多次修改运行非常稳定，已经用于生产环境。内部线程通信使用wait()/notify()机制，效率很高。本文只在Java层面讨论HBase的多线程，HBase API内部多线程机制不在本文讨论范围之内。HBase客户端需要的jar包自行下载，这里就不提供了，
hbase 多线程 大数据量入库
Rudolf__的博客
07-06 629
1.插入数据库 @Test public void poolinserts(){ List poolInserts = new ArrayList(); final Connection conn =HbaseUtils.conn(); final String tableName = “ns1:t2”; ThreadPoolExecutor pool = ThreadPool.getPool(...
hbase数据读取优化_HBase读写性能优化
weixin_39968760的博客
12-19 354
一个系统上线之后，开发和调优将会一直伴随在系统的整个生命周期中，HBase也不例外。下面我们要学习如何进行HBase读写性能调优，以获取最大的读写效率。HBase写入优化客户端优化批量写采用批量写，可以减少客户端到RegionServer之间的RPC的次数，提高写入性能。批量写请求要么全部成功返回，要么抛出异常。HTable.put(List<Put>);异步批量提交如果业务可以接受异...
HBase性能优化
xiaoruoxian的博客
04-18 373
HBase性能优化方法总结（一）：表的设计 表的设计 1.1 Pre-Creating Regions 默认情况下，在创建HBase表的时候会自动创建一个region分区，当导入数据的时候，所有的HBase客户端都向这一个region写数据，直到这个region足够大了才进行切分。一种可以加快批量写入速度的方法是通过预先创建一些空的regions，这样当数据写入HBase时，会按照region分...
Zookeeper+Hadoop+Spark+Flink+Kafka+Hbase+Hive 完全分布式高可用集群搭建(保姆级超详细含图文) 附安装包网盘下载
热门推荐
Mr.L-OAM的博客
07-05 2万+
Hadoop+Spark+Flink+Zookeeper+Kafka+Hbase+Hive完全分布式高可用集群搭建 Hadoop高可用集群搭建 Spark高可用集群搭建 Flink高可用集群搭建 Zookeeper高可用集群搭建 Kafka高可用集群搭建 Hbase高可用集群搭建 Hive高可用集群搭建 mysql搭建 jdk部署 大数据集群环境搭建
java 线程池管理多线程操作Hbase数据库完整项目
qq_36484611的博客
01-08 1407
Hbase-site.xml配置文件: &amp;amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot;?&amp;amp;gt; &amp;amp;lt;?xml-stylesheet type=&amp;quot;text/xsl&amp;quot; href=&amp;quot;configuration.xsl&amp
优化hbase的查询优化-大幅提升读写速率
xuefengmiao的专栏
05-10 941
环境：suse  8G内存，8核，12T磁盘           hbase master 占一台，其他7台作为hbase的region server 注意：此处不讨论hadoop 情景：           我们有7亿的数据，需要做查询操作，需要从1.7亿的表中查找一个字段，并写入到7亿数据的表中。           这里为了描述方便，将7亿数据的表称为：A表，1.7亿数据的表称
java+Hbase高效多线程（插入+删除）
qq_40304825的博客
06-11 1918
（Hbase版本直接使用jar有较大的变化，我使用的Hbase1.3.3，安装可见上一个博客） https://blog.youkuaiyun.com/qq_40304825/article/details/91335063 如果是纯命令行的Linux，推荐使用Filezilla在Windows与Linux虚拟机之间文件传输。 一、效果 在Hadoop服务器上256MB的日志文件（.log） 在Hb...
HBase多线程建立HTable问题
codepython的专栏
01-23 2023
 最近在写wormhole的HBase plugin，需要分别实现hbase reader和hbase writer。 　　相关阅读： 　　Hadoop+HBase搭建云存储总结 PDF 　　HBase 结点之间时间不一致造成regionserver启动失败 　　Hadoop+ZooKeeper+HBase集群配置 　　在测试的时候会报错如下： 　　2013-07-08 0
Hbase 获取 rowkey list
weixin_34378045的博客
03-15 1299
2019独角兽企业重金招聘Python工程师标准>>> ...
Hbase高并发读写优化
xgs
03-24 1万+
淘宝搜索的个性化离线实时分析系统Pora已升级至Pora2，Pora2是在基于Yarn的流式计算框架IStream基础上开发的，同时为保证数据和消息的实时处理系统中较多地使用了HBase，是一个典型的高并发读写HBase的分布式应用。 系统在发布之初遇到了比较严重的性能问题，表现为处理速度跟不上实时日志，并且整个Hadoop/HBase集群压力大，连带其它应用受影响。经过排查发现问题主要都出
Hbase利用多线程插入和读取数据（读取.CSV文件并写入到Hbase中。）
weixin_42369418的博客
12-13 901
HBaseUtilss类 import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.*; import org.apache.hadoop.hbase.util.Bytes; import java.io...
hadoop.hbase查询结果Result[] results = table.get(list)为null包空指针异常解决方案
cucgyfjklx的博客
02-21 1万+
hadoop.hbase查询结果Result[] results = table.get(list)为null包空指针异常解决方案
HBase Scan类用法
07-24 2826
public static void main(String[] args) throws IOException {         //Scan类常用方法说明         //指定需要的family或column ，如果没有调用任何addFamily或Column，会返回所有的columns；          // scan.addFamily();          // sc
spring boot 代码实现接口触发在oracle一张表里面读出数据写入到kafka中，然后根据kafka customer客户端中多线程进行消费每条与Hbase里面规则关联生成一张新表插入到oracle中
最新发布
03-30
<think>好的，我需要解决用户的问题：使用Spring Boot实现从Oracle读取数据，发送到Kafka，然后通过多线程消费者处理并与HBase规则关联，生成新表后插入回Oracle。我得先分解这个流程，看看每个环节需要什么组件和配置。 首先，数据读取部分。用户用的是Oracle，所以得配置Spring Boot连接Oracle的数据源。记得引用中提到多数据源的配置，比如引用[4]里的例子，用两个数据源，这里可能只需要一个Oracle的配置。但可能需要Druid连接池，所以得引入Druid依赖，并在application.properties里设置url、用户名、密码等。这部分应该没问题，但要注意Oracle的JDBC驱动可能需要手动添加到项目中，因为Maven中央仓库可能没有。 接下来是发送到Kafka。Spring有Spring Kafka项目，可以方便地集成。生产者需要配置bootstrap servers，然后使用KafkaTemplate发送消息。引用[3]提到生产者如何选择分区，这里用户可能用默认的轮询或者根据某个关键字分区。这部分需要添加Kafka的依赖，配置生产者参数，然后在读取数据后调用KafkaTemplate发送。 然后是消费者部分，需要多线程处理。Spring Kafka的消费者默认是单线程的，但可以通过配置concurrency参数来启动多个消费者线程。比如设置concurrency = 5，就会启动5个线程。同时，消费者需要反序列化消息，处理数据，并连接HBase进行规则匹配。这里可能需要HBase的Java客户端，比如HBaseTemplate，或者直接使用HBase的API。规则关联部分可能需要查询HBase表，根据某些键值获取规则，然后生成新的数据。 生成新表并插入回Oracle，这里涉及到在Oracle中动态创建表，可能需要执行DDL语句。使用Spring的JdbcTemplate或者MyBatis等工具来执行创建表和插入操作。需要注意的是权限问题，以及表结构是否已经存在，避免重复创建。 整个流程中，数据的一致性需要保证。比如在读取Oracle数据后，是否要标记已处理，避免重复发送到Kafka。可能需要在数据库中使用状态字段，或者采用事务管理。但Kafka发送部分的事务可能需要更复杂的配置，比如使用Kafka事务管理器。 另外，多线程处理时需要考虑线程安全和资源竞争。比如HBase的连接是否线程安全，或者是否需要为每个线程创建独立的连接。还有异常处理，比如某个消息处理失败，是否需要重试或者记录错误日志。 配置方面，需要检查所有的依赖是否正确，比如Spring Boot的版本是否兼容Spring Kafka和HBase客户端。可能还需要配置HBase的ZooKeeper地址，以及Kafka的消费者组ID等。 测试环节也很重要，每个部分都需要单元测试和集成测试。比如使用EmbeddedKafka来测试生产者消费者，用测试数据库来验证数据读取和插入是否正确，以及HBase规则匹配是否准确。 最后，性能优化。引用[5]提到JVM调优和项目优化，可能需要调整堆内存、垃圾回收器等参数，确保应用在高负载下稳定运行。同时，Kafka的生产者和消费者配置，如批处理大小、重试机制等，也需要优化以提高吞吐量。 可能遇到的问题包括：Oracle数据量大时的分页查询效率，Kafka消息顺序和分区策略的影响，HBase查询的性能瓶颈，多线程间的协调，以及事务管理的复杂性。需要逐步调试，查看日志，定位问题点。</think>### 分步实现方案 #### 1. **环境准备与依赖配置** - **Spring Boot 项目初始化** 使用 Spring Initializr 创建项目，添加依赖： ```xml <!-- Oracle 驱动 --> <dependency> <groupId.com.oracle.database.jdbc</groupId> <artifactId>ojdbc8</artifactId> <version>21.5.0.0</version> </dependency> <!-- Kafka 集成 --> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> <!-- HBase 客户端 --> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>2.4.11</version> </dependency> <!-- 多数据源支持 --> <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId> <version>3.5.1</version> </dependency> ``` - **Oracle 数据源配置** 在 `application.properties` 中配置 Oracle 连接（参考引用[4]）： ```properties spring.datasource.dynamic.primary=oracle spring.datasource.dynamic.datasource.oracle.url=jdbc:oracle:thin:@localhost:1521:ORCL spring.datasource.dynamic.datasource.oracle.username=user spring.datasource.dynamic.datasource.oracle.password=pass spring.datasource.dynamic.datasource.oracle.driver-class-name=oracle.jdbc.OracleDriver ``` #### 2. **Oracle 数据读取与 Kafka 生产** - **数据读取服务** 使用 Spring Data JPA 或 MyBatis 查询数据： ```java @Service public class OracleService { @Autowired private JdbcTemplate jdbcTemplate; public List<Map<String, Object>> fetchData() { return jdbcTemplate.queryForList("SELECT * FROM source_table"); } } ``` - **Kafka 生产者配置** 在 `application.properties` 中配置 Kafka 生产者（参考引用[3]）： ```properties spring.kafka.bootstrap-servers=localhost:9092 spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer ``` - **发送消息到 Kafka** ```java @Service public class KafkaProducerService { @Autowired private KafkaTemplate<String, Object> kafkaTemplate; public void sendMessage(String topic, Object data) { kafkaTemplate.send(topic, data); } } ``` #### 3. **Kafka 多线程消费与 HBase 规则关联** - **Kafka 消费者配置（多线程）** 配置消费者并发度以实现多线程（引用[3]）： ```properties spring.kafka.consumer.group-id=rule-processor-group spring.kafka.consumer.auto-offset-reset=earliest spring.kafka.listener.concurrency=5 # 启动 5 个消费者线程 ``` - **消费者处理逻辑** ```java @KafkaListener(topics = "data-topic") public void processMessage(ConsumerRecord<String, Object> record) { Map<String, Object> data = (Map<String, Object>) record.value(); // 从 HBase 查询规则 Configuration hbaseConfig = HBaseConfiguration.create(); try (Connection connection = ConnectionFactory.createConnection(hbaseConfig)) { Table table = connection.getTable(TableName.valueOf("rules")); Get get = new Get(Bytes.toBytes(data.get("id").toString())); Result result = table.get(get); // 应用规则生成新数据 Map<String, Object> newData = applyRule(data, result); // 插入新表到 Oracle insertIntoOracle(newData); } } ``` #### 4. **HBase 规则匹配与 Oracle 新表生成** - **HBase 查询逻辑** 使用 `hbase-client` 实现条件过滤： ```java private Map<String, Object> applyRule(Map<String, Object> data, Result ruleResult) { // 解析规则并生成新数据（示例） String rule = Bytes.toString(ruleResult.getValue(Bytes.toBytes("cf"), Bytes.toBytes("rule"))); data.put("processed_value", data.get("value") + "_" + rule); return data; } ``` - **Oracle 新表插入** 动态创建表并插入数据： ```java public void insertIntoOracle(Map<String, Object> data) { jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS result_table (id NUMBER, processed_value VARCHAR2(50))"); jdbcTemplate.update("INSERT INTO result_table VALUES (?, ?)", data.get("id"), data.get("processed_value")); } ``` #### 5. **事务与容错处理** - **Kafka 事务支持** 在生产者端启用事务（引用[3]）： ```java @Bean public ProducerFactory<String, Object> producerFactory() { Map<String, Object> configs = new HashMap<>(); configs.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "txn-1"); return new DefaultKafkaProducerFactory<>(configs); } ``` - **消费者重试机制** 配置 `RetryTemplate` 处理异常： ```java @Bean public ConcurrentKafkaListenerContainerFactory<String, Object> kafkaListenerContainerFactory() { ConcurrentKafkaListenerContainerFactory<String, Object> factory = new ConcurrentKafkaListenerContainerFactory<>(); factory.setRetryTemplate(new RetryTemplate()); return factory; } ``` ### 关键问题与优化 1. **性能瓶颈** - **Kafka 分区策略**：根据业务键（如 `data.id`）分区，确保相同键的数据由同一线程处理[^3]。 - **HBase 批量查询**：使用 `Batch.Get` 减少网络开销。 2. **数据一致性** - 在 Oracle 中标记已处理数据，避免重复消费。 - 使用 Kafka 的 `ack=all` 配置保证消息持久化[^3]。 3. **动态表创建** - 预检查表是否存在，避免频繁执行 DDL。 ### 示例代码整合 ```java // 主控制器 @RestController public class DataController { @Autowired private OracleService oracleService; @Autowired private KafkaProducerService kafkaProducer; @Scheduled(fixedDelay = 5000) public void fetchAndSend() { List<Map<String, Object>> dataList = oracleService.fetchData(); dataList.forEach(data -> kafkaProducer.sendMessage("data-topic", data)); } } ``` ### 相关引用配置 - Oracle 多数据源配置参考引用[4] - Kafka 生产者分区策略参考引用[3] - Spring Boot 优化方法参考引用[5]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值