日志处理实验之MapReduce方法

最新推荐文章于 2021-11-30 22:16:32 发布
最新推荐文章于 2021-11-30 22:16:32 发布
阅读量1.7k 收藏
点赞数
分类专栏： 大数据实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/book_mmicky/article/details/25714407
版权
1：创建日志格式处理类KPI 
package hadoop2.logs;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Locale;
import java.util.Set;

/*
 * KPI Object
 */
public class KPI {
	private String remote_addr;// 记录客户端的ip地址
	private String remote_user;// 记录客户端用户名称,忽略属性"-"
	private String time_local;// 记录访问时间与时区
	private String request;// 记录请求的url与http协议
	private String status;// 记录请求状态；成功是200
	private String body_bytes_sent;// 记录发送给客户端文件主体内容大小
	private String http_referer;// 用来记录从那个页面链接访问过来的
	private String http_user_agent;// 记录客户浏览器的相关信息

	private boolean valid = true;// 判断数据是否合法

	private static KPI parser(String line) {
		// System.out.println(line);
		KPI kpi = new KPI();
		String[] arr = line.split(" ");
		if (arr.length > 11) {
			kpi.setRemote_addr(arr[0]);
			kpi.setRemote_user(arr[1]);
			kpi.setTime_local(arr[3].substring(1));
			kpi.setRequest(arr[6]);
			kpi.setStatus(arr[8]);
			kpi.setBody_bytes_sent(arr[9]);
			kpi.setHttp_referer(arr[10]);

			if (arr.length > 12) {
				kpi.setHttp_user_agent(arr[11] + " " + arr[12]);
			} else {
				kpi.setHttp_user_agent(arr[11]);
			}

			if (Integer.parseInt(kpi.getStatus()) >= 400) {// 大于400，HTTP错误
				kpi.setValid(false);
			}
		} else {
			kpi.setValid(false);
		}
		return kpi;
	}

	/**
	 * 按page的pv分类
	 */
	public static KPI filterPVs(String line) {
		return parser(line);
		// KPI kpi = parser(line);
		// Set<String> pages = new HashSet<String>();
		// pages.add("/about");
		// pages.add("/black-ip-list/");
		// pages.add("/cassandra-clustor/");
		// pages.add("/finance-rhive-repurchase/");
		// pages.add("/hadoop-family-roadmap/");
		// pages.add("/hadoop-hive-intro/");
		// pages.add("/hadoop-zookeeper-intro/");
		// pages.add("/hadoop-mahout-roadmap/");
		//
		// if (!pages.contains(kpi.getRequest())) {
		// kpi.setValid(false);
		// }
		// return kpi;
	}

	/**
	 * 按page的独立ip分类
	 */
	public static KPI filterIPs(String line) {
		return parser(line);
		// KPI kpi = parser(line);
		// Set<String> pages = new HashSet<String>();
		// pages.add("/about");
		// pages.add("/black-ip-list/");
		// pages.add("/cassandra-clustor/");
		// pages.add("/finance-rhive-repurchase/");
		// pages.add("/hadoop-family-roadmap/");
		// pages.add("/hadoop-hive-intro/");
		// pages.add("/hadoop-zookeeper-intro/");
		// pages.add("/hadoop-mahout-roadmap/");
		//
		// if (!pages.contains(kpi.getRequest())) {
		// kpi.setValid(false);
		// }
		//
		// return kpi;
	}

	/**
	 * PV按浏览器分类
	 */
	public static KPI filterBroswer(String line) {
		return parser(line);
	}

	/**
	 * PV按小时分类
	 */
	public static KPI filterTime(String line) {
		return parser(line);
	}

	/**
	 * PV按访问域名分类
	 */
	public static KPI filterDomain(String line) {
		return parser(line);
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("valid:" + this.valid);
		sb.append("\nremote_addr:" + this.remote_addr);
		sb.append("\nremote_user:" + this.remote_user);
		sb.append("\ntime_local:" + this.time_local);
		sb.append("\nrequest:" + this.request);
		sb.append("\nstatus:" + this.status);
		sb.append("\nbody_bytes_sent:" + this.body_bytes_sent);
		sb.append("\nhttp_referer:" + this.http_referer);
		sb.append("\nhttp_user_agent:" + this.http_user_agent);
		return sb.toString();
	}

	public String getRemote_addr() {
		return remote_addr;
	}

	public void setRemote_addr(String remote_addr) {
		this.remote_addr = remote_addr;
	}

	public String getRemote_user() {
		return remote_user;
	}

	public void setRemote_user(String remote_user) {
		this.remote_user = remote_user;
	}

	public String getTime_local() {
		return time_local;
	}

	public Date getTime_local_Date() throws ParseException {
		SimpleDateFormat df = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss",
				Locale.US);
		return df.parse(this.time_local);
	}

	public String getTime_local_Date_hour() throws ParseException {
		SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHH");
		return df.format(this.getTime_local_Date());
	}

	public void setTime_local(String time_local) {
		this.time_local = time_local;
	}

	public String getRequest() {
		return request;
	}

	public String getRequest_domain() {
		// String str = this.request.replace("\"", "").replace("http://", "")
		// .replace("https://", "");
		// return str.lastIndexOf("/") > 0 ? str.substring(0, str.lastIndexOf("/")) : "/";
		String rtnString="";		
		String[] request_domain = request.split("/");

		if (request_domain.length > 3) {
			for (int i = 0; i < 3; i++) {
				rtnString= rtnString + request_domain[i]+"/" ;
			}
		} else {
			for (int i = 0; i < request_domain.length; i++) {
				rtnString= request.lastIndexOf("/") > 0 ? request.substring(0, request.lastIndexOf("/")) +"/" : "/";
			}
		}
		
		return rtnString;
		// string value = "192.168.128.33";
		// string[] names = value.split("\\.");
		// for (int i = 0; i < names.length; i++) {
		// system.out.println(names[i]);

	}

	public void setRequest(String request) {
		this.request = request;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getBody_bytes_sent() {
		return body_bytes_sent;
	}

	public void setBody_bytes_sent(String body_bytes_sent) {
		this.body_bytes_sent = body_bytes_sent;
	}

	public String getHttp_referer() {
		return http_referer;
	}

	public String getHttp_referer_domain() {
		if (http_referer.length() < 8) {
			return http_referer;
		}

		String str = this.http_referer.replace("\"", "").replace("http://", "")
				.replace("https://", "");
		return str.indexOf("/") > 0 ? str.substring(0, str.indexOf("/")) : str;
	}

	public void setHttp_referer(String http_referer) {
		this.http_referer = http_referer;
	}

	public String getHttp_user_agent() {
		return http_user_agent;
	}

	public void setHttp_user_agent(String http_user_agent) {
		this.http_user_agent = http_user_agent;
	}

	public boolean isValid() {
		return valid;
	}

	public void setValid(boolean valid) {
		this.valid = valid;
	}

	public static void main(String args[]) {
		String line = "222.68.172.190 - - [18/Sep/2013:06:49:57 +0000] \"GET /stru.zip HTTP/1.1\" 200 19939 \"http://www.angularjs.cn/A00n\" \"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36\"";
		System.out.println(line);
		KPI kpi = new KPI();
		String[] arr = line.split(" ");

		kpi.setRemote_addr(arr[0]);
		kpi.setRemote_user(arr[1]);
		kpi.setTime_local(arr[3].substring(1));
		kpi.setRequest(arr[6]);
		kpi.setStatus(arr[8]);
		kpi.setBody_bytes_sent(arr[9]);
		kpi.setHttp_referer(arr[10]);
		kpi.setHttp_user_agent(arr[11] + " " + arr[12]);
		// System.out.println(kpi);
		 System.out.println(kpi.getRequest_domain());

		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy.MM.dd:HH:mm:ss",
					Locale.US);
			System.out.println(df.format(kpi.getTime_local_Date()));
			System.out.println(kpi.getTime_local_Date_hour());
			System.out.println(kpi.getHttp_referer_domain());
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}

}

2：统计(所有日志)独立 ip 数目，即不同 ip 的总数
下面代码输出了独立IP的访问次数，同时通过一个reduce计数器ReportTest.TotalIP来得到不同IP的总数。由于例程中combine和reduce采用同一方法，所以在统计IP 的总数的时候，需要取消combine过程，不然计数器将是combine过程计数和reduce过程计数过程之和。当然如果combine和reduce用不同的方法，那就不必取消combine过程了。 
package hadoop2.logs;

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

public class KPIIP {
	
	static enum ReportTest{
		TotalIP
	}
	public static class KPIIPMapper extends
			Mapper<Object, Text, Text, IntWritable> {
		private final static IntWritable one = new IntWritable(1);
		private Text word = new Text();

		@Override
		public void map(Object key, Text value, Context context)
				throws IOException, InterruptedException {
			KPI kpi = KPI.filterPVs(value.toString());
			word.set(kpi.getRemote_addr());
			context.write(word, one);
		}
	}

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

		@Override
		public void reduce(Text key, Iterable<IntWritable> values,
				Context context) throws IOException, InterruptedException {
			int sum = 0;
			for (IntWritable val : values) {
				sum += val.get();
			}
			result.set(sum);
			context.getCounter(ReportTest.TotalIP).increment(1);
			context.write(key, result);
		}
	}

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args)
				.getRemainingArgs();
		if (otherArgs.length != 2) {
			System.err.println("Usage: KPIIP <in> <out>");
			System.exit(2);
		}

		Job job = new Job(conf, "KPIIP");
		job.setJarByClass(KPIIP.class);
		job.setMapperClass(KPIIPMapper.class);
		//job.setCombinerClass(KPIIPReducer.class);
		job.setReducerClass(KPIIPReducer.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
		FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
		System.exit(job.waitForCompletion(true) ? 0 : 1);
	}

}

3：统计(所有日志)每个子目录访问次数
对于日志来说，客户端的访问还有很多种形式，有可能是点击的、有可能是链接等等，日志中记录下来的访问请求要根据需要进行处理来满足分析的需求，可以通过编写KPI.filterPVs方法来达到过滤的目的，用KPI.getRequest_domain来格式化要分析的用户请求数据，最终通过mapreduce来完成分析之目的。 
package hadoop2.logs;

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

public class KPIPV {

	public static class KPIPVMapper extends
			Mapper<Object, Text, Text, IntWritable> {
		private final static IntWritable one = new IntWritable(1);
		private Text word = new Text();

		@Override
		public void map(Object key, Text value, Context context)
				throws IOException, InterruptedException {
			KPI kpi = KPI.filterPVs(value.toString());
			word.set(kpi.getRequest_domain());
			context.write(word, one);
		}
	}

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

		@Override
		public void reduce(Text key, Iterable<IntWritable> values,
				Context context) throws IOException, InterruptedException {
			int sum = 0;
			for (IntWritable val : values) {
				sum += val.get();
			}
			result.set(sum);
			context.write(key, result);
		}
	}

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args)
				.getRemainingArgs();
		if (otherArgs.length != 2) {
			System.err.println("Usage: KPIPV <in> <out>");
			System.exit(2);
		}

		Job job = new Job(conf, "KPIPV");
		job.setJarByClass(KPIPV.class);
		job.setMapperClass(KPIPVMapper.class);
		job.setCombinerClass(KPIPVReducer.class);
		job.setReducerClass(KPIPVReducer.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
		FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
		System.exit(job.waitForCompletion(true) ? 0 : 1);
	}

}

4：统计(所有日志)每个 ip，访问的子目录次数
和上面的例子一样，只是map的key中多了一个IP信息。 
package hadoop2.logs;

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

public class KPI3 {
	public static class KPI3Mapper extends
			Mapper<Object, Text, Text, IntWritable> {
		private final static IntWritable one = new IntWritable(1);
		private Text word = new Text();

		@Override
		public void map(Object key, Text value, Context context)
				throws IOException, InterruptedException {
			KPI kpi = KPI.filterPVs(value.toString());
			word.set(kpi.getRemote_addr() + " " + kpi.getRequest_domain());
			context.write(word, one);
		}
	}

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

		@Override
		public void reduce(Text key, Iterable<IntWritable> values,
				Context context) throws IOException, InterruptedException {
			int sum = 0;
			for (IntWritable val : values) {
				sum += val.get();
			}
			result.set(sum);
			context.write(key, result);
		}
	}

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		String[] otherArgs = new GenericOptionsParser(conf, args)
				.getRemainingArgs();
		if (otherArgs.length != 2) {
			System.err.println("Usage: KPI3 <in> <out>");
			System.exit(2);
		}

		Job job = new Job(conf, "KPI3");
		job.setJarByClass(KPI3.class);
		job.setMapperClass(KPI3Mapper.class);
		job.setCombinerClass(KPI3Reducer.class);
		job.setReducerClass(KPI3Reducer.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
		FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
		System.exit(job.waitForCompletion(true) ? 0 : 1);
	}

}

mmicky20110730
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce计数器实验
Today_2018的博客
06-13 501
一、实验目的 通过实验掌握基本的MapReduce编程方法； 掌握用MapReduce解决一些常见的数据处理问题，编写计数器程序。 二、实验平台 操作系统：Linux（建议CentOS6.5）； Hadoop版本：2.9.2； JDK版本：1.8或以上版本； Java IDE：Eclipse； 三、实验要求 能够理解MapReduce编程思想，然后会编写MapReduce版本计数器程序，并能执行该程序和分析执行过程。 四、实验背景 1、MapReduce计数器是什么？ 计数器
大数据技术之MapReduce
悦分享
02-08 648
MapReduce是一个分布式运算程序的编程框架，是基于Hadoop的数据分析计算的核心框架。MapReduce处理过程分为两个阶段：Map和Reduce。Map负责把一个任务分解成多个任务，Reduce负责把分解后多任务处理的结果汇总。压缩技术能够有效减少底层存储系统（HDFS）读写字节数。压缩提高了网络带宽和磁盘空间的效率。在运行MR程序时，I/O操作、网络数据传输、Shuffle 和Merge要花大量的时间，尤其是数据规模很大和工作负载密集的情况下，因此，使用数据压缩显得非常重要。
基于YARN的MapReduce日志几个注意事项
程序人生
04-22 2432
说明：本文提及的所有配置参数，都是基于Hadoop 2.5.0-cdh5.2.0环境。 MapReduce（MR）的调试是一个比较麻烦的问题，除了一些辅助调试工具（如mrunit）外，相信通过日志定位问题仍然是一个比较常见的方法。虽然这种方法比较原始，但是很多时候也能解决大问题...... 下面将描述使用MR的日志时，需要注意的一些问题。 1. MR运行过程中，日志将暂存于yarn.node
MapReduce 编程模型在日志分析方面的应用
weixin_34288121的博客
10-10 130
from:http://www.ibm.com/developerworks/cn/java/java-lo-mapreduce/index.html 简介 日志分析往往是商业智能的基础，而日益增长的日志信息条目使得大规模数据处理平台的出现成为必然。MapReduce 处理数据的有效性为日志分析提供了可靠的后盾。 本文将以对访问网页用户的日志进行分析，进而挖掘出用户兴趣点这一完整流程为例，详...
MapReduce处理日志框架
dcxhun3的博客
03-22 1246
最近完成了日志处理框架，由于日志也是文本，不需要自定义读取接口（图像需要）。故主要工作就是将日志格式进行解析和对日志要进行什么操作。 在map函数中，调用编写的日志解析接口实现对每一条日志的解析，然后对解析后的日志进行指定的操作。代码如下： public class Map extends Mapper { private IntWritable one = new IntWritab
MapReduce初级编程实践
Kuicer的博客
10-25 1422
一、实验目的 通过实验掌握基本的MapReduce编程方法； 掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。 二、实验平台 操作系统：Linux Hadoop版本：2.6.0 三、实验步骤 （一）编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件和输出文件的一个样例供参考。 输入文件A的样例如下： 20170101 x 20
数据库实验5MapReduce Prgramming实验
AthlenaA的博客
02-25 392
MapReduce Prgramming实验 Source Code for WordCount v1.0 From http://hadoop.apache.org/docs/stable/mapred_tutorial.html#Source+Code WordCount.java package org.myorg; import java.io.IOException; import ...
MapReduce的小作业方式以及聚合日志
BackToMe的博客
09-06 188
uber模式：允许小作业按序列在单个jvm中运行。 <!--默认设置--> mapreduce.job.ubertask.enable=false; mapreduce.job.ubertask.maxmaps=9; mapreduce.job.ubertask.maxreduces=1; mapreduce.job.ubertask.maxbytes=""; 在mapred-si...
『Hadoop』MapReduce 处理 日志log(单机版)
乌云压顶是吧
10-26 1008
『Hadoop』MapReduce 处理 日志log(单机版) 博客引流 本文为Hadoop单机版，伪分布版请移步『HDFS』伪分布式Hadoop集群 10.2晚又出现上次CPU打满 于是痛定思痛 检查了下业务流程 发现处理日志和build两块很吃内存 尤其是日志处理，随着日志量的增大，不可避免的是处理越来越慢，对性能要求越来越高 这个时候不免想到利用MapReduce对处理过程进行分布式操作 S...
大数据实验四-MapReduce编程实践
最新发布
04-03
**实验总结**：通过本次实验，不仅掌握了MapReduce的基本编程方法，还了解了其在大数据处理领域的重要作用。MapReduce能够高效地处理大量数据，极大地提升了数据分析的速度和准确性。 **心得体会**： 1. **理解...
大数据技术基础实验报告-MapReduce编程.docx
10-31
【MapReduce编程基础】 MapReduce是一种分布式计算框架，由Google提出，主要用于处理和生成大规模数据集。...在实际应用中，MapReduce常用于日志分析、搜索引擎索引构建、社交网络分析等多种场景。
MapReduce 谷歌实验室论文
04-08
MapReduce是一种由谷歌实验室提出的大规模数据处理模型及其相关实现方案。这篇论文详细介绍了MapReduce的概念、工作机制以及在实际中的应用。MapReduce模型通过两个主要函数——Map函数和Reduce函数来处理数据，使得...
Spark的MapReduce
ShangGuanhaochen的博客
08-24 558
Spark的MapReduce相对是比较简单的,步骤如下: 先编写测试文件[zyf@hadoop ~]$ vi b.txt [zyf@hadoop ~]$ cat b.txt aaa bbb ccc fff aaa bbb bbb fff（1）、将本地文件或者HDFS上的文件通过sc.textFile(“/input/b.txt”)加载到RDD中 （2）、可以将RDD文件通过filter（）函
MapReduce 框架原理（三）
prefect_start的博客
11-30 1699
1、MapTask工作机制 Read阶段：MapTask通过InputFormat获得的RecordReader，从输入InputSplit中解析出一个个key/value。 Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。 Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitio
大数据技术学习笔记之Hadoop框架基础3-网站日志分析及MapReduce过程详解
锋子的博客
03-26 1060
一、回顾    -》Hadoop启动方式        -》单个进程            sbin/hadoop-daemon.sh start namenode/datanode            sbin/yarn-daemon.sh start resourcemanager/nodemanager        -》分别启动hdfs与yarn            sbin/star...
大数据日志分析系统-spark进行日志计算
u014171282的博客
02-27 1804
spark简介：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。需要满足的项目需求：用spark进行实时统计，从kafka中获取数据，流式计算每分钟一次将计算结果存入es，供客户进行查询。说一次啊这里不用原来直接存入es的方式进行聚合或者存入es之后再进行计算的原因：1.直接存入es进行聚合的话es中会随着时间的推移保存大量的原始日志，es存入数据量太大的数据会产生性能问...
Spark的简单介绍（与MapReduce对比）
bjtucheryl的博客
02-10 2155
1.spark计算 引擎： 1.快速 DAG（有向无环图） Memory 2.通用 spark sparkSQL、SparkStreaming等相当于在spark平台上的 jar包 需要时直接以Jar包的方式导入2运行模式. Hadoop、Mesos、standlone。 可以处理任意类型的hadoop数据源 如hbase、hive等3.MapReduce与Spark
hadoop之mapreduce编程实例（系统日志初步清洗过滤处理）
热门推荐
zfszhangyuan的博客
09-13 1万+
刚刚开始接触hadoop的时候，总觉得必须要先安装hadoop集群才能开始学习MR编程，其实并不用这样，当然如果你有条件有机器那最好是自己安装配置一个hadoop集群，这样你会更容易理解其工作原理。我们今天就是要给大家演示如何不用安装hadoop直接调试编程MapReduce函数。
Hadoop-MapReduce-学习日志-20181213
夜雨寒霜
12-13 711
目录 1、MapReduce编程套路（有一张图重要） 2、maptask的并行度 3、MapReduce中自定义类 4、MapReduce程序的运行模式 5、MapReduce案例包 6、排序 7、combiner 8、分区—reducetask的并行度 9、join：hql——&gt;sql 10、分组 11、shuffle的原理解析（有一个张图重要） 12、多job串联...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值