ZhongZiChang's Dao » 开发工具 http://www.zhongzichang.com Fri, 16 Sep 2011 17:36:17 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Maven是什么 http://www.zhongzichang.com/archives/217 http://www.zhongzichang.com/archives/217#comments Tue, 27 Jul 2010 10:06:43 +0000 zhongzichang http://www.zhongzichang.com/?p=217 Continue reading →]]>
Maven的架构

Maven的主要作用

Apache Maven 是一个软件项目管理和理解工具。基于项目对象模型（POM）的概念，管理一个项目的建立，报告和文档。
如果你认为Maven给与你的项目与帮助，你可以在导航栏的“关于“段找到更多的信息。这里面深入的描述 Maven 是什么， 一些主要的特点， 和一些用户频繁问到的问题。
简介

Maven , Yiddish语为知识的累加器、专家。创建这个项目的目的源于在Jakata Turbin 项目中简化建造的过程。有几个项目，他们的Ant 建造文件略有不同，JARs检入到CVS中。我们想有一个标准的方式建造这些项目，一个清晰的定义就是项目是由什么组成，便易的方法是发布项目信息并且在几个项目之间共享JARs。
导致产生了一个用来建造和管理基于Java的项目的工具。我们希望这些事情能让Java开发者更容易工作，并且帮助对基于Java的项目的理解。
Maven 的目标

Maven的主要目的是帮助开发者在最短的时间内理解开发进展的完全状态。为了达到这个目标，Maven处理几个相关的领域的问题：
+ 使建造过程更容易
Maven 没有排除知道底层机制的需要的同时，对细节提供很多防护层。
+ 提供统一的建造系统
Maven允许使用他的项目对象模型（POM）和一个插件的集合来建造项目。一旦你熟悉一个Maven项目是如何建造的，你会自动明白所有的Maven项目是如何建造的，当驾驭很多个的项目时，能节约的大量的时间。
+ 提供高品质的项目信息
Maven提供大量有用的项目信息，一部分来自POM，一部分你来自项目的源码。例如，Maven可以提供：
++ Change 日志文档，直接从源码控制那里创建
++ 源码的交叉应用
++ 邮箱列表
++ 依赖列表
++ 单元测试报告(内含涉及范围)
Maven改良了信息的供给，所有这些对用户来说都是透明的。
其他产品可以提供Maven插件，来允许他们在Mave给出的标准的信息旁边放置自己的项目信息集。所有这些都是基于POM的。
+ 提供开发练习的指导方案
Maven为最好的开发练习收集理念，在这个方向上给项目提供指导。
例如，规范，执行和单元测试报告，这些都是使用Maven的正常建造周期的一部分。当前单元测试最好的练习指南：
++ 把你的单元测试源代码防止在独立，并且是平行的源码树中
++ 使用 test case 命名约定来定位和执行测试
++ 拥有单元测试的设置自己的环境，对于测试准备，不依赖自定义的建造。
Maven帮助项目流程，如发布管理和问题跟踪。
Maven提供对于项目目录结构布局的知道，一旦你学会布局，你可以很容易以同样的方式浏览其他的项目。
+ 允许透明合并新的 features
Maven为Maven客户端提供一个容易的方式来更新已安装的版本，以致达到充分利用升级后的好处。
从这点来讲，安装或者升级新的Maven自己或者第三方的插件是无关重要的。
Maven 不是什么

你可能听说过关于Maven的一些事情：
+ Maven是一个站点和一个文档工具
+ Maven扩展了Ant，让你下载依赖
+ Maven是一个可重用的Ant scriplets的集合
你从上面可以了解到Maven可以做这些事情。但这不是Maven具备的所有能力，他的目标是十分不同。
Maven鼓励更好的练习，但我们认识到由于历史的原因，一些项目已经不适合用于练习。在这些状况和出于不同项目的需要，没有对目标完善的妥协，它不能迎合每一种状况。
如果你决定用 Maven ，但拥有一个你不能整改的不平常的建造结构，你要么忘记这些特征或者完全使用Maven。
特色概要

+ 简单项目的setup – 在几秒钟内获得一个新项目或者模块
+ 所有的项目，一致的用法，表示新的开发者使用同样的时间就能进入一个项目
+ 超级的依赖管理，包含自动升级，依赖关口（传递依赖）
+ 在同一时间开展多个项目
+ 在盒子之外使用一个大型的、可增长的libraries和metadata的仓库，和大型的开源项目安置在一起，实时获得这些项目的最新发布版本
+ 可扩展性，容易使用Java或者脚本语言写插件
+ 不需要或者小小的配置就能实时访问新的features
+ 在Maven之外用Ant任务做依赖管理和发布
+ 基于模块的建造：Maven能够建造一定数量的预定义项目，输出类型如 JAR, WAR, 或者分发，基于该项目的metadata，对于大多数项目都不需要编写脚本。
+ 清晰的项目信息站点： 为建造过程使用同样的metadata，Maven能生成一个web站点或者PDF，包含你增加的文档，或者增加的标准报告，关于项目开发的状态。这些信息出现在左边导航的底下的“Project Information“和“Project Report” 子菜单。
+ 发行管理和分支发布：不需要额外的配置，Maven可以与你的源代码控制系统交互，如CVS，基于某个tag的项目发行。同样可以发布到某个分发的位置，给其他的项目使用。Maven能发布独立的输出，如JAR，一个包含其他依赖和文档的Archarce，或者一个源码分发。
+ 依赖管理： Maven鼓励使用JARs和其他依赖的中央仓库。Maven设定一个机制，就是你项目的客户端将会使用从中央仓库下载需要的JARs来建造你的项目，如Perl的CPAN。这让Maven的用户在项目之间重用JARs，鼓励项目之间的通信，确保向后兼容的问题的处理。中央仓库安置在ibiblio的服务器上。
]]> http://www.zhongzichang.com/archives/217/feed 0 在 Eclipse 为 Axis2 开发 Web Services 的要点和注意事项 http://www.zhongzichang.com/archives/142 http://www.zhongzichang.com/archives/142#comments Mon, 17 May 2010 07:48:21 +0000 zhongzichang http://www.zhongzichang.com/?p=142 Continue reading →]]> 开发环境

Ubuntu Linux 9.10 + Eclipse Galileo SR2 + Axis2 1.5.1 + JDK 1.6.0_19 + Tomcat 6.0.26

运行环境

Redhat Linux S4 + JRE 1.6.0 + Tomcat 6.0.26

S1

主菜单 Window -> Preferences -> Web services -> Axis2 设置你已安装好的 Axis2

S2

创建 Dynamic Web Project 时，增加 Axis2 Web Services 的支持。

如果创建项目时没有增加 Axis2 的支持，可以在创建Web Service时添加，将缺省的 runtime 由 apache axis 改为 axis2。

S3

修改项目 的 web.xml

下面的内容

<servlet>

<display-name>Apache-Axis Admin Servlet Web Admin</display-name>

<servlet-name>AxisAdminServlet</servlet-name>

<servlet-class>org.apache.axis2.transport.http.AxisAdminServlet</servlet-class>

<load-on-startup>100</load-on-startup>

</servlet>

修 改为

<servlet>

<display-name>Apache-Axis Admin Servlet Web Admin</display-name>

<servlet-name>AxisAdminServlet</servlet-name>

<servlet-class>org.apache.axis2.webapp.AxisAdminServlet</servlet-class>

<load-on-startup>100</load-on-startup>

</servlet>

S4

可能会显 示一些找不到某些类的错误/异常，实际上，WTP没有把所有的jar包含进去，你需要将缺少的jar拷贝到 lib 目录（findjar.com这 样的网站能帮助你根据class的名字查找到相应的jar，我只拷贝了httpcore就可以）。

S5

建议以Top-Down 的方式生成Web Service，这样做有两个优点，一是兼容其他语言的客户端，二是支持自定义的参数类型。

创建WSDL文件时，使用 WTP提供的可视化编辑工具编辑的，生成的文件可能存在错误或者警告，这时需要先进行验证，以source的方式手工修正源代码。

]]> http://www.zhongzichang.com/archives/142/feed 0 介绍一下XMLBeans，它真的很好用 http://www.zhongzichang.com/archives/140 http://www.zhongzichang.com/archives/140#comments Mon, 10 Aug 2009 15:17:21 +0000 zhongzichang http://www.zhongzichang.com/?p=140 Continue reading →]]> XMLBeans 提供一种直观的方法处理XML，让你更容易使用Java访问和管理XML数据和文档。

XMLBeans 中 有关XML 的特性

  • 为XML数据提供一个友好的Java面向对象的视图，不会在访问原始本地的XML结构中迷失。
  • 使 用XMLBeans的过程中，XML作为一个文档的完整性并没有丢失。面向XML的APIs通常分类XML，目的是为了绑定它的多个部分。使用 XMLBeans，整个XML实例文档以一个整体的方式处理。XML数据以XML的方式存储再内存中。这表示文档的次序将被保留，就如原始带有空白的元素 内容。
  • 从schema那里生成类型，以类似JavaBean的 get 和 set 方式访问XML实例。
  • 它一开始就 以 XML schema 为中心而设计 — XMLBeans支持所有的XML schema定义。
  • 快速访问XML

XMLBeans 的起始点是 XML schema。一个schema（包含在一个XSD文件中）是一个XML文档，它定义了其他的XML文档必须遵守的规则集合。XML schema 规范提供一个丰富的数据模型，允许你在数据中表达复杂的结构和约束。例如，一个XML schema 能强行控制一个文档中的数据排序，或者一些特殊值的约束（例如，生日的数据必须在1900年之后）。遗憾的是，如果在java中没有自己编写代码的话，想 这样的强制规则的能力是典型无效的。XMLBeans 尊重 schema 的 约束。

注意：一个XML schema 定义了一个XML文档的规则，一个XML实例是一个符合这个schema的文档。 你编译一个schema（XSD）文件，生成一个schema镜像的Java接口集。 你就可以使用这些类型来处理符合这个schema的XML实例文档。你绑定一个XML实例文档到这些类型上；通过这些java接口来改变下面的XML内 容。

前面处理XML的选项，包含使用XML编程接口（如 DOM 或者 SAX）或者一个XML 编组/绑定工具（如JAXB）。因为它缺少鉴定的面向schema的类型，一个面向DOM的模型导航是更加乏味的，所以需要一个更加易懂的完全对象模型。 JAXB提供对XML schema规法的支持，但它仅仅处理一个子集；XMLBeans则支持所有的特性。同样，一个XML的方式在内存中存储数据， XMLBeans 能够减少 编组和反编组 的消耗。

使用它的schema来访问XML

瞄一下，你可以使用XMLBeans来做哪些事情， 来看看这个使用XML做购物订单的例子。这个购物订单的XML包含双方的交换数据，比如两个公司。 双方都需要能够以来一个统一的消息模型，和一个 schema 来指定共同的基础。
一个购物订单XML实例表现如下：

<po:purchase-order xmlns:po=”http://openuri.org/easypo”>
<po:customer>
<po:name>张三</po:name>
<po:address>北京市海淀区</po:address>
</po:customer>
<po:date>2003-01-07T14:16:00-05:00</po:date>
<po:line-item>
<po:description>Linux 高级配置详解</po:description>
<po:per-unit-ounces>5</po:per-unit-ounces>
<po:price>21.79</po:price>
<po:quantity>2</po:quantity>
</po:line-item>
<po:line-item>
<po:description>Linux 核心</po:description>
<po:per-unit-ounces>5</po:per-unit-ounces>
<po:price>19.89</po:price>
<po:quantity>2</po:quantity>
</po:line-item>
<po:shipper>
<po:name>EMS</po:name>
<po:per-ounce-rate>0.74</po:per-ounce-rate>
</po:shipper>
</po:purchase-order>

这 个XML包含一个根元素，purchase-order，它拥有四种子元素：customer，date，line-item，和shipper。从一种 直观的，面向对象的视角来看这个XML，会得到一个对象，表现出 purchase-order 元素，并且它提供方法来获取 date 以及下面的对象，包括customer，line-item，和 shipper 元素。后面的三个元素也有自己的方法来获取内部的日期。

先来看看 schema

下面的XML是前面购物订单XML的schema。它定义了XML的模型–其中的元素是什么，显示的顺序，哪个是哪个的子元素等等。

<xs:schema targetNamespace=”http://openuri.org/easypo”
xmlns:po=”http://openuri.org/easypo”
xmlns:xs=”http://www.w3.org/2001/XMLSchema”
elementFormDefault=”qualified”>

<xs:element name=”purchase-order”>
<xs:complexType>
<xs:sequence>
<xs:element name=”customer” type=”po:customer”/>
<xs:element name=”date” type=”xs:dateTime”/>
<xs:element name=”line-item” type=”po:line-item” minOccurs=”0″ maxOccurs=”unbounded”/>
<xs:element name=”shipper” type=”po:shipper” minOccurs=”0″/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:complexType name=”customer”>
<xs:sequence>
<xs:element name=”name” type=”xs:string”/>
<xs:element name=”address” type=”xs:string”/>
</xs:sequence>
</xs:complexType>
<xs:complexType name=”line-item”>
<xs:sequence>
<xs:element name=”description” type=”xs:string”/>
<xs:element name=”per-unit-ounces” type=”xs:decimal”/>
<xs:element name=”price” type=”xs:double”/>
<xs:element name=”quantity” type=”xs:int”/>
</xs:sequence>
</xs:complexType>
<xs:complexType name=”shipper”>
<xs:sequence>
<xs:element name=”name” type=”xs:string”/>
<xs:element name=”per-ounce-rate” type=”xs:decimal”/>
</xs:sequence>
</xs:complexType>
</xs:schema>

这个 schema 为描述了购物订单的XML实例，定义如下：

  • 定 义三个 complex 类型– customer, line-item, 和 shipper 。 这三种类型用于作为 purchase-order 元素的子元素。 在 schema 中 ，一个complex类型定义了一个拥有子元素和属性的元素。comlex 类型内部的 sequence 元素将列出它的子元素。这些是global类型。因为它们都位于schema的顶层。（换句话讲，仅仅位于shcema根元素之下）。这表示它们可以在 schema的任何位置引用。
  • 在complex类型中使用简单类型。name，address，和description元素是典型的简单类型。也叫内建类型。一个内建类型（以“xs”为前缀）是schema规范的一部分。（规范定义了46中内建类型。）
  • 一个叫purchase-order的全局元素。这个元素的定义中，内部包含一个complex类型定义，指定purchase-order的子元素。注意complex类型含有本schema的其他complex类型的引用。

换句话讲，schema定义子元素的类型，并且指明它们在根元素purchase-order中的位置。当你使用XMLBeans编译象这样的XSD文件时，将生成一个JAR文件，内含来自该schema的接口。

编写使用接口的Java代码

再 你的应用中使用XMLBean接口，可以在代码中使用新的类型来处理基于这个schema的XML。下面就是一个例子，提出购物订单XML中的每一条 item信息，计算items数量，并计算它们的总价。特别要看看 printItems 方法，它接受包含一个购物订单的XML文件对象。

package docs.xmlbeans;

import java.io.File;
import org.apache.xmlbeans.*;
import org.openuri.easypo.PurchaseOrderDocument;
import org.openuri.easypo.PurchaseOrder;
import org.openuri.easypo.LineItem;

public class POHandler
{
public static void printItems(File po) throws Exception
{
/*
* All XMLBeans schema types provide a nested Factory class you can
* use to bind XML to the type, or to create new instances of the type.
* Note that a “Document” type such as this one is an XMLBeans
* construct for representing a global element. It provides a way
* for you to get and set the contents of the entire element.
*
* Also, note that the parse method will only succeed if the
* XML you’re parsing appears to conform to the schema.
*/
PurchaseOrderDocument poDoc =
PurchaseOrderDocument.Factory.parse(po);

/*
* The PurchaseOrder type represents the purchase-order element’s
* complex type.
*/
PurchaseOrder po = poDoc.getPurchaseOrder();

/*
* When an element may occur more than once as a child element,
* the schema compiler will generate methods that refer to an
* array of that element. The line-item element is defined with
* a maxOccurs attribute value of “unbounded”, meaning that
* it may occur as many times in an instance document as needed.
* So there are methods such as getLineItemArray and setLineItemArray.
*/
LineItem[] lineitems = po.getLineItemArray();
System.out.println(“Purchase order has ” + lineitems.length + ” line items.”);

double totalAmount = 0.0;
int numberOfItems = 0;

/*
* Loop through the line-item elements, using generated accessors to
* get values for child elements such a description, quantity, and
* price.
*/
for (int j = 0; j < lineitems.length; j++)
{
System.out.println(” Line item: ” + j);
System.out.println(
” Description: ” + lineitems[j].getDescription());
System.out.println(” Quantity: ” + lineitems[j].getQuantity());
System.out.println(” Price: ” + lineitems[j].getPrice());
numberOfItems += lineitems[j].getQuantity();
totalAmount += lineitems[j].getPrice() * lineitems[j].getQuantity();
}
System.out.println(“Total items: ” + numberOfItems);
System.out.println(“Total amount: ” + totalAmount);
}
}

注意，从schema那里生成的类型，反映出XML里面有什么：

  • 一个 PurchaseOrderDocument 表示全局的根元素
  • 一个 getPurchaseOrder 方法返回一个 PurchaseOrderDocument.PurchaseOrder 类型，内含子元素，含有 line-item。一个 getLineItemArray 方法返回一个  LineItem 数组。
  • 其他的方法，如个体Quanity，个体Price，等等，按照schema的描述，返回相应的line-item元素的子元素相应的内容。
  • 包含这些类型的包的名称，派生自 schema 的 目标 namespace。

生成的类型名遵守Java的编码规范。同样，分析XML文件的例子，其他分析方法，支持 一个 Java InputStream 对象，一个Reader对象等等。

前面的Java代码执行后在控制台中输出如下：

Purchase order has 3 line items.
Line item 0
Description: Burnham’s Celestial Handbook, Vol 1
Quantity: 2
Price: 21.79
Line item 1
Description: Burnham’s Celestial Handbook, Vol 2
Quantity: 2
Price: 19.89
Total items: 4
Total amount: 41.68

从schema那里创建新的XML实例

前面你看到XMLBeans提供一个factory类，可以使用它来创建新的实例。下面的例子，创建一个新的purchase-order元素，然后增加一个customer子元素。然后插入name和address子元素，创建元素并设置其值，仅需调用一个set方法。

public PurchaseOrderDocument createPO()
{
PurchaseOrderDocument newPODoc = PurchaseOrderDocument.Factory.newInstance();
PurchaseOrder newPO = newPODoc.addNewPurchaseOrder();
Customer newCustomer = newPO.addNewCustomer();
newCustomer.setName(“Doris Kravitz”);
newCustomer.setAddress(“Bellflower, CA”);
return newPODoc;
}

下面就是这个XML的结果。注意XMLBeans在schema的基础上指派正确的名字空间，用 一个 “ns1″ （或者，”namespace 1″）前缀。实际上，前缀并不重要–它的 namespace URI 定义了名字空间，前缀仅仅是表示的标记。

<ns1:purchase-order xmlns:ns1=”http://openuri.org/easypo”>
<ns1:customer>
<ns1:name>Doris Kravitz</ns1:name>
<ns1:address>Bellflower, CA</ns1:address>
</ns1:customer>
</ns1:purchase-order>

注意，所有继承自XmlObject的所有类型（包含那些由schema生成的），都提供一个Factory类。要浏览整个类型系统找到哪种XmlObject合适，查看 XMLBeans Support for Built-In Schema Types 。查询参考信息，看 XmlObject Interface。

XMLBeans 的层次

前 面例子中的生成的类型是XMLBean类型层次的一部分。层次是一种方法，XMLBeans通过它来直观的展示schema。 在层次的顶部是XmlObject，XMLBeans类型的基本接口。在这之下，有两种主要的类型分类：生成类型，表现用户派生的schema类型；其次 是内建的schema类型。这里已经介绍过生成类型。要得到更多的信息，查看 Java Types Generated from User-Derived Schema Types。

内建的类型支持

除 了从给出的schema中生成类型外，XMLBeans提供46中Java类型，对应着XML schema 规范中内建的46种类型。 如 schema 定义的 xs:string, xs:decimal ，和 xs:int ，对应着 XMLBeans 则是 XmlString, XmlDecimal，和XmlInt。这些对象都是从XmlObject（对应内建schema类型的 xs:anyType）中派生。

XMLBeans 提供一种方法，让你能想内建的类型般处理XML数据。另外，如你在前面的例子中看到的，对于大部分的类型，method将返回原Java类型，如int。下面两行代码都是返回元素值的数量，但返回的类型却是不同的。

// Methods that return simple types begin with an “x”.
XmlInt xmlQuantity = lineitems[j].xgetQuantity();
// Methods that return a natural Java type are unadorned.
int javaQuantity = lineitems[j].getQuantity();

在感觉上，两个方法都是返回元素数量。getQuantity方法更深入一步，转换元素的值到原生Java类型。（XMLBeans提供方法来检查你要处理的XML）

如果你知道一点关于XML schema的，XMLBeans 的类型将看起来更直观。如果不，你将需要更多的练习使用你自己的schemas和XML实例来试验XMLBeans。

需要更多的信息关于schema的类型生成，看 Methods for Types Generated From Schema 。需要更多的信息关于XMLBeans如何展示内建的schema类型，看 XMLBeans Support for Built-In Schema Types。

使用XQuery表达式

用XMLBeans，你可以使用XQuery来查询到XML指定的数据块。XQuery有时被认为是“SQL for XML”，因为提供一套机制直接访问XML文档中的数据， 就如SQL提供一套机制来访问数据库中的数据。

XQuery 从 XPath 那里借用了一些语法，在XML指定内部数据的语法。下面的例子，返回所有价格子元素的值小于或等于20.00的line-item元素。

PurchaseOrderDocument doc = PurchaseOrderDocument.Factory.parse(po);

/*
* The XQuery expression is the following two strings combined. They’re
* declared separately here for convenience. The first string declares
* the namespace prefix that’s used in the query expression; the second
* declares the expression itself.
*/
String nsText = “declare namespace po = ‘http://openuri.org/easypo’; “;
String pathText = “$this/po:purchase-order/po:line-item[po:price <= 20.00]“;
String queryText = nsText + pathText;

XmlCursor itemCursor = doc.newCursor().execQuery(queryText);
System.out.println(itemCursor.xmlText());

这 些代码在文档的开始位置创建一个指针。 使用 XmlCursor 接口的 execQuery 方法来执行查询表达式。 在这个例子中， 方法的参数是一个Xquery表达式，说出”从指针的位置开始，历遍整个purchase-order 元素，或者那些价格值小于或等于20.00的line-item。这里$this变量表示“当前位置”。需要更多关于XQuery的信息，到W3C的网站 上，查看 XQuery 1.0: An XML Query Language 。

使用XML指针

在 前面的例子中，想必你已经注意到 XmlCursor接口。处理提供一种执行XQuery表达式的方法以外，一个XML 指针提供一个优良的去处杂乱数据的模型来处理数据。XML 指针 API，类似 DOM的 对象API， 是一种简易的方法指向数据的某些块。因此，就如一个指针，帮助历遍一个词处理文档，XML指针定义一个再XML的位置，在那里对选择的XML执行动作。

在 没有schema的情况下，指针是个历遍XML文档的理想工具。一旦你获得意想的位置的指针，你可以对它进行多种操作。例如，你可以set或者get 值，insert或者removeXML片段，copy片段从XML文档的一个部分到其他的部分，或者对XML文档做出其他的fine-grained改 变。

下面的例子，使用XML指针来转移到 customer 元素的 name 子元素。

PurchaseOrderDocument doc =
PurchaseOrderDocument.Factory.parse(po);

XmlCursor cursor = doc.newCursor();
cursor.toFirstContentToken();
cursor.toFirstChildElement();
cursor.toFirstChildElement();
System.out.println(cursor.getText());

cursor.dispose();

发生了哪些事情呢？如早期的例子，代码装入一个XML文件。装入后，代码在开始的位置创建一个指针。多次移动指针，直至它到达name元素的位置。使用getText方法获取了元素的值。
这仅仅是对XML指针的简介。要获得关于指针的更多信息，参考 Navigating XML with Cursors.

接下来要干嘛
  • XMLBeans 提供处理XML的直接方法，特别是在你了解schema的情况下。 如何你正在访问基于schema的XML，你会发现使用schema生成的类型来访问XML是最有效的。要做到这点，需要你先编译schema来生成接 口。要得到更多关于使用schema生成的XMLBeans类型的资料，参考 Java Types Generated From User-Derived Schema Types and Methods for Types Generated From Schema 。
  • 你 可能有兴趣阅读更多关于XMLBeans基于的类型系统，特别是在你使用schema生成的类型的情况下。 XMLBeans提供层次型的类型系统，对应到XML schema规范。如果你是用schema，你会发现它将帮助你了解这些类型如何工作。了解更多的信息，参考 XMLBeans Support for Built-In Schema Types and Introduction to Schema Type Signatures。
  • XMLBeans 提供通过XQuery来访问XML，它从Xpath那里借来路径语法。使用XQuery，不管在有没有schema的情况下，你都可以指定特定的XML片段。了解更多关于XMLBeans中XQuery和XPath的内容，参考 Selecting XML with XQuery and XPath。
  • 你可使用XmlCursor接口进行 fine-grained 航行和操作XML。获取更多信息，参考 Navigating XML with Cursors。

注意：xbean.jar 文件 包含 XMLBeans 库，在功能上完全能作为一个独立库。

相关主题

XMLBeans Samples

]]> http://www.zhongzichang.com/archives/140/feed 0 ibm发布支持mapreduce开发框架的eclipse插件 http://www.zhongzichang.com/archives/88 http://www.zhongzichang.com/archives/88#comments Tue, 17 Apr 2007 14:59:22 +0000 zhongzichang http://www.zhongzichang.com/archives/88 Continue reading →]]> IBM MapReduce Tools for Eclipse 是一个插件，支持在Eclipse内创建MapReduce应用。 它使用 Hadoop 开源 MapReduce框架， 可以在普通机器组成的大型集群上，运行数据密集型应用程序。
这个Eclipse插件支持一下的特征：
• 以 Jar 文件的方式打包和部署Java项目到一个Hadoop服务器（本地或者远程）；
• 辅助开发过程的cheat sheets；
• 独立的视角，观看 Hadoop服务器，Hadoop分布式文件系统和当前job状态；
• 提供向导，促进基于MapReduce框架的类的开发。
他如何工作？
插件自动创建包含支持开发和测试Hadoop库的项目。同时提供MapReduce驱动的模板。项目完成后，插件使用SCP（安全拷贝）来发布代码到一个Hadoop服务器，然后通过SSH（安全Shell）远程执行。执行期间，插件通过HTTP协议与Hadoop任务跟踪器通信来显示job状态。

IBM MapReduce Tools for Eclipse 是一个插件，支持在Eclipse内创建MapReduce应用。 它使用 Hadoop 开源 MapReduce框架， 可以在普通机器组成的大型集群上，运行数据密集型应用程序。
这个Eclipse插件支持一下的特征：
• 以 Jar 文件的方式打包和部署Java项目到一个Hadoop服务器（本地或者远程）；
• 辅助开发过程的cheat sheets；
• 独立的视角，观看 Hadoop服务器，Hadoop分布式文件系统和当前job状态；
• 提供向导，促进基于MapReduce框架的类的开发。
他如何工作？
插件自动创建包含支持开发和测试Hadoop库的项目。同时提供MapReduce驱动的模板。项目完成后，插件使用SCP（安全拷贝）来发布代码到一个Hadoop服务器，然后通过SSH（安全Shell）远程执行。执行期间，插件通过HTTP协议与Hadoop任务跟踪器通信来显示job状态。

]]> http://www.zhongzichang.com/archives/88/feed 0 用Hadoop搭建分布式存储和分布式运算集群 http://www.zhongzichang.com/archives/83 http://www.zhongzichang.com/archives/83#comments Mon, 09 Apr 2007 11:59:03 +0000 zhongzichang http://www.zhongzichang.com/archives/83 Continue reading →]]> 1.硬件和软件环境

普通PC，要求：
cpu: 750M-1G
mem: >128M
disk: >10G
不需要太昂贵的机器。

机器名：
finewine01
finewine02
finewine03

将finewine01设为主节点，其它的机器为从节点。

linux

java 1.6.0

ssh , sshd 运行，用于Hadoop脚本来管理远程守护

rsync 软件同步

ntp 时间同步

2. 下载和生成

从这里checkout，我选择trunk

http://svn.apache.org/repos/asf/lucene/hadoop/

使用ant进行生成

3. 部署前的准备工作
在主节点的start-all.sh脚本执行后，主节点和从节点的所有服务运行。即这个脚本将启动主节点的服务，并ssh到从所有的节点，继而启动从节点的服务。

start-all.sh这个脚本假定hadoop被安装在所有机器的同一个位置，每一台机器都用同一个路径存放hadoop的数据。

我们需要在每台机器上创建同样的目录结构。
/hadoop
/hadoop-install/hadoop-0.10.0 hadoop的0.10.0版的安装位置
/filesystem hadoop文件系统的根
/home 用户hadoop的主目录

以root登录到所有的机器，创建hadoop用户和目录结构。
ssh -l root finewine01
mkdir /hadoop
mkdir /hadoop/hadoop-install
mkdir /hadoop/filesystem
mkdir /hadoop/home
groupadd hadoop
useradd -d /hadoop/home -g hadoop hadoop
chown -R hadoop:hadoop /hadoop
passwd hadoop hadooppassword

start-all.sh脚本要启动所有机器的服务，需要对所有的机器进行ssh无密码的登录的能力。因此我们需要在每台机器上创建一个ssh key。在这个例子中，主节点也需要启动自己的服务，因此主节点同样需要做无密码的ssh登录设置。

用vi编辑/hadoop/hadoop-install/hadoop-0.10.0/conf/hadoop-env.sh，将下面的环境变量设置：

export HADOOP_HOME=/hadoop/hadoop-install/hadoop-0.10.0
export JAVA_HOME=/usr/java/jdk1.5.0_06
export HADOOP_LOG_DIR=${HADOOP_HOME}/logs
export HADOOP_SLAVES=${HADOOP_HOME}/conf/slaves

这个文件还有很多变量，这些变量的设定影响hadoop的运行。比如你以后执行脚本时发生ssh错误，就需要调整其中的HADOOP_SSH_OPTS变量。
同时需要注意的是，在初始的拷贝操作后，需要在设置hadoop-env.sh文件中的HADOOP_MASTER变量，这样程序才能通过rsync同步主节点的改变到所有的从节点上。

在主节点上创建ssh keys，然后复制到各个从节点上。这些操作必须由先前创建的hadoop用户完成。不要su成hadoop用户来做。开启一个新shell，以hadoop用户的身份登录来完成这些操作。
cd /hadoop/home
ssh-keygen -t rsa (Use empty responses for each prompt)
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /hadoop/home/.ssh/id_rsa.
Your public key has been saved in /hadoop/home/.ssh/id_rsa.pub.
The key fingerprint is:
a6:5c:c3:eb:18:94:0b:06:a1:a6:29:58:fa:80:0a:bc nutch@localhost

在主节点上，拷贝刚才创建的公共key到一个名为authorized_keys的文件：
cd /hadoop/home/.ssh
cp id_rsa.pub authorized_keys

只需在主节点上运行ssh-kegen程序。其他节点的目录结构创建后，将刚才在主节点创建的keys通过scp拷贝到从节点的同样的目录上。
scp /hadoop/home/.ssh/authorized_keys hadoop@finewine02:/hadoop/home/.ssh/authorized_keys
第一次，你需要输入hadoop用户的密码。第一次登录到其他的机器上，ssh提示你是否选择将机器加入到已知的机器列表中，选择yes。这个keys文件拷贝后，以hadoop的身份从主节点到从节点的登录就不需要密码了。
可以从主节点上以hadoop的身份测试:
ssh finewine02
接下来一个命令提示符将直接出现，不需要密码的。

一旦成功在所有机器上创建ssh keys后，就可以开始在从节点上部署hadoop。

4. 部署hadoop到一个机器上

首先，我们部署hadoop到一个节点上(主节点)。确保运行正常后，加入其他从节点。下面所有的操作都是由登录后的hadoop用户进行的。
cp -R /path/to/build/* /hadoop/hadoop-install/hadoop-x.x.x

然后确保这些shell脚本文件都是unix格式，并且是可执行的(这些文件分别在/bin和/conf目录中)。

一个hadoop-site.xml的例子:

<?xml version=”1.0″?>

<configuration>

<property>

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

<value>finewine01:9000</value>

<description>The name of the default file system. Either the literal string
“local” or a host:port for NDFS.</description>

</property>

<property>

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

<value>finewine01:9001</value>

<description>The host and port that the MapReduce job tracker runs at. If
“local”, then jobs are run in-process as a single map and
reduce task.</description>

</property>

<property>

<name>mapred.map.tasks</name>

<value>2</value>

<description>define mapred.map tasks to be number of slave hosts</description>

</property>

<property>

<name>mapred.reduce.tasks</name>

<value>2</value>

<description>define mapred.reduce tasks to be number of slave hosts</description>

</property>

<property>

<name>dfs.name.dir</name>

<value>/hadoop/filesystem/name</value>

</property>

<property>

<name>dfs.data.dir</name>

<value>/hadoop/filesystem/data</value>

</property>

<property>

<name>mapred.system.dir</name>

<value>/hadoop/filesystem/mapreduce/system</value>

</property>

<property>

<name>mapred.local.dir</name>

<value>/hadoop/filesystem/mapreduce/local</value>

</property>

<property>

<name>dfs.replication</name>

<value>1</value>

</property>

</configuration>

说明
fs.default.name // 缺省的文件系统 “local”或者”host:port”

hadoop包含两个组件，分别是分布式文件系统和mapreduce功能。分布式文件系统允许你在多台普通机器上存储和复制文件。mapreduce可以让你很容易就执行并行程序任务。

分布式文件系统包含名字节点和数据节点。当一个客户想操作一个在文件系统上的文件时，它首先和名字节点联系，名字节点将告诉它在那个数据节点上可以取得文件。名字节点负责调度和保存那些数据块保存和复制到在那些机器上。数据节点是数据仓库，保存真实的文件数据块。当你在同一台机器上运行名字节点和数据节点的服务时，它同样会通过sockets来通讯，如同在不同机器上一样。

mapreduce是一种分布式运算，就如分布式文件系统一样，只不过分布的一个运算操作，而不是文件。负责mapreduce调度服务器叫做mapreduce job tracker。每一个执行运算操作的节点都有一个守护叫task tracker，task tracker运行并且和job tracker通信。

主节点和从节点的通信以连续的heartbeat(5-10秒)的方式进行。如果从节点的heartbeat停止，主节点将假定该从节点失效并不再使用该节点。

mapredu.job.traker // mapreduce的主节点,”local”或者”host:port”

mapred.map.tasks和mapred.reduce.tasks用于设定并行任务的数量。

dfs.name.dir // 名字节点用于存储数据节点的跟踪和调度信息

dfs.data.dir // 数据节点用于存储实际的数据块

mapred.system.dir // mapreduce tasker 存储自己的数据，仅仅在tasker所在的机器上，不在mapreduce主机上

mpred.local.dir // mapreduce 在节点上存储自己的本地数据。mapreduce使用巨大的本地空间来执行它的tasks。tasks退出时，mapreduce产生的中间文件并没有被删除。在每个节点上，这个属性是一样的。

dfs.replication // 冗余，单个文件将被拷贝到多少机器上。这个值不能高于的所有的数据节点的数量。否则守护启动时会看见很多错误信息。

在你启动hadoop服务之前，确保格式化名字节点

bin/hadoop namenode -format

现在可以启动hadoop服务了

bin/start-all.sh

停止hadoop服务可以使用下面的命令

bin/stop-all.sh

如果设置正确，会看到正常的输出信息

5. 部署Hadoop到多台机器上

一旦你在一台机器上成功运行hadoop，就可以将配置文件拷贝到其他的机器上。
如：
scp -r /hadoop/hadoop-install/hadoop-x.x.x hadoop@finewine02:/hadoop/hadoop-install/

对每台从节点机器都执行这个操作。然后编辑slaves文件，增加每一个slave到这个文件中，每行一个。编辑hadoop-site.xml的值，修改map和reduce的task的数量。修改replication属性。

6. 分布式搜索

产品系统一般每个索引库存100万条记录。50个服务器每秒处理20多个请求。
多处理器、多磁盘的系统，每个服务使用一个独立的磁盘和索引，这样机器的费用可以降低50%，电力解约到75%。一个多磁盘的机器并不能像单磁盘机器一样每秒处理那么多查询，但是它能处理更大的索引数量，因此平均起来效率更高一些。

7. 同步代码到从节点上

hadoop提供同步代码到从节点的能力。这个功能是可选的，因为它会减慢服务启动的速度，并且有时候你并不想同步改变到从节点上。

虽然从节点可以和主节点同步，但在第一次，你仍然需要基本的安装到从节点上，以至同步的脚本生效。这些工作上面我们在上面已经做了，所以不需要做改变。

同步的启动是由主节点ssh到从节点上，并执行bin/hadoop-daemon.sh脚本。这个脚本调用rsync来同步主节点。这表示你需要能以无密码的方式由从节点登录到主节点。前面，我们设置了从主节点到从节点的无密码登录，现在则设置反向登录。

如果是由于rsync选项引起了问题，查看bin/hadoop-daemon.sh脚本，大约在82行有rsync的选项。

那么，首先第一件事情就是在conf/hadoop-env.sh文件中，设置hadoop主节点变量。如:
export HADOOP_MASTER=finewine01:/hadoop/hadoop-install/hadoop-x.x.x

然后拷贝到所有从节点上，scp /hadoop/hadoop-installl/hadoop-x.x.x/conf/hadoop-env.sh hadoop@finewine02:/hadoop/hadoop-install/hadoop-x.x.x/hadoop-env.sh

最终，你需要登录到所有的从节点上，为每台机器创建一个ssh key。然后拷贝回到主节点，并追加到文件/hadoop/home/.ssh/authorized_keys文件中。在每个从节点上进行如下操作：

ssh -l nutch finewine02
cd /hadoop/home/.ssh

ssh-keygen -t rsa (Use empty responses for each prompt)
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /hadoop/home/.ssh/id_rsa.
Your public key has been saved in /hadoop/home/.ssh/id_rsa.pub.
The key fingerprint is:
a6:5c:c3:eb:18:94:0b:06:a1:a6:29:58:fa:80:0a:bc nutch@localhost

scp id_rsa.pub hadoop@finewine01:/hadoop/home/finewine02.pub

在每台从节点机器完成上面的操作后，追加所有的文件到主节点的authorized_keys文件。

cd /hadooop/home
cat finewine*.pub >> .ssh/authorized_keys

当这些操作完成后，每次运行bin/start-all.sh脚本，文件都会从主节点同步的每一个从节点。

8. 查看状况

端口 : 50070
dfs的状态

端口：50060
tracker状态

50030
map/reduce管理

其他端口：
dfs.secondary.info.port 50090
dfs.datanode.port 50010
dfs.info.port 50070
mapred.job.tracker.info.port 50030
mapred.task.tracker.report.port 50050
tasktracker.http.port 50060

]]> http://www.zhongzichang.com/archives/83/feed 0