输入的InputFormat----SequenceFileInputFormat

继承关系：SequenceFileInputFormat extends FileInputFormat implements InputFormat 。

SequenceFileInputFormat 代码如下（其实很简单）：

/**
* 覆盖了FileInputFormat的这个方法，FileInputFormat通过这个方法得到的FileStatus[]
* 长度就是将要运行的map的长度，每个FileStatus对应一个文件
*/
@Override
protected FileStatus[] listStatus(JobConf job) throws IOException {
FileStatus[] files = super.listStatus(job);
/*调用父类的listStatus方法，然后进行了自己的处理，将得到的FileStatus[]遍历一遍，
遇到文件夹时候，看其是否为MapFile，是的话去除其中也是SequenceFile的data文件，否则将文件夹过滤掉。
*/
for (int i = 0; i < files.length; i++) {
FileStatus file = files[i];
if (file.isDir()) {     // it's a MapFile
Path dataFile = new Path(file.getPath(), MapFile.DATA_FILE_NAME);
FileSystem fs = file.getPath().getFileSystem(job);
// use the data file
files[i] = fs.getFileStatus(dataFile);
}
}
return files;
}

下面看看FileInputFormat的listStatus(JobConf job)方法：

protected FileStatus[] listStatus(JobConf job) throws IOException {
//得到job配置中的所有输入路径，路径中是以 ,号隔开的 。
Path[] dirs = getInputPaths(job);
if (dirs.length == 0) {
throw new IOException("No input paths specified in job");
}

// get tokens for all the required FileSystems..
TokenCache.obtainTokensForNamenodes(job.getCredentials(), dirs, job);

List<FileStatus> result = new ArrayList<FileStatus>();
List<IOException> errors = new ArrayList<IOException>();

// creates a MultiPathFilter with the hiddenFileFilter and the
// user provided one (if any).
//处理一个过路文件的filter，可以将输入文件夹中的一些文件过滤掉
List<PathFilter> filters = new ArrayList<PathFilter>();
filters.add(hiddenFileFilter);
PathFilter jobFilter = getInputPathFilter(job);
if (jobFilter != null) {
filters.add(jobFilter);
}
PathFilter inputFilter = new MultiPathFilter(filters);
//对于每个输入文件夹进行遍历
for (Path p: dirs) {
FileSystem fs = p.getFileSystem(job);
//得到这个输入文件下下的所有文件(夹)
FileStatus[] matches = fs.globStatus(p, inputFilter);
if (matches == null) {
errors.add(new IOException("Input path does not exist: " + p));
} else if (matches.length == 0) {
errors.add(new IOException("Input Pattern " + p + " matches 0 files"));
} else {
//遍历输入问价夹下的每个文件(夹)
for (FileStatus globStat: matches) {
if (globStat.isDir()) {
//文件夹的话，将该文件夹下的所有文件和文件夹添加到结果中
//****注意此处没有再往下层遍历，而是将文件和文件夹都返回到结果中 。
for(FileStatus stat: fs.listStatus(globStat.getPath(),
inputFilter)) {
result.add(stat);
}
} else {
//文件的话直接添加到result中，其实没有任何判断该文件是否是输入需要的格式等等
result.add(globStat);
}
}
}
}

if (!errors.isEmpty()) {
throw new InvalidInputException(errors);
}
LOG.info("Total input paths to process : " + result.size());
return result.toArray(new FileStatus[result.size()]);
}

是以总结SequenceFileInputFormat中输出文件的规律（假设输入文件夹是/input ）：

1、输入文件夹中的文件 ，即满足：/input/***文件 。

2、输入文件夹中子文件夹中的文件 ，/input/***/***文件 。

3、输入文件夹中的子文件夹的子文件夹中的data文件 ，/input/***/***/data文件 ，该主要是针对MapFile的 。

得到一个个文件后，怎么将文件映射到InputSplit（有可能一个file映射1个InputSplit，也可能映射几个InputSplit），代码见下：

/** Splits files returned by {@link #listStatus(JobConf)} when
* they're too big.*/
@SuppressWarnings("deprecation")
public InputSplit[] getSplits(JobConf job, int numSplits)
throws IOException {
FileStatus[] files = listStatus(job);

// Save the number of input files in the job-conf
job.setLong(NUM_INPUT_FILES, files.length);
long totalSize = 0;                           // compute total size
for (FileStatus file: files) {                // check we have valid files
if (file.isDir()) {
throw new IOException("Not a file: "+ file.getPath());
}
totalSize += file.getLen();
}

long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits);
long minSize = Math.max(job.getLong("mapred.min.split.size", 1),
minSplitSize);

// generate splits
ArrayList<FileSplit> splits = new ArrayList<FileSplit>(numSplits);
NetworkTopology clusterMap = new NetworkTopology();
//对于每个文件该分割成多少InputSplit的处理
for (FileStatus file: files) {
Path path = file.getPath();
FileSystem fs = path.getFileSystem(job);
long length = file.getLen();
BlockLocation[] blkLocations = fs.getFileBlockLocations(file, 0, length);
//允许切割文件时候，即允许将一个file切割成多个InputSplit 。
if ((length != 0) && isSplitable(fs, path)) {
long blockSize = file.getBlockSize();
//分块的大小，一般是以快为单位，即会选择blockSize ，其实会将按照block来分块，这样比较合适
long splitSize = computeSplitSize(goalSize, minSize, blockSize);

long bytesRemaining = length;
//按照分割设置（每块大小），将文件从从offset=0 到offset=length 分割成 (length/splitSize+1) 个（其实也并不是这些个啦 ~ ~ ，最后一块的大小可以是splitSize*SPLIT_SLOP）
while (((double) bytesRemaining)/splitSize > SPLIT_SLOP) {
String[] splitHosts = getSplitHosts(blkLocations,
length-bytesRemaining, splitSize, clusterMap);
splits.add(new FileSplit(path, length-bytesRemaining, splitSize,
splitHosts));
bytesRemaining -= splitSize;
}
//返回splits
if (bytesRemaining != 0) {
splits.add(new FileSplit(path, length-bytesRemaining, bytesRemaining,
blkLocations[blkLocations.length-1].getHosts()));
}
} else if (length != 0) {
String[] splitHosts = getSplitHosts(blkLocations,0,length,clusterMap);
splits.add(new FileSplit(path, 0, length, splitHosts));
} else {
//Create empty hosts array for zero length files
splits.add(new FileSplit(path, 0, length, new String[0]));
}
}
LOG.debug("Total # of splits: " + splits.size());
return splits.toArray(new FileSplit[splits.size()]);
}

ok ，一切都完了 ，但是你看上面的代码可能会产生一个疑问：SequenceFile是存储的一个个的key-value值，这样分割文件的话，会不会破坏原有的数据结构，即 要是某一个key-value被分到了两个FileSplit肿么办 ？

见文章：http://www.cnblogs.com/serendipity/articles/2112613.html

个人感觉mapreduce的这个工具InputFormat比较乱，往往不看源代码，你永远也无法知道到底哪些文件被选上了 。