硬件资源：

三台CentOS5.6虚拟机（Vmware）

本机 windows7 64x

基本资源配置：

三台虚拟机均是克隆自同一个镜像

已经安装了Java环境（jdk1.6.0_25）

Hadoop路径在/usr/hadoop/hadoop-0.20.205.0

操作步骤：

1、机器名称规范

ip分别为128、129、130，将128设置为master，其他设置为slave

修改

/etc/sysconfig/network

/etc/hosts

两处配置，名称分别为hadoop-master\hadoop-slave01\hadoop-slave02

注意：此处名称最好不用使用下划线，有可能引发namenode的启动异常。

2、修改Hadoop配置 

在master节点的conf中修改master和slave文件，分别为机器的ip地址

修改master节点的conf中：

core-site.xml

<property>

<name>fs.default.name</name>

<value>hdfs://ip-master:9000</value>

</property>

mapred-site.xml

<property>

<name>mapred.job.tracker</name>                                   

<value>master:9001</value>                                

</property>

hdfs-site.xm

<property>

<name>dfs.replication</name>

<value>2</value>

</property>

注意此处的端口号均为默认。

3、建立m-s之间的ssh连接

首先master与slave机器都需要进行ssh信任文件生成，执行如下命令：

$ ssh-keygen -t rsa

中间需要输入的地方直接回车，接受缺省值即可

由于使用root用户登录，所以密钥文件生成在 /root/.ssh/文件夹下，存有一对密钥id_dsa和id_dsa.pub。

此处id_dsa（私钥）必须为其他用户不可读，所以文件属性应当是600

在master机器执行：

将id_dsa.pub（公钥）复制为 authorized_keys

$ cp id_dsa.pub authorized_keys

如果是多台机器需要,无密码登陆,则各自机器产生公钥追加到authorized_keys即可.

使用scp协议覆盖slave端的密钥文件夹，使得slave机器信任来自master的连接:

$ scp /root/.ssh/* ip-slave:/root/.ssh

4、启动服务 

建议将$HADOOP_HOME/bin下的所有文件给与执行权限：

$ chmod 777 bin

master作为namenod需要执行如下脚本：

$HADOOP_HOME/bin/hadoop namenode –format

完成后执行 $HADOOP_HOME/bin/start-all.sh

5、问题检查

在Hadoop根目录下的logs文件中，检查各个服务日志的启动情况

6、其他情况说明：

Q: $HADOOP_HOME is deprecated

A: 基本不会产生任何影响。由于脚本启动时设置了该环境变量，就会提示用户原有环境变量失效。可以取消环境变量设置，或者直接去bin/hadoop中找到这句话，去掉即可

Q: 无效的选项 -jvm / Unrecognized option: -jvm

A: 在使用root用户登录时 bin/hadoop 脚本就会进行判断，加上-jvm参数。此处是为了进入jsvc（http://commons.apache.org/daemon/jsvc.html），此处并不确定是否bug，也不再进行详细的追溯，解决方法就是进入 bin/hadoop 脚本中 找到 jvm 参数并去掉。

项目背景，一个新的产品，小型项目，纯开发人员3-4人，2名熟练开发人员，1名新手，偶尔会有协助人员。没有技术经理，项目经理身负多个项目，对项目进度关心不足，部门经理会协助进行工作和进度管理。可以看到管理还是比较混乱。

由于项目进度太慢，领导要求从我这边调一个熟练人员协助开发。我也基本了解他们的项目状况，为了不让我的人进去抓瞎，我就和他一起去了解项目情况。

项目状况比较糟糕，介入项目时已经开发了一段时间，保留的文档只有两份，一副数据库说明，一份非常粗略的需求说明，而且还与开发进度不同步，就是没有维护。

我了解了一下项目目前的难度，开发人员和我反映一个是人员熟练程度的问题，二是需求变更的问题。我整体了解了一下项目目前的需求和设计，以及进度。就挑了一个模块询问他们的变更情况，这个模块是一个关键词匹配功能。结果是领导看了他们的页面之后，嫌信息量太少，就要求提供一些更细化的数据展示。开发人员问我有什么意见，我就简单讲了一下页面大概怎么构建。其中有一个点，是用于变更数据范围，即查询的表变更，我一开始觉得使用下拉框就可以，产生了一些意见。有人建议分为不同子模块，或者tab页，或者分为多块并列展示。我想了想，就给他们讲了我认为几种方案的优点缺点及适用范围。

1.       多块并行展示：

多个不同范围的数据在同一页面中分为不同区域以相同形式展示。原因是由于多块数据之间有一定的关联因果关系，或值得对比。适用范围：如购物网站中的多个物品比较。

2.       Tab页：

同一个页面的多个tab页，表示多个tab页中的数据可能在一定的领域概念之下有一定的关联，但关联度不强。因为tab页更重要的是强调一个同步工作的状态，即A tab页查看一定信息，会打开B tab页查看其他信息，中途还会切回A tab页。适用范围：如邮箱中，收件箱和草稿箱。

3.       下拉框

下拉框作为查询条件的一部分，常用于有着常规或固定的可选择内容中（如性别，月份），更多是以过滤的形态出现，即下拉框更适合针对某表的某个字段过滤，如果针对的是数据范围或是对用户需要直观了解的重要业务条件则不太合适。适用范围：如在考试成绩中使用下拉框过滤“男女”或“及格不及格”。

4.       单选框

单选框与下拉框的作用范围相似，但是不同之处在于将被选项全部展示，目的在于能够让用户清楚的了解当前数据显示的实际范围或条件，以及备选的其他范围或条件。更适用于选项与实际业务及当前展示数据关系重要，不同选项可能会引发用户的不同行为。适用范围：如银行系统显示了当前用户下绑定多个帐号时，使用单选框。

经过上述讨论，我们仔细分析了这个模块中用户的实际需求，以及可能后续操作，最终选择的单选框的方案。

目前还没有后续，但是我想我们基于用户真是需求的挖掘和后续操作的认真分析，会让我们在与领导进行需求讨论的时候有更加充分合理的依据。

回来之后我又看了看淘宝的搜索页面，比如就搜索“鞋子”来讲，将品牌这栏设置为单选和下拉将是完全不同的效果，而确定方案的理由则是对于用户的需求和实际行为的深入研究。这个应该是需求分析和调研的结果。将搜索条件以tag的形式标注于页面上，并且可以直接点击X按钮进行删除，我觉得更加可以倾向为用户体验。满足并充分考虑了用户实际需求的是好的需求分析，能够简化并引导用户行为的是好的用户体验。

当我们面临的系统感觉非常难用的时候，往往这时候并非是用户体验差，我们应该检讨的是我们对用户需求有没有好好挖掘，做出来的是不是用户想要、用户能用的系统。

MongoDB介绍

当今NoSQL领域中有很多有力的竞争者通过多种方式来处理海量数据问题。其中重要的解决方案之一就是MongoDB。MongoDB是面向文档的弱结构化存储方案，使用JSON格式来展现、查询和修改数据。

MongoDB文档相当完备，扩展规模与安装一样简单。它提供冗余、切片、索引以及map/reduce等概念支持。MongoDB的开源社区非常大且非常活跃。MongoDB在很多大型产品中被实际运用，如：Disney, Craigslist, Foursquare, Github 和SourceForge。MongoDB是一个开源项目，由10gen.com建立并维护，该公司由DoubleClick的前任执行人员创立。同时，10gen也提供了极好的商业支持与参与建设。

MongoDB 与 NoSQL: 缺陷与优势

MongoDB作为一个可用NoSQL方案具有很多优势。我刚开始接触NoSQL数据库了解了一系列基于Java的方案，并且花了大量的时间来弄懂什么是列家族，Hadoop与HBase的关系，ZooKeeper到底是什么。当我终于全部清楚之后，发现Cassandra与HBase确实是对于NoSQL领域非常可靠、可信赖的解决方案。但与其他的解决方案相比，MongoDB让我在能够开始写代码之前，不用理解那么多的概念。

与其他软件相似，MongoDB也存在缺陷。经过一段时间使用MongoDB，我列举经历过并需要注意的一些事情，我成为“Gotchas”：

• 不要按照关系型数据库来思考。这很明显，MongoDB使得构建和执行复杂查询变得非常容易。当实际使用的时候，你会主要关注于效率问题（像我一样）。
• MongoDB的索引是二进制的树。如果你不是很熟悉B-tree，可能需要了解一下。这些都涉及到构建符合提供查询条件需求的建立索引的方式。
• 小心的设计索引结构。这涉及到上面提到的B-tree。刚开始我的索引包含文档中的很多字段，以防我会使用到他们。不要犯同样的错误。我有一个很小集合的索引（大约1千万记录）增长到超过17GB的空间，比集合本身还大。你应该不会想要索引一个包含成百上千个实体的列表字段。
• MongoDB采用了非常有意思的方式来实现NoSQL：采用BSON作为存储，JSON作为展示，JavaScript用于管理和Map/Reduce。因此也引起了一些小问题比如这个 （破坏了Number和Long的相等操作），在MongoDB逐渐流行之后，可能会不断的展示出来。

MongoDB, 命令行与驱动

MongoDB基本是使用JavaScript客户端命令行程序来进行复杂任务管理的，如数据整合和简单信息处理，编程都是完全使用JavaScript语言来的。本文中，我们会展示命令行的使用示例。现在有大量的MongoDB客户端产品提供，并且由MongoDB社区来支持驱动。通常每种编程语言都有驱动，并且所有流行的语言都有包括，一些不那么流行的也包含在内。这篇文章展示了使用MongoDB的Java驱动，并使用一个ORM库（MJORM）与之进行比较。

介绍 MJORM: MongoDB的ORM方案

在解决的众多有意思的问题中，最近NoSQL数据存储在开发者中主要的问题趋势就是对象关系映射。对象关系映射就是将传统中保存在关系型数据库中的持久化数据映射为在应用程序中使用的对象。这使得编程语言使用起来更加流畅和自然。

MongoDB面向文档的架构使得它非常适合对象关系映射，因为文档本身就是以对象形式存储的。可惜没有太多的MongoDB的Java对象关系映射库，但是还是有一些，如morphia-(A type-safe Java library for MongoDB)， spring-data(SpringData项目的MongoDB实现)

这些ORM库大量使用了注解，因为一些原因对我不适合，其中最重要的就是这些被注解的对象在多个项目中的兼容性问题。这让我开始了mongo-Java-orm 或者 "MJORM" (发音 me-yorm)项目，一个MongoDB的Java对象关系映射项目。MJORM是在MIT许可之下，并且在发布在了google code project。项目采用maven构建，并且maven构件仓库托管于google code版本控制服务器。MJORM的最新可用发布版本为0.15，已经由一些项目使用与生产环境中。

开始使用ORM

加入MJORM 库

Maven的使用者首先应当在pom.xml中加入MJORM的maven仓库，使得MJORM构件可用。

<repository>

         <id>mjorm-webdav-maven-repo</id>

         <name>mjorm maven repository</name>

         <url>http://mongo-Java-orm.googlecode.com/svn/maven/repo/</url>

         <layout>default</layout>

</repository>

然后加入依赖:

<dependency>

         <groupId>com.googlecode</groupId>

         <artifactId>mongo-Java-orm</artifactId>

         <version>0.15</version>

</dependency>

这样就可以在应用中引入MJORM代码。假如没有使用maven，则你需要手动下载MJORM的pom.xml中列举的所有依赖。

建立 POJOs

依赖已经导入，可以开始编码了。我们从POJO开始:

class Author {

         private String firstName;

         private String lastName;

         // ... setters and getters ...

}

class Book {

         private String id;

         private String isbn;

         private String title;

         private String description;

         private Author author;

         // ... setters and getters ...

}

我们在这个对象模型中的描述是，作者有ID、姓和名，书有ID、ISNB、标题、描述和作者。

你可能注意到书的id属性是一个字符串，这是为了适应MongoDB的对象ID类型。MongoDB的ID是一个12字节的二进制值显示为一个十六进制的字符串。MongoDB要求集合中的每个文档都必须有一个唯一id，但不要求一定要是ObjectId。目前MJORM只支持ObjectId，并且显示为字符串。

你也可能注意到了Author没有id字段。这是因为Book是它的父文档，因此不需要有id。记住，MongoDB只要求集合中的文档在根级别的id。

创建XML映射文件

下一个步骤就是建立XML映射文件，MJORM能够将MongoDB文档转换为对象。我们为每个文档创建一个对象作为示范，无论将所有的映射放在一个XML文件中还是分开都是可以的。

Author.mjorm.xml:

<?xml version="1.0"?>

<descriptors>

         <object class="Author">

                 <property name="firstName" />

                 <property name="lastName" />

         </object>

</descriptors>

Book.mjorm.xml:

<?xml version="1.0"?>

<descriptors>

         <object class="Book">

                 <property name="id" id="true" auto="true" />

                 <property name="isbn" />

                 <property name="title" />

                 <property name="description" />

                 <property name="author" />

         </object>

</descriptors>

这些映射文件能够很好的自解释。descriptors 元素是根元素，必须包含在每个映射文件中。在它下面是object元素定义了文档与之对应的类。Object包含的property 元素主要用于描述POJO中的属性以及这些属性如何与MongoDB中的文档想对应。property 元素至少必须包含一个name 属性，这个元素就是POJO和MongoDB的文档中的属性名称。column 属性则是可选的，用于特定一个在MongoDB文档中的可选属性名称。

property 元素当中的id属性应该是对象的唯一识别。一个对象只能有一个property 元素包含id属性。auto 的设置会使得MJORM在持久化时为该属性自动生成一个值。

可以在google code的MJORM项目主页中查看XML映射文件的更多细节描述。

整合POJO与XML

我们创建了数据模型以及映射文件，使得MJORM可以从MongoDB序列号以及反序列号POJO。我们可以进行一些有意思的事情了，首先打开MongoDB的链接：

Mongo mongo = new Mongo(

         new MongoURI("mongodb://localhost/mjormIsFun")); // 10gen driver

Mongo 对象是由10gen编写的Java驱动提供的。示例中连接了一个本地的MongoDB实例中的mjormIsFun数据库。接下来我们创建MJORM ObjectMapper 。目前ObjectMapper 在MJORM中的唯一实现就是XmlDescriptorObjectMapper，使用XML结构描述信息。可能之后会增加对注解或其他结构定义的支持。

XmlDescriptorObjectMapper objectMapper = new XmlDescriptorObjectMapper();

mapper.addXmlObjectDescriptor(new File("Book.mjorm.xml"));

mapper.addXmlObjectDescriptor(new File("Author.mjorm.xml"));

建立好了XmlDescriptorObjectMapper 并且加入了映射文件。接下来建立由MJORM提供的MongoDao 对象的实例。

DB db = mongo.getDB("mjormIsFun"); // 10gen driver

MongoDao dao = new MongoDaoImpl(db, objectMapper);

首先我们要获得10gen驱动提供的DB对象实例。然后使用DB和ObjectMapper 建立MongoDao 。我们准备开始持久化数据，建立一个Book 然后保存到MongoDB中。

Book book = new Book();

book.setIsbn("1594743061");

book.setTitle("MongoDB is fun");

book.setDescription("...");

book = dao.createObject("books", book);

System.out.println(book.getId()); // 4f96309f762dd76ece5a9595

首先建立Book 对象并且填值，然后调用MongoDao 的 createObject 方法，将Book 对象传入"books" 的集合中。MJORM会按照之前的xml映射文件将Book 转换为DBObject (这是10gen的Java驱动使用的基本类型)，并保存一个新的文档进"books" 集合。MJORM返回Book对象时，id属性会被填充。请注意，MongoDB默认是不需要在使用前建立数据库或集合的，系统会在需要时自动创建，这可能会造成某些困扰。在MongoDB的命令行中查看Book对象大概如下：

> db.books.find({_id:ObjectId("4f96309f762dd76ece5a9595")}).pretty()

{

         "_id":          ObjectId("4f96309f762dd76ece5a9595"),

         "isbn":         "1594743061",

         "title":        "MongoDB is fun",

         "description": "..."

}

我们来看看假如不用MJORM而直接使用10gen的Java驱动，如何使用createObject 方法：

Book book = new Book();

book.setIsbn("1594743061");

book.setTitle("MongoDB is fun");

book.setDescription("...");

DBObject bookObj = BasicDBObjectBuilder.start()

         .add("isbn",              book.getIsbn())

         .add("title",             book.getTitle())

         .add("description",       book.getDescription())

         .get();

// 'db' is our DB object from earlier

DBCollection col = db.getCollection("books");

col.insert(bookObj);

ObjectId id = ObjectId.class.cast(bookObj.get("_id"));

System.out.println(id.toStringMongod()); // 4f96309f762dd76ece5a9595

下面进行对象的查询:

Book book = dao.readObject("books", "4f96309f762dd76ece5a9595", Book.class);

System.out.println(book.getTitle()); // "MongoDB is fun"

readObject 方法根据给定文档的id从指定的集合中读取文档，转换为对象（再次使用映射文件）并返回。

敏锐的读者会注意到Book还没有指定Author，仍然保存了。这归咎于MongoDB的结构不敏感的特性。我们不能要求集合中的文档包含所有属性（id属性是必须的），所有在MongoDB中没有Author的Book是可以的。我们现在为Book添加一个Author并且更新一下：

Author author = new Author();

author.setFirstName("Brian");

author.setLastName("Dilley");

book.setAuthor(author);

dao.updateObject("books", "4f96309f762dd76ece5a9595", book);

现在Book就包含了Author，并且在MongoDB中持久化了。现在在命令行查看了Book：

> db.books.find({_id:ObjectId("4f96309f762dd76ece5a9595")}).pretty()

{

         "_id":          ObjectId("4f96309f762dd76ece5a9595"),

         "isbn":         "1594743061",

         "title":        "MongoDB is fun",

         "description": "..."

         "author": {

             "firstName": "Brian",

             "lastName": "Dilley"

         }

}

可以看到持久化的Book中已经包含了author。不使用MJORM来操作一遍：

Author author = new Author();

author.setFirstName("Brian");

author.setLastName("Dilley");

book.setAuthor(author);

DBObject bookObj = BasicDBObjectBuilder.start()

         .add("isbn",              book.getIsbn())

         .add("title",             book.getTitle())

         .add("description",       book.getDescription())

         .push("author")

                 .add("firstName",         author.getFirstName())

                 .add("lastName",  author.getLastName())

                 .pop()

         .get();

DBCollection col = db.getCollection("books");

col.update(new BasicDBObject("_id", bookObj.get("_id")), bookObj);

对于MongoDao 方法的深入讨论已经超出了本文的范围。对于将MJORM有兴趣用于实际项目中的用户强烈建议了解一下MJORM项目提供的相关文档，或者MongoDao 接口提供的相关用法。

总结

希望这篇文章对MongoDB和MJORM的亮点有所展示。MongDB是一个优秀的呃NoSQL数据存储，有着大量优秀的特性，会是NoSQL市场中长期竞争者。若你会在一个Java项目中使用MongoDB，希望你也能够考虑使用MJORM作为你的ORM框架。十分欢迎大家提交特性需求、错误异常报告、文档和源码修正。

作者 Bio

Brian Dilley 是一个经验丰富的高级工程师以及项目领导，在Java/Java EE /Spring Framework/Linux内部结构理解和管理有着超过13年的经验。Brian对于创业公司有很多经验，推向市场，构建/维护产品等。他是Iaas、cloud、PHP和Linux的专家，熟悉产品的采购、安装及配置定义，以及公司的软硬件架构包括负载均衡、数据库、微博等。可以follow Brian的 Twitter 。

转变了数据管理方式的技术正是虚拟化。低成本存储、云计算、NoSQL数据库以及Hadoop。当我们提起虚拟化时，已经远远超出为一台物理机器提供一套软件实例这一概念。时至今日，我们可以虚拟化服务器、存储以及网络。所有这些虚拟化意味着我们不再被这些物理条件所限制，能够迅速构建物理环境以支持我们特定时刻的特定需求。当面对Gb、Tb、Pb等级数据量的处理需求时，我们基本能摆脱结构化的数据仓库。我们不在需要仅仅为了发掘业务的某一方面而建立一个特殊的环境了。

低成本存储在业务的数据存储方面节省了开支。高昂的存储成本会使得企业寻找在限定规模的数据之上进行关键业务分析的方案，这样使得如何选择最重要的数据变得十分关键，而且还限制了系统能够处理的数据的质量。

负面影响便是业务最终可能面临很少的选择，因为没有足够的历史数据提供从而识别一个有效关键模式。或者因为高昂的投入使得业务被停止，而使用常规惯例来识别模式。

云计算为那些需要通过海量数据源在合理时间范围内产生结果的需求提供了一个可用的方式。海量数据处理需要两点：弹性存储，CPU。高速网络很有帮助，但是待会我们会看到在发掘软件在处理海量数据时，它并非是系统的瓶颈。弹性存储意味着企业不会在期望操作的数据规模或类型上受到限制，降低了使用数据仓库无法获取最佳结果的风险。更多的CPU使得结果能够在期望的时间范围内更快的被交付。

NoSQL提供了海量数据的支持，但与传统的关系型数据库没有关联。而且大部分NoSQL数据库是开源的，无须支付购买证书等费用。NoSQL对于表结构有着惊人的灵活性，无须随着系统的改进而不断修改完善定义。NoSQL可以支持不同数据源的合并查看，从而成为EII之后另一个备选方案，这或许是NoSQL最重要的方面了。

NoSQL内置了数据冗余与分布式数据存储机制。海量数据的最大问题之一就是磁盘读写，NoSQL通过将数据分布至一系列节点来缓解这个问题。当一个查询请求发出时，这些节点能够并行查询自身节点，而不是仅仅依靠一块磁盘，一个磁盘阵列或一条网络连接等，数据查询能够在节省了读写开支之后变得更加迅速。

最终，我们来讨论Hadoop，集合了上述所有技术力量与一身的用于检测和分析数据的框架。有些人可能认为Hadoop是一项NoSQL技术，实际上Hadoop是一个分布组件的java框架，用于分解“吃大象”（此处也双关Hadoop是以创立者的儿子给自己的一个大象玩具起的名字）的工作——每次一口。

Hadoop自身实际上与待处理数据是各自独立的。它将大型查询任务分解为小的并行查询任务，然后收集结果，并整合出答案返回给用户。Hadoop相对于NoSQL来说是一个并行查询框架，通过云计算驱动节点，运行在低成本存储及虚拟化技术之上。

Kicking的知识回顾

当EII第一次作为最佳实践出现于2003-2004年，关键要素就是无需再移动数据了。当时大部分的数据中心仍然运行于低速网络中，有限的空间用于复制数据。之后，EII成为了当时可用技术和问题域中最优秀的解决方案。EII的某些方面的优秀即使在海量数据中也是很显著的。

EII的优点之一就是将处理过程转移到数据所在地。海量数据方案的关键架构要素之一就是将处理过程转移到数据所在地，而不是转移数据。EII中的一个重要原则就是使用数据归属地的查询功能。这项实践就是构建靠近数据源网络的Web Service，能够建立起通用查询接口，但只针对本地数据库进行查询。我们通过开放的基于Web的接口解决了数据的专有格式的问题，从而使得多个数据子集能够迅速的整合并以统一模式展示。

有了低成本存储和10G网络之后，我们就不必那么担心数据冗余与数据迁移，但还是有其他问题存在的，数据仓库无法确保数据的原始性便是其中之一。在EII中，我们将从原始数据源获取数据视为“黄金准则”，这样就能够保证信息未被修改过，且是准确的。

Big Data要求数据必须转移到新的物理位置，这样可信任度又成为了问题。EII的那些获取基线数据的最佳实践仍然是相关而且重要的。实际上，那些为EII设计开发的Web Services接口最终在Big Data的启用中扮演主要角色。

当然，讨论数据管理不能不涉及到安全问题。EII在安全领域中还是超过了Big Data。技术上来说，Big Data在数据集成方面更加高效与敏捷，但是大部分缺少了固有的安全性，因为在设计上会加大处理的难度。所以，可能要由源系统来担任起数据访问安全方面的责任。因为EII直接在源系统中查询数据，所以必须要求有适当的授权，否则查询就将失败。

上述关于安全讨论描述的是内在的安全控制情况。将访问权限控制列表集成进数据库是非常合理的，这将确保安全能够作为查询的一部分进行维护。然后，一旦能够直接查询NoSQL数据源，就意味着能够自由的访问你所有的数据。

总结

引用老的Virginia Slims的广告中的台词：“我们已经历很长的路途了，宝贝儿！”文中讨论到的技术的发展已经对21世纪第二个10年中的的数据解决方案产生了巨大的影响。商业化与小型化扫除了一些思想体系上的障碍，使得架构师能够专注于问题本身，而不是寻找一些实用及可实现的问题解决方案。构建10000个节点的处理引擎，能够在数秒内处理Pb级别的数据量，却只消耗每小时几便士，这就是数据处理的美好前景。

有了这些新工具，我们就要重新考虑如何推进数据管理。为何数据无法被很好地被维护整合，并且需要花费数万美元。数据管理几乎是每个大中型企业的心病。数据管理曾经在存储、管理、访问、整合以及查询上花费巨大，但是今后不再会是这样了。

关于作者

JP Morgenthal 是在IT策略与云计算方面的世界级专家之一。他在企业复杂问题域的解决方案实施上有着25年的经验。JP Morgenthal以其在技术方面的深度和广度，有利的支持他在企业问题域中的敏感度。他在集成、软件开发和云计算是一位让人尊敬的作者，同时也是InfoQ在引领云计算方面的编辑，并且参与了“云计算：评估风险”项目。 

原文链接：http://www.infoq.com/articles/DataIntegrationFromEIItoBigData

其实软件开发区分阶段已经广为大家接受，普遍的概念即需要区分为分析、设计、实施、测试、发布，过程中会产生若干产物，如需求说明书、概要设计、详细设计等。若提及过程方法，如RUP的话，主要分为四大阶段，先启（Inception）、精华（Elaboration）、构建（Construction）、交付（Transition）迭代的开发方式，而Scrum的核心概念则是Sprint。

Maven在项目管理中有那些帮助呢？Maven能够从一个信息中心为项目提供构建，报告，文档编制等工作。在Maven官方介绍《What is maven》中介绍了maven的项目目标（Objectives）（http://maven.apache.org/what-is-maven.html），如下：

l         简化构建过程

l         提供统一的构建系统

l         提供项目质量信息

l         提供对于开发最佳实践的指导

l         允许对于新特性的透明整合

对于Maven影响最为深刻的就是它的构建系统，几乎贯穿了整个实施阶段。作为对比我们参考一下RUP的Construction阶段，以及Scrum的单个Sprint过程。

RUP的Construction阶段的目标：

这个阶段的目标是澄清需求并基于架构基线完成开发。

l          通过优化资源来缩减开支，并避免无意义的争执与返工。

l          实用性与质量兼具。

l          尽快发布可用版本。

l          完成对所有功能的分析、设计、开发、测试。

l          采用增量迭代的模式完成开发并准备交付。

l          检查项目发布的所有资源是否已经准备完全。

l          形成项目组之间的并行开发。

在《硝烟中的Scrum与XP》一书中，介绍了作者实施Scrum的过程。在一个Sprint中，不是只有Sprint backlog、burn down chat等，实施过程中的敏捷思想也是其中的核心，我们来看看敏捷信奉的一部分最佳实践：

l          简单设计（Simple Design）

l          结对编程（Pair Programming）

l          测试驱动（Test-Driven Development）

l          小规模发布（Small Releases）

l          持续集成（Continuous Integration）

l          集体拥有代码（Collective Code Ownership）

l          编码标准（Coding Standard）

Maven对于上述目标中的质量（实用性与质量，以测试驱动）、可用（可用版本，小规模）、资源管理等均能发挥较大的作用。主要是其定义了一套完整优秀的构建生命周期机制，其基本阶段如下：

l         validate – 验证项目正确性及依赖有效性

l         compile – 编译项目源码

l         test – 使用合适的单元测试框架对编译后的源码进行测试，测试代码不会被打包或发布

l         package –将编译后的代码以规定格式打包，如Jar

l         integration-test – 将打包后的代码放置于环境中进行集成测试

l         verify – 检查打包的有效性并验证质量标准

l         install – 将包装载入本地仓库，以提供与其他项目的依赖

l         deploy – 将包发布至远程仓库中

其上每一个阶段实际都分为前中后三个阶段，用户可以定义在每一个阶段前后进行自定义的操作，打造自己的构建流程（如在某个阶段执行前制定特殊的配置文件，完成后再改回默认）。对于阶段的实际使用方式，如：validate可以项目所有依赖有效，test可以针对dao层进行单元测试，intergration-test可以对完整业务流程或服务层等进行集成测试。

在项目中实际使用的经验，对于标签的使用心得：

1.<dependency> - 依赖标签，最重要的标签，也是Maven的基础功能。

              <dependency>

                     <groupId>junit</groupId>

                     <artifactId>junit</artifactId>

                     <version>4.8.1</version>

                     <scope>test</scope>

              </dependency>

2. <repository> - 资源仓库，可以包含多个，常用的有Maven，Jboss等，如下是公司内建的Nexus资源库。

<repository>

                     <id>Suntang's Maven Repository</id>

                     <name>Suntang Nexus Repository</name>

                     <url>http://10.10.10.33:8081/nexus/content/groups/public</url>

              </repository>

3. <profile> - 解释为情景模式可能较为合适。可以有多个，在何种场景下会使用哪些属性、插件等。如下例子便是当缺失某个文件时激活。

（感觉写的不错的一篇，http://blog.csdn.net/turkeyzhou/article/details/4894657）

<profile>

 <activation>

<file>

<missing>target/generated-sources/axistools/wsdl2java/org/apache/maven</missing>

</file>

</activation>

 </profile>

4.<build> - 构建过程。是进行整个项目管理的核心标签。重点需要掌握的知识就是生命周期。

（http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference）

下面的例子就是制定了打包时的资源路径，并且定义了最终打包的名称。

       <build>

              <resources>

                     <resource>

                            <directory>src/main/resources</directory>

                            <includes>

                                   <include>**/*</include>

                            </includes>

                     </resource>

                     <resource>

                            <directory>src/main/assembly</directory>

                            <includes>

                                   <include>**/*</include>

                            </includes>

                     </resource>

              </resources>

              <finalName>po</finalName>

       </build>

4.< plugin > - 支持插件。如单元测试自动化，之前提到的Ant的插件等。若有某些功能觉得不顺手，可以尝试官网找一下有没有合适的插件（http://maven.apache.org/plugins/index.html）。

下面的例子就是在集成测试中，只运行后缀为TestSuitex.java的测试类

                     <plugin>

                            <groupId>org.apache.maven.plugins</groupId>

                            <artifactId>maven-surefire-plugin</artifactId>

                            <version>2.4.3</version>

                            <configuration>

                                   <junitArtifactName>junit:junit</junitArtifactName>

                                   <forkMode>once</forkMode>

                            </configuration>

                            <executions>

                                   <execution>

                                          <id>default-test</id>

                                          <phase>integration-test</phase>

                                          <goals>

                                                 <goal>test</goal>

                                          </goals>

                                          <configuration>

                                                 <skip>false</skip>

                                                 <includes>

                                                        <include>**/*TestSuitex.java</include>

                                                 </includes>

                                          </configuration>

                                   </execution>

                            </executions>

                     </plugin>

我作为项目经理和技术架构管理人员负责公司一条生产线。讨论之后，首席架构师希望我们能够实施TDD。在实施TDD的过程中，设计实施过程的整体思路就是：单元测试用例文档 - 实施单元测试 - 实施业务代码 – 修改业务代码逻辑。实施人员需要参与每个环节，按照规范编写单元测试用例文档。单元测试我们按照模块（模块与人员基本没有重合）划分包（suite），保证实施起来不会产生干扰。。技术架构决定采用：maven，junit，svn。

技术背景：

技术架构设计上，我们封装了dao层的实现，所以实施人员基本无需涉及dao层的开发。服务层我们采用了JAX-RS的服务规范，对外开发服务接口。

在测试覆盖率方面，我们基本不要求对dao层的单元测试，但要求在服务层的单元测试达到100%。由于服务层是Restful WS的模式，所以我们采用了模拟HTTP请求的方式在测试服务层。

由于需要模拟HTTP的请求，所以我们在单元测试中采用了jetty作为内嵌服务器，单元测试开始时同一启动，完成后关闭。

实施过程：

开发过程中，实际实施的时候发现一个问题，对于测试数据的管理问题。即测试当中需要一定的数据环境来验证业务逻辑。这个数据环境如何建立？

方案一，使用dbunit和hsqldb。在测试启动时重建数据环境。

否决，原因：

1.与实际运行环境差异较大。

2.反复重建数据环境，效率上有缺失。

3.技术架构增加，学习和维护曲线较大。

讨论后决定使用

方案二，独立出一套测试数据库，完整数据环境。考虑到增删改与查询的冲突，制定默认规则，如id在20之内的不允许进行任何改动。以尽量隔离增删改的影响。

针对方案二，有一个较大的问题，如何在开发过程中自由的切换数据库配置呢？由于我们还是用了Hudson作为CI服务器，还要考虑到打包的过程。整体考虑之后，有两个步骤需要注意：

一、开发过程。开发过程中，我们将配置直接指向测试数据库。

二、打包过程。使用了maven，存在单元测试配置与最终产品配置的冲突。

所以最终问题的焦点集中在打包过程的maven配置方案。

搜索之后比较好的资料有

MAVEN:如何为开发和生产环境建立不同的配置文件 --我的简洁方案

（http://www.blogjava.net/scud/archive/2010/10/27/336326.html）

这篇博客是介绍在maven 中使用mvn package -P test 这样的自定义profile来实现的。这样是可行的，但是在Hudson中无法实现一条命令切换两套配置。

于是继续寻找，最终在maven的官方网站找到《Building For Different Environments with Maven 2》（http://maven.apache.org/guides/mini/guide-building-for-different-environments.html）看完文章之后发现，实际maven提供了一个非常好的插件maven-antrun-plugin，以实现某些ant的功能。此处还需要了解的知识就是maven的构建生命周期标准（http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html）。基于上述两个知识点，我们制定出如下方案，在项目中建立测试配置目录及产品配置目录，在maven的package阶段开始前，都使用测试配置，运行集成测试，完成在package阶段前将产品配置覆盖至打包文件夹内，然后进行打包。思路就是这样，下面贴出pom文件的关键部分。

POM.xml

<!—profile 节点定义覆盖文件的方式内容 -->

       <profiles>

              <profile>

                     <id>product</id>

                     <build>

                            <plugins>

                                   <plugin>

                                          <artifactId>maven-antrun-plugin</artifactId>

                                          <executions>

                                                 <execution>

                                                        <id>pre_product</id>

                                                        <phase>prepare-package</phase>

                                                        <goals>

                                                               <goal>run</goal>

                                                        </goals>

                                                        <configuration>

<!—此处与ant的任务相似 -->

                                                               <tasks>

                                                                      <delete file="${project.build.outputDirectory}/spring/dataSourceContext.xml" />

                                                                      <delete file="${project.build.outputDirectory}/log4j.properties" />

                                                                      <copy file="src/product/assembly/log4j.properties" tofile="${project.build.outputDirectory}/log4j.properties" />

                                                                      <copy file="src/product/assembly/spring/dataSourceContext.xml" tofile="${project.build.outputDirectory}/spring/dataSourceContext.xml" />

                                                               </tasks>

                                                        </configuration>

                                                 </execution>

                                          </executions>

                                   </plugin>

                            </plugins>

                     </build>

              </profile>

       </profiles>

<!—构建过程 -->

       <build>

<!—指定资源目录 -->

              <resources>

                     <resource>

                            <directory>src/test/resources</directory>

                            <includes>

                                   <include>**/*</include>

                            </includes>

                     </resource>

                     <resource>

                            <directory>src/test/assembly</directory>

                            <includes>

                                   <include>**/*</include>

                            </includes>

                     </resource>

              </resources>

              <finalName>po</finalName>

<!—指定集成测试配置 -->

              <plugins>

                     <plugin>

                            <groupId>org.apache.maven.plugins</groupId>

                            <artifactId>maven-surefire-plugin</artifactId>

                            <version>2.4.3</version>

                            <configuration>

                                   <junitArtifactName>junit:junit</junitArtifactName>

                                   <forkMode>once</forkMode>

                            </configuration>

                            <executions>

                                   <execution>

                                          <id>default-test</id>

                                          <phase>integration-test</phase>

                                          <goals>

                                                 <goal>test</goal>

                                          </goals>

                                          <configuration>

                                                 <skip>false</skip>

                                                 <includes>

                                                        <include>**/*TestSuitex.java</include>

                                                 </includes>

                                          </configuration>

                                   </execution>

                            </executions>

                     </plugin>

              </plugins>

       </build>

由于公司的业务需要，要在网络收集网页之后对网页进行结构化的解析，这个结构化过程希望能够基于HDFS并且使用MR算法实现。

我虚拟了一个需求，针对http://hadoop.apache.org/common/releases.html 页面，假设已经下载了页面并入库。要求最终体现的数据是 “版本号+完整链接（即a标签全部内容）” 的结构。

伪分布式环境搭建在虚拟机上，操作系统是centos5.5，hadoop的版本是1.0.0.

插入书中的一些环境搭建的介绍

书中的2.1节中介绍了每个进程的作用。2.2节中的ssh设置也比较重要，否则好像会一直提示你输入密码。2.3.2节介绍了伪分布式的配置方式，对core-site.xml，mapred-site.xml，hdfs-site.xml进行配置之后，需要对namenode节点进行格式化。

bin/hadoop namenode –format

hadoop的根目录为/usr/local/hadoop-1.0.0，直接启动start-all.sh

[root@localhost hadoop-1.0.0]# ./bin/start-all.sh

启动成功后使用jps命令

jdk小工具jps介绍 

jps(Java Virtual Machine Process Status Tool)是JDK 1.5提供的一个显示当前所有java进程pid的命令，简单实用，非常适合在linux/unix平台上简单察看当前java进程的一些简单情况。 jps存放在JAVA_HOME/bin/jps

[root@localhost hadoop-1.0.0]# jps

5694 SecondaryNameNode

5461 NameNode

5578 DataNode

6027 Jps

5784 JobTracker

5905 TaskTracker

这几个进程是非常重要的。很多时候出现意外就是因为某项服务未启动或异常。可以看到上面的命令上打印出日志位置。出现异常后可以在日志中查看详细的堆栈信息。

至此，hadoop已经启动，环境已经准备就绪。

下面准备我们的测试数据，将目标页面的html保存为news.txt，伪分布式也同样支持hdfs，所以我们使用 fs –put 将news.txt存入hdfs中。

[root@localhost hadoop-1.0.0]# ./bin/hadoop fs -put /mnt/hgfs/shared/news.txt /user/root

[root@localhost hadoop-1.0.0]# ./bin/hadoop fs -lsr /userdrwxr-xr-x   - root supergroup          0 2012-04-01 11:22 /user/root

-rw-r--r--   1 root supergroup       3935 2012-04-01 11:22 /user/root/news.txt

实现的代码在eclipse中使用maven打包，上传至虚拟机。

文件名com.suntang.analyse.hadoop-0.0.1.jar。
使用hadoop的中的jar命令调用该jar文件。

[root@localhost hadoop-1.0.0]# ./bin/hadoop jar com.suntang.analyse.hadoop-0.0.1.jar com.suntang.analyse.hadoop.AnalyseJob /user/root/news.txt output_root_test

12/04/01 14:40:04 INFO input.FileInputFormat: Total input paths to process : 1

12/04/01 14:40:05 INFO mapred.JobClient: Running job: job_201204011420_0001

12/04/01 14:40:06 INFO mapred.JobClient:  map 0% reduce 0%

12/04/01 14:40:19 INFO mapred.JobClient:  map 100% reduce 0%

12/04/01 14:40:31 INFO mapred.JobClient:  map 100% reduce 100%

12/04/01 14:40:37 INFO mapred.JobClient: Job complete: job_201204011420_0001

…

此处注意我犯的一个错误：

[root@localhost hadoop-1.0.0]# ./bin/hadoop jar com.suntang.analyse.hadoop-0.0.1.jar AnalyseJob -libjars hadoop-core-1.0.0.jar /user/root/news.txt output_root_test

Exception in thread "main" java.lang.ClassNotFoundException: AnalyseJob

提示找不到类，因为我忘了写完整类名，命令应该改为

./bin/hadoop jar com.suntang.analyse.hadoop-0.0.1.jar com.suntang.analyse.hadoop.AnalyseJob -libjars hadoop-core-1.0.0.jar /user/root/news.txt output_root_test 即可。

 

此处运行可能出现另外一个错误。在命令行中出现

12/04/01 14:01:38 INFO mapred.JobClient: Task Id : attempt_201204011356_0001_m_000001_0, Status : FAILED

java.lang.Throwable: Child Error

        at org.apache.hadoop.mapred.TaskRunner.run(TaskRunner.java:271)

Caused by: java.io.IOException: Creation of symlink from /mnt/hgfs/shared/hadoop-1.0.0/libexec/../logs/userlogs/job_201204011356_0001/attempt_201204011356_0001_m_000001_0 to 。。。

就不打全了，重点在与

Creation of symlink，看详细日志中hadoop-root-tasktracker-localhost.localdomain.log中提示org.apache.hadoop.fs.FileUtil: Command 'ln -s ....': Operation not supported，即ln操作不支持。google可知这个是由于vm中的共享区域的问题，解决方法就是将hadoop完全转移至linux目录中。本例中从/mnt/hgfs/shared/hadoop-1.0.0转移至/usr/local/hadoop-1.0.0。

执行完成后可在hdfs中查看结果，查看目录结构为

-rw-r--r--   1 root supergroup          0 2012-04-01 14:40 /user/root/output_root_test/_SUCCESS

drwxr-xr-x   - root supergroup          0 2012-04-01 14:40 /user/root/output_root_test/_logs

drwxr-xr-x   - root supergroup          0 2012-04-01 14:40 /user/root/output_root_test/_logs/history

-rw-r--r--   1 root supergroup      13634 2012-04-01 14:40 /user/root/output_root_test/_logs/history/job_201204011420_0001_1333262405103_root_ccAnalyseJob

-rw-r--r--   1 root supergroup      20478 2012-04-01 14:40 /user/root/output_root_test/_logs/history/job_201204011420_0001_conf.xml

-rw-r--r--   1 root supergroup       3580 2012-04-01 14:40 /user/root/output_root_test/part-r-00000

/user/root/output_root_test/part-r-00000即为最终结果文件。

 =======================================================================

附加AnalyseJob代码

package com.suntang.analyse.hadoop;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.conf.Configured;

import org.apache.hadoop.fs.Path;

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.input.TextInputFormat;

import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

import org.apache.hadoop.util.Tool;

import org.apache.hadoop.util.ToolRunner;

public class AnalyseJob extends Configured implements Tool {

       public static class MapClass extends Mapper<LongWritable, Text, Text, Text> {

              @Override

              protected void map(LongWritable key, Text value, Context context)

                            throws IOException, InterruptedException {

                     // TODO Auto-generated method stub

                     // super.map(key, value, context);

                     if (value.toString().matches("<a[^>]*>.*?release.*?</a>"))

                            context.write(

                                          new Text(value.toString().substring(

                                                        value.toString().indexOf("release") + 8,

                                                        value.toString().indexOf("available") - 1)),

                                          value);

              }

       }

       public static class ReduceClass extends Reducer<Text, Text, Text, Text> {

              @Override

              protected void reduce(Text arg0, Iterable<Text> arg1, Context arg2)

                            throws IOException, InterruptedException {

                     // TODO Auto-generated method stub

                     // super.reduce(arg0, arg1, arg2);

                     arg2.write(arg0, arg1.iterator().next());

              }

       }

       public int run(String[] args) throws Exception {

              Configuration conf = getConf();

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

              job.setJarByClass(getClass());

              Path in = new Path(args[0]);

              Path out = new Path(args[1]);

              FileInputFormat.setInputPaths(job, in);

              FileOutputFormat.setOutputPath(job, out);

              job.setMapperClass(MapClass.class);

              job.setReducerClass(ReduceClass.class);

              job.setInputFormatClass(TextInputFormat.class);

              job.setOutputFormatClass(TextOutputFormat.class);

              job.setOutputKeyClass(Text.class);

              job.setOutputValueClass(Text.class);

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

              return 0;

       }

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

              int res = ToolRunner.run(new Configuration(), new AnalyseJob(), args);

              System.exit(res);

       }

}