Hadoop切片机制

最新推荐文章于 2021-10-31 15:33:14 发布
最新推荐文章于 2021-10-31 15:33:14 发布
阅读量985 收藏 6
点赞数
分类专栏： 大数据 文章标签： 大数据
原文链接：https://blog.csdn.net/u010502101/article/details/104012173
版权

文章目录


一个超大文件在HDFS上存储时，是以多个Block存储在不同的节点上，比如一个512M的文件，HDFS默认一个Block为128M，那么1G的文件分成4个Block存储在集群中4个节点上。
Hadoop在map阶段处理上述512M的大文件时分成几个MapTask进行处理呢？Hadoop的MapTask并行度与数据切片有有关系，数据切片是对输入的文件在逻辑上进行分片，对文件切成多少份，Hadoop就会分配多少个MapTask任务进行并行执行该文件，原理如下图所示。
Block与Splite区别：Block是HDFS物理上把数据分成一块一块；数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。如下图所示，一个512M的文件在HDFS上存储时，默认一个block为128M，那么该文件需要4个block进行物理存储；若对该文件进行切片，假设以100M大小进行切片，该文件在逻辑上需要切成5片，则需要5个MapTask任务进行处理。
在这里插入图片描述

 

一、数据切片源码详解

  /** 
	   * Generate the list of files and make them into FileSplits.
	   * @param job the job context
	   * @throws IOException
	   */
	  public List<InputSplit> getSplits(JobContext job) throws IOException {
	    StopWatch sw = new StopWatch().start();
	    /*
	     * 	1、minSize默认最小值为1
	     *     maxSize默认最大值为9,223,372,036,854,775,807‬
	     * */
	    long minSize = Math.max(getFormatMinSplitSize(), getMinSplitSize(job));
	    long maxSize = getMaxSplitSize(job);

	    // generate splits
	    List<InputSplit> splits = new ArrayList<InputSplit>();
	    /*
	     *   2、获取所有需要处理的文件
	     * */
	    List<FileStatus> files = listStatus(job);
	    for (FileStatus file: files) {
	      Path path = file.getPath();
	      /*
	       *   3、获取文件的大小
	       * */
	      long length = file.getLen();
	      if (length != 0) {
	        BlockLocation[] blkLocations;
	        if (file instanceof LocatedFileStatus) {
	          /*
	           * 4、获取文件的block，比如一个500M的文件，默认一个Block为128M,500M的文件会分布在4个DataNode节点上进行存储
	           * */
	          blkLocations = ((LocatedFileStatus) file).getBlockLocations();
	        } else {
	        	/*
	        	 * 5、Hadoop如不特殊指定，默认用的HDFS文件系统，只会走上面if分支
	        	 * */
	          FileSystem fs = path.getFileSystem(job.getConfiguration());
	          blkLocations = fs.getFileBlockLocations(file, 0, length);
	        }
	        if (isSplitable(job, path)) {
	          /*
	           * 6、获取Block块的大小，默认为128M
	           * */
	          long blockSize = file.getBlockSize();
	          /*
	           * 7、计算spliteSize分片的尺寸，首先取blockSize与maxSize之间的最小值即blockSize，
	                          *         然后取blockSize与minSize之间的最大值，即为blockSize=128M,所以分片尺寸默认为128M
	           * */
	          long splitSize = computeSplitSize(blockSize, minSize, maxSize);

	          long bytesRemaining = length;
	          /*
	           * 8、计算分片file文件可以在逻辑上划分为多少个数据切片，并把切片信息加入到List集合中
	           * */
	          while (((double) bytesRemaining)/splitSize > SPLIT_SLOP) {
	            int blkIndex = getBlockIndex(blkLocations, length-bytesRemaining);
	            splits.add(makeSplit(path, length-bytesRemaining, splitSize,
	                        blkLocations[blkIndex].getHosts(),
	                        blkLocations[blkIndex].getCachedHosts()));
	            bytesRemaining -= splitSize;
	          }

	          /*
	           * 9、如果文件最后一个切片不满128M,单独切分到一个数据切片中
	           * */
	          if (bytesRemaining != 0) {
	            int blkIndex = getBlockIndex(blkLocations, length-bytesRemaining);
	            splits.add(makeSplit(path, length-bytesRemaining, bytesRemaining,
	                       blkLocations[blkIndex].getHosts(),
	                       blkLocations[blkIndex].getCachedHosts()));
	          }
	        } else { // not splitable
	          /*
	           * 10、如果文件不可以切分，比如压缩文件，会创建一个数据切片
	           * */
	          splits.add(makeSplit(path, 0, length, blkLocations[0].getHosts(),
	                      blkLocations[0].getCachedHosts()));
	        }
	      } else { 
	        //Create empty hosts array for zero length file
	    	/*
	    	 * 11、如果为空文件，创建一个空的数据切片
	    	 * */
	        splits.add(makeSplit(path, 0, length, new String[0]));
	      }
	    }
	    // Save the number of input files for metrics/loadgen
	    job.getConfiguration().setLong(NUM_INPUT_FILES, files.size());
	    sw.stop();
	    if (LOG.isDebugEnabled()) {
	      LOG.debug("Total # of splits generated by getSplits: " + splits.size()
	          + ", TimeTaken: " + sw.now(TimeUnit.MILLISECONDS));
	    }
	    return splits;
	  }

二、数据切片机制

1、TextInputFormat切片机制

切片方式：TextInputFormat是默认的切片机制，按文件规划进行切分。比如切片默认为128M，如果一个文件为200M，则会形成两个切片，一个是128M，一个是72M，启动两个MapTask任务进行处理任务。但是如果一个文件只有1M，也会单独启动一个MapTask执行此任务，如果是10个这样的小文件，就会启动10个MapTask处理小文件任务。
读取方式：TextInputFormat是按行读取文件的每条记录，key代表读取的文件行在该文件中的起始字节偏移量，key为LongWritable类型；value为读取的行内容，不包括任何行终止符（换行符/回车符）, value为Text类型，相当于java中的String类型。
例如

Birds of a feather flock together
Barking dogs seldom bite
Bad news has wings

用TextInputFormat按每行读取文件时，对应的key和value分别为：

（0，Birds of a feather flock together）
（34，Barking dogs seldom bite）
（59，Bad news has wings）

Demo：下面测试案例已统计单词为测试案例，处理文件为D:\tmp\word\in 目录下的4个文件。在这里插入图片描述
建立对应的Mapper类WordCountMapper：

package com.lzj.hadoop.input;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

/*
 * LongWritable - 表示读取第几行
 * Text 		-  表示读取一行的内容
 * Text			- 表示输出的键
 * IntWritable 	- 表示输出的键对应的个数
 * */
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
	
	Text k = new Text();
	IntWritable v = new IntWritable(1);
	
	@Override
	protected void map(LongWritable key, Text value, Context context)
			throws IOException, InterruptedException {
		//1、读取一行内容
		String line = value.toString();
		if(line.isEmpty()) {
			return;
		}
		//2、按空格切割读取的单词
		String[] words = line.split(" ");
		//3、输出mapper处理完的内容
		for(String word : words) {
			/*给键设置值*/
			k.set(word); 
			/*把mapper处理后的键值对写到context中*/
			context.write(k, v);
		}
		
	}
	
}

建立对应的Reducer类：

package com.lzj.hadoop.input;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

/*
 * Text 		-  输入的键（即Mapper阶段输出的键）
 * IntWritable 	- 输入的值(个数)(即Mapper阶段输出的值)
 * Text 		- 输出的键
 * IntWritable 	- 输出的值
 * */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
	@Override
	protected void reduce(Text text, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
		//1、统计键对应的个数
		int sum = 0;
		for(IntWritable value : values) {
			sum = sum + value.get();
		}
		//2、设置reducer的输出
		IntWritable v = new IntWritable(sum);
		context.write(text, v);
	}
}

建立驱动类drive

/*测试TextInputFormat*/
public void testTextInputFormat() throws IOException, ClassNotFoundException, InterruptedException{
	//1、获取job的配置信息
	Configuration conf = new Configuration();
	Job job = Job.getInstance(conf);
	//2、设置jar的加载路径
	job.setJarByClass(WordCountDriver.class);
	//3、分别设置Mapper和Reducer类
	job.setMapperClass(WordCountMapper.class);
	job.setReducerClass(WordCountReducer.class);
	//4、设置map的输出类型
	job.setMapOutputKeyClass(Text.class);
	job.setMapOutputValueClass(IntWritable.class);
	//5、设置最终输出的键值类型
	job.setOutputKeyClass(Text.class);
	job.setOutputValueClass(IntWritable.class);
	//6、设置输入输出路径
	FileInputFormat.setInputPaths(job, new Path("D:/tmp/word/in"));
	FileOutputFormat.setOutputPath(job, new Path("D:/tmp/word/out"));
	//7、提交任务
	boolean flag = job.waitForCompletion(true);
	System.out.println("flag ； " + flag);
}

启动测试，在输出的日志信息中会有如下一行内容：

number of splits:4
  • 1

处理的4个文件1.txt、2.txt、3.txt、4.txt分别小于128M，每一个文件会被切成一个split。

2、CombineTextInputFormat切片机制

如果要处理的任务中含有很多小文件，采用默认的TextInputFormat切片机制会启动多个MapTask任务处理文件，浪费资源。CombineTextInputFormat用于处理小文件过多的场景，它可以将多个小文件从逻辑上切分到一个切片中。CombineTextInputFormat在形成切片过程中分为虚拟存储过程和切片过程两个过程。

（1）虚拟存储过程
将输入目录下所有文件大小，依次和设置的setMaxInputSplitSize值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值2倍，此时将文件均分成2个虚拟存储块（防止出现太小切片）。
例如setMaxInputSplitSize值为4M，输入文件大小为8.02M，则先逻辑上分成一个4M。剩余的大小为4.02M，如果按照4M逻辑划分，就会出现0.02M的小的虚拟存储文件，所以将剩余的4.02M文件切分成（2.01M和2.01M）两个文件。
（2）切片过程
判断虚拟存储的文件大小是否大于setMaxInputSplitSize值，大于等于则单独形成一个切片；
如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。

下面以“D:\\tmp\\word\\in”目录下的1.txt（576K）、2.txt（1151K）、3.txt（2302K）、4.txt（4604K）为例，比如设置虚拟存储切片setMaxInputSplitSize为2M，1.txt 大小576K小于2M，形成一个存储块，2.txt大小1151K也小于2M，形成一个存储块，3.txt大小2302K大于2M，但小于4M，形成两个存储块，分别为1151K，4.txt大小4604K大于4M，形成一个2M的存储块后，还剩4604-1024*2=2556K，2556K大于2M，小于4M，分别形成2个1278K的存储块，  在存储过程会形成6个文件块，分别为：
  •  

576K、1151K、（1151K，1151K）、（2048K、1278K、1278K）

在切片过程中，前3个存储块和为576K + 1151K + 1151K = 2878K > 2M，形成一个切片；
第4和第5个存储块和为：1151K + 2048K = 3199K > 2M，形成一个切片；最后两个存储块和为：1278K + 1278K = 2556K > 2M，形成一个切片，最终在切片过程中，4个文件形成了3个切片，启动三个MapTask任务进行处理文件。

Demo:采用上述D:\tmp\word\in目录下的文件进行测试
WordCountMapper和WordCountReducer同上例，驱动类如下

/*测试CombineTextInputFormat*/
public void testCombineTextInputFormat() throws IOException, ClassNotFoundException, InterruptedException {
	//1、获取job的配置信息
	Configuration conf = new Configuration();
	Job job = Job.getInstance(conf);
	//2、设置jar的加载路径
	job.setJarByClass(WordCountDriver.class);
	//3、分别设置Mapper和Reducer类
	job.setMapperClass(WordCountMapper.class);
	job.setReducerClass(WordCountReducer.class);
	//4、设置map的输出类型
	job.setMapOutputKeyClass(Text.class);
	job.setMapOutputValueClass(IntWritable.class);
	//5、设置最终输出的键值类型
	job.setOutputKeyClass(Text.class);
	job.setOutputValueClass(IntWritable.class);
	//6、设置输入输出路径
	FileInputFormat.setInputPaths(job, new Path("D:\\tmp\\word\\in"));
	FileOutputFormat.setOutputPath(job, new Path("D:\\tmp\\word\\out"));
	//7、设置数据切分方式
	job.setInputFormatClass(CombineTextInputFormat.class);
	CombineTextInputFormat.setMaxInputSplitSize(job, 2097152); //2M
	//8、提交任务
	boolean flag = job.waitForCompletion(true);
	System.out.println("flag ； " + flag);
}

启动测试类，日志输出中会有如下内容：

number of splits:3
  •  

3、KeyValueTextInputFormat切片机制

KeyValueTextInputFormat与TextInputFormat相似，按行读入记录，每个文件形成一个切片，但KeyValueTextInputFormat在读入一行后可以指定切割符，把一行内容按切割符分割成键值对的形式。例如

A-this is a
B-this is b
C-this is c
C-this is c

经过mapper阶段后被切割成：

(A,this is a)
(B,this is b)
(C,this is c)
(C,this is c)

下面统计每行开头为相同字母的个数。
Mapper类为：

package com.lzj.hadoop.input;

import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

/*
 * LongWritable - 表示读取第几行
 * Text 		-  表示读取一行的内容
 * Text			- 表示输出的键
 * IntWritable 	- 表示输出的键对应的个数
 * */
public class WordCountMapper extends Mapper<Text, Text, Text, LongWritable>{
	
	LongWritable v = new LongWritable(1);
	
	@Override
	protected void map(Text key, Text value, Context context)
			throws IOException, InterruptedException {
		//1、读取一行内容
		String line = value.toString();
		if(line.isEmpty()) {
			return;
		}
		//2、按空格切割读取的单词
		context.write(key, v);
		
	}
	
}

Reducer类为：


```java
package com.lzj.hadoop.input;

import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

/*
 * Text 		-  输入的键（即Mapper阶段输出的键）
 * IntWritable 	- 输入的值(个数)(即Mapper阶段输出的值)
 * Text 		- 输出的键
 * IntWritable 	- 输出的值
 * */
public class WordCountReducer extends Reducer<Text, LongWritable, Text, LongWritable>{
	@Override
	protected void reduce(Text text, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
		//1、统计键对应的个数
		long sum = 0;
		for(LongWritable value : values) {
			sum = sum + value.get();
		}
		//2、设置reducer的输出
		LongWritable v = new LongWritable(sum);
		context.write(text, v);
	}
}

Driver驱动类为：

/*测试keyvaleTextInputFormat*/
public static void testkeyValeTextInputFormat() throws IOException, ClassNotFoundException, InterruptedException {
	//1、获取job的配置信息
	Configuration conf = new Configuration();
	Job job = Job.getInstance(conf);
	//2、设置jar的加载路径
	job.setJarByClass(WordCountDriver.class);
	//3、分别设置Mapper和Reducer类
	job.setMapperClass(WordCountMapper.class);
	job.setReducerClass(WordCountReducer.class);
	//4、设置map的输出类型
	job.setMapOutputKeyClass(Text.class);
	job.setMapOutputValueClass(LongWritable.class);
	//5、设置最终输出的键值类型
	job.setOutputKeyClass(Text.class);
	job.setOutputValueClass(LongWritable.class);
	//6、设置输入输出路径
	FileInputFormat.setInputPaths(job, new Path("D:/tmp/word/in1/1.txt"));
	FileOutputFormat.setOutputPath(job, new Path("D:/tmp/word/out6"));
	//7、设置数据切分方式
	job.setInputFormatClass(KeyValueTextInputFormat.class);
	conf.set(KeyValueLineRecordReader.KEY_VALUE_SEPERATOR, "-");
	//8、提交任务
	boolean flag = job.waitForCompletion(true);
	System.out.println("flag ； " + flag);
}
  • ，输出切片个数为1

4、NLineInputFormat切片机制

NLineInputFormat可以指定切分文件时按指定的行数进行切分，比如文件总行数为n，切分行数为N，则切片数为：如果n/N整除，切片数为n/N；如果不能整除，切片数为（n/N + 1）。以下面测试文件为例：

There is no royal road to learning
It is never too old to learn
A man becomes learned by asking questions
Absence makes the heart grow fonder
When the cat is away, the mice will play
No cross, no crown
Ill news travels fast
He that climbs high falls heavily
From saving comes having
Experience is the mother of wisdom
East or west, home is best
Don't teach your grandmother to suck eggs
Don't trouble trouble until trouble troubles you
Doing is better than saying 
Birds of a feather flock together
Barking dogs seldom bite
Bad news has wings
As the tree, so the fruit
An idle youth, a needy age

文件共有19行，假设设置切片行数为5，即每5行形成一个切片，可以分成 19/5+1=5个切片。Mapper在读入文件时与TextInputFormat相同，按每行读取记录，对应的键key为该行内容在文件中的偏移量，对应的值value为该行具体内容。例如

（0，There is no royal road to learning）
（35，It is never too old to learn）
（64，A man becomes learned by asking questions）
	……

统计该测试文件中单词数案例如下
建立Mapper类：

package com.lzj.hadoop.input.nline;

import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class NLineInputFormatMapper extends Mapper<LongWritable, Text, Text, LongWritable> {

	Text k = new Text();
	LongWritable v = new LongWritable(1);
	
	@Override
	protected void map(LongWritable key, Text value, Context context)
			throws IOException, InterruptedException {
		//1、获取一行内容
		String line = value.toString();
		//2、切割行
		String[] words = line.split(" ");
		//3、循环写出
		for(String word : words) {
			k.set(word);
			context.write(k, v);
		}
		
	}
}

建立Reducer类：

package com.lzj.hadoop.input.nline;

import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class NLineInputFormatReducer extends Reducer<Text, LongWritable, Text, LongWritable> {

	LongWritable v = new LongWritable();
	
	@Override
	protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
		long sum = 0;
		for(LongWritable value : values) {
			sum = sum + value.get();
		}
		v.set(sum);
		context.write(key, v);
	}
}

建立Driver测试类：

package com.lzj.hadoop.input.nline;

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.NLineInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class NLineInputFormatDriver {

	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		//1、获取job的配置信息
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf);
		//2、设置jar的加载路径
		job.setJarByClass(NLineInputFormatDriver.class);
		//3、分别设置Mapper和Reducer类
		job.setMapperClass(NLineInputFormatMapper.class);
		job.setReducerClass(NLineInputFormatReducer.class);
		//4、设置map的输出类型
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(LongWritable.class);
		//5、设置最终输出的键值类型
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(LongWritable.class);
		//6、设置输入输出路径
		FileInputFormat.setInputPaths(job, new Path("D:\\tmp\\word\\in2"));
		FileOutputFormat.setOutputPath(job, new Path("D:\\tmp\\word\\out7"));
		//7、设置切分方式
		job.setInputFormatClass(NLineInputFormat.class);
		NLineInputFormat.setNumLinesPerSplit(job, 5);
		//8、提交任务
		boolean flag = job.waitForCompletion(true);
		System.out.println("flag ； " + flag);
	}

}

启动测试类，日志中会输出切片的个数：

number of splits:4
  • 1

5、自定义InputFormat切片机制

除了上述hadoop自带的切片机制，还可以自定义切片机制满足定制开发。自定义InputFormat切片机制时需要自定义一个RecorderReader用于读取文件，需要自定义一个InputFormat用于设置切文件输入切分方式，然后后续开发如同上述切片机制开发一样，创建Mapper、Reducer、driver类即可。
下面以将3个小文件合并成一个大文件为例
首先，定制RecordReader类

package com.lzj.hadoop.input.custom;

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

public class CustomRecordReader extends RecordReader<Text, BytesWritable>{

	private FileSplit split;
	private Configuration conf;
	private Text key = new Text();
	private BytesWritable value = new BytesWritable();
	private Boolean isProgress = true;
	
	@Override
	public void initialize(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException {
		this.split = (FileSplit) split;
		conf = context.getConfiguration();
	}

	@Override
	public boolean nextKeyValue() throws IOException, InterruptedException {
		if(isProgress) {
			FSDataInputStream inputStream = null;
			try {
				/*1、获取文件系统*/
				Path path = split.getPath();
				FileSystem fs = path.getFileSystem(conf);
				/*2、获取数据输入流*/
				inputStream = fs.open(path);
				/*3、读取文件内容*/
				byte[] buf = new byte[(int) split.getLength()];
				IOUtils.readFully(inputStream, buf, 0, buf.length);
				/*4、设置输出文件内容value*/
				value.set(buf, 0, buf.length);
				/*5、设置输出文件的key*/
				String fileName = split.getPath().toString();
				key.set(fileName);
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				/*6、关闭数据流*/
				IOUtils.closeStream(inputStream);
			}
			isProgress = false;
			return true;
		}
		return false;
	}

	@Override
	public Text getCurrentKey() throws IOException, InterruptedException {
		return key;
	}

	@Override
	public BytesWritable getCurrentValue() throws IOException, InterruptedException {
		return value;
	}

	@Override
	public float getProgress() throws IOException, InterruptedException {
		return 0;
	}

	@Override
	public void close() throws IOException {
		// TODO Auto-generated method stub
		
	}

}
  • 定制FileInputFormat
package com.lzj.hadoop.input.custom;

import java.io.IOException;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

public class CustomFileInputFormat extends FileInputFormat<Text, BytesWritable>{

	@Override
	protected boolean isSplitable(JobContext context, Path filename) {
		return false;
	}
	
	@Override
	public RecordReader<Text, BytesWritable> createRecordReader(InputSplit split, TaskAttemptContext context)
			throws IOException, InterruptedException {
		CustomRecordReader recorder = new CustomRecordReader();
		recorder.initialize(split, context);
		return recorder;
	}

}

然后创建Mapper类

package com.lzj.hadoop.input.custom;

import java.io.IOException;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class CstomMapper extends Mapper<Text, BytesWritable, Text, BytesWritable>{
	@Override
	protected void map(Text key, BytesWritable value, Mapper<Text, BytesWritable, Text, BytesWritable>.Context context)
			throws IOException, InterruptedException {
		//把文件名作为key，文件内容作为value
		context.write(key, value);
	}
}
  • ，创建Reducer类：
package com.lzj.hadoop.input.custom;

import java.io.IOException;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class CustomReducer extends Reducer<Text, BytesWritable, Text, BytesWritable>{

	@Override
	protected void reduce(Text key, Iterable<BytesWritable> values,
			Reducer<Text, BytesWritable, Text, BytesWritable>.Context context) throws IOException, InterruptedException {
		/*把key（文件名）+ value(文件内容)写入到一个文件中*/
		context.write(key, values.iterator().next());
	}
}

最后，创建Driver驱动类：

package com.lzj.hadoop.input.custom;

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;

public class CustomDriver {
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		//1、获取job的配置信息
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf);
		//2、设置jar的加载路径
		job.setJarByClass(CustomDriver.class);
		//3、分别设置Mapper和Reducer类
		job.setMapperClass(CstomMapper.class);
		job.setReducerClass(CustomReducer.class);
		//4、设置map的输出类型
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(BytesWritable.class);
		//5、设置最终输出的键值类型
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(BytesWritable.class);
		//6、设置输入文件格式
		job.setInputFormatClass(CustomFileInputFormat.class);
		//7、设置输出文件格式
		job.setOutputFormatClass(SequenceFileOutputFormat.class);
		//6、设置输入输出路径
		FileInputFormat.setInputPaths(job, new Path("D:/tmp/word/in3"));
		FileOutputFormat.setOutputPath(job, new Path("D:/tmp/word/out7"));
		//8、提交任务
		boolean flag = job.waitForCompletion(true);
		System.out.println("flag ； " + flag);
	}
}

运行驱动类，会在out7目录下生成一个part-r-00000文件，打开之后，发现把in3目录下的1.txt、2.txt、3.txt的文件和内容写入到了该文件中，以后直接读取该文件，通过key(文件名)就可以直接获取小文件的内容。

Mark_ZQ
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
hadoop 切片机制详解
congge
01-02 1万+
hadoop切片机制详解
10、Hadoop切片机制
u010502101的博客
03-31 3732
一个超大文件在HDFS上存储时，是以多个Block存储在不同的节点上，比如一个1G的文件，HDFS默认一个Block为128M，那么1G的文件分成8个Block存储在集群中8个节点上。 Hadoop在map阶段处理上述1G的大文件时分成几个MapTask进行处理呢？ ...
HDFS的block和切片(split)的区别
Guo142326的博客
10-31 1498
先来说一说block(数据块)，HDFS存储数据在adtanode节点，而datanodo节点里是分为一个个block存数据的。大数据可能一个地方放不下，需要被拆开存放，并且拆开存放有利于数据的读取。HDFS文件系统默认block是文件存储最小单位(64MB或128MB)。HDFS支持文件“一次写入多次读取”，实际应用都是只写入数据一次但却读取一次或多次，并且读取速度应能满足流式读取的需要。 block也有如下优势： 1.支持大规模文件存储 2.简化系统设计 3.适合数据备份 4.集中的存储 ..
Hadoop中分片split的原理解析
jinYwuM的博客
08-06 4192
一、定义 1、block：block是物理切块，在文件上传到HDFS文件系统后，对大文将以每128MB的大小切分若干，存放在不同的DataNode上； 2、split：split是逻辑切片，在mapreduce中的map task开始之前，将文件按照指定的大小切割成若干个部分，每一部分称为一个split，默认是split的大小与block的大小相等，均为128MB。 注意：在hadoop1....
Hadoop源码解读(切片原理)
yujianxiaoyaobb的博客
11-21 619
Hadoop源码解读(切片原理) 在上一篇博客中。主要聊了聊一个hadoop的job在提交后，运行前所做的一些准备工作。主要是： 获取Job运行的环境是LocalJobRunner还是YarnRunner。 校验输出路径 获取Job的工作目录 获取当前将要运行的Job的Id 拼接上面两个，生成当前Job的工作目录，并创建 生成切片信息，返回切片的数量，并将切片信息放入Job工作目录中 将当前Jo...
hadoop 面试题大全
06-04
7. FileInputFormat的切片机制决定了数据如何分片处理。在Job提交流程中，waitForCompletion()方法会调用submit()，然后连接到JobTracker（YARN中的ResourceManager），初始化并提交Job。submitJobInternal()创建...
HadoopMapReduce-分区、排序、切片等.zip
最新发布
10-04
在大数据处理领域，Hadoop MapReduce 是一个关键的框架，用于处理和存储大规模数据集。...通过理解这些核心机制，并结合Java源代码，开发者能够更好地设计和优化MapReduce作业，从而充分利用Hadoop集群的计算能力。
hadoop0.20.2
04-05
总的来说，Hadoop 0.20.2虽然较新版本有所落后，但它的设计理念和实现机制对于理解分布式计算和大数据处理仍然具有很高的学习价值。对于想要深入了解Hadoop历史和原理的开发者来说，这是一个宝贵的资源。
Hadoop介绍
10-18
Map阶段将数据切片并分发到各个节点进行本地处理，Reduce阶段则负责聚合和整合Map阶段的结果。 **二、Hadoop的生态系统** Hadoop生态系统包括许多相关的开源项目，它们共同构成了大数据处理的完整解决方案： 1. *...
新版Hadoop视频教程 段海涛老师Hadoop八天完全攻克Hadoop视频教程 Hadoop开发
07-20
第五天 hadoop2.x中HA机制的原理和全分布式集群安装部署及维护 01-zookeeper.avi 02-zookeeper2.avi 03-NN高可用方案的要点1.avi 04-hadoop-HA机制的配置文件.avi 05-hadoop分布式集群HA模式部署.avi 06-hdfs...
Hadoop分块与分片介绍及分片和分块大小相同的原因
hellojoy的博客
06-05 951
概念介绍分块在HDFS系统中，为了便于文件的管理和备份，引入分块概念（block）。这里的 块 是HDFS存储系统当中的最小单位，HDFS默认定义一个块的大小为64MB。当有文件上传到HDFS上时，若文件大小大于设置的块大小，则该文件会被切分存储为多个块，多个块可以存放在不同的DataNode上，整个过程中 HDFS系统会保证一个块存储在一个datanode上 。但值得注意的是 如果某文件大小没有...
Hadoop HDFS中的数据块和Map任务的分片
weixin_34236497的博客
05-26 186
HDFS的数据块 磁盘数据块是磁盘进行数据读/写的最小单位，一般是512字节, 而HDFS中也有数据块，默认为64MB。所以HDFS上的大文件被分为许多个chunk.而HDFS上的小文件（小于64MB)的文件不会占据整个块的空间。 HDFS数据块设置大的原因是减少寻址开销，数据备份也是以块为单位的。 用hadoop fsck / -files -blocks 命令可以...
Hadoop hdfs切片计算方式
mthinking
03-27 2330
HDFS的block是逻辑上的数据块.Hadoop2.0中每一块默认大小128MB,实际存储过程中block大小小于等128MB,它是以文件为存储对象.如一200MB大小文件,分两个数据块128MB+72MB这里的两个块大实际小分别是128MB和72MB 算法分析: getFormatMinSplitSize() = 1 //最小切片值，默认为1 max(minSize, min(...
关于MapReduce中的切片机制
Pan_Mars的博客
03-27 3711
MapReduce的每一个Spilt都回提交给一个Job 最后都有一个Client 关于Spilt 将待处理数据执行逻辑切片（即按照一个特定切片大小，将待处理数据划分成逻辑上的多个split），然后每一个split分配一个mapTask并行实例处理 这段逻辑及形成的切片规划描述文件，由FileInputFormat实现类的getSplits()方法完成，切片定义在InputFormat类中的g
Hadoop FileInputFormat 默认切片机制
热门推荐
小杨的技术博客
04-07 2万+
默认的切片机制 简单地按照文件的内容长度进行切片 切片大小，默认等于 block 大小**(Local模式默认32M，集群模式默认128M)** 切片时不考虑数据集整体，而是逐个针对每一个文件单独切片 源码分析 Hadoop MapReduce Splits 切片源码分析及切片机制 计算切片大小 computeSplitSize 默认情况下，切片大小=blocksize protected...
Hadoop中的SequenceFile和MapFile
lavimer
02-02 4211
一：SequenceFile 1. SequenceFile概述 1.1.sequenceFile文件是Hadoop用来存储二进制形式的对而设计的一种平面文件(Flat File)。 1.2.可以把SequenceFile当做是一个容器，把所有的文件打包到SequenceFile类中可以高效的对小文件进行存储和处理。 1.3.SequenceFile文件并不按照其存储的Key进行排序存储，
简介hdfs中文件切块
weixin_47699191的博客
04-01 2520
hadoop hdfs 存储一个大文件,会切分成数据块128M一个. 是逻辑切块 比如文件278.16 MB 上传到hdfs中他就会被切块,Hadoop 2.x 默认128M为一个文件块 这是切分成了3个文件块block0 , block1, block2 block0的信息 block id, block pool id, size大小:134217728 单位为byte = 128M 而且有三个副本在 存在三个节点上 节点:wxt01 wxt02 wxt03 block1信息 也是128
HDFS的架构、优缺点、文件的切分和存放、secendryNameNode为什么不是备份
weixin_43681796的博客
03-31 508
1、HDFS架构包括什么？ HDFS（Hadoop Distribute FileSystem）分布式文件存储系统。它易于扩展的分布式文件系统，而且运行在大量廉价机器上，并且提供容错机制为大量用户提供性能不错的文件存取服务 NameNode -- NameNode主要功能： 1、接受客户端的读/写服务。 2、接受DN汇报的block位...
Hadoop源码分析之文件拆分
进击的数据小白
04-09 886
InputFormat介绍 当我们编写MapReduce程序的时候，都会进行输入格式的设置，方便hadoop可以根据设置得文件格式正确的读取数据进行处理，一般设置代码如下: job.setInputFormatClass(KeyVakueTextInputFormat.class) 通过上面的代码来保证输入的文件是按照我们想要的格式被读取，所有的输入格式都继承于InputFormat，这是一个抽...
hadoop切片机制和块不一一对应的原因是大量小文件场景map进行造成严重的资源浪费
06-13
是的，Hadoop的切片机制和块不一一对应的原因之一是在大量小文件的场景中，将小文件直接映射到Map任务上会导致严重的资源浪费。 在Hadoop中，文件被切分成多个块进行分布式存储和处理。每个块的大小可以通过配置文件进行设置，默认为128MB。在MapReduce任务中，每个切片对应一个Map任务，Map任务会读取该切片对应的块进行处理。 然而，如果有大量小文件，每个文件的大小都不足一个HDFS块的大小，那么就会导致很多小文件无法充分利用HDFS存储的块。此时，如果直接将每个小文件映射到一个Map任务上进行处理，就会造成严重的资源浪费，包括Map任务的启动、执行和关闭等过程中的开销，以及网络传输、磁盘I/O等方面的性能损失。 为了解决这个问题，Hadoop引入了CombineFileInputFormat机制，可以将多个小文件合并成一个切片进行处理，避免了大量小文件直接映射到Map任务上的资源浪费和性能损失。CombineFileInputFormat机制可以通过将多个小文件合并成一个虚拟切片，或者将多个虚拟切片合并成一个更大的虚拟切片，来实现更高效的数据读取和处理。 因此，在处理大量小文件的场景中，可以通过使用CombineFileInputFormat机制，或者将小文件合并成大文件，来避免Hadoop切片机制和块不一一对应的问题，提高数据处理的效率和性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值