冠字号查询系统中HBase写入数据性能测试

最新推荐文章于 2022-10-24 21:24:17 发布
最新推荐文章于 2022-10-24 21:24:17 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： Hadoop HBase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelababy_huan/article/details/53364360
版权

    机器说明：4台centos虚拟机，每台分别配置2G内存

    测试步骤：

为了方便测试，利用hbase shell新建表如下：

create 'identify01', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify02', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify03', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify04', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify05', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify07', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify08', {NAME => 'op_www', VERSIONS => 1000},SPLITS => ['AAAR3333','AABI6666']
create 'identify09', {NAME => 'op_www', VERSIONS => 1000},
SPLITS => [' AAAK3999',' AAAU7999',' AABF1999',' AABP5999']

1.  利用hbase2hbase的MR程序将表'identify_rmb_records'的数据分别导入上述建立的表中。

2.  按照冠字号生成规则，随机生成10w条、20w条数据分别保存在test_10.txt、test_20.txt中。

3.  读取test_10.txt文件数据，然后利用HBase Java API单线程将数据插入identify01表中、利用HBase Java API多线程(5线程，每线程10w条数据)将数据插入identify03表中、利用HBase Java API多线程(10线程，每线程10w条数据)将数据插入identify04表中。

4.  读取test_20.txt文件数据，然后利用HBase Java API单线程将数据插入identify02表中、利用HBase Java API多线程(5线程，每线程20w条数据)将数据插入identify05表中。

5.  将test_10.txt、test_20.txt文件上传到hdfs上，然后利用MR(3个region)将test_10.txt中数据插入到identify07表中、利用MR(3个region)将test_20.txt中数据插入到identify08表中、利用MR(5个region)将test_10中数据插入到identify09表中。

    测试结果：

    测试总结：
由上述结果可以看出，最适合冠字号查询系统的写入方法是利用HBase Java API多线程的方式。因为冠字号查询系统的目的就是为了实现快速读写，而MR的话，启动

时间开销太大，并且MR更适合做离线数据处理，而不是在线实时数据分析。

    测试代码：

      HBaseJava API 单线程：

package write;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import demo.Utils;
public class WriteTest {
	public static long putData(String tableName,Connection connection,List<byte[]> rowkeys) throws IOException{
		Table table = connection.getTable(TableName.valueOf(tableName));
		Put put = null;
		long start =System.currentTimeMillis();
		long count =0;
		long putNums = 0;
		try {
			for(byte[] rowkey:rowkeys){
				count++;
				put = Utils.generatePutFromRow(rowkey, "1");
				if(table.checkAndPut(rowkey, Utils.OP_WWW,
						Utils.COL_EXIST, Bytes.toBytes("0"), put)){
					putNums++;
				}
				if (count % 1000 == 0) {
					System.out.println("count:"+count);
				}
			}
			long end = System.currentTimeMillis();
			System.out.println(new Date()+":"+rowkeys.size()+"条记录，读取耗时:"+(end-start)*1.0/1000+"s");
			return putNums;
		} catch (Exception e) {
			table.close();
			return putNums;
		}
	}
}
      HBase Java API 多线程： 

package write;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import demo.Utils;
public class WriteThread implements Runnable {
	private List<byte[]> rks;
	private Table table;
	public  WriteThread(String tableName ,List<byte[]> rks) throws IOException {
		this.table =Utils.getConn().getTable(TableName.valueOf(tableName));
		this.rks = rks;
	}
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+" "+new Date()+":开始读取记录...");
		Put put = null;
		long count =0;
		long putNums = 0;
		long start =System.currentTimeMillis();
		try{
			for(byte[] rowkey:rks){
				count++;
				put = Utils.generatePutFromRow(rowkey, "1");
				if(table.checkAndPut(rowkey, Utils.OP_WWW,
						Utils.COL_EXIST, Bytes.toBytes("0"), put)){
					putNums++;
				}
				if (count % 1000 == 0) {
					System.out.println("count:"+count);
				}
			}
		long end = System.currentTimeMillis();
		System.out.println(Thread.currentThread().getName()+" "+new Date()
				+":"+rks.size()+"条记录，读取耗时:"+(end-start)*1.0/1000+"s");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
} 

      identify01- identify05测试main入口：

package write;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.util.ToolRunner;
import org.apache.jasper.tagplugins.jstl.core.If;
import demo.ReadThread;
import demo.Utils;
import hbase2hbase.HBaseToHBase;
public class AllTest {
	public static List<byte[]> list_10; //保存10w条数据
	public static List<byte[]> list_20; // 保存20w条数据
	public static void main(String[] args) throws Exception {
//        随机生成测试数据并写入到txt中
//		list_10 = Utils.generateRowKey(100000);
//		list_20 = Utils.generateRowKey(200000);
//		writeToFile("C:\\Users\\Administrator\\Desktop\\test_10.txt", list_10);
//		writeToFile("C:\\Users\\Administrator\\Desktop\\test_20.txt", list_20);
		list_10 = readFromFile("C:\\Users\\Administrator\\Desktop\\test_10.txt");
		list_20 = readFromFile("C:\\Users\\Administrator\\Desktop\\test_20.txt");
//		 测试单线程写入identify01数据库10w条数据
		System.out.println(WriteTest.putData("identify01", 
				Utils.getConn(), list_10));
//		 测试单线程写入identify02数据库20w条数据
		System.out.println(WriteTest.putData("identify02", 
				Utils.getConn(), list_20));
//		 测试多线程写入identify03数据库10w条数据
		int threadSize1 = 5;
		for(int i=0;i<threadSize1;i++){
			new Thread(new WriteThread("identify03", list_10)).start();
		}
		// 测试多线程写入identify04数据库20w条数据
		int threadSize2 = 10;
		for(int i=0;i<threadSize2;i++){
			new Thread(new WriteThread("identify04", list_10)).start();
		}
//		 测试多线程写入identify04数据库20w条数据
		for(int i=0;i<threadSize1;i++){
			new Thread(new WriteThread("identify05", list_20)).start();
		}
	}
	public static void writeToFile(String fileName,List<byte[]> list) throws IOException{
		FileWriter fw = new FileWriter(fileName);
		BufferedWriter bw = new BufferedWriter(fw);
		for (byte[] bs : list) {
			bw.write(new String(bs)+"\n");
		}
		bw.close();
		fw.close();
	}
	public static List<byte[]> readFromFile(String fileName) throws IOException{
		List<byte[]> list = new ArrayList<>();
		BufferedReader bf = new BufferedReader(new FileReader(fileName));
		String read = null;
		while ((read =bf.readLine()) != null ) {
			list.add(Bytes.toBytes(read));
		}
		bf.close();
		return list;
	}
}
      Util工具类: 

package demo;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
public class Utils {
	public static String TABLE = "identify_rmb_records";
	private static DecimalFormat df = new DecimalFormat( "0000" );
	public static String[]  crownSizePrefixes =null;
	static Random random = new Random();
	public static byte[] OP_WWW = Bytes.toBytes("op_www");
	public static byte[] COL_EXIST = Bytes.toBytes("exists");
	static {
		crownSizePrefixes = new String[26*2];
		for (int i = 0; i < crownSizePrefixes.length/2; i++) {
			crownSizePrefixes[i] = "AAA" + (char) (65 + i);
			crownSizePrefixes[i+26] = "AAB" + (char) (65 + i);		
		}
	}
	public static Put generatePutFromRow(byte[] row, String exist) {
		Put put = null;
		try {
			put = new Put(row);
			put.addColumn(OP_WWW, COL_EXIST, Bytes.toBytes(exist));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return put;
	}
	/**
	 * 把0~9999 转为 0000~9999
	 * @param num
	 * @return
	 */
	public static String formatCrownSizeSuffix(int num){
		return df.format(num);
	}
	public static Table getTable() throws IOException{
		return getConn().getTable(TableName.valueOf(TABLE));
	}
	public static String getRandomCrownSize(){
		return crownSizePrefixes[random.nextInt(crownSizePrefixes.length)]
				+formatCrownSizeSuffix(random.nextInt(10000));
	}
	public static Connection getConn() throws IOException {
		Configuration conf = HBaseConfiguration.create();
		conf.set("hbase.master", "master:16000");// 指定HMaster
		conf.set("hbase.rootdir", "hdfs://master:8020/hbase");// 指定HBase在HDFS上存储路径
		conf.set("hbase.zookeeper.quorum", "slave1,slave2,slave3");// 指定使用的Zookeeper集群
		conf.set("hbase.zookeeper.property.clientPort", "2181");// 指定使用Zookeeper集群的端口

		Connection connection = ConnectionFactory.createConnection(conf);// 获取连
		return connection;
	}
	
	public static List<byte[]> generateRowKey(long size){
		System.out.println(new Date()+"开始生成"+size +"条记录...");
		long start =System.currentTimeMillis();
		List<byte[]>  rowkeys = new ArrayList<>();
		
		for(int i=0;i<size;i++){
			rowkeys.add(Bytes.toBytes(Utils.getRandomCrownSize()));
		}
		long end =System.currentTimeMillis();
		System.out.println(new Date()+":"+rowkeys.size()+"条记录，生成耗时:"+(end-start)*1.0/1000+"s");
		return rowkeys;
	}
}

      hbase2hbase的MR Driver：

package hbase2hbase;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
/**
 * Job Driver驱动类
 * @author wmh
 * 
 * 
 *
 */
public class HBaseToHBase  extends Configured implements Tool {
	public static String FROMTABLE=null;
	@Override
	public int run(String[] args) throws Exception {
		if(args.length!=2){
			System.err.println("Usage:\n ImportToHBase <input> \n rowkey file path");
			return -1;
		}
		
		Configuration conf = getConf();
	
        String jobName ="From table "+FROMTABLE;
        FROMTABLE = args[0];
        conf.set("filePath", args[1]);
        Job job = Job.getInstance(conf, jobName);
        job.setJarByClass(HBaseToHBase.class);    
        //  设置HBase表输入：表名、scan、Mapper类、mapper输出键类型、mapper输出值类型（提示：参考ExportFromHBase）
        TableMapReduceUtil.initTableMapperJob(
        		FROMTABLE,
        		new Scan(), 
        		H2HMapper.class, 
        		ImmutableBytesWritable.class, 
        		Put.class, 
        		job);
        //  设置HBase表输出：表名，reducer类（提示：参考ImportToHBase）
        TableMapReduceUtil.initTableReducerJob(FROMTABLE,
        		null, job);       
	    // 没有 reducers，  直接写入到 输出文件
	    job.setNumReduceTasks(0);
	 
        return job.waitForCompletion(true) ? 0 : 1;
	}	
	private static Configuration configuration;
	public static Configuration getConfiguration(){
		if(configuration==null){
			/**
			 *了解如何直接从Windows提交代码到Hadoop集群
			 *      并修改其中的配置为实际配置
			 */
			configuration = new Configuration();
			configuration.setBoolean("mapreduce.app-submission.cross-platform", true);// 配置使用跨平台提交任务
			configuration.set("fs.defaultFS", "hdfs://master:8020");// 指定namenode
			configuration.set("mapreduce.framework.name", "yarn"); // 指定使用yarn框架
			configuration.set("yarn.resourcemanager.address", "master:8032"); // 指定resourcemanager
			configuration.set("yarn.resourcemanager.scheduler.address", "master:8030");// 指定资源分配器
			configuration.set("mapreduce.jobhistory.address", "master:10020");// 指定historyserver
			configuration.set("hbase.master", "master:16000");
			configuration.set("hbase.rootdir", "hdfs://master:8020/hbase");
			configuration.set("hbase.zookeeper.quorum", "slave1,slave2,slave3");
			configuration.set("hbase.zookeeper.property.clientPort", "2181");
			//TODO 需export->jar file ; 设置正确的jar包所在位置
			configuration.set("mapreduce.job.jar",JarUtil.jar(HBaseToHBase.class));// 设置jar包路径
		}
		
		return configuration;
	}

}
      Mapper： 

package hbase2hbase;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapper;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.mapreduce.Mapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Mapper类，接收HBase表数据，写入到HBase表中
 * @author wmh
 *
 */
public class H2HMapper extends TableMapper<ImmutableBytesWritable, Put> {
	private static List<String> rowKeys = new ArrayList<>();
	private static byte[] FAMILY = Bytes.toBytes("op_www");
	private static byte[] COLUMN = Bytes.toBytes("exists");
	Logger log = LoggerFactory.getLogger(H2HMapper.class);
	@Override
	protected void setup(Context context)
			throws IOException, InterruptedException {
		String filePath = context.getConfiguration().get("filePath");
		Path path = new Path(filePath);
		FileSystem fs = FileSystem.get(context.getConfiguration());
		rowKeys = readFromFile(fs,path);	
	}
	private static Put put = null;
	private static byte[] existsValue = null;
	@Override
	protected void map(ImmutableBytesWritable key, Result value,
			Mapper<ImmutableBytesWritable, Result, ImmutableBytesWritable, Put>.Context context)
					throws IOException, InterruptedException {
		if(rowKeys.contains(new String(key.get()))){
			put = new Put(key.get());
			existsValue = value.getValue(FAMILY, COLUMN);
	 		if(new String(existsValue).equals("0")){
	 			put.addColumn(FAMILY, COLUMN, Bytes.toBytes("1"));
	 			log.info("****:  "+new String(key.get()));
	 			context.write(key, put);
	 		}else{
	 			return;
	 		}			
	 	}else{
	 		return;
	 	}
	}

	public static List<String> readFromFile(FileSystem fs,Path fileName) throws IOException{
		List<String> list = new ArrayList<>();
		FSDataInputStream data = fs.open(fileName);
		BufferedReader bf = new BufferedReader(new InputStreamReader(data));
		String read = "";
		while ((read =bf.readLine()) != null ) {
			list.add(read);
		}
		bf.close();
		data.close();
		return list;
	}

}
      测试MR的main函数入口： 
package hbase2hbase;
import java.util.Date;
import org.apache.hadoop.util.ToolRunner;
public class Test {
	public static void main(String[] args) throws Exception {
		String[] myArgs1 = {
				"identify07",
				"hdfs://master:8020/user/root/test_10.txt"
		};
		long start =System.currentTimeMillis();
		ToolRunner.run(HBaseToHBase.getConfiguration(), new HBaseToHBase(), myArgs1);
		long end = System.currentTimeMillis();
		System.out.println(new Date()+":"+"100000"+"条记录，读取耗时:"+(end-start)*1.0/1000+"s");
		String[] myArgs2 = {
				"identify08",
				"hdfs://master:8020/user/root/test_20.txt"
		};
		long start1 =System.currentTimeMillis();
		ToolRunner.run(HBaseToHBase.getConfiguration(), new HBaseToHBase(), myArgs2);
		long end1 = System.currentTimeMillis();
		System.out.println(new Date()+":"+"200000"+"条记录，读取耗时:"+(end1-start1)*1.0/1000+"s");
		String[] myArgs3 = {
				"identify09",
				"hdfs://master:8020/user/root/test_10.txt"
		};
		long start2 =System.currentTimeMillis();
		ToolRunner.run(HBaseToHBase.getConfiguration(), new HBaseToHBase(), myArgs3);
		long end2 = System.currentTimeMillis();
		System.out.println(new Date()+":"+"100000"+"条记录，读取耗时:"+(end2-start2)*1.0/1000+"s");
	}

}
      测试identify07时的截图：

                                         

      测试identify08时的截图：

                                   





Angelababy_huan
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于HBase的冠字号查询系统1--理论部分
fansy1990的专栏
06-04 1万+
1. 软件版本和部署maven：3.3.9，jdk：1.7 ，Struts2：2.3.24.1，hibernate：4.3.6，spring：4.2.5，MySQL：5.1.34，Junit：4，Myeclipse：2014；Hadoop2.6.4，HBase1.1.2源码下载：https://github.com/fansy1990/ssh_v3/releases部署参考：http://blog
基于HBase的冠字号查询系统2--实现部分
热门推荐
fansy1990的专栏
06-04 1万+
1. 软件版本和部署maven：3.3.9，jdk：1.7 ，Struts2：2.3.24.1，hibernate：4.3.6，spring：4.2.5，MySQL：5.1.34，Junit：4，Myeclipse：2014；Hadoop2.6.4，HBase1.1.2源码下载：https://github.com/fansy1990/ssh_v3/releases部署参考：http://blog
HBase冠字号查询系统（实训报告）
weixin_51309151的博客
09-07 909
HBase冠字号查询系统（实训报告）
冠字号查询系统数据
06-04
基于HBase冠字号查询系统、数据，参考https://github.com/fansy1990/ssh_v3/releases
Part9---Java查询Hbase数据
weixin_46408961的博客
04-17 6011
查询Hbase数据分为Get方式查询，Scan方式查询，Scan配合Filter过滤查询 01.Get方式查询 import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.clie
基于Django LayUI HBase的文献数据挖掘系统.zip
最新发布
11-11
《基于Django、LayUI和HBase的文献数据挖掘系统》 在信息化时代，数据挖掘已经成为科研和商业领域的重要工具，它可以帮助我们从海量的数据中发现有价值的信息和模式。本项目“基于Django LayUI HBase的文献数据挖掘...
HBase高性能复杂条件查询引擎
02-21
该方案由一个智能交通解决方案演变而来，设计之初仅寄希望于通过二级索引提升查询性能，由于在前期架构时充分考虑了通用性以及对复杂条件的支持，在后来的演变中逐渐被剥离出来形成了一个通用的查询引擎。...
Hbase系统架构及数据结构
03-02
HBase中的表一般有这样的特点：1大：一个表可以有上亿行，上百万列2面向列:面向列(族)的存储和权限控制，列(族)独立检索。3稀疏:对于为空(null)的列，并不占用存储空间，因此，表可以设计的非常稀疏。下面一幅图是...
26个数据分析案例——第一站：基于Python的HBase冠字号查询系统
u014552259的博客
08-07 2542
26个数据分析案例——第一站：基于Python的HBase冠字号查询系统 实验所需环境 • Python: Python 3.x； • Hadoop 2.7.7环境； • HBase 1.3.5； 实验背景 针对于人民币的真假识别，最传统的方式就是一看、二摸、三听、四测四种方式，但随着不法分子仿制水平的提高，可能会通过一些技术手段欺骗我们，针对于这种情况我们可以建立一套针对于冠字号管理查询系统进行识别，以唯一的冠字号查询手段，检验真假，冠字号钞票的唯一编号，全世界仅有一个，如果有一个大表可以把所有的人民币以
测试写Hbase的三种不同方法的性能
bradyM的博客
03-18 903
文章目录背景测试条件结论代码1.PutList2.saveAsNewAPIHadoopDataset3.BulkLoad测试中出现的问题汇总1.Exception in thread “main” java.lang.IllegalArgumentException: Can not create a Path from an empty string2.java.io.IOException: ...
冠字号FSN文件解析成对象 与 对象转为FSN文件
03-19
冠字号FSN文件解析成对象 与 对象转为FSN文件 实现将FSN冠字号文件解析成对象，然后可以将对象再转为FSN文件，进行存储
Hbase性能测试详细设计文档及用例q
11-02
默认情况下，在创建HBase表的时候会自动创建一个region分区，当导入数据的时候，所有的HBase客户端都向这一个region写数据，直到这个region足够大了才进行切分。 一种可以加快批量写入速度的方法是通过预先创建一些空的regions，这样当数据写入HBase时，会按照region分区情况，在集群内做数据的负载均衡。
某大数据公司内部Hbase性能测试详细设计文档及用例
11-29
某大数据公司内部Hbase性能测试详细设计文档及用例 罗列了Hbase性能测试需要注意的一些参数设置，给出了Hbase测试用例
一场HBase2.x的写入性能优化之旅
小米云技术
10-10 1349
本文通过实战跑分来展示HBase2.x的写入性能往期文章回顾：首先，简单介绍一下我们的测试环境：集群由5个节点组成，每个节点有12块800GB的SSD盘、24核CPU、1...
HBase写入性能分析及改造—multi-thread flush and compaction(约能提高两到三倍吞吐量，带压缩测试)
牛_plus_plus的专栏
02-20 1万+
首先描述一下现象 最近对HDFS底层做了许多优化，包括硬件压缩卡，内存盘及SSD。 在出测试报告时发现老问题，HBase写入速度不稳定，这个大家都习以为常了吧，就是压测时，只要row size稍小一点，不管你怎么压，HBase的RegionServer总是不愠不火特淡定。有些人就怀疑是磁盘到瓶颈了？还有些人怀疑是不是GC拖累了？ 总之网上大部分测试都是黑盒测试嘛，大家也就乱猜呗。 下面我仔
【分布式数据库】HBase读写性能调优（一）
康师傅没有眼泪
10-24 4471
HBase关键参数配置如果同时存在读和写的操作，这两种操作的性能会相互影响。如果写入导致的flush和Compaction操作频繁发生，会占用大量的磁盘IO操作，从而影响读取的性能。如果写入导致阻塞较多的Compaction操作，就会出现Region中存在多个HFile的情况，从而影响读取的性能。所以如果读取的性能不理想的时候，也要考虑写入的配置是否合理。
HBase读写性能解析以及提升性能方案
。。。。。。
03-15 4183
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集群 数据写入_hbase写入性能测试（从hdfs向hbase写入数据） | 学步园
weixin_28932845的博客
01-16 455
测试集群：9个region server(16 core + 24GB内存)。Hbase client机器(8 core + 32GB内存)数据量：日志数据，1122MB，存储在hdfs中。 hbase rowkey为9个字节，第一个字节是hash值，后八个字节对应long型数值；value约200b。写性能关键影响因素1. rowkey分布式是否均衡，最好先了解rowkey的特征，预设spli...
java 根据行号读取文件内容
迟到的help的博客
06-10 822
Java 8解决方案： 对于小文件： Stringline32=Files.readAllLines(Paths.get("aaa.txt")).get(12); 对于大型文件： Stream<String> lines = Files.lines(Paths.get("D:\\Desktop\\aaa.txt")); String s = lines.skip(12).findFirst().get(); System.out.println(s); ...
使用spark写一个酒店推荐系统，数据从Hbase中读取
05-10
好的，首先需要明确一下酒店推荐系统的具体需求和算法模型。在此假设推荐系统采用协同过滤算法，即根据用户历史行为和其他用户的行为数据，推荐给用户可能感兴趣的酒店。 接下来，我们可以按照以下步骤来实现： 1. 从Hbase中读取酒店和用户行为数据，使用Spark SQL进行数据清洗和预处理。 2. 使用协同过滤算法，计算用户之间的相似度，得到用户相似度矩阵。 3. 对于每个用户，根据相似度矩阵和用户历史行为，推荐可能感兴趣的酒店列表。 4. 将推荐结果存储到Hbase中，以备后续查询。 以下是一份简单的代码示例： ```python from pyspark.sql import SparkSession # 创建SparkSession对象 spark = SparkSession.builder.appName("HotelRecommendationSystem").getOrCreate() # 从Hbase中读取酒店和用户行为数据 hotel_data = spark.read.format("org.apache.hadoop.hbase.spark") \ .option("hbase.table", "hotel_table") \ .option("hbase.columns.mapping", "hotel_id STRING :key, hotel_name STRING info:hotel_name") \ .load() user_data = spark.read.format("org.apache.hadoop.hbase.spark") \ .option("hbase.table", "user_table") \ .option("hbase.columns.mapping", "user_id STRING :key, hotel_id STRING info:hotel_id") \ .load() # 数据清洗和预处理 hotel_data = hotel_data.selectExpr("hotel_id", "hotel_name") user_data = user_data.groupBy("user_id").agg(collect_list("hotel_id").alias("hotel_ids")) # 使用协同过滤算法，计算用户相似度矩阵 user_similarity = ... # 对于每个用户，根据相似度矩阵和用户历史行为，推荐可能感兴趣的酒店列表 user_recommendations = ... # 将推荐结果存储到Hbase中 user_recommendations.write.format("org.apache.hadoop.hbase.spark") \ .option("hbase.table", "recommendation_table") \ .option("hbase.columns.mapping", "user_id STRING :key, hotel_ids STRING info:hotel_ids") \ .save() # 关闭SparkSession对象 spark.stop() ``` 需要注意的是，上述代码中的`user_similarity`和`user_recommendations`需要根据具体的算法模型进行实现。另外，还需要根据实际情况进行调整，如更改Hbase表的名称和列族，以及更改数据预处理和推荐算法的参数等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值