Hadoop之倒排索引

前言：
　　從IT跨度到DT,如今的數據每天都在海量的增長。面對如此巨大的數據，如何能讓搜索引擎更好的工作呢？本文作為Hadoop系列的第二篇，將介紹分布式情況下搜索引擎的基礎實現，即“倒排索引”。

1.問題描述
　將所有不同文件里面的關鍵詞進行存儲，並實現快速檢索。下面假設有3個文件的數據如下：

file1.txt:MapReduce is simple
file2.txt:mapReduce is powerful is simple
file3.txt:Hello MapReduce bye MapReduce

　最終應生成如下索引結果:

Hello     file3.txt:1
MapReduce    file3.txt:2;file2.txt:1;file1.txt:1
bye     file3.txt:1
is     file2.txt:2;file1.txt:1
powerful    file2.txt:1
simple     file2.txt:1;file1.txt:1

--------------------------------------------------------

2.設計
　　首先，我們對讀入的數據利用Map操作進行預處理，如圖1：

對比之前的單詞計數（WorldCount.java），要實現倒排索引單靠Map和Reduce操作明顯無法完成，因此中間我們加入'Combine'，即合並操作；具體如圖2：

--------------------------------------------------------------

3.代碼實現

 

package pro;

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.IntWritable;
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;
import org.apache.hadoop.util.GenericOptionsParser;

public class InvertedIndex {
    final static String INPUT_PATH = "hdfs://hadoop0:9000/index_in";
    final static String OUTPUT_PATH = "hdfs://hadoop0:9000/index_out";

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

        private Text keyInfo = new Text(); // 存儲單詞和URL組合
        private Text valueInfo = new Text(); // 存儲詞頻
        private FileSplit split; // 存儲Split對象

        // 實現map函數
        public void map(Object key, Text value, Context context)
                throws IOException, InterruptedException {
            // 獲得<key,value>對所屬的FileSplit對象
            split = (FileSplit) context.getInputSplit();
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()) {

                // 只獲取文件的名稱。
                int splitIndex = split.getPath().toString().indexOf("file");
                keyInfo.set(itr.nextToken() + ":"
                        + split.getPath().toString().substring(splitIndex));
                // 詞頻初始化為1
                valueInfo.set("1");
                context.write(keyInfo, valueInfo);
            }
        }
    }

    public static class Combine extends Reducer<Text, Text, Text, Text> {
        private Text info = new Text();

        // 實現reduce函數
        public void reduce(Text key, Iterable<Text> values, Context context)
                throws IOException, InterruptedException {
            // 統計詞頻
            int sum = 0;
            for (Text value : values) {
                sum += Integer.parseInt(value.toString());
            }

            int splitIndex = key.toString().indexOf(":");
            // 重新設置value值由URL和詞頻組成
            info.set(key.toString().substring(splitIndex + 1) + ":" + sum);
            // 重新設置key值為單詞
            key.set(key.toString().substring(0, splitIndex));
            context.write(key, info);
        }
    }

    public static class Reduce extends Reducer<Text, Text, Text, Text> {
        private Text result = new Text();

        // 實現reduce函數
        public void reduce(Text key, Iterable<Text> values, Context context)
                throws IOException, InterruptedException {
            // 生成文檔列表
            String fileList = new String();
            for (Text value : values) {
                fileList += value.toString() + ";";
            }
            result.set(fileList);

            context.write(key, result);
        }
    }

    public static void main(String[] args) throws Exception {

        Configuration conf = new Configuration();

        Job job = new Job(conf, "Inverted Index");
        job.setJarByClass(InvertedIndex.class);

        // 設置Map、Combine和Reduce處理類
        job.setMapperClass(Map.class);
        job.setCombinerClass(Combine.class);
        job.setReducerClass(Reduce.class);

        // 設置Map輸出類型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);

        // 設置Reduce輸出類型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        // 設置輸入和輸出目錄
        FileInputFormat.addInputPath(job, new Path(INPUT_PATH));
        FileOutputFormat.setOutputPath(job, new Path(OUTPUT_PATH));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

 

4.測試結果

 

Hello        file3.txt:1;
MapReduce    file3.txt:2;file1.txt:1;file2.txt:1;
bye        file3.txt:1;
is        file1.txt:1;file2.txt:2;
powerful    file2.txt:1;
simple        file2.txt:1;file1.txt:1;

Reference:

[1]Hadoop權威指南【A】Tom Wbite

[2]深入雲計算·Hadoop應用開發實戰詳解【A】萬川梅 謝正蘭

--------------

結語：

　　從上面的Map---> Combine ----> Reduce操作過程中，我們可以體會到“倒排索引”的過程其實也就是不斷組合並拆分字符串的過程，而這也就是Hadoop中MapReduce並行計算的體現。在現今的大部分企業當中，Hadoop主要應用之一就是針對日志進行處理，所以想進軍大數據領域的朋友，對於Hadoop的Map/Reduce實現原理可以通過更多的實戰操作加深理解。本文僅僅只是牛刀小試，對於Hadoop的深層應用本人也正在慢慢摸索~~