MapReduce两个数据源关联

最新推荐文章于 2021-07-02 13:13:03 发布
最新推荐文章于 2021-07-02 13:13:03 发布
阅读量2.7k 收藏 3
点赞数
分类专栏： MapReduce hbase hadoop 文章标签： hbase hadoop mapreduce 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/maclaren001/article/details/44115277
版权
本文介绍了一种在Hadoop MapReduce环境下实现HDFS上多个数据源关联的方法，通过示例代码展示了如何处理数据源的笛卡儿积，并最终将处理结果写入HBase。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

平时开发的时候会遇到很多需要将HDFS上多个数据源的某个字段做为关联字段，得出多个数据源的笛卡儿积。了解了MapReduce多数据源关联的基本思路后就很简单。

基本思路：在Map输入阶段获取输入路径，在Map输出阶段根据路径的不同加以区分，即在将关联的列作为Key,在Value中加以区分是哪个数据源的数据，接着在Reduce的输入阶段，在reduce方法的入参会得到所有Key相同的集合，这样便可对数据进行响应的组装，这样便可完成2个数据源的关联，多个数据源的关联也类似。

下面附上本人写的一个demo:

package com.mclaren.hadoop.mr;

import java.io.IOException;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.PosixParser;
import org.apache.commons.lang.StringUtils;
import org.apache.directory.api.util.Strings;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.HFileOutputFormat2;
import org.apache.hadoop.hbase.mapreduce.PutSortReducer;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.hbase.mapreduce.TableOutputFormat;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.mclaren.hadoop.config.ConfSource;


/**
 * 
 * @ClassName: Sync2HBaseJob
 * @Description: 数据入hbase MapReduce
 * @author Mclaren.Pan
 * @date 2014年11月5日 上午9:49:04
 *
 */
public class Sync2HBaseJob {
	
	private static final Logger LOG = LoggerFactory.getLogger(Sync2HBaseJob.class);
	
	private static CommandLine cl = null; 
	
	private static ConfClz confClz = new ConfClz();
	
	public static class Sync2HBaseMapper extends Mapper<Object, Text, Text, Text> {
		private String[] headers = {};
    	
    	private String familyCol = "";
    	
    	private String rowKeyStr = "";
    	
    	private String dataSourceID = "";
    	
    	private String separator = "";
    	
    	//判断数据源标志
    	private String flag;

    	private Text k;
    	
		private Text v;
    	
    	
        @Override
        protected void setup(Context context){
        	String headerStr_ = context.getConfiguration().get("headerStr");
        	headers = headerStr_.split("\\|", -1);
        	separator = context.getConfiguration().get("separator");
        	familyCol = context.getConfiguration().get("familyCol");
        	rowKeyStr = context.getConfiguration().get("rowKeyStr");
        	dataSourceID = context.getConfiguration().get("dataSourceID");
        	
        	FileSplit split = (FileSplit) context.getInputSplit();
        	flag = split.getPath().toString();
        }
        
        public void map(Object key, Text value, Context context)
				throws IOException, InterruptedException {
			if (StringUtils.isNotBlank(value.toString())){
				// 数据源A
				if (flag.contains("DS_A")) {
					String[] vals = splitLine(value, separator);
					k = new Text(vals[1]);
					StringBuilder sb = new StringBuilder();
					for (String item : vals) {
						sb.append(item).append(",");
					}
					v = new Text("DS_A@_@"
							+ sb.delete(sb.length() - 1, sb.length())
									.toString());
				} else {
					String[] vals = splitLine(value, "$");
					k = new Text(vals[1]);
					StringBuilder sb = new StringBuilder();
					for (String item : vals) {
						sb.append(item).append(",");
					}
					v = new Text("DS_B@_@"
							+ sb.delete(sb.length() - 1, sb.length())
									.toString());
				}
				context.write(k, v);
			}
    	}
        
        /**
         * 
         * @MethodName: splitLine
         * @Description: 分割行
         * @param lineValue
         * @param split
         * @return String[] 
         * @throws
         */
        private String[] splitLine(Text lineValue, String split) {
    		String line = Strings.trim(lineValue.toString());
    		String[] vals;
    		if ("|".equals(split) || StringUtils.isEmpty(split)) {
    			vals = line.split("\\|", -1);
    		} else if ("$".equals(split)) {
    			vals = line.split("\\$", -1);
    		} else {
    			vals = line.split(split, -1);
    		}
    		return vals;
        }
        
    }
    
    /**
     * 
     * @ClassName: Sync2HBaseReducer
     * @Description: TODO
     * @author Mclaren.Pan
     * @date 2014年12月2日 下午5:01:17
     *
     */
    public static class Sync2HBaseReducer extends
		Reducer<Text, Text, Text, Text> {
    	private String[] headers = {};
    	
    	private String familyCol = "";
    	
    	private String rowKeyStr = "";
    	
    	private String dataSourceID = "";
    	
    	private String separator = "";
    	
    	@Override
		protected void setup(Context context) throws IOException,
				InterruptedException {
    		String headerStr_ = context.getConfiguration().get("headerStr");
        	headers = headerStr_.split("\\|", -1);
        	separator = context.getConfiguration().get("separator");
        	familyCol = context.getConfiguration().get("familyCol");
        	rowKeyStr = context.getConfiguration().get("rowKeyStr");
        	dataSourceID = context.getConfiguration().get("dataSourceID");
		}

		@Override
		protected void cleanup(Context context) throws IOException,
				InterruptedException {
		}
		
		public void reduce(Text key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			boolean ds_a_found = false;
			String[] finalLine = null;
			String acc_nbr = "";
			boolean ds_b_found = false;
			String[] vals = null;
			
			//得到相同key的集合，所以会得到两个数据源的数据
			for (Text val : values) {
				String[] data = val.toString().split("@_@");
				
	        	if (data[0].toString().contains("DS_A")) {
	        		finalLine = splitLine(new Text(data[1]), ",");
	        		ds_a_found = true;
	        	} else {
	        		vals = splitLine(new Text(data[1]), ",");
	        		acc_nbr = vals[4];
	        		ds_b_found = true;
	        	}
	        	
	        	if (ds_a_found && ds_b_found) {
	        		StringBuilder sb = new StringBuilder();
	        		for (String col : finalLine) {
	        			sb.append(col).append(",");
	        		}
	        		String rowKey_ = acc_nbr + "_" + finalLine[0];
	        		
	        		String temp = sb.delete(sb.length() -1 , sb.length()).toString();
	        		//可能存在一对多的情况，都要插入
	        		context.write(new Text(rowKey_), new Text(temp));
	        		ds_b_found = false;
	        	}
			}
			
		}
		
        private String[] splitLine(Text lineValue, String split) {
    		String line = Strings.trim(lineValue.toString());
    		String[] vals;
    		if ("|".equals(split) || StringUtils.isEmpty(split)) {
    			vals = line.split("\\|", -1);
    		} else {
    			vals = line.split(split, -1);
    		}
    		return vals;
        }
    }
    
    /**
     * 
     * @ClassName: ExportHBaseMapper
     * @Description: TODO
     * @author Mclaren.Pan
     * @date 2014年12月4日 上午12:35:09
     *
     */
    public static class ExportHBaseMapper extends Mapper<Text, Text, ImmutableBytesWritable, Put> {

    	private String[] headers = {};
    	
    	private String separator = "";
    	
    	private String familyCol = "";
    	
    	private String rowKeyStr = "";
    	
    	private String dataSourceID = "";
    	
        @Override
        protected void setup(Context context){
        	String headerStr_ = context.getConfiguration().get("headerStr");
        	headers = headerStr_.split("\\|", -1);
        	separator = context.getConfiguration().get("separator");
        	familyCol = context.getConfiguration().get("familyCol");
        	rowKeyStr = context.getConfiguration().get("rowKeyStr");
        	dataSourceID = context.getConfiguration().get("dataSourceID");
        }
        
        @Override
        public void map(Text key, Text value, Context context) throws IOException, InterruptedException {
        	
        	//分解行
        	String[] vals = splitLine(value);
        	
        	//获取rowKey
        	byte[] rowKeyVal = key.copyBytes();
    		
        	//插入hbase
        	try {
        		Put put = buildPutInstance(rowKeyVal, vals);
        		ImmutableBytesWritable immutableBytesWritable = new ImmutableBytesWritable();
        		immutableBytesWritable.set(rowKeyVal);
        		context.write(immutableBytesWritable, put);
        	} catch (Exception e) {
        		LOG.error("", e);
        	}
    		
    	}
        
        
        /**
         * 
         * @MethodName: buildPutInstance
         * @Description: 组装Put实例
         * @param rowKeyVal
         * @param vals
         * @return Put 
         * @throws
         */
        private Put buildPutInstance(byte[] rowKeyVal, String[] vals) {
        	String item = "";
        	String itemDataType = "";
        	byte[] familyCol_bytes = Bytes.toBytes(familyCol);
        	Put put = new Put(rowKeyVal);
    		for (int i = 0; i < vals.length; i++) {
    			item = Strings.trim(vals[i]);
    			itemDataType = ConfSource.getDataTypeFromConf(dataSourceID,
    					headers[i]);
    			if ("" != itemDataType) {
    				if (itemDataType.contains("NUMBER")) {
    					if (itemDataType.contains(",")) {
    						if ("".equals(item.trim())) {
    							put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
    									Bytes.toBytes(0.0));
    						}
    						else {
    							Double itemVal = 0.0;
    							itemVal = Double.parseDouble(item.trim());
    							put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
    									Bytes.toBytes(itemVal));
    						}
    					} else {
    						Pattern pattern = Pattern.compile("(\\d+)");
    						Matcher matcher = pattern.matcher(itemDataType);
    						int precision = 0;
    						if (matcher.find()) {
    							precision = Integer.valueOf(matcher.group(1));
    						}
    						 NUMBER如果超过10位，可能超过int表示范围-2147483648~2147483647，会报错，这里转成long
    						if (precision >= 10) {
    							if ("".equals(item.trim())) {
    								put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
    										Bytes.toBytes(0));
    							}
    							else {
    								Double itemVal = Double.parseDouble(item.trim());
        							put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
        									Bytes.toBytes(itemVal));
    							}
    						} else {
    							if ("".equals(item.trim())) {
    								put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
    										Bytes.toBytes(0));
    							}
    							else {
    								Integer itemVal = 0;
    								itemVal = Integer.parseInt(item.trim());
    								put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
    										Bytes.toBytes(itemVal));
    							}
    						}
    					}
    				} else {
    					put.add(familyCol_bytes, Bytes.toBytes(headers[i]),
    							Bytes.toBytes(item));
    				}
    			} else {
    				put.add(familyCol_bytes, Bytes.toBytes(headers[i]), Bytes.toBytes(item));
    			}
    		}
    		return put;
        }
        
        /**
         * 
         * @MethodName: splitLine
         * @Description: 分割行
         * @param lineValue
         * @return String[] 
         * @throws
         */
        private String[] splitLine(Text lineValue) {
    		String line = lineValue.toString().trim();
    		String[] vals;
    		if ("|".equals(separator) || StringUtils.isEmpty(separator)) {
    			vals = line.split("\\|", -1);
    		}
    		else  {
    			vals = line.split(separator, -1);
    		}
    		return vals;
        }
        
        /**
         * 
         * @MethodName: getRowKeyVal
         * @Description: 获取rowkey
         * @param headers
         * @param colsPerLine
         * @throws InterruptedException
         * @return byte[] 
         * @throws
         */
        private byte[] getRowKeyVal(String[] headers, String[] colsPerLine) throws InterruptedException {
        	String[] rowKeys = rowKeyStr.split(",");
        	StringBuilder rkBuf = new StringBuilder();
        	for (String rowKey : rowKeys) {
        		int rkIdx = Arrays.asList(headers).indexOf(rowKey);
        		rkBuf.append(colsPerLine[rkIdx]).append("_");
        	}
        	int rkBufLen = rkBuf.length();
    		byte[] rowKeyVal = Bytes.toBytes(rkBuf.delete(rkBufLen - 1, rkBufLen).toString());
    		return rowKeyVal;
        }
    }

    /**
     * @throws IOException 
     * 
     * @MethodName: sync2HBase
     * @Description: 导入bigtable的共用执行类
     * @throws Exception
     * @return void 
     * @throws
     */
    private void sync2HBase() throws IOException{
    	
		Configuration conf1 = ConfSource.getHBaseConf();
		Job job1 = new Job(conf1, "2个数据源关联");
		job1.setOutputKeyClass(Text.class);
		job1.setOutputValueClass(Text.class);
		job1.setJarByClass(Sync2HBaseJob.class);
		job1.setMapperClass(Sync2HBaseMapper.class);
		job1.setReducerClass(Sync2HBaseReducer.class);
		job1.setOutputKeyClass(Text.class);
		job1.setOutputValueClass(Text.class);
		FileInputFormat.addInputPaths(job1, confClz.getDownloadPath());
		FileOutputFormat.setOutputPath(job1, new Path("/mr_temp"));
		// 设置参数
		job1.getConfiguration().set("headerStr", confClz.getHeaderStr());
		job1.getConfiguration().set("separator", confClz.getSeparator());
		job1.getConfiguration().set("familyCol", confClz.getFamilyCol());
		job1.getConfiguration().set("rowKeyStr", confClz.getRowKeyStr());
		job1.getConfiguration().set("dataSourceID", confClz.getDataSourceID());
		
		try {
			job1.waitForCompletion(true);

		} catch (Exception e) {
			e.printStackTrace();
		}
		
		try {
			Configuration conf2 = ConfSource.getHBaseConf();
			Job job2 = new Job(conf2, "Import into hbase table"
					+ confClz.getHbaseTable() + " from "
					+ confClz.getDownloadPath());
			job2.setJarByClass(Sync2HBaseJob.class);
			job2.setInputFormatClass(KeyValueTextInputFormat.class);
			FileInputFormat.setInputPaths(job2, new Path("/mr_temp"));
			job2.setMapperClass(ExportHBaseMapper.class);
			HTable table = new HTable(conf2, confClz.getHbaseTable());
			job2.setReducerClass(PutSortReducer.class);
			Path outputDir = new Path(confClz.getHfilePath());
			FileOutputFormat.setOutputPath(job2, outputDir);
			job2.setMapOutputKeyClass(ImmutableBytesWritable.class);
			job2.setMapOutputValueClass(Put.class);
			HFileOutputFormat2.configureIncrementalLoad(job2, table);
			TableMapReduceUtil.addDependencyJars(job2);

			// 设置参数
			job2.getConfiguration().set("headerStr", confClz.getHeaderStr());
			job2.getConfiguration().set("separator", confClz.getSeparator());
			job2.getConfiguration().set("familyCol", confClz.getFamilyCol());
			job2.getConfiguration().set("rowKeyStr", confClz.getRowKeyStr());
			job2.getConfiguration().set("dataSourceID", confClz.getDataSourceID());

				job2.waitForCompletion(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		
    }
    
    /**
     * 
     * @MethodName: getConf
     * @Description: 加载配置文件
     * @return void 
     * @throws
     */
	private void getConf() {
		
		//读取数据源ID
		String dataSourceID = cl.getOptionValue("dsid");
		if (StringUtils.isEmpty(dataSourceID)) {
			LOG.error("没有指定数据源ID");
			System.exit(1);
		}
		
		//读取列
		String headerStr = ConfSource.getProperty(dataSourceID + ".header");
		String[] headers = headerStr.split("\\|", -1);
		
		//读取分隔符
		String separator = ConfSource.getProperty(dataSourceID + ".separator");
		
		//读取hbase表名
		String hbaseTable = cl.getOptionValue("tb");
		
		if (StringUtils.isEmpty(hbaseTable)) {
			LOG.error("没有指定导入的HBASE表名");
			System.exit(1);
		}
		
		//读取列族
		String familyCol = ConfSource.getProperty(dataSourceID + ".familyCol"); 
		
		//rowkey,支持组合rowKey
		String rowKeyStr = ConfSource.getProperty(dataSourceID + ".rowKey");
		String[] rowKeys = rowKeyStr.split(",");
		for (String rk : rowKeys) {
			int rkIdx = Arrays.asList(headers).indexOf(rk);
			if (-1 == rkIdx) {
				LOG.error("指定RowKey在列数据中未找到！");
				System.exit(1);
			}
		}

		//读取hdfs路径
		String downloadPath = "";
		String inputPath = cl.getOptionValue("path");
		if (StringUtils.isEmpty(inputPath)) {
			String dataFilePath = ConfSource.getProperty(dataSourceID + ".hdfsPath");
			if (StringUtils.isEmpty(dataFilePath)) {
				LOG.error("没有指定数据文件地址，并且默认数据文件地址未来找到！");
				System.exit(1);
			} else {
				downloadPath = dataFilePath;
			}
		} else {
			downloadPath = inputPath;
		}

		// hfile 存放hdfs路径
		String hfilePath = cl.getOptionValue("hfilePath");
		if (StringUtils.isEmpty(hfilePath)) {
			LOG.error("必须设置hfile存放的hdfs路径!");
			System.exit(1);
		}

		confClz.setDataSourceID(dataSourceID);
		confClz.setFamilyCol(familyCol);
		confClz.setRowKeyStr(rowKeyStr);
		confClz.setHbaseTable(hbaseTable);
		confClz.setHeaderStr(headerStr);
		confClz.setSeparator(separator);
		confClz.setDownloadPath(downloadPath);
		confClz.setHfilePath(hfilePath);
	}
    
    /**
     * 
     * @MethodName: getCommandParam
     * @Description: 从命令行获取参数
     * @param args
     * @return void 
     * @throws
     */
    private void getCommandParam(String[] args) {
    	Options opt = new Options();
    	opt.addOption("dsid", true, "data source identity");
    	opt.addOption("path", true, "hdfs absolute path");
    	opt.addOption("tb", true, "which hbase table to export");
    	opt.addOption("hfilePath", "hfile path", true, "hfile output hdfs path");
    	String formatStr = "sh hadoop [this jar path][-dsid][-path][-tb][-bulkpath] ";
    	HelpFormatter formatter = new HelpFormatter();
    	CommandLineParser parser = new PosixParser();
    	try {
    		cl = parser.parse(opt, args); 
    	} catch (Exception e) {
    		formatter.printHelp(formatStr, opt);
    		System.exit(1);
    		LOG.error("", e);
    	}
    }
    
    public static void main(String[] args) {
    	try {
    		Sync2HBaseJob job = new Sync2HBaseJob();
    		job.getCommandParam(args);
    		job.getConf();
    		job.sync2HBase();
    	}
    	catch (Exception e) {
    		e.printStackTrace();
    	}
    }
    	
}


MapReduce医疗数据分析与健康管理
AI天才研究院
07-22 886
MapReduce医疗数据分析与健康管理 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来 随着医疗信息化和大数据技术的快
Google MapReduce 大数据处理系统
最新发布
山川湖海*
05-24 723
在过去的5年中，本文作者和许多Google的程序员已经实现了数百个特定用途的计算程序，处理了海量的原始数据，包括抓取到的文档、网页请求日志等，计算各种衍生出来的数据，如反向索引、网页文档的图形结构的各种表示、每个host下抓取到的页面数量的总计、一个给定日期内的最频繁查询的集合等。大多数这种计算概念明确。然而，输入数据通常都很大，并且计算必须分布到数百或数千台机器上以确保在一个合理的时间内完成。如何并行计算、分布数据、处理错误等问题使这个起初很简单的计算，由于增加了处理这些问题的很多代码而变得十分复杂。
hadoop2面试题 - 迅速在两个含有大量数据的文件中寻找相同的数据.pdf
08-11
hadoop2面试题 - 迅速在两个含有大量数据的文件中寻找相同的数据.pdf
mapreduce 实现内连接，左连接，右连接，全连接，反连接
gongpulin的博客
03-06 449
数据集user(id name)用户表 1 user1 2 user2 3 user3 4 user4 5 user5 6 user6post(userid postid postname)帖子表 1 1 post1 1 2 post2 2 3 post3 4 4 post4 5 5 post5 8 6 post6 8 7 post7 8 8 post8package com.test; imp...
Hadoop MapReduce开发--两个输入数据关联
冯大叔的博客
01-12 389
测试数据： dept.txt #deptno    dname    loc 30    sales    chicago 20    research    dallas 10    accounting    newyork employee.txt #empno    ename    job            mgr        hiredate    sal     ...
MapReduce特性(三) 连接-Join DataSets
ThisIsNobody的博客
06-27 232
把Join作为实现的核心部分的高级框架：Pig Hive Cascading Cruc Spark连接操作取决于数据集的规模和分区方式1 如果其中一个数据集很小，可以分发到各个MR节点上连接2 如果两个数据集都很大，需要考虑如何使用map端连接和reduce端连接mapper执行连接称为 mapper端连接reducer执行连接称为reduce端连接map端连接数据到达map函数之前连接    &...
MapReduce数据处理两表join连接
关注大数据专栏
03-29 702
现在这里有两个text文档,需要把它合并成一个文档,并且里面的数据不能有冗余.. [plain] view plaincopy info.txt文件:      1003 kaka   1004 da   1005 jue   1006 zhao   [plain] view plaincopy
基于Mapreduce的关联规则挖掘（2）
weixin_44869866的博客
05-08 1177
二、调研近年来基于Mapreduce的关联规则挖掘算法，并进行综述。 目前已提出的基于 Mapreduce计算模型的并行关联规则 挖掘算法大多是将 Apriori、FP-Growth算法及Eclat算法三种经典算法向 Mapreduce计算模型迁移，实现并行计算。其基本思路是：利 用 Mapreduce的开源实现 Hadoop作为设计和运行的平台；利 用 Hadoop的分布式文件系统 HDFS进行大数据集的分布式存 储；将算法的输入和输出改造成 Mapreduce计算模型要求的 〈key，value〉模型；
Hadoop MapReduce实现数据关联：客户与订单信息整合示例
如果找到匹配，就将两个数据集中的记录组合成一条输出记录。 在实际开发中，我们可能需要为Map侧join创建一个自定义的RecordReader，或者将小数据集以一种特殊格式存储在HDFS上，以便Map任务可以快速访问。在本例中...
基于MapReduce的Apriori算法代码
11-08
3. Mapper和Reducer：Mapper和Reducer是MapReduce框架中的两个主要组件，Mapper负责将输入数据集映射成键值对，Reducer负责聚合Mapper输出的键值对。 4. 并行计算：该代码使用MapReduce框架来实现Apriori算法的并行...
大数据技术之Hadoop之MapReduce（3）——KeyValueTextInputFormat使用案例
zy13765287861的博客
03-06 223
3.1.7 KeyValueTextInputFormat使用案例 1．需求 统计输入文件中每一行的第一个单词相同的行数。 （1）输入数据 banzhang ni hao xihuan hadoop banzhang banzhang ni hao xihuan hadoop banzhang （2）期望结果数据 banzhang 2 xihuan 2 2．需求分析 在本地的Hadoop3.1...
MapReduce的表关联
流云晨风
10-17 883
Join方式 （1）Reduce端连接 （2）Map端连接 （3）SemiJoin半连接 （1）Reduce端连接原理 Map端的主要工作：打标签，为来自不同表（文件）的key/value对打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。 reduce端的主要工作：在reduce端以连接字段作为key的分组已经完成，我们只
Java未来路在何方？大厂直通车！
m0_57064830的博客
07-02 187
一.java基础面试知识点 java中==和equals和hashCode的区别 int、char、long各占多少字节数 int与integer的区别 探探对java多态的理解 String、StringBuffer、StringBuilder区别 什么是内部类？内部类的作用 抽象类和接口区别 抽象类的意义 抽象类与接口的应用场景 抽象类是否可以没有方法和属性？ 接口的意义 泛型中extends和super的区别 父类的静态方法能否被子类重写 进程和线程的区别 final，finally，finaliz.
MapReduce多个作业协调处理
lavimer
01-25 1569
一：背景 当数据来源不同的时候，比如用户表在MYSQL数据库中，而销售表在HDFS中，我们可以启动多个作业来依次处理这些数据源。 二：技术实现 #需求 #用户表user在MYSQL数据库中，数据如下： 1 liaozhongmin 2 lavimer 3 liaozemin #销售表user_data在HDFS中，数据如下： 1 12 2 28 2 36 3 88 #我们
mapreduce分组统计_一种基于MapReduce的Map端数据的聚合方法与流程
weixin_35928736的博客
01-13 921
本发明涉及的是一种分布式计算方法，具体涉及一种基于MapReduce的Map端数据的聚合方法。背景技术：当前处理大数据应用问题时，比较重要的两个思想：并行和分治。通过将大规模的数据合理的拆分成多个小部分，通过并行思想和分治思想相结合的计算方法，使得问题得到的相对满意的解决。MapReduce为我们提供了一种有效、快速的并行编程框架。MapReduce实现了两个主要功能：Map和Reduce。Map...
成为Java顶尖程序员，先过了下面问题！
weixin_30384217的博客
11-30 823
一、数据结构与算法基础 说一下几种常见的排序算法和分别的复杂度。 用Java写一个冒泡排序算法 描述一下链式存储结构。 如何遍历一棵二叉树？ 倒排一个LinkedList。 用Java写一个递归遍历目录下面的所有文件。 java学习群669823128 二、Java基础 接口与抽象类的区别？ Java中的异常有哪几类？分别怎么使用？ 常用的集合类有哪些？比如List如何排...
经典问题总结
思考、总结、专注
08-12 2972
一、Java基础 1. 实例方法和静态方法有什么不一样？ 2. Java中的异常有哪几类？分别怎么使用？ 3. 常用的集合类有哪些？比如List如何排序？ 4. ArrayList和LinkedList内部的实现大致是怎样的？他们之间的区别和各自适应的场景是什么？ 5. 内存溢出是怎么回事？ 6. ClassLoader有什么用？ 7. ==和equals
MapReduce作业Map阶段和Reduce阶段重要过程详述（Partitioner、Combiner、Shuffle三个阶段的解析）
热门推荐
马超的博客
05-13 1万+
MapReduce作业Map阶段和Reduce阶段重要过程详述（Partitioner、Combiner、Shuffle）MapReduce作业Map阶段和Reduce阶段重要过程详述（Partitioner、Combiner、Shuffle三个阶段的解析）备注：map阶段包括partitioner、combiner；reduce阶段包括shuffle。combiner阶段：（combiner阶段：
Hadoop开篇之Mapreduce实现多类别流量统计的两种实现方式
jp_850741123的博客
09-04 2090
1、环境：hadoop2.6伪分布式 2、输入：流量日志文件 1）日志具体内容： 1363157985066 13726230503 00-FD-07-A4-72-B8:CMCC 120.196.100.82 i02.c.aliimg.com 24 27 2481 24681 200 1363157995052 13826544101 5C-0E-8B-C7-F1-E
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值