05_MapReduce编程二

最新推荐文章于 2023-08-17 18:42:10 发布
最新推荐文章于 2023-08-17 18:42:10 发布
阅读量422 收藏
点赞数
分类专栏： Hadoop生态框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TU_JCN/article/details/102600805
版权

 

目录

一、MR编程—自定义分区—词频统计（重点 ）

1.1、分区原理

1.2 默认分区

1.3、MR—自定义分区

1.3.1 需求

1.3.2 分析

1.3.3 MR代码

1、自定义分区器

2、main ，(map/reduce与以前一样)

3、完整代码 

二、 MR编程—自定义Combiner（重点 ）

2.1 需求

2.2、分析

2.3 MR代码

三、 MR编程—MR压缩

3.1、需求

3.2、分析

3.3 MR代码

1、main 

2、完整代码

四、MR编程—自定义InputFormat—处理小文件（重点+难点 ）

4.1 MapReduce执行过程

4.2 需求

4.3 分析

1、自定义InputFormat 类

2、自定义RecordReader类

3、main

4、完整代码

 

一、MR编程—自定义分区—词频统计（重点 ）

  •  如果默认分区器不满足业务需求，可以自定义分区器

    • 自定义分区器的类继承Partitioner类

    • 覆写getPartition()，在方法中，定义自己的分区策略

    • 在main()方法中调用job.setPartitionerClass()

    • main()中设置reduce任务数

1.1、分区原理

  • 在map任务中，从环形缓冲区溢出写磁盘时，会先对kv对数据进行分区操作

  • 分区操作是由MR中的分区器负责的

  • MapReduce有自带的默认分区器 HashPartitioner

    • 关键方法getPartition返回当前键值对的分区索引(partition index

  • public class HashPartitioner<K2, V2> implements Partitioner<K2, V2> {

  public void configure(JobConf job) {}

  /** Use {@link Object#hashCode()} to partition. */
  public int getPartition(K2 key, V2 value, int numReduceTasks) {
    return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
  }
}

    代码说明：

    • （1）环形缓冲区溢出写磁盘前，将每个kv对，作为getPartition()的参数传入；

    • （2）先对键值对中的key求hash值（int类型），与MAX_VALUE按位与；再模上reduce task个数。

    • 假设reduce task个数设置为4（可在程序中使用job.setNumReduceTasks(4)指定reduce task个数为4）

    • 那么map任务溢出文件有4个分区，分区index分别是0、1、2、3

    • getPartition()结果有四种：0、1、2、3

    • 根据计算结果，决定当前kv对，落入哪个分区，如结果是0，则当前kv对落入溢出文件的0分区中

    • 最终被相应的reduce task通过http获得

若是MR默认分区器，不满足需求；可根据业务逻辑，设计自定义分区器，比如实现图上的功能

 

1.2 默认分区

  • MR读取三个文件part1.txt、part2.txt、part3.txt；三个文件放到HDFS目录：/customParttitioner中

- part1.txt内容如下：

  ```
  Dear Bear River
  Dear Car
  ```

- part2.txt内容如下：

  ```
  Car Car River
  Dear Bear
  ```

- part3.txt内容如下：

  ```
  Dear Car Bear
  Car Car
  ``

- 默认HashPartitioner分区时，查看结果（看代码）

  • 运行参数： /customParttitioner /cp01

  • 打jar包运行，结果如下：

只有part-r-00001、part-r-00003有数据；另外两个没有数据

HashPartitioner将Bear分到index=1的分区；将Car|Dear|River分到index=3分区

1.3、MR—自定义分区

  • 使用combine时，首先考虑当前MR是否适合combine

  • 总原则是不论使不使用combine不能影响最终的结果

  • 在MR时，发生数据倾斜，且可以使用combine时，可以使用combine缓解数据倾斜

1.3.1 需求

  • 自定义分区，使得文件中，分别以Dear、Bear、River、Car为键的键值对，分别落到index是0、1、2、3的分区中

1.3.2 分析

  • 若要实现以上的分区策略，需要自定义分区类

    • 此类实现Partitioner接口

    • 在getPartition()中实现分区逻辑

  • main方法中

    • 设定reduce个数为4

    • 设置自定义的分区类，调用job.setPartitionerClass方法

1.3.3 MR代码

1、自定义分区器

2、main ，(map/reduce与以前一样)

3、完整代码 

package com.kaikeba.hadoop.partitioner;

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

import java.util.HashMap;

public class CustomPartitioner extends Partitioner<Text, IntWritable> {
    public static HashMap<String, Integer> dict = new HashMap<String, Integer>();

    //定义每个键对应的分区index，使用map数据结构完成
    static{
        dict.put("Dear", 0);
        dict.put("Bear", 1);
        dict.put("River", 2);
        dict.put("Car", 3);
    }

    public int getPartition(Text text, IntWritable intWritable, int i) {
        //
        int partitionIndex = dict.get(text.toString());
        return partitionIndex;
    }
}

 

package com.kaikeba.hadoop.mapreduce.partitioner;

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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;


/**
 *
 * 在单词计数的例子的基础上，增加自定义分区的功能
 */
public class WordCountMain {
    public static void main(String[] args) throws IOException,
            ClassNotFoundException, InterruptedException {
        if (args.length != 2 || args == null) {
            System.out.println("please input Path!");
            System.exit(0); }
        // 1、配置
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration, WordCountMain.class.getSimpleName());
        job.setJarByClass(WordCountMain.class);
        //  2、设置输入/输出路径
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        // 3、设置处理Map/Reduce阶段的类
        job.setMapperClass(WordCountMap.class);
        //job.setCombinerClass(WordCountReduce.class);//自定义combine类，还是用的是reduce
        job.setReducerClass(WordCountReduce.class);
        // 4、设置输出kv
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        //  5、======使用自定义的分区类进行分区
        job.setPartitionerClass(CustomPartitioner.class);
        //  6、=====设置reduce任务数为4======
        job.setNumReduceTasks(4);

        //  7、提交作业
        job.waitForCompletion(true);

    }
}

 

 

二、 MR编程—自定义Combiner（重点 ）

2.1 需求

  • （1）现状：普通的MR是reduce通过http，取得map任务的分区结果；具体的聚合出结果是在reduce端进行的；

    • 以单词计数为例：

      • 下图中的第一个map任务(map1)，本地磁盘中的结果有5个键值对：(Dear, 1)、(Bear, 1)、(River, 1)、(Dear, 1)、(Car, 1)

      • 其中，map1中的两个相同的键值对(Dear, 1)、(Dear, 1)，会被第一个reduce任务(reduce1)通过网络拉取到reduce1端

  • （2）存在问题：

    • 那么假设map1中(Dear, 1)有1亿个呢？

    • 按原思路，map1端需要存储1亿个(Dear, 1)，再将1亿个(Dear, 1)通过网络被reduce1获得，然后再在reduce1端汇总，

    • 我们称之为combine操作，答案是可以的

  • （3）解决方法：

    • 那么想，能不能在reduce1从map1拉取1亿个(Dear, 1)之前，在map端就提前先做下reduce汇总，得到结果(Dear, 100000000)，
    • 然后再将这个结果（一个键值对）传输到reduce1呢？
    • 这样做map端本地磁盘IO、数据从map端到reduce端传输的网络IO比较大
    • map端combine本地聚合（本质是reduce）

  • （4）注意：

    • 不论运行多少次Combine操作，都不能影响最终的结果

    • 并非所有的mr都适合combine操作，比如求平均值

2.2、分析

  • 当每个map任务的环形缓冲区添满80%，开始溢写磁盘文件

  • 此过程中，会分区、每个分区内按键排序、再combine操作（若设置了combine的话）、若设置map输出压缩的话则再压缩

    • 在合并溢写文件时，如果至少有3个溢写文件，并且设置了map端combine的话，会在合并的过程中触发combine操作；

    • 但是若只有2个或1个溢写文件，则不触发combine操作（因为combine操作，本质上是一个reduce，需要启动JVM虚拟机，有一定的开销）

  • combine本质上也是reduce；因为自定义的combine类继承自Reducer父类

    • map: (K1, V1) -> list(K2, V2)

    • combiner: (K2, list(V2)) -> (K2, V2)

    • reduce: (K2, list(V2)) -> (K3, V3)

  • reduce函数与combine函数通常是一样的

    • 即reduce的输入的kv类型分别与输出的kv类型相同

    • V3与V2类型相同 ；K3与K2类型相同；

2.3 MR代码

对原词频统计代码做修改；详细代码见代码工程

（1）WordCountMap、WordCountReduce代码保持不变

（2）唯一需要做的修改是在WordCountMain中，增加job.setCombinerClass(WordCountReduce.class);

  • 修改如下：

三、 MR编程—MR压缩

  • MR过程中使用压缩可减少数据量，进而减少磁盘IO、网络IO数据量

  • 可设置map端输出的压缩

  • 可设置job最终结果的压缩

  • 通过相应的配置项即可实现

3.1、需求

  • 作用：在MR中，为了减少磁盘IO及网络IO，可考虑在map端、reduce端设置压缩功能

  • 给“MapReduce编程：用户搜索次数”代码，增加压缩功能

3.2、分析

只需在main方法中，给Configuration对象增加如下设置即可

//开启map输出进行压缩的功能
configuration.set("mapreduce.map.output.compress", "true");

//设置map输出的压缩算法是：BZip2Codec，它是hadoop默认支持的压缩算法，且支持切分
configuration.set("mapreduce.map.output.compress.codec", "org.apache.hadoop.io.compress.BZip2Codec");

//开启job输出压缩功能
configuration.set("mapreduce.output.fileoutputformat.compress", "true");

//指定job输出使用的压缩算法
configuration.set("mapreduce.output.fileoutputformat.compress.codec", "org.apache.hadoop.io.compress.BZip2Codec");

3.3 MR代码

给“MapReduce编程：用户搜索次数”代码，增加压缩功能，代码如下：

1、main 

 

2、完整代码

package com.kaikeba.hadoop.mrcompress;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
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 java.io.IOException;

/**
 * 本MR示例，用于统计每个用户搜索并查看URL链接的次数
 */

public class UserSearchCount {
  
       // =========  main =========
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        // 1、判断以下，输入参数是否是两个，分别表示输入路径、输出路径
        if (args.length != 2 || args == null) {
            System.out.println("please input Path!");
            System.exit(0);
        }

        Configuration configuration = new Configuration();
        //configuration.set("mapreduce.job.jar","/home/hadoop/IdeaProjects/Hadoop/target/com.kaikeba.hadoop-1.0-SNAPSHOT.jar");
        
        // 2、开启map输出进行压缩的功能
        configuration.set("mapreduce.map.output.compress", "true");
        // 设置map输出的压缩算法是：BZip2Codec，它是hadoop默认支持的压缩算法，且支持切分
        configuration.set("mapreduce.map.output.compress.codec", "org.apache.hadoop.io.compress.BZip2Codec");
        
        // 3、开启job输出压缩功能
        configuration.set("mapreduce.output.fileoutputformat.compress", "true");
        // 指定job输出使用的压缩算法
        configuration.set("mapreduce.output.fileoutputformat.compress.codec", "org.apache.hadoop.io.compress.BZip2Codec");

        // 4、调用getInstance方法，生成job实例
        Job job = Job.getInstance(configuration, UserSearchCount.class.getSimpleName());

        // 5、设置jar包，参数是包含main方法的类
        job.setJarByClass(UserSearchCount.class);

        //通过job设置输入/输出格式
        //MR的默认输入格式是TextInputFormat，所以下两行可以注释掉
//        job.setInputFormatClass(TextInputFormat.class);
//        job.setOutputFormatClass(TextOutputFormat.class);

        // 6、设置输入/输出路径
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

//        FileOutputFormat.setCompressOutput(job, true);
//        FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class);

        // 7、设置处理Map阶段的自定义的类
        job.setMapperClass(SearchCountMapper.class);
        
        //设置map combine类，减少网路传出量
        //job.setCombinerClass(WordCountReduce.class);
        
        // 8、设置处理Reduce阶段的自定义的类
        job.setReducerClass(SearchCountReducer.class);

        //如果map、reduce的输出的kv对类型一致，直接设置reduce的输出的kv对就行；如果不一样，需要分别设置map, reduce的输出的kv类型
        //注意：此处设置的map输出的key/value类型，一定要与自定义map类输出的kv对类型一致；否则程序运行报错
//        job.setMapOutputKeyClass(Text.class);
//        job.setMapOutputValueClass(IntWritable.class);

        // 9、设置reduce task最终输出key/value的类型
        //注意：此处设置的reduce输出的key/value类型，一定要与自定义reduce类输出的kv对类型一致；否则程序运行报错
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // 10、提交作业
        job.waitForCompletion(true);
    }

    
    // =========  Map =========
    
    public static class SearchCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
        // 0、定义共用的对象，减少GC压力
        Text userIdKOut = new Text();
        IntWritable vOut = new IntWritable(1);

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            // 1、获得当前行的数据
            //样例数据：20111230111645  169796ae819ae8b32668662bb99b6c2d        塘承高速公路规划线路图  1       1       http://auto.ifeng.com/roll/20111212/729164.shtml
            String line = value.toString();

            // 2、切分，获得各字段组成的数组
            String[] fields = line.split("\t");

            //因为要统计每个user搜索并查看URL的次数，所以将userid放到输出key的位置
            //注意：MR编程中，根据业务需求设计key是很重要的能力
            String userid = fields[1];

            // 3、设置输出的key的值
            userIdKOut.set(userid);
            
            // 4、输出结果
            context.write(userIdKOut, vOut);
        }
    }

    
    // =========  Reduce =========
    
    public static class SearchCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        
        // 0、定义共用的对象，减少GC压力
        IntWritable totalNumVOut = new IntWritable();

        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;

            for(IntWritable value: values) {
                sum += value.get();
            }

            //设置当前user搜索并查看总次数
            totalNumVOut.set(sum);
            context.write(key, totalNumVOut);
        }
    }
}

 

 

四、MR编程—自定义InputFormat—处理小文件（重点+难点 ）

  • 若要自定义InputFormat的话

    • （1）需，自定义InputFormat类，并覆写getRecordReader()方法

    • （2）需，自定义RecordReader类，实现方法

      • initialize()

      • nextKeyValue()

      • getCurrentKey()

      • getCurrentValue()

      • getProgress()

      • close()

4.1 MapReduce执行过程

上图也描述了mapreduce的一个完整的过程；我们主要看

map任务，如何从hdfs读取分片数据的部分，涉及3个关键的类：

      ① InputFormat 输入格式类：将输入文件分成一个个分片Split，

      ② InputSplit 输入分片类：getSplits()，计算有多少个spit，每个Map任务对应一个split分片（block）

      ③ RecordReader 记录读取器类：createRecordReader()，读取分片数据，一行记录生成一个键值对，传入map任务的map()方法，调用map()

 

因此，如果需要根据自己的业务情况，自定义输入的话，需要自定义两个类：

  • InputFormat类

  • RecordReader类

 

MapReduce详细流程：

  • （1）客户端调用InputFormat的getSplits()方法，获得输入文件的分片信息（相当于分为几个128M的block）

  • （2）将分片信息传递给MRjob的AppMaster

    • 注： 针对每个MR job会生成一个相应的app master，负责map\reduce任务的调度及监控执行情况

  • （3）AppMaster根据分片信息，尽量将map任务，调度在split分片数据所在节点（这种方式称为：移动计算，不移动数据）

    • 有几个分片，就生成几个map任务

  • （4）每个map任务将split分片传递给createRecordReader()方法，生成此分片对应的RecordReader

  • （5）RecordReader读取分片的数据，生成记录的键值对

    • nextKeyValue()判断是否有下一个键值对，如果有，返回true；否则，返回false

    • 如果返回true，调用getCurrentKey()获得当前的键

    • 调用getCurrentValue()获得当前的值

  • （6）map任务运行过程，会调用run()

    • ① 首先运行一次setup()方法（只在map任务启动时，运行一次）；

      • 一些初始化的工作可以在setup方法中完成；如要连接数据库之类的操作

    • ② while循环，调用context.nextKeyValue()；会委托给RecordRecord的nextKeyValue()，判断是否有下一个键值对

      • 如果有下一个键值对，调用context.getCurrentKey()、context.getCurrentValue()获得当前的键、值的值（也是调用RecordReader的同名方法）

      • 作为参数传入map(key, value, context)，调用一次map()

    • ③ 当读取分片尾，context.nextKeyValue()返回false；退出循环

    • ④ 调用cleanup()方法，只在map任务结束之前，调用一次；所以，一些回收资源的工作可在此方法中实现，如关闭数据库连接

 

4.2 需求

  • 无论hdfs还是mapreduce，处理小文件都有损效率，实践中，又难免面临处理大量小文件的场景，此时，就需要有相应解决方案

4.3 分析

  • 小文件的优化无非以下几种方式：

    • （1）在数据采集的时候，就将小文件或小批数据合成大文件再上传HDFS(SequenceFile方案)

    • （2）在业务处理之前，在HDFS上使用mapreduce程序对小文件进行合并；可使用自定义InputFormat实现

    • （3）在mapreduce处理时，可采用CombineFileInputFormat提高效率

  • 本例小文件的优化使用第二种方案，自定义InputFormat

  • 一次性读取多个小文件，形成一个分片，避免每个小文件形成一个分片

 

1、自定义InputFormat 类

 

2、自定义RecordReader类

实现6个相关方法 ：初始化 、判断是否有下一个键值对、获得当前的key、获得当前的value、获得分片读取的百分比

 

 

3、main

 

 

 

4、完整代码

package com.kaikeba.hadoop.inputformat;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

import java.io.IOException;

/**
 * 自定义InputFormat类；
 * 泛型：
 * 		 键：因为不需要使用键，所以设置为NullWritable
 *  	 值：值用于保存小文件的内容，此处使用BytesWritable
 */
public class WholeFileInputFormat extends FileInputFormat<NullWritable, BytesWritable> {

    /**
     * 返回false，表示输入文件  不可切割
     * @param context
     * @param file
     * @return
     */
    @Override
    protected boolean isSplitable(JobContext context, Path file) {
        return false;
    }

    /**
     * 生成读取分片split的RecordReader
     * @param split
     * @param context
     * @return
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public RecordReader<NullWritable, BytesWritable> createRecordReader(InputSplit split, TaskAttemptContext context) throws IOException,InterruptedException {
        // 1、使用 自定义的RecordReader类
        WholeFileRecordReader reader = new WholeFileRecordReader();
        // 2 、初始化RecordReader
        reader.initialize(split, context);
        return reader;
    }
}

 

package com.kaikeba.hadoop.inputformat;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;

/**
 * RecordReader的核心工作逻辑：
 * 	通过nextKeyValue()方法去读取数据构造将返回的key   value
 * 	通过getCurrentKey 和 getCurrentValue来返回上面构造好的key和value
 */
public class WholeFileRecordReader extends RecordReader<NullWritable, BytesWritable> {

    // 1、要读取的分片
    private FileSplit fileSplit;
    private Configuration conf;

    // 2、读取的value数据
    private BytesWritable value = new BytesWritable();
    
    /**
     * 3、标识变量，分片是否已被读取过；因为小文件设置成了不可切分，所以一个小文件只有一个分片；
     * 而这一个分片的数据，只读取一次，一次读完所有数据
     * 所以设置此标识
     */
    private boolean processed = false;

    
    /**
     * 4、初始化
     * @param split
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public void initialize(InputSplit split, TaskAttemptContext context)
            throws IOException, InterruptedException {
        this.fileSplit = (FileSplit) split;
        this.conf = context.getConfiguration();
    }


    /**
     *  5、判断是否有下一个键值对。若有，则读取分片中的所有的数据
     * @return
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public boolean nextKeyValue() throws IOException, InterruptedException {
        if (!processed) {
            byte[] contents = new byte[(int) fileSplit.getLength()];
            Path file = fileSplit.getPath();
            FileSystem fs = file.getFileSystem(conf);
            FSDataInputStream in = null;
            try {
                in = fs.open(file);
                IOUtils.readFully(in, contents, 0, contents.length);
                value.set(contents, 0, contents.length);
            } finally {
                IOUtils.closeStream(in);
            }
            processed = true;
            return true;
        }
        return false;
    }

    /**
     *  7、获得当前的key
     * @return
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public NullWritable getCurrentKey() throws IOException,
            InterruptedException {
        return NullWritable.get();
    }


    /**
     *  8、获得当前的value
     * @return
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public BytesWritable getCurrentValue() throws IOException,
            InterruptedException {
        return value;
    }

    /**
     * 9、获得分片读取的百分比；因为如果读取分片数据的话，会一次性的读取完；所以进度要么是1，要么是0
     * @return
     * @throws IOException
     */
    @Override
    public float getProgress() throws IOException {
        //因为一个文件作为一个整体处理，所以，如果processed为true，表示已经处理过了，进度为1；否则为0
        return processed ? 1.0f : 0.0f;
    }

    @Override
    public void close() throws IOException {
    }
}
package com.kaikeba.hadoop.inputformat;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.io.IOException;

/**
 * 让主类继承Configured类，实现Tool接口
 * 实现run()方法
 * 将以前main()方法中的逻辑，放到run()中
 * 在main()中，调用ToolRunner.run()方法，第一个参数是当前对象；第二个参数是输入、输出
 */
public class SmallFiles2SequenceFile extends Configured implements Tool {

    /**
     * 自定义Mapper类
     * mapper类的输入键值对类型，与自定义InputFormat的输入键值对保持一致
     * mapper类的输出的键值对类型，分别是文件名、文件内容
     */
    static class SequenceFileMapper extends
            Mapper<NullWritable, BytesWritable, Text, BytesWritable> {

        private Text filenameKey;

        /**
         * 取得文件名
         * @param context
         * @throws IOException
         * @throws InterruptedException
         */
        @Override
        protected void setup(Context context) throws IOException,
                InterruptedException {
            InputSplit split = context.getInputSplit();
            //获得当前文件路径
            Path path = ((FileSplit) split).getPath();
            filenameKey = new Text(path.toString());
        }

        @Override
        protected void map(NullWritable key, BytesWritable value,
                           Context context) throws IOException, InterruptedException {
            context.write(filenameKey, value);
        }
    }

    public int run(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf,"combine small files to sequencefile");
        job.setJarByClass(SmallFiles2SequenceFile.class);

        //设置自定义输入格式
        job.setInputFormatClass(WholeFileInputFormat.class);

        WholeFileInputFormat.addInputPath(job,new Path(args[0]));
        //设置输出格式SequenceFileOutputFormat及输出路径
        job.setOutputFormatClass(SequenceFileOutputFormat.class);
        SequenceFileOutputFormat.setOutputPath(job,new Path(args[1]));

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(BytesWritable.class);
        job.setMapperClass(SequenceFileMapper.class);
        return job.waitForCompletion(true) ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new SmallFiles2SequenceFile(),
                args);
        System.exit(exitCode);

    }
}

 

TUJC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据实验四-MapReduce编程实践
04-03
MapReduce编程实践： 使用MapReduce实现多个文本文件中WordCount词频统计功能，实验编写Map处理逻辑、编写Reduce处理逻辑、编写main方法。 二．实验目的 1、通过实验掌握基本的MapReduce编程方法。 2、实现统计HDFS...
实验项目 MapReduce 编程
04-18
2. 在 Hadoop 集群主节点上搭建 MapReduce 开发环境 Eclipse。 3. 查看 Hadoop 自带的 MR-App 单词计数源代码 WordCount.java，在 Eclipse 项目 MapReduceExample 下建立新包 com.xijing.mapreduce，模仿内置的 ...
Hadoop学习笔记—4.初识MapReduce
deguotiantang的专栏
02-28 3994
一、神马是高大上的MapReduce 　　MapReduce是Google的一项重要技术，它首先是一个编程模型，用以进行大数据量的计算。对于大数据量的计算，通常采用的处理手法就是并行计算。但对许多开发者来说，自己完完全全实现一个并行计算程序难度太大，而MapReduce就是一种简化并行计算的编程模型，它使得那些没有多有多少并行计算经验的开发人员也可以开发并行应用程序。这也就是MapReduc
MapReduce详解
优质后端技术知识记录
10-30 1万+
第1章 MapReduce入门 1.1 MapReduce定义 Mapreduce是一个分布式运算程序的编程框架，是用户开发“基于hadoop的数据分析应用”的核心框架。 Mapreduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个hadoop集群上。 1.2MapReduce优缺点 1.2.1 优点 1．MapReduce易于编......
MAPREDUCE详解
woaini886353的博客
05-10 1万+
1. MAPREDUCE原理篇（1） Mapreduce是一个分布式运算程序的编程框架，是用户开发“基于hadoop的数据分析应用”的核心框架； Mapreduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个hadoop集群上； 1.1 为什么要MAPREDUCE （1）海量数据在单机上处理因为硬件资源限制，无法胜任 （2）而一旦将单机版程序扩展到集群来分布式运行，将极大增加程序的复杂度和开发难度 （3）引入mapreduce框架后，开发人员
大数据学习——MapReduce
daybreak98的博客
05-17 6925
具体实现bean对象序列化步骤如下。（1）实现Writable接口（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造（3）重写序列化和反序列化方法，同时要求顺序一致（4）如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序。默认分区通过key的hashCode对ReduceTask个数取模得到。
MapReduce详细介绍
白玉杰的博客
03-22 6926
一 MapReduce入门 1.1 MapReduce定义 Mapreduce是一个分布式运算程序的编程框架，是用户开发“基于hadoop的数据分析应用”的核心框架； Mapreduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个hadoop集群上。 1.2 MapReduce优缺点 1.2.1 优点 1）MapReduce 易于编程。它简单的实现...
mapreduce_reduce_mapReduce_settingn2p_
10-03
MapReduce是一种编程模型，用于大规模数据集（大于1TB）的并行运算。概念"Map（映射）"和"Reduce（归约）"，是它们的主要思想，都是从函数式编程语言里借来的，还有从矢量编程语言里借来的特性...
mapreducewordcounter-master_wordcount_mapReduce_
10-01
这是大数据架构的编程作业，用python实现mapreduce里的word count
【Hadoop】MapReduce详解
小哲的博客
07-26 5135
MapReduce详解MapReduce介绍MapReduce的基本编程模型MapReduce的计算过程1. Map阶段可以概括为5个步骤：2. Reduce节点也可以分为5个步骤：设置ReduceTask并行度（个数）关于分片（Split）关于ShuffleMap端的shuffleReduce端的ShuffleShuffle流程详解补充问题：MapReduce分区相关问题理解1.Partition的原理和作用2.Partition的使用3.分组的概念和使用分组排序的步骤4.Combiner的使用概念实现步
什么是MapReduce(入门篇)
热门推荐
大数据梦想家
11-13 2万+
        在HDFS系列完结之后,小伙伴们期待的MapReduce系列已经在向大家挥手了。本篇博客,小菌将为大家带来MapReduce的入门介绍!         在正式开始之前,让我们通过一张图片回顾一下Hadoop的组成部分,以及...
MapReduce介绍
最新发布
qq_25409421的博客
08-17 2万+
MapReduce是一个用于大规模数据处理的分布式计算模型，最初由Google工程师设计并实现的，Google已经将完整的MapReduce论文公开发布了。其中的定义是，MapReduce是一个编程模型，是一个用于处理和生成大规模数据集的相关的实现。用户定义一个map函数来处理一个Key-Value对以生成一批中间的Key-Value对，再定义一个reduce函数将所有这些中间的有相同Key的Value合并起来。很多现实世界中的任务都可用这个模型来表达。
hadoop之MapReduce简介
cxzaiwyy的博客
02-06 3693
hadoop之MapReduce的一些简介，架构和分析
MapReduce概述
mengxianglong123的博客
08-02 2311
一、MapReduce定义 MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。 MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。 二、 MapReduce优缺点 1. 优点 1）MapReduce易于编程 它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是
MapReduce详解及实战
花开蝶自来
05-22 2654
MapReduce详解及实战
Google云平台技术架构
weixin_30881367的博客
05-16 1173
Google Cloud 设计原理： 1.分布式文件系统： Google Distributed File System(GSF) 为了满足Google迅速增长的数据处理需求，我们设计并实现了Google文件系统(Google File System – GFS)。GFS与传统的分布式文件系统有着很多相同的设计目标，比如，性能、可伸缩性、可靠性以及可用性。但是，我们的设计还基...
Hadoop深入浅出MapReduce详解（全网最细）
清风的博客
05-28 1万+
文章目录前言-MR概述1.Hadoop MapReduce设计思想及优缺点设计思想优点：缺点：2. Hadoop MapReduce核心思想3.MapReduce工作机制剖析MapReduce运行机制过程描述第一阶段：作业提交（图1-4步）第二阶段：作业初始化（图5-7步）第三阶段：任务的分配(图8)第四阶段：任务的执行（图9-11）第五阶段：作业完成Tips 知识点：进度和状态更新4.MR各组成部分工作机制原理4.1概览：4.2 MapTask工作机制4.3 ReduceTask工作机制4.4shuffl
MapReduce编程
05-05
下面是MapReduce编程的一般步骤： 1. 将数据拆分成多个块，并将这些数据块分配给不同的计算机节点。 2. 对于每个数据块，Map函数会将它们转换成一组键值对。 3. 每个键值对都会被传递给Reduce函数，Reduce函数会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值