Hadoop-Invert-Index

倒排索引是文档检索系统中最常见的数据结构，被广泛用于全文索引引擎。它主要是用来存储某个单词(或词组）在一个文档或一组文档那该的存储位置的映射，即提供了一种根据内容来查找文档的方式。由于不是根据文档来确定文档所包含的内容，而是进行了相反的操作（即根据关键字来查找文档），故称为倒排索引。

源码

import java.io.IOException;  
import java.util.StringTokenizer;  

import org.apache.hadoop.conf.Configuration;  
import org.apache.hadoop.fs.Path;  
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.output.FileOutputFormat;  

public class InversedIndex {  

    /** 
     * 将输入文件拆分， 
     * 将关键字和关键字所在的文件名作为map的key输出， 
     * 该组合的频率作为value输出 
     * */  

    public static class InversedIndexMapper extends Mapper<Object, Text, Text, Text> {  

        private Text outKey = new Text();  
        private Text outVal = new Text();  

        @Override  
        public void map (Object key,Text value,Context context) {  
            StringTokenizer tokens = new StringTokenizer(value.toString());  
            FileSplit split = (FileSplit) context.getInputSplit();  
            while(tokens.hasMoreTokens()) {  
                String token = tokens.nextToken();  
                try {  
                    outKey.set(token + ":" + split.getPath());  
                    outVal.set("1");  
                    context.write(outKey, outVal);  
                } catch (IOException e) {  
                    e.printStackTrace();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  

    /** 
     * map的输出进入到combiner阶段，此时来自同一个文件的相同关键字进行一次reduce处理， 
     * 将输入的key拆分成关键字和文件名，然后关键字作为输出key， 
     * 将文件名与词频拼接，作为输出value， 
     * 这样就形成了一个关键字，在某一文件中出现的频率的 key--value 对 
     * */  
    public static class InversedIndexCombiner extends Reducer<Text, Text, Text, Text> {  

        private Text outKey = new Text();  
        private Text outVal = new Text();  

        @Override  
        public void reduce(Text key,Iterable<Text> values,Context context) {  
            String[] keys = key.toString().split(":");  
            int sum = 0;  
            for(Text val : values) {  
                sum += Integer.parseInt(val.toString());  
            }  
            try {  
                outKey.set(keys[0]);  
                int index = keys[keys.length-1].lastIndexOf('/');  
                outVal.set(keys[keys.length-1].substring(index+1) + ":" + sum);  
                context.write(outKey, outVal);  
            } catch (IOException e) {  
                e.printStackTrace();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  

    }  

    /** 
     * 将combiner后的key value对进行reduce， 
     * 由于combiner之后，一个关键字可能对应了多个value，故需要将这些value进行合并输出 
     * */  

    public static class InversedIndexReducer extends Reducer<Text, Text, Text, Text> {  

        @Override  
        public void reduce (Text key,Iterable<Text> values,Context context) {  
            StringBuffer sb = new StringBuffer();  
            for(Text text : values) {  
                sb.append(text.toString() + " ,");  
            }  
            try {  
                context.write(key, new Text(sb.toString()));  
            } catch (IOException e) {  
                e.printStackTrace();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  

    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {  
        Configuration conf = new Configuration();  
        Job job = new Job(conf,"index inversed");  

        job.setJarByClass(InversedIndex.class);  
        job.setMapperClass(InversedIndexMapper.class);  
        job.setCombinerClass(InversedIndexCombiner.class);  
        job.setReducerClass(InversedIndexReducer.class);  
        job.setMapOutputKeyClass(Text.class);  
        job.setMapOutputValueClass(Text.class);  
        job.setOutputKeyClass(Text.class);  
        job.setOutputValueClass(Text.class);  

        job.setNumReduceTasks(3);  

        FileInputFormat.addInputPath(job, new Path("input"));  
        FileOutputFormat.setOutputPath(job, new Path("output"));  

        System.exit(job.waitForCompletion(true)?0:1);  

    }  

} 

Example

原文本文件

text1.txt
MapReduce is sample

text2.txt
MapReduce is powerful is sample

text3.txt
Hello MapReduce hello world

运行结果文件

Hello text3.txt:1
MapReduce text3.txt:1 text1.txt:1 , text2.txt:1
hello text2.txt:2 , text1.txt:1
powerful text2.txt:1 ,text1.txt:1
world text3.txt:1

过程分析

Map过程：
将输入文件关键字和关键字所在的文件名组合作为map的key输出，map的value为１
如 MapReduce这个关键字map后结果为：
< MapReduce:text1.tx1 ,1>
< MapReduce:text2.txt ,1>
< MapReduce:text3.txt ,1>

Combiner过程:
对Map过程中产生的key相同的做Reduce处理
如< hello:text3.txt , 1> < hello:text3.txt ,1 >合并成< hello　，text3.txt：2>

Reduce过程：

对于combiner过程中产生的具有相同的key的value进行合并输出，最终结果为运行结果文件

摘自Hadoop之道–MapReduce简单应用倒排索引(InvertedIndex)