MapReduce(四) 典型编程场景（二）

最新推荐文章于 2024-08-10 16:30:06 发布
最新推荐文章于 2024-08-10 16:30:06 发布
阅读量414 收藏
点赞数 1
分类专栏： mapreduce 文章标签： mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42685589/article/details/81029969
版权


一、MapJoin-DistributedCache 应用 

     1、mapreduce join 介绍

在各种实际业务场景中，按照某个关键字对两份数据进行连接是非常常见的。如果两份数据 都比较小，那么可以直接在内存中完成连接。如果是大数据量的呢？ 显然，在内存中进行连 接会发生 OOM。 MapReduce 可以用来解决大数据量的链接
MapReduce 的 Join 操作主要分两类： MapJoin 和 ReduceJoin

先看 ReduceJoin:
（1）map 阶段，两份数据 data1 和 data2 会被 map 分别读入，解析成以链接字段为 key 以查 询字段为 value 的 key-value 对，并标明数据来源是 data1 还是 data2。
（2）reduce 阶段， reducetask 会接收来自 data1 和 data2 的相同 key 的数据，在 reduce 端进 行乘积链接， 最直接的影响是很消耗内存，导致 OOM 

再看 MapJoin:
MapJoin 适用于有一份数据较小的连接情况。做法是直接把该小份数据直接全部加载到内存 当中，按链接关键字建立索引。 然后大份数据就作为 MapTask 的输入，对 map()方法的每次 输入都去内存当中直接去匹配连接。 然后把连接结果按 key 输出，这种方法要使用 hadoop
中的 DistributedCache 把小份数据分布到各个计算节点，每个 maptask 执行任务的节点都需 要加载该数据到内存，并且按连接关键字建立索引 
（map读的是大表数据，在读大表之前，把小表数据放到内存当中，用setup方法）

    2、需求

现有两份数据 movies.dat 和 ratings.dat 数据样式分别为：

Movies.dat：
     1::Toy Story (1995)::Animation|Children's|Comedy
     2::Jumanji (1995)::Adventure|Children's|Fantasy
     3::Grumpier Old Men (1995)::Comedy|Romance
     字段含义： movieid, moviename, movietype

Ratings.dat
    1::1193::5::978300760
    1::661::3::978302109
    1::914::3::978301968

字段含义： userid, movieid, rate, timestamp 

现要求对两表进行连接，要求输出最终的结果有以上六个字段：
movieid, userid, rate, moviename, movietype, timestamp 

 

     3、实现

第一步：封装 MovieRate,方便数据的排序和序列化 
    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package  com.ghgj.mr.mymapjoin;
import  java.io.DataInput;
import  java.io.DataOutput;
import  java.io.IOException;
import  org.apache.hadoop.io.WritableComparable;
public  class  MovieRate  implements  WritableComparable<MovieRate>{
private  String movieid;
private  String userid;
private  int  rate;
private  String movieName;
private  String movieType;
private  long  ts;
public  String getMovieid() {
return  movieid;
}
public  void  setMovieid(String movieid) {
this .movieid = movieid;
}
public  String getUserid() {
return  userid;
}
public  void  setUserid(String userid) {
this .userid = userid;
}
public  int  getRate() {
return  rate;
}
public  void  setRate( int  rate) {
this .rate = rate;
}
public  String getMovieName() {
return  movieName;
}
public  void  setMovieName(String movieName) {
this .movieName = movieName;
}
public  String getMovieType() {
return  movieType;
}
public  void  setMovieType(String movieType) {
this .movieType = movieType;
}
public  long  getTs() {
return  ts;
}
public  void  setTs( long  ts) {
this .ts = ts;
}
public  MovieRate() {
}
public  MovieRate(String movieid, String userid,  int  rate, String movieName,
String movieType,  long  ts) {
this .movieid = movieid;
this .userid = userid;
this .rate = rate;
this .movieName = movieName;
this .movieType = movieType;
this .ts = ts;
}
@Override
public  String toString() {
return  movieid +  "\t"  + userid +  "\t"  + rate +  "\t"  + movieName
+  "\t"  + movieType +  "\t"  + ts;
}
@Override
public  void  write(DataOutput out)  throws  IOException {
out.writeUTF(movieid);
out.writeUTF(userid);
out.writeInt(rate);
out.writeUTF(movieName);
out.writeUTF(movieType);
out.writeLong(ts);
}
@Override
public  void  readFields(DataInput in)  throws  IOException {
this .movieid = in.readUTF();
this .userid = in.readUTF();
this .rate = in.readInt();
this .movieName = in.readUTF();
this .movieType = in.readUTF();
this .ts = in.readLong();
}
@Override
public  int  compareTo(MovieRate mr) {
int  it = mr.getMovieid().compareTo( this .movieid);
if (it ==  0 ){
return  mr.getUserid().compareTo( this .userid);
} else {
return  it;
}
}
}

第二步：编写mapreduce程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package  com.ghgj.mr.mymapjoin;
import  java.io.BufferedReader;
import  java.io.FileReader;
import  java.io.IOException;
import  java.net.URI;
import  java.util.HashMap;
import  java.util.Map;
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.LongWritable;
import  org.apache.hadoop.io.NullWritable;
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.filecache.DistributedCache;
import  org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import  org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public  class  MovieRatingMapJoinMR {
public  static  void  main(String[] args)  throws  Exception {
Configuration conf =  new  Configuration();
conf.set( "fs.defaultFS" ,  "hdfs://hadoop02:9000" );
System.setProperty( "HADOOP_USER_NAME" , "hadoop" );

Job job = Job.getInstance(conf);
// job.setJarByClass(MovieRatingMapJoinMR.class);
job.setJar("/home/hadoop/mrmr.jar");
job.setMapperClass(MovieRatingMapJoinMRMapper.class);
job.setMapOutputKeyClass(MovieRate.class);
job.setMapOutputValueClass(NullWritable.class);
// job.setReducerClass(MovieRatingMapJoinMReducer.class);
// job.setOutputKeyClass(MovieRate.class);
// job.setOutputValueClass(NullWritable.class);
job.setNumReduceTasks(0);
String minInput = args[0];
String maxInput = args[1];
String output = args[2];
FileInputFormat.setInputPaths(job, new Path(maxInput));
Path outputPath = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(outputPath)){
fs.delete(outputPath, true);
}
FileOutputFormat.setOutputPath(job, outputPath);
URI uri = new Path(minInput).toUri();
job.addCacheFile(uri);
boolean status = job.waitForCompletion(true);
System.exit(status?0:1);
}

　　

二、自定义 OutputFormat—数据分类输出 

实现：自定义 OutputFormat，改写其中的 RecordWriter，改写具体输出数据的方法 write() 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package  com.ghgj.mr.score_outputformat;
 
import  java.io.IOException;
 
import  org.apache.hadoop.conf.Configuration;
import  org.apache.hadoop.fs.FSDataOutputStream;
import  org.apache.hadoop.fs.FileSystem;
import  org.apache.hadoop.fs.Path;
import  org.apache.hadoop.io.IOUtils;
import  org.apache.hadoop.io.NullWritable;
import  org.apache.hadoop.io.Text;
import  org.apache.hadoop.mapreduce.RecordWriter;
import  org.apache.hadoop.mapreduce.TaskAttemptContext;
import  org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
 
public  class  MyScoreOutputFormat  extends  TextOutputFormat<Text, NullWritable>{
 
     @Override
     public  RecordWriter<Text, NullWritable> getRecordWriter(
             TaskAttemptContext job)  throws  IOException, InterruptedException {
         Configuration configuration = job.getConfiguration();
         
         FileSystem fs = FileSystem.get(configuration);
         Path p1 =  new  Path( "/score1/outpu1" );
         Path p2 =  new  Path( "/score2/outpu2" );
         
         if (fs.exists(p1)){
             fs.delete(p1,  true );
         }
         if (fs.exists(p2)){
             fs.delete(p2,  true );
         }
         
         FSDataOutputStream fsdout1 = fs.create(p1);
         FSDataOutputStream fsdout2 = fs.create(p2);
         return  new  MyRecordWriter(fsdout1, fsdout2);
     }
     
     static  class  MyRecordWriter  extends  RecordWriter<Text, NullWritable>{
 
         FSDataOutputStream dout1 =  null ;
         FSDataOutputStream dout2 =  null ;
         
         public  MyRecordWriter(FSDataOutputStream dout1, FSDataOutputStream dout2) {
             super ();
             this .dout1 = dout1;
             this .dout2 = dout2;
         }
 
         @Override
         public  void  write(Text key, NullWritable value)  throws  IOException,
                 InterruptedException {
             // TODO Auto-generated method stub
             
             String[] strs = key.toString().split( "::" );
             if (strs[ 0 ].equals( "1" )){
                 dout1.writeBytes(strs[ 1 ]+ "\n" );
             } else {
                 dout2.writeBytes(strs[ 1 ]+ "\n" );
             }
         }
 
         @Override
         public  void  close(TaskAttemptContext context)  throws  IOException,
                 InterruptedException {
             IOUtils.closeStream(dout2);
             IOUtils.closeStream(dout1);
         }
     }
}

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package  com.ghgj.mr.score_outputformat;
 
import  java.io.IOException;
 
import  org.apache.hadoop.conf.Configuration;
import  org.apache.hadoop.conf.Configured;
import  org.apache.hadoop.fs.FileSystem;
import  org.apache.hadoop.fs.Path;
import  org.apache.hadoop.io.LongWritable;
import  org.apache.hadoop.io.NullWritable;
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.FileInputFormat;
import  org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import  org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import  org.apache.hadoop.util.Tool;
import  org.apache.hadoop.util.ToolRunner;
 
public  class  ScoreOutputFormatMR  extends  Configured  implements  Tool{
 
     // 这个run方法就相当于Driver
     @Override
     public  int  run(String[] args)  throws  Exception {
         
         Configuration conf =  new  Configuration();
         conf.set( "fs.defaultFS" ,  "hdfs://hadoop02:9000" );
         System.setProperty( "HADOOP_USER_NAME" ,  "hadoop" );
         Job job = Job.getInstance(conf);
         
         job.setMapperClass(ScoreOutputFormatMRMapper. class );
         job.setMapOutputKeyClass(Text. class );
         job.setMapOutputValueClass(NullWritable. class );
         
         job.setNumReduceTasks( 0 );
         
         // 这就是默认的输入输出组件
         job.setInputFormatClass(TextInputFormat. class );
         // 这是默认往外输出数据的组件
//      job.setOutputFormatClass(TextOutputFormat.class);
         job.setOutputFormatClass(MyScoreOutputFormat. class );
         
         FileInputFormat.setInputPaths(job,  new  Path( "/scorefmt" ));
         Path output =  new  Path( "/scorefmt/output" );
         FileSystem fs = FileSystem.get(conf);
         if (fs.exists(output)){
             fs.delete(output,  true );
         }
         FileOutputFormat.setOutputPath(job, output);
         
         boolean  status = job.waitForCompletion( true );
         return  status? 0 : 1 ;
     }
 
     public  static  void  main(String[] args)  throws  Exception {
         
         int  run =  new  ToolRunner().run( new  ScoreOutputFormatMR(), args);
         System.exit(run);
     }
     
     static  class  ScoreOutputFormatMRMapper  extends  Mapper<LongWritable,  Text, Text, NullWritable>{
         @Override
         protected  void  map(LongWritable key, Text value,
                 Mapper<LongWritable, Text, Text, NullWritable>.Context context)
                 throws  IOException, InterruptedException {
             
             String[] split = value.toString().split( "\t" );
             if (split.length- 2  >=  6 ){
                 context.write( new  Text( "1::" +value.toString()), NullWritable.get());
             } else {
                 context.write( new  Text( "2::" +value.toString()), NullWritable.get());
             }
         }
     }
}

三、自定义 InputFormat—小文件合并 

      第一步：自定义InputFormat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package  com.ghgj.mr.format.input;
 
import  java.io.IOException;
 
import  org.apache.hadoop.fs.Path;
import  org.apache.hadoop.io.NullWritable;
import  org.apache.hadoop.io.Text;
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;
 
public  class  WholeFileInputFormat  extends  FileInputFormat<NullWritable, Text> {
     // 设置每个小文件不可分片,保证一个小文件生成一个key-value键值对
     @Override
     protected  boolean  isSplitable(JobContext context, Path file) {
         return  false ;
     }
 
     @Override
     public  RecordReader<NullWritable, Text> createRecordReader(
             InputSplit split, TaskAttemptContext context)  throws  IOException,
             InterruptedException {
         WholeFileRecordReader reader =  new  WholeFileRecordReader();
         reader.initialize(split, context);
         return  reader;
     }
}

　　第二步：编写自定义的 RecordReader 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package  com.ghgj.mr.format.input;
 
import  java.io.IOException;
 
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.IOUtils;
import  org.apache.hadoop.io.NullWritable;
import  org.apache.hadoop.io.Text;
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;
 
class  WholeFileRecordReader  extends  RecordReader<NullWritable, Text> {
     private  FileSplit fileSplit;
     private  Configuration conf;
     private  Text value =  new  Text();
     private  boolean  processed =  false ;
 
     @Override
     public  void  initialize(InputSplit split, TaskAttemptContext context)
             throws  IOException, InterruptedException {
         this .fileSplit = (FileSplit) split;
         this .conf = context.getConfiguration();
     }
 
     @Override
     public  boolean  nextKeyValue()  throws  IOException, InterruptedException {
         if  (!processed) {
             // 获取 输入逻辑切片的 字节数组
             byte [] contents =  new  byte [( int ) fileSplit.getLength()];
             // 通过 filesplit获取该逻辑切片在文件系统的位置
             Path file = fileSplit.getPath();
             FileSystem fs = file.getFileSystem(conf);
             FSDataInputStream in =  null ;
             try  {
                 // 文件系统对象fs打开一个file的输入流
                 in = fs.open(file);
                 /**
                  *  in是输入流
                  *  contents是存这个流读取的到数的数据的字节数组
                  * 
                  */
                 IOUtils.readFully(in, contents,  0 , contents.length);
                 
                 value.set(contents,  0 , contents.length);
                 
             }  finally  {
                 IOUtils.closeStream(in);
             }
             processed =  true ;
             return  true ;
         }
         return  false ;
     }
 
     @Override
     public  NullWritable getCurrentKey()  throws  IOException, InterruptedException {
         return  NullWritable.get();
     }
 
     @Override
     public  Text getCurrentValue()  throws  IOException, InterruptedException {
         return  value;
     }
 
     @Override
     public  float  getProgress()  throws  IOException {
         return  processed ?  1 .0f :  0 .0f;
     }
 
     @Override
     public  void  close()  throws  IOException {
         // do nothing
     }
}

　　 第三步：编写mapreduce程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package  com.ghgj.mr.format.input;
 
import  java.io.IOException;
 
import  org.apache.hadoop.conf.Configuration;
import  org.apache.hadoop.conf.Configured;
import  org.apache.hadoop.fs.FileSystem;
import  org.apache.hadoop.fs.Path;
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.Reducer;
import  org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import  org.apache.hadoop.mapreduce.lib.input.FileSplit;
import  org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import  org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import  org.apache.hadoop.util.Tool;
import  org.apache.hadoop.util.ToolRunner;
 
public  class  SmallFilesConvertToBigMR  extends  Configured  implements  Tool {
     
     public  static  void  main(String[] args)  throws  Exception {
         int  exitCode = ToolRunner.run( new  SmallFilesConvertToBigMR(), args);
         System.exit(exitCode);
     }
 
     static  class  SmallFilesConvertToBigMRMapper  extends
             Mapper<NullWritable, Text, Text, Text> {
         
         private  Text filenameKey;
         @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, Text value, Context context)
                 throws  IOException, InterruptedException {
             context.write(filenameKey, value);
         }
     }
 
     static  class  SmallFilesConvertToBigMRReducer  extends
             Reducer<Text, Text, NullWritable, Text> {
         @Override
         protected  void  reduce(Text filename, Iterable<Text> bytes,
                 Context context)  throws  IOException, InterruptedException {
             context.write(NullWritable.get(), bytes.iterator().next());
         }
     }
 
     @Override
     public  int  run(String[] args)  throws  Exception {
         Configuration conf =  new  Configuration();
         conf.set( "fs.defaultFS" ,  "hdfs://hadoop02:9000" );
         System.setProperty( "HADOOP_USER_NAME" ,  "hadoop" );
         Job job = Job.getInstance(conf,  "combine small files to bigfile" );
         
         job.setJarByClass(SmallFilesConvertToBigMR. class );
         
         job.setMapOutputKeyClass(Text. class );
         job.setMapOutputValueClass(Text. class );
         job.setMapperClass(SmallFilesConvertToBigMRMapper. class );
 
         job.setOutputKeyClass(NullWritable. class );
         job.setOutputValueClass(Text. class );
         job.setReducerClass(SmallFilesConvertToBigMRReducer. class );
 
         // TextInputFormat是默认的数据读取组件
//      job.setInputFormatClass(TextInputFormat.class);
         // 不是用默认的读取数据的Format，我使用自定义的 WholeFileInputFormat
         job.setInputFormatClass(WholeFileInputFormat. class );
         
         
         Path input =  new  Path( "/smallfiles" );
         Path output =  new  Path( "/bigfile" );
         FileInputFormat.setInputPaths(job, input);
         FileSystem fs = FileSystem.get(conf);
         if  (fs.exists(output)) {
             fs.delete(output,  true );
         }
         FileOutputFormat.setOutputPath(job, output);
 
         int  status = job.waitForCompletion( true ) ?  0  :  1 ;
         return  status;
     }
}
牛逸凡
关注
专栏目录
【Hadoop入门学习系列之四】MapReduce 2.0应用场景和原理、基本架构和编程模型
生命奇迹泉的专栏
10-24 3437
一.MapReduce的应用场景1.MapReduce特点 易于编程  良好的扩展性  高容错性  适合PB级以上海量数据的离线处理 备注：*MR的最后一个特性就注定了它的应用场景的特定性，专门为处理离线批量大数据*而生。 问：那MR不擅长什么啊？它不擅长的东西谁比较擅长呢？2.MapReduce的特色—不擅长的方面 实时计算spark 像MySQL一样，在毫秒级或者秒级内返回
MapReduce典型编程场景——多Job串联
Sven119的博客
12-14 1636
主要说一下多job串联的使用方法
MapReduce编程之Reduce Join多种应用场景与使用
weixin_30877227的博客
08-13 237
在关系型数据库中 Join 是非常常见的操作，各种优化手段已经到了极致。在海量数据的环境下，不可避免的也会碰到这种类型的需求， 例如在数据分析时需要连接从不同的数据源中获取到数据。不同于传统的单机模式，在分布式存储下采用 MapReduce 编程模型，也有相应的处理措施和优化方法。 我们先简要地描述待解决的问题。假设有两个数据集：气象站数据库和天气记录数据库，并考虑如何合二为一。一个典型的查询是...
MapReduce 简单介绍
最新发布
slb190623的博客
08-10 919
MapReduce 是一个使用简单的软件框架，基于它写出来的应用程序能够运行在由上千个商用机器组成的大型集群上，并以一种可靠容错式并行处理TB级别的数据集。MapReduce是一个并行程序的计算模型与方法MapReduce是一个并行程序运行的软件框架MapReduce是一个基于集群的高性能并行计算平台。
MapReduce场景应用
lemon
01-07 5205
MapReduce场景应用 一，QQ共同好友简单分析 相信大家都有用过QQ, QQ会不定期的向你推荐些可能认识的人(显示你们有多少个共同好友)。 那么它的数据是哪里来的呢？实际上是每个人好友列表数据分析出来的。 比如说 A 的好友列表中有 B C， B的好友列表有 C D E ,那么系统可能会给A推荐 D E ，这样才是合理的方案。 对于QQ用户来说，用户群是非常庞大的，分析每个人好友列...
大数据开发：MapReduce应用场景
shuimuzh123的博客
05-19 3495
MapReduce最初进入我们的实现，是作为Hadoop的核心计算引擎，负责分布式计算，也作为编程模型使用。在整个Hadoop生态当中，MapReduce的影响意义是深远的，也是第一代计算框架代表产品。今天的大数据开发学习分享，我们就来讲讲MapReduce应用场景相关的知识。 首先，MapReduce的设计初衷就是为了大规模数据集的批量处理，提升整体的数据处理效率，而MapReduce诞生之初，典型的应用就是使用MapReduce进行长句切割，然后进行词频统计，这也为MapReduce的应用场.
MapReduce应用实例
wtq1993的博客
05-17 5914
1.各个部门的总工资如何进行问题分析的? 2.各个部门的总工资处理流程是怎样的？ 3.个部门的人数和平均工资又是如何得到的？ 4.个部门的人数和平均工资代码如何实现？ 案例所用包全部下载：链接: http://pan.baidu.com/s/1sjNyDIX 密码: 游客，如果您要查看本帖隐藏内容请回复 1、环境说明 部署节点操作系统为CentOS，防
MapReduce典型编程场景——TopN算法自定义GroupComparator
Sven119的博客
12-14 768
主要介绍MapReduce编程场景中TopN场景
MapReduce----3.MapReduce 典型编程场景
XiaodunLP的博客
02-02 229
1、MapReduce 多 Job 串联 1.1、需求 一个稍复杂点的处理逻辑往往需要多个 MapReduce 程序串联处理，多 job 的串联可以借助 MapReduce 框架的 JobControl 实现 1.2、实例 以下有两个 MapReduce 任务，分别是 Flow 的 SumMR 和 SortMR，其中有依赖关系：SumMR 的输出是 SortMR 的输入，所以 SortMR...
MongoDB中MapReduce编程模型使用实例
09-10
单词计数示例是MapReduce的一个典型应用，其基本思想是统计文本中每个单词出现的次数。在MongoDB中，首先需要准备好待处理的文档数据，这些文档通常存储在一个集合中。例如，向集合中插入一些包含句子的文档： ```...
10、Mapreduce的一些场景
weixin_34040079的博客
10-29 266
2019独角兽企业重金招聘Python工程师标准>>> ...
mapreduce mapreduce mapreduce
06-03
mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce mapreduce
MapReduce 2.0应用场景、原理与基本架构
yunpiao123456的专栏
07-05 5140
现介绍计算框架MapReduce。MapReduce一个应用场景是有大量文件，里面存储了单词， 且一个单词占一行 。执行任务是如何统计每个单词出现的次数？ 类似应用场景有搜索引擎中，统计最流行的K个搜索词以及统计搜索词频率，帮助优化搜索词提示 。         MapReduce将作业的整个运行过程分为两个阶段 ：Map阶段和Reduce阶段          Map阶段由一定数量的Map
MapReduce(三) 典型场景（一）
weixin_30877755的博客
04-17 76
一、mapreduce多job串联 1、需求 一个稍复杂点的处理逻辑往往需要多个 mapreduce 程序串联处理，多 job 的串联可以借助mapreduce 框架的 JobControl 实现 2、实例 以下有两个 MapReduce 任务，分别是 Flow 的 SumMR 和 SortMR，其中有依赖关系： SumMR的输出是SortMR的输入，所以Sor...
hadoop学习笔记二_MapReduce应用场景、原理、基本架构
画夜的专栏
12-16 1147
MapReduce应用场景  MapReduce特点：易于变成；良好的扩展性；高容错性；适合PB级以上海量数据的离线处理 不适合：   实时计算     像MySQL一样，在毫秒级或者在秒级内返回结果   流式计算     MapReduce的输入数据集是静态的，不能动态变化     MapReduce自身的设计特点决定了数据远必须是静态的   DAG计算      多个应用程序
MapReduce 2.0应用场景、原理与基本架构 | mapreduce顺序图 + mapreduce动图
titer1的专栏
04-08 1988
MapReduce基本原理  MapReduce编程模型  MapReduce架构  MapReduce任务调度器  MapReduce应用场景 mapreduce顺序图 + mapreduce动图
MapReduce(一)
weixin_34097242的博客
12-19 179
分布式并行编程框架 特点： MapReduce将复杂的、运行于大规模集群上的并行计算过程高度地抽象到了两个函数：Map和Reduce•编程容易，不需要掌握分布式并行编程细节，也可以很容易把自己的程序运行在分布式系统上，完成海量数据的计算； •MapReduce采用“分而治之”策略，一个存储在分布式文件系统中的大规模数据集，会被...
Mapreduce
xiaoxiao______的博客
08-18 131
Mapreduce是什么？有什么优点？为什么要学？ 优点
mapreduce
qzc_root的博客
04-20 109
MapReduce介绍 MapReduce的思想核心是分而治之，适用于大量复杂的任务处理场景（大规模数据处理场景） map负责分，把负责的任务分解为若干个简单的任务来并行处理，可以进行拆分的前提是这些小任务可以并行计算，彼此之间几乎没有依赖关心。 reduce负责合，对map阶段的结果进行全局汇总 需求：a.txt 300M统计文件中每个单词出现的次数 在实际应用中，不一定只有一个reduce，不同的reduce汇总不同类型的数据。 MapReduce设计构思 MapReduce是一个分布式运算程序的编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值