大数据学习总结13

一、Hadoop-Mapreduce

1. MapReduce 介绍

MapReduce思想在生活中处处可见。或多或少都曾接触过这种思想。MapReduce的思想核心是“分而治之”，适用于大量复杂的任务处理场景（大规模数据处理场景）。

• Map负责“分”，即把复杂的任务分解为若干个“简单的任务”来并行处理。可以进行拆分的前提是这些小任务可以并行计算，彼此间几乎没有依赖关系。

• Reduce负责“合”，即对map阶段的结果进行全局汇总。

• MapReduce运行在yarn集群

  1. ResourceManager
  2. NodeManager

这两个阶段合起来正是MapReduce思想的体现。

2、MapReduce 设计构思

MapReduce是一个分布式运算程序的编程框架，核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在Hadoop集群上。MapReduce设计并提供了统一的计算框架，为程序员隐藏了绝大多数系统层面的处理细节。为程序员提供一个抽象和高层的编程接口和框架。程序员仅需要关心其应用层的具体计算问题，仅需编写少量的处理应用本身计算问题的程序代码。如何具体完成这个并行计算任务所相关的诸多系统层细节被隐藏起来,交给计算框架去处理：Map和Reduce为程序员提供了一个清晰的操作接口抽象描述。MapReduce中定义了如下的Map和Reduce两个抽象的编程接口，由用户去编程实现.Map和Reduce,MapReduce处理的数据类型是<key,value>键值对。
Map: (k1; v1) → [(k2; v2)]
Reduce: (k2; [v2]) → [(k3; v3)]
一个完整的mapreduce程序在分布式运行时有三类实例进程：
1. MRAppMaster 负责整个程序的过程调度及状态协调
2. MapTask 负责map阶段的整个数据处理流程
3. ReduceTask 负责reduce阶段的整个数据处理流程

 

 

 

3、 MapReduce 编程规范

MapReduce 的开发一共有八个步骤, 其中 Map 阶段分为 2 个步骤，Shuffle 阶段 4 个步骤，Reduce 阶段分为 2 个步骤

Map 阶段 2 个步骤

1. 设置 InputFormat 类, 将数据切分为 Key-Value (K1和V1) 对, 输入到第二步

2. 自定义 Map 逻辑, 将第一步的结果转换成另外的 Key-Value（K2和V2） 对, 输出结果

Shuffle 阶段 4 个步骤

3. 对输出的 Key-Value 对进行分区

4. 对不同分区的数据按照相同的 Key 排序

5. (可选) 对分组过的数据初步规约, 降低数据的网络拷贝

6. 对数据进行分组, 相同 Key 的 Value 放入一个集合中

Reduce 阶段 2 个步骤

7. 对多个 Map 任务的结果进行排序以及合并, 编写 Reduce 函数实现自己的逻辑, 对输入的 Key-Value 进行处理, 转为新的 Key-Value（K3和V3）输出

8. 设置 OutputFormat 处理并保存 Reduce 输出的 Key-Value 数据

 

 

 

4、案例WordCount

需求: 在一堆给定的文本文件中统计输出每一个单词出现的总次数

代码：

package mapperduce;

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

import java.io.IOException;

/**
 * @author MoooJL
 * @data 2020/8/26-14:48
 */

/*
四个泛型类解释
    KEYIN:K1的类型
    VALUEIN:v1的类型
    KEYOUT:K2的类型
    VALUEOUT:v2的类型
 */
public class WordCountMapper extends Mapper<LongWritable, Text,Text,LongWritable> {
    //map方法是将k1,v1转化为k2,v2
    /*
    key : k1 行偏移量
    value : v1 每一行的文本数据
    context : 上下文对象
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        Text text =new Text();
        LongWritable longWritable=new LongWritable();
        //1、将一行数据进行拆分\
        String[] split = value.toString().split(",");
        //2、遍历数组，组装k2 v2
        for (String word : split) {
            //3、将k2 v2 写入上下文
            text.set(word);
            longWritable.set(1);
            context.write(text,longWritable);
        }
    }
}

Mapper

package mapperduce;

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

import java.io.IOException;

/**
 * @author MoooJL
 * @data 2020/8/26-15:14
 */

/*
四个泛型类解释
    KEYIN:K2的类型
    VALUEIN:v2的类型
    KEYOUT:K3的类型
    VALUEOUT:v3的类型
 */
public class WordCountReducer extends Reducer<Text, LongWritable,Text,LongWritable> {
    //map方法是将k2,v2转化为k3,v3
    /*
    key : k2 行偏移量
    value : v2 每一行的文本数据
    context : 上下文对象
     */
    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        //1、遍历集合，将集合的数字相加得到v3
        long count =0;
        LongWritable longWritable=new LongWritable();
        for (LongWritable value : values) {
            count+=value.get();
        }
        //2、将k3  v3写入上下文
        longWritable.set(count);
        context.write(key,longWritable);
    }
}

Reducer

package mapperduce;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.net.URI;


/**
 * @author MoooJL
 * @data 2020/8/26-15:24
 */
public class jobMain extends Configured implements Tool {
    //该方法用于指定一个job任务
    @Override
    public int run(String[] args) throws Exception {
        //1、创建一个job对象
        Job job = Job.getInstance(super.getConf(), "wordcount");
        //2、配置job任务的8个对象
        //第一步 指定文件的读取方式和路径
        job.setInputFormatClass(TextInputFormat.class);
        /*
            如果打包运行出错 加配置
            job.setJarByClass(jobMain.class);
         */
        TextInputFormat.addInputPath(job,new Path("hdfs://node01:8020/wordcount"));
        //TextInputFormat.addInputPath(job,new Path("file:///D:\\mapreduce\\input"));
        //第二步 指定map阶段的处理方式和数据类型
        job.setMapperClass(WordCountMapper.class);
        //设置map阶段k2的类型
        job.setMapOutputKeyClass(Text.class);
        //设置map阶段v2的类型
        job.setMapOutputValueClass(LongWritable.class);
        //第三 四 五 六步 采用默认方式
        //第七步 指定reduce阶段的处理方式和数据类型
        job.setReducerClass(WordCountReducer.class);
        //设置k3  v3类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(LongWritable.class);
        //第八步 设置输出类型
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出路径
        Path path = new Path("hdfs://node01:8020/wordcount/wordcount_out");
        FileSystem fileSystem = FileSystem.get(new URI("hdfs://node01:8020"), new Configuration());
        //判断目录是否存在
        boolean exists = fileSystem.exists(path);
        if (exists){
            //删除目标目录
            fileSystem.delete(path,true);
        }
        //集群运行模式
        TextOutputFormat.setOutputPath(job,path);
        //本地运行模式
        //TextOutputFormat.setOutputPath(job,new Path("file:///D:\\mapreduce\\output"));
        //等待任务结束
        boolean b = job.waitForCompletion(true);
        return b ? 0:1;
    }

    public static void main(String[] args) throws Exception {
        Configuration configuration=new Configuration();
        //启动job任务
        int run = ToolRunner.run(configuration, new jobMain(), args);
        System.exit(run);
    }
}

job

MapReduce 程序是被提交给 LocalJobRunner 在本地以单进程的形式运行，处理的数据及输出结果可以在本地文件系统, 也可以在hdfs上

集群运行模式 ：将程序打包

1. 将 MapReduce 程序提交给 Yarn 集群, 分发到很多的节点上并发执行

2. 处理的数据和输出结果应该位于 HDFS 文件系统

3. 提交集群的实现步骤: 将程序打成JAR包，然后在集群的任意一个节点上用hadoop命令启动

 

 

 

 

本地运行模式：修改文件路径

TextInputFormat.addInputPath(job,newPath("file:///D:\\mapreduce\\input"));

TextOutputFormat.setOutputPath(job,new Path("file:///D:\\mapreduce\\output"));

 

 

 

5、MapReduce分区

在 MapReduce 中, 通过我们指定分区, 会将同一个分区的数据发送到同一个 Reduce 当中进行处理

例如: 为了数据的统计, 可以把一批类似的数据发送到同一个 Reduce 当中, 在同一个 Reduce 当中统计相同类型的数据, 就可以实现类似的数据分区和统计等

其实就是相同类型的数据, 有共性的数据, 送到一起去处理

Reduce 当中默认的分区只有一个

需求：将以下数据进行分开处理，其中第五个字段表示开奖结果数值，现在需求将15以上的结果以及15以下的结果进行分开成两个文件进行保存

分区步骤：

1. 定义 Mapper

这个 Mapper 程序不做任何逻辑, 也不对 Key-Value 做任何改变, 只是接收数据, 然后往下发送

package partition;

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;

/**
 * @author MoooJL
 * @data 2020/8/26-20:52
 */
/*
  K1: 行偏移量 LongWritable
  V1: 行文本数据  Text

  K2: 行文本数据 Text
  V2:  NullWritable
 */
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());
    }
}

Mapper

2、自定义 Partitioner

主要的逻辑就在这里, 这也是这个案例的意义, 通过 Partitioner 将数据分发给不同的 Reducer

package partition;

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

/**
 * @author MoooJL
 * @data 2020/8/26-20:56
 */
public class MyPartitioner extends Partitioner<Text, NullWritable> {
    @Override
    /*
    定义分区规则  返回对应的分区编号
     */
    public int getPartition(Text text, NullWritable nullWritable, int i) {
        String[] split = text.toString().split("\t");
        String numStr=split[5];
        if (Integer.parseInt(numStr)>15){
            return 1;
        }else{
            return 0;
        }
    }
}

Partitioner

3、定义 Reducer 逻辑

这个 Reducer 也不做任何处理, 将数据原封不动的输出即可

package partition;

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

import java.io.IOException;

/**
 * @author MoooJL
 * @data 2020/8/26-21:04
 */
/*
  K2:  Text
  V2:  NullWritable

  K3:  Text
  V3: NullWritable
 */
public class PartitionerReducer 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());
    }
}

Reducer

4. 主类中设置分区类和ReduceTask个数

package partition;

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;



/**
 * @author MoooJL
 * @data 2020/8/26-21:05
 */
public class JobMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        //创建job任务对象
        Job job = Job.getInstance(super.getConf(), "partition_maperduce");
        //配置job  8个步骤
        //1、设置输入类和输入路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("hdfs://node01:8020/input"));
        //2、设置Mapper类和数据类型
        job.setMapperClass(PartitionMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);
        //3、指定分区类
        job.setPartitionerClass(MyPartitioner.class);
        // 4 5 6
        //7、指定reducer类和数据类型
        job.setReducerClass(PartitionerReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);
        //设置ReduceTask的个数
        job.setNumReduceTasks(2);
        //8、指定输入类和输入路径
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path("hdfs://node01:8020/out/partition_out"));

        //结束
        boolean b = job.waitForCompletion(true);
        return b?0:1;
    }

    public static void main(String[] args) throws Exception {
        Configuration configuration=new Configuration();
        int run= ToolRunner.run(configuration,new JobMain(),args);
        System.exit(run);
    }
}

JobMain

集群运行模式结果：