深入理解与应用Hadoop中的MapReduce

最新推荐文章于 2024-03-19 11:56:58 发布
最新推荐文章于 2024-03-19 11:56:58 发布
阅读量1.7w 收藏 54
点赞数 12
分类专栏： MapReduce 文章标签： mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2011480169/article/details/52924955
版权

现在大数据是越来越火了，而我自己研究这方面也很长时间了，今天就根据我自己的经验教会大家学会如何使用MapReduce，下文中将MapReduce简写为MR。
本篇博客将结合实际案例来具体说明MR的每一个知识点。

1、本篇博客核心内容:

参考

2、MR的基本概念

这里写图片描述

3、MR中map()函数和reduce()函数如何编写

这里写图片描述

4、MR程序的基本编写流程(MR的基本执行过程)

这里写图片描述
这里写图片描述

下面将用一个具体的电信业务说明MR最基本的编写过程：
实验所用数据:
这里写图片描述
具体字段描述:
这里写图片描述
业务要求:统计同一个用户的上行总流量和，下行总流量和以及上下总流量和
例如：
这里写图片描述

代码示例：

package com.appache.celephone3;


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.Text;
import org.apache.hadoop.mapreduce.Job;
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.mapreduce.lib.output.TextOutputFormat;


public class FlowCount
{
    public static String path1 = "hdfs://hadoop:9000/dir/flowdata.txt";
    public static String path2 = "hdfs://hadoop:9000/dirout/";
	public static void main(String[] args) throws Exception
    {
    	Configuration conf = new Configuration();
    	conf.set("fs.default.name","hdfs://hadoop:9000/");
    	FileSystem fileSystem = FileSystem.get(conf);
    	if(fileSystem.exists(new Path(path2)))
    	{
    		fileSystem.delete(new Path(path2), true);
    	}   	
    	Job job = new Job(conf,"FlowCount");
    	job.setJarByClass(FlowCount.class);
    	//编写驱动
    	FileInputFormat.setInputPaths(job, new Path(path1));
    	job.setInputFormatClass(TextInputFormat.class);
    	job.setMapperClass(MyMapper.class);
    	job.setMapOutputKeyClass(Text.class);
    	job.setMapOutputValueClass(Text.class);
    	//shuffle洗牌阶段
    	job.setReducerClass(MyReducer.class);
    	job.setOutputKeyClass(Text.class);
    	job.setOutputValueClass(Text.class);
    	job.setOutputFormatClass(TextOutputFormat.class);
    	FileOutputFormat.setOutputPath(job, new Path(path2));	
    	//将任务提交给JobTracker
    	job.waitForCompletion(true);
    	//查看程序的运行结果
    	FSDataInputStream fr = fileSystem.open(new Path("hdfs://hadoop:9000/dirout/part-r-00000"));
    	IOUtils.copyBytes(fr,System.out,1024,true);
    }
}

package com.appache.celephone3;

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class MyMapper   extends Mapper<LongWritable, Text, Text, Text>
{
    @Override
    protected void map(LongWritable k1, Text v1,Context context)throws IOException, InterruptedException
    {
    	String line = v1.toString();//拿到日志中的一行数据
    	String[] splited = line.split("\t");//切分各个字段
    	//获取我们所需要的字段
    	String msisdn = splited[1];
    	String upFlow = splited[8];
    	String downFlow = splited[9];
    	long flowsum = Long.parseLong(upFlow) + Long.parseLong(downFlow);
    	context.write(new Text(msisdn), new Text(upFlow+"\t"+downFlow+"\t"+String.valueOf(flowsum)));
    }
}

package com.appache.celephone3;

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class MyReducer  extends Reducer<Text, Text, Text, Text>
{
    @Override
    protected void reduce(Text k2, Iterable<Text> v2s,Context context)throws IOException, InterruptedException
    {
       long upFlowSum = 0L;
       long downFlowSum = 0L;
       long FlowSum = 0L;
       for(Text v2:v2s)
       {
    	   String[] splited = v2.toString().split("\t");
    	   upFlowSum += Long.parseLong(splited[0]);
    	   downFlowSum += Long.parseLong(splited[1]);
    	   FlowSum += Long.parseLong(splited[2]);
       }
       String data = String.valueOf(upFlowSum)+"\t"+String.valueOf(downFlowSum)+"\t"+String.valueOf(FlowSum);
       context.write(k2,new Text(data));
    }
}

运行结果：
这里写图片描述

这里写图片描述

5、MR程序的优化方式1---分区

这里写图片描述

具体业务描述：对于上面的电信数据，统计同一个用户的上行总流量和，下行总流量和以及上下总流量和，并且手机号(11位)的信息输出到一个文件中，非手机号(8位)的信息输出到一个文件中
代码示例：

package com.appache.partitioner;


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


public class FlowCount
{
   public static String path1 = "hdfs://hadoop:9000/dir/flowdata.txt";
   public static String path2 = "hdfs://hadoop:9000/dirout/";
   public static void main(String[] args) throws Exception
   {
	   Configuration conf = new Configuration();
	   conf.set("fs.default.name", "hdfs://hadoop:9000/");
	   FileSystem fileSystem = FileSystem.get(conf); 
	   if(fileSystem.exists(new Path(path2)))
	   {
		   fileSystem.delete(new Path(path2), true);
	   }
	   
	   Job job = new Job(conf,"FlowCount");
	   job.setJarByClass(FlowCount.class);
	   FileInputFormat.setInputPaths(job, new Path(path1));
	   job.setInputFormatClass(TextInputFormat.class);//<k1,v1>
	   job.setMapperClass(MyMapper.class);
	   job.setMapOutputKeyClass(Text.class);
	   job.setMapOutputValueClass(FlowBean.class);//<k2,v2>
       //shuffle阶段:分区、排序、分组、本地归并
	   job.setPartitionerClass(MyPartitioner.class);
	   job.setNumReduceTasks(2);
	   //<k2,v2s>
	   job.setReducerClass(MyReducer.class);
	   job.setOutputKeyClass(Text.class);
	   job.setOutputValueClass(FlowBean.class);
	   job.setOutputFormatClass(TextOutputFormat.class);
	   FileOutputFormat.setOutputPath(job, new Path(path2)); 
	   //提交作业
	   job.waitForCompletion(true);      
   }
}

package com.appache.partitioner;

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

import org.apache.hadoop.io.Writable;

public class FlowBean implements Writable
{
   long upFlow ;  //上行流量
   long downFlow; //下行流量
   long flowSum; //总流量
   
   public FlowBean() {}
   public FlowBean(String upFlow,String downFlow)
   {
	   this.upFlow = Long.parseLong(upFlow);
	   this.downFlow = Long.parseLong(downFlow);
	   this.flowSum = Long.parseLong(upFlow) + Long.parseLong(downFlow);
   }
   
   public long getupFlow()  
   {return upFlow;}
   public long getdownFlow() 
   {return downFlow;}
   public long getflowSum () 
   {return flowSum;}
   
   @Override
   public void write(DataOutput out) throws IOException
   {
	  out.writeLong(upFlow);
	  out.writeLong(downFlow);
	  out.writeLong(flowSum);	
   }
   @Override
   public void readFields(DataInput in) throws IOException
   {
	  upFlow = in.readLong();
	  downFlow = in.readLong();
	  flowSum = in.readLong();	
   }  
   public String toString()
   {
	   return upFlow+"\t"+downFlow+"\t"+flowSum;  
   }
}


package com.appache.partitioner;

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class MyMapper  extends Mapper<LongWritable, Text, Text, FlowBean>
{
    @Override
    protected void map(LongWritable k1, Text v1,Context context)throws IOException, InterruptedException
    {
    	String line = v1.toString();//拿到日志中的一行数据
    	String[] splited = line.split("\t");//切分各个字段
    	//获取我们所需要的字段
    	String msisdn = splited[1];//手机号 k2
    	FlowBean flowData = new FlowBean(splited[8],splited[9]);//<100,200>
    	context.write(new Text(msisdn), flowData);
    }
}


package com.appache.partitioner;

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



public class MyPartitioner extends Partitioner<Text,FlowBean>  //分区<18330267966,{100,200}>
{
	@Override
	public int getPartition(Text k2, FlowBean v2, int numPartitions)
	{
	   String tele = k2.toString();
	   if(tele.length() ==  11)
		   return 0;  //手机号的信息输出到0区
	   else 
		   return 1;  //非手机号的信息输出到1区
	}
}


package com.appache.partitioner;

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class MyReducer extends Reducer<Text, FlowBean, Text, FlowBean>
{
    @Override
    protected void reduce(Text k2, Iterable<FlowBean> v2s,Context context)throws IOException, InterruptedException
    {
    	long upFlow = 0L;
    	long downFlow = 0L;
    	long flowSum = 0L;
    	for(FlowBean v2: v2s)
    	{
    		upFlow += v2.getupFlow();
    		downFlow += v2.getdownFlow();
    		flowSum += v2.getflowSum();
    	}
    	context.write(k2, new FlowBean(upFlow+"",downFlow+""));  //将数据输出到指定的文件当中
    }
}

运行结果：
这里写图片描述

6、MR程序的优化方式2---自定义排序

这里写图片描述

业务描述:
对于上面业务得到的统计结果:
这里写图片描述

先按照总流量由低到高排序，在总流量相同的情况下，按照下行流量和从低到高排序:
实例代码:

package com.appache.sort;

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.mapreduce.Job;
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.mapreduce.lib.output.TextOutputFormat;


public class FlowCount  
{
	   public static String path1 = "hdfs://hadoop:9000/flowCount.txt";
	   public static String path2 = "hdfs://hadoop:9000/dirout/";
	   public static void main(String[] args) throws Exception
	   {
		   Configuration conf = new Configuration();
		   conf.set("fs.default.name","hdfs://hadoop:9000/");
		   FileSystem fileSystem = FileSystem.get(conf);
		   if(fileSystem.exists(new Path(path2)))
		   {
			   fileSystem.delete(new Path(path2), true);
		   }
		   
		   Job job = new Job(conf, "FlowCount");
		   job.setJarByClass(FlowCount.class);
		   
		   //编写驱动
		   FileInputFormat.setInputPaths(job,new Path(path1));  //输入文件的路径
		   job.setInputFormatClass(TextInputFormat.class);//<k1,v1>
	       job.setMapperClass(MyMapper.class);
	       job.setMapOutputKeyClass(FlowBean.class);
	       job.setMapOutputValueClass(NullWritable.class);
	       //shuffle优化阶段
	       job.setReducerClass(MyReducer.class);
	       job.setOutputKeyClass(FlowBean.class);
	       job.setOutputValueClass(NullWritable.class);
	       job.setOutputFormatClass(TextOutputFormat.class);
	       FileOutputFormat.setOutputPath(job,new Path(path2));
	       
	       job.waitForCompletion(true);    
	       //查看运行结果:
	       FSDataInputStream fr = fileSystem.open(new Path("hdfs://hadoop:9000/dirout/part-r-00000"));
	       IOUtils.copyBytes(fr,System.out,1024,true);
	   }
}


package com.appache.sort;

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

import org.apache.hadoop.io.WritableComparable;



public class FlowBean  implements  WritableComparable<FlowBean>
{
   private String msisdn;  //获取我们所需要的字段
   private long upFlow;
   private long downFlow;
   private long flowSum;
   
   public FlowBean(){}
   public FlowBean(String msisdn,String upFlow,String downFlow,String flowSum)
   {
	  this.msisdn = msisdn;
	  this.upFlow = Long.parseLong(upFlow);
	  this.downFlow = Long.parseLong(downFlow);
	  this.flowSum = Long.parseLong(flowSum); //通过构造函数自动求取总流量
   }
   
	public String getMsisdn()
	{
		return msisdn;
	}
	public long getUpFlow()
	{
		return upFlow;
	}
	public long getDownFlow()
	{
		return downFlow;
	}
	public long getFlowSum()
	{
		return flowSum;
	}
	
	@Override   //所谓序列化就是将对象写到字节输出流当中
	public void write(DataOutput out) throws IOException
	{
	    out.writeUTF(msisdn);
	    out.writeLong(upFlow);
	    out.writeLong(downFlow);
	    out.writeLong(flowSum);
	}
	@Override  //所谓反序列化就是将对象从输入流当中给读取出来
	public void readFields(DataInput in) throws IOException
	{
		this.msisdn = in.readUTF();
		this.upFlow = in.readLong();
		this.downFlow = in.readLong();
		this.flowSum = in.readLong();
	}
	
	@Override   //指定比较的标准
	public int compareTo(FlowBean obj)
	{
        if(this.flowSum == obj.flowSum)   
        	return (int)(obj.downFlow - this.downFlow);  //下行流量由高到底
        else 
            return (int)(this.flowSum - obj.flowSum);	//总流量由低到高  
	}
	public String toString()
	{
		return this.msisdn+"\t"+this.upFlow+"\t"+this.downFlow+"\t"+this.flowSum;
	}
}


package com.appache.sort;

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 MyMapper extends Mapper<LongWritable, Text, FlowBean, NullWritable>
{
    @Override
    protected void map(LongWritable k1, Text v1,Context context)throws IOException, InterruptedException
    {
    	//拿到日志中的一行数据
    	String line = v1.toString();
    	//切分各个字段
    	String[] splited = line.split("\t");
    	//获取我们所需要的字段---并用FlowBean存储我们所需要的字段
    	FlowBean flowdata = new FlowBean(splited[0],splited[1],splited[2],splited[3]);
    	context.write(flowdata, NullWritable.get()); //<{18330267966,100,200},null>
    }
}


package com.appache.sort;

import java.io.IOException;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;

public class MyReducer extends Reducer<FlowBean, NullWritable, FlowBean, NullWritable>
{
    @Override  
    protected void reduce(FlowBean k2, Iterable<NullWritable> v2s,Context context)throws IOException, InterruptedException
    {  
       for(NullWritable v2:v2s)
       {
    	   context.write(k2, NullWritable.get());
       }
    }
}

运行结果:
这里写图片描述
这里写图片描述

7、MR程序的优化方式3---本地归并Combiner

这里写图片描述

具体业务描述：对于上面的电信数据，统计同一个用户的上行总流量和，下行总流量和以及上下总流量和，代码中要求加入本地归并优化方式:
代码示例：

package com.appache.celephone3;


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.Text;
import org.apache.hadoop.mapreduce.Job;
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.mapreduce.lib.output.TextOutputFormat;


public class FlowCount
{
    public static String path1 = "hdfs://hadoop:9000/dir/flowdata.txt";
    public static String path2 = "hdfs://hadoop:9000/dirout/";
	public static void main(String[] args) throws Exception
    {
    	Configuration conf = new Configuration();
    	conf.set("fs.default.name","hdfs://hadoop:9000/");
    	FileSystem fileSystem = FileSystem.get(conf);
    	if(fileSystem.exists(new Path(path2)))
    	{
    		fileSystem.delete(new Path(path2), true);
    	}   	
    	Job job = new Job(conf,"FlowCount");
    	job.setJarByClass(FlowCount.class);
    	//编写驱动
    	FileInputFormat.setInputPaths(job, new Path(path1));
    	job.setInputFormatClass(TextInputFormat.class);
    	job.setMapperClass(MyMapper.class);
    	job.setMapOutputKeyClass(Text.class);
    	job.setMapOutputValueClass(Text.class);
    	//加入本地归并优化方式:
    	job.setCombinerClass(MyReducer.class);
    	job.setNumReduceTasks(2);
    	//shuffle洗牌阶段
    	job.setReducerClass(MyReducer.class);
    	job.setOutputKeyClass(Text.class);
    	job.setOutputValueClass(Text.class);
    	job.setOutputFormatClass(TextOutputFormat.class);
    	FileOutputFormat.setOutputPath(job, new Path(path2));	
    	//将任务提交给JobTracker
    	job.waitForCompletion(true);
    	//查看程序的运行结果
    	FSDataInputStream fr = fileSystem.open(new Path("hdfs://hadoop:9000/dirout/part-r-00000"));
    	IOUtils.copyBytes(fr,System.out,1024,true);
    }
}

package com.appache.celephone3;

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class MyMapper   extends Mapper<LongWritable, Text, Text, Text>
{
    @Override
    protected void map(LongWritable k1, Text v1,Context context)throws IOException, InterruptedException
    {
    	String line = v1.toString();//拿到日志中的一行数据
    	String[] splited = line.split("\t");//切分各个字段
    	//获取我们所需要的字段
    	String msisdn = splited[1];
    	String upFlow = splited[8];
    	String downFlow = splited[9];
    	long flowsum = Long.parseLong(upFlow) + Long.parseLong(downFlow);
    	context.write(new Text(msisdn), new Text(upFlow+"\t"+downFlow+"\t"+String.valueOf(flowsum)));
    }
}


package com.appache.celephone3;

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class MyReducer  extends Reducer<Text, Text, Text, Text>
{
    @Override
    protected void reduce(Text k2, Iterable<Text> v2s,Context context)throws IOException, InterruptedException
    {
       long upFlowSum = 0L;
       long downFlowSum = 0L;
       long FlowSum = 0L;
       for(Text v2:v2s)
       {
    	   String[] splited = v2.toString().split("\t");
    	   upFlowSum += Long.parseLong(splited[0]);
    	   downFlowSum += Long.parseLong(splited[1]);
    	   FlowSum += Long.parseLong(splited[2]);
       }
       String data = String.valueOf(upFlowSum)+"\t"+String.valueOf(downFlowSum)+"\t"+String.valueOf(FlowSum);
       context.write(k2,new Text(data));
    }
}

运行结果：
这里写图片描述
这里写图片描述

8、MR程序的优化方式4---自定义计数器

这里写图片描述

9、如何用MR实现某个业务的方式总结

这里写图片描述

对于文章的内容，如有问题，欢迎留言指正！

一只懒得睁眼的猫
关注
  • 12
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
基于Hadoop的MapReduce架构研究.docx
11-07
本论文旨在帮助读者深入了解Hadoop架构的原理和应用，以及在大数据处理和分析方面的优势。读者可以通过学习本论文，掌握Hadoop的基本概念、工作原理和核心组件，了解其在实际场景中的应用，并能够根据需求进行相应的...
HDFS之MapReduce（特别篇）
不念人间朝暮的博客
08-17 755
HDFS之MapReduce（特别篇） 1、MapReduce概述 1、MapReduce定义 ​ MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。 ​ MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整分布式运算程序，并发运行在一个Hadoop集群上。 2、MapReduce优点 1、MapReduce易于编程 ​ 它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。
在hadoop2.x中的三大核心组件之HDFS和YARN、MapReduce
u011441473的专栏
03-11 4979
Hadoop的三大核心组件之HDFS和YARN Hadoop集群具体来说包含两个集群：HDFS集群和YARN集群，两者逻辑上分离，但物理上常在一起。 （1）HDFS集群：负责海量数据的存储，集群中的角色主要有NameNode/DataNode/SecondaryNameNode。 （2）YARN集群：负责海量数据运算时的资源调度，集群中的角色主要有ResourceManager/NodeManager （3）MapReduce:分布式计算框架（它其实是一个应用程序开发包）。 （MapRe...
大数据技术学习笔记（十三）—— HBase
最新发布
hu_wei123的博客
03-19 1426
HBase 是一种分布式可扩展支持海量数据存储的NoSQL数据库，支持对大数据进行随机、实时的读/写访问。NoSQL数据库（非关系型数据库）是一种不同于传统关系型数据库的数据库管理系统。它们使用灵活的数据模型，不遵循传统的表格关系模式，而是采用键值对（如Redis）、文档型（如MongoDB）、列族存储（如HBase）、图形数据库（如Neo4j）等各种数据模型。非关系型数据库主要用于存储和处理大量分散的数据，具有高性能、高可扩展性和高可用性的特点。
初识Hadoop两大核心：HDFS和MapReduce
web13170611647的博客
08-28 4545
其中NameNode、Secondary NameNode、JobTracker运行在Master节点上，而在每个Slave节点上，部署一个DataNode和TaskTracker，以便 这个Slave服务器运行的数据处理程序能尽可能直接处理本机的数据。Hadoop是一个能够对大量数据进行分布式处理的软件框架，实现了Google的MapReduce编程模型和框架，能够把应用程序分割成许多的小的工作单元，并把这些单元放到任何集群节点上执行。Datanode(Slave)：记录着服务器内所储存的数据块的列表。.
hadoop的hdfs（分布式存储）和mapreduce（分布式计算）
qiao_qing的博客
06-20 2839
文章目录2.hdfs（分布式存储）3.mapreduce ## 1.Hadoop简介 - hadoop主流版本： - Apache基金会所开发的分布式系统基础架构（hadoop）； - Cloudera版本（Cloudera’s Distribution Including Apache Hadoop，简称“CDH”），企业化版本； - Hortonworks版本（Hortonworks Data Platform，简称“HDP”），常用版本。 hadoop的框架最核心的设计是：底层的分布式存储（H.
HDFS、YARN、MapReduce概述及三者之间的关系(图解)
HGl1327401792的博客
01-20 1468
HDFS(Hadoop Distributed File System) 是一种分布式文件系统，用于处理在商业硬件上运行的大型数据集。它用于将单个 Apache Hadoop 集群扩展到数百 （甚至数千）个节点。HDFS 是的主要组件之一，其他组件包括MapReduce和 YARN。HDFS的使用场景：适合一次写入，多次读出的场景。一个文件经过创建、写入和关闭之后就不需要改变。MapReduce是一种分布式计算框架。
Hadoop技术内幕 深入理解MapReduce架构设计与实现原理 扫描版 带简单书签
03-21
文档仅包含 简单书签 ...最后从实际应用的角度深入讲解了Hadoop的性能优化、安全机制、多用户作业调度器和下一代MapReduce框架等高级主题和内容。《Hadoop技术内幕:深入解析MapReduce架构设计与实现原理》适合Hadoop的
深入理解MapReduce架构设计与实现原理
10-20
本书以Hadoop 1.0为基础，深入剖析了Hadoop MapReduce中各个组件的实现细节，包括RPC框架、JobTracker实现、TaskTracker实现、Task实现和作业调度器实现等。书中不仅详细介绍了MapReduce各个组件的内部实现原理，...
Hadoop技术内幕：深入理解MapReduce架构设计与实现原理.pdf
01-28
Hadoop 领域资深的实践者亲自执笔，首先介绍了 MapReduce 的设计理念和编程模型，然后从源代码的角度深入分析了 RPC 框架、客户端、JobTracker、 TaskTracker 和 Task 等 MapReduce 运行时环境的架构设计与实现原理...
深入理解hadoop
03-05
本书作者基于对Hadoop系统的实践，深入浅出地对Hadoop进行了详细的讲解，包含大量的实例和技巧，可帮助有一定基础的开发者快速掌握分布式系统。主要内容包括：第1章～第4章讲解大数据系统的基本概念、Hadoop系统的...
HDFS与MapReduce
weixin_41643439的博客
03-03 1924
HDFS基本概念 1、HDFS设计思想 分而治之：将大文件、大批量文件，分布式存放在大量服务器上，以便于采取分而治之的方式对海量数据进行运算分析 2、概念和特性 概念：HDFS是一个分布式的文件系统。 特性： （1）HDFS中的文件在物理上是分块存储（block），块的大小可以通过配置参数(dfs.blocksize)来规定，默认大小在hadoop2.x版本中是128M，老版本中是64...
Hadoop深入浅出MapReduce详解（全网最细）
热门推荐
清风的博客
05-28 1万+
文章目录前言-MR概述1.Hadoop MapReduce设计思想及优缺点设计思想优点：缺点：2. Hadoop MapReduce核心思想3.MapReduce工作机制剖析MapReduce运行机制过程描述第一阶段：作业提交（图1-4步）第二阶段：作业初始化（图5-7步）第三阶段：任务的分配(图8)第四阶段：任务的执行（图9-11）第五阶段：作业完成Tips 知识点：进度和状态更新4.MR各组成部分工作机制原理4.1概览：4.2 MapTask工作机制4.3 ReduceTask工作机制4.4shuffl
HDFS--Map Reduce框架
zhang09090606的博客
08-11 547
一、概述 从前面文章大家已经知道HDFS的应用场景已经实现原理了，但是将文件分布式存储到硬盘只是第一步，而从海量数据中提取分析我们需要的内容就是MapReduce做的事了。Map Reduce并不仅为HDFS服务而是一种通用的大数据分布式数据分析的框架 下面以一个计算海量数据最大值为例：一个银行有上亿储户，银行希望找到存储金额最高的金额是多少，按照传统的计算方式，我们会这样： Long moneys[] ... Long max = 0L; for(int i=0;i<moneys.l
Hadoop之mapreduce详解(基础篇)
qq_38147044的博客
09-08 3332
本篇文章主要从mapreduce运行作业的过程，shuffle，以及mapreduce作业失败的容错几个方面进行详解。转载：https://www.cnblogs.com/zsql/p/11600136.html 目录 一、mapreduce作业运行过程 1.1、mapreduce介绍 1.2、作业运行过程 二、shuffle 2.1、map端 2.2、reduce端 2.3、总结 三、作业失败和容错 3.1、任务运行失败 3.2、application master运行失败 3.3
hadoop之MapReduce简介
cxzaiwyy的博客
02-06 3518
hadoop之MapReduce的一些简介，架构和分析
Hadoop(hdfs, yarn, mapreduce)理论详解
myself_ning的博客
07-10 1670
hadoop,hdfs,yarn,mapreduce
【Hadoop学习笔记】（一）——MapReduce的原理及使用
wanger61的博客
10-25 1202
MapReduce是大数据离线计算的一种处理范式。它的基本概念就是“分而治之”：将单个问题分解成多个独立的子任务，再将子任务的结果汇聚成最终结果。在 MapReduce 中，它会先把样本分成一段段能够令单台计算机处理的规模，然后让多台计算机同时进行各段样本的整理和统计，每执行完一次统计就对映射统计结果进行规约处理，最终完成大规模的数据规约。MapReduce 的含义分为两步：Map 和 Reduce (映射和规约)。上述过程第一阶段的整理工作就是"映射"，把数据进行分类和整理，
“深入简出”好程序员教你MapReduce全过程
weixin_33928137的博客
05-14 134
欲说MapReduce，好程序员要和大家先讲一对概念——移动数据和移动计算。在学习大数据的时候，我们便会接触移动数据和移动计算，这两种联系紧密而又有很大不同的概念，其中移动计算也叫做本地计算。在以前的数据处理中时使用的移动数据，其实就是将需要处理的数据传输到存放不同处理数据方式逻辑的各个节点上。这样做的效率很低，特别是大数据中的数据量是很大的，至少都是GB以上，更大的是TB、PB甚至更大，而且磁盘...
期末试题0(hadoop大数据技术与应用) - 汇总
12-14
Hadoop大数据技术是当前互联网时代最常用的大数据处理平台之一，它能够处理海量的数据并且实现分布式存储和计算。在本学期的课程学习中，我们深入了解了Hadoop的基本架构和原理，包括HDFS分布式文件系统、MapReduce计算模型、YARN资源管理等核心组件。 在学习Hadoop的过程中，我们还学习了如何使用Hive和HBase这两种不同的数据存储方式，了解了它们的特点和适用场景。同时，我们也掌握了如何使用Pig和Spark等工具来进行大数据的处理和分析，包括数据清洗、转换和挖掘等操作。 在实际操作中，我们通过搭建Hadoop集群、编写MapReduce程序和使用Hive、HBase等工具来完成了大量的实验和项目，对Hadoop大数据技术有了更加深入的理解和掌握。同时，我们也学习了如何优化Hadoop集群的性能，避免出现单点故障和提高系统的稳定性。 通过本学期的学习，我对Hadoop大数据技术有了全面的了解，并且在实践中积累了丰富的经验。我相信这门课程的学习将对我的未来职业发展有着重要的帮助，我会继续不断地加强对Hadoop大数据技术的学习和应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只懒得睁眼的猫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值