Hadoop—MapReduce练习（数据去重、数据排序、平均成绩、倒排索引）

1. wordcount程序

先以简单的wordcount为例。

Mapper：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.wordcount;  
   
 import java.io.IOException;  
   
 import org.apache.commons.lang.StringUtils;  
 import org.apache.hadoop.io.IntWritable;  
 import org.apache.hadoop.io.LongWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Mapper;  
   
 //4个泛型中，前两个是指定mapper输入数据的类型，KEYIN是输入的key的类型，VALUEIN是输入的value的类型  
 //map 和 reduce 的数据输入输出都是以 key-value对的形式封装的  
 //默认情况下，Map框架传递给我们的mapper的输入数据中，key是要处理的文本中一行的起始偏移量（选用LongWritable），value是这一行的内容（VALUEIN选用Text）  
 //在wordcount中，经过mapper处理数据后，得到的是<单词，1>这样的结果，所以KEYOUT选用Text，VAULEOUT选用IntWritable  
 public class WCMapper extends Mapper {  
   
     // MapReduce框架每读一行数据就调用一次map方法  
     @Override  
     protected void map(LongWritable k1, Text v1,  
             Mapper.Context context)  
             throws IOException, InterruptedException {  
         // 将这一行的内容转换成string类型  
         String line = v1.toString();  
         // 对这一行的文本按特定分隔符切分  
         // String[] words = line.split(" ");  
         String[] words = StringUtils.split(line, " ");  
         // 遍历这个单词数组,输出为key-value形式 key：单词 value ： 1  
         for (String word : words) {  
             context.write(new Text(word), new IntWritable(1));  
         }  
   
     }  
   
 }  

Reducer：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.wordcount;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.IntWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 //经过mapper处理后的数据会被reducer拉取过来，所以reducer的KEYIN、VALUEIN和mapper的KEYOUT、VALUEOUT一致  
 //经过reducer处理后的数据格式为<单词，频数>,所以KEYOUT为Text，VALUEOUT为IntWritable  
 public class WCReducer extends Reducer {  
   
     // 当mapper框架将相同的key的数据处理完成后，reducer框架会将mapper框架输出的数据变成。  
     // 例如，在wordcount中会将mapper框架输出的所有变为，即这里的，然后将作为reduce函数的输入  
     @Override  
     protected void reduce(Text k2, Iterable v2s,  
             Reducer.Context context)  
             throws IOException, InterruptedException {  
         int count = 0;  
         // 遍历v2的list，进行累加求和  
         for (IntWritable v2 : v2s) {  
             count = v2.get();  
         }  
         // 输出这一个单词的统计结果  
         context.write(k2, new IntWritable(count));  
     }  
   
 }  

驱动类：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.wordcount;  
   
 import java.io.IOException;  
   
 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;  
   
 /** 
  * 用来描述一个特定的作业 比如，该作业使用哪个类作为逻辑处理中的map，哪个作为reduce 还可以指定该作业要处理的数据所在的路径 
  * 还可以指定改作业输出的结果放到哪个路径 
  *  
  * @author Oner.wv 
  * 
  */  
 public class WCRunner {  
     public static void main(String[] args) throws ClassNotFoundException,  
             InterruptedException, IOException {  
   
         Configuration conf = new Configuration();  
         Job wcJob = Job.getInstance(conf);  
   
         // 设置job所在的类在哪个jar包  
         wcJob.setJarByClass(WCRunner.class);  
   
         // 指定job所用的mappe类和reducer类  
         wcJob.setMapperClass(WCMapper.class);  
         wcJob.setReducerClass(WCReducer.class);  
   
         // 指定mapper输出类型和reducer输出类型  
         // 由于在wordcount中mapper和reducer的输出类型一致，  
         // 所以使用setOutputKeyClass和setOutputValueClass方法可以同时设定mapper和reducer的输出类型  
         // 如果mapper和reducer的输出类型不一致时，可以使用setMapOutputKeyClass和setMapOutputValueClass单独设置mapper的输出类型  
         // wcJob.setMapOutputKeyClass(Text.class);  
         // wcJob.setMapOutputValueClass(IntWritable.class);  
         wcJob.setOutputKeyClass(Text.class);  
         wcJob.setOutputValueClass(IntWritable.class);  
   
         // 指定job处理的数据路径  
         FileInputFormat.setInputPaths(wcJob, new Path(  
                 "hdfs://master:9000/user/exe_mapreduce/wordcount/input"));  
         // 指定job处理数据输出结果的路径  
         FileOutputFormat.setOutputPath(wcJob, new Path(  
                 "hdfs://master:9000/user/exe_mapreduce/wordcount/output"));  
   
         // 将job提交给集群运行  
         wcJob.waitForCompletion(true);  
     }  
 }  

2. 统计手机流量信息

从下面的数据中的得到每个手机号的上行流量、下行流量、总流量。

源数据：

[html]  view plain
 copy
 
 1363157985066   13726230503 00-FD-07-A4-72-B8:CMCC  120.196.100.82  i02.c.aliimg.com        24  27  2481    24681   200  
 1363157995052   13826544101 5C-0E-8B-C7-F1-E0:CMCC  120.197.40.4            4   0   264 0   200  
 1363157991076   13926435656 20-10-7A-28-CC-0A:CMCC  120.196.100.99          2   4   132 1512    200  
 1363154400022   13926251106 5C-0E-8B-8B-B1-50:CMCC  120.197.40.4            4   0   240 0   200  
 1363157993044   18211575961 94-71-AC-CD-E6-18:CMCC-EASY 120.196.100.99  iface.qiyi.com  视频网站    15  12  1527    2106    200  
 1363157995074   84138413    5C-0E-8B-8C-E8-20:7DaysInn  120.197.40.4    122.72.52.12        20  16  4116    1432    200  
 1363157993055   13560439658 C4-17-FE-BA-DE-D9:CMCC  120.196.100.99          18  15  1116    954 200  
 1363157995033   15920133257 5C-0E-8B-C7-BA-20:CMCC  120.197.40.4    sug.so.360.cn   信息安全    20  20  3156    2936    200  
 1363157983019   13719199419 68-A1-B7-03-07-B1:CMCC-EASY 120.196.100.82          4   0   240 0   200  
 1363157984041   13660577991 5C-0E-8B-92-5C-20:CMCC-EASY 120.197.40.4    s19.cnzz.com    站点统计    24  9   6960    690 200  
 1363157973098   15013685858 5C-0E-8B-C7-F7-90:CMCC  120.197.40.4    rank.ie.sogou.com   搜索引擎    28  27  3659    3538    200  
 1363157986029   15989002119 E8-99-C4-4E-93-E0:CMCC-EASY 120.196.100.99  www.umeng.com   站点统计    3   3   1938    180 200  
 1363157992093   13560439658 C4-17-FE-BA-DE-D9:CMCC  120.196.100.99          15  9   918 4938    200  
 1363157986041   13480253104 5C-0E-8B-C7-FC-80:CMCC-EASY 120.197.40.4            3   3   180 180 200  
 1363157984040   13602846565 5C-0E-8B-8B-B6-00:CMCC  120.197.40.4    2052.flash2-http.qq.com 综合门户    15  12  1938    2910    200  
 1363157995093   13922314466 00-FD-07-A2-EC-BA:CMCC  120.196.100.82  img.qfc.cn      12  12  3008    3720    200  
 1363157982040   13502468823 5C-0A-5B-6A-0B-D4:CMCC-EASY 120.196.100.99  y0.ifengimg.com 综合门户    57  102 7335    110349  200  
 1363157986072   18320173382 84-25-DB-4F-10-1A:CMCC-EASY 120.196.100.99  input.shouji.sogou.com  搜索引擎    21  18  9531    2412    200  
 1363157990043   13925057413 00-1F-64-E1-E6-9A:CMCC  120.196.100.55  t3.baidu.com    搜索引擎    69  63  11058   48243   200  
 1363157988072   13760778710 00-FD-07-A4-7B-08:CMCC  120.196.100.82          2   2   120 120 200  
 1363157985066   13726238888 00-FD-07-A4-72-B8:CMCC  120.196.100.82  i02.c.aliimg.com        24  27  2481    24681   200  
 1363157993055   13560436666 C4-17-FE-BA-DE-D9:CMCC  120.196.100.99          18  15  1116    954 200  

数据格式为：

想要的到的数据格式为：

[html]  view plain
 copy
 
 手机号 上行流量    下行流量    总流量  
 13726230503     2481    24681   27162  
 13826544101     264     0   264  
 13926435656     132     1512    1644  
 ...             ...     ...  

2.1 引入和Hadoop序列化机制相关的mapreduce

由于源数据中每一个手机号可能存在多条上网记录，最后要得到的输出格式是一个手机号的所有上行流量、下行流量和总流量。所以可以考虑利用MapReduce框架的特性，将每个手机号作为map的输出key，该手机号上网信息作为map的输出value，经过shuffle，则在reduce端接收到一个，其中，key手机号，value-list为该手机号所对应的一些上网信息的集合。这里有一个问题，由于map和reduce输入输出都为key-value键值对形式，所以必须将手机的上网信息（上行流量、下行流量）封装成一个Bean类，将这个类作为value。

由于数据需要在不同的节点间进行网络传输，所以Bean类必须实现序列化和反序列化，Hadoop提供了一套序列化机制（实现Writable接口）

FlowBean:

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.flowsum;  
   
 import java.io.DataInput;  
 import java.io.DataOutput;  
 import java.io.IOException;  
   
 import org.apache.hadoop.io.Writable;  
   
 public class FlowBean implements Writable {  
   
     private String phoneNB;  
     private long up_flow;  
     private long down_flow;  
     private long sum_flow;  
   
     // 在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数  
     public FlowBean() {  
     }  
   
     // 为了对象数据的初始化方便，加入一个带参的构造函数  
     public FlowBean(String phoneNB, long up_flow, long down_flow) {  
         this.phoneNB = phoneNB;  
         this.up_flow = up_flow;  
         this.down_flow = down_flow;  
         this.sum_flow = up_flow + down_flow;  
     }  
   
     // 将对象的数据序列化到流中  
     @Override  
     public void write(DataOutput out) throws IOException {  
         out.writeUTF(phoneNB);  
         out.writeLong(up_flow);  
         out.writeLong(down_flow);  
         out.writeLong(sum_flow);  
     }  
   
     // 从流中反序列化出对象的数据  
     // 从数据流中读出对象字段时，必须跟序列化时的顺序保持一致  
     @Override  
     public void readFields(DataInput in) throws IOException {  
         this.phoneNB = in.readUTF();  
         this.up_flow = in.readLong();  
         this.down_flow = in.readLong();  
         this.sum_flow = in.readLong();  
     }  
   
     public String getPhoneNB() {  
         return phoneNB;  
     }  
   
     public void setPhoneNB(String phoneNB) {  
         this.phoneNB = phoneNB;  
     }  
   
     public long getUp_flow() {  
         return up_flow;  
     }  
   
     public void setUp_flow(long up_flow) {  
         this.up_flow = up_flow;  
     }  
   
     public long getDown_flow() {  
         return down_flow;  
     }  
   
     public void setDown_flow(long down_flow) {  
         this.down_flow = down_flow;  
     }  
   
     public long getSum_flow() {  
         return sum_flow;  
     }  
   
     public void setSum_flow(long sum_flow) {  
         this.sum_flow = sum_flow;  
     }  
   
     @Override  
     public String toString() {  
         return "" + up_flow + "\t" + down_flow + "\t" + sum_flow;  
     }  
 }  

FlowSumMapper:

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.flowsum;  
   
 import java.io.IOException;  
   
 import org.apache.commons.lang.StringUtils;  
 import org.apache.hadoop.io.LongWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Mapper;  
   
 public class FlowSumMapper extends Mapper {  
       
     @Override  
     protected void map(LongWritable k1, Text v1,  
             Mapper.Context context)  
             throws IOException, InterruptedException {  
         // 一行数据  
         String line = v1.toString();  
         // 切分数据  
         String[] fields = StringUtils.split(line, "\t");  
         // 得到想要的手机号、上行流量、下行流量  
         String phoneNB = fields[1];  
         long up_flow = Long.parseLong(fields[7]);  
         long down_flow = Long.parseLong(fields[8]);  
         // 封装数据为kv并输出  
         context.write(new Text(phoneNB), new FlowBean(phoneNB, up_flow,  
                 down_flow));  
   
     }  
 }  

FlowSumReducer:

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.flowsum;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 public class FlowSumReducer extends Reducer {  
   
     // 框架每传递一组数据<1387788654,{flowbean,flowbean,flowbean,flowbean.....}>调用一次我们的reduce方法  
     // reduce中的业务逻辑就是遍历values，然后进行累加求和再输出  
     @Override  
     protected void reduce(Text k2, Iterable v2s,  
             Reducer.Context context)  
             throws IOException, InterruptedException {  
         long up_flow = 0;  
         long down_flow = 0;  
   
         for (FlowBean v2 : v2s) {  
             up_flow += v2.getUp_flow();  
             down_flow += v2.getDown_flow();  
         }  
   
         context.write(k2, new FlowBean(k2.toString(), up_flow, down_flow));  
     }  
 }  

FlowSumRunner:

Job描述和提交的规范写法如下：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.flowsum;  
   
 import org.apache.hadoop.conf.Configuration;  
 import org.apache.hadoop.conf.Configured;  
 import org.apache.hadoop.fs.Path;  
 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 org.apache.hadoop.util.Tool;  
 import org.apache.hadoop.util.ToolRunner;  
   
 //这是job描述和提交类的规范写法  
 public class FlowSumRunner extends Configured implements Tool {  
   
     public static void main(String[] args) throws Exception {  
         int res = ToolRunner  
                 .run(new Configuration(), new FlowSumRunner(), args);  
         System.exit(res);  
     }  
   
     @Override  
     public int run(String[] args) throws Exception {  
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(FlowSumRunner.class);  
   
         job.setMapperClass(FlowSumMapper.class);  
         job.setReducerClass(FlowSumReducer.class);  
   
         // job.setMapOutputKeyClass(Text.class);  
         // job.setMapOutputValueClass(FlowBean.class);  
   
         job.setOutputKeyClass(Text.class);  
         job.setOutputValueClass(FlowBean.class);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         FileOutputFormat.setOutputPath(job, new Path(args[1]));  
   
         // 执行成功，返回0，否则返回1  
         return job.waitForCompletion(true) ? 0 : 1;  
     }  
 }  

打成jar包后运行：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop jar flowcount.jar cn.nuc.hadoop.mapreduce.flowsum.FlowSumRunner /user/exe_mapreduce/flowcount/input /user/exe_mapreduce/flowcount/output  

查看结果：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/output/part-r-00000  
 13480253104 180 200 380  
 13502468823 102 7335    7437  
 13560436666 954 200 1154  
 13560439658 5892    400 6292  
 13602846565 12  1938    1950  
 13660577991 9   6960    6969  
 13719199419 0   200 200  
 13726230503 2481    24681   27162  
 13726238888 2481    24681   27162  
 13760778710 120 200 320  
 13826544101 0   200 200  
 13922314466 3008    3720    6728  
 13925057413 63  11058   11121  
 13926251106 0   200 200  
 13926435656 1512    200 1712  
 15013685858 27  3659    3686  
 15920133257 20  3156    3176  
 15989002119 3   1938    1941  
 18211575961 12  1527    1539  
 18320173382 18  9531    9549  
 84138413    4116    1432    5548  

2.2 引入hadoop自定义排序

从上面得到的结果可以看出来，hadoop默认将结果按照mapper的输出按照key来进行排序，如果我们想要自定义排序结果（比如按照总流量从高到低排序），该如何做呢？了解shuffle的都知道，shuffle过程中，会将map的输出结果按照key进行排序，所以只需要将FlowBean作为map输出的key值，前提是FlowBean实现了Comparable接口。在hadoop中既实现Writable接口，又实现Comparable接口，可以简写为实现了WritableComparable接口。

FlowBean：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.flowsort;  
   
 import java.io.DataInput;  
 import java.io.DataOutput;  
 import java.io.IOException;  
   
 import org.apache.hadoop.io.WritableComparable;  
   
 public class FlowBean implements WritableComparable {  
   
     private String phoneNB;  
     private long up_flow;  
     private long down_flow;  
     private long sum_flow;  
   
     // 在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数  
     public FlowBean() {  
     }  
   
     // 为了对象数据的初始化方便，加入一个带参的构造函数  
     public FlowBean(String phoneNB, long up_flow, long down_flow) {  
         this.phoneNB = phoneNB;  
         this.up_flow = up_flow;  
         this.down_flow = down_flow;  
         this.sum_flow = up_flow + down_flow;  
     }  
   
     // 将对象的数据序列化到流中  
     @Override  
     public void write(DataOutput out) throws IOException {  
         out.writeUTF(phoneNB);  
         out.writeLong(up_flow);  
         out.writeLong(down_flow);  
         out.writeLong(sum_flow);  
     }  
   
     // 从流中反序列化出对象的数据  
     // 从数据流中读出对象字段时，必须跟序列化时的顺序保持一致  
     @Override  
     public void readFields(DataInput in) throws IOException {  
         this.phoneNB = in.readUTF();  
         this.up_flow = in.readLong();  
         this.down_flow = in.readLong();  
         this.sum_flow = in.readLong();  
     }  
   
     public String getPhoneNB() {  
         return phoneNB;  
     }  
   
     public void setPhoneNB(String phoneNB) {  
         this.phoneNB = phoneNB;  
     }  
   
     public long getUp_flow() {  
         return up_flow;  
     }  
   
     public void setUp_flow(long up_flow) {  
         this.up_flow = up_flow;  
     }  
   
     public long getDown_flow() {  
         return down_flow;  
     }  
   
     public void setDown_flow(long down_flow) {  
         this.down_flow = down_flow;  
     }  
   
     public long getSum_flow() {  
         return sum_flow;  
     }  
   
     public void setSum_flow(long sum_flow) {  
         this.sum_flow = sum_flow;  
     }  
   
     @Override  
     public String toString() {  
         return "" + up_flow + "\t" + down_flow + "\t" + sum_flow;  
     }  
   
     // 实现Comparable接口，需要复写compareTo方法  
     @Override  
     public int compareTo(FlowBean o) {  
         return this.sum_flow > o.sum_flow ? -1 : 1;  
     }  
 }  

SortMapReduce：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.flowsort;  
   
 import java.io.IOException;  
   
 import org.apache.commons.lang.StringUtils;  
 import org.apache.hadoop.conf.Configuration;  
 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.Reducer;  
 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
   
 public class SortMapReduce {  
   
     public static class SortMapper extends  
             Mapper {  
         @Override  
         protected void map(  
                 LongWritable k1,  
                 Text v1,  
                 Mapper.Context context)  
                 throws IOException, InterruptedException {  
               
             String line = v1.toString();  
             String[] fields = StringUtils.split(line, "\t");  
   
             String phoneNB = fields[0];  
             long up_flow = Long.parseLong(fields[1]);  
             long down_flow = Long.parseLong(fields[2]);  
   
             context.write(new FlowBean(phoneNB, up_flow, down_flow),  
                     NullWritable.get());  
         }  
     }  
   
     public static class SortReducer extends  
             Reducer {  
         @Override  
         protected void reduce(FlowBean k2, Iterable v2s,  
                 Reducer.Context context)  
                 throws IOException, InterruptedException {  
             String phoneNB = k2.getPhoneNB();  
             context.write(new Text(phoneNB), k2);  
         }  
     }  
   
     public static void main(String[] args) throws IOException,  
             ClassNotFoundException, InterruptedException {  
   
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(SortMapReduce.class);  
   
         job.setMapperClass(SortMapper.class);  
         job.setReducerClass(SortReducer.class);  
   
         job.setMapOutputKeyClass(FlowBean.class);  
         job.setMapOutputValueClass(NullWritable.class);  
   
         job.setOutputKeyClass(Text.class);  
         job.setOutputValueClass(FlowBean.class);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         FileOutputFormat.setOutputPath(job, new Path(args[1]));  
   
         System.exit(job.waitForCompletion(true) ? 0 : 1);  
     }  
 }  

打成jar包，运行：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop jar flowcountsort.jar cn.nuc.hadoop.mapreduce.flowsort.SortMapReduce /user/exe_mapreduce/flowcount/output /user/exe_mapreduce/flowcount/sortout/  

查看结果：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/sortout/part-r-00000  
 13726238888 2481    24681   27162  
 13726230503 2481    24681   27162  
 13925057413 63  11058   11121  
 18320173382 18  9531    9549  
 13502468823 102 7335    7437  
 13660577991 9   6960    6969  
 13922314466 3008    3720    6728  
 13560439658 5892    400 6292  
 84138413    4116    1432    5548  
 15013685858 27  3659    3686  
 15920133257 20  3156    3176  
 13602846565 12  1938    1950  
 15989002119 3   1938    1941  
 13926435656 1512    200 1712  
 18211575961 12  1527    1539  
 13560436666 954 200 1154  
 13480253104 180 200 380  
 13760778710 120 200 320  
 13826544101 0   200 200  
 13926251106 0   200 200  
 13719199419 0   200 200  

2.3 引入Hadoop分区功能

如果信息特别多，想要将最后的结果分别存放在不通过的文件中，该怎么办呢？可以使用Hadoop提供的Partitioner函数，hadoop默认使用HashPartitioner。可以查看下Hadoop源码：

[java]  view plain
 copy
 
 public class HashPartitioner extends Partitioner {  
   
   /** Use {@link Object#hashCode()} to partition. */  
   public int getPartition(K key, V value,  
                           int numReduceTasks) {  
     return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;  
   }  
   
 }  

HashPartitioner是处理Mapper任务输出的，getPartition()方法有三个形参，key、value分别指的是Mapper任务的输出，numReduceTasks指的是设置的Reducer任务数量，默认值是1。那么任何整数与1相除的余数肯定是0。也就是说getPartition(…)方法的返回值总是0。也就是Mapper任务的输出总是送给一个Reducer任务，最终只能输出到一个文件中。据此分析，如果想要最终输出到多个文件中，在Mapper任务中对数据应该划分到多个区中。

AreaPartitioner

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.areapartition;  
   
 import java.util.HashMap;  
   
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Partitioner;  
   
 public class AreaPartitioner extends Partitioner {  
   
     private static HashMap areaMap = new HashMap<>();  
   
     static {  
         areaMap.put("135", 0);  
         areaMap.put("136", 1);  
         areaMap.put("137", 2);  
         areaMap.put("138", 3);  
         areaMap.put("139", 4);  
     }  
   
     @Override  
     public int getPartition(Text key, FlowBean value, int numPartitions) {  
         // 从key中拿到手机号，查询手机归属地字典，不同的省份返回不同的组号  
         Integer areCoder = areaMap.get(key.toString().substring(0, 3));  
         if (areCoder == null) {  
             areCoder = 5;  
         }  
         return areCoder;  
     }  
   
 }  

FlowBean

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.areapartition;  
   
 import java.io.DataInput;  
 import java.io.DataOutput;  
 import java.io.IOException;  
   
 import org.apache.hadoop.io.WritableComparable;  
   
 public class FlowBean implements WritableComparable {  
   
     private String phoneNB;  
     private long up_flow;  
     private long down_flow;  
     private long sum_flow;  
   
     // 在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数  
     public FlowBean() {  
     }  
   
     // 为了对象数据的初始化方便，加入一个带参的构造函数  
     public FlowBean(String phoneNB, long up_flow, long down_flow) {  
         this.phoneNB = phoneNB;  
         this.up_flow = up_flow;  
         this.down_flow = down_flow;  
         this.sum_flow = up_flow + down_flow;  
     }  
   
     // 将对象的数据序列化到流中  
     @Override  
     public void write(DataOutput out) throws IOException {  
         out.writeUTF(phoneNB);  
         out.writeLong(up_flow);  
         out.writeLong(down_flow);  
         out.writeLong(sum_flow);  
     }  
   
     // 从流中反序列化出对象的数据  
     // 从数据流中读出对象字段时，必须跟序列化时的顺序保持一致  
     @Override  
     public void readFields(DataInput in) throws IOException {  
         this.phoneNB = in.readUTF();  
         this.up_flow = in.readLong();  
         this.down_flow = in.readLong();  
         this.sum_flow = in.readLong();  
     }  
   
     public String getPhoneNB() {  
         return phoneNB;  
     }  
   
     public void setPhoneNB(String phoneNB) {  
         this.phoneNB = phoneNB;  
     }  
   
     public long getUp_flow() {  
         return up_flow;  
     }  
   
     public void setUp_flow(long up_flow) {  
         this.up_flow = up_flow;  
     }  
   
     public long getDown_flow() {  
         return down_flow;  
     }  
   
     public void setDown_flow(long down_flow) {  
         this.down_flow = down_flow;  
     }  
   
     public long getSum_flow() {  
         return sum_flow;  
     }  
   
     public void setSum_flow(long sum_flow) {  
         this.sum_flow = sum_flow;  
     }  
   
     @Override  
     public String toString() {  
         return "" + up_flow + "\t" + down_flow + "\t" + sum_flow;  
     }  
   
     // 实现Comparable接口，需要复写compareTo方法  
     @Override  
     public int compareTo(FlowBean o) {  
         return this.sum_flow > o.sum_flow ? -1 : 1;  
     }  
 }  

FlowSumArea

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.areapartition;  
   
 import java.io.IOException;  
   
 import org.apache.commons.lang.StringUtils;  
 import org.apache.hadoop.conf.Configuration;  
 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.Mapper;  
 import org.apache.hadoop.mapreduce.Reducer;  
 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
   
 /** 
  * 对流量原始日志进行流量统计，将不同省份的用户统计结果输出到不同文件 需要自定义改造两个机制： 1、改造分区的逻辑，自定义一个partitioner 
  * 2、自定义reduer task的并发任务数 
  *  
  * @author [email protected] 
  * 
  */  
 public class FlowSumArea {  
   
     public static class FlowSumAreaMapper extends  
             Mapper {  
   
         @Override  
         protected void map(LongWritable k1, Text v1,  
                 Mapper.Context context)  
                 throws IOException, InterruptedException {  
             String line = v1.toString();  
             String[] fields = StringUtils.split(line, "\t");  
   
             String phoneNB = fields[1];  
             Long up_flow = Long.parseLong(fields[7]);  
             Long down_flow = Long.parseLong(fields[8]);  
   
             context.write(new Text(phoneNB), new FlowBean(phoneNB, up_flow,  
                     down_flow));  
         }  
     }  
   
     public static class FlowSumAreaReducer extends  
             Reducer {  
   
         @Override  
         protected void reduce(Text k2, Iterable v2s,  
                 Reducer.Context context)  
                 throws IOException, InterruptedException {  
             long up_flow = 0;  
             long down_flow = 0;  
             for (FlowBean v2 : v2s) {  
                 up_flow += v2.getUp_flow();  
                 down_flow += v2.getDown_flow();  
             }  
             context.write(new Text(k2), new FlowBean(k2.toString(), up_flow,  
                     down_flow));  
         }  
     }  
   
     public static void main(String[] args) throws IOException,  
             ClassNotFoundException, InterruptedException {  
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(FlowSumArea.class);  
   
         job.setMapperClass(FlowSumAreaMapper.class);  
         job.setReducerClass(FlowSumAreaReducer.class);  
   
         // 定义分组逻辑类  
         job.setPartitionerClass(AreaPartitioner.class);  
   
         job.setOutputKeyClass(Text.class);  
         job.setOutputValueClass(FlowBean.class);  
   
         // 设定reducer的任务并发数,应该跟分组的数量保持一致  
         job.setNumReduceTasks(6);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         FileOutputFormat.setOutputPath(job, new Path(args[1]));  
           
         System.exit(job.waitForCompletion(true) ? 0 : 1);  
     }  
 }  

打包运行：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop jar area.jar cn.nuc.hadoop.mapreduce.areapartition.FlowSumArea /user/exe_mapreduce/flowcount/input /user/exe_mapreduce/flowcount/areaout  

查看结果：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop fs -ls /user/exe_mapreduce/flowcount/areaout/  
 Found 7 items  
 -rw-r--r--   3 hadoop supergroup          0 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/_SUCCESS  
 -rw-r--r--   3 hadoop supergroup         77 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/part-r-00000  
 -rw-r--r--   3 hadoop supergroup         49 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/part-r-00001  
 -rw-r--r--   3 hadoop supergroup        104 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/part-r-00002  
 -rw-r--r--   3 hadoop supergroup         22 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/part-r-00003  
 -rw-r--r--   3 hadoop supergroup        102 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/part-r-00004  
 -rw-r--r--   3 hadoop supergroup        172 2016-02-07 19:28 /user/exe_mapreduce/flowcount/areaout/part-r-00005  

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/areaout/part-r-00000  
 13502468823 102 7335    7437  
 13560436666 954 200 1154  
 13560439658 5892    400 6292  
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/areaout/part-r-00001  
 13602846565 12  1938    1950  
 13660577991 9   6960    6969  
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/areaout/part-r-00002  
 13719199419 0   200 200  
 13726230503 2481    24681   27162  
 13726238888 2481    24681   27162  
 13760778710 120 200 320  
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/areaout/part-r-00003  
 ^[[A13826544101 0   200 200  
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/areaout/part-r-00004  
 ^[[A13922314466 3008    3720    6728  
 13925057413 63  11058   11121  
 13926251106 0   200 200  
 13926435656 1512    200 1712  
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/flowcount/areaout/part-r-00005  
 13480253104 180 200 380  
 15013685858 27  3659    3686  
 15920133257 20  3156    3176  
 15989002119 3   1938    1941  
 18211575961 12  1527    1539  
 18320173382 18  9531    9549  
 84138413    4116    1432    5548  

3. 数据去重

“ 数据去重”主要是为了掌握和利用并行化思想来对数据进行有意义的筛选。统计大数据集上的数据种类个数、从网站日志中计算访问地等这些看似庞杂的任务都会涉及数据去重。下面就进入这个实例的 MapReduce 程序设计。

3.1 实例描述

对数据文件中的数据进行去重。数据文件中的每行都是一个数据。

样例输入如下所示：

file1:

[plain]  view plain
 copy
 
 2012-3-1 a  
 2012-3-2 b  
 2012-3-3 c  
 2012-3-4 d  
 2012-3-5 a  
 2012-3-6 b  
 2012-3-7 c  
 2012-3-3 c  

file2:

[plain]  view plain
 copy
 
 2012-3-1 b  
 2012-3-2 a  
 2012-3-3 b  
 2012-3-4 d  
 2012-3-5 a  
 2012-3-6 c  
 2012-3-7 d  
 2012-3-3 c  

样例输出如下：

[plain]  view plain
 copy
 
 2012-3-1 a  
 2012-3-1 b  
 2012-3-2 a  
 2012-3-2 b  
 2012-3-3 b  
 2012-3-3 c  
 2012-3-4 d  
 2012-3-5 a  
 2012-3-6 b  
 2012-3-6 c  
 2012-3-7 c  
 2012-3-7 d  

3.2 设计思路

数据去重的最终目标是让原始数据中出现次数超过一次的数据在输出文件中只出现一次。我们自然而然会想到将同一个数据的所有记录都交给一台 reduce 机器，无论这个数据出现多少次，只要在最终结果中输出一次就可以了。具体就是 reduce 的输入应该以数据作为 key，而对 value-list 则没有要求。当 reduce 接收到一个时就直接将 key复制到输出的 key 中，并将 value 设置成空值。

在 MapReduce 流程中， map 的输出经过 shuffle 过程聚集成后会交给 reduce。所以从设计好的 reduce 输入可以反推出 map 的输出 key 应为数据， value任意。继续反推， map 输出数据的 key 为数据，而在这个实例中每个数据代表输入文件中的一行内容，所以 map 阶段要完成的任务就是在采用 Hadoop 默认的作业输入方式之后，将value 设置为 key，并直接输出（输出中的 value 任意）。 map 中的结果经过 shuffle 过程之后交给 reduce。 reduce 阶段不会管每个 key 有多少个 value，它直接将输入的 key 复制为输出的 key，并输出就可以了（输出中的 value 被设置成空了）。

3.3 程序代码

DedupMapper：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.dedup;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.LongWritable;  
 import org.apache.hadoop.io.NullWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Mapper;  
   
 public class DedupMapper extends Mapper {  
   
     private static Text field = new Text();  
   
     @Override  
     protected void map(LongWritable key, Text value, Context context)  
             throws IOException, InterruptedException {  
   
         field = value;  
         context.write(field, NullWritable.get());  
   
     }  
 }  

DedupReducer：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.dedup;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.NullWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 public class DedupReducer extends  
         Reducer {  
     @Override  
     protected void reduce(Text key, Iterable values,  
             Context context) throws IOException, InterruptedException {  
   
         context.write(key, NullWritable.get());  
   
     }  
 }  

DedupRunner：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.dedup;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.conf.Configuration;  
 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.FileInputFormat;  
 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
   
 public class DedupRunner {  
     public static void main(String[] args) throws IOException,  
             ClassNotFoundException, InterruptedException {  
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(DedupRunner.class);  
   
         job.setMapperClass(DedupMapper.class);  
         job.setReducerClass(DedupReducer.class);  
   
         job.setOutputKeyClass(Text.class);  
         job.setOutputValueClass(NullWritable.class);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         FileOutputFormat.setOutputPath(job, new Path(args[1]));  
   
         job.waitForCompletion(true);  
     }  
 }  

打成jar包后运行：

[sql]  view plain
 copy
 
 [hadoop@master ~]$  hadoop jar dedup.jar cn.nuc.hadoop.mapreduce.dedup.DedupRunner /user/exe_mapreduce/dedup/input /user/exe_mapreduce/dedup/out  

查看结果：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/dedup/output/part-r-00000  
 2012-3-1 a  
 2012-3-1 b  
 2012-3-2 a  
 2012-3-2 b  
 2012-3-3 b  
 2012-3-3 c  
 2012-3-4 d  
 2012-3-5 a  
 2012-3-6 b  
 2012-3-6 c  
 2012-3-7 c  
 2012-3-7 d  

4. 数据排序

“ 数据排序”是许多实际任务执行时要完成的第一项工作，比如学生成绩评比、数据建立索引等。这个实例和数据去重类似，都是先对原始数据进行初步处理，为进一步的数据操作打好基础。下面进入这个示例。

4.1 实例描述

对输入文件中数据进行排序。输入文件中的每行内容均为一个数字，即一个数据。要求在输出中每行有两个间隔的数字，其中，第一个代表原始数据在原始数据集中的位次，第二个代表原始数据。

样例输入：

file1：

[plain]  view plain
 copy
 
 2  
 32  
 654  
 32  
 15  
 756  
 65223  

file2：

[plain]  view plain
 copy
 
 5956  
 22  
 650  
 92  

file3：

[plain]  view plain
 copy
 
 26  
 54  
 6  

样例输出：

[plain]  view plain
 copy
 
 1 2  
 2 6  
 3 15  
 4 22  
 5 26  
 6 32  
 7 32  
 8 54  
 9 92  
 10 650  
 11 654  
 12 756  
 13 5956  
 14 65223  

4.2 设计思路

这个实例仅仅要求对输入数据进行排序，熟悉 MapReduce 过程的读者会很快想到在 MapReduce 过程中就有排序，是否可以利用这个默认的排序，而不需要自己再实现具体的排序呢？答案是肯定的。

但是在使用之前首先需要了解它的默认排序规则。它是按照 key 值进行排序的，如果 key 为封装 int 的 IntWritable 类型，那么 MapReduce 按照数字大小对 key 排序，如果 key 为封装为 String 的 Text 类型，那么 MapReduce 按照字典顺序对字符串排序。

了解了这个细节，我们就知道应该使用封装 int 的 IntWritable 型数据结构了。也就是在 map 中将读入的数据转化成 IntWritable 型，然后作为 key 值输出（ value 任意）。 reduce 拿到之后，将输入的 key 作为 value 输出，并根据 value-list 中元素的个数决定输出的次数。输出的 key（即代码中的 linenum）是一个全局变量，它统计当前 key 的位次。需要注意的是这个程序中没有配置 Combiner，也就是在 MapReduce 过程中不使用 Combiner。这主要是因为使用 map 和 reduce 就已经能够完成任务了。

4.3 程序代码

SortMapper：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.sort;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.IntWritable;  
 import org.apache.hadoop.io.LongWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Mapper;  
   
 //map将输入中的 value化成 IntWritable类型，作为输出的 key  
 public class SortMapper extends  
         Mapper {  
   
     private static IntWritable data = new IntWritable();  
     private static final IntWritable one = new IntWritable(1);  
   
     @Override  
     protected void map(LongWritable key, Text value, Context context)  
             throws IOException, InterruptedException {  
         String line = value.toString();  
         data.set(Integer.parseInt(line));  
         context.write(data, one);  
     }  
 }  

SortReducer：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.sort;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.IntWritable;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 //reduce 将输入中的 key 复制到输出数据的 key 上，  
 //然后根据输入的 value‐list 中元素的个数决定 key 的输出次数  
 //用全局linenumber来代表key的位次  
 public class SortReducer extends  
         Reducer {  
   
     private static IntWritable linenumber = new IntWritable(1);  
   
     @Override  
     protected void reduce(IntWritable key, Iterable values,  
             Context context) throws IOException, InterruptedException {  
         for (IntWritable value : values) {  
             context.write(linenumber, key);  
             linenumber.set(linenumber.get() + 1);  
             // linenumber=new IntWritable(linenumber.get()+1);  
         }  
   
     }  
 }  

SotrRunner：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.sort;  
   
 import java.io.IOException;  
   
 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;  
   
 public class SortRunner {  
     public static void main(String[] args) throws IllegalArgumentException,  
             IOException, ClassNotFoundException, InterruptedException {  
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(SortRunner.class);  
   
         job.setMapperClass(SortMapper.class);  
         job.setReducerClass(SortReducer.class);  
   
         job.setOutputKeyClass(IntWritable.class);  
         job.setOutputValueClass(IntWritable.class);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         FileOutputFormat.setOutputPath(job, new Path(args[1]));  
   
         job.waitForCompletion(true);  
     }  
 }  

打成jar包运行：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop jar sort.jar cn.nuc.hadoop.mapreduce.sort.SortRunner /user/exe_mapreduce/sort/input /user/exe_mapreduce/sort/output  

查看结果：

[sql]  view plain
 copy
 
 [hadoop@master input]$ hadoop fs -cat /user/exe_mapreduce/sort/output/part-r-00000  
 1   2  
 2   6  
 3   15  
 4   22  
 5   26  
 6   32  
 7   32  
 8   54  
 9   92  
 10  650  
 11  654  
 12  756  
 13  5956  
 14  65223  

5 平均成绩

“平均成绩”主要目的还是在重温经典“ WordCount”例子，可以说是在基础上的微变化版，该实例主要就是实现一个计算学生平均成绩的例子。

5.1 实例描述

对输入文件中数据进行就算学生平均成绩。输入文件中的每行内容均为一个学生的姓名和他相应的成绩，如果有多门学科，则每门学科为一个文件。要求在输出中每行有两个间隔的数据，其中，第一个代表学生的姓名，第二个代表其平均成绩。

样本输入：

math：

[plain]  view plain
 copy
 
 张三 88  
 李四 99  
 王五 66  
 赵六 77  

china：

[plain]  view plain
 copy
 
 张三 78  
 李四 89  
 王五 96  
 赵六 67  

english：

[plain]  view plain
 copy
 
 张三 80  
 李四 82  
 王五 84  
 赵六 86  

样本输出：

[plain]  view plain
 copy
 
 张三 82  
 李四 90  
 王五 82  
 赵六 76  

5.2 设计思路

计算学生平均成绩是一个仿“ WordCount”例子，用来重温一下开发 MapReduce 程序的流程。程序包括两部分的内容： Map 部分和 Reduce 部分，分别实现了 map 和 reduce 的功能。

Map 处理的是一个纯文本文件，文件中存放的数据时每一行表示一个学生的姓名和他相应一科成绩。 Mapper 处理的数据是由 InputFormat 分解过的数据集，其中 InputFormat 的作用是将数据集切割成小数据集 InputSplit，每一个 InputSlit 将由一个 Mapper 负责处理。此外，InputFormat 中还提供了一个 RecordReader 的实现，并将一个 InputSplit 解析成对提供给了 map 函数。 InputFormat 的默认值是 TextInputFormat，它针对文本文件，按行将文本切割成 InputSlit，并用 LineRecordReader 将 InputSplit 解析成对， key 是行在文本中的位置， value 是文件中的一行。

Map 的结果会通过 partion 分发到 Reducer， Reducer 做完 Reduce 操作后，将通过以格式 OutputFormat 输出。

Mapper 最终处理的结果对，会送到 Reducer 中进行合并，合并的时候，有相同 key 的键/值对则送到同一个 Reducer 上。 Reducer 是所有用户定制 Reducer 类地基础，它的输入是 key 和这个 key 对应的所有 value 的一个迭代器，同时还有 Reducer 的上下文。 Reduce 的结果由 Reducer.Context 的 write 方法输出到文件中。

5.3 程序代码

ScoreMapper：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.score;  
   
 import java.io.IOException;  
   
 import org.apache.commons.lang.StringUtils;  
 import org.apache.hadoop.io.IntWritable;  
 import org.apache.hadoop.io.LongWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Mapper;  
   
 public class ScoreMapper extends Mapper {  
   
     private static Text name = new Text();  
     private static IntWritable score = new IntWritable();  
   
     @Override  
     protected void map(LongWritable key, Text value, Context context)  
             throws IOException, InterruptedException {  
         String line = value.toString();  
         String[] fields = StringUtils.split(line, " ");  
         String strName = fields[0];//学生姓名  
         int strScore = Integer.parseInt(fields[1]);//学生单科成绩  
   
         name.set(strName);  
         score.set(strScore);  
         context.write(name, score);  
     }  
 }  

ScoreReducer：

[java]  view plain
 copy
 package cn.nuc.hadoop.mapreduce.score;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.IntWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 public class ScoreReducer extends Reducer {  
   
     private static IntWritable avg_score = new IntWritable();  
   
     @Override  
     protected void reduce(Text key, Iterable values,  
             Context context) throws IOException, InterruptedException {  
         int sum_score = 0;//统计总成绩  
         int count=0;//统计总的科目数  
         for (IntWritable score : values) {  
             count++;  
             sum_score += score.get();         
         }  
   
         avg_score.set(sum_score / count);  
         context.write(key, avg_score);  
     }  
 }  

ScoreRunner：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.score;  
   
 import java.io.IOException;  
   
 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;  
   
 public class ScoreRunner {  
     public static void main(String[] args) throws IOException,  
             ClassNotFoundException, InterruptedException {  
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(ScoreRunner.class);  
   
         job.setMapperClass(ScoreMapper.class);  
         job.setReducerClass(ScoreReducer.class);  
   
         job.setOutputKeyClass(Text.class);  
         job.setOutputValueClass(IntWritable.class);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         FileOutputFormat.setOutputPath(job, new Path(args[1]));  
   
         job.waitForCompletion(true);  
     }  
 }  

打成jar包执行：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop jar score.jar cn.nuc.hadoop.mapreduce.score.ScoreRunner /user/exe_mapreduce/score/input /user/exe_mapreduce/score/output  

查看结果：

[sql]  view plain
 copy
 
 [hadoop@master ~]$ hadoop fs -cat /user/exe_mapreduce/score/output/part-r-00000  
 张三  82  
 李四  90  
 王五  82  
 赵六  76  

6 倒排索引

“ 倒排索引”是文档检索系统中最常用的数据结构，被广泛地应用于全文搜索引擎。它主要是用来存储某个单词（或词组）在一个文档或一组文档中的存储位置的映射，即提供了一种根据内容来查找文档的方式。由于不是根据文档来确定文档所包含的内容，而是进行相反的操作，因而称为倒排索引（ Inverted Index）。

6.1 实例描述

通常情况下，倒排索引由一个单词（或词组）以及相关的文档列表组成，文档列表中的文档或者是标识文档的 ID 号，或者是指文档所在位置的 URL，如图 6.1-1 所示。

从图 6.1-1 可以看出，单词 1 出现在{文档 1，文档 4，文档 13， ……}中，单词 2 出现在{文档 3，文档 5，文档 15， ……}中，而单词 3 出现在{文档 1，文档 8，文档 20， ……} 中。在实际应用中，还需要给每个文档添加一个权值，用来指出每个文档与搜索内容的相关度，如图 6.1-2 所示。

最常用的是使用词频作为权重，即记录单词在文档中出现的次数。以英文为例，如图 6.1-3 所示，索引文件中的“ MapReduce”一行表示：“ MapReduce”这个单词在文本 T0 中出现过 1 次，T1 中出现过 1 次，T2 中出现过 2 次。当搜索条件为“ MapReduce”、“ is”、“ Simple” 时，对应的集合为： {T0， T1， T2}∩{T0， T1}∩{T0， T1}={T0， T1}，即文档 T0 和 T1 包含了所要索引的单词，而且只有 T0 是连续的。

更复杂的权重还可能要记录单词在多少个文档中出现过，以实现 TF-IDF（ Term Frequency-Inverse Document Frequency）算法，或者考虑单词在文档中的位置信息（单词是否出现在标题中，反映了单词在文档中的重要性）等。

样例输入如下所示。

file1：

[plain]  view plain
 copy
 
 MapReduce is simple  

file2：

[plain]  view plain
 copy
 
 MapReduce is powerful is simple  

file3：

[plain]  view plain
 copy
 
 Hello MapReduce bye MapReduce  

样例输出如下所示：

[plain]  view plain
 copy
 
 MapReduce file1.txt:1;file2.txt:1;file3.txt:2;  
 is file1.txt:1;file2.txt:2;  
 simple file1.txt:1;file2.txt:1;  
 powerful file2.txt:1;  
 Hello file3.txt:1;  
 bye file3.txt:1;  

6.2 设计思路

实现“ 倒排索引”只要关注的信息为：单词、文档 URL 及词频，如图 3-11 所示。但是在实现过程中，索引文件的格式与图 6.1-3 会略有所不同，以避免重写 OutPutFormat 类。下面根据 MapReduce 的处理过程给出倒排索引的设计思路。

1）Map过程

首先使用默认的 TextInputFormat 类对输入文件进行处理，得到文本中每行的偏移量及其内容。显然， Map 过程首先必须分析输入的对，得到倒排索引中需要的三个信息：单词、文档 URL 和词频，如图 6.2-1 所示。

这里存在两个问题：第一，对只能有两个值，在不使用 Hadoop 自定义数据类型的情况下，需要根据情况将其中两个值合并成一个值，作为 key 或 value 值；第二，通过一个 Reduce 过程无法同时完成词频统计和生成文档列表，所以必须增加一个 Combine 过程完成词频统计。

这里讲单词和 URL 组成 key 值（如“ MapReduce： file1.txt”），将词频作为 value，这样做的好处是可以利用 MapReduce 框架自带的 Map 端排序，将同一文档的相同单词的词频组成列表，传递给 Combine 过程，实现类似于 WordCount 的功能。

2）Combine过程

经过 map 方法处理后， Combine 过程将 key 值相同的 value 值累加，得到一个单词在文档在文档中的词频，如图 6.2-2 所示。如果直接将图 6.2-2 所示的输出作为 Reduce 过程的输入，在 Shuffle 过程时将面临一个问题：所有具有相同单词的记录（由单词、 URL 和词频组成）应该交由同一个 Reducer 处理，但当前的 key 值无法保证这一点，所以必须修改 key 值和 value 值。这次将单词作为 key 值， URL 和词频组成 value 值（如“ file1.txt： 1”）。这样做的好处是可以利用 MapReduce 框架默认的 HashPartitioner 类完成 Shuffle 过程，将相同单词的所有记录发送给同一个 Reducer 进行处理。

3）Reduce过程

经过上述两个过程后， Reduce 过程只需将相同 key 值的 value 值组合成倒排索引文件所需的格式即可，剩下的事情就可以直接交给 MapReduce 框架进行处理了。如图 6.2-3 所示。索引文件的内容除分隔符外与图 6.1-3 解释相同。

4）需要解决的问题

本实例设计的倒排索引在文件数目上没有限制，但是单词文件不宜过大（具体值与默认 HDFS 块大小及相关配置有关），要保证每个文件对应一个 split。否则，由于 Reduce 过程没有进一步统计词频，最终结果可能会出现词频未统计完全的单词。可以通过重写 InputFormat 类将每个文件为一个 split，避免上述情况。或者执行两次 MapReduce，第一次 MapReduce 用于统计词频，第二次 MapReduce 用于生成倒排索引。除此之外，还可以利用复合键值对等实现包含更多信息的倒排索引。

6.3 程序代码

InvertedIndexMapper：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.invertedindex;  
   
 import java.io.IOException;  
   
 import org.apache.commons.lang.StringUtils;  
 import org.apache.hadoop.io.LongWritable;  
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Mapper;  
 import org.apache.hadoop.mapreduce.lib.input.FileSplit;  
   
 public class InvertedIndexMapper extends Mapper {  
   
     private static Text keyInfo = new Text();// 存储单词和 URL 组合  
     private static final Text valueInfo = new Text("1");// 存储词频,初始化为1  
   
     @Override  
     protected void map(LongWritable key, Text value, Context context)  
             throws IOException, InterruptedException {  
   
         String line = value.toString();  
         String[] fields = StringUtils.split(line, " ");// 得到字段数组  
   
         FileSplit fileSplit = (FileSplit) context.getInputSplit();// 得到这行数据所在的文件切片  
         String fileName = fileSplit.getPath().getName();// 根据文件切片得到文件名  
   
         for (String field : fields) {  
             // key值由单词和URL组成，如“MapReduce:file1”  
             keyInfo.set(field + ":" + fileName);  
             context.write(keyInfo, valueInfo);  
         }  
     }  
 }  

InvertedIndexCombiner：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.invertedindex;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 public class InvertedIndexCombiner extends Reducer {  
   
     private static Text info = new Text();  
   
     // 输入：   
     // 输出：  
     @Override  
     protected void reduce(Text key, Iterable values, Context context)  
             throws IOException, InterruptedException {  
         int sum = 0;// 统计词频  
         for (Text value : values) {  
             sum += Integer.parseInt(value.toString());  
         }  
   
         int splitIndex = key.toString().indexOf(":");  
         // 重新设置 value 值由 URL 和词频组成  
         info.set(key.toString().substring(splitIndex + 1) + ":" + sum);  
         // 重新设置 key 值为单词  
         key.set(key.toString().substring(0, splitIndex));  
           
         context.write(key, info);  
     }  
 }  

InvertedIndexReducer：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.invertedindex;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.io.Text;  
 import org.apache.hadoop.mapreduce.Reducer;  
   
 public class InvertedIndexReducer extends Reducer {  
   
     private static Text result = new Text();  
   
     // 输入：  
     // 输出：  
     @Override  
     protected void reduce(Text key, Iterable values, Context context)  
             throws IOException, InterruptedException {  
         // 生成文档列表  
         String fileList = new String();  
         for (Text value : values) {  
             fileList += value.toString() + ";";  
         }  
   
         result.set(fileList);  
         context.write(key, result);  
     }  
 }  

InvertedIndexRunner：

[java]  view plain
 copy
 
 package cn.nuc.hadoop.mapreduce.invertedindex;  
   
 import java.io.IOException;  
   
 import org.apache.hadoop.conf.Configuration;  
 import org.apache.hadoop.fs.FileSystem;  
 import org.apache.hadoop.fs.Path;  
 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;  
   
 public class InvertedIndexRunner {  
     public static void main(String[] args) throws IOException,  
             ClassNotFoundException, InterruptedException {  
         Configuration conf = new Configuration();  
         Job job = Job.getInstance(conf);  
   
         job.setJarByClass(InvertedIndexRunner.class);  
   
         job.setMapperClass(InvertedIndexMapper.class);  
         job.setCombinerClass(InvertedIndexCombiner.class);  
         job.setReducerClass(InvertedIndexReducer.class);  
   
         job.setOutputKeyClass(Text.class);  
         job.setOutputValueClass(Text.class);  
   
         FileInputFormat.setInputPaths(job, new Path(args[0]));  
         // 检查参数所指定的输出路径是否存在，若存在，先删除  
         Path output = new Path(args[1]);  

你可能感兴趣的:(mapreduce)

Linux（centos7）部署hive 灯下夜无眠 Linux linux hive 运维 dbeaver hive客户端
前提环境：已部署完hadoop(HDFS、MapReduce、YARN)1、安装元数据服务MySQL切换root用户#更新密钥rpm--importhttps://repo.mysql.com/RPM-GPG-KEY-mysqL-2022#安装Mysqlyum库rpm-Uvhhttp://repo.mysql.com//mysql57-community-release-el7-7.noarch.
关于HDP的20道高级运维面试题编织幻境的妖运维
1.描述HDP的主要组件及其作用。HDP（HortonworksDataPlatform）的主要组件包括Hadoop框架、HDFS、MapReduce、YARN以及Hadoop生态系统中的其他关键工具，如Spark、Flink、Hive、HBase等。以下是对这些组件及其作用的具体描述：Hadoop框架:Hadoop是一个开源的分布式计算框架，用Java语言编写，用于存储和处理大规模数据集。它广义
linux安装单机版spark3.5.0 爱上雪茄大数据 JAVA知识 spark 大数据分布式
一、spark介绍是一种通用的大数据计算框架，正如传统大数据技术Hadoop的MapReduce、Hive引擎，以及Storm流式实时计算引擎等.Spark主要用于大数据的计算二、spark下载spark3.5.0三、spark环境变量配置exportJAVA_HOME=/usr/local/jdk1.8.0_391exportJRE_HOME=/usr/local/jdk1.8.0_391/jr
03hive数仓安装与基础使用 daydayup9527 hadoop_hive 运维 hadoop
hiveHive概述Hive是基于Hadoop的一个数据仓库工具。可以将结构化的数据文件映射为一张表，并提供完整的sql查询功能，本质上还是一个文件底层是将sql语句转换为MapReduce任务进行运行本质上是一种大数据离线分析工具学习成本相当低，不用开发复杂的mapreduce应用，十分适合数据仓库的统计分析hive可以用来进行数据提取、转化、加载，这是一种可以存储、查询和分析存储在hadoop
HDFS weixin_51987187 笔记大数据
（一）HDFS简介及其基本概念 HDFS（HadoopDistributedFileSystem）是hadoop生态系统的一个重要组成部分，是hadoop中的的存储组件，在整个Hadoop中的地位非同一般，是最基础的一部分，因为它涉及到数据存储，MapReduce等计算模型都要依赖于存储在HDFS中的数据。HDFS是一个分布式文件系统，以流式数据访问模式存储超大文件，将数据分块存储到一个商业硬件
基于MapReduce的汽车数据清洗与统计案例醉里挑灯代码 MapReduce学习 mapreduce 汽车大数据
数据简介ecar168.csv（汽车销售数据表）：字段数据类型字段说明rankingString排名manufacturerString厂商vehicle_typeString车型monthly_sales_volumeString月销量accumulated_this_yearString本年累计last_monthString上月chain_ratioString环比corresponding
大数据开发（Hadoop面试真题-卷二） Key-Key 大数据 hadoop 面试
大数据开发（Hadoop面试真题）1、在大规模数据处理过程中使用编写MapReduce程序存在什么缺点？如何解决这些问题？2、请解释一下HDFS架构中NameNode和DataNode之间是如何通信的？3、请解释一下Hadoop的工作原理及其组成部分？4、HDFS读写流程是什么样子？5、Hadoop中fsimage和edit的区别是什么？6、Spark为什么比MapReduce更快？7、详细描述一
hbase、hive、clickhouse对比 freshrookie hbase hive hadoop
概念架构hbasemaster存储元数据、regionServer实际控制表数据，存储单位是Region，底层数据存储使用HDFShive通过driver将sql分解成mapreduce任务元数据需要单独存储到一个关系型数据库，一般是mysql实际数据存储可以是外表，也可以是内表clickhouse单体架构分层类似mysql，集群状态下是多主，通过zookeeper通信数据存储看引擎，最重要的引擎
EMR StarRocks实战——Mysql数据实时同步到SR 爱吃辣条byte #StarRocks 数仓建设大数据数据仓库
文章摘抄阿里云EMR上的StarRocks实践：《基于实时计算Flink使用CTAS&CDAS功能同步MySQL数据至StarRocks》前言CTAS可以实现单表的结构和数据同步，CDAS可以实现整库同步或者同一库中的多表结构和数据同步。下文主要介绍如何使用Flink平台和E-MapReduceStarRocks，通过CTAS&CDAS功能实现实时数仓中TP（TransactionProcessi
JAVA基础之Fork/Join框架冰河winner
1、核心思想Fork/Join框架是Java7提供的一个用于并行执行任务的框架，核心思想就是把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果，其实现思想与MapReduce有异曲同工之妙。Fork就是把一个大任务切分为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。比如计算1+2+…＋10000，可以分割成10个子任务，每个子任务分别对100
HIVE中MAP和REDUCE数量这孩子谁懂哈 HIVE hive hadoop mapreduce
一、总览MR执行过程一般的MapReduce程序会经过以下几个过程：输入（Input）、输入分片（Splitting）、Map阶段、Shuffle阶段、Reduce阶段、输出（Finalresult）。1、输入就不用说了，数据一般放在HDFS上面就可以了，而且文件是被分块的。关于文件块和文件分片的关系，在输入分片中说明。2、输入分片：在进行Map阶段之前，MapReduce框架会根据输入文件计算输
粉丝：什么情况下，hive 只会产生一个reduce任务，而没有maptask 浪尖聊大数据-浪尖 mapreduce hive 大数据 spark java
今天下午，在微信群里看到粉丝聊天，提到了一个某公司的面试题：什么情况下，hive只会产生一个reduce任务，而没有maptask这个问题是不是很神奇？我们常规使用的mapreducer任务执行过程大致如下图：appmaster通过某种策略计算数据源可以做多少分片（getSplits方法），对应的生成固定数量的maptask，假如存在shuffle的话，就根据默认或者指定的reducer数，将数据
Hive 基于MapReduce引擎 map和reduce数的参数控制原理与调优经验 abcdggggggg 大数据 Hive 大数据 hadoop hive mapreduce map
1.概述主要对基于MR的map数和reduce数测试与调优2.数据准备（1）表信息本次测试的表和sql都是使用的TPC-DS，表文件存储格式为text表名是否压缩总数占用空间文件数date_dim否730499.8M1item否4800012.9M1store否11830.5K1store_sales否230396418723109G8000store_sales_compress是2303964
hive中控制map和reduce数量的简单实现方法数仓大山哥 hive Hadoop系列 map数 reduce数
0、先说结论：由于mapreduce中没有办法直接控制map数量，所以只能曲线救国，通过设置每个map中处理的数据量进行设置；reduce是可以直接设置的。控制map和reduce的参数setmapred.max.split.size=256000000; --决定每个map处理的最大的文件大小，单位为Bsetmapred.min.split.size.per.node=1; --节点
Hadoop生态圈陈超Terry的技术屋
生态圈1.HBase的数据存储在HDFS里2.MapReduce可以计算HBase里的数据，也可以计算HDFS里的数据3.Hive是数据分析数据引擎，也是MapReduce模型，支持SQL4.Pig也是一个数据分析引擎，不支持SQL，有自己的PigLatin数据5.Sqoop是数据采集工具，针对关系数据库6.Flume是针对文件等数据的采集7.Hadoop的HA通过Zookeeper来实现8.HU
基于腾讯云基础，如何最大限度的提升出海效率？九河云服务器运维腾讯云
随着出海业务的需求量逐步增大，国内企业也逐步开始向海外扩展。在出海过程中，大部分企业都会为接收国内外的庞大数据以及资源如何安全管理而苦恼，这其中的成本控制、数据管理与运维、如何达成高效率、安全稳定等一直都是出海企业的痛点之一。九河云作为多云的合作伙伴并且基于自身多年从云经验，针对这些痛点为出海企业选择腾讯云的弹性MapReduce(EMR)助力企业出海顺利。弹性MapRduce(EMR)是什么？该
spark为什么比mapreduce快？后端
spark为什么比mapreduce快？首先澄清几个误区：1：两者都是基于内存计算的，任何计算框架都肯定是基于内存的，所以网上说的spark是基于内存计算所以快，显然是错误的2;DAG计算模型减少的是磁盘I/O次数（相比于mapreduce计算模型而言），而不是shuffle次数，因为shuffle是根据数据重组的次数而定，所以shuffle次数不能减少所以总结spark比mapreduce快的原
大数据Map Reduce (Hadoop) 和 MPP数据库的区别山哥Samuel
原理的角度出发,mapreduce其实就是二分查找的一个逆过程,不过因为计算节点有限,所以map和reduce前都预先有一个分区的步骤.二分查找要求数据是排序好的,所以MapReduce之间会有一个shuffle的过程对Map的结果排序.Reduce的输入是排好序的.MR分而治之的策略和数据库行业中另一种数据库MassivelyParallelProcessor即大规模并行处理数据库(典型代表AW
Vue技术栈 Shansec~ vue vue javascript 前端
Vue的声明周期声明周期的函数Vue中的指令计算属性计算属性复杂操作对象字面量增强写法条件判断v-if的原理:案例小问题:v-show和v-if的区别数组中响应式方法JavaScript中的高阶函数filtermapreducev-model双向绑定v-model原理v-model的修饰符组件化开发父组件和子组件注册组件的语法糖格式父子组件间的通信父子组件的访问方式slot插槽插槽的基本使用具名插
Hive切换引擎(MR、Tez、Spark) 落空空。 hive mr spark
Hive切换引擎(MR、Tez、Spark)1.MapReduce计算引擎(默认)sethive.execution.engine=mr;2.Tez引擎sethive.execution.engine=tez;1.Spark计算引擎sethive.execution.engine=spark;
测试环境搭建整套大数据系统（三：搭建集群zookeeper，hdfs，mapreduce，yarn，hive）宇智波云大数据项目 zookeeper hdfs mapreduce hive
一：搭建zkhttps://blog.csdn.net/weixin_43446246/article/details/123327143二：搭建hadoop，yarn，mapreduce。1.安装hadoop。sudotar-zxvfhadoop-3.2.4.tar.gz-C/opt2.修改java配置路径。cd/opt/hadoop-3.2.4/etc/hadoopvimhadoop-env.
Hadoop Streaming原理可乐加冰丶丶
Streaming简介•MapReduce和HDFS采用Java实现，默认提供Java编程接口•Streaming框架允许任何程序语言实现的程序在HadoopMapReduce中使用•Streaming方便已有程序向Hadoop平台移植Streaming原理Streaming优点•开发效率高–方便移植Hadoop平台，只需按照一定的格式从标准输入读取数据、向标准输出写数据就可以–原有的单机程序稍加
以内存为核心的开源分布式存储系统这次靠你了大数据 Tachyon hdfs 大数据
是一个以内存为核心的开源分布式存储系统，也是目前发展最迅速的开源大数据项目之一。Tachyon为不同的大数据计算框架（如ApacheSpark，HadoopMapReduce,ApacheFlink等）提供可靠的内存级的数据共享服务。此外，Tachyon还能够整合众多现有的存储系统（如AmazonS3,ApacheHDFS,RedHatGlusterFS,OpenStackSwift等），为用
马士兵 day4_Yarn和Map/Reduce配置启动和原理讲解 PC_Repair
day4_Yarn和Map/Reduce配置启动和原理讲解云计算：分布式计算，分布在多台机器上同时运行的运算。分布式计算原则：移动计算，而不是移动数据hadoop默认包含了hdfs、yarn、mapReduce三个组件yarn（YetAnotherResourceNegotiater）是资源调度系统，yarn调配的是内存和cpu，不参入计算。map/reduce是计算引擎配置vim/usr/loc
学习篇-Hadoop-YARN-环境搭建东东爱编码 hadoop 大数据 hadoop
文章目录一、Hadoop-YARN-环境搭建一、Hadoop-YARN-环境搭建官网参考：https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/SingleCluster.html配置：etc/hadoop/mapred-site.xmlmapreduce.framework.nameyarnmapreduc
hadoop-yarn资源分配介绍-以及推荐常用优化参数 Winhole hadoop Linux
根据网上的学习，结合工作进行的一个整理。如果有什么不正确的欢迎大家一起交流学习~Yarn前言作为Hadoop2.x的一部分，YARN采用MapReduce中的资源管理功能并对其进行打包，以便新引擎可以使用它们。这也简化了MapReduce，使其能够做到最好，处理数据。使用YARN，您现在可以在Hadoop中运行多个应用程序，所有应用程序都共享一个公共资源管理。那资源是有限的，YARN如何识别资源并
(15)Hive调优——数据倾斜的解决指南爱吃辣条byte #Hive 大数据 hive
目录前言一、什么是数据倾斜二、发生数据倾斜的表现2.1MapReduce任务2.2Spark任务三、如何定位发生数据倾斜的代码四、发生数据倾斜的原因3.1key分布不均匀3.1.1某些key存在大量相同值3.1.2存在大量异常值或空值3.2业务数据本身的特性3.3SQL语句本身就有数据倾斜3.4建表时考虑不周四、触发数据倾斜的SQL操作五、数据倾斜的解决方案5.1Map长尾优化5.1.1Map读取
MapReduce 诺冰1314 大数据 haoop MapReduce hadoop mapreduce 大数据
MapReduce定义mapReduce是一个分布式运算程序的编程框架，是用户开发基于hadoop的数据分析应用的核心框架。mapreduce的核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并运行在一个hadoop集群上。MapReduce的优缺点优点：易于编程良好的扩展性高容错性适合tb/pb级以上海量数据的离线处理缺点：不擅长实时计算不擅长流式计算不擅长DAG
EMS5730 MapReduce program areyousure7 网络 windows 数据库
EMS5730Spring2024Homework#0Releasedate:Jan10,2024Duedate:Jan21,2024(Sunday)23:59pm(Note:Thecourseadd-dropperiodendsat5:30pmonJan22.)Nolatehomeworkwillbeaccepted!EveryStudentMUSTincludethefollowingstat
排序的区别 incover
orderby(全局排序)对输入的数据做排序，故此只有一个reduce(多个reduce无法保证全局有序)；只有一个reduce，会导致当输入规模较大时，需要较长的计算时间。sortby(非全局排序)在数据进入reduce前完成排序；当mapreduce.task>1时，只能保证每个reduce的输出有序，不能保证全局有序。distributeby按照指定的字段对数据进行划分输出到不同的reduc
设计模式介绍 tntxia 设计模式
设计模式来源于土木工程师克里斯托弗亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。亚历山大与萨拉-石川佳纯和穆雷西乐弗斯坦合作
android高级组件使用(一) 百合不是茶 android RatingBar Spinner
1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。使用AutoCompleteTex
[网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题..... 这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入 &nbs
自写简单Redis内存统计shell 商人shang Linux shell 统计Redis内存
#!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
单例模式(饿汉 vs懒汉) oloz 单例模式
package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
springMvc json支持杨白白 json springmvc
1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
android播放，掃描添加本地音頻文件小桔子
最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
oracle常用命令 aichenglong oracle dba 常用命令
1 创建临时表空间 create temporary tablespace user_temp tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m autoextend on next 50m maxsize 20480m extent management local
25个Eclipse插件 AILIKES eclipse插件
提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。 1.新建注解： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
“闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
AngularJS Module类的方法 bijian1013 JavaScript AngularJS Module
AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。一.Main方法在哪里如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
[Maven学习笔记七]Maven插件和目标 bit1129 maven插件
插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标使用插件和目标使得我们可以干预
【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度 2. 多用户资源共享的调度
Nginx使用Linux内存加速静态文件访问 ronin47
Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
关于Unity3D中的Shader的知识 brotherlamp unity unity资料 unity教程 unity视频 unity自学
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
CopyOnWriteArrayList vs ArrayList bylijinnan java
package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
内存中栈和堆的区别 chicony 内存
1、内存分配方面：堆：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
回答一位网友对Scala的提问 chenchao051 scala map
本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。问题写道对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
mysql 取每组前几条记录 daizj mysql 分组最大值最小值每组三条记录
一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a WHERE 3> (SELECT COUNT(*) FROM tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
HTTP深入浅出 http请求 dcj3sjt126com http
HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。　　我这里总结了判断记录是否存在的常用方法：　　sql语句： select count ( * ) from tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
对HTML XML的一点认识 e200702084 html xml
感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。节点根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的：整个文档是一个文档节点每个 HTML 标签是一个元素节点包含在 HTML 元素中的文本是文本节点每一个 HTML 属性是一个属性节点注释属于注释节点 Node 层次
jquery分页插件 genaiwei jquery Web 前端分页插件
//jquery页码控件// 创建一个闭包 (function($) { // 插件的定义 $.fn.pageTool = function(options) { var totalPa
Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatis ibatis 区别联系
一、为什么使用IBatis/Mybatis 对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
C中怎样合理决定使用那种整数类型？秋风扫落叶 c 数据类型
如果需要大数值(大于32767或小于32767), 使用long 型。否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。除此之外, 就使用 int 型。如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。但是, 要注意在表达式中混用有符号和无符号值的情况。 &nbs
maven问题 zhb8015 maven问题
问题1： Eclipse 中新建maven项目无法添加src/main/java 问题 eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。按照maven目录结构，添加src/main/ja
(二)androidpn-server tomcat版源码解析之--push消息处理 spjich java androdipn 推送
在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题中华好儿孙 JavaScript Ajax Web 上传文件 FormData
var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
mybatis常用jdbcType数据类型 ysj5125094 mybatis mapper jdbcType
MyBatis 通过包含的jdbcType 类型 BIT FLOAT CHAR