MapReduce阶段性总结实例一

最新推荐文章于 2024-04-03 11:45:47 发布
最新推荐文章于 2024-04-03 11:45:47 发布
阅读量569 收藏
点赞数
分类专栏： Hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_t_y_y/article/details/72829838
版权

一、

源数据：

13156578896 123 456
13156578896 123 456
13155555555 333 555
13726230503 2481 24681
13826544101 264 0
13926435656 132 1512 1644
18784965678 123 567
18845678909 67890 345
12345678999 908 888
13344445555 9999 7777
12345678999 908 888
13344445555 9999 7777
13145678901 678 456


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

1.数据分析：

（1.）数据格式为：

手机号，上行流量，下行流量

（2.）想要得到的数据格式为：

[html]  view plain  copy   在CODE上查看代码片 派生到我的代码片
  1. 手机号 上行流量    下行流量    总流量  
  2. 13726230503     2481    24681   27162  
  3. 13826544101     264     0   264  
  4. 13926435656     132     1512    1644  
  5. ...             ...     ... 
2.思路分析：

由于源数据中每一个手机号可能存在多条上网记录，最后要得到的输出格式是一个手机号的所有上行流量、下行流量和总流量。所以可以考虑利用MapReduce框架的特性，将每个手机号作为map的输出key，该手机号上网信息作为map的输出value，经过shuffle，则在reduce端接收到一个<key， value-list>，其中，key手机号，value-list为该手机号所对应的一些上网信息的集合。这里有一个问题，由于map和reduce输入输出都为key-value键值对形式，所以必须将手机的上网信息（上行流量、下行流量）封装成一个Bean类，将这个类作为value。由于数据需要在不同的节点间进行网络传输，所以Bean类必须实现序列化和反序列化，Hadoop提供了一套序列化机制（实现Writable接口）。

3.代码如下：

com.phone.Phone:

package com.phone;

import java.io.DataInput;  
import java.io.DataOutput;  
import java.io.IOException;  
 
import org.apache.hadoop.io.Writable;  
 
public class Phone  implements Writable {  
 
   private String phoneNB;  
   private long up_flow;  
   private long down_flow;  
   private long sum_flow;  
 
   // 在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数  
   public Phone() {  
   }  
 
   // 为了对象数据的初始化方便，加入一个带参的构造函数  
   public Phone(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;  
   }  
}

com.phone.PhoneOutPut: 

package com.phone;
import org.apache.hadoop.mapreduce.Reducer;  
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;  
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.GenericOptionsParser;
import org.apache.hadoop.util.Tool;  
import org.apache.hadoop.util.ToolRunner; 

import com.zt.Sort;
import com.zt.Sort.Map;
import com.zt.Sort.Reduce;
import com.zt.WordCount.IntSumReducer;

public class PhoneOutPut {
	
	
	 public static class FlowSumMapper extends Mapper<LongWritable, Text, Text, Phone> {  
	      
		      
		    public  void map(LongWritable k1, Text v1,  
		            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]);  */
		    	
		        String fileds[]=line.split(" ");
		        String phoneNB=fileds[0];
		        long up_flow = Long.parseLong(fileds[1]);  
		        long down_flow = Long.parseLong(fileds[2]); 
		        
		        // 封装数据为kv并输出  
		       // System.out.println(phoneNB+"  流量一:"+up_flow+" 流量二:"+down_flow);
		        context.write(new Text(phoneNB), new Phone(phoneNB, up_flow,  
		                down_flow));  
		  //  System.out.println(new Phone(phoneNB, up_flow, down_flow));  
		  
		    }  
		}  
	 
	 
	 public  static class FlowSumReducer extends Reducer<Text, Phone, Text, Phone> {  
		 
		  
		    // 框架每传递一组数据<1387788654,{Phone,Phone,Phone,Phone.....}>调用一次我们的reduce方法  
		    // reduce中的业务逻辑就是遍历values，然后进行累加求和再输出  
		     
		    public  void reduce(Text k2, Iterable<Phone> v2s,  
		           Context context)  
		            throws IOException, InterruptedException {  
		    	 
		        long up_flow = 0;  
		        long down_flow = 0;  
		  
		        for (Phone v2 : v2s) {  
		            up_flow += v2.getUp_flow();  
		            down_flow += v2.getDown_flow();  
		        }  
		       context.write(k2, new Phone(k2.toString(), up_flow, down_flow));  //打印对象时调用toString方法
		        System.out.println(k2+" "+new Phone(k2.toString(), up_flow, down_flow));
		     /*   LongWritable l=new LongWritable(up_flow);
		        context.write(k2, l);*/
		    }  
		}  
	 
	 
	 
	 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: Data Sort <in> <out>");

	         System.exit(2);

	     }

	     

	     Job job = new Job(conf, "phone1");

	     job.setJarByClass(PhoneOutPut.class);

	     

	     //设置Map和Reduce处理类

	     job.setMapperClass(FlowSumMapper.class);  
	     job.setCombinerClass(FlowSumReducer.class);  
	        job.setReducerClass(FlowSumReducer.class);  

	     

	     //设置输出类型

	        job.setOutputKeyClass(Text.class);  
	        job.setOutputValueClass(Phone.class);  

	     

	     //设置输入和输出目录

	     FileInputFormat.addInputPath(job, new Path(otherArgs[0]));

	     FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));

	     System.exit(job.waitForCompletion(true) ? 0 : 1);

	     }

	}

context.write相当于java中的System.out.print()，而打印类的对象时会调用该类的toString()方法，所以这里用context.write()可以将覆写的toString()方法里面的内容输出到hdfs的文件夹中。

输出如下：

12345678999	1816	1776	3592
13145678901	678	456	1134
13155555555	333	555	888
13156578896	246	912	1158
13344445555	19998	15554	35552
13726230503	2481	24681	27162
13826544101	264	0	264
13926435656	132	1512	1644
18784965678	123	567	690
18845678909	67890	345	68235

二、引入hadoop自定义排序

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

源数据：

13156578897 123 456
13156578896 123 456
13155555555 333 555
13726230503 2481 24681
13826544101 264 0
13926435656 132 1512 1644
18784965678 123 567
18845678909 67890 345
12345678999 908 888
13344445555 9999 7777
12345678999 908 888
13344445555 9999 7777
13145678901 678 456


com.zort.MyPhone：

package com.zort;

import java.io.DataInput;  
import java.io.DataOutput;  
import java.io.IOException;  
 
import org.apache.hadoop.io.WritableComparable;  
 
public class MyPhone implements WritableComparable<MyPhone> {  
 
   private String phoneNB;  
   private long up_flow;  
   private long down_flow;  
   private long sum_flow;  
 
   // 在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数  
   public MyPhone() {  
   }  
 
   // 为了对象数据的初始化方便，加入一个带参的构造函数  
   public MyPhone(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(MyPhone o) {  
       return this.sum_flow > o.sum_flow ? -1 : 1;  
   }  
}

com.zort.PhoneSort:

package com.zort;

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 PhoneSort {  
 
   public static class SortMapper extends  
           Mapper<LongWritable, Text, MyPhone, NullWritable> {  
       @Override  
       protected void map(  
               LongWritable k1,  
               Text v1,  
               Mapper<LongWritable, Text, MyPhone, NullWritable>.Context context)  
               throws IOException, InterruptedException {  
             
           String line = v1.toString();  
           String[] fields = line.split(" ");
 
           String phoneNB = fields[0];  
           long up_flow = Long.parseLong(fields[1]);  
           long down_flow = Long.parseLong(fields[2]);  
 
           context.write(new MyPhone(phoneNB, up_flow, down_flow),  
                   NullWritable.get());  
       }  
   }  
 
   public static class SortReducer extends  
           Reducer<MyPhone, NullWritable, Text, MyPhone> {  
       @Override  
       protected void reduce(MyPhone k2, Iterable<NullWritable> v2s,  
               Reducer<MyPhone, NullWritable, Text, MyPhone>.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(PhoneSort.class);  
 
       job.setMapperClass(SortMapper.class);  
       job.setReducerClass(SortReducer.class);  
 
       job.setMapOutputKeyClass(MyPhone.class);  
       job.setMapOutputValueClass(NullWritable.class);  
 
       job.setOutputKeyClass(Text.class);  
       job.setOutputValueClass(MyPhone.class);  
 
       FileInputFormat.setInputPaths(job, new Path(args[0]));  
       FileOutputFormat.setOutputPath(job, new Path(args[1]));  
 
       System.exit(job.waitForCompletion(true) ? 0 : 1);  
   }  
}



输出如下：

18845678909	67890	345	68235
13726230503	2481	24681	27162
13344445555	9999	7777	17776
13344445555	9999	7777	17776
12345678999	908	888	1796
12345678999	908	888	1796
13926435656	132	1512	1644
13145678901	678	456	1134
13155555555	333	555	888
18784965678	123	567	690
13156578897	123	456	579
13156578896	123	456	579
13826544101	264	0	264

三、引入Hadoop分区功能

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

    public class HashPartitioner<K, V> extends Partitioner<K, V> {  
      
      /** 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任务中对数据应该划分到多个区中。比如下面统计考试的总得分：

源数据：

小明 第一次考试 100 90 80
小李 第一次考试 60 61 64
小王 第一次考试 30 40 50
小明 第二次考试 89 90 80
小李 第二次考试 60 71 64
小王 第二次考试 31 40 50
小宋 第一次考试 30 20 40
小张 第一次考试 20 30 55
小明 第三次考试 78 90 80

序列化类： 

package com.sum;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.Writable;

public class Sum  implements Writable{
	private int chiness;
	private int math;
	private int english;
	private int sum;
	public Sum(){
		
	}
	
	public Sum(int chiness,int math,int english){
		this.chiness=chiness;
		this.math=math;
		this.english=english;
		this.sum=this.chiness+this.math+this.english;
	}
	
	public int getChiness(){
		return this.chiness;
	}
	public int getMath(){
		return this.math;
	}
	public int getEnglish(){
		return this.english;
	}
	public int getSum(){
		return this.sum;
	}
	public String toString(){
		return "语文:"+this.chiness+"数学："+this.math+"英语："+this.english+"总分："+this.sum;
	}

	@Override
	public void readFields(DataInput in) throws IOException {
		// TODO Auto-generated method stub
		this.chiness=in.readInt();
		this.math=in.readInt();
		this.english=in.readInt();
		this.sum=in.readInt();
		
	}

	@Override
	public void write(DataOutput out) throws IOException {
		// TODO Auto-generated method stub
		out.writeInt(chiness);
		out.writeInt(math);
		out.writeInt(english);
		out.writeInt(sum);
	}

}

分区类： 

package com.sum;


import java.util.HashMap;  
import java.util.StringTokenizer;

import org.apache.hadoop.io.Text;  
import org.apache.hadoop.mapreduce.Partitioner;  
 
public class position extends Partitioner<Text, Sum> {  //输出
 
   private static HashMap<String, Integer> areaMap = new HashMap<>();  
 
   static {  
       areaMap.put("小明", 0);  
       areaMap.put("小宋", 1);  
       areaMap.put("小张", 2);  
       areaMap.put("小王", 3);  
       
   }  
 
   @Override  
   public int getPartition(Text key, Sum value, int numPartitions) {  
       // 
	   String p=key.toString();
	   StringTokenizer p1=new StringTokenizer(p);
	   String id="";
	   while(p1.hasMoreElements()){
		   id=p1.nextToken();
	   }
       Integer areCoder = areaMap.get(id); 
       if (areCoder == null) {  
           areCoder = 4;  
       }  
       return areCoder;  
   }


}


MapReduce类： 

package com.sum;

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hdfs.server.namenode.Content;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

import com.phone.Phone;
import com.phone.PhoneOutPut;
import com.phone.PhoneOutPut.FlowSumMapper;
import com.phone.PhoneOutPut.FlowSumReducer;
import com.position.AreaPartitioner;

public class SumPosition{
	
	public static class Map extends Mapper<LongWritable,  Text, Text,Sum>{
		public void map(LongWritable key,Text value,Context context) throws IOException, InterruptedException{
			String p=value.toString();
			String name="";
			int chiness=0;
			int math=0;
			int english=0;
			/*String []text=p.split(" ");
			String name=text[0];
			int chiness=Integer.parseInt(text[2]);
			int math=Integer.parseInt(text[3]);
			int english=Integer.parseInt(text[4]);*/
			StringTokenizer token=new StringTokenizer(p);
			while(token.hasMoreElements()){
				name=token.nextToken();
				String count=token.nextToken();
				chiness=Integer.parseInt(token.nextToken());
			    math=Integer.parseInt(token.nextToken());
				english=Integer.parseInt(token.nextToken());
				
			}
			System.out.println(name+"  "+chiness+"  "+math+"  "+english);
			context.write(new Text(name), new Sum(chiness,math,english));
		}
		
	}
	
	public static class Reduce extends Reducer<Text,Sum, Text, Sum>{
		public void reduce(Text key,Iterable<Sum> value,Context context) throws IOException, InterruptedException{
			int chiness=0;
			int math=0;
			int english=0;
			for(Sum  v:value ){
				chiness+=v.getChiness();;
				math+=v.getMath();
				english+=v.getEnglish();
				
			}
			context.write(key, new Sum(chiness,math,english));
		}
	}
	
	public static void main(String args[]) throws IOException, ClassNotFoundException, InterruptedException{
		 Configuration conf = new Configuration();


	     String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();

	     if (otherArgs.length != 2) {

	     System.err.println("Usage: Data Sort <in> <out>");

	         System.exit(2);

	     }

	     

	     Job job = new Job(conf, "sum");

	     job.setJarByClass(SumOutPut.class);

	     

	     //设置Map和Reduce处理类

	     job.setMapperClass(Map.class);  
	     job.setCombinerClass(Reduce.class);  
	        job.setReducerClass(Reduce.class);  
	        // 定义分组逻辑类  
	        job.setPartitionerClass(position.class);  
	     

	     //设置输出类型

	        job.setOutputKeyClass(Text.class);  
	        job.setOutputValueClass(Sum.class);  

	        job.setNumReduceTasks(5);  
	        

	     //设置输入和输出目录

	     FileInputFormat.addInputPath(job, new Path(otherArgs[0]));

	     FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));

	     System.exit(job.waitForCompletion(true) ? 0 : 1);

	     }



}


输出文件夹中一共生成了5个文件： 

小明	语文:267数学：270英语：240总分：777


小宋	语文:30数学：20英语：40总分：90

小张	语文:20数学：30英语：55总分：105


小王	语文:61数学：80英语：100总分：241


小李	语文:120数学：132英语：128总分：380










w_t_y_y
关注
专栏目录
mapreduce实例
10-09
MapReduce是Google提出的一种分布式计算模型，被广泛应用于大数据处理领域，尤其是在Hadoop平台上。Hadoop MapReduce将大规模数据处理的任务分解为两个主要阶段：Map阶段和Reduce阶段，以实现并行计算，提高处理效率...
关于MapReduce（一）
lvqianqian_csdn的博客
12-03 276
MapReduce是一种可用于数据处理的编程模型。该模型比较简单，但是想写出有用的程序却不太容易。Hadoop可以运行Java、Ruby和Python等语言的MapReduce。最重要的是MapReduce本质上是并行运行的，因此可以将大规模的数据分析任务分发给任何一个拥有足够多机器的数据中心。MapReduce的优势在于处理大规模数据集，这里先使用广为流传的气象数据集作为例子来实现一个简单的de...
Hadoop2.x实战：WordCount、Sort、去重复、average实例MapRedure编写
Evankaka的专栏
07-18 3763
Hadoop版本：2.6.0Eclipse版本：luna一、     Hadoop做的一个计算单词的实例1、引入jar org.apache.hadoop hadoop-common 2.2.0 org.apache.hadoop hadoop-hdfs 2.2.0 org.apache.hadoop hadoop-c
MapReduce基础知识(个人总结)
hellosrc的博客
11-05 2211
MapReduce有三个进程: MrAppMaster: 负责整个程序的过程调度及状态协调 MapTask ReduceTask 类型对应: Java类型 Hadoop Writable类型 Boolean BooleanWritable Byte ByteWritable Int IntWritable Float FloatWritable Long LongWritable Double DoubleWritable String Text Map Ma
MapReduce总结
机械工程跑路哥
08-05 2659
序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。.......................................
MapReduce实例
04-18
MapReduce是一种分布式计算模型，由Google开发，用于处理和生成大规模数据集。在这个实例中，我们看到MapReduce被用来从Hbase数据库中提取海量数据，对其进行处理，然后将统计结果存储到MySQL数据库中。这个过程涉及...
HBase MapReduce完整实例.rar
06-19
MapReduce是处理大数据的一种编程模型，它将复杂的计算任务分解为两个阶段：Map阶段和Reduce阶段。Map阶段将原始数据切分为小块，分别处理，而Reduce阶段则将Map阶段的结果进行聚合，得到最终结果。这种模型非常适合...
【1】MapReduce概述
01-20
MapReduce是Google提出的一种分布式计算模型，被广泛应用于大数据处理领域，特别是在Hadoop生态系统中。它的设计目标是简化大规模数据集的并行处理，让用户能够专注于业务逻辑，而无需过多关心底层分布式系统的复杂...
MapReduce原理要点和难点以及应用实例.zip
最新发布
05-23
MapReduce是一种分布式计算模型，由Google在2004年提出，主要用于处理和生成大规模数据集。这个模型将复杂的并行计算任务分解为两个主要阶段：Map（映射）和Reduce（规约），同时结合了一个中间数据存储阶段，称为...
MapReduce的学习心得
m0_58342743的博客
09-26 2314
1如果需要自定义Bean类型来充当输出的Key或Value，则自定义的Bean类要继承Writable接口并实现序列化及反序列化方法，序列化反序列化顺序要一致，要有空参构造器，要提供toString 2.如果自定义序列化类充当输出的Key或Value的同时，还需要自定义排序规则，则可以继承WritableComparable接口实现序列化反序列话方法和compareTo方法进行排序（二次排序等等都可） 3.若要进行分区，则需要自定义类继承Partitioner类重写getPartition方法，并在dr
MapReduce解析
weixin_42874157的博客
02-27 312
1.1 MapReduce是什么 Hadoop MapReduce是一个软件框架，基于该框架能够容易地编写应用程序，这些应用程序能够运行在由上千个商用机器组成的大集群上，并以一种可靠的，具有容错能力的方式并行地处理上TB级别的海量数据集。这个定义里面有着这些关键词， 一是软件框架，二是并行处理，三是可靠且容错，四是大规模集群，五是海量数据集。 1.2 MapReduce做什么 MapReduce擅...
大数据实验四-MapReduce编程实践
qq_63462564的博客
04-03 3153
本实验使用了MapReduce框架实现了多个文本文件中的WordCount词频统计功能。通过编写Map处理逻辑，将每个文本文件中的单词进行拆分并统计数量。在Reduce处理逻辑中，对相同的单词进行合并统计，并输出最终结果。在main方法中，设置了作业的配置信息、任务类型、输入输出路径等。实验结果展示了MapReduce在大数据处理领域的高效性和可靠性。在实际应用中，可以根据需求对代码进行优化，提高性能。
MapReduce优缺点
weixin_38023225的博客
09-18 3390
优点 1．MapReduce易于编程 它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是因为这个特点使得MapReduce编程变得非常流行。 2．良好的扩展性 当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。 3．高容错性 MapReduc...
MapReduce知识总结
sparky的博客
07-24 1572
文章目录1.MapReduce概述2.Map和Reduce函数3.MapReduce的核心思想3.1MapTask3.2ReduceTask4. MapReduce优缺点4.1优点4.2缺点5.MapReduce工作流程6. Shuffle详解6.1Shuffle过程简介6.2. Map端的Shuffle过程6.3. Reduce端的Shuffle过程7.MapReduce编程7.1Mapper阶段7.2Reduce阶段7.3Driver阶段 1.MapReduce概述 Map Reduce是一个分布式运
谈谈(详解！)MapReduce--个人感想。
酒心★
12-13 2240
MapReduce的大致计算处理过程: 数据是经过mapper 然后 通过Shuffle,最后通过Reducer，然后输出。 Map是映射，负责数据的过滤分发；Reduce是规约，负责数据的计算归并。 mapper阶段: 根据使用者的意愿，mapper对输入的数据进行操作，选取需要的字段(这个字段可能来自原数据中的值，也可能是原数据中的字段，或者是一个新的字段)和值(这个值可能来自原数据，但是更可...
hadoop 的MapReduce原理和学习心得
每天积累一点，一年后你会发现，自己变化很大
11-20 4289
mapreduce是hadoop的核心组成，是专门用于数据计算。主要掌握 map、reduce 函数的特点、如何写函数。 我的开发环境是在eclipse，运行程序的时候经常会出现 java 内存不足的情况，需要修改ecplise的jdk使用自己安装的JDK就行。 对于 Hadoop 的 map 函数和 reduce 函数，处理的数据是键值对，也就是说 map 函数接收的数据是键值对，两
Hadoop MapReduce详解与WordCount实例
总结来说，MapReduce是一种处理大规模数据的编程模型，通过将复杂问题分解为Map和Reduce两个阶段，使得并行计算变得简单。Hadoop的实现让这一模型在实际应用中具有高度的可扩展性和容错性。在实际开发中，理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

w_t_y_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值