MapReduce类型与格式

最新推荐文章于 2021-04-12 08:50:51 发布
最新推荐文章于 2021-04-12 08:50:51 发布
阅读量1.4k 收藏
点赞数
分类专栏： 大数据 hadoop 文章标签： hadoop MapReduce 数据格式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfdanding/article/details/51366566
版权

输入格式
1）输入分片与记录
a）JobClient通过指定的输入文件的格式来生成数据分片InputSpilit
输入格式概览如图所示：
这里写图片描述
抽象类：FileInputFormat
1、FileInputFormat是所有使用文件作为数据源的InputFormat实现的基类
2、FileInputFormat输入数据格式的分片大小由数据块大小决定
在org.apache.hadoop.mapreduce.lib.input.FileInputFormat.java中的getSplits方法


  /** 
   * Generate the list of files and make them into FileSplits.
   */ 
  public List<InputSplit> getSplits(JobContext job
                                    ) throws IOException {
    long minSize = Math.max(getFormatMinSplitSize(), getMinSplitSize(job));
    long maxSize = getMaxSplitSize(job);

    // generate splits
    List<InputSplit> splits = new ArrayList<InputSplit>();
    List<FileStatus>files = listStatus(job);
    for (FileStatus file: files) {
      Path path = file.getPath();
      FileSystem fs = path.getFileSystem(job.getConfiguration());
      long length = file.getLen();
      BlockLocation[] blkLocations = fs.getFileBlockLocations(file, 0, length);
      if ((length != 0) && isSplitable(job, path)) { 
        long blockSize = file.getBlockSize();
        long splitSize = computeSplitSize(blockSize, minSize, maxSize);

        long bytesRemaining = length;
        while (((double) bytesRemaining)/splitSize > SPLIT_SLOP) {
          int blkIndex = getBlockIndex(blkLocations, length-bytesRemaining);
          splits.add(new FileSplit(path, length-bytesRemaining, splitSize, 
                                   blkLocations[blkIndex].getHosts()));
          bytesRemaining -= splitSize;
        }

        if (bytesRemaining != 0) {
          splits.add(new FileSplit(path, length-bytesRemaining, bytesRemaining, 
                     blkLocations[blkLocations.length-1].getHosts()));
        }
      } else if (length != 0) {
        splits.add(new FileSplit(path, 0, length, blkLocations[0].getHosts()));
      } else { 
        //Create empty hosts array for zero length files
        splits.add(new FileSplit(path, 0, length, new String[0]));
      }
    }

    // Save the number of input files in the job-conf
    job.getConfiguration().setLong(NUM_INPUT_FILES, files.size());

    LOG.debug("Total # of splits: " + splits.size());
    return splits;
  }

调用org.apache.hadoop.mapreduce.lib.input.FileInputFormat.java中的computeSplitSize方法

  protected long computeSplitSize(long blockSize, long minSize,
                                  long maxSize) {
    return Math.max(minSize, Math.min(maxSize, blockSize));
  }

b）一个分片不是数据本身，而是可分片数据的引用
c）InputFormat接口负责生成分片

2）文件输入
抽象类：CombineFileInputFormat
1、可以使用CombineFileInputFormat来合并小文件
2、因为CombineFileInputFormat是一个抽象类，使用的时候需要创建一个CombineFileInputFormat的实体类，并且实现getRecordReader（）的方法
3、避免文件分割的方法：
A、数据块大小尽可能大，这样使文件的大小小于数据块的大小，就不用进行分片
B、继承FileInputFormat，并且重载isSplitable（）方法

3）文本输入
类名：TextInputFormat
1、TextInputFormat是默认的InputFormat，每一行数据就是一条记录
2、TextInputFormat的key是LongWritable类型的，存储该行在整个文件的偏移量，value是每行的数据内容，Text类型
3、输入分片与HDFS数据块关系：TextInputFormat每一条记录就是一行，很有可能某一行跨数据块存放
这里写图片描述
类名：KeyValueTextInputFormat
1、KeyValueTextInputFormat类可以通过设置key为行号的方式来知道记录的行号，并且可以通过key.value.separator.in.input设置key与value的分割符

类名：NLineInputFormat
1、可以设置每个mapper处理的行数，可以通过mapred.line.input.format.linespermap属性设置

4）二进制输入
类：SequenceFileInputFormat
SequenceFileAsTextInputFormat
SequenceFileAsBinaryInputFormat
1、由于SequenceFile能够支持Splittable，所以能够作为mapreduce输入的格式，能够很方便的得到已经含有

/**
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */


package org.apache.hadoop.examples;

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;

public class WordCount {

  public static class TokenizerMapper 
       extends Mapper<Object, Text, Text, IntWritable>{

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

    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());
        context.write(word, one);
      }
    }
  }

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

    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: wordcount <in> <out>");
      System.exit(2);
    }
    Job job = new Job(conf, "word count");
    job.setJarByClass(WordCount.class);
    job.setMapperClass(TokenizerMapper.class);
    job.setCombinerClass(IntSumReducer.class);
    job.setReducerClass(IntSumReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
    FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
    FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

现在修改代码使其对SequenceFile进行词频统计

package com.mr;

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

public class TestInputFormat {

  public static class TokenizerMapper 
       extends Mapper<IntWritable, Text, Text, IntWritable>{

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

    public void map(IntWritable key, Text value, Context context
                    ) throws IOException, InterruptedException {
      StringTokenizer itr = new StringTokenizer(value.toString());
      while (itr.hasMoreTokens()) {
        word.set(itr.nextToken());
        context.write(word, one);
      }
    }
  }

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

    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: wordcount <in> <out>");
      System.exit(2);
    }
    Job job = new Job(conf, "word count");
    job.setJarByClass(TestInputFormat.class);
    job.setMapperClass(TokenizerMapper.class);
    job.setCombinerClass(IntSumReducer.class);
    job.setReducerClass(IntSumReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
    job.setInputFormatClass(SequenceFileInputFormat.class) ;
    FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
    FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

读取的SequenceFile文件通过如下代码生成

import java.net.URI;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.SequenceFile;
import org.apache.hadoop.io.SequenceFile.CompressionType;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.BZip2Codec;


public class SequenceFileWrite {

    public static String uri = "hdfs://10.13.33.218:9000" ;
    public static String[] data = {
        "one,two" ,
        "three,four" ,
        "five,six" ,
        "seven,eight" ,
        "nine,ten" 
    } ;
    public static void main(String args[])throws Exception{
        Configuration conf = new Configuration() ;
        FileSystem fs = FileSystem.get(URI.create(uri),conf) ;
//      Path path = new Path("/tmp.seq") ;
        Path path = new Path("/b.seq") ;
        IntWritable key = new IntWritable() ;
        Text value = new Text() ;
        //SequenceFile.Writer writer = SequenceFile.createWriter(fs, conf,path, key.getClass(), value.getClass()) ;
        SequenceFile.Writer writer = SequenceFile.createWriter(fs, conf,path, key.getClass(), value.getClass(),CompressionType.RECORD,new BZip2Codec()) ;//对SequenceFile进行记录压缩
        for(int i=0;i<100;i++){
            key.set(100-i) ;
            value.set(data[i%data.length]) ;
            writer.append(key, value) ;
        }
        IOUtils.closeStream(writer) ;
    }
}

现在修改代码使其对SequenceFile和文本文件同时进行词频统计，代码如下：

package com.mr;

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

public class TestInputFormat {

    public static class Mapper1 extends
            Mapper<LongWritable, Text, Text, IntWritable> {

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

        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()) {
                word.set(itr.nextToken());
                context.write(word, one);
            }
        }
    }

    public static class Mapper2 extends
            Mapper<IntWritable, Text, Text, IntWritable> {

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

        public void map(IntWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()) {
                word.set(itr.nextToken());
                context.write(word, one);
            }
        }
    }

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

        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: wordcount <in> <out>");
//      System.exit(2);
//    }
    Job job = new Job(conf, "word count");
    job.setJarByClass(TestInputFormat.class);
//    job.setMapperClass(TokenizerMapper.class);
    job.setCombinerClass(IntSumReducer.class);
    job.setReducerClass(IntSumReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
 //   job.setInputFormatClass(SequenceFileInputFormat.class) ;
    Path path1 = new Path("hdfs://10.13.33.218:9000/a.txt") ;
    Path path2 = new Path("hdfs://10.13.33.218:9000/b.seq") ;
    MultipleInputs.addInputPath(job, path1, TextInputFormat.class,Mapper1.class) ;
    MultipleInputs.addInputPath(job, path2, SequenceFileInputFormat.class,Mapper2.class) ;
//    FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
    FileOutputFormat.setOutputPath(job, new Path("hdfs://10.13.33.218:9000/output3"));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

输出格式概览，如图所示：
这里写图片描述

1、文本输出
类名：TextOutputFormat
1）默认的输出方式，key是LongWritable类型的，value是Text类型的
2）以“key \t value”的方式输出行

2、二进制输出
类名：SequenceFileOutputFormat
子类：SequenceFileAsBinaryOutputFormat

3、多文件输出
类名：MultipleOutputs可以产生不同类型的输出

4、数据库输出
类名：DBOutputFormat

lfdanding
关注
专栏目录
MapReduce的类型与格式
匆匆那些年
06-27 2102
MapReduce类型 map函数和reduce函数常规格式： map：(k1,v1)—>list(k2,v2) reduce：(k2,list(v2))—>list(k3,v3) 如果含有combiner函数 map：(k1,v1)—>list(k2,v2) combiner：(k2,list(v2))—>list(k2,v2) reduce：(k2,list(v2))—>list
Hadoop学习笔记（五）：MapReduce的类型与格式
Arthur-Chen的专栏
07-25 2195
在MapReduce中，map和reduce函数的输入和输出都是键值对（key/value）。 1. MapReduce函数的常规格式 MapReduce的函数一般遵循以下常规格式： map：（K1, V1）—> list（K2，V2） combine：（K2，list(V2)）—> list（K2，V2） partition：（K2，V2）—> integer reduce：
Hadoop基础-MapReduce的常用文件格式介绍
weixin_34352005的博客
07-12 181
　　　　　　　　　　　　　　Hadoop基础-MapReduce的常用文件格式介绍　　 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰 版权声明：原创作品，谢绝转载！否则将追究法律责任。     一.MR文件格式-SequenceFile 1&gt;.生成SequenceFile文件（SequenceFileOutputFormat） The Apache...
MapReduce类型及格式
07-30
MapReduce类型的概念涉及到数据类型在MapReduce编程模型中所扮演的角色。这些数据类型包括： 1. 输入数据类型：Map阶段所处理的原始数据类型，通常为文本文件或其他可序列化的数据格式。 2. Map输出类型：Map阶段...
MapReduce数据处理：类型与格式详解
"MapReduce类型及格式" MapReduce是一种分布式计算框架，主要应用于大数据处理，由Google提出并广泛应用于Hadoop等系统。它的核心在于通过map和reduce两个阶段来处理大规模的数据集。本文将深入探讨MapReduce的数据...
MapReduce类型和格式(二) 输入格式
ThisIsNobody的博客
06-26 908
输入分片和记录一个map操作处理一个split，一个split被分为若干记录，每个记录是一键值对，map一个个处理键值对。public abstract class InputSplit { /** * Get the size of the split, so that the input splits can be sorted by size. * @return the n...
MapReduce的输入输出格式
学习记录
04-12 1411
InputFormat TextInputFile 最普通的文本文档格式，MR中默认的 InputFormat，不需要特殊指定 每条记录是一行输入。键是LongWritable 类型，存储该行在整个文件中的字节偏移量。 值是这行的内容，不包括任何行终止符（换行符合回车符），它被打包成一个 Text 对象。 SequenceFileInputFormat 序列化文件格式，文件中两个字段，分别代表key和value。 KEYIN VALUEIN (根据文件字段的实际类型确定) KeyValueFileInput
hadoop学习笔记（十一）：MapReduce数据类型
weixin_30847939的博客
04-28 390
一、序列化 1 hadoop自定义了数据类型，在hadoop中，所有的key/value类型必须实现Writable接口。有两个方法，一个是write，一个是readFileds。分别用于读（反序列化操作）和写（序列化操作）。 2 所有的key必须实现Comparable接口，在MapReduce过程中需要对key/value对进行反复的排序，默认情况下依据key进行排序，要实现compare...
关于hadoop中MapReduce使用对象类型数据问题
大头鱼
06-23 346
使用序列化 在Hadoop的集群工作过程中，一般是利用RPC来进行集群节点之间的通信和消息的传输，所以要求MapReduce处理的对象必须可以进行序列化/反序列操作。 Hadoop并没有使用Java原生的序列化，而是利用的是Avro实现的序列化和反序列，并且在其基础上进行了更好的封装，提供了便捷的API 在Hadoop中要求被序列化的对象对应的类必须实现Writable接口 序列化过程中要求属性...
简述mapreduce的四个对象
weixin_30908941的博客
08-14 168
mapreduce的四个对象：客户端(client)，JobTracker，TaskTracker，Hdfsg 1.客户端(client) 　　编写mapreduce程序，配置作业，提交作业，这就是程序员完成的工作。 2.JobTracker 　　初始化作业，分配作业，与TaskTracker通信，协调整个作业的执行。 3.TaskTracker 　　保持与JobTracker通信，在...
MapReduce类的输入文件的格式
baidu_15113429的博客
11-10 722
输入多个文件，但是格式一样FileInputFormat.addInputPath(conf, new Path("hdfs://192.168.16.128:9000/test/groupby/cityA.txt"));输入多个文件，但是每个文件的格式可以不一样MultipleInputs.addInputPath(job, new Path("hdfs://192.168.16.128:9000
mapreduce关于数据压缩使用与支持的格式
涤生大数据
06-17 4058
1.压缩概述 数据压缩这是mapreduce的一种优化策略：通过压缩编码对mapper或者reducer的输出进行压缩，以减少磁盘IO，提高MR程序运行速度（但相应增加了cpu运算负担） Mapreduce支持将map输出的结果或者reduce输出的结果进行压缩，以减少网络IO或最终输出数据的体积 压缩特性运用得当能提高性能，但运用不当也可能降低性能 压缩使用基本原则：...
利用map和reduce编写实现字符串转化为浮点数的str2float（）函数
林中小屋
09-09 3852
利用map和reduce编写实现字符串转化为浮点数的str2float（）函数
Hadoop MapReduce的类型和格式
siyuan_zhu的专栏
04-01 268
1.MapReduce的类型 Hadoop的MapReduce函数遵循如下常规格式： --map：(K1, V1) -&gt; list(K2, V2) --combine：(K2, list(V2)) -&gt; list(K2, V2) --partition：(K2, V2) -&gt; integer --reduce：(K2, list(V2)) -&gt; list(K3...
Hadoop权威指南---MapReduce的类型与格式
l1394049664的博客
09-23 331
目录 1、MapReduce的类型简介 2、 输入格式  2.1、输入分片与记录  1）、FileInputFormat类 2）、FileInputFormat类的输入路径 3）、FileInputFormat类的输入分片 4）、小文件和combineFileInputFormat 5）、避免切分 6）、mapper中的文件信息 7）、把整个文件当成一条记录处理 2.2、文本...
hadoop中mapreduce的常用类
想~ai抽
03-09 2445
写这个文章的时候才意识到新旧API是同时存在于1.1.2的hadoop中的。以前还一直纳闷儿为什么有时候是jobClient提交任务，有时是Job...不管API是否更新，下面这些类也还是存在于API中的，经过自己跟踪源码，发现原理还是这些。只不过进行了重新组织，进行了一些封装，使得扩展性更好。所以还是把这些东西从记事本贴进来吧。 关于这些类的介绍以及使用，有的是在自己debug中看到的，多数为
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值