夜深了我还没有休息，临近过春节了，可是加班还是那么的多，心累了，好想找个地方休息休息，放松下自己 、、、
可是路还要走，生活还要继续，洗把脸，我还要战斗，生活就那点事、、、

一、倒排索引

倒排索引，是一种为了提高搜索效率而创建的索引，是一种数据结构。在搜索索引中输入关键词，然后让搜索引擎取互联网采集包括关键词的信息网络列表返还给你，但是这个样会耗费比较长的时间，但是如果在查询之前，就知道关键词已经存在哪些网页中，这样的话那查询的效率会更加的快速。

在本文章中通过mapreduce实现倒排索引的：
数据例子如下：
Facebook is very good and very nice
Google is very good too
Tencent is very good too

所要实现的效果：
Facebook 第1行数据,索引位置0 :1;
Google 第2行数据,索引位置0 :1;
Tencent 第3行数据,索引位置0 :1;
and 第1行数据,索引位置4 :1;
good 第1行数据,索引位置3 :1;第2行数据,索引位置3 :1;第3行数据,索引位置3 :1;
is 第1行数据,索引位置1 :1;第2行数据,索引位置1 :1;第3行数据,索引位置1 :1;
nice 第1行数据,索引位置6 :1;
too 第2行数据,索引位置4 :1;第3行数据,索引位置4 :1;
very 第1行数据,索引位置2 :1;第1行数据,索引位置5 :1;第2行数据,索引位置2 :1;第3行数据,索引位置2 :1;

整个项目的结构如下：

InvertedIndexKeyValue : 存放map和reduce中间输出变量的函数（这里只实现了map的中间比变量）
InvertedIndexMain：整个项目的入口函数，实现配置map和reduce类的入口
InvertedIndexMapper：项目的map过程
InvertedIndexReducer：项目的reduce过程

项目目录结构.png

分开介绍各个函数的结构：

InvertedIndexKeyValue：主要是定义带有中文描述的数据结构，为map的中间结果使用，当然这里面也可以添加reduce的中间结果，依据需求添加；

package InvertedIndex;

public class InvertedIndexKeyValue {
    //切分单词，形成相应的倒排索引的模式数据
    private String keywords;  //定义map中间结果的key
    private String describe;  //定义map中间结果的 value
    public void setKeywords(String keywords) {
        this.keywords = keywords;
    }
    public void setDescribe(String describe) {
        this.describe = describe;
    }
    public String getKeywords() {
        return keywords;
    }
    public String getDescribe() {
        return describe;
    }
}

InvertedIndexMapper：实现map的过程，主要数统计文件中每一行的数据中单词出现的词频，形成<key,value>的键值对；其中key的构成带有两部分：单词+单词位于第几行中出现；

package InvertedIndex;

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.ObjectWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

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

public class InvertedIndexMapper {
    private static Text text= new Text();

    public static InvertedIndexKeyValue AnalysisKeyWord(String keyword,String i,String j){
        //分开英文单词的函数，以空格进行分词的操作
        InvertedIndexKeyValue invertedIndexKeyValue=new InvertedIndexKeyValue();
        invertedIndexKeyValue.setKeywords(keyword+":"+"第"+i+"行数据,索引位置"+j+" ");
        invertedIndexKeyValue.setDescribe("1");
        return invertedIndexKeyValue;
    }

    public static void delfile(Configuration conf, Path path) throws Exception{
        //每次重复执行之前对相应目录进行清除的操作，确保程序正常执行
        FileSystem fs =FileSystem.get(new URI(path.toString()),conf);
        Path fspath = path;
        if(fs.exists(fspath)){
            fs.delete(fspath,true);
        }
    }

    public static class MapIndex extends Mapper<LongWritable,Text,Text,Text>{
        //先执行计数的过程
        private Text valueof = new Text();
        private Text keyof = new Text();
        private int i=1;
        protected void map(LongWritable key, Text text, Context context) throws IOException, InterruptedException{
            StringTokenizer stringTokenizer = new StringTokenizer(text.toString());
            int index =0; //每个单词位于每一行的数据的索引位置
            while(stringTokenizer.hasMoreTokens()){
                //对每一行进行处理的过程
                InvertedIndexKeyValue invertedIndexKeyValue=InvertedIndexMapper.AnalysisKeyWord(stringTokenizer.nextToken(),String.valueOf(i),String.valueOf(index));
                keyof.set(invertedIndexKeyValue.getKeywords().toString());
                valueof.set(invertedIndexKeyValue.getDescribe().toString());
                context.write(keyof,valueof);
                index++;
            }
            i+=1;
        }
    }
}

InvertedIndexReducer：此函数由两部分构成，Combine和Reduce两个类构成，分别进行reduce的过程；

Combine处理的过程是：map的输出结果的部分，key的形式为：Facebook：第1行数据,索引位置0，而value的形式为1，combine的过程为拆分出“：”之前的单词进行reduce的过程统计值啊每一行上单词出现的词频；
Reduce处理的过程是：把Combine的处理结果按照单词相同和相关描述进行归类，把相关描述按照串联的情况写到一起

package InvertedIndex;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class InvertedIndexReducer {
    // 完成词频统计的工作
    public static class ReduceIndex extends Reducer<Text,Text,Text,Text>{
        private Text keyindex = new Text();
        private Text valueindex = new Text();
        protected void reduce(Text key,Iterable<Text> value,Context context) throws IOException,InterruptedException{
            StringBuilder stringBuilder = new StringBuilder();
            for (Text va :value){
                stringBuilder.append(va.toString()+";");
            }
            keyindex.set(key);
            valueindex.set(stringBuilder.toString());
            context.write(keyindex,valueindex);
        }
    }

    public static class Combine extends Reducer<Text,Text,Text,Text>{
        private Text keyinfo = new Text();
        private Text valueinfo = new Text();
        protected void reduce(Text key,Iterable<Text> value,Context context) throws IOException,InterruptedException{
            //开始统计词频的过程
            int sum = 0 ;
            for (Text text:value){
                sum += Integer.parseInt(text.toString()); //对value的值进行统计处理
            }
            //重新设计key和value的值，sum座位value的值，对key值进行拆分处理，一部分取出作为value的值进行处理
            int spiltindex = key.toString().indexOf(":");
            keyinfo.set(key.toString().substring(0,spiltindex));
            valueinfo.set(key.toString().substring(spiltindex+1)+":"+sum);
            context.write(keyinfo,valueinfo);
        }
    }
}

InvertedIndexMain：负责的相应的类的调用的过程

package InvertedIndex;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class InvertedIndexMain {
    //倒排索引的主函数
    public static void main(String[] args) throws Exception{
        Configuration conf = new Configuration();
        Path path1 = new Path("InvertedIndex/InvertedIndexFile");
        //Path path2 = new Path(args[1]);
        Path path2 = new Path("outputInvertedIndex");
        InvertedIndexMapper.delfile(conf,path2);
        Job job= Job.getInstance(conf,"InvertedIndex");

        FileInputFormat.setInputPaths(job,path1);
        FileOutputFormat.setOutputPath(job,path2);

        job.setJarByClass(InvertedIndexMain.class);

        job.setMapperClass(InvertedIndexMapper.MapIndex.class);
        job.setCombinerClass(InvertedIndexReducer.Combine.class);
        job.setReducerClass(InvertedIndexReducer.ReduceIndex.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        //map函数搞定
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.waitForCompletion(true);
    }
}

执行结果.png

PS：hadoop的本地环境的配置参考我上一篇文章！！！

加班过后，熬夜写了今天的学习内容，虽然累，但是觉得还是值得的，为自己加油！！！