import com.sun.image.codec.jpeg.JPEGCodec;
      import com.sun.image.codec.jpeg.JPEGImageEncoder;
     
      public class JpgTest {
 
 public void JpgTset() throws Exception{
     File _file = new File("/Order005-0001.jpg");                       //读入文件
     Image src = javax.imageio.ImageIO.read(_file);                     //构造Image对象
     int wideth=src.getWidth(null);                                     //得到源图宽
     int height=src.getHeight(null);                                    //得到源图长
     BufferedImage tag = new BufferedImage(wideth/2,height/2,BufferedImage.TYPE_INT_RGB);
     tag.getGraphics().drawImage(src,0,0,wideth/2,height/2,null);       //绘制缩小后的图
     FileOutputStream out=new FileOutputStream("newfile.jpg");          //输出到文件流
     JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);      
     encoder.encode(tag);                                               //近JPEG编码
     //System.out.print(width+"*"+height);                             
     out.close();
 }
      }
   
    过程很简单，从本地磁盘读取文件Order005-0001.jpg(2032*1524)，变成Image对象src，接着构造目标文件tag，设置tag的长宽为源图的一半，对tag进行编码，输出到文件流out，最后关闭文件流。
   
    还有一些问题需要说明：
    第一，目前只能支持JPG(JPEG)、GIF、PNG三种格式。（这里有些问题，在最下面解释）
    第二，对于源图的容量有限制，最好不要超过1M，否则会抛内存不足的错误，不过我试验过1.8M的源图，可以成功，但是也很容易抛内存不足。
   
    引用一位前辈的话：图象运算本身是密集型运算，需要大量的内存存放象素值。我用VC试了一下，4M的图象也有问题，而且越是压缩比大的图片在内存中还原成BITMAP时需要的内存越大。解决的方法，可以重写编码类，先开一定的内存，然后一段一段编码写到临时文件中，输出的时候再一段一段读出来。或利用nio的内存映象来操作。JavaMail由于采用了Builder模式，先生成一个邮件的每一个部分，然后合并成一个完整的邮件对象，这样每个构件都要先生成到内存中，你如果发送一个上百兆的附件，那么在构造Part时肯定内存溢出，所以我就改写了BodyPart的构造，让他和一个临时文件关联，然后用临时文件保存Part而不是构造在内存中，这样任义大小的附件(硬盘能放得下为限)都可以发送了。
   
    最后，如果大家对图像处理有更高的要求，不妨关注一下开源项目。比如JMagick，可以使用JMagick来实现图片的复制、信息获取、斜角、特效、组合、改变大小、加边框、旋转、切片、改变格式、去色等等功能。

2007-06-20更新
其实按照上面的做法只能压缩jpg格式，gif是不能压缩的（由于算法版权问题，直到Java 6.0才能压缩gif），前段时间要用gif压缩，在网上找了个类，可以解决问题。请参考：http://mindprod.com/jgloss/gifencoder.html。
替换以前代码的相应部分：

当代码运行完毕，用EditPlus之类的文本编辑器打开之后可以发现文件头已经是gif87格式了。

请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

面向服务体系

SOA （面向服务体系）是近期推动应用和业务集成领域产生巨大飞跃的新技术之一。 SOA 定义了一系列详尽的体系规范、范例和实现应用程序间进行松散耦合交互的最佳准则。

SOA 基于定义明确的接口，促进多个应用程序间的松散耦合交互。服务的实现是独立的，且不依赖上下文信息以及其他服务的状态。服务间数据交换主要基于文本类型的格式，使用基于标准的消息模型。服务自身并不知道服务提供者和服务消费者之间传输级的通讯交互。

尽管不是强制要求，当今大部分流行的基于 SOA 的系统都利用了 Web 服务以及近似技术为服务间交互提供必要的管道管理。 WSDL （ Web 服务定义语言）扮演了主要的通讯模型角色； SOAP 扮演了消息承载协议、 HTTP 扮演了网络传输协议。当然，这并不意味着你必须利用上述技术实现基于 SOA 的系统。另外，有些术语之前就已经存在了，所以很多企业已利用类似的体系实现了系统的松散耦合交互。不管怎样，主要的不同点在于我们现在已经有标准协议、工具集和软件了，使面向服务体系更健全。

SOA 原则与面向对象范式、原则有着显著不同。主要不同在于服务间交互的接口被定义了更多面向数据的行为。一个孤立的服务也许会采用面向对象原则和技术，但是，服务之间的交互很少采用这些手段。相反，这些接口更适合于基于文档的交换。面向对象的行为是绑定数据，而面向服务从行为中分离数据。

企业服务总线

ESB （企业服务总线）为面向服务体系提供了基础架构。通过设计工具定义服务间交互和规则， ESB 为部署和发现服务提供了运行时环境。

    在 ESB 的世界中，服务不会直接彼此交互。“ ESB 运行时”作为一个仲裁者在服务间松散的耦合它们。“ ESB 运行时”将实现协议绑定、消息传输、消息处理，等等。

一个服务总线将包括下列关键项：

    为服务提供传输绑定

    定义和发现已部署服务

    在服务间基于规则的路由和编排消息

    包括文档传递在内的增值服务等

大部分的 ESB 提供商基于自己的 SOA 提议来开放标准和技术，包括多种 Web 服务标准和协议。他们提供多种调用服务的传输绑定，包括 HTTP 、 FTP 以及 JMS 等等。大部分 ESB 用户利用 WS-BPEL （ Web 服务的业务流程执行语言）来了解已部署服务之间是如何实现业务流程的。 ESB 提供商同时也提供服务质量特性，包括容错、故障转移、负载平衡、消息缓冲等等。

Java 业务集成

JBI （ Java 业务集成）的提出是基于面向服务体系提倡的方法和原则，为了解决 EAI 和 B2B 若干问题的 Java 标准。当前版本（ 1.0 ）是 2005 年 8 月通过的 JSR （ Java 规范需求） 208 定案。商业和开源界都欢迎 JBI 成为他们 ESB 产品的集成标准。

基于仲裁者体系

JBI 定义了基于插件方式的架构，以便服务能融入“ JBI 运行时”环境。 JBI 提供了详细的接口，使服务能与“ JBI 运行时”环境交互。这些服务要为“ JBI 运行时”环境暴露接口，以便“ JBI 运行时”环境为服务路由消息。“ JBI 运行时”环境在部署在 SOA 环境中的服务间扮演仲裁者的角色。

在同一 JVM 中，“ JBI 运行时”核心主要包括如下组件：

    组件框架：组件框架把不同类型的组件部署到“ JBI 运行时”。

     归一化消息路由器：归一化消息路由器利用标准机制实现服务间消息交换。

     管理框架：管理框架基于 JMX 进行部署、管理以及监控“ JBI 运行时”中的组件。

组件模型

    JBI 在“ JBI 运行时”环境中定义了两种组件：

    服务引擎组件：该组件负责实现业务逻辑和其他服务。服务引擎组件在其内部可使用多种技术和设计模式。服务引擎组件可提供数据传输和转换这种简单的基础服务，也可实现像 WS-BPEL 实例一样复杂的业务处理。

    绑定组件：绑定组件主要为已部署服务提供传输级绑定。绑定组件有多种类型：

        利用标准传输协议与外部系统进行远程通讯。

        使已部署服务能在同一个 JVM 内部相互调用。

        服务间可使用标准的 WS-I （ Web 服务协同工作组织）规范通讯。

    JBI 的关键是分离服务引擎和绑定组件，以便业务逻辑不被下面的具体细节所干扰。这种方式促进了体系的灵活性和可扩展性。绑定组件和服务引擎组件在 JBI 内部都可以是服务提供者和 / 或服务消费者。

    绑定组件和服务引擎组件为“ JBI 运行时”提供接口以便从“ JBI 运行时”接收消息。同样的，它们也利用 JBI 提供的接口来和“ JBI 运行时”通讯。

消息传输模型

JBI 利用消息传输模型分离服务提供者和服务消费者之间的耦合。消息传输模型利用了 WSDL 。 WSDL 用于描述暴露的服务引擎组件和绑定组件的业务处理。另外， WSDL 也用于定义抽象服务处理的传输级绑定。

JBI 架构中一个关键组件是 NMR （归一化消息路由器，也译作“正规消息路由器”）。 NMR 基于 WSDL 提供了主要的消息传输中枢， NMR 为部署在“ JBI 运行时”中的服务引擎组件和绑定组件间的消息传递提供松散耦合。服务需要有聚合业务处理的接口，每个业务处理由零个或多个消息组成。而一个接口有一个或多个传输级绑定。

“ JBI 运行时”利用归一化格式描述消息。一个归一化消息由以下部分组成：

    消息属性

    消息有效载荷

消息附件

利用 NMR ， JBI 规范为服务提供者和消费者的消息交换提供标准接口。 NMR 支持服务生产者和消费者之间单向模式和服务响应模式的调用。

管理

JBI 利用 JMX 实现运行时的服务安装、配置和监控。服务必须实现 JBI 接口集，以便这些服务在 JBI 环境中是可管理的。 JBI 环境必须提供一套 JMX MBeans 实现“ JBI 运行时”的管理。

“ JBI 运行时”环境允许服务引擎组件和绑定组件的相关操作如下：

    安装组件：使组件接口可使用归一化消息路由器。

    安装 artefact 组件：这将允许已部署的 artefacts 组件获得与已安装组件同样的机能。例如，可以部署一个“连接服务”来提供具体的数据库连接。

    启动、停止服务以及进行相关服务分组。

JBI 为组件及 artefact 组件定义了标准的部署描述符以及打包模型。

角色

JBI 为基于 JBI 的端到端 EAI 解决方案定义了如下角色：

     引擎开发者：引擎开发者提供遵循 NMR 和管理约束的服务引擎组件。

    绑定开发者：绑定开发者提供遵循 NMR 和管理约束的绑定组件。

JBI 环境提供者： JBI 环境提供者为“ JBI 运行时”使用 J2EE 1.4 或 J2SE 1.4 或更新的平台提供支持。

J2EE 平台提供者： J2EE 平台提供者把“ JBI 运行时”作为提供应用程序服务的一部分。

JBI 应用程序开发者： JBI 应用程序开发者利用服务引擎组件、绑定组件以及 JBI 环境构建 JBI 应用程序。

结论

    当今业界走向越来越开放的标准和规范， JBI 在使 Java 技术利用面向服务体系和 ESB 基础架构实现业务集成方面产生了巨大飞跃。像 Oracle 这样的商用产品提供商和 ServiceMix 这样的开源软件都把 JBI 作为了他们 ESB 方案的一部分。

关于作者

    Meeraj Kinnumpurath 是位在 VOCA 有限公司（原来叫 BACS ）就职的 Java 架构师，这家公司是英国最大的票据交换所。他有 8 年的 Java 开发经验，主要从事企业应用程序开发。他已出版了一些 Java 、 J2EE 以及 Web 服务方面的书籍。

请注意！引用、转贴本文应注明原译者：Rosen Jiang 以及出处： http://www.blogjava.net/rosen

                                                                             

报表介绍

     BIRT 应用开发从报表设计开始。基于 Eclipse 插件提供多种快速构建报表工具。
        
         数据浏览器 － 把你的数据源（连接）以及数据集（查询）组织起来。数据集编辑器允许你测试数据集，以确保报表接收数据的正确性。
         布局视图 － 所见即所得编辑器为你的报表提供以拽方式来创建表现内容。包含一个标准报表条目调色板。
         属性编辑器 － 以便利的格局表现大多数通用的用户属性使编辑更快速和容易。BIRT 也集成了标准 Eclipse 属性视图，为每个条目提供详细的属性列表。
         报表预览 － 你可以在任何时间采用真实数据测试你的报表。预览窗口直接内嵌在 Eclipse 中。
         代码编辑器 － 在访问数据以及报表生成或浏览时，脚本把业务逻辑添加给报表。在编辑脚本时代码编辑器提供标准的 Eclipse 特性：语法加色、自动完成等等。BIRT 用很简单的脚本来表达，expression builder 能更容易的创建这些表达。
         略图 － BIRT 报表被组织为一个树型结构作为整体报表的根，并且为样式、报表内容、数据源、数据集、报表参数等分类。略图视图提供你整个报表结构紧凑的预览。
         Cheat Sheets － 学习新工具永远是种挑战，但是 Eclipse 提供一种创新方案：cheat sheets。它们是一些帮助你完成新任务的文档。
        
数据定制
   
    正如前面所提到的，报表通常为要表现的数据添加业务逻辑。BIRT 提供多个工具来完成这一操作：
   
        栏位计算－数据库为存储组织数据，但这些数据通常为结合表现层而预先整理好。栏位计算让你能定义基于业务逻辑的附加数据集栏位。这种逻辑是一个简单的语法、脚本或调用一个已有的 Java 逻辑。
        输入以及输出参数－许多数据源都支持参数：在查询时传入或传出数据的能力。比如，SQL Select 语句可包含输入参数。存储过程既有传入又有传出参数。
        栏位元数据－当数据源提供的名字是 unintuitive 的，你可以提供栏位别名。
        过滤 － 有些数据源，尤其是 SQL，提供良好的内置过滤特性。然而，有些数据源（单纯的文件，应用程序对象）却没有提供过滤特性。另外，过滤器条件是定义在脚本或 Java 代码中的。你可把过滤器定义为报表的一部分，BIRT 引擎会自动调用它们。
        脚本化数据集 － 有些报表需要访问专门或不常用的数据。你可以在 Java 或脚本创建访问，利用脚本化数据集可在报表中集成这些逻辑。
       
条件格式化
   
    有些报表有着固定的格式，其他的却需要条件格式化。例如，某报表列出了交易记录来表现不同的销售与利润之比。或者，一个客户服务报表要按照不同规则进行色彩显示。BIRT 提供多个条件格式化特性：
   
    条件可见度 － 你可以根据数据隐藏报表元素。在上述的交易报表中，你可以创建销售和交易收入两部分，接着隐藏报表指定记录中不需要的部分。
   
    值映射 － 数据库数据通常使用代码值：M/F 代表男性或女性，1/2 代表销售和收入，等等。值映射让你定义一个从数据库值到显示值的映射。例如，我们可把值“1”对应到“Sale”，把“2”对应到“Return”。
   
    加强 － 简单的标识可让你对特定报表套用样式。例如，在客户服务报表中，我们可以使用绿色表示上一的计划，红色表示下一计划。
   
    脚本

    BIRT 提供基于 JavaScript（与知名的 ECMAScript 形式上相同）的脚本。JavaScript 经常作为客户端脚本语言，但是它也可以用于用于表达业务逻辑。特别的，JavaScript 能与你的现有 Java 逻辑进行良好集成，能非常轻松地从 BIRT 报表调用业务逻辑。
   
    BIRT 提供从 JavaScript 对象访问报表对象模型（Report Object Model）的整套方案：同时表现报表设计和运行时的状况，允许报表的完全控制处理甚至最复杂的报表格式化工作。
   
项目管理

    BIRT 集成了 Eclipse 项目管理特性来组织相关报表。BIRT 也可以与 Eclipse CVS 协作进行源码管理。BIRT 的 XML 报表设计格式让它能容易的比较两份报表，或者两个不同版本的相同报表，并跟踪变更。
   
    样式

    任何设计 web 页面的人都知道有时会反复使用相同的样式。CSS 允许 web 设计者从内容中提取样式信息，并复用样式。
   
    BIRT 提供类似的特性。当然，BIRT 样式也是基于 CSS 的，这样使得网页应用开发人员能容易得设计 BIRT 表现形式。BIRT 样式可堆叠，允许你在一个地方设置样式后套用到所有报表或报表的一部分或单一报表中。
   
    库

    典型的应用中会包括许多有关联的报表。一个简单的客户应用将包括一个按照字母排序的客户列表、按照地理位置分类的客户群，为客户指定的销售代表，客户身份筛选等等。总之，用户不停的地变化报表以解决具体业务需要。
   
    这样一来，最终的报表应用将包含多组相关报表。相同的数据源、样式、业务逻辑、报表条目。
   
    将来的 BIRT 版本将包含组织这些共享资源的支持库。这些库可包含任何报表元素，比如样式、数据源、报表条目、脚本等等。
   
国际化

    全世界都可以访问你的 web 应用程序。BIRT 为国际化和本地化提供良好的支持。
   
    文本本地化 － 你可以建立一份把字符串自动变成用户本地语言显示的简单报表。所有的表单和报表文本都能以标准的 Java 本地化规则进行翻译。在运行时，BIRT 使用资源 key 找出文本的正确翻译。
   
    本地化 － BIRT 提供 locale-aware 格式化数据，意味着对于美国用户的日期数据可以以 mm/dd/yy 的格式出现，而欧洲用户则是 dd-mm-yy 格式。
   
    动态格式化 － 中文文本非常紧凑，德文有时又有点冗长，而英文正好是中等大小。BIRT 自动调整报表条目的大小来适合其中的内容，避免每次翻译都要进行报表测试。
   
扩展性

    报表应用程序的范围是十分庞大的，BIRT 团队不能为每个应用提供很具体的特性。可利用 BIRT 脚本来扩展 BIRT，另外还可构建 BIRT 扩展插件到 BIRT 中。
    
    数据访问
   
    BIRT 提供 ODA(Open Data Access) 框架来支持自定义数据访问方法。数据访问的范围还包括一个获取数据的运行时组件。也包括构建自定义查询的自定义设计时 UI。例如，打包后的应用程序可以让 ODA 构建数据访问 UI 并运行在自己的数据模型中。
    
    报表栏目
   
    BIRT 为要表现的数据提供一致的报表栏目集。可以在应用程序中自定义附件报表栏目，并像 BIRT 自身的报表栏目一样运行在设计器和引擎中。例如，性能管理应用程序要添加报表栏目来高亮显示停止项、尺度表以及其他用来衡量性能的可视标志。
   
    图表类型
   
    BIRT 图表包提供了很多的图表类型。但是，一些行业需要很特殊的图表样式。开发者可以在 BIRT 图表引擎中创建图表插件来提供这些图表样式。
   
    输出格式
   
    BIRT 1.0.1 支持输出到 HTML 和 PDF。当然，也可能需要其他类型输出：Excel、RTF(Rich Text Format)、SVG(Scalable Vector Graphic)、图像、等等。BIRT 在今后会提供其中一些，除开这些的其他格式可能需要的用户就很少了。开发者可利用 BIRT 引擎接口添加转换器以达到目的。


请注意！引用、转贴本文应注明原译者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

<?xml version="1.0" encoding="GBK" ?> <propertysets>  <propertset name="rea_faculty" description="team">   <field>10290</field>  </propertset>  <propertset name="faculty_lea" description="another team">   <field>10286</field>  </propertset>  <propertset name="office" description="teams">   <field>10287</field>  </propertset>   </propertysets>

    
为以上 XML 文件构造 Propertys 类：

public class Propertys {    private String name;  private String description;  private String field;  public String getDescription() {   return description;  }  public void setDescription(String description) {   this.description = description;  }  public String getField() {   return field;  }  public void setField(String field) {   this.field = field;  }  public String getName() {   return name;  }  public void setName(String name) {   this.name = name;  } }

读取方法（返回包含 Propertys 的列表）：
   

public List getAll() {   List list = new ArrayList();   try {    InputStream is = getClass().getResourceAsStream("/navigation.xml");    SAXReader reader = new SAXReader();          Document document = reader.read(is);    Element root = document.getRootElement();    Iterator lv = root.elementIterator("propertset");    Element el = null;    while (lv.hasNext()) {     Propertys property=new Propertys();     el = (Element) lv.next();     property.setName(el.attributeValue("name"));     property.setDescription(el.attributeValue("description"));     property.setField(el.elementText("field"));     list.add(property);    }   } catch (Exception e) {    e.printStackTrace();   }   return list;  }

添加新节点（成功返回 1 否则 0）：
       

public int saveProperty(Propertys property) {   try {    InputStream is = getClass().getResourceAsStream("/navigation.xml");    SAXReader reader = new SAXReader();          Document document = reader.read(is);    Element root = document.getRootElement();    root.addElement("propertset")     .addAttribute("name",property.getName())     .addAttribute("description",property.getDescription())     .addElement("field").addText(property.getField());        OutputFormat outformat = OutputFormat.createPrettyPrint();    outformat.setEncoding("GBK");    FileWriter out = new FileWriter(      System.getProperty("user.dir")      +"/web/WEB-INF/classes/navigation.xml");    XMLWriter writer=new XMLWriter(out,outformat);    writer.write(document);    writer.close();    return 1;   } catch (Exception e) {    e.printStackTrace();   }   return 0;  }

更新节点（按照 name 属性查找）：
   

public int updateProperty(String pro,Propertys property) {   try {    InputStream is = getClass().getResourceAsStream("/navigation.xml");    SAXReader reader = new SAXReader();          Document document = reader.read(is);    Element root = document.getRootElement();    Iterator lv = root.elementIterator("propertset");    Element el = null;    while (lv.hasNext()) {     el = (Element) lv.next();     if (el.attributeValue("name").equals(pro)) {      el.setAttributeValue("name",property.getName());      el.setAttributeValue("description",property.getDescription());      el.element("field").setText(property.getField());     }    }    OutputFormat outformat = OutputFormat.createPrettyPrint();    outformat.setEncoding("GBK");    FileWriter out = new FileWriter(      System.getProperty("user.dir")      +"/web/WEB-INF/classes/navigation.xml");    XMLWriter writer=new XMLWriter(out,outformat);    writer.write(document);    writer.close();    return 1;   } catch (Exception e) {    e.printStackTrace();   }   return 0;  }

删除节点：
   

public int delProperty(String pro) {   try {    InputStream is = getClass().getResourceAsStream("/navigation.xml");    SAXReader reader = new SAXReader();          Document document = reader.read(is);    Element root = document.getRootElement();    Iterator lv = root.elementIterator("propertset");    Element el = null;    while (lv.hasNext()) {     el = (Element) lv.next();     if (el.attributeValue("name").equals(pro)) {      el.detach();     }    }    OutputFormat outformat = OutputFormat.createPrettyPrint();    outformat.setEncoding("GBK");    FileWriter out = new FileWriter(      System.getProperty("user.dir")      +"/web/WEB-INF/classes/navigation.xml");    XMLWriter writer=new XMLWriter(out,outformat);    writer.write(document);    writer.close();    return 1;   } catch (Exception e) {    e.printStackTrace();   }   return 0;  }

请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

    测试方法：
    采用 JSP 端调用Bean（至于为什么采用JSP来调用，请参考：http://blog.csdn.net/rosen/archive/2004/10/15/138324.aspx），让每一种方案分别解析10K、100K、1000K、10000K的 XML 文件，计算其消耗时间（单位:毫秒）。
   
    JSP 文件：
    <%@ page contentType="text/html; charset=gb2312" %>
    <%@ page import="com.test.*"%>

    <html>
        <body>
        <%
            String args[]={""};
            MyXMLReader.main(args);
        %>
        </body>
    </html>

测 试

    首先出场的是 DOM（JAXP Crimson 解析器）   

    DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。
   
    另一方面，对于特别大的文档，解析和加载整个文档可能很慢且很耗资源，因此使用其他手段来处理这样的数据会更好。这些基于事件的模型，比如 SAX。

    Bean文件：
    package com.test;

    import java.io.*;
    import java.util.*;
    import org.w3c.dom.*;
    import javax.xml.parsers.*;

    public class MyXMLReader{

        public static void main(String arge[]){
            long lasting =System.currentTimeMillis();
            try{  
                File f=new File("data_10k.xml");
                DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
                DocumentBuilder builder=factory.newDocumentBuilder();
                Document doc = builder.parse(f);
                NodeList nl = doc.getElementsByTagName("VALUE");
                for (int i=0;i<nl.getLength();i++){
                    System.out.print("车牌号码:" +  doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
                    System.out.println(" 车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
                }
            }catch(Exception e){
                e.printStackTrace();
            }
            System.out.println("运行时间："+(System.currentTimeMillis() - lasting)+" 毫秒");
        }
    }

      10k消耗时间：265 203 219 172
    100k消耗时间：9172 9016 8891 9000
  1000k消耗时间：691719 675407 708375 739656
10000k消耗时间：OutOfMemoryError

    接着是 SAX
   
    这种处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX 还比它的替代者 DOM 快许多。

    选择 DOM 还是选择 SAX ？

    对于需要自己编写代码来处理 XML 文档的开发人员来说，选择 DOM 还是 SAX 解析模型是一个非常重要的设计决策。
    DOM 采用建立树形结构的方式访问 XML 文档，而 SAX 采用的事件模型。
    DOM 解析器把 XML 文档转化为一个包含其内容的树，并可以对树进行遍历。用 DOM 解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用 DOM 解析器的时候需要处理整个 XML 文档，所以对性能和内存的要求比较高，尤其是遇到很大的 XML 文件的时候。由于它的遍历能力，DOM 解析器常用于 XML 文档需要频繁的改变的服务中。
    SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。
   
    Bean文件：
    package com.test;
    import org.xml.sax.*;
    import org.xml.sax.helpers.*;
    import javax.xml.parsers.*;

    public class MyXMLReader extends DefaultHandler {

        java.util.Stack tags = new java.util.Stack();

        public MyXMLReader() {
            super();
        }

        public static void main(String args[]) {
            long lasting = System.currentTimeMillis();
            try {
                SAXParserFactory sf = SAXParserFactory.newInstance();
                SAXParser sp = sf.newSAXParser();
                MyXMLReader reader = new MyXMLReader();
                sp.parse(new InputSource("data_10k.xml"), reader);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
        }

        public void characters(char ch[], int start, int length) throws SAXException {
            String tag = (String) tags.peek();
            if (tag.equals("NO")) {
                System.out.print("车牌号码：" + new String(ch, start, length));
            }
            if (tag.equals("ADDR")) {
                System.out.println("  地址:" + new String(ch, start, length));
            }
        }

        public void startElement(
            String uri,
            String localName,
            String qName,
            Attributes attrs) {
                tags.push(qName);
            }
        }

      10k消耗时间：110 47 109 78
    100k消耗时间：344 406 375 422
  1000k消耗时间：3234 3281 3688 3312
10000k消耗时间：32578 34313 31797 31890 30328

    然后是 JDOM http://www.jdom.org/

    JDOM 的目的是成为 Java 特定文档模型，它简化与 XML 的交互并且比使用 DOM 实现更快。由于是第一个 Java 特定模型，JDOM 一直得到大力推广和促进。正在考虑通过“Java 规范请求 JSR-102”将它最终用作“Java 标准扩展”。从 2000 年初就已经开始了 JDOM 开发。

    JDOM 与 DOM 主要有两方面不同。首先，JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二，API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java 开发者的使用。

    JDOM 文档声明其目的是“使用 20%（或更少）的精力解决 80%（或更多）Java/XML 问题”（根据学习曲线假定为 20%）。JDOM 对于大多数 Java/XML 应用程序来说当然是有用的，并且大多数开发者发现 API 比 DOM 容易理解得多。JDOM 还包括对程序行为的相当广泛检查以防止用户做任何在 XML 中无意义的事。然而，它仍需要您充分理解 XML 以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习 DOM 或 JDOM 接口都更有意义的工作。

    JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档。JDOM 是在 Apache 许可证变体下发布的开放源码。

    Bean文件：
    package com.test;

    import java.io.*;
    import java.util.*;
    import org.jdom.*;
    import org.jdom.input.*;

    public class MyXMLReader {

        public static void main(String arge[]) {
            long lasting = System.currentTimeMillis();
            try {
                SAXBuilder builder = new SAXBuilder(); 
                Document doc = builder.build(new File("data_10k.xml"));
                Element foo = doc.getRootElement();
                List allChildren = foo.getChildren();
                for(int i=0;i<allChildren.size();i++) {
                    System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText());
                    System.out.println(" 车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
        }
    }

      10k消耗时间：125 62 187 94
    100k消耗时间：704 625 640 766
  1000k消耗时间：27984 30750 27859 30656
10000k消耗时间：OutOfMemoryError

    最后是 DOM4J http://dom4j.sourceforge.net/
   
    虽然 DOM4J 代表了完全独立的开发结果，但最初，它是 JDOM 的一种智能分支。它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过 DOM4J API 和标准 DOM 接口具有并行访问功能。从 2000 下半年开始，它就一直处于开发之中。

    为支持所有这些功能，DOM4J 使用接口和抽象基本类方法。DOM4J 大量使用了 API 中的 Collections 类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然 DOM4J 付出了更复杂的 API 的代价，但是它提供了比 JDOM 大得多的灵活性。

    在添加灵活性、XPath 集成和对大文档处理的目标时，DOM4J 的目标与 JDOM 是一样的：针对 Java 开发者的易用性和直观操作。它还致力于成为比 JDOM 更完整的解决方案，实现在本质上处理所有 Java/XML 问题的目标。在完成该目标时，它比 JDOM 更少强调防止不正确的应用程序行为。

    DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

    Bean文件：
    package com.test;

    import java.io.*;
    import java.util.*;
    import org.dom4j.*;
    import org.dom4j.io.*;

    public class MyXMLReader {

        public static void main(String arge[]) {
            long lasting = System.currentTimeMillis();
            try {
                File f = new File("data_10k.xml");
                SAXReader reader = new SAXReader();
                Document doc = reader.read(f);
                Element root = doc.getRootElement();
                Element foo;
                for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
                    foo = (Element) i.next();
                    System.out.print("车牌号码:" + foo.elementText("NO"));
                    System.out.println(" 车主地址:" + foo.elementText("ADDR"));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
        }
    }

      10k消耗时间：109 78 109 31
    100k消耗时间：297 359 172 312
  1000k消耗时间：2281 2359 2344 2469
10000k消耗时间：20938 19922 20031 21078

THE END

   JDOM 和 DOM 在性能测试时表现不佳，在测试 10M 文档时内存溢出。在小文档情况下还值得考虑使用 DOM 和 JDOM。虽然 JDOM 的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM 仍是一个非常好的选择。DOM 实现广泛应用于多种编程语言。它还是许多其它与 XML 相关的标准的基础，因为它正式获得 W3C 推荐（与基于非标准的 Java 模型相对），所以在某些类型的项目中可能也需要它（如在 JavaScript 中使用 DOM）。
   SAX表现较好，这要依赖于它特定的解析方式。一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。
   无疑，DOM4J是这场测试的获胜者，目前许多开源项目中大量采用 DOM4J，例如大名鼎鼎的 Hibernate 也用 DOM4J 来读取 XML 配置文件。如果不考虑可移植性，那就采用DOM4J吧！

参考文献：
http://www-900.ibm.com/developerWorks/cn/xml/x-injava/index.shtml
http://www-900.ibm.com/developerWorks/cn/xml/x-injava2/index.shtml
 

请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

    在一个类中，有一个叫做test()的方法需要被JSP端调用（test()主要任务是System.out.print()），于是在test()方法开始的地方加上"long lasting =System.currentTimeMillis()，"在结束的地方加上"System.out.println("运行时间："+(System.currentTimeMillis() - lasting)+" 毫秒")"。

    然后把test()方法改成main()方法，以便单独测试类，JSP端代码作出相应调整以便访问main()方法。奇怪的事情发生了，经过反复测试，使用JSP访问main()方法消耗的时间为 451 毫秒，而单独运行这个类消耗的时间为 2864 毫秒。

    为什么会这样？是不是WEB容器的原因呢？
   
-----------------------------------------------------------------------------

  在一个人气很高的论坛上，我得到些解答，自己也总结了一些，请各位看官来发表意见：
   
    第一次请求JSP时，WEB容器将JSP发送到编译器，编译成Servlet。然后把Servlet和其他类（比如自己写的类）缓存在WEB容器中，再放入内存常驻，最后将响应结果返回给客户端；而JSP的所有后继请求，WEB容器将自动载入缓存，除非JSP或者类经过修改，否则WEB容器将不会重新执行编译并构造缓存。而单独运行类就不一样了，由于没有WEB容器缓存支持，每次运行都需要重新编译再读入内存才行，所以要慢些了。
    另外，根据测试，在JSP端第一次被调用的时候，时间和单独运行类差不多，这也印证了上面的解释吧。

   
附上源程序
类：
package com.test;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class MyXMLReader extends DefaultHandler{ 

 java.util.Stack tags=new java.util.Stack();

 public MyXMLReader(){
  super();
 }

 public static void main(String args[]){
 long lasting =System.currentTimeMillis();
  try{  
      SAXParserFactory sf  = SAXParserFactory.newInstance();
      SAXParser sp = sf.newSAXParser();
      MyXMLReader reader = new MyXMLReader();
      sp.parse(new InputSource("data.xml"),reader);
  }
  catch(Exception e){
   e.printStackTrace();
  }
  System.out.println("运行时间："+(System.currentTimeMillis() - lasting)+" 毫秒");
 }

 public void characters (char ch[], int start, int length)
    throws SAXException
   {

  //从栈中得到当前节点的信息
   String tag=(String) tags.peek();
    if(tag.equals("NO") ){
   System.out.print("车牌号码：" +  new String(ch,start,length));
    }
    if(tag.equals("ADDR")){
   System.out.println("  地址:" + new String(ch,start,length));
    }
   }

 public void startElement(String uri, String localName, String qName, Attributes attrs){ 
 tags.push(qName);
 }
}

JSP：
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="com.test.*"%>

<%
    long lasting =System.currentTimeMillis();
%>
<html>
    <body>
<%
    String args[]={""};
    MyXMLReader.main(args);
%>
    </body>
</html> 



请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

package BMP;

import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.MemoryImageSource;

import java.io.FileInputStream;
import java.io.FileOutputStream;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

public class BMPReader{

    public String Reader(){ 
        Image image;                                    //构造一个目标图
        String result="";                               //返回结果
 try{
     FileInputStream fs=new FileInputStream("/test.BMP");
     int bflen=14;                           
     byte bf[]=new byte[bflen];            
     fs.read(bf,0,bflen);                       //读取14字节BMP文件头
     int bilen=40;                 
     byte bi[]=new byte[bilen];
     fs.read(bi,0,bilen);                       //读取40字节BMP信息头

     // 获取一些重要数据
     int nwidth=(((int)bi[7]&0xff)<<24)         //源图宽度
     | (((int)bi[6]&0xff)<<16)
     | (((int)bi[5]&0xff)<<8)
     | (int)bi[4]&0xff;
     System.out.println("宽:"+nwidth);
            int nheight=(((int)bi[11]&0xff)<<24)       //源图高度
     | (((int)bi[10]&0xff)<<16)
     | (((int)bi[9]&0xff)<<8)
     | (int)bi[8]&0xff;
     System.out.println("高:"+nheight);
            //位数
     int nbitcount=(((int)bi[15]&0xff)<<8) | (int)bi[14]&0xff;
     System.out.println("位数:"+nbitcount);
            //源图大小
     int nsizeimage=(((int)bi[23]&0xff)<<24)
     | (((int)bi[22]&0xff)<<16)
     | (((int)bi[21]&0xff)<<8)
     | (int)bi[20]&0xff;
     System.out.println("源图大小:"+nsizeimage);

            //对24位BMP进行解析
     if(nbitcount==24){
         int npad=(nsizeimage/nheight)-nwidth*3;
         int ndata[]=new int[nheight*nwidth];
         byte brgb[]=new byte[(nwidth+npad)*3*nheight];
         fs.read (brgb,0,(nwidth+npad)*3*nheight);
         int nindex=0;
         for(int j=0;j<nheight;j++){
      for(int i=0;i<nwidth;i++){
                 ndata [nwidth*(nheight-j-1)+i]=
          (255&0xff)<<24
          | (((int)brgb[nindex+2]&0xff)<<16)
          | (((int)brgb[nindex+1]&0xff)<<8)
          | (int)brgb[nindex]&0xff;
                 nindex+=3;
            }
     nindex+=npad;
                }
  Toolkit kit=Toolkit.getDefaultToolkit();
  image=kit.createImage(new MemoryImageSource(nwidth,nheight,
      ndata,0,nwidth));
                result="从BMP得到图像image";
                System.out.println("从BMP得到图像image");
     }else{
         result="不是24位BMP，失败！";
                System.out.println("不是24位BMP，失败！");
         image=(Image)null;
     }
            fs.close();        //关闭输入流
           
            //开始进行图像压缩（对image对象进行操作）
     int wideth=image.getWidth(null);                                   //得到源图宽
     int height=image.getHeight(null);                                  //得到源图长
     BufferedImage tag=new BufferedImage(wideth/2,height/2,BufferedImage.TYPE_INT_RGB);
     tag.getGraphics().drawImage(image,0,0,wideth/2,height/2,null);     //绘制缩小后的图
     FileOutputStream out=new FileOutputStream("/newfile.jpg");         //输出到文件流
     JPEGImageEncoder encoder=JPEGCodec.createJPEGEncoder(out);     
     encoder.encode(tag);                                               //进行JPEG编码
     out.close();       //关闭输出流                     
 }catch (Exception e){
     System.out.println(e);
        }
        return result;
    }
}

    相信代码部分应该没有什么问题吧？通过以下方法，你可以得到更多的信息：

       //得到压缩值
        int ncompression = (((int)bi[19])<<24)
        | (((int)bi[18])<<16)
        | (((int)bi[17])<<8)
        | (int)bi[16];
        System.out.println("压缩:"+ncompression);

       //象素情况
        int nxpm = (((int)bi[27]&0xff)<<24)
        | (((int)bi[26]&0xff)<<16)
        | (((int)bi[25]&0xff)<<8)
        | (int)bi[24]&0xff;
        System.out.println("X-象素/米:"+nxpm);
        int nypm = (((int)bi[31]&0xff)<<24)
        | (((int)bi[30]&0xff)<<16)
        | (((int)bi[29]&0xff)<<8)
        | (int)bi[28]&0xff;
        System.out.println("Y-象素/米:"+nypm);

       //颜色使用情况
        int nclrused = (((int)bi[35]&0xff)<<24)
        | (((int)bi[34]&0xff)<<16)
        | (((int)bi[33]&0xff)<<8)
        | (int)bi[32]&0xff;
        System.out.println("颜色使用数:"+nclrused);
        int nclrimp = (((int)bi[39]&0xff)<<24)
        | (((int)bi[38]&0xff)<<16)
        | (((int)bi[37]&0xff)<<8)
        | (int)bi[36]&0xff;
        System.out.println("颜色显要:"+nclrimp);
        int nplanes = (((int)bi[13]&0xff)<<8) | (int)bi[12]&0xff;
        System.out.println("位面:"+nplanes);

       //信息头中的图像大小
        int nbisize = (((int)bi[3]&0xff)<<24) 
        | (((int)bi[2]&0xff)<<16)
        | (((int)bi[1]&0xff)<<8)
        | (int)bi[0]&0xff;
        System.out.println("BMP信息头大小:"+nbisize);

       //文件大小及种类
        int nsize=(((int)bf[5]&0xff)<<24)      
               | (((int)bf[4]&0xff)<<16)
        | (((int)bf[3]&0xff)<<8)
        | (int)bf[2]&0xff;
        System.out.println("文件种类:"+(char)bf[0]+(char)bf[1]);
        System.out.println("文件大小:"+nsize);
       
后记

       可以通过变量nbitcount来判断是否是8位位图并作出相应处理。限于目前24位位图应用较为广泛，所以没有写出相应代码，如有需要可查阅Jeff West与John D.Mitchell之著作《How to read 8- and 24-bit Microsoft Windows bitmaps in Java applications》。

       在此，我谨慎的表示：因为位图（BMP）没有经过压缩，所以对于源图的容量几乎没有限制，不会出现内存不足的情况。
   
       在写这篇文章时我只进行了9M左右BMP的读取，其实大家有兴趣的话可以利用50M左右的TIF图转换为BMP（几乎还是50M）来做试验。并欢迎上来指正。



请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

    通过本文，你将能了解到如何配置服务以及Google WebService的语法结构；怎样个性化你的搜索，例如:国家、语言；怎样提炼搜索结果。
    Google目前已经成了Web上最流行的搜索引擎，为了让诸如new content watchdog、GUI搜索工具和模式分析之类的应用程序成为可能，现在它们为20亿个页面建立了索引，开发者们可以通过基于SOAP的API进行调用。
   
WebService 简介

    Web应用的巨大成功和不断发展，使其渗透到商业领域和个人生活的各个方面。人们只要使用浏览器，就可以享受到各种各样的Web服务，例如网上购物，网上交易，网络游戏，预定车票，网上聊天和交友等等。与此同时，由于Web技术所带来的优势（统一的客户端和较好的维护性），使一些传统的应用纷纷转型到基于B/S架构的瘦客户端应用程序，这是因为它能够避免花在桌面应用程序发布上的高成本，也能够很好的解决客户和服务器之间的通信问题。在客户端和服务器之间的通信，一个完美的解决方案是使用HTTP协议来通信。这是因为任何运行Web浏览器的机器都使用HTTP协议，可以很好地透过防火墙进行通信。许多商业程序还面临另一个问题，那就是与其他程序的互操作性。目前有很多商业数据仍然在大型主机上以非关系文件（VSAM）的形式存放，并由COBOL语言编写的大型机程序访问。而且，还有很多商业程序使用C++、JAVA、VB和其他各种各样的语言编写。现在初了最简单的程序之外，所有的程序都需要与运行在其他异构平台上的应用程序集成并进行数据交换。在以前，没有一个应用程序通信标准是独立于平台、组建模型和编程语言的。只有通过Web Service、客户端和服务器才能够自由的用HTTP进行通信，不论两个程序的平台和编程语言是什么。Web Service技术完全基于标准的技术，只有基于标准，所有的开放厂商才能有相同的标准，才能够在各自的平台上开发出具有跨平台互操作能力的软件产品和解决方案。标准时达成跨平台互操作能力的灵魂。

    Web是为了程序到用户的交互，而Web Service是为程序到程序的交互做准备。Web Service使公司可以降低进行电子商务的成本、更快的部署解决方案以及开拓新机遇。达到这个目标的关键在于通用的程序到程序通信模型，该模型应建立在现有的和新兴的标准之上。其中包括：HTTP，SOAP, WSDL, UDDI
   
      SOAP：是“Simple Object Access Protocol”的缩写，SOAP是消息传递的协议,它规定了Web Services之间是怎样传递信息的。
简单的说，SOAP规定了：
1. 传递信息的格式为XML。这就使Web Services能够在任何平台上，用任何语言进行实现。
2. 远程对象方法调用的格式。规定了怎样表示被调用对象以及调用的方法名称和参数类型等。
3. 参数类型和XML格式之间的映射。这是因为，被调用的方法有时候需要传递一个复杂的参数，例如，一个Person对象。怎样用XML来表示一个对象参数，也是SOAP所定义的范围。

    WSDL：是“Web Services Description Language”的缩写。WSDL是Web Services的定义语言。当实现了某种服务的时候(如：股票查询服务)，为了让别的程序调用，必须告诉大家服务接口。例如：服务名称，服务所在的机器名称，监听端口号，传递参数的类型，个数和顺序，返回结果的类型等等。这样别的应用程序才能调用该服务。WSDL协议就是规定了有关Web Services描述的标准。

    UDDI：是“Universal Description, Discovery,and Integration”的缩写。简单说，UDDI用于集中存放和查找WSDL描述文件，起着目录服务器的作用。

快速安装

    本文的运行环境是JDK1.3+Tomcat4.0+JSP。要使用Google的服务，必须要有“license key”，可以在https://www.google.com/accounts/NewAccount?continue=http://api.google.com/createkey&followup=http://api.google.com/createkey中取得，输入相应的信息，然后到你的邮箱收取“license key”。接着还需要“Java API for XML Messaging”亦即“JAXM”。它是Java XML Pack的一部分，在http://java.sun.com/xml/downloads/javaxmlpack.html提供。
    为了更简单的表达，我直接用JSP模式，并使用手工编码，没有用IDE环境。
    解开刚才下载的java_xml_pack-summer02_01.zip，找到java_xml_pack-summer-02_01\jaxp-1.2_01\xalan.jar文件，用WinRAR解开把org文件夹拷贝到你的应用程序的WEB-INF\classes下。找到java_xml_pack-summer-02_01\jaxm-1.1_01\lib\saaj-api.jar文件，解开它并拷贝javax文件夹到同上的目录。找到java_xml_pack-summer-02_01\jaxm-1.1_01\lib\jaxm-api.jar文件，解开它并拷贝javax文件夹到相同目录。找到java_xml_pack-summer-02_01\jaxp-1.2_01\jaxp-api.jar文件，解开它并拷贝javax文件夹到相同目录。找到java_xml_pack-summer-02_01\jaxm-1.1_01\jaxm\saaj-ri.jar文件，解开并拷贝com文件夹到相同目录。
    
   

程序源代码

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="org.apache.xalan.processor.TransformerFactoryImpl"%>
<%@ page import="javax.xml.soap.SOAPConnectionFactory"%>
<%@ page import="javax.xml.soap.SOAPConnection"%>
<%@ page import="javax.xml.soap.MessageFactory"%>
<%@ page import="javax.xml.soap.SOAPMessage"%>
<%@ page import="javax.xml.soap.SOAPPart"%>
<%@ page import="javax.xml.soap.SOAPEnvelope"%>
<%@ page import="javax.xml.soap.SOAPBody"%>
<%@ page import="javax.xml.soap.SOAPElement"%>
<%@ page import="java.io.FileInputStream"%>
<%@ page import="javax.xml.transform.stream.StreamSource"%>
<%@ page import="javax.xml.messaging.URLEndpoint"%>
<%@ page import="javax.xml.transform.TransformerFactory"%>
<%@ page import="javax.xml.transform.Transformer"%>
<%@ page import="javax.xml.transform.Source"%>
<%@ page import="javax.xml.transform.stream.StreamResult"%>

<html>
<head>
<title>google WebService</title>
</head>
       
<%
try { 
       
    //首先建立一个连接
    SOAPConnectionFactory soapConnFactory =
                       SOAPConnectionFactory.newInstance();
    SOAPConnection connection =
                        soapConnFactory.createConnection();

    //接着，创建消息
    MessageFactory messageFactory=MessageFactory.newInstance();
    SOAPMessage message=messageFactory.createMessage();
    
    //为消息部份创建SOAP对象         
    SOAPPart soapPart=message.getSOAPPart();
                        
    //组装信息，根据C盘根目录下search.msg文件进行搜索
    StreamSource preppedMsgSrc=new StreamSource(new FileInputStream("/search.msg"));            
    soapPart.setContent(preppedMsgSrc);
    
    //保存消息
    message.saveChanges();
         
    //发送到目标地址
    URLEndpoint destination=
          new URLEndpoint("http://api.google.com/search/beta2");
    
    //发送消息
    SOAPMessage reply=connection.call(message, destination);

    //保存输出，建立传出信息
   TransformerFactory transformerFactory =
                      TransformerFactory.newInstance();

   //根据样式文件translate.xsl进行解析
   Source styleSheet=new StreamSource("/translate.xsl");  
   Transformer transformer=
               transformerFactory.newTransformer(styleSheet);
         
   //提取收到的内容
   Source sourceContent=reply.getSOAPPart().getContent();
       
   //建立输出文件results.out
   StreamResult result=new StreamResult("/results.out"); 
   transformer.transform(sourceContent, result);
   out.println("文件已生成C:\results.out");
        
   //关闭连接           
   connection.close();
}catch(Exception e){
    System.out.println(e.getMessage());
}
%>

</body>
</html>

    源代码部分完全按照Google的规定进行编写，程序注解部分也在其中，这里就不罗嗦了。

搜索格式

<?xml version='1.0' encoding='UTF-8'?>
<SOAP-ENV:Envelope 
          xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" 
          xmlns:xsi="http://www.w3.org/1999/XMLSchema-instance"
          xmlns:xsd="http://www.w3.org/1999/XMLSchema">
   <SOAP-ENV:Body>
    <ns1:doGoogleSearch  xmlns:ns1="urn:GoogleSearch"
         SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
        
      <key xsi:type="xsd:string">00000000000000000000000000000000</key> 
      <q xsi:type="xsd:string">CSDN论坛</q>
      <start xsi:type="xsd:int">0</start>
      <maxResults xsi:type="xsd:int">10</maxResults>
      <filter xsi:type="xsd:boolean">false</filter>
      <restrict xsi:type="xsd:string"></restrict>
      <safeSearch xsi:type="xsd:boolean">false</safeSearch>
      <lr xsi:type="xsd:string"></lr>
      <ie xsi:type="xsd:string">latin1</ie>
      <oe xsi:type="xsd:string">latin1</oe>
    </ns1:doGoogleSearch>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

    search.msg文件标签<<key></key>之前的为固定格式，无需费心。标签<key>就是本文第一部分所提到的“license key”，直接复制过来。标签<q>是指具体要搜索的内容。标签<start>是指从第几个开始搜索。标签<maxResults>是指每次返回搜索结果的最大值，Google WebService规定，最大值只能是“10”。标签<filter>是指过滤掉结果中相似和域名相同的结果。标签<restrict>是指国家和主题的约束，例如要限制只在国内搜索，就需要输入countryCN；要限制只在Linux主题内搜索，就输入linux。标签<safeSearch>过滤掉成人信息。标签<lr>搜索的语言，例如只搜索简体中文，就要输入lang_zh-CN。标签<ie>和<oe>分别指输入和输出的编码格式默认为latin1(UTF-8)。

解析格式

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">       
  <xsl:output method="text"/>        
    <xsl:template match="/">
      <xsl:apply-templates select="//item"/>
    </xsl:template>        
    <xsl:template match="item">
   
      <xsl:value-of select="title" disable-output-escaping="yes"/>
      <xsl:text>
      </xsl:text>
      <xsl:value-of select="URL"/>
      <xsl:text>      
    </xsl:text>   
    <xsl:value-of select="summary"/>
  </xsl:template>        
</xsl:stylesheet>

    translate.xsl文件。我们从<xsl:value-of select="title" disable-output-escaping="yes"/>这一句开始，select="title"确定了返回结果的第一部分为标题。接下来，select="URL"解析出URL地址。<xsl:text></xsl:text>暂且理解为换行标签吧。select="summary"解析出摘要。还有一些标签，详情请参考“Google Web APIs Reference”。

后 记

    程序运行以后所产生的结果results.out请大家自己去查看，在这里就不一一列举了。
    创作这篇文章的目的纯属个人爱好，完全是对Google引擎的一种喜爱。文章不是很有深度，希望能给各位起到抛砖引玉的作用我就满足了，更加丰富的功能还有待我们去探索！



请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen