MapReduce实例----倒排索引

讲这个例子之前，先来看一下setCombinerClass这个函数，MapReduce框架只要一个map函数和一个reduce函数即可，而我们在Job调用这两个函数所在的类之间往往会调用一次setCombinerClass函数，其参数和setReducerClass是一样的。实际上，这个setCombinerClass不是必须要调用的，视具体情况而定，可要可不要。那么调用setCombinerClass的作用何在呢？

在MapReduce中，当map生成的数据过大时，带宽就成了瓶颈，怎样精简压缩传给Reduce的数据，有不影响最终的结果呢。有一种方法就是使用Combiner，Combiner号称本地的Reduce，Reduce最终的输入，是Combiner的输出。以之前的WordCount统计单词出现次数为例，我们在map中将每个单词的词频初始化为1输出，这样reduce的输入每个key所对应的value将是一大串1，但如果处理的文本很多时，这一大串1已将占用很大的带宽，如果我们在map的输出给于reduce之前做一下合并或计算，那么传给reduce的数据就会少很多，减轻了网络压力。此时Combiner就排上用场了。我们现在本地把Map的输出做一个合并计算，把具有相同key的1做一个计算，比如这里是累加求和，这样就把一大串1转化成了一个数字，然后再把此输出作为reduce的输入，这样传给reduce的数据就少了很多。Combiner是用reducer来定义的，多数的情况下Combiner和reduce处理的是同一种逻辑，所以job.setCombinerClass()的参数可以直接使用定义的reduce，当然也可以单独去定义一个有别于reduce的Combiner，继承Reducer，写法基本上和定义reduce一样。下面这个倒排索引的例子就需要重新定义一个Combiner，来看一下：

1.实例描述：

"倒排索引"是文档检索系统中最常用的数据结构，被广泛地应用于全文搜索引擎。它主要是用来存储某个单词（或词组）在一个文档或一组文档中的存储位置的映射，即提供了一种根据内容来查找文档的方式。由于不是根据文档来确定文档所包含的内容，而是进行相反的操作，因而称为倒排索引（Inverted Index）。通常情况下，倒排索引由一个单词（或词组）以及相关的文档列表组成，文档列表中的文档或者是标识文档的ID号，或者是指文档所在位置的URL，如图所示：

可以看出，单词1出现在{文档1，文档4，文档13，……}中，单词2出现在{文档3，文档5，文档15，……}中，而单词3出现在{文档1，文档8，文档20，……}中。在实际应用中，还需要给每个文档添加一个权值，用来指出每个文档与搜索内容的相关度，如下图所示：

最常用的是使用词频作为权重，即记录单词在文档中出现的次数。以英文为例，如下图所示，索引文件中的"MapReduce"一行表示："MapReduce"这个单词在文本T0中出现过1次，T1中出现过1次，T2中出现过2次。当搜索条件为"MapReduce"、"is"、"Simple"时，对应的集合为：{T0，T1，T2}∩{T0，T1}∩{T0，T1}={T0，T1}，即文档T0和T1包含了所要索引的单词，而且只有T0是连续的。

更复杂的权重还可能要记录单词在多少个文档中出现过，以实现TF-IDF（Term Frequency-Inverse Document Frequency）算法，或者考虑单词在文档中的位置信息（单词是否出现在标题中，反映了单词在文档中的重要性）等。

2.源数据：

file1.txt:

MapReduce is simple

file2.txt:

MapReduce is powerful is simple

file3.txt:

Hello MapReduce bye MapReduce

3.代码如下：

package com.sy;

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 SuoYin {

 

    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()) {

                // key值由单词和URL组成，如"MapReduce：file1.txt"

                // 获取文件的完整路径

                // keyInfo.set(itr.nextToken()+":"+split.getPath().toString());

                // 这里为了好看，只获取文件的名称。

                int splitIndex = split.getPath().toString().indexOf("file");
               

                keyInfo.set(itr.nextToken() + ":"

                    + split.getPath().toString().substring(splitIndex));

                // 词频初始化为1
            

                valueInfo.set("1");

 

           //     System.out.println(keyInfo+"   "+valueInfo);
                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 {

 

          //  System.out.println(key);
        	// 统计词频

            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);
            //System.out.println(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 {

 

          // System.out.println(key);
        	// 生成文档列表

            String fileList = new String();

            for (Text value : values) {

                fileList += value.toString() + ";";

            }

 

            result.set(fileList);

 

            context.write(key, result);
            System.out.println(key+"    "+result);

        }

    }

 

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

        Configuration conf = new Configuration();

       
        String[] otherArgs = new GenericOptionsParser(conf, args)

                .getRemainingArgs();

        if (otherArgs.length != 2) {

            System.err.println("Usage: Inverted Index <in> <out>");

            System.exit(2);

        }

 

        Job job = new Job(conf, "Inverted Index");

        job.setJarByClass(SuoYin.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(otherArgs[0]));

        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));

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

    }

} 

运行程序输出如下：

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;

4.代码分析：

map函数整理每个文件每个单词的初始词频，map输出:

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

 Combine函数整理每个单词的url和词频，Combine输出：

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

reduce函数整理成目标输出形式。