hadoop示例程序

1. java怎么连接hdfs文件系统，需要哪些包

apache的Hadoop项目提供一类api可以通过java工程操作hdfs中的文件，包括：文件打开，读写，删除等、目录的创建，删除，读取目录中所有文件等。
1、到http://hadoop.apache.org/releases.html下载Hadoop，解压后把所有jar加入项目的lib里
2、程序处理步骤： 1）得到Configuration对象，2）得到FileSystem对象，3）进行文件操作，简单示例如下：
/**
*
*/
package org.jrs.wlh;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

/**
* @PutMeger.java
* java操作hdfs 往 hdfs中上传数据
* @version $Revision$</br>
* update: $Date$
*/
public class PutMeger {

public static void main(String[] args) throws IOException {

String[] str = new String[]{"E:\\hadoop\\UploadFileClient.java","hdfs://master:9000/user/hadoop/inccnt.java"};
Configuration conf = new Configuration();
FileSystem fileS= FileSystem.get(conf);
FileSystem localFile = FileSystem.getLocal(conf); //得到一个本地的FileSystem对象

Path input = new Path(str[0]); //设定文件输入保存路径
Path out = new Path(str[1]); //文件到hdfs输出路径

try{
FileStatus[] inputFile = localFile.listStatus(input); //listStatus得到输入文件路径的文件列表
FSDataOutputStream outStream = fileS.create(out); //创建输出流
for (int i = 0; i < inputFile.length; i++) {
System.out.println(inputFile[i].getPath().getName());
FSDataInputStream in = localFile.open(inputFile[i].getPath());

byte buffer[] = new byte[1024];
int bytesRead = 0;
while((bytesRead = in.read(buffer))>0){ //按照字节读取数据
System.out.println(buffer);
outStream.write(buffer,0,bytesRead);
}

in.close();
}

}catch(Exception e){
e.printStackTrace();
}
}

}

2. Hadoop实战的作品目录

第一部分Hadoop——一种分布式编程框架
第1章Hadoop简介2
1.1为什么写《Hadoop 实战》3
1.2什么是Hadoop3
1.3了解分布式系统和Hadoop4
1.4比较SQL数据库和Hadoop5
1.5理解MapRece6
1.5.1动手扩展一个简单程序7
1.5.2相同程序在MapRece中的扩展9
1.6用Hadoop统计单词——运行第一个程序11
1.7Hadoop历史15
1.8小结16
1.9资源16
第2章初识Hadoop17
2.1Hadoop的构造模块17
2.1.1NameNode17
2.1.2DataNode18
2.1.3Secondary NameNode19
2.1.4JobTracker19
2.1.5TaskTracker19
2.2为Hadoop集群安装SSH21
2.2.1定义一个公共账号21
2.2.2验证SSH安装21
2.2.3生成SSH密钥对21
2.2.4将公钥分布并登录验证22
2.3运行Hadoop22
2.3.1本地(单机)模式23
2.3.2伪分布模式24
2.3.3全分布模式25
2.4基于Web的集群用户界面28
2.5小结30
第3章Hadoop组件31
3.1HDFS文件操作31
3.1.1基本文件命令32
3.1.2编程读写HDFS35
3.2剖析MapRece程序37
3.2.1Hadoop数据类型39
3.2.2Mapper40
3.2.3Recer41
3.2.4Partitioner：重定向Mapper输出41
3.2.5Combiner：本地rece43
3.2.6预定义mapper和Recer类的单词计数43
3.3读和写43
3.3.1InputFormat44
3.3.2OutputFormat49
3.4小结50
第二部分实战
第4章编写MapRece基础程序52
4.1获得专利数据集52
4.1.1专利引用数据53
4.1.2专利描述数据54
4.2构建MapRece程序的基础模板55
4.3计数60
4.4适应Hadoop API的改变64
4.5Hadoop的Streaming67
4.5.1通过Unix命令使用Streaming68
4.5.2通过脚本使用Streaming69
4.5.3用Streaming处理键/值对72
4.5.4通过Aggregate包使用Streaming75
4.6使用combiner提升性能80
4.7温故知新83
4.8小结84
4.9更多资源84
第5章高阶MapRece85
5.1链接MapRece作业85
5.1.1顺序链接MapRece作业85
5.1.2具有复杂依赖的MapRece链接86
5.1.3预处理和后处理阶段的链接86
5.2联结不同来源的数据89
5.2.1Rece侧的联结90
5.2.2基于DistributedCache的复制联结98
5.2.3半联结：map侧过滤后在rece侧联结101
5.3创建一个Bloom filter102
5.3.1Bloom filter做了什么102
5.3.2实现一个Bloom filter104
5.3.3Hadoop 0.20以上版本的Bloom filter110
5.4温故知新110
5.5小结111
5.6更多资源112
第6章编程实践113
6.1开发MapRece程序113
6.1.1本地模式114
6.1.2伪分布模式118
6.2生产集群上的监视和调试123
6.2.1计数器123
6.2.2跳过坏记录125
6.2.3用IsolationRunner重新运行出错的任务128
6.3性能调优129
6.3.1通过combiner来减少网络流量129
6.3.2减少输入数据量129
6.3.3使用压缩129
6.3.4重用JVM132
6.3.5根据猜测执行来运行132
6.3.6代码重构与算法重写133
6.4小结134
第7章细则手册135
7.1向任务传递作业定制的参数135
7.2探查任务特定信息137
7.3划分为多个输出文件138
7.4以数据库作为输入输出143
7.5保持输出的顺序145
7.6小结146
第8章管理Hadoop147
8.1为实际应用设置特定参数值147
8.2系统体检149
8.3权限设置151
8.4配额管理151
8.5启用回收站152
8.6删减DataNode152
8.7增加DataNode153
8.8管理NameNode和SNN153
8.9恢复失效的NameNode155
8.10感知网络布局和机架的设计156
8.11多用户作业的调度157
8.11.1多个JobTracker158
8.11.2公平调度器158
8.12小结160
第三部分Hadoop也疯狂
第9章在云上运行Hadoop162
9.1Amazon Web Services简介162
9.2安装AWS163
9.2.1获得AWS身份认证凭据164
9.2.2获得命令行工具166
9.2.3准备SSH密钥对168
9.3在EC2上安装Hadoop169
9.3.1配置安全参数169
9.3.2配置集群类型169
9.4在EC2上运行MapRece程序171
9.4.1将代码转移到Hadoop集群上171
9.4.2访问Hadoop集群上的数据172
9.5清空和关闭EC2实例175
9.6Amazon Elastic MapRece和其他AWS服务176
9.6.1Amazon Elastic MapRece176
9.6.2AWS导入/导出177
9.7小结177
第10章用Pig编程178
10.1像Pig一样思考178
10.1.1数据流语言179
10.1.2数据类型179
10.1.3用户定义函数179
10.2安装Pig179
10.3运行Pig180
10.4通过Grunt学习Pig Latin182
10.5谈谈Pig Latin186
10.5.1数据类型和schema186
10.5.2表达式和函数187
10.5.3关系型运算符189
10.5.4执行优化196
10.6用户定义函数196
10.6.1使用UDF196
10.6.2编写UDF197
10.7脚本199
10.7.1注释199
10.7.2参数替换200
10.7.3多查询执行201
10.8Pig实战——计算相似专利的例子201
10.9小结206
第11章Hive及Hadoop群207
11.1Hive207
11.1.1安装与配置Hive208
11.1.2查询的示例210
11.1.3深入HiveQL213
11.1.4Hive小结221
11.2其他Hadoop相关的部分221
11.2.1HBase221
11.2.2ZooKeeper221
11.2.3Cascading221
11.2.4Cloudera222
11.2.5Katta222
11.2.6CloudBase222
11.2.7Aster Data和Greenplum222
11.2.8Hama和Mahout223
11.3小结223
第12章案例研究224
12.1转换《纽约时报》1100万个库存图片文档224
12.2挖掘中国移动的数据225
12.3在StumbleUpon推荐最佳网站229
12.3.1分布式StumbleUpon的开端230
12.3.2HBase和StumbleUpon230
12.3.3StumbleUpon上的更多Hadoop应用236
12.4搭建面向企业查询的分析系统——IBM的ES2项目238
12.4.1ES2系统结构240
12.4.2ES2爬虫241
12.4.3ES2分析242
12.4.4小结249
12.4.5参考文献250
附录AHDFS文件命令251

3. spark和hadoop的区别

直接比较Hadoop和Spark有难度，因为它们处理的许多任务都一样，但是在一些方面又并不相互重叠。

比如说，Spark没有文件管理功能，因而必须依赖Hadoop分布式文件系统(HDFS)或另外某种解决方案。

Hadoop框架的主要模块包括如下：

• Hadoop Common

• Hadoop分布式文件系统(HDFS)

• Hadoop YARN

• Hadoop MapRece

虽然上述四个模块构成了Hadoop的核心，不过还有其他几个模块。这些模块包括：Ambari、Avro、Cassandra、Hive、 Pig、Oozie、Flume和Sqoop，它们进一步增强和扩展了Hadoop的功能。

Spark确实速度很快(最多比Hadoop MapRece快100倍)。Spark还可以执行批量处理，然而它真正擅长的是处理流工作负载、交互式查询和机器学习。

相比MapRece基于磁盘的批量处理引擎，Spark赖以成名之处是其数据实时处理功能。Spark与Hadoop及其模块兼容。实际上，在Hadoop的项目页面上，Spark就被列为是一个模块。

Spark有自己的页面，因为虽然它可以通过YARN(另一种资源协调者)在Hadoop集群中运行，但是它也有一种独立模式。它可以作为 Hadoop模块来运行，也可以作为独立解决方案来运行。

MapRece和Spark的主要区别在于，MapRece使用持久存储，而Spark使用弹性分布式数据集(RDDS)。

性能

Spark之所以如此快速，原因在于它在内存中处理一切数据。没错，它还可以使用磁盘来处理未全部装入到内存中的数据。

Spark的内存处理为来自多个来源的数据提供了近乎实时分析的功能：营销活动、机器学习、物联网传感器、日志监控、安全分析和社交媒体网站。另 外，MapRece使用批量处理，其实从来就不是为惊人的速度设计的。它的初衷是不断收集来自网站的信息，不需要这些数据具有实时性或近乎实时性。

易用性

支持Scala(原生语言)、Java、Python和Spark SQL。Spark SQL非常类似于SQL 92，所以几乎不需要经历一番学习，马上可以上手。

Spark还有一种交互模式，那样开发人员和用户都可以获得查询和其他操作的即时反馈。MapRece没有交互模式，不过有了Hive和Pig等附加模块，采用者使用MapRece来得容易一点。

成本

“Spark已证明在数据多达PB的情况下也轻松自如。它被用于在数量只有十分之一的机器上，对100TB数据进行排序的速度比Hadoop MapRece快3倍。”这一成绩让Spark成为2014年Daytona GraySort基准。

兼容性

MapRece和Spark相互兼容;MapRece通过JDBC和ODC兼容诸多数据源、文件格式和商业智能工具，Spark具有与MapRece同样的兼容性。

数据处理

MapRece是一种批量处理引擎。MapRece以顺序步骤来操作，先从集群读取数据，然后对数据执行操作，将结果写回到集群，从集群读 取更新后的数据，执行下一个数据操作，将那些结果写回到结果，依次类推。Spark执行类似的操作，不过是在内存中一步执行。它从集群读取数据后，对数据 执行操作，然后写回到集群。

Spark还包括自己的图形计算库GraphX。GraphX让用户可以查看与图形和集合同样的数据。用户还可以使用弹性分布式数据集(RDD)，改变和联合图形，容错部分作了讨论。

容错

至于容错，MapRece和Spark从两个不同的方向来解决问题。MapRece使用TaskTracker节点，它为 JobTracker节点提供了心跳(heartbeat)。如果没有心跳，那么JobTracker节点重新调度所有将执行的操作和正在进行的操作，交 给另一个TaskTracker节点。这种方法在提供容错性方面很有效，可是会大大延长某些操作(即便只有一个故障)的完成时间。

Spark使用弹性分布式数据集(RDD)，它们是容错集合，里面的数据元素可执行并行操作。RDD可以引用外部存储系统中的数据集，比如共享式文件系统、HDFS、HBase，或者提供Hadoop InputFormat的任何数据源。Spark可以用Hadoop支持的任何存储源创建RDD，包括本地文件系统，或前面所列的其中一种文件系统。

RDD拥有五个主要属性：

• 分区列表

• 计算每个分片的函数

• 依赖其他RDD的项目列表

• 面向键值RDD的分区程序(比如说RDD是散列分区)，这是可选属性

• 计算每个分片的首选位置的列表(比如HDFS文件的数据块位置)，这是可选属性

RDD可能具有持久性，以便将数据集缓存在内存中。这样一来，以后的操作大大加快，最多达10倍。Spark的缓存具有容错性，原因在于如果RDD的任何分区丢失，就会使用原始转换，自动重新计算。

可扩展性

按照定义，MapRece和Spark都可以使用HDFS来扩展。那么，Hadoop集群能变得多大呢?

据称雅虎有一套42000个节点组成的Hadoop集群，可以说扩展无极限。最大的已知Spark集群是8000个节点，不过随着大数据增多，预计集群规模也会随之变大，以便继续满足吞吐量方面的预期。

安全

Hadoop支持Kerberos身份验证，这管理起来有麻烦。然而，第三方厂商让企业组织能够充分利用活动目录Kerberos和LDAP用于身份验证。同样那些第三方厂商还为传输中数据和静态数据提供数据加密。

Hadoop分布式文件系统支持访问控制列表(ACL)和传统的文件权限模式。Hadoop为任务提交中的用户控制提供了服务级授权(Service Level Authorization)，这确保客户拥有正确的权限。

Spark的安全性弱一点，目前只支持通过共享密钥(密码验证)的身份验证。Spark在安全方面带来的好处是，如果你在HDFS上运行Spark，它可以使用HDFS ACL和文件级权限。此外，Spark可以在YARN上运行，因而能够使用Kerberos身份验证。

总结

Spark与MapRece是一种相互共生的关系。Hadoop提供了Spark所没有的功能特性，比如分布式文件系统，而Spark 为需要它的那些数据集提供了实时内存处理。完美的大数据场景正是设计人员当初预想的那样：让Hadoop和Spark在同一个团队里面协同运行。

然后看这篇文章：Link



注：对下面这一段持保留意见：

此外我们这里还要讲到的是一个关于spark的重要误区—“spark是基于内存的技术”。它不是基于内存的技术；spark是一个管道式的执行引擎，而且在shuffle的过程中会将数据写入磁盘(比如说，如果我们想针对某个字段做聚合操作)、如果内存不够的话也一样会内存溢出(但是内存可以调整)。因此，spark之所以比MapRece快主要是因为它是管道式处理方式而不是有些人说的“基于内存的优化”。当然，spark在内存中做了缓存来提高性能，但这不是spark真正工作快的原因。

现在，我们再来完整比对一下：

1. MapRece可以被Spark Core替换？是的，它会随着时间的推移被替代，而且这种替代是合理的。但是spark目前还不是特别成熟能完全替代MapRece。此外，也没有人会完全放弃MapRece,除非所有依赖MapRece的工具都有可替代方案。比如说，想要在pig上运行的脚本能在spark上执行还是有些工作要做的。

（注：Pig是一种数据流语言，用来快速轻松的处理巨大的数据，雅虎推出的，现在正在走下坡路。Pig可以非常方便的处理HDFS和HBase的数据，和Hive一样,Pig可以非常高效的处理其需要做的，通过直接操作Pig查询可以节省大量的劳动和时间。当你想在你的数据上做一些转换，并且不想编写MapRece jobs就可以用Pig.）

2. Hive可以被Spark SQL替换？是的，这又是对的。但是我们需要理解的是Spark SQL对于spark本身来说还是比较年轻的，大概要年轻1.5倍。相对于比较成熟的Hive来说它只能算是玩具了吧，我将在一年半到两年之内再回头来看Spark SQL.。如果我们还记得的话，两到三年前Impala就号称要终结Hive,但是截止到目前两种技术也还是共存状态，Impala并没有终结Hive。在这里对于Spark SQL来说也是一样的。

3. Storm可以被Spark Streaming替换？是的，可以替换。只不过平心而论storm并不是Hadoop生态系统中的一员，因为它是完全独立的工具。他们的计算模型并不太形同，所以我不认为storm会消失，反而仍会作为一个商业产品。

4. Mahout可以被MLib替换？公平的讲，Machout已经失去了市场，而且从过去的几年来看它正在快速失去市场。对于这个工具，我们可以说这里是Spark真正可以替换Hadoop生态系统中的地方。 (注：同意！Spark的ML非常好用！要好好学！)

因此，总的来说，这篇文章的结论是：

1.不要被大数据供应商的包装所愚弄。他们大量推进的是市场而不是最终的真理。Hadoop最开始是被设计为可扩展的框架，而且其中很多部分是可替换的：可以将HDFS替换为Tachyon（现在新的名字是Alluxio），可以将YARN替换为Mesos，可以将MapRece替换为Tez并且在Tez之上可以运行Hive。这将会是Hadoop技术栈的可选方案或者完全替代方案？倘若我们放弃的MR（MapRece）而使用Tez,那么它还会是Hadoop吗？

2. Spark不能为我们提供完整的技术栈。它允许我们将它的功能集成到我们的Hadoop集群中并且从中获益，而不用完全脱离我们老的集群方案。

3. Spark还不够成熟。我认为在过三到四年我们就不会再叫“Hadoop栈”而是叫它“大数据栈”或者类似的称呼。因为在大数据栈中我们有很广泛的选择可以选出不同的开源产品来组合在一起形成一个单独的技术栈使用。

4. 如何使用Python为Hadoop编写一个简单的MapRece程序

在这个实例中，我将会向大家介绍如何使用Python 为 Hadoop编写一个简单的MapRece
程序。
尽管Hadoop 框架是使用Java编写的但是我们仍然需要使用像C++、Python等语言来实现Hadoop程序。尽管Hadoop官方网站给的示例程序是使用Jython编写并打包成Jar文件，这样显然造成了不便，其实，不一定非要这样来实现，我们可以使用Python与Hadoop 关联进行编程，看看位于/src/examples/python/wordCount.py 的例子，你将了解到我在说什么。

我们想要做什么？

我们将编写一个简单的 MapRece 程序，使用的是C-Python，而不是Jython编写后打包成jar包的程序。
我们的这个例子将模仿 WordCount 并使用Python来实现，例子通过读取文本文件来统计出单词的出现次数。结果也以文本形式输出，每一行包含一个单词和单词出现的次数，两者中间使用制表符来想间隔。

先决条件

编写这个程序之前，你学要架设好Hadoop 集群，这样才能不会在后期工作抓瞎。如果你没有架设好，那么在后面有个简明教程来教你在Ubuntu linux 上搭建（同样适用于其他发行版linux、unix）

如何使用Hadoop Distributed File System (HDFS)在Ubuntu Linux 建立单节点的 Hadoop 集群

如何使用Hadoop Distributed File System (HDFS)在Ubuntu Linux 建立多节点的 Hadoop 集群

Python的MapRece代码

使用Python编写MapRece代码的技巧就在于我们使用了 HadoopStreaming 来帮助我们在Map 和 Rece间传递数据通过STDIN (标准输入)和STDOUT (标准输出).我们仅仅使用Python的sys.stdin来输入数据，使用sys.stdout输出数据，这样做是因为HadoopStreaming会帮我们办好其他事。这是真的，别不相信！

Map: mapper.py

将下列的代码保存在/home/hadoop/mapper.py中，他将从STDIN读取数据并将单词成行分隔开，生成一个列表映射单词与发生次数的关系：
注意：要确保这个脚本有足够权限（chmod +x /home/hadoop/mapper.py）。

#!/usr/bin/env python

import sys

# input comes from STDIN (standard input)
for line in sys.stdin:
# remove leading and trailing whitespace
line = line.strip()
# split the line into words
words = line.split()
# increase counters
for word in words:
# write the results to STDOUT (standard output);
# what we output here will be the input for the
# Rece step, i.e. the input for recer.py
#
# tab-delimited; the trivial word count is 1
print '%s\\t%s' % (word, 1)在这个脚本中，并不计算出单词出现的总数，它将输出 "<word> 1" 迅速地，尽管<word>可能会在输入中出现多次，计算是留给后来的Rece步骤（或叫做程序）来实现。当然你可以改变下编码风格，完全尊重你的习惯。

Rece: recer.py

将代码存储在/home/hadoop/recer.py 中，这个脚本的作用是从mapper.py 的STDIN中读取结果，然后计算每个单词出现次数的总和，并输出结果到STDOUT。
同样，要注意脚本权限：chmod +x /home/hadoop/recer.py

#!/usr/bin/env python

from operator import itemgetter
import sys

# maps words to their counts
word2count = {}

# input comes from STDIN
for line in sys.stdin:
# remove leading and trailing whitespace
line = line.strip()

# parse the input we got from mapper.py
word, count = line.split('\\t', 1)
# convert count (currently a string) to int
try:
count = int(count)
word2count[word] = word2count.get(word, 0) + count
except ValueError:
# count was not a number, so silently
# ignore/discard this line
pass

# sort the words lexigraphically;
#
# this step is NOT required, we just do it so that our
# final output will look more like the official Hadoop
# word count examples
sorted_word2count = sorted(word2count.items(), key=itemgetter(0))

# write the results to STDOUT (standard output)
for word, count in sorted_word2count:
print '%s\\t%s'% (word, count)
测试你的代码（cat data | map | sort | rece）

我建议你在运行MapRece job测试前尝试手工测试你的mapper.py 和 recer.py脚本，以免得不到任何返回结果
这里有一些建议，关于如何测试你的Map和Rece的功能：
——————————————————————————————————————————————
\r\n
# very basic test
hadoop@ubuntu:~$ echo "foo foo quux labs foo bar quux" | /home/hadoop/mapper.py
foo 1
foo 1
quux 1
labs 1
foo 1
bar 1
——————————————————————————————————————————————
hadoop@ubuntu:~$ echo "foo foo quux labs foo bar quux" | /home/hadoop/mapper.py | sort | /home/hadoop/recer.py
bar 1
foo 3
labs 1
——————————————————————————————————————————————

# using one of the ebooks as example input
# (see below on where to get the ebooks)
hadoop@ubuntu:~$ cat /tmp/gutenberg/20417-8.txt | /home/hadoop/mapper.py
The 1
Project 1
Gutenberg 1
EBook 1
of 1
[...]
(you get the idea)

quux 2

quux 1

——————————————————————————————————————————————

在Hadoop平台上运行Python脚本

为了这个例子，我们将需要三种电子书：

The Outline of Science, Vol. 1 (of 4) by J. Arthur Thomson\r\n
The Notebooks of Leonardo Da Vinci\r\n
Ulysses by James Joyce
下载他们，并使用us-ascii编码存储 解压后的文件，保存在临时目录，比如/tmp/gutenberg.

hadoop@ubuntu:~$ ls -l /tmp/gutenberg/
total 3592
-rw-r--r-- 1 hadoop hadoop 674425 2007-01-22 12:56 20417-8.txt
-rw-r--r-- 1 hadoop hadoop 1423808 2006-08-03 16:36 7ldvc10.txt
-rw-r--r-- 1 hadoop hadoop 1561677 2004-11-26 09:48 ulyss12.txt
hadoop@ubuntu:~$

复制本地数据到HDFS

在我们运行MapRece job 前，我们需要将本地的文件复制到HDFS中：

hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -FromLocal /tmp/gutenberg gutenberg
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -ls
Found 1 items
/user/hadoop/gutenberg <dir>
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -ls gutenberg
Found 3 items
/user/hadoop/gutenberg/20417-8.txt <r 1> 674425
/user/hadoop/gutenberg/7ldvc10.txt <r 1> 1423808
/user/hadoop/gutenberg/ulyss12.txt <r 1> 1561677

执行 MapRece job

现在，一切准备就绪，我们将在运行Python MapRece job 在Hadoop集群上。像我上面所说的，我们使用的是
HadoopStreaming 帮助我们传递数据在Map和Rece间并通过STDIN和STDOUT，进行标准化输入输出。

hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop jar contrib/streaming/hadoop-0.19.1-streaming.jar
-mapper /home/hadoop/mapper.py -recer /home/hadoop/recer.py -input gutenberg/*
-output gutenberg-output
在运行中，如果你想更改Hadoop的一些设置，如增加Rece任务的数量，你可以使用“-jobconf”选项：

hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop jar contrib/streaming/hadoop-0.19.1-streaming.jar
-jobconf mapred.rece.tasks=16 -mapper ...

一个重要的备忘是关于Hadoop does not honor mapred.map.tasks
这个任务将会读取HDFS目录下的gutenberg并处理他们，将结果存储在独立的结果文件中，并存储在HDFS目录下的
gutenberg-output目录。
之前执行的结果如下：

hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop jar contrib/streaming/hadoop-0.19.1-streaming.jar
-mapper /home/hadoop/mapper.py -recer /home/hadoop/recer.py -input gutenberg/*
-output gutenberg-output

additionalConfSpec_:null
null=@@@userJobConfProps_.get(stream.shipped.hadoopstreaming
packageJobJar: [/usr/local/hadoop-datastore/hadoop-hadoop/hadoop-unjar54543/]
[] /tmp/streamjob54544.jar tmpDir=null
[...] INFO mapred.FileInputFormat: Total input paths to process : 7
[...] INFO streaming.StreamJob: getLocalDirs(): [/usr/local/hadoop-datastore/hadoop-hadoop/mapred/local]
[...] INFO streaming.StreamJob: Running job: job_200803031615_0021
[...]
[...] INFO streaming.StreamJob: map 0% rece 0%
[...] INFO streaming.StreamJob: map 43% rece 0%
[...] INFO streaming.StreamJob: map 86% rece 0%
[...] INFO streaming.StreamJob: map 100% rece 0%
[...] INFO streaming.StreamJob: map 100% rece 33%
[...] INFO streaming.StreamJob: map 100% rece 70%
[...] INFO streaming.StreamJob: map 100% rece 77%
[...] INFO streaming.StreamJob: map 100% rece 100%
[...] INFO streaming.StreamJob: Job complete: job_200803031615_0021

[...] INFO streaming.StreamJob: Output: gutenberg-output hadoop@ubuntu:/usr/local/hadoop$

正如你所见到的上面的输出结果，Hadoop 同时还提供了一个基本的WEB接口显示统计结果和信息。
当Hadoop集群在执行时，你可以使用浏览器访问 http://localhost:50030/ ，如图：

检查结果是否输出并存储在HDFS目录下的gutenberg-output中：

hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -ls gutenberg-output
Found 1 items
/user/hadoop/gutenberg-output/part-00000 <r 1> 903193 2007-09-21 13:00
hadoop@ubuntu:/usr/local/hadoop$

可以使用dfs -cat 命令检查文件目录

hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -cat gutenberg-output/part-00000
"(Lo)cra" 1
"1490 1
"1498," 1
"35" 1
"40," 1
"A 2
"AS-IS". 2
"A_ 1
"Absoluti 1
[...]
hadoop@ubuntu:/usr/local/hadoop$

注意比输出，上面结果的(")符号不是Hadoop插入的。

转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦