[18 장 ● 무공 편] 일곱 번 째 장: MapReduce 의 역 렬 색인

위 키 백과 에서 말 했다.
역 배열 색인 (영어: Inverted index) 은 역방향 색인, 파일 삽입 또는 역방향 파일 이 라 고도 불 리 며 전체 텍스트 검색 에 저 장 된 한 단어 가 한 문서 나 한 문서 에 저 장 된 위 치 를 나타 내 는 색인 방법 입 니 다.그것 은 문서 검색 시스템 에서 가장 자주 사용 하 는 데이터 구조 이다.두 가지 서로 다른 역방향 색인 형식 이 있 습 니 다. 1. 기 록 된 수평 역방향 색인 (또는 역방향 파일 색인) 은 모든 단 어 를 참조 하 는 문서 의 목록 을 포함 합 니 다.2. 한 단어의 수평 역방향 색인 (또는 완전 역방향 색인) 은 각 단어 가 한 문서 에 있 는 위 치 를 포함한다.후자 의 형식 은 더 많은 호환성 (예 를 들 어 구문 검색) 을 제공 하지만 더 많은 시간 과 공간 이 필요 합 니 다.
역 배열 색인 은 데이터 세트 와 다른 데이터 세트 를 만 드 는 데 자주 사용 된다.다른 데이터 세트 에 대한 검색 능력 을 제공 하기 위해 데이터 세트 의 색인 을 만 드 는 것 이 목적 이다.
MapReduce 가 후진 색인 을 만 드 는 것 은 매우 간단 하 다. 왜냐하면 MapReduce 프레임 워 크 는 대부분의 업 무 를 처리 할 것 이기 때문이다.
역 색인 인 스 턴 스
키워드 검색 문 서 는 역 색인 애플 리 케 이 션 의 고전 이 라 고 할 수 있 습 니 다.아래 의 인 스 턴 스 는 텍스트 파일 에 어떤 단어 가 있 는 지 찾 고 모든 단어 가 어떤 파일 에 있 었 는 지 통계 하여 단어 와 파일 의 대응 관 계 를 구축 하여 키 워드 를 통 해 파일 을 빠르게 색인 할 수 있 도록 하 는 것 입 니 다.

package mapreduce.invertedindex;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.util.ToolRunner;

/**
 * Created by     on 2018/1/31.
 * hadoop jar  ~/chybin/orderdemo-1.0-SNAPSHOT.jar  mapreduce.invertedindex.InverteIndexMain hdfs://ClusterTest/chybin/index hdfs://ClusterTest/chybin/out/index/1 1
 */
public class InverteIndexMain {
    public static void main(String[] args) throws Exception {
        Configuration configuration = new Configuration();
        int status = ToolRunner.run(configuration, new InverteIndexMR(), args);
        System.exit(status);
    }
}

package mapreduce.invertedindex;

import com.huaban.analysis.jieba.JiebaSegmenter;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.SortedMapWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
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.hadoop.util.Tool;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * Created by     on 2018/1/31.
 */
public class InverteIndexMR extends Configured implements Tool {

    @Override
    public int run(String[] args) throws Exception {
        //    
        Configuration configuration = this.getConf();
        //  job
        Job job = Job.getInstance(configuration, InverteIndexMR.class.getSimpleName());
        //  MapReduce  
        job.setJarByClass(InverteIndexMR.class);
        //      
        FileInputFormat.addInputPath(job, new Path(args[0]));
        job.setMapperClass(InverteIndexMR.InverteIndexMapper.class);
        //      
        Path outpath = new Path(args[1]);
        FileOutputFormat.setOutputPath(job, outpath);
        //  Map    
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(SortedMapWritable.class);
        //  reducer 
        job.setReducerClass(InverteIndexMR.InverteIndexReducer.class);
        //      
        job.setOutputKeyClass(Text.class);
        //      
        job.setOutputValueClass(SortedMapWritable.class);
        //  reduce  
        job.setNumReduceTasks(Integer.valueOf(args[2]));
        //  Combiner
        job.setCombinerClass(InverteIndexReducer.class);
        //      
        job.addFileToClassPath(new Path("hdfs://ClusterTest/chybin/jar/jieba-analysis-1.0.2.jar"));
        boolean isSucces = job.waitForCompletion(true);
        return isSucces ? 0 : 1;
    }

    public static class InverteIndexMapper extends Mapper<Object, Text, Text, SortedMapWritable> {
        @Override
        protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            //        
            FileSplit fileSplit = (FileSplit) context.getInputSplit();
            final String fileName = fileSplit.getPath().getName();

            //    
            JiebaSegmenter segmenter = new JiebaSegmenter();
            List words = segmenter.sentenceProcess(value.toString());

            //        map  
            for (final String word : words) {
                SortedMapWritable map = new SortedMapWritable();
                map.put(new Text(fileName), new IntWritable(1));

                //map  ：key   ，value Map  ，Map                
                context.write(new Text(word), map);
            }
        }
    }

    public static class InverteIndexReducer extends Reducer<Text, SortedMapWritable, Text, SortedMapWritable> {
        @Override
        protected void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException {
            //        ，     ：        、     

            //     ，     outMap  
            SortedMapWritable outMap = new SortedMapWritable();
            for (SortedMapWritable map : values) {
                for (Map.Entry entry : map.entrySet()) {
                    if (outMap.get(entry.getKey()) == null) {
                        //          outMap           ，      
                        outMap.put(entry.getKey(), entry.getValue());
                    } else {
                        //          outMap           ，        
                        int count = ((IntWritable) outMap.get(entry.getKey())).get() + ((IntWritable) entry.getValue()).get();
                        outMap.put(entry.getKey(), new IntWritable(count));
                    }
                }
            }
            context.write(key, outMap);
        }
    }
}