hadoop大数据入门篇-hdfs（二）

最新推荐文章于 2024-09-15 10:32:33 发布

zlh114607851

最新推荐文章于 2024-09-15 10:32:33 发布

阅读量87

点赞数

文章标签： hadoop hdfs mapreduce

本文链接：https://blog.csdn.net/zlh114607851/article/details/108433496

版权

1.主题

  采用MapReduce框架实现wordCount功能

2.适用读者对象

  本文适用于hadoop大数据入门初学者

3.基础环境信息

软件	系统	haoop
版本	centos7	2.6.0-cdh5.14.4

4.问题描述

你有一个100TB的文件，存放着大量的单词，每行有多个单词，用逗号分隔，现在你需要计算每个单词的出现次数。

文件内容如下：

    helllo,world

    hdfs,world

    world,hdfs

    ......



以上问题如果用单机程序处理，代码复杂，性能低下！

5.解决方案

采用MapReduce模型计算框架



(1)代码处理数据流程图

在这里插入图片描述
（2）详细代码

package com.zhenglihan.cdh.hdfs;
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.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

/**
 * 功能描述：
 *   采用MapReduce框架实现wordCount功能
 *   输入：hdfs
 *   输出：hdfs
 *   args(0): /tmp/zhenglihan/cdhBigdata/hdfs/wordCount.txt
 *   args(1)：/tmp/zhenglihan/cdhBigdata/hdfs/mapredTmp
 */
public class MapreduceWordCountDemo {
    public static class TokenizerMapper
            extends Mapper<Object, Text, Text, IntWritable>{

        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();

        /**
         * map函数负责以“行”为单位处理文件
         * @param key：输入键(不重要）
         * @param value：输入值（真正要处理的文本数据）
         * @param context：存放输出键和输出值的应用上下文
         * @throws IOException
         * @throws InterruptedException
         */
        public void map(Object key, Text value, Context context
        ) throws IOException, InterruptedException {
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()) {
                word.set(itr.nextToken());
                //单词每出现一次发送一个键值对(word,1)
                context.write(word, one);
            }
        }
    }

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

        /**
         *  reduce函数会把map函数的处理结果中相同key值的（key,value)对收集到一起，上次（key,Iterable<IntWritable> values)
         * @param key：这里表示文本中的单词
         * @param values：value集合
         * @param context
         * @throws IOException
         * @throws InterruptedException
         */
        public void reduce(Text key, Iterable<IntWritable> values,
                           Context context
        ) throws IOException, InterruptedException {
            int sum = 0;
            //累加单词出现的次数
            for (IntWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
            context.write(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:  <in> [<in>...] <out>");
            System.exit(2);
        }
        Job job = Job.getInstance(conf, "word count");
        job.setJarByClass(MapreduceWordCountDemo.class);
        job.setMapperClass(TokenizerMapper.class);
        job.setCombinerClass(IntSumReducer.class);
        job.setReducerClass(IntSumReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        for (int i = 0; i < otherArgs.length - 1; ++i) {
            FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
        }
        FileOutputFormat.setOutputPath(job,
                new Path(otherArgs[otherArgs.length - 1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

}