MapReduce天龙八部

最新推荐文章于 2024-03-23 14:22:34 发布

滚小滚

最新推荐文章于 2024-03-23 14:22:34 发布

阅读量615

点赞数

CC 4.0 BY-SA版权

分类专栏： MapReduce 文章标签： mapreduce

本文链接：https://blog.csdn.net/qq_25534101/article/details/114501375

MapReduce 专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了MapReduce的运作流程，包括Map阶段的解析、Shuffle阶段的分区与排序、Reduce阶段的处理以及程序的本地运行和集群运行模式。还提供了具体的代码示例，包括MapReduce程序的主类、Mapper、Reducer、分区和排序类的实现。此外，文中还提到了Combiner规约过程及其在优化数据传输中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

天龙八部：

map阶段：
第一步：读取文件，解析成key，value对，形成k1，v1；
第二步：接受k1，v1，自定义逻辑，转换成新的k2，v2，进行输出

shuffle阶段：
第三步：分区：
相同key的value值发送到同一个reduce中去，key合并，value形成一个集合
第四步：排序默认按照自字段顺序进行排序
第五步：规约
第六步：分组

reduce阶段
第七步：接受k2，v2 自定义reduce逻辑，转换成新的k3，v3进行输出
第八步：将k3，v3进行输出

注意：
上面八个任务都是单独的一个java类，
八个步骤完了以后，通过job任务组装mr程序，
进行任务的提交

最简单的MapReduce程序：

主类：


package MR;

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.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


public class MainCount extends Configured implements Tool {
    public static void main(String[] args) throws Exception {
        //这里执行完成后，得到一个int类型的返回值，表示我们的程序退出状态码
        //如果退出的是0，程序执行成功
        //这里设置configuration，相当于我们把父类的configuration设置值了
        int run = ToolRunner.run(new Configuration(), new MainCount(), args);
        System.exit(run);
    }
    /*
    必须实现run方法，这里面就是通过job对象来组装我们程序，组装八个类
     */
    @Override
    public int run(String[] strings) throws Exception {
        //第一步：读取文件，解析成key，value

        //获取一个job，job的作用主要是用来组装MapReduce各个阶段的任务
        //Job的getInstance方法需要两个参数，第一个是一个Configuration的实例，第二个是jobName，可以自己随便定义
        Job job = Job.getInstance(super.getConf(), "xxx");
        //把job和需要操作的文件所在的目录添加进来，注意此时增加的目录
        TextInputFormat.addInputPath(job,new Path("hdfs://hadoop11:8020/wordcount"));

        //打包到集群，必须添加如下配置，不添加的话会报错
        job.setJarByClass(MainCount.class);

        //指定job需要执行的任务的原始数据的类型
        job.setInputFormatClass(TextInputFormat.class);

        //第二步：自定义map类
        //指定map
        job.setMapperClass(WordCountMapper.class);
        //设置k2，v2的类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);


        //第七步：自定义reduce类
        //指定reduce
        job.setReducerClass(WordCountReducer.class);
        //设置k3.v3
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        //第八步：输出文件
        //指定路径
        TextOutputFormat.setOutputPath(job,new Path("hdfs://hadoop11:8020/wordcountoutput"));

        //设置job输出数据的类型
        job.setOutputFormatClass(TextOutputFormat.class);

        //提交任务到集群
        boolean b = job.waitForCompletion(true);
        //使用三元表达确认返回值
        return b?0:1;
    }
}

定义一个map类：

package MR;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;
//定义四个泛型
/*
k1--行偏移量
v1--行内容
k2--单词内容
v2--单词的次数
 */
public class WordCountMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
    /**
     *必须重写map方法，实现逻辑
     * @param key       LongWritable key--代表k1
     * @param value     Text value--代表v1
     * @param context   Context context--上下文对象，将数据往下发送
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

      //第一步：将行数据进行切分,用逗号进行分割
      String[] words = value.toString().split(",");
      //遍历切分的文字，通过write方法向下发送
      for(String word:words){
          context.write(new Text(word),new IntWritable(1));
      }
    }
}

定义一个reduce类

package MR;

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

import java.io.IOException;
//reduce的泛型参数代表k2，v2，k3，v3
public class WordCountReducer extends Reducer<Text, IntWritable,Text,IntWritable> {
    /**
     *和map类同理，必须重写reduce方法
     * @param key   Text key--k2
     * @param values  Iterable<IntWritable> values--是一个集合，v2的类型
     * @param context   承上启下，向下发送
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
       //sum用来统计values的个数
        int sum=0;
        for (IntWritable value:values){

       // ntWritable是一个对象，而如果想要用int参加计算，那么我们需要调用IntWritable对象的一个成员get()，这个函数返回int.
        sum+=value.get();
    }
        context.write(key,new IntWritable(sum));
    }
}

MapReduce程序运行模式

本地运行模式

（1）mapreduce程序是被提交给LocalJobRunner在本地以单进程的形式运行
（2）而处理的数据及输出结果可以在本地文件系统，也可以在hdfs上
（3）怎样实现本地运行？写一个程序，不要带集群的配置文件
本质是程序的conf中是否有mapreduce.framework.name=local以及yarn.resourcemanager.hostname=local参数
（4）本地模式非常便于进行业务逻辑的debug，只要在eclipse中打断点即可

本地模式运行代码设置
configuration.set(“mapreduce.framework.name”,“local”);
configuration.set(“yarn.resourcemanager.hostname”,“local”);
TextInputFormat.addInputPath(job,new Path(“file:///F:\传智播客大数据离线阶段课程资料\3、大数据离线第三天\wordcount\input”));
TextOutputFormat.setOutputPath(job,new Path(“file:///F:\传智播客大数据离线阶段课程资料\3、大数据离线第三天\wordcount\output”));

集群运行

程序运行，将项目打包，发送至hadop集群上执行

hadoop jar original-day03_hdfs-1.0-SNAPSHOT.jar.0 MR.MainCount

MapReduce分区和排序

分区的思路：

第一步：读取文件，形成k1–Longwritab，v1–text
第二步：自定义map接收k1，v1 转换成k2–text，v2–LongWritable
第三步：自定义一个分区类：
使用getPartition（）方法
对k2进行分割，得到一个数组，使用数组下标得到一个result值
使用result值作为分区依据
>result 返回分区号
<result 返回分区号

第四步：自定义reduce类接受k2，v2 直接写出去即可，转换成k3–text，v3–Nullwritab直接输出

简单的案例：

主类：

package mr.demo1;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class PartitionMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {

        Job job = Job.getInstance(super.getConf(), "mypartiton");
        job.setJarByClass(PartitionMain.class);

        TextInputFormat.addInputPath(job,new Path(args[0]));

        job.setInputFormatClass(TextInputFormat.class);

        job.setMapperClass(PartitionMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);

        //第三步
        job.setPartitionerClass(PartitonOwn.class);
       job.setReducerClass(PartitionReduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        //设置redeuce的数量，不设置不行
        //reduce的个数和分区数相同
        job.setNumReduceTasks(2);

        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path(args[1]));

        boolean b = job.waitForCompletion(true);


        return b?0:1;
    }
    public static void main(String[] args) throws Exception {
        int run = ToolRunner.run(new Configuration(), new PartitionMain(), args);
        System.exit(run);
    }

}

mapper类

package mr.demo1;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class PartitionMapper extends Mapper<LongWritable, Text,Text, NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        context.write(value,NullWritable.get());
    }
}

reduce类：

package mr.demo1;

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

import java.io.IOException;

public class PartitionReduce extends Reducer<Text, NullWritable,Text,NullWritable> {
    @Override
    protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        context.write(key,NullWritable.get());
    }
}

分区类：

package mr.demo1;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

public class PartitonOwn extends Partitioner<Text, NullWritable> {

    @Override
    public int getPartition(Text text, NullWritable nullWritable, int numReduceNum) {
        String line = text.toString();

        String[] split = line.split("\t");

        if(Integer.parseInt(split[5])>15){
            return 0;
        }else {
            return 1;
        }
    }
    }

排序的思路：

第一步：读取文件，解析成k1–LongWritable，v1–text
第二步：自定义javaBean，实现WritableComparable，接受k1，v1
转换成k2–JavaBean，v2–Nullwritable
第三步：接受k2，v2不做处理，直接输出

主类：

package mrSort.demo1;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
    public class SortMain extends Configured implements Tool {

    @Override
    public int run(String[] strings) throws Exception {
        Job job = Job.getInstance(super.getConf(), "sort");
        //解析文件
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("file:///E:\\baishi\\测试目录\\input\\sort.txt"));

        //自定义map逻辑
        job.setMapperClass(SortMapper.class);
        job.setMapOutputKeyClass(k2Bean.class);
        job.setMapOutputValueClass(NullWritable.class);

        //自定义reduce
        job.setReducerClass(SortReduce.class);
        job.setOutputKeyClass(k2Bean.class);
        job.setOutputValueClass(NullWritable.class);
        job.setOutputValueClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path("file:///E:\\baishi\\测试目录\\output04"));

        boolean b = job.waitForCompletion(true);

        return b?0:1;
    }
    public static void main(String[] args) throws Exception {

        Configuration configuration=new Configuration();

        System.exit(ToolRunner.run(configuration,new SortMain(),args));
    }

}

k2bean排序类：

package mrSort.demo1;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class k2Bean implements WritableComparable<k2Bean>{
    /*
    封装两个字段
     */
    private  String first;
    private Integer second;
    /*
    用于数据的比较排序
     */
    @Override
    public int compareTo(k2Bean o) {
        /*
        int a=compareto(b);
        如果a>b  返回1；
        如果a=b，返回0；
        如果a<b,返回-1；

        所以比较两个字段比较的话，只能用大于0，等于0，小于0表示
         */
        //当前的值和传进来的o进行比较
        //如果第一个字段相同，就比较第二个字段
        //如果第二个字段相同，就直接返回结果

        int i = this.first.compareTo(o.first);
        if(i ==0){
            //比较第二个字段
            int i1 = second.compareTo(o.second);
            return i1;
        }else {
            return i;
        }
    }


    /*
    序列化
     */
    @Override
    public void write(DataOutput dataOutput) throws IOException {
    dataOutput.writeUTF(first);
    dataOutput.writeInt(second);
    }
    /*
    反序列化
     */
    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.first=dataInput.readUTF();
        this.second=dataInput.readInt();

    }

    public String getFirst() {
        return first;
    }

    public void setFirst(String first) {
        this.first = first;
    }

    public Integer getSecond() {
        return second;
    }

    public void setSecond(Integer second) {
        this.second = second;
    }

    @Override
    public String toString() {
        return first +"\t"+second;
    }
}

mapper类

package mrSort.demo1;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Counter;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class SortMapper extends Mapper<LongWritable, Text,k2Bean, NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

        //自定义计数器，计数map阶段输入多少条数据
        Counter counter = context.getCounter("mr_intput_count", "map_total_result");
        counter.increment(1L);

        String[] split = value.toString().split("\t");
        k2Bean k2Bean = new k2Bean();

        k2Bean.setFirst(split[0]);
        k2Bean.setSecond(Integer.parseInt(split[1]));
        context.write(k2Bean,NullWritable.get());

    }
}

reduce类

package mrSort.demo1;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Counter;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class SortReduce extends Reducer<k2Bean, NullWritable,k2Bean,NullWritable> {
    
    //定义一个类
    public static  enum Counter{
        REDUCE_INPUT_RECORD,
        REDUCE_OUTPUT_RECORD,
    }
    
    @Override
    protected void reduce(k2Bean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {

        //定义计数器，计数reduce输出条数
        org.apache.hadoop.mapreduce.Counter counter = context.getCounter(Counter.REDUCE_INPUT_RECORD);
        counter.increment(1L);
        
        for (NullWritable value:values) {

            org.apache.hadoop.mapreduce.Counter counter1 = context.getCounter(Counter.REDUCE_OUTPUT_RECORD);
            counter1.increment(1L);
            //将排序后的数据进行输出
            context.write(key, NullWritable.get());
        }
    }
}

规约的过程

发生在reduce阶段，接收k2，v2
combiner不改变数据结果，只用于调优，减少发送到reduce的数据量

思路：
第一步：读取文件，解析k1–LongWritable，v1-text
第二步：自定义javabean，转换成k2–javabean，v2–Nullwritab，输出
第三步：自定义一个Combiner规约类，接受k2，v2 ，直接输出
注释：因为combine类和reduce类一直，所以一般直接调用reduce类
job.setCombinerClass(SortReduce.class);
第四步：自定义reduce类直接输出