MRJobConfig
public static fina COMBINE_CLASS_ATTR
属性COMBINE_CLASS_ATTR = "mapreduce.job.combine.class"
————子接口（F4） JobContent
方法getCombinerClass
————子实现类 JobContextImpl
实现getCombinerClass方法：
public Class<? extends Reducer<?,?,?,?>> getCombinerClass()
throws ClassNotFoundException {
return (Class<? extends Reducer<?,?,?,?>>)
conf.getClass(COMBINE_CLASS_ATTR, null);
}
因为JobContextImpl是MRJobConfig子类
所以得到了父类MRJobConfig的COMBINE_CLASS_ATTR属性
————子类Job
public void setCombinerClass(Class<? extends Reducer> cls
) throws IllegalStateException {
ensureState(JobState.DEFINE);
conf.setClass(COMBINE_CLASS_ATTR, cls, Reducer.class);
}
因为JobContextImpl是MRJobConfig子类,
而Job是JobContextImpl的子类
所以也有COMBINE_CLASS_ATTR属性
通过setCombinerClass设置了父类MRJobConfig的属性
MRJobConfig
————子接口JobContent
方法getCombinerClass
————子实现类 JobContextImpl
————子类 Job
————子实现类 TaskAttemptContext
继承了方法getCombinerClass
Task
$CombinerRunner(Task的内部类)
该内部类有方法create：
public static <K,V> CombinerRunner<K,V> create(JobConf job,
TaskAttemptID taskId,
Counters.Counter inputCounter,
TaskReporter reporter,
org.apache.hadoop.mapreduce.OutputCommitter committer
) throws ClassNotFoundException
{
Class<? extends Reducer<K,V,K,V>> cls =
(Class<? extends Reducer<K,V,K,V>>) job.getCombinerClass();
if (cls != null) {
return new OldCombinerRunner(cls, job, inputCounter, reporter);
}
// make a task context so we can get the classes
org.apache.hadoop.mapreduce.TaskAttemptContext taskContext =
new org.apache.hadoop.mapreduce.task.TaskAttemptContextImpl(job, taskId,
reporter);
Class<? extends org.apache.hadoop.mapreduce.Reducer<K,V,K,V>> newcls =
(Class<? extends org.apache.hadoop.mapreduce.Reducer<K,V,K,V>>)
taskContext.getCombinerClass();
if (newcls != null) {
return new NewCombinerRunner<K,V>(newcls, job, taskId, taskContext,
inputCounter, reporter, committer);
}
return null;
}
其中这一段应该是旧的API
Class<? extends Reducer<K,V,K,V>> cls =
(Class<? extends Reducer<K,V,K,V>>) job.getCombinerClass();
if (cls != null) {
return new OldCombinerRunner(cls, job, inputCounter, reporter);
}
而这个是新的API
org.apache.hadoop.mapreduce.TaskAttemptContext taskContext =
new org.apache.hadoop.mapreduce.task.TaskAttemptContextImpl(job, taskId,
reporter);
Class<? extends org.apache.hadoop.mapreduce.Reducer<K,V,K,V>> newcls =
(Class<? extends org.apache.hadoop.mapreduce.Reducer<K,V,K,V>>)
taskContext.getCombinerClass();
if (newcls != null) {
return new NewCombinerRunner<K,V>(newcls, job, taskId, taskContext,
inputCounter, reporter, committer);
}
return null;
（不知道为什么要写全名，去掉那些包名、向上/下转型和各种泛型的话，看起来就会清晰很多？）
而TaskAttemptContext是JobContent的子实现类，所以继承了getCombinerClass方法
而且，这里用的是多态，其调用的是子实现类TaskAttemptContextImpl的getCombinerClass方法
（TaskAttemptContextImpl继承了JobContextImpl，而JobContextImpl实现了该方法）
所以最终get到了属性COMBINE_CLASS_ATTR，即得到了我们通过job.setCombinerClass的xxxC
而这个xxxC是给了newcls，而newcls是给了NewCombinerRunner的构造函数的reducerClassc参数
NewCombinerRunner(Class reducerClass,
JobConf job,
org.apache.hadoop.mapreduce.TaskAttemptID taskId,
org.apache.hadoop.mapreduce.TaskAttemptContext context,
Counters.Counter inputCounter,
TaskReporter reporter,
org.apache.hadoop.mapreduce.OutputCommitter committer)
{
super(inputCounter, job, reporter);
this.reducerClass = reducerClass;
this.taskId = taskId;
keyClass = (Class<K>) context.getMapOutputKeyClass();
valueClass = (Class<V>) context.getMapOutputValueClass();
comparator = (RawComparator<K>) context.getCombinerKeyGroupingComparator();
this.committer = committer;
}
Task
MapTask
$MapOutputBuffer
private CombinerRunner<K,V> combinerRunner;
$SpillThread类($表示内部类)
combinerRunner = CombinerRunner.create(job, getTaskID(),
combineInputCounter,
reporter, null);
//此时，我们得到了设置好的合并类
if (combinerRunner == null) {
// spill directly
DataInputBuffer key = new DataInputBuffer();
while (spindex < mend &&
kvmeta.get(offsetFor(spindex % maxRec) + PARTITION) == i) {
final int kvoff = offsetFor(spindex % maxRec);
int keystart = kvmeta.get(kvoff + KEYSTART);
int valstart = kvmeta.get(kvoff + VALSTART);
key.reset(kvbuffer, keystart, valstart - keystart);
getVBytesForOffset(kvoff, value);
writer.append(key, value);
++spindex;
}
} else {
int spstart = spindex;
while (spindex < mend &&
kvmeta.get(offsetFor(spindex % maxRec)
+ PARTITION) == i) {
++spindex;
}
// Note: we would like to avoid the combiner if we've fewer
// than some threshold of records for a partition
if (spstart != spindex) {
combineCollector.setWriter(writer);
RawKeyValueIterator kvIter =
new MRResultIterator(spstart, spindex);
combinerRunner.combine(kvIter, combineCollector);
}
}
再查看combine函数
在Task的内部类NewCombinerRunner下
public void combine(RawKeyValueIterator iterator,
OutputCollector<K,V> collector)
throws IOException, InterruptedException,ClassNotFoundException
{
// make a reducer
org.apache.hadoop.mapreduce.Reducer<K,V,K,V> reducer =
(org.apache.hadoop.mapreduce.Reducer<K,V,K,V>)
ReflectionUtils.newInstance(reducerClass, job);
org.apache.hadoop.mapreduce.Reducer.Context
reducerContext = createReduceContext(reducer, job, taskId,
iterator, null, inputCounter,
new OutputConverter(collector),
committer,
reporter, comparator, keyClass,
valueClass);
reducer.run(reducerContext);
}
上面的reducerClass就是我们传入的xxxC
最终是通过反射创建了一个xxxC对象，并将其强制向上转型为Reducer实例对象，
然后调用了向上转型后对象的run方法（当前的xxxC没有run方法，调用的是父类Reduce的run）
在类Reducer中，run方法如下
/**
* Advanced application writers can use the
* {@link #run(org.apache.hadoop.mapreduce.Reducer.Context)} method to
* control how the reduce task works.
*/
public void run(Context context) throws IOException, InterruptedException {
setup(context);
try {
while (context.nextKey()) {
reduce(context.getCurrentKey(), context.getValues(), context);
// If a back up store is used, reset it
Iterator<VALUEIN> iter = context.getValues().iterator();
if(iter instanceof ReduceContext.ValueIterator) {
((ReduceContext.ValueIterator<VALUEIN>)iter).resetBackupStore();
}
}
} finally {
cleanup(context);
}
}
有由于多态，此时调用的reduce是子类xxxC中的reduce方法
（多态态性质：子类复写了该方法，则实际上执行的是子类中的该方法）
所以说，我们自定义combine用的类的时候，应该继承Reducer类，并且复写reduce方法
且其输入形式：(以wordcount为例)
reduce(Text key, Iterable<IntWritable> values, Context context)
其中key是单词个数，而values是个数列表，也就是value1、value2........
注意，此时已经是列表，即<键，list<值1、值2、值3.....>>
(之所以得到这个结论，是因为我当时使用的combine类是WCReduce，
即Reduce和combine所用的类是一样的，通过对代码的分析，传入值的结构如果是<lkey,value>的话，是不可能做到combine的啊——即所谓的对相同值合并，求计数的累积和，这根本就是两个步骤，对key相同的键值对在map端就进行了一次合并了，合并成了<key,value list>，然后才轮到combine接受直接换个形式的输入，并处理——我们的处理是求和，然后再输出到context，进入reduce端的shuffle过程。
然后我在reduce中遍历了用syso输出
结果发现是0，而这实际上是因为经过一次遍历，我的指针指向的位置就不对了啊，
)
嗯，自己反复使用以下的代码，不断的组合、注释，去测试吧~就会得出这样的结论了
/reduce publicstaticclassWCReduce extends Reducer<Text,IntWritable,Text,IntWritable>{ private final IntWritableValueOut=newIntWritable(); @Override protectedvoid reduce(Text key,Iterable<IntWritable> values, Context context) throws IOException,InterruptedException{ for(IntWritable value : values){ System.out.println(value.get()+"--"); } // int total = 0 ;// for (IntWritable value : values) {// total += value.get();// }// ValueOut.set(total);// context.write(key, ValueOut); } } job.setCombinerClass(WCReduce.class);
附件列表
- 关于MapReduce中自定义分区类（四）
MapTask类 在MapTask类中找到run函数 if(useNewApi){ runNewMapper(job, splitMetaInfo, umbilical, reporter ...
- 关于MapReduce中自定义分组类（三）
Job类 /** * Define the comparator that controls which keys are grouped together * for a single ...
- 关于MapReduce中自定义带比较key类、比较器类（二）——初学者从源码查看其原理
Job类 /** * Define the comparator that controls * how the keys are sorted before they * are pa ...
- python3.4中自定义数组类（即重写数组类）
'''自定义数组类,实现数组中数字之间的四则运算,内积运算,大小比较,数组元素访问修改及成员测试等功能''' class MyArray: '''保证输入值为数字元素(整型,浮点型,复数)''' de ...
- flask中自定义日志类
一:项目架构 二:自定义日志类 1. 建立log.conf的配置文件 log.conf [log] LOG_PATH = /log/ LOG_NAME = info.log 2. 定义日志类 LogC ...
- 读取SequenceFile中自定义Writable类型值
1)hadoop允许程序员创建自定义的数据类型,如果是key则必须要继承WritableComparable,因为key要参与排序,而value只需要继承Writable就可以了.以下定义一个Doub ...
- Java中自定义注解类，并加以运用
在Java框架中,经常会使用注解,而且还可以省很多事,来了解下自定义注解. 注解是一种能被添加到java代码中的元数据,类.方法.变量.参数和包都可以用注解来修饰.注解对于它所修饰的代码并没有直接的影 ...
- Haoop Mapreduce 中的FileOutputFormat类
FileOutputFormat类继承OutputFormat,需要提供所有基于文件的OutputFormat实现的公共功能,主要有以下两点: (1)实现checkOutputSpecs方法 chec ...
- c#(winform)中自定义ListItem类方便ComboBox添加Item项
1.定义ListItem类 public class ListItem { private string _key = string.Empty; private string _value = st ...
随机推荐
- 萌新笔记——Cardinality Estimation算法学习（二）（Linear Counting算法、最大似然估计(MLE)）
在上篇,我了解了基数的基本概念,现在进入Linear Counting算法的学习. 理解颇浅,还请大神指点! http://blog.codinglabs.org/articles/algorithm ...
- 2-kvm创建快照以及网卡绑定
kvm创建快照以及网卡绑定 创建node1 查看node1 进入到kvm的配置文件里 将rhcs文件复制一份取名为node1.xml 通过这个命令随机生成一个uuid 然后就进入node1.xml里修 ...
- MVC中的BASE.ONACTIONEXECUTING(FILTERCONTEXT) 的作用
一句话,就是调用base.OnActionExecuting(filterContext)这个后,才会执行后续的ActionFilter,如果你确定只有一个,或是不想执行后续的话,那么可以不用调用该语 ...
- SQL 中的 AND OR
AND 和 OR 运算符用于基于一个以上的条件对记录进行过滤. AND 和 OR 运算符 AND 和 OR 可在 WHERE 子语句中把两个或多个条件结合起来. 如果第一个条件和第二个条件都成立,则 ...
- 搭建基于PHP的www服务器
安装MySQL #!/bin/bash mount |grep "/dev/sr0" if [ "$?" != 0 ];then mount /dev/sr0 ...
- MMORPG大型游戏设计与开发（服务器 AI 逻辑设定和状态结点）
人工智能(AI)中往往都会有这么一个问题,那就是我要做什么?我该怎么做?我需要什么?所以这里所谓的智能就是赋予AI对象的判断力,以及它根据判断得到的相应反应.就好比,你去商店买东西,钱够别人才卖给你, ...
- JS 阶段练习~ 仿flash的图片轮换效果
结合了所学的简单运动框架~ 做这样一个综合小实例~~ -------------------------主要问题: 1.getByClassName IE低版的兼容性 2.DOM不够严谨 … 各种 ...
- 攻城记：Thinkphp框架的项目规划总结和踩坑经验
一.项目模块规划 1.项目分为PC端.移动端.和PC管理端,分为对应目录为 /Application/Home,/Application/Mobile,/Application/Admin: 对应入口 ...
- minHash最小哈希原理
minHash最小哈希原理 收藏 初雪之音 发表于 9个月前 阅读 208 收藏 9 点赞 1 评论 0 摘要: 在数据挖掘中,一个最基本的问题就是比较两个集合的相似度.通常通过遍历这两个集合中的所有 ...
- java 导出word 并下载
记录一下导出操作 源码: /************ * 导出word 并下载 * @param id 房号记录编号 * ***********************/ @RequestMappin ...
