一、简介
"倒排索引"是文档检索系统中最常用的数据结构，被广泛地应用于全文搜索引擎。它主要是用来存储某个单词（或词组）在一个文档或一组文档中的存储位置的映射，即提供了一种根据内容来查找文档的方式。由于不是根据文档来确定文档所包含的内容，而是进行相反的操作，因而称为倒排索引（Inverted Index）。
二、例子
（1）实例描述
通常情况下，倒排索引由一个单词（或词组）以及相关的文档列表组成，文档列表中的文档或者是标识文档的ID号，或者是指文档所在位置的URL
在实际应用中，还需要给每个文档添加一个权值，用来指出每个文档与搜索内容的相关度
样例输入：
1）file1：
MapReduce is simple
2）file2：
MapReduce is powerful is simple
3）file3：
Hello MapReduce bye MapReduce
期望输出：
MapReduce file1.txt:1;file2.txt:1;file3.txt:2;
is file1.txt:1;file2.txt:2;
simple file1.txt:1;file2.txt:1;
powerful file2.txt:1;
Hello file3.txt:1;
bye file3.txt:1;
（2）问题分析
实现"倒排索引"只要关注的信息为：单词、文档URL及词频。但是在实现过程中，索引文件的格式会略有所不同，以避免重写OutPutFormat类
（3）实现步骤
1）Map过程
首先使用默认的TextInputFormat类对输入文件进行处理，得到文本中每行的偏移量及其内容。显然，Map过程首先必须分析输入的<key,value>对，得到倒排索引中需要的三个信息：单词、文档URL和词频
存在两个问题：
第一，<key,value>对只能有两个值，在不使用Hadoop自定义数据类型的情况下，需要根据情况将其中两个值合并成一个值，作为key或value值；
第二，通过一个Reduce过程无法同时完成词频统计和生成文档列表，所以必须增加一个Combine过程完成词频统计。
单词和URL组成key值（如"MapReduce：file1.txt"），将词频作为value，这样做的好处是可以利用MapReduce框架自带的Map端排序，将同一文档的相同单词的词频组成列表，传递给Combine过程，实现类似于WordCount的功能。
2）Combine过程
经过map方法处理后，Combine过程将key值相同的value值累加，得到一个单词在文档在文档中的词频，如果直接将图所示的输出作为Reduce过程的输入，在Shuffle过程时将面临一个问题：所有具有相同单词的记录（由单词、URL和词频组成）应该交由同一个Reducer处理，但当前的key值无法保证这一点，所以必须修改key值和value值。
这次将单词作为key值，URL和词频组成value值（如"file1.txt：1"）。可以利用MapReduce框架默认的HashPartitioner类完成Shuffle过程，将相同单词的所有记录发送给同一个Reducer进行处理
3）Reduce过程
经过上述两个过程后，Reduce过程只需将相同key值的value值组合成倒排索引文件所需的格式即可，剩下的事情就可以直接交给MapReduce框架进行处理了
4）需要解决的问题
本倒排索引在文件数目上没有限制，但是单词文件不宜过大（具体值与默认HDFS块大小及相关配置有关），要保证每个文件对应一个split。否则，由于Reduce过程没有进一步统计词频，最终结果可能会出现词频未统计完全的单词。可以通过重写InputFormat类将每个文件为一个split，避免上述情况。或者执行两次MapReduce，第一次MapReduce用于统计词频，第二次MapReduce用于生成倒排索引。除此之外，还可以利用复合键值对等实现包含更多信息的倒排索引。
（4）关键代码
package com.mk.mapreduce;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
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.output.FileOutputFormat;
import org.apache.jute.Index;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.net.URI;
import java.util.*;
import java.util.stream.Collectors;
public class InvertedIndex {
public static class InvertedIndexMapper extends Mapper<LongWritable, Text, Text, Text> {
private final Text newKey = new Text();
private final Text newValue = new Text("1");
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
if (StringUtils.isBlank(value.toString())) {
System.out.println("空白行");
return;
}
StringTokenizer tokenizer = new StringTokenizer(value.toString());
FileSplit fileInputSplit = (FileSplit) context.getInputSplit();
String fileName = fileInputSplit.getPath().getName();
while (tokenizer.hasMoreTokens()) {
String word = tokenizer.nextToken();
newKey.set(word + "\u0001" + fileName);
context.write(newKey, newValue);
}
}
}
public static class InvertedIndexCombiner extends Reducer<Text, Text, Text, Text> {
private final Text newKey = new Text();
private final Text newValue = new Text();
@Override
protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
String[] keys = key.toString().split("\u0001");
List<String> list = new LinkedList<>();
values.forEach(v -> list.add(v.toString()));
int count = list.stream().map(Integer::valueOf).reduce(0, (s, a) -> s + a);
newKey.set(keys[0]);
newValue.set(keys[1] + "\u0001" + count);
context.write(newKey, newValue);
}
}
public static class InvertedIndexReducer extends Reducer<Text, Text, Text, Text> {
private final Text newValue = new Text();
@Override
protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
Map<String, Integer> map = new HashMap<>();
for (Text v : values) {
String[] value = v.toString().split("\u0001");
Integer count = map.get(value[0]);
if (Objects.isNull(count)) {
count = Integer.parseInt(value[1]);
} else {
count = count + Integer.parseInt(value[1]);
}
map.put(value[0], count);
}
String info = map.entrySet().stream()
.sorted((a, b) -> {
int c = a.getValue() - b.getValue();
if (c != 0)
return c;
return a.getKey().compareTo(b.getKey());
})
.reduce(new StringBuilder(), (StringBuilder s, Map.Entry<String, Integer> v) -> {
s.append(v.getKey()).append(" ").append(v.getValue()).append(";");
return s;
}, StringBuilder::append).toString();
newValue.set(info);
context.write(key, newValue);
}
}
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
String uri = "hdfs://192.168.150.128:9000";
String input = "/invertedIndex/input";
String output = "/invertedIndex/output";
Configuration conf = new Configuration();
if (System.getProperty("os.name").toLowerCase().contains("win"))
conf.set("mapreduce.app-submission.cross-platform", "true");
FileSystem fileSystem = FileSystem.get(URI.create(uri), conf);
Path path = new Path(output);
fileSystem.delete(path, true);
Job job = new Job(conf, "InvertedIndex");
job.setJar("./out/artifacts/hadoop_test_jar/hadoop-test.jar");
job.setJarByClass(InvertedIndex.class);
job.setMapperClass(InvertedIndexMapper.class);
job.setCombinerClass(InvertedIndexCombiner.class);
job.setReducerClass(InvertedIndexReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
FileInputFormat.addInputPaths(job, uri + input);
FileOutputFormat.setOutputPath(job, new Path(uri + output));
boolean ret = job.waitForCompletion(true);
System.out.println(job.getJobName() + "-----" + ret);
}
}
