arch
 这个子目录包含了所有体系结构相关的核心代码。它还包含每种支持的体系结构的子目录，如i386。
include
 这个目录包括了用来重构核心的大多数include文件。对于每种支持的体系结构分别有一个子目录。 此目录中的asm子目录中是对应某种处理器的符号连接，如include/asm-i386。要修改处理器结构 则只需编辑核心的makefile并重新运行Linux核心配置程序。
init
 此目录包含核心启动代码。
mm
 此目录包含了所有的内存管理代码。与具体体系结构相关的内存管理代码位于arch/*/mm目录下， 如arch/i386/mm/fault.c 。
drivers
 系统中所有的设备驱动都位于此目录中。它又进一步划分成几类设备驱动，如block。
ipc
 此目录包含了核心的进程间通讯代码。
modules
 此目录仅仅包含已建好的模块。
fs
 所有的文件系统代码。它也被划分成对应不同文件系统的子目录，如vfat和ext2。
kernel
 主要核心代码。同时与处理器结构相关代码都放在arch/*/kernel目录下。
net
 核心的网络部分代码。
lib
 此目录包含了核心的库代码。与处理器结构相关库代码被放在arch/*/lib/目录下。
scripts
 此目录包含用于配置核心的脚本文件（如awk和tk脚本）。

从哪里入手,如何入手

阅读象Linux核心代码这样的复杂程序令人望而生畏。它象一个越滚越大的雪球。阅读核心某个部分经常要 用到好几个其他的相关文件，不久你将会忘记你原来在干什么。本小节将给出一些提示。

系统启动与初始化

在基于intel的系统上，Linux可以通过loadlin.exe或者LILO将核心载入内存并将控制传递给它。这部分程序 位于arch/i386/kerneld/head.S。此文件完成一些处理器相关操作并跳转到init/main.c中的main()例程。

内存管理

这部分代码主要位于mm目录中但其处理器结构相关部分被放在arch/*/mm中。页面出错处理代码位于mm下的 memory.c文件中而内存映射与页面cache代码位于filemap.c中。buffer cache则在mm/buffer.c中实现， swap cache位于mm/swap_state.c和mm/swapfile.c中。

核心

大多数通用代码位于kernel目录下而处理器相关代码被放在arch/*/kernel中。调度器位于kernel/sched.c 而fork代码位于kernel/fork.c中。底层部分处理代码位于include/linux/interrupt.h中。task_struct的 描叙则在/linux/sched.h中可以找到。

PCI

PCI伪设备驱动位于drivers/pci/pci.c且其系统通用定义放在include/linux/pci.h中。每个处理器结构 具有特殊的PCI BIOS代码，Alpha AXP的位于arch/alpha/kernel/bios32.c中。

进程间通讯

所有这些代码都在ipc目录中。系统V IPC对象都包含一个ipc_perm结构，它在include/linux/ipc.h中描叙。 系统V消息在ipc/msg.c中实现，共享内存在ipc/shm.c而信号灯位于ipc/sem.c中。管道在ipc/pipe.c中实现。

中断处理

核心的中断处理代码总是与微处理器结构相关。Intel系统的中断处理代码位于arch/i386/kernel/irq.c中， 其定义位于include/asm-i386/irq.h中。

设备驱动

Linux核心源码的大多数都是设备驱动。所有Linux的设备驱动源码都放在drivers目录中并分成以下几类：

/block
 块设备驱动包括IDE（在ide.c中）驱动。如果你想寻找这些可包含文件系统的设备的初始化过程 则应该在drivers/block/genhd.c中的device_setup()。当安装一个nfs文件系统时不但要初始化 硬盘还需初始化网络。块设备包括IDE与SCSI设备。

/char
 此目录包含字符设备的驱动，如ttys，串行口以及鼠标。

/cdrom
 包含所有Linux CDROM代码。在这里可以找到某些特殊的CDROM设备（如Soundblaster CDROM）。 IDE接口的CD驱动位于drivers/block/ide-cd.c中而SCSI CD驱动位于drivers/scsi/scsi.c中。

/pci
 它包含了PCI伪设备驱动源码。这里可以找到关于PCI子系统映射与初始化的代码。另外位于 arch/alpha/kernel/bios32.c中的Alpha AXP PCI补丁代码也值得一读。

/scsi
 这里可以找到所有的SCSI代码以及Linux支持的SCSI 设备的设备驱动。

/net
 包含网络驱动源码，如tulip.c中的DECChip 21040 PCI以太网驱动。

/sound
 所有的声卡驱动源码。

文件系统

EXT2文件系统的源码位于fs/ext2中，其数据结构定义位于include/linux/ext2_fs.h, ext2_fs_i.h 以及 ext2_fs_sb.h中。虚拟文件系统数据结构在include/linux/fs.h中描叙且其代码在fs/*中。buffer cache 和update核心后台进程在fs/buffer.c中实现。

网络

网络代码位于net目录而大多数包含文件位于include/net中。BSD套接口代码位于net/socket.c中。IPV4的 INET套接口代码位于net/ipv4/af_inet.c中。通用协议支撑代码（包括sk_buff处理过程）位于net/core中， 同时TCP/IP网络代码位于net/ipv4中。网络设备驱动位于drivers/net中。

模块

核心模块代码部分位于核心中部分位于modules包中。核心代码位于kernel/modules.c且其数据结构与核心 后台进程kerneld消息位于include/linux/module.h和include/linux/kerneld.h目录中。同时必要时需查阅 include/linux/elf.h中的ELF文件格式。

在创建一个bean定义（通常为XML配置文件）时，你可以简单的将其理解为：用以创建由该bean定义所决定的实际对象实例的一张“处方（recipe）”或者模板。就如class一样，根据一张“处方”你可以创建多个对象实例。

你不仅可以控制注入到对象（bean定义）中的各种依赖和配置值，还可以控制该对象的作用域。这样你可以灵活选择所建对象的作用域，而不必在 Java Class级定义作用域。Spring Framework支持五种作用域（其中有三种只能用在基于web的Spring ApplicationContext）。

内置支持的作用域分列如下：

3.4.1. Singleton作用域

当一个bean的作用域为singleton, 那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

换言之，当把一个bean定义设置为singlton作用域时，Spring IoC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例。

下图演示了Spring的singleton作用域。

 

 

请注意Spring的singleton bean概念与“四人帮”（GoF）模式一书中定义的Singleton模式是完全不同的。经典的GoF Singleton模式中所谓的对象范围是指在每一个ClassLoader中指定class创建的实例有且仅有一个。把Spring的singleton作用域描述成一个container对应一个bean实例最为贴切。亦即，假如在单个Spring容器内定义了某个指定class的bean，那么Spring容器将会创建一个且仅有一个由该bean定义指定的类实例。

Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

<bean id="accountService" class="com.foo.DefaultAccountService"/>



<!-- the following is equivalent, though redundant (singleton scope is the default) -->

<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>



<!-- the following is equivalent, though redundant (and preserved for backward compatibility) -->

<bean id="accountService" class="com.foo.DefaultAccountService" singleton="true"/>

3.4.2. Prototype作用域

Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。根据经验，对所有有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。

下图演示了Spring的prototype作用域。请注意，典型情况下，DAO不会被配置成prototype，因为一个典型的DAO不会持有任何会话状态，因此应该使用singleton作用域。

 

 

要在XML中将bean定义成prototype，可以这样配置：

<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>



<!-- the following is equivalent too (and preserved for backward compatibility) -->

<bean id="accountService" class="com.foo.DefaultAccountService" singleton="false"/>

对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责：容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不 闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被 调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用 bean的后置处理器，该处理器持有要被清除的bean的引用。）

谈及prototype作用域的bean时，在某些方面你可以将Spring容器的角色看作是Java new操作符的替代者。任何迟于该时间点的生命周期事宜都得交由客户端来处理。在第 3.5.1 节 “Lifecycle接口”一节中会进一步讲述Spring IoC容器中的bean生命周期。

<web-app>

...

<listener>

<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>

</listener>

...

</web-app>

<web-app>

..

<filter> 

<filter-name>requestContextFilter</filter-name> 

<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>

</filter> 

<filter-mapping> 

<filter-name>requestContextFilter</filter-name> 

<url-pattern>/*</url-pattern>

</filter-mapping>

...

</web-app>

<bean id="loginAction" class="com.foo.LoginAction" scope="request"/>

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

<bean id="userPreferences" class="com.foo.UserPreferences" scope="globalSession"/>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">



<!-- a HTTP Session-scoped bean exposed as a proxy -->

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session">



<!-- this next element effects the proxying of the surrounding bean -->

<aop:scoped-proxy/>

</bean>



<!-- a singleton-scoped bean injected with a proxy to the above bean -->

<bean id="userService" class="com.foo.SimpleUserService">



<!-- a reference to the proxied 'userPreferences' bean -->

<property name="userPreferences" ref="userPreferences"/>



</bean>

</beans>

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>



<bean id="userManager" class="com.foo.UserManager">

<property name="userPreferences" ref="userPreferences"/>

</bean>

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session">

<aop:scoped-proxy/>

</bean>



<bean id="userManager" class="com.foo.UserManager">

<property name="userPreferences" ref="userPreferences"/>

</bean>

void registerScope(String scopeName, Scope scope);

// note: the ThreadScope class does not exist; I made it up for the sake of this example

Scope customScope = new ThreadScope();

beanFactory.registerScope("thread", scope);

<bean id="..." class="..." scope="thread"/>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">



<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">

<property name="scopes">

<map>

<entry key="thread" value="com.foo.ThreadScope"/>

</map>

</property>

</bean>



<bean id="bar" class="x.y.Bar" scope="thread">

<property name="name" value="Rick"/>

<aop:scoped-proxy/>

</bean>



<bean id="foo" class="x.y.Foo">

<property name="bar" ref="bar"/>

</bean>



</beans>

在一个条件查询中没有必要显式的使用 "group by" 。某些投影类型就是被定义为 分组投影，他

们也出现在SQL的group by子句中。

可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的

实现方式：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
    .addOrder( Order.asc("colr") )
    .list();

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.groupProperty("color").as("colr") )
    .addOrder( Order.asc("colr") )
    .list();

alias()和as()方法简便的将一个投影实例包装到另外一个 别名的Projection实例中。简而言之，

当你添加一个投影到一个投影列表中时 你可以为它指定一个别名：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount(), "catCountByColor" )
        .add( Projections.avg("weight"), "avgWeight" )
        .add( Projections.max("weight"), "maxWeight" )
        .add( Projections.groupProperty("color"), "color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();


List results = session.createCriteria(Domestic.class, "cat")
    .createAlias("kittens", "kit")
    .setProjection( Projections.projectionList()
        .add( Projections.property("cat.name"), "catName" )
        .add( Projections.property("kit.name"), "kitName" )
    )
    .addOrder( Order.asc("catName") )
    .addOrder( Order.asc("kitName") )
    .list();


也可以使用Property.forName()来表示投影：

List results = session.createCriteria(Cat.class)
    .setProjection( Property.forName("name") )
    .add( Property.forName("color").eq(Color.BLACK) )
    .list();
List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount().as("catCountByColor") )
        .add( Property.forName("weight").avg().as("avgWeight") )
        .add( Property.forName("weight").max().as("maxWeight") )
        .add( Property.forName("color").group().as("color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();


8. 离线(detached)查询和子查询
DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来

执行它。

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
    .add( Property.forName("sex").eq('F') );
//创建一个Session
Session session = .;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();


DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者
Property获得。

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
    .add( Property.forName("weight).gt(avgWeight) )
    .list();
DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
    .add( Subqueries.geAll("weight", weights) )
    .list();

相互关联的子查询也是有可能的：

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
    .setProjection( Property.forName("weight").avg() )
    .add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
    .add( Property.forName("weight).gt(avgWeightForSex) )
    .list();











如图 1 。 Hibernate 设计了 CriteriaSpecification 作为 Criteria 的顶级接口，其下面提供了 Criteria 和 DetachedCriteria 。

Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需 Session ， DetachedCriteria 提供了 4 个静态方法 forClass(Class) 或 forEntityName(Name) 进行 DetachedCriteria 实例的创建。 Spring 的框架提供了

getHibernateTemplate().findByCriteria(detachedCriteria) 方法可以很方便地根据

DetachedCriteria 来返回查询结果。

如图 1 ， Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设置 FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel （冲刷 Session 的方式）和 LockMode （数据库锁模式）。

下面就对 Criterion 和 Projection 进行详细说明。

  Criterion 是 Criteria 的查询条件。

Criteria 提供了 add(Criterion criterion) 方法来添加查询条件。图 2 是 Criterion 的结构图。 Criterion 接口的主要实现包括： Example 、 Junction 和 SimpleExpression 。而 Junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 AND 和 OR 操作符进行来联结查询条件集合。

Criterion 的实例可以通过 Restrictions 工具类来创建， Restrictions 提供了大量的静态方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 Criterion 查询条件

（ SimpleExpression 实例）。除此之外， Restrictions 还提供了方法来创建 conjunction 和 disjunction 实例，通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合。

至于 Example 的创建有所不同， Example 本身提供了一个静态方法 create(Object entity) ，即根据一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设置一些过滤条件：

Example exampleUser =Example.create(u)

.ignoreCase() // 忽略大小写

.enableLike(MatchMode.ANYWHERE);

// 对 String 类型的属性，无论在那里值在那里都匹配。相当于 %value%

 

Project 主要是让 Criteria 能够进行报表查询，并可以实现分组。 Project 主要有 SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和 ProjectionList 的实例化是由内建的 Projections 来完成，如提供的 avg 、 count 、 max 、 min 、 sum 可以让开发者很容易对某个字段进行统计查询。

       Property 是对某个字段进行查询条件的设置，如通过

      Porperty.forName(“color”).in(new String[]); 则可以创建一个 Project 实例。通过 criteria 的 add(Project) 方法加入到查询条件中去。

使用 Criteria 进行查询，主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查询条件的创建和组装，其结构层次如何。这样使用起来便可得心应手。

一、总述  

• Mule Homepage
• Mule2.0 Overview
• Mule1.4 时代的旧笔记

      Mule的运作能力也许是它在开源ESB中最大的优势：商业的支持公司Mulesource.com，给大家贡献代码的MuleForge.org，年度大会MuleConf，还挖来了CXF的作者与SaleForces的CXO......

二、示例

• LoanBroker EAI界经典例子，有ESB(JMS MessageBus)、ESN（WebService同步/异步)，JBPM工作流等模式。
• Pattern Based Development with Mule 2.0 《Open-Source ESBs in Action》作者
• CXF and Mule ppt CXF 作者 (for 1.4)
• Using SEDA to Ensure Service Availability(InfoQ) (for 1.4)

三、Mule的功能

1.  重温ESB的功能

• 解耦中介：客户对实际服务提供者的身份、物理位置、传输协议和接口定义都是不知道也不关心的，交互集成代码提取到了业务逻辑之外，由ESB平台进行中央的宣告式定义。
                ESB平台实现协议转换(WebService，Http，JMS...)，消息转换(转换、充实、过滤)，消息路由(同步/异步、发布/订阅、基于内容路由、分支与聚合...)。 
• 服务中介：ESB平台作为中介提供服务交互中的基础服务。
                ESB平台实现SLA(可靠性保证，负载均衡，流量控制，缓存，事务控制，加密传输)，服务管理监控(异常处理，服务调用及消息数据记录，系统及服务的状态监控，ESB配置管理)，统一安全管理(这个有点理想主义)。
• 服务编排：多个服务进行编排形成新的服务。
                ESB支持一个直观的形式定义新组合服务的流程(工作流、BPEL 或 代码级编排)。

2. Mule的解耦中介

    Pluggable的传输层，路由器，转换器是所有ESB必然支持的核心功能，作为《Enterprise Intergration Patterns》的遵循者提供如下：

• Transport：WebService、JMS等常用的协议都已满足，IBM MQ在企业版中提供，只缺Weblogic Tuxedo了。
• Router/Filter:提供EIP中描述的路由
  1.基于内容路由，Fillter提供消息类型、消息属性、JXPath和OGNL表达式的基础过滤能力。另有去除重复消息的Router。
  2.接收表基类，由用户自行实现。
  3.分拆聚合重排路由。
  4.流程编排路由见后。
• Transformer：提供基础层次上的的协议类型转换、XML<->Java转换、编码、压缩、加密转换。业务级转换由用户实现。

      不过，1.4版中的Transport的实现质量很一般，而Router、Filter、Transformer都实现得较简单和基础，

      最后，Mule额外提供了POJO的编程模型，而不是痛苦的XQuery Base的XML消息。

3. Mule的服务中介

     提供较基本的中介服务：

• 事务(支持XA的JDBC,JMS,VM queue)
• 异常处理(支持异常控制策略与Dead Letter Channel)
• 安全 (用Acegi意思了一下，弱)
• JMX监控及其他工具

    其他的能力如流量控制、负载均衡，可基于Mule的机制自行实现。

4. 服务编排

• ChainRouter简单实现Pipeline模式
• JBPM Router(见loanbroker example)。
• 在1.4版中还有OSWorkflow Router  和Apache PXE BPEL Router。

5. Service Container

   这是个额外的Bonus。Mule的身份并不纯粹。如果Component是什么都不干的Bridge Component，它就是真正纯调度外部服务的ESB。
   如果Component是业务POJO，在Mule中运行业务逻辑，Mule就成为一个Service Container，类似于SCA Domain。
   这时候它本身就是Spring+CXF的，额外有多通信协议支持，有SEDA(Staged Event-Driven Architecture)，有异步编程模式，有服务中介基础设施，作为后台服务容器也是个不错的选择。
   日后自己可能会越来越多使用Mule 2.0+Terracotta作为自己的服务容器方案。

四、Mule2.0 印象

    与Mule 2.0抵死缠绵了两周，喜忧掺半。但只在2.0之后，Mule才算真正站到了ESB的起跑线上。

• InfoQ中文站新闻
• Mule2.0的What's new
• Migrating Mule 1.x to 2.0

1. 很Spring，很SCA的配置文件

• 全Spring又全nameSpace化的配置文件，简洁而规范，在IDE中有良好的提示。
  尤其是transport相关的endpoint的改进明显，原来的URI<endpoint address="pop3://bob:secret@localhost:62002"> 或如下的connector

<connector name="SystemStreamConnector" className="org.mule.providers.stream.SystemStreamConnector">
<properties>
<property name="promptMessage" value="Please enter something: "/>
<property name="messageDelayTime" value="1000"/>
</properties>
</connector>

            改为transport特定的namespace后，IDE中清晰显示了可选的配置项。

<stdio:connector name="SystemStreamConnector" promptMessage="Please enter something: "messageDelayTime="1000"/>

• SCA的Service/Component概念。
  Service/Component代替了原来注定要被遗忘的MuleDescriptor，其中Component定义业务逻辑的POJO，Service定义如何以服务的方式管理组件的配置。
  在POJO中调用远程服务的Nested Router也改为了很SCA的Binding。
  Component也有Component 与 PooledComponent的选项。完整的例子如下：

<pooled-component>
<spring-object bean="mySpringPojo"/>
<binding interface="org.mule.example.loanbroker.credit.CreditAgencyService">
<outbound-endpoint ref="CreditAgency"/>
</binding>
<pooling-profile exhaustedAction="WHEN_EXHAUSTED_FAIL" initialisationPolicy="INITIALISE_ALL"
      maxActive="1" maxIdle="2"maxWait="3"/>
</pooled-component>

      上文按pooling-profile定义的pooled-component，在spring中定义mySpringPojo，并将一个远程的CXF Endpoint binding到POJO的CreditAgencyService变量中，可直接调用；

• 可视化拖拽的Eclipse 插件Mule IDE。
  虽然还非常原始，但总算有个盼头。

2. 架构的更改

1. Web Service支持增强
   随着CXF作者的加入，Web Service这事实上SOA里最重要的Transport得到了加强，WSDL终于可以通过annotation准确配置。
   虽然无奈，就冲这个理由就应该升级到2.0了。不是2.0太好，而是1.4太差了。 
2. REST支持增强
   Mule RESTPack，支持apache abdera(Atom Publish协议实现)，Jersey(JSR131 RESTful WebService实现)和Restlet 三种Transport。
3. 代码结构的合理化
   抽象出相对稳定的org.mule.api接口包，代替原来的org.mule.umo包。
   开发团队还检查调整了Mule中所有对象的定义，使其更加准确。
4. 各个模块的升级
   如核心MuleManager大对象拆成MuleContext and Registry，运行时Reistry支持动态加载Service，支持向OSGI进军；
   如以流的方式转换处理消息。
   如SEDA模型定义的细化，见后。
5. 工具增强
   Mule Galaxy SOA治理工具(开源)， Mule Saturn 消息流监控工具，Mule HQ 底层监控工具。
   不过还没试用不知道实际效果如何。

3. 遗憾的地方：

1. 性能下降
   无论是代替XFire的CXF还是Mule 2.0，都拖得性能大大下降。(但用JDK6的话情况又好一点)
2. 仍然没有自带的集群，负载均衡，流量控制实现。
   不像BEA、ServiceMix都使用JMS的底层，Mule使用vm queue在单一JVM的节点间流动。
   我们团队主要用TerraCotta在集群里同步状态数据，流量控制与负载均衡也是自己实现。
3. CXF transport 仍然使用Mule自己实现的Http Connector。
   CXF Standlone也是用Jetty的，看tomcat们努力的劲头，相信谁都能随便实现一个不错的Http Connector。
4. 从1.4升到2.0非常的花时间。
   估计团队重构的太兴奋了，从代码到配置文件再到XFire to CXF，一些代码级修改还没文档详述。
5. 文档从1.4版更新到2.0版的进度太慢，而且文档仍然简略。
6. 质量仍然在使用中检验。
   文档说2.0版本的比1.x版本增加了30%的单元测试用例，按理来说项目质量应该提高了。
   但还是被我发现了在很重要的AbstractEntryPointResolver类里，居然有内存泄漏。(http://mule.mulesource.org/jira/browse/MULE-3521)
   原因是用了StringBuffer作为HashMap的key，而SB并没有重载Object的equals()函数的，结果map永远都在增大。

这说明了，开源项目的质量，最终是靠一个积极使用和反馈的用户群和一个活跃的开发团队，"用"出来的。

五、诡异的消息流

     不同的inbound-outbound模式下，Mule中的消息流与交互模式非常诡异，不熟悉的人会很痛苦，详见交互编程模式

• 同步模式：如果component有outbound，最终向调用者的返回结果就是outbound的返回结果而不是component的。
                  当不再有outbound后，如果component的函数返回null，则返回NullPayload，如果函数为void，返回请求参数，其余正常返回。
• 异步请求应答模式：一个同步Inbound，一个Ountbound（通常有reply-to的配置），一个 async-reply。Component请求，发给outbound，在async等待outbound返回，再返回给调用者。

六、诡异的SEDA模型

   Mule 2.0的SEDA模型配置更加细腻，但却没有文档描述，以下都是从配置文件的Schema读出。

  SEDA的配置项仍然分Thread Pool、Component Pool、Queue三项，但其中Thread Pool又细分Receiver,Dispatcher ,Component 三项。

• <configuration>可设定全局的Thread Pool，又分default-threading-profile与default-receiver-threading-profile等四项。后面三项如果没有特别设定，则采用第一项的值。
• <connector>可设自己的dispatcher与receiver threading profile。
• <model>可设自己的queue profile。
• <service>可设自己的component-threading-profile与queue profile
• <pooled-component>可设自己的pooling-profile。

换个角度描述：

• Threading：<configuration>描述全局默认Threading，<connector>描述dispatcher与receiver，service描述compent-threading
• Compoent Pool:<pooled-component>
• Queue:<model>，<service>

最后结果，配了default-threading-profile为100后，系统开了100条的http.receiver，其他component和vm.receiver都只有1条线程。在典型场景的CXF -> component->同步VM Queue ->component的情况下，一个请求的两个component都在同一个http.receiver线程内执行。

相对于1.4的改进：

  Thread Pool的配置细腻了，而且不会去开N条实际用不到的vm.receiver

  Component 不再默认有个对象池，也可以是<component>指向自身或Spring的单例，<pool-component>时才做池化处理。

webservice
src-service
cn.hidetoishandsome.xfire.service
IUploadService.java
cn.hidetoishandsome.xfire.service.impl
UploadService.java
src-conf
META-INF
xfire
services.xml
web
WEB-INF
lib
web.xml

<beans xmlns="http://xfire.codehaus.org/config/1.0">
<service>
<name>UploadService</name>
<namespace>http://localhost:9090/webservice/services/UploadService</namespace>
<serviceClass>cn.hidetoishandsome.xfire.service.IUploadService</serviceClass>
<implementationClass>cn.hidetoishandsome.xfire.service.impl.UploadService</implementationClass>
</service>
</beans>

package cn.hidetoishandsome.xfire.service.impl;
import java.io.File;
import java.io.FileOutputStream;
import org.codehaus.xfire.util.Base64;
import cn.hidetoishandsome.xfire.service.IUploadService;
public class UploadService implements IUploadService {
public String upload(String encodedFileString) {
FileOutputStream fos = null;
File file = new File("D:\\test.jpg");
byte[] bytes = Base64.decode(encodedFileString);
try {
fos = new FileOutputStream(file);
fos.write(bytes);
fos.flush();
fos.close();
} catch (Exception e) {
return "Wrong!";
}
return "Success!";
}
}

esb
web
WEB-INF
lib
mule-services-config.xml
web.xml
index.jsp

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mule-configuration PUBLIC "-//MuleSource //DTD mule-configuration XML V1.0//EN"
"http://mule.mulesource.org/dtds/mule-configuration.dtd">
<mule-configuration id="Mule_Demo" version="1.0">
<mule-descriptor name="UploadService" inboundEndpoint="vm://uploadservice" implementation="org.mule.components.simple.BridgeComponent">
<outbound-router>
<router className="org.mule.routing.outbound.OutboundPassThroughRouter">
<endpoint address="wsdl-xfire:http://localhost:9090/webservice/services/UploadService?wsdl&method=upload"/>
</router>
</outbound-router>
</mule-descriptor>
</mule-configuration>

<%@ page import="org.mule.extras.client.MuleClient, org.mule.umo.UMOMessage, org.apache.commons.fileupload.disk.DiskFileItemFactory, org.apache.commons.fileupload.servlet.ServletFileUpload, org.apache.commons.fileupload.*, java.util.List, org.codehaus.xfire.util.Base64"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<html>
<head>
<title>Mule Upload Example</title>
</head>
<body>
<%
try {
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
List fileItems = upload.parseRequest(request);
FileItem item = (FileItem) fileItems.get(0);
MuleClient client = new MuleClient();
byte[] bytes = item.get();
String encodedFileString = Base64.encode(bytes);
UMOMessage message = client.send("vm://uploadservice", encodedFileString, null);
out.print(message.getPayload());
} catch(Exception e) {
}
%>
<form method="POST" name="uploadFile" action="" enctype="multipart/form-data">
<table>
<tr><td>
<input type="file" name="file"/></td><td><input type="submit" name="Go" value=" Go " />
</td></tr>
</table>
</form>
<p/>
</body>
</html>

Java代码

1. webservice   
2.   src-service   
3.     cn.hidetoishandsome.xfire.model   
4.       Book.java   
5.     cn.hidetoishandsome.xfire.service   
6.       IBookService.java   
7.     cn.hidetoishandsome.xfire.service.impl   
8.       BookService.java   
9.   src-conf   
10.     META-INF   
11.       xfire   
12.         services.xml   
13.   web   
14.     WEB-INF   
15.       lib   
16.       web.xml  

webservice
src-service
cn.hidetoishandsome.xfire.model
Book.java
cn.hidetoishandsome.xfire.service
IBookService.java
cn.hidetoishandsome.xfire.service.impl
BookService.java
src-conf
META-INF
xfire
services.xml
web
WEB-INF
lib
web.xml

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>     
2. <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4"     
3.          xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">     
4.      
5.     <servlet>     
6.         <servlet-name>xfire</servlet-name>     
7.         <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>     
8.     </servlet>     
9.      
10.     <servlet-mapping>     
11.         <servlet-name>xfire</servlet-name>     
12.         <url-pattern>/services/*</url-pattern>     
13.     </servlet-mapping>     
14.      
15. </web-app>  

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
</web-app>

Java代码

1. <beans xmlns="http://xfire.codehaus.org/config/1.0">     
2.     <service>     
3.         <name>BookService</name>     
4.         <namespace>http://localhost:9090/webservice/services/BookService</namespace>     
5.         <serviceClass>cn.hidetoishandsome.xfire.service.IBookService</serviceClass>     
6.         <implementationClass>cn.hidetoishandsome.xfire.service.impl.BookService</implementationClass>     
7.     </service>     
8. </beans>  

<beans xmlns="http://xfire.codehaus.org/config/1.0">
<service>
<name>BookService</name>
<namespace>http://localhost:9090/webservice/services/BookService</namespace>
<serviceClass>cn.hidetoishandsome.xfire.service.IBookService</serviceClass>
<implementationClass>cn.hidetoishandsome.xfire.service.impl.BookService</implementationClass>
</service>
</beans>

Java代码

1. esb   
2.   web   
3.     WEB-INF   
4.       lib   
5.         mule-services-config.xml   
6.         web.xml   
7.     index.jsp  

esb
web
WEB-INF
lib
mule-services-config.xml
web.xml
index.jsp

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>     
2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">     
3. <web-app>     
4.     <display-name>Mule</display-name>   
5.     <description>Mule Demo</description>   
6.      
7.     <context-param>   
8.         <param-name>org.mule.config</param-name>   
9.         <param-value>/WEB-INF/mule-services-config.xml,</param-value>   
10.     </context-param>   
11.      
12.     <listener>   
13.         <listener-class>org.mule.config.builders.MuleXmlBuilderContextListener</listener-class>   
14.     </listener>   
15.   
16.     <welcome-file-list>   
17.         <welcome-file>index.jsp</welcome-file>   
18.     </welcome-file-list>   
19. </web-app>  

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>Mule</display-name>
<description>Mule Demo</description>
<context-param>
<param-name>org.mule.config</param-name>
<param-value>/WEB-INF/mule-services-config.xml,</param-value>
</context-param>
<listener>
<listener-class>org.mule.config.builders.MuleXmlBuilderContextListener</listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>     
2.      
3. <!DOCTYPE mule-configuration PUBLIC "-//MuleSource //DTD mule-configuration XML V1.0//EN"      
4.                                 "http://mule.mulesource.org/dtds/mule-configuration.dtd">     
5.      
6. <mule-configuration id="Mule_Demo" version="1.0">   
7.   
8.     <mule-descriptor name="BookService" inboundEndpoint="vm://bookservice" implementation="org.mule.components.simple.BridgeComponent">   
9.   
10.         <outbound-router>   
11.             <router className="org.mule.routing.outbound.OutboundPassThroughRouter">   
12.                 <endpoint address="wsdl-xfire:http://localhost:9090/webservice/services/BookService?wsdl&method=findBookByISBN"/>   
13.             </router>   
14.         </outbound-router>   
15.   
16.     </mule-descriptor>   
17.   
18. </mule-configuration>  

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mule-configuration PUBLIC "-//MuleSource //DTD mule-configuration XML V1.0//EN"
"http://mule.mulesource.org/dtds/mule-configuration.dtd">
<mule-configuration id="Mule_Demo" version="1.0">
<mule-descriptor name="BookService" inboundEndpoint="vm://bookservice" implementation="org.mule.components.simple.BridgeComponent">
<outbound-router>
<router className="org.mule.routing.outbound.OutboundPassThroughRouter">
<endpoint address="wsdl-xfire:http://localhost:9090/webservice/services/BookService?wsdl&method=findBookByISBN"/>
</router>
</outbound-router>
</mule-descriptor>
</mule-configuration>

Java代码

1. <%@ page import="org.mule.extras.client.MuleClient, org.mule.umo.UMOMessage"%>     
2. <%@ page language="java" contentType="text/html; charset=UTF-8" %>     
3.      
4. <html>     
5. <head>     
6. <title>Mule Echo Example</title>     
7. </head>     
8. <body>     
9. <%      
10.     String s = request.getParameter("isbn");      
11.     if(s!=null) {      
12.         MuleClient client = new MuleClient();      
13.         UMOMessage message = client.send("vm://bookservice", s, null);        
14. %>     
15. <h3>The book with isbn "<%=s%>" is : <<<%=message.getPayload()%>>></h3>     
16.      <%}%>     
17. Please enter the isbn of book:      
18. <form method="POST" name="submitISBM" action="">     
19.     <table>     
20.         <tr><td>     
21.             <input type="text" name="isbn"/></td><td><input type="submit" name="Go" value=" Go " />     
22.         </td></tr>     
23.     </table>     
24. </form>     
25. <p/>     
26. </body>     
27. </html>    

<%@ page import="org.mule.extras.client.MuleClient, org.mule.umo.UMOMessage"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<html>
<head>
<title>Mule Echo Example</title>
</head>
<body>
<%
String s = request.getParameter("isbn");
if(s!=null) {
MuleClient client = new MuleClient();
UMOMessage message = client.send("vm://bookservice", s, null);
%>
<h3>The book with isbn "<%=s%>" is : <<<%=message.getPayload()%>>></h3>
<%}%>
Please enter the isbn of book:
<form method="POST" name="submitISBM" action="">
<table>
<tr><td>
<input type="text" name="isbn"/></td><td><input type="submit" name="Go" value=" Go " />
</td></tr>
</table>
</form>
<p/>
</body>
</html>

Java代码

1. webservice   
2.     src-service   
3.         cn.hidetoishandsome.xfire.model   
4.             Book.java   
5.         cn.hidetoishandsome.xfire.service   
6.             BookService.java   
7.         cn.hidetoishandsome.xfire.service.impl   
8.             BookServiceImpl.java   
9.     src-conf   
10.         META-INF   
11.             xfire   
12.                 services.xml   
13.     src-test   
14.         cn.hidetoishandsome.xfire.test   
15.             BookServiceTest.java   
16.     src-util   
17.         cn.hidetoishandsome.xfire.util   
18.             XfireClientFactory.java   
19.     web   
20.         WEB-INF   
21.             lib   
22.             web.xml   
23.         index.html  

webservice
src-service
cn.hidetoishandsome.xfire.model
Book.java
cn.hidetoishandsome.xfire.service
BookService.java
cn.hidetoishandsome.xfire.service.impl
BookServiceImpl.java
src-conf
META-INF
xfire
services.xml
src-test
cn.hidetoishandsome.xfire.test
BookServiceTest.java
src-util
cn.hidetoishandsome.xfire.util
XfireClientFactory.java
web
WEB-INF
lib
web.xml
index.html

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4"  
3.          xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">   
4.   
5.     <servlet>   
6.         <servlet-name>xfire</servlet-name>   
7.         <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>   
8.     </servlet>   
9.   
10.     <servlet-mapping>   
11.         <servlet-name>xfire</servlet-name>   
12.         <url-pattern>/services/*</url-pattern>   
13.     </servlet-mapping>   
14.   
15. </web-app>  

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
</web-app>

Java代码

1. package cn.hidetoishandsome.xfire.model;   
2.   
3. public class Book {   
4.   
5.     private String title;   
6.   
7.     private String isbn;   
8.   
9.     public String getIsbn() {   
10.         return isbn;   
11.     }   
12.   
13.     public void setIsbn(String isbn) {   
14.         this.isbn = isbn;   
15.     }   
16.   
17.     public String getTitle() {   
18.         return title;   
19.     }   
20.   
21.     public void setTitle(String title) {   
22.         this.title = title;   
23.     }   
24.   
25. }  

package cn.hidetoishandsome.xfire.model;
public class Book {
private String title;
private String isbn;
public String getIsbn() {
return isbn;
}
public void setIsbn(String isbn) {
this.isbn = isbn;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}

Java代码

1. package cn.hidetoishandsome.xfire.service;   
2.   
3. import cn.hidetoishandsome.xfire.model.Book;   
4.   
5. public interface BookService {   
6.     Book findBookByISBN(String isbn);   
7. }  

package cn.hidetoishandsome.xfire.service;
import cn.hidetoishandsome.xfire.model.Book;
public interface BookService {
Book findBookByISBN(String isbn);
}

Java代码

1. package cn.hidetoishandsome.xfire.service.impl;   
2.   
3. import cn.hidetoishandsome.xfire.model.Book;   
4. import cn.hidetoishandsome.xfire.service.BookService;   
5.   
6. public class BookServiceImpl implements BookService {   
7.   
8.     private Book book;   
9.   
10.     public BookServiceImpl() {   
11.         book = new Book();   
12.         book.setTitle("XFire Quick Start");   
13.         book.setIsbn("123456");   
14.     }   
15.   
16.     public Book findBookByISBN(String isbn) {   
17.         if (isbn.equals(book.getIsbn()))   
18.             return book;   
19.         throw new RuntimeException("Can't find book");   
20.     }   
21.   
22. }  

package cn.hidetoishandsome.xfire.service.impl;
import cn.hidetoishandsome.xfire.model.Book;
import cn.hidetoishandsome.xfire.service.BookService;
public class BookServiceImpl implements BookService {
private Book book;
public BookServiceImpl() {
book = new Book();
book.setTitle("XFire Quick Start");
book.setIsbn("123456");
}
public Book findBookByISBN(String isbn) {
if (isbn.equals(book.getIsbn()))
return book;
throw new RuntimeException("Can't find book");
}
}

Java代码

1. <beans xmlns="http://xfire.codehaus.org/config/1.0">   
2.     <service>   
3.         <name>BookService</name>   
4.         <namespace>http://localhost:8080/xfire/services/BookService</namespace>   
5.         <serviceClass>cn.hidetoishandsome.xfire.service.BookService</serviceClass>   
6.         <implementationClass>cn.hidetoishandsome.xfire.service.impl.BookServiceImpl</implementationClass>   
7.     </service>   
8. </beans>  

<beans xmlns="http://xfire.codehaus.org/config/1.0">
<service>
<name>BookService</name>
<namespace>http://localhost:8080/xfire/services/BookService</namespace>
<serviceClass>cn.hidetoishandsome.xfire.service.BookService</serviceClass>
<implementationClass>cn.hidetoishandsome.xfire.service.impl.BookServiceImpl</implementationClass>
</service>
</beans>

Java代码

1. Context path="/webservice" docBase="D:\project\webservice\web" reloadable="true"/>  

Context path="/webservice" docBase="D:\project\webservice\web" reloadable="true"/>

Java代码

1. package cn.hidetoishandsome.xfire.util;   
2.   
3. import java.net.MalformedURLException;   
4.   
5. import org.apache.commons.logging.Log;   
6. import org.apache.commons.logging.LogFactory;   
7. import org.codehaus.xfire.client.XFireProxyFactory;   
8. import org.codehaus.xfire.service.Service;   
9. import org.codehaus.xfire.service.binding.ObjectServiceFactory;   
10. import org.springframework.util.Assert;   
11.   
12. public class XfireClientFactory {   
13.     private static XFireProxyFactory serviceFactory = new XFireProxyFactory();   
14.   
15.     private static final Log log = LogFactory.getLog(XfireClientFactory.class);   
16.   
17.     private XfireClientFactory() {   
18.     }   
19.   
20.     public static <T> T getClient(String serviceURL, Class<T> serviceClass) {   
21.         Assert.notNull(serviceURL);   
22.         Assert.notNull(serviceClass);   
23.         Service serviceModel = new ObjectServiceFactory().create(serviceClass);   
24.         try {   
25.             return (T) serviceFactory.create(serviceModel, serviceURL);   
26.         } catch (MalformedURLException e) {   
27.             log.error(e.getMessage(), e);   
28.             return null;   
29.         }   
30.     }   
31.   
32. }  

package cn.hidetoishandsome.xfire.util;
import java.net.MalformedURLException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
import org.springframework.util.Assert;
public class XfireClientFactory {
private static XFireProxyFactory serviceFactory = new XFireProxyFactory();
private static final Log log = LogFactory.getLog(XfireClientFactory.class);
private XfireClientFactory() {
}
public static <T> T getClient(String serviceURL, Class<T> serviceClass) {
Assert.notNull(serviceURL);
Assert.notNull(serviceClass);
Service serviceModel = new ObjectServiceFactory().create(serviceClass);
try {
return (T) serviceFactory.create(serviceModel, serviceURL);
} catch (MalformedURLException e) {
log.error(e.getMessage(), e);
return null;
}
}
}

Java代码

1. package cn.hidetoishandsome.xfire.test;   
2.   
3. import cn.hidetoishandsome.xfire.service.BookService;   
4. import cn.hidetoishandsome.xfire.util.XfireClientFactory;   
5.   
6. public class BookServieTest {   
7.   
8.     public static void main(String[] args) {   
9.         String serviceURL = "http://localhost:8080/webservice/services/BookService";   
10.         try {   
11.             BookService service = XfireClientFactory.getClient(serviceURL, BookService.class);   
12.             System.out.println("Book with ISBN '123456': 《" + service.findBookByISBN("123456").getTitle() + "》");   
13.         } catch (Exception e) {   
14.             e.printStackTrace();   
15.         }   
16.   
17.     }   
18. }  

package cn.hidetoishandsome.xfire.test;
import cn.hidetoishandsome.xfire.service.BookService;
import cn.hidetoishandsome.xfire.util.XfireClientFactory;
public class BookServieTest {
public static void main(String[] args) {
String serviceURL = "http://localhost:8080/webservice/services/BookService";
try {
BookService service = XfireClientFactory.getClient(serviceURL, BookService.class);
System.out.println("Book with ISBN '123456': 《" + service.findBookByISBN("123456").getTitle() + "》");
} catch (Exception e) {
e.printStackTrace();
}
}
}

Java代码

1. Book with ISBN '123456': 《XFire Quick Start》

Java代码

1. mule   
2.   src-demo   
3.     cn.hidetoishandsome.mule.demo   
4.       EchoService.java   
5.       IEchoService.java   
6.   images   
7.     mule-banner.gif   
8.   WEB-INF   
9.     lib   
10.     mule-echo-config.xml   
11.     web.xml   
12.   contents.html   
13.   echo.jsp   
14.   header.html   
15.   index.html   
16.   welcome.html  

mule
src-demo
cn.hidetoishandsome.mule.demo
EchoService.java
IEchoService.java
images
mule-banner.gif
WEB-INF
lib
mule-echo-config.xml
web.xml
contents.html
echo.jsp
header.html
index.html
welcome.html

Java代码

1. package cn.hidetoishandsome.mule.demo;   
2.   
3. public interface IEchoService {   
4.     String echo(String s);   
5.   
6.     String haha(String s);   
7. }  

package cn.hidetoishandsome.mule.demo;
public interface IEchoService {
String echo(String s);
String haha(String s);
}

Java代码

1. package cn.hidetoishandsome.mule.demo;   
2.   
3. public class EchoService implements IEchoService {   
4.   
5.     public String echo(String s) {   
6.         return "Hello, " + s + "!";   
7.     }   
8.   
9.     public String haha(String s) {   
10.         return "haha";   
11.     }   
12.   
13.     public String hehe(String s) {   
14.         return "hehe";   
15.     }   
16. }  

package cn.hidetoishandsome.mule.demo;
public class EchoService implements IEchoService {
public String echo(String s) {
return "Hello, " + s + "!";
}
public String haha(String s) {
return "haha";
}
public String hehe(String s) {
return "hehe";
}
}

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">   
3. <web-app>   
4.     <display-name>Mule</display-name>   
5.     <description>Mule Demo</description>   
6.   
7.     <context-param>   
8.         <param-name>org.mule.config</param-name>   
9.         <param-value>/WEB-INF/mule-echo-config.xml,</param-value>   
10.     </context-param>   
11.   
12.     <listener>   
13.         <listener-class>org.mule.config.builders.MuleXmlBuilderContextListener</listener-class>   
14.     </listener>   
15.   
16.     <servlet>   
17.         <servlet-name>muleServlet</servlet-name>   
18.         <servlet-class>org.mule.providers.http.servlet.MuleReceiverServlet</servlet-class>   
19.         <load-on-startup/>   
20.     </servlet>   
21.   
22.     <servlet-mapping>   
23.         <servlet-name>muleServlet</servlet-name>   
24.         <url-pattern>/services/*</url-pattern>   
25.     </servlet-mapping>   
26.   
27.     <welcome-file-list>   
28.         <welcome-file>index.html</welcome-file>   
29.     </welcome-file-list>   
30. </web-app>  

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>Mule</display-name>
<description>Mule Demo</description>
<context-param>
<param-name>org.mule.config</param-name>
<param-value>/WEB-INF/mule-echo-config.xml,</param-value>
</context-param>
<listener>
<listener-class>org.mule.config.builders.MuleXmlBuilderContextListener</listener-class>
</listener>
<servlet>
<servlet-name>muleServlet</servlet-name>
<servlet-class>org.mule.providers.http.servlet.MuleReceiverServlet</servlet-class>
<load-on-startup/>
</servlet>
<servlet-mapping>
<servlet-name>muleServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>   
2.   
3. <!DOCTYPE mule-configuration PUBLIC "-//MuleSource //DTD mule-configuration XML V1.0//EN"  
4.                                 "http://mule.mulesource.org/dtds/mule-configuration.dtd">   
5.   
6. <mule-configuration id="Mule_Demo" version="1.0">   
7.     <mule-descriptor name="echoService" implementation="cn.hidetoishandsome.mule.demo.EchoService">   
8.         <inbound-router>   
9.             <endpoint address="xfire:http://localhost:8181/services"/>   
10.         </inbound-router>   
11.         <properties>     
12.             <list name="serviceInterfaces">      
13.                 <entry value="cn.hidetoishandsome.mule.demo.IEchoService"/>      
14.             </list>     
15.         </properties>     
16.    </mule-descriptor>   
17. </mule-configuration>  

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mule-configuration PUBLIC "-//MuleSource //DTD mule-configuration XML V1.0//EN"
"http://mule.mulesource.org/dtds/mule-configuration.dtd">
<mule-configuration id="Mule_Demo" version="1.0">
<mule-descriptor name="echoService" implementation="cn.hidetoishandsome.mule.demo.EchoService">
<inbound-router>
<endpoint address="xfire:http://localhost:8181/services"/>
</inbound-router>
<properties>
<list name="serviceInterfaces">
<entry value="cn.hidetoishandsome.mule.demo.IEchoService"/>
</list>
</properties>
</mule-descriptor>
</mule-configuration>

Java代码

1. <%@ page import="org.mule.extras.client.MuleClient, org.mule.umo.UMOMessage"%>   
2. <%@ page language="java" contentType="text/html; charset=UTF-8" %>   
3.   
4. <html>   
5. <head>   
6. <title>Mule Echo Example</title>   
7. </head>   
8. <body>   
9. <%   
10.     String s = request.getParameter("name");   
11.     if(s!=null) {   
12.         MuleClient client = new MuleClient();   
13.         UMOMessage message = client.send("xfire:http://localhost:8181/services/echoService?method=echo", s, null);     
14. %>   
15. <h3><%=message.getPayload()%></h3>   
16.      <%}%>   
17. Please enter your name:   
18. <form method="POST" name="submitEcho" action="">   
19.     <table>   
20.         <tr><td>   
21.             <input type="text" name="name"/></td><td><input type="submit" name="Go" value=" Go " />   
22.         </td></tr>   
23.     </table>   
24. </form>   
25. <p/>   
26. </body>   
27. </html>  

<%@ page import="org.mule.extras.client.MuleClient, org.mule.umo.UMOMessage"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<html>
<head>
<title>Mule Echo Example</title>
</head>
<body>
<%
String s = request.getParameter("name");
if(s!=null) {
MuleClient client = new MuleClient();
UMOMessage message = client.send("xfire:http://localhost:8181/services/echoService?method=echo", s, null);
%>
<h3><%=message.getPayload()%></h3>
<%}%>
Please enter your name:
<form method="POST" name="submitEcho" action="">
<table>
<tr><td>
<input type="text" name="name"/></td><td><input type="submit" name="Go" value=" Go " />
</td></tr>
</table>
</form>
<p/>
</body>
</html>

Java代码

1. UMOMessage message = client.send("xfire:http://localhost:8181/services/echoService?method=haha", s, null);  

UMOMessage message = client.send("xfire:http://localhost:8181/services/echoService?method=haha", s, null);

    （图一）Intra-SOA和Inter-SOA架构

Webservice的价值观
    WebService很好的解决了基于不同平台，基于不同语言开发的应用系统间的集成问题，成为解决Inter-SOA，最通用最好的技术手段。但是，如果良药乱用，只要谈到SOA，就要用WebService，那么“良药”服用过量，也会中毒。在构建企业的应用、或新建系统的建设时，都考虑将业务封装成webservice的方式以适应业务的变化，这并非合理的选择。
 在儒家文化的一种理念价值观就是“中庸之道，过犹不及”。对待Webservice的态度，我们面临的是同样的选择。
    而有没有一种技术既能适应用外环境的变化，也能适应用内部系统的变化呢？那就需要intra-SOA和inter-SOA内外配合，前者从业务的角度来解决因业务的需求变化，后者从系统层面解决跨系统间业务与数据的整合。intra-SOA和inter-SOA “内外兼修”才能称之为完整的SOA解决方案。
TmaxSoft的SOA之道
    目前TmaxSoft提供了基于intra-SOA的ProFrame用来构建企来内部的SOA，同时也提供了基于inter-SOA的ESB产品ProBus来解决接口层异构系统EAI、workflow和多渠道接入的功能，从而提供由内到外的一整套SOA企业级完整解决方案。
TmaxSoft把整个SOA框架分为四个层次：用户界面层(UI)、接口层(Interface)、业务层(Business)和数据层(Data)，其中在接口层提供基于Inter-SOA的解决方案、在业务层提供基于Intra-SOA的解决方案。

（图二）Tmaxsoft企业级完整SOA解决方案

    ProFrame是定义生成实现并重用SOA服务的Business Framework的核心解决方案。ProFrame最大化了基于SOA的下一代系统所要求的灵活性，重复性及安全性。 ProFrame的“Enterprise ModuleBus构架”是运用Gartner提出的“Microflows”概念，实现“Intra-SOA”的TmaxSoft的核心技术。通过ESB消除了系统与服务间的相互依赖性，提高了服务的可重用性。类似，通过EMB消除了组件或模块间的相互依赖性，从而提高了各模块的重用性。通过组合服务接口、单位模块，以及通过ESB构建的模块流程，构建了真正的服务组件。EMB的优点不仅在于可重用性，而且实现了服务的业务逻辑的可视性。因此用户不懂编程，也可以参与到设计与开发工作当中。其中ProFrame的核心就是EMB (Enterprise Module Bus)，它不同于ESB(Enterprise Service Bus)，但却有着异曲同工之妙，它通过把企业的业务逻辑按照Business Module和Service Module的方式，在ProFrame平台上进行开发与定义，通过EMB来统一管理Service Module，通过组合已有的模块产生各种新的服务，构建一个内部的SOA环境。构建的这些Business Module和Service Module可以复用和重新组合成新的服务，从而在企业内部形成一个intra-SOA的松耦合、可重用、高性能的SOA环境。

（图三）基于松耦合架的企业模块总线(Enterprise Module Bus)
用EMB创建的服务由松耦合模块组成，保证了每个模块的独立性和系统结构的灵活性。松耦合组件提高了组件的重用性和系统的可维护性。
 ProBus是TmaxSoft的Inter-SOA中ESB解决方案，是TmaxSoft 对服务、应用、资源以及分散的服务组件进行连接或整合，提供可靠通信的ESB解决方案。它解决系统之间的互联、消息传递、转换、路由、web服务支持、Flow的控制等。ProBus 以高性能的引擎结构保障稳定的服务，可以与BPM、MCI进行连动，灵活支持多种适配器，是真正实现SOA 2.0的ESB解决方案。

     我们声称要构建SOA，于是新建的系统要遵循一系列的标准，要支持Webservice，很多原来可以直接以内部模块的方式非常高效的构建系统，现在为了SOA，为了支持异构系统的调用，把它封装成了Webservice，居不知，这正是噩梦的开始。Webservice基于SOAP协议来进行通信，它传输数据的格式为XML，而每次调用Webservice时都需要传输XML格式的数据，对XML进行解析，这些都是出现性能瓶颈的罪魁祸首。
总结
    当我们需要构建复杂而高效的SOA环境时，Webservice的通讯方式和笨拙的数据交换格式而引起的性能问题，注定无法让它在企业占据核心的地位，而TmaxSoft ProFrame提供了一套高效的基于SOA的Framework，基于Proframe来构建企业的核心应用，而WebService作为企业SOA解决方案中inter-SOA的首选技术。
     不论是基于inter-SOA还是intra-SOA，实施SOA的目的是一样的，那就是实现以业务为核心，提高IT系统扩展的灵活性以及IT资产的复用，达到业务灵活组合的状态。而WebService则是作为inter-SOA中首选的技术，而非解决SOA的唯一途径

     是人都知道去官方网站去下载就行了。

2.配置过程

2.1 web.xml文件

配置为以下内容即可：

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app>

 <display-name>WebServicesClient</display-name>  <description>Hebbn WebServices Client</description>

 <context-param>   <param-name>webAppRootKey</param-name>   <param-value>HebbnClient.root</param-value>  </context-param>  <context-param>   <param-name>log4jConfigLocation</param-name>   <param-value>/WEB-INF/log4j.properties</param-value>  </context-param>  <context-param>   <param-name>log4jRefreshInterval</param-name>   <param-value>60000</param-value>  </context-param>  <context-param>   <param-name>contextConfigLocation</param-name>   <param-value>    /WEB-INF/applicationContext.xml   </param-value>  </context-param>

 <listener>   <listener-class>    org.springframework.web.context.ContextLoaderListener   </listener-class>  </listener>  <listener>   <listener-class>    org.springframework.web.util.IntrospectorCleanupListener   </listener-class>  </listener>  <listener>   <listener-class>    org.springframework.web.context.request.RequestContextListener   </listener-class>  </listener>  <listener>   <listener-class>    org.springframework.web.util.Log4jConfigListener   </listener-class>  </listener>

 <servlet>   <servlet-name>CXFServlet</servlet-name>   <display-name>CXF Servlet</display-name>   <servlet-class>    org.apache.cxf.transport.servlet.CXFServlet   </servlet-class>   <load-on-startup>1</load-on-startup>  </servlet>

 <servlet-mapping>   <servlet-name>CXFServlet</servlet-name>   <url-pattern>/services/*</url-pattern>  </servlet-mapping>  <session-config>   <session-timeout>30</session-timeout>  </session-config>

 <!-- MIME mapping -->  <mime-mapping>   <extension>inc</extension>   <mime-type>text/plain</mime-type>  </mime-mapping>

 <mime-mapping>   <extension>doc</extension>   <mime-type>application/vnd.ms-word</mime-type>  </mime-mapping>  <mime-mapping>   <extension>gif</extension>   <mime-type>image/gif</mime-type>  </mime-mapping>  <mime-mapping>   <extension>htm</extension>   <mime-type>text/html</mime-type>  </mime-mapping>  <mime-mapping>   <extension>html</extension>   <mime-type>text/html</mime-type>  </mime-mapping>  <mime-mapping>   <extension>jad</extension>   <mime-type>text/vnd.sun.j2me.app-descriptor</mime-type>  </mime-mapping>  <mime-mapping>   <extension>jnlp</extension>   <mime-type>application/x-java-jnlp-file</mime-type>  </mime-mapping>  <mime-mapping>   <extension>jpeg</extension>   <mime-type>image/jpeg</mime-type>  </mime-mapping>  <mime-mapping>   <extension>jpg</extension>   <mime-type>image/jpeg</mime-type>  </mime-mapping>  <mime-mapping>   <extension>js</extension>   <mime-type>application/x-javascript</mime-type>  </mime-mapping>  <mime-mapping>   <extension>pdf</extension>   <mime-type>application/pdf</mime-type>  </mime-mapping>  <mime-mapping>   <extension>png</extension>   <mime-type>image/png</mime-type>  </mime-mapping>  <mime-mapping>   <extension>rar</extension>   <mime-type>application/x-rar-compressed</mime-type>  </mime-mapping>  <mime-mapping>   <extension>txt</extension>   <mime-type>text/plain</mime-type>  </mime-mapping>  <mime-mapping>   <extension>xls</extension>   <mime-type>application/vnd.ms-excel</mime-type>  </mime-mapping>  <mime-mapping>   <extension>xml</extension>   <mime-type>text/xml</mime-type>  </mime-mapping>  <mime-mapping>   <extension>xul</extension>   <mime-type>application/vnd.mozilla.xul-xml</mime-type>  </mime-mapping>  <mime-mapping>   <extension>zhtml</extension>   <mime-type>text/html</mime-type>  </mime-mapping>  <mime-mapping>   <extension>zip</extension>   <mime-type>application/x-zip</mime-type>  </mime-mapping>  <mime-mapping>   <extension>zul</extension>   <mime-type>text/html</mime-type>  </mime-mapping>  <mime-mapping>   <extension>wsdl</extension>   <mime-type>text/xml</mime-type>  </mime-mapping>

 <mime-mapping>   <extension>xsd</extension>   <mime-type>text/xml</mime-type>  </mime-mapping>  <welcome-file-list>   <welcome-file>index.jsp</welcome-file>  </welcome-file-list> </web-app>

主要的就是apace cxf那个servlet的配置参数以及spring的一些配置参数要搞对就行了。

2.2 spring的配置文件

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:jaxws="http://cxf.apache.org/jaxws"  xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">  <import resource="classpath:META-INF/cxf/cxf.xml" />  <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">   <property name="locations">    <list>     <value>WEB-INF/jdbc.properties</value>    </list>   </property>  </bean>

 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">   <property name="driverClassName" value="${jdbc.driverClassName}"/>   <property name="url" value="${jdbc.url}"/>   <property name="username" value="${jdbc.username}"/>   <property name="password" value="${jdbc.password}"/>   <property name="maxActive" value="${jdbc.maxActive}"/>   <property name="initialSize" value="${jdbc.initialSize}"/>   <property name="maxWait" value="${jdbc.maxWait}"/>   <property name="minIdle" value="${jdbc.minIdle}"/>   <property name="testOnBorrow" value="true"/>   <property name="testOnReturn" value="true"/>   <property name="testWhileIdle" value="true"/>   <property name="validationQuery" value="select 1 from dual"/>  </bean>

 <!-- Transaction manager for a single JDBC DataSource -->  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">   <property name="dataSource" ref="dataSource"/>  </bean>

 <jaxws:endpoint id="testServices" implementor="com.tsxd.hebbn.services.TestServices" address="/testServices" />   </beans>

如果要操作数据库的话就带着配置参数中数据库相关的部分，但是在apace cxf的下载包中不包含数据库相关的spring库文件，需要自己下载。单纯的想测试Apache CXF的话就留着最后一行就得了。

2.3 Java测试代码

2.3.1 接口类源代码

注意那个@WebService

package com.tsxd.hebbn.services;

import javax.jws.WebService; @WebService public interface ITestServices {

   public java.util.Date getServerDate();    public String sayHello(String name); }

2.3.2 实现类代码

package com.tsxd.hebbn.services;

import java.util.Date;

import javax.jws.WebService;

@WebService(endpointInterface="com.tsxd.hebbn.services.ITestServices") public class TestServices implements ITestServices {

 public Date getServerDate() {   return new Date();  }

 public String sayHello(String name) {   if (null==name){    return "fuck u";   }   return "hello :"+name;  }

}

也是注意那个@WebService声明。

2.4 测试

部署到tomcat中去，因为在web.xml文件中配置了cxf servlet 类mapping到/services路径，所以访问时

http://IP地址:端口号/应用程序上下文/services/就行了

应该会有已经配置好的services的列表,像下边这样：

{http://services.hebbn.tsxd.com/}TestServicesPort

点击联接可以查看WSDL描述

2.5 最后

    这个破Apache CXF和spring绑的也太紧密了，用spring的话就会造成生成的wsdl描述中参数名称都变成args0这样无意义的名称，不好，不喜欢，结论，还是直接用xfire就行了，没必要用这个巨大的CXF.





二、入门

1. 为CXF设置编译和开发环境

打开eclipse（其他的IDE也可以），引入如下的类库（也可以省事一点，把CXF\lib路径下的所有类库都引入）

commons-logging-1.1.jar

geronimo-activation_1.1_spec-1.0-M1.jar (or Sun's Activation jar)

geronimo-annotation_1.0_spec-1.1.jar (JSR 250)

geronimo-javamail_1.4_spec-1.0-M1.jar (or Sun's JavaMail jar)

geronimo-servlet_2.5_spec-1.1-M1.jar (or Sun's Servlet jar)

geronimo-ws-metadata_2.0_spec-1.1.1.jar (JSR 181)

jaxb-api-2.0.jar

jaxb-impl-2.0.5.jar

jaxws-api-2.0.jar

neethi-2.0.jar

saaj-api-1.3.jar

saaj-impl-1.3.jar

stax-api-1.0.1.jar

wsdl4j-1.6.1.jar

wstx-asl-3.2.1.jar

XmlSchema-1.2.jar

xml-resolver-1.2.jar

引入Spring相关的jars (只对):

aopalliance-1.0.jar

spring-core-2.0.4.jar

spring-beans-2.0.4.jar

spring-context-2.0.4.jar

spring-web-2.0.4.jar

引入CXF相关的jar:

cxf-2.0-incubator.jar

2. 编写自己的服务

在eclipse里创建一个J2EE的动态Web项目

这里所有的例子代码都在 “D:\cxf\samples\java_first_spring_support”路径下。“d:\cxf”是CXF的安装路径。但是在这个路径下不包含

Web Service的例子源代码（怀疑是开发人员忘记了），需要手工在项目中生成。

首先写一个服务接口，例子中的HelloWorld.java。我们要注意的是这个例子使用了JSR181规范中的声明“@WebService”。

package demo.spring;
 
import javax.jws.WebService;
 
@WebService
public interface HelloWorld {
    String sayHi(String text);
}
下一步实现这个服务接口，例子中的HelloWorldImpl.java。这个例子代码中的“@WebService”标签只包含一个endpointInterface的属性，这

个属性让CXF知道根据哪个接口生成WSDL文件。这里有点和我们第一个例子不同，没有包含ServiceName属性。这是因为这个属性会在Spring的

配置文件中声明，请参考下面的beans.xml这个配置文件。

package demo.spring;
 
import javax.jws.WebService;
 
@WebService(endpointInterface = "demo.hw.server.HelloWorld")
public class HelloWorldImpl implements HelloWorld {
 
    public String sayHi(String text) {
        return "Hello " + text;
    }
}
 

3. 在Spring中声明你的服务Beans

CXF中包含对Spring2.0很好的支持。对于JAX-WS这一类配置，我们有<jaxws:endpoint>bean作为服务端节点的配置说明。

让我们创建一个”beans.xml”文件在我们项目的WEB-INF路径下，注意这个文件的例子可以在“D:\cxf\samples\java_first_spring_support\

”中找到。

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:jaxws="http://cxf.apache.org/jaxws"
      xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
 
      <import resource="classpath:META-INF/cxf/cxf.xml" />
      <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
      <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
 
      <jaxws:endpoint
        id="helloWorld"
        implementor="demo.spring.HelloWorldImpl"
        address="/HelloWorld" />
       
</beans>
这里我们可以看到<jaxws:endpoint>的三个属性id, implementor和address。

“id”指定这个Bean在Spring上下文中唯一的标识。

“implementor”指定了这个Web Service的实现类。

“address”指定了服务在Web服务器上发布的地址。这个地址可以包含ip和端口的完整地址，也可以是只包含相对路径的地址。

1.       配置你的Servlet

配置的过程中我们需要在web.xml中添加如下两项：

第一个是Spring的ContextLoaderListerp类会在启动时加载上面配置beans.xml文件。我们需要设定context-param节点；第二个是增加一个CXF

Servlet。配置文件如下，注意这个文件可以在“D:\cxf\samples\java_first_spring_support\”中找到。

<web-app>
   <context-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>WEB-INF/beans.xml</param-value>
   </context-param>
   <listener>
          <listener-class>
          org.springframework.web.context.ContextLoaderListener
          </listener-class>
   </listener>
   <servlet>
          <servlet-name>CXFServlet</servlet-name>
          <display-name>CXF Servlet</display-name>
          <servlet-class>
          org.apache.cxf.transport.servlet.CXFServlet
          </servlet-class>
          <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
          <servlet-name>CXFServlet</servlet-name>
          <url-pattern>/*</url-pattern>
   </servlet-mapping>
</web-app>
这里需要注意的是你配置的endpoint的地址（address）属性必须和你在Beans.xml中定义的一致。尽管在我们的例子中没有在

HelloWorldImpl.java中声明“address“属性，我们也需要在实际的配置中有所注意。

2.       CXF引入了一个JaxWsProxyFactory bean，他可以根据服务接口创建一个客户端程序。你只需要告诉服务类是什么（这个例子中是

HelloWorld interface这个类）和服务的URL就可以了。你可以通过JaxWsProxyFactory的create方法来生成一个客户端的bean。

下面是配置bean的例子

<beans xmlns="http://www.springframework.org/schema/beans"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xmlns:jaxws="http://cxf.apache.org/jaxws"

     xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://cxf.apache.org/jaxws http://cxf.apache.org/schema/jaxws.xsd">

    <bean id="client" class="demo.spring.HelloWorld"

      factory-bean="clientFactory" factory-method="create"/>

     <bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">

       <property name="serviceClass" value="demo.spring.HelloWorld"/>

       <property name="address" value="http://localhost:9002/HelloWorld"/>

     </bean>

</beans>

如果你在客户端代码要使用这个bean，代码会非常简单，例子如下

ApplicationContext context = ...; // your Spring ApplicationContext

HellWorld client = (HelloWorld) context.getBean("client");

客户端的例子代码Client.java和配置文件例子client-beans.xml都可以在

“D:\cxf\samples\java_first_spring_support\src\demo\spring\client“中找到。

例子的运行，我们可以通过两种方式来运行我们完成的例子。

一．              利用ant来直接运行CXF安装路径下的samples。方法可以参考D:\cxf\samples\ReadMe.txt文件。

a)         首先在“D:\cxf\samples”创建了一个”setenv.cmd”文件，文件内容如下：

set CXF_HOME=d:\cxf

set JAVA_HOME=C:\Program Files\Java\jdk1.5.0_13

set ANT_HOME=d:\apache\ant

set PATH=%JAVA_HOME%\bin;%ANT_HOME%\bin;%CXF_HOME%\bin;%PATH%

set CLASSPATH=.;%CXF_HOME%\lib\cxf-manifest-incubator.jar;.\build\classes

这个执行文件配置了运行CXF例子所需的环境变量。

b)      开始->运行，敲入“cmd”，进入dos命令输入界面，进入CXF的spring例子的路径“D:\cxf\samples” 运行我们在上一步创建的

“setenv.cmd”,

c)      进入“D:\cxf\samples\java_first_spring_support”,编译服务的代码。运行“ant”

d)      启动服务器“ant server”

e)      开始->运行，敲入“cmd”，进入dos命令输入界面，进入CXF的spring例子的路径“D:\cxf\samples” 运行我们在上一步创建的

“setenv.cmd”,

f)      启动客户端“ant client”

把我们上面eclipse中开发的Web项目打包为 war包的形式。部署到tomcat或者jetty服务器上。注意部署时访问的路径。比如我部署在Tomcat上

，访问的路径就是：http://localhost:8080/CXFSpring/HelloWorld

好在我把CXF项目的网站的链接给同学发了过程，与此同时我也注意到了 Apache CXF： An Open Source Service FrameWork 这个标题。 我想这很概括的回答了前面那个问题CXF是做什么的。

这个 Service Framework所做的工作就在将各种应用发布为Web Services。
在发布你的应用之前你需要告诉CXF两个信息， 一个是 WSDL Contracts，一个是你服务应用的具体实现。

熟悉WSDL的朋友应该知道，WSDL提供了Web Servcies的服务描述，定义服务所提供的操作信息，以及操作支持消息数据信心。我们可以把这些信息称为是WSDL contracts。在CXF内部是通过

Service Model来描述这些WSDL Contracts的，这样做的目的有两个一个是屏蔽了WSDL1.1 与WSDL2.0之间的区别，另一个是为CXF内部运行环境提供了一个统一的服务信息描述接口。

这样以来我们可以很轻松的实行 WSDL <--> ServiceModel <--> Java Class Service Endpoint Interface(SEI)的转换。
同时CXF可以同时支持WSDL First以及 Code First两种编程模型。

服务的实现可以是POJO ，也可以是使用JSR181标记过（Annoatated）的Java类实现，同时也可以是一个js文件。在CXF中通过不同的Front-End来支持这些不同的服务实现。 JAX-WS Front-End支持采用JAX-WS API创建服务。Simple Front-End 支持POJO服务实现。 JS Front-End则提供了java script服务实现的支持。


Apache CXF 2.0的发布

Apache最近宣布了Apache CXF 2.0的发布。Apache CXF提供了一套创建SOA服务的基础设施框架，用户由此可以按照自己喜欢的编程模式，利用

Apache CXF提供的简单易用工具（包括Maven插件），创建适合SOA环境的任何WEB服务，包括SOAP/HTTP服务及REST/HTTP服务。Apache CXF可扩

展的插拔式架构不但支持XML消息格式和HTTP通信协议，而且还支持基于其他通信协议如IIOP和非XML消息格式如CORBA CDL或JSON。

Apache CXF项目是由Objectweb Celtix和Codehaus XFire在一年前合并成立的。Objectweb Celtix是由IONA公司赞助、于2005年成立的开源

Java ESB产品，XFire则是业界知名的SOAP堆栈。合并后的Apache CXF融合该两个开源项目的功能精华，提供了实现SOA所需要的核心ESB功能框

架，包括SOA服务创建，服务路由，及一系列企业级QoS功能。此次发布代表了Apache CXF开发人员及社区用户一年的努力结果，并标志 Apache

CXF软件的进一步成熟，成为实现SOA的优秀技术解决方案之一。

这次发布的新版本的特性包括：

JAX-WS Compliant frontend - Apache CXF has now passed the standalone JAX-WS TCK.
Java2WSDL and WSDL2Java tools and Maven plugin
SOAP 1.1 & 1.2, XML and RESTful HTTP bindings
JAXB 2.0 Databinding support
WSDL 1.1 support
WS-Addressing, WS-ReliableMessaging, WS-Security, and WS-Policy support
MTOM attachment and SOAP w/ Attachments support
HTTP, Servlet, JMS and Local Transports
Simple POJO service frontend
Javascript frontend
JBI Service Engine. CXF services can be deployed into any JBI compliant container (ServiceMix or OpenESB)
JCA 1.0 support, J2EE application can integrate with legacy application through JCA 1.0 support in CXF
Spring Support
JSON support with Jettison
Many other bug fixes and feature enhancements

和部署问题，IBM当前不仅以服务商的角色介入SOA，而且在此次大会上还带来了众多的SOA的成功实施案例；BEA公司也定位于SOA平台提供商，

并且推出了一系列产品和方案；国内软件企业，像中创、东方通科技以及金蝶、用友、科诺等公司也在不同程度地切入SOA工具或解决方案的开

发。种种迹象表明，SOA已经超越概念走向应用，并逐渐形成一股不可阻挡的潮流。

二、Web Services开源热火朝天
1.Web Services开源项目
    作为SOA一种主要实行方式的Web Services，其开源项目正如火如荼。

    Java6 发布，支持XML&WebService, JDK就直接支持Web Services了。这样Sun强势参与Web Services的竞争。这种现象很有趣，各大厂商

在各自强项之间互相渗透，Sun被Apache Harmony项目所逼，被一些厂商要求两年后，将JDK开源，但同时也给IBM、BEA、Oracle等厂商反戈一

击，在刚发布的JDK 6中捆绑Web Services。

    Axis2和XFire是最火的两个Web Services开源项目，但其他的项目也做得不错。

XFire
Celtix
Mule
Apache Axis2
Apache CXF
    XFire和Celtix合并，在Apache下形成的一个新的孵化项目。
Apache Ode
    是一个WS-BPEL实现
Apache Rampart
    是一个WS-Security实现
Apache Sandesha2
    是一个WS-ReliableMessaging实现
Apache Tuscany
    是一个SCA实现。
Apache ServiceMix
    是一个JBI实现。

Eclipse的STP（SOA Tooling Project）子项目
此Eclipse项目旨在提供一个其他开发人员可以使用的SOA开发工具框架，以便使他们不必自己开发这些工具。

2.Web Services开源项目特点：
    1)各项目侧重点有些不一样，还互相引用，交流甚多，人员合作也较多。不像Sun JDK开源和Apache Harmony，Apahce Geronomy和JBOSS等

几乎重叠，正面冲突。

    2)这些项目都支持Spring的Bean配置或扩展Spring的接口，和Spring集成。可见Spring火爆程度。不同开源社区不断融合，互相吸引人气

。
    3)使用工具的变化
    版本管理工具由cvs变为subversion
    build工具由ant变为maven
    4)众多开源社区中Apache的人气最旺
    有意思的是，很多开源项目在别的小社区发展到2.0, 3.0版本后还不遗余力地迁移到Apache, 如ServiceMix从Codehaus搬到Apache，

Codehaus的XFire和objectweb的Celtix合并后，乔迁到Apache。它们甚至甘愿接受Apache社区的规定：需要一段时间的修炼才能从孵化器中毕

业。

3.微软Indigo
    说了这么多JAVA阵营的Web Services项目，还得提一下巨人微软的策略。
    Indigo是微软用于构建面向服务应用程序的代号，后被正式命名为Windows Communication Foundation。Indigo允许目前创建面向对象应

用程序的开发人员采用 .NET Framework以相似的方式来创建面向服务的应用程序。同时为了让这些应用程序能够与运行在 Windows 和其他平

台上的软件有效地进行交互，Indigo 还实现了SOAP和其他Web服务技术，这样开发人员就可以创建可靠、安全且能够与运行在任何系统上的软

件实现互操作的事务型服务。

为了实现基本通信以外的功能，Indigo 采用了一些更新的WS-* 规范。这些文档定义了用于添加可靠消息传输、安全性、事务以及更多基于

SOAP 的 Web 服务的多供应商方式。所有这些规范最初均是由 Microsoft、IBM 及其他供应商共同制定的。随着它们日渐稳定，所有权通常会

转移到一些标准机构，如结构化信息标准促进组织 (OASIS)。Indigo 第一版中支持的 Web 服务规范包括 WS-Addressing、WS-Policy、WS-

MetadataExchange、WS-ReliableMessaging、WS-Security、WS-Trust、WS-SecureConversation、WS-Coordination、WS- AtomicTransaction

和 SOAP 消息传输优化机制 (MTOM)。

    Indigo已经包含在Vista之中。

    目前Web Services的实现分为两大阵营，一是微软，一是Java厂商。这两大阵营实现Web Services规范的产品都在互相进行互操作性测试

。

三、这一年各开源项目广泛实现的web services规范
    括弧里的开源项目支持前面的规范及其新版本。

SOAP 1.2（Axis2 1.1）
WSDL 2.0（XFire 1.2.2）
JAX-WS 2.0（Celtix 1.0）
WS-Policy（Axis2 1.1）
MTOM（Axis2 1.1）
XOP（Axis2 1.1）
WS-RM（Celtix 1.0、Apache Sandesha2、Axis2 1.1）
WS-Addressing（Axis2 1.1、Celtix 1.0）
WS-Security（Apache Rampart、Axis2 1.1）
SAAJ 1.1（Axis2 1.1、Celtix 1.0）
JBI（ServiceMix 3.0.1，Celtix 1.0仅集成，XFire 1.2.2仅集成，Mule）
SCA（Tuscany）
WS-BPEL（Apache Ode、ServiceMix 3.0.1）

四、争论与融合
1. SOAP和REST正走向融合
    基于SOAP和WSDL的Web Services规范多而复杂，虽然它是标准的，但是用户头疼，学习曲线陡而长，应用构建时间长。简单就是美，易用

性是金。在java企业应用开发领域， EJB的没落，Spring框架的兴起和流行印证了这一规律。同样，在SOA领域这一规律也已起作用，兴起了另

一种简单的实现——REST，虽然它不是标准的。

    其实REST和SOAP各有所长。REST简单、易用，与互联网思想一脉相承，核心思想是资源共享、面向资源的Web Services。而SOAP是广为接

受的标准，在互操作性方面，解决复杂的系统集成方面优势明显，其核心思想是面向活动的Web Services。

    以前，REST和SOAP的争论异常激烈。如google选择SOAP；而Amazon 85％的web services应用采用REST，15％采用SOAP。

    但慢慢地厂商变得越来越聪明，逐步摆脱理论上的争论，看重实际的接受度。如微软的Web Services项目Indigo去年底宣布支持REST；

Apache Axis2同时支持SOAP协议栈和REST，而且二者可互相通讯。
    同时，SOAP族的Web Services规范新版本开始支持REST的特性（http get/post）,如WSDL 2.0和SOAP 1.2

    真所谓分久必合，合久必分。SOAP和REST正走向融合。
       
2. JBI和SCA之争
    SUN阵营支持JBI，而BEA、IBM、SAP、SIEBEL支持SCA。随着7月初SUN公司的加入SCA/SDO国际构件标准组织，标志着Sun将逐步放弃自己的

JBI，预示着Java和JavaEE将在未来五年内逐渐退出‘解决客户关键问题的主流技术’的地位。
    其实不少JBI和JCA专家组的成员更倾向于JBI，但是IBM等不喜欢SUN控制JAVA，不愿看到将来SUN控制SOA的商业应用。其实JBI是好东西，

被牺牲了。不过，SUN如果早点将JDK开源，避垄断JAVA之嫌，就不会这么孤立。

3. JAX-WS2.0 替换JAX-RPC 1.1
    JAX-WS2.0即Java API for XML Web Services (JAX-WS) 2.0，JAX-RPC 1.1即Java API for XML-Based RPC (JAX-RPC) 1.1。它们都是sun

公司的使用 Java 技术开发 Web 服务的规范，前者是后者的升级版本。
    JAX-WS2.0的binding层用JAXB（JSR 222），xml解析层用StAX（JSR 173），完全基于标准，性能得到大幅提升；支持Java 5的注释

（annotation），容易开发。
   

五、总结
1. SOA是未来企业的IT应用模式
    而在SOA创造的商业世界里，企业将有机会像玩积木（网络服务构件就是积木）游戏一样创造崭新的商业模式，从不同厂商购买网络服务，

编排和组装自己的应用。IT的收费方式不是整个产品，也不是按CPU、license收费，而是按网络服务调用次数收费。灵活、总体拥有成本将大

大降低，将注意力集中于自身的商业逻辑。
    同时，经历十几年、二十几年的IT建设，企业拥有了各种各样的系统，c++、java、c、cobra写的各种各样的遗留系统，保护企业以前的投

资，构建出新的应用，这样的需求越来越多、越来越强烈。而这正是SOA发挥作用的舞台，SOA可提供跨平台、跨语言的、可扩展的、可靠和安

全的网络服务。
    Gartner预测，到2008年，75%的新企业应用将采纳SOA。

2. ESB（企业服务总线）的淡出
     ESB这一概念将会淡出，SOA治理、策略（policy）和SOA Network、SOA Repository正在兴起。

3. SOA应用趋势
总结一句，SOA的应用大潮将至，SOA中间件产品的竞争越来越激烈。IBM 11月1日宣布在北京和印度成立SOA全球解决方案中心。这标志着SOA应

用竞争的升级。

AXIS VS CXF
在SOA领域，我们认为Web Service是SOA体系的构建单元（building block）。对于作过WebService的开发人员来说，AXIS和CXF一定都不会陌生。这两个产品都是Apache孵化器下面的Web Service开源开发工具。 Axis2的最新版本是1.3，CXF现在已经到了2.0版本。

这两个框架 都是从已有的开源项目发展起来的。Axis2是从Axis1.x系列发展而来。CXF则是XFire和Celtix项目的结合产品。Axis2是从底层全部重新实现，使用了新的扩展性更好模块架构。 CXF也重新的深化了XFire和Celtix这两个开发工具。

新产品的退出导致了几个问题。是不是现有的使用Axis 1.x，XFire和Celix的应用需要迁移的新的版本上。如果一个开发人员确定要迁移它的应用到新的框架上，那么他应该选择哪一个呢？相反的，如果一个开发者决定从头开发一个新的Web Service，他应该使用哪个呢？ 这两个框架哪一个更好一些呢？

对于系统迁移来说，也许迁移到新的框架并不难。Axis和CXF都提供了迁移的指导。能够给开发者一些迁移的技巧和经验。但是对于这样迁移，这两个开源项目都没有提供迁移的工具。对于这样的迁移工作，尽管很值得去寻找所有的可行方案。Axis2和CXF都有各自不同的WebService开发方法，每个方法都有相当数量拥护者。

通过一个比较矩阵来比较Axis2和CXF变得有现实的意义。这两个项目都开发不够成熟，但是最主要的区别在以下几个方面：
1. CXF支持 WS-Addressing，WS-Policy， WS-RM， WS-Security和WS-I Basic Profile。Axis2不支持WS-Policy，但是承诺在下面的版本支持。
2. CXF可以很好支持Spring。Axis2不能
3. AXIS2支持更广泛的数据并对，如XMLBeans，JiBX，JaxMe和JaxBRI和它自定义的数据绑定ADB。注意JaxME和JaxBRI都还是试验性的。CXF只支持JAXB和Aegis。在CXF2.1
4. Axis2支持多语言-除了Java,他还支持C/C++版本。

比较这两个框架的Web Service开发方法与比较它们的特性同样重要。 从开发者的角度，两个框架的特性相当的不同。 Axis2的开发方式类似一个小型的应用服务器，Axis2的开发包要以WAR的形式部署到Servlet容器中，比如Tomcat，通过这些容器可以对工作中的Web Service进行很好的监控和管理。Axis2 的Web administrion模块可以让我们动态的配置Axis2.一个新的服务可以上载，激活，使之失效，修改web服务的参数。管理UI也可以管理一个或者多个处于运行状态的服务。这种界面化管理方式的一个弊端是所有在运行时修改的参数没有办法保存，因为在重启动之后，你所做的修改就会全部失效。

Axis2允许自己作为独立的应用来发布Web Service，并提供了大量的功能和一个很好的模型，这个模型可以通过它本身的架构（modular architecture）不断添加新的功能。有些开发人员认为这种方式对于他们的需求太过于繁琐。这些开发人员会更喜欢CXF。

CXF更注重开发人员的工效（ergonomics）和嵌入能力（embeddability）。大多数配置都可以API来完成，替代了比较繁琐的XML配置文件， Spring的集成性经常的被提及，CXF支持Spring2.0和CXF's API和Spring的配置文件可以非常好的对应。CXF强调代码优先的设计方式（code-first design)，使用了简单的API使得从现有的应用开发服务变得方便。

不过你选择Axis2还是CXF，你都可以从开源社区得到大量的帮助。这两个框架都有商业公司提供服务，WSO2提供AXIS2的支持，Iona提供CXF的支持。这两公司都有很活跃的开发者社区。 Axis2出现的时间较早，CXF的追赶速度快。我的建议是：如果你需要多语言的支持，你应该选择AXIS2。如果你需要把你的实现侧重JAVA并希望和Spring集成，CXF就是更好的选择，特别是把你的Web Service嵌入其他的程序中。如果你觉得这两个框架的新特性对于你并没有太大的用处，你会觉得Axis1也是不错的选择，你应该继续使用它知道你有充分的理由去更换它。

二、开始XFire的生火之旅：
1、配置XFire运行环境：
在Tomcat下新建一个Web Applications，命名为stove，然后在其WEB-INF目录下新建一个web.xml文件，文件中输入：

Xml代码

1. <?xml version="1.0" encoding="GB2312">  
2. <!DOCTYPE web-app   
3.     PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"   
4.     "http://java.sun.com/dtd/web-app_2_3.dtd">  
5.        
6. <web-app>  
7.   
8.   <servlet>  
9.     <servlet-name>XFireServlet</servlet-name>  
10.     <display-name>XFire Servlet</display-name>  
11.     <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>  
12.   </servlet>  
13.   
14.   <servlet-mapping>  
15.     <servlet-name>XFireServlet</servlet-name>  
16.     <url-pattern>/servlet/XFireServlet/*</url-pattern>  
17.   </servlet-mapping>  
18.   
19.   <servlet-mapping>  
20.     <servlet-name>XFireServlet</servlet-name>  
21.     <url-pattern>/services/*</url-pattern>  
22.   </servlet-mapping>  
23.   
24. </web-app>  

<?xml version="1.0" encoding="GB2312">
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<servlet>
<servlet-name>XFireServlet</servlet-name>
<display-name>XFire Servlet</display-name>
<servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/servlet/XFireServlet/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
</web-app>

其中主要就是引入了XFireServlet，用以处理Web Service请求，并且负责提供Web Service的WSDL，如果你发布了一个名为BookService的WebService，则可以通过网址：
http://<服务器>[:端口]/<webapp名>/services/BookService
来访问这个WebService，并且通过地址：
http://<服务器>[:端口]/<webapp名>/services/BookService?WSDL  来得到这个WebService的WSDL信息。

2、开发最简单的WebService
在WEB-INF目录下新建src文件夹，然后再建一个package:
cn.com.pansky.webservice.xfire.study
，在这个包下面新建一个接口：

Java代码

1. package cn.com.pansky.webservice.xfire.study;   
2.   
3. public interface SayHiService{   
4.   public String sayHi(String name);   
5. }  

package cn.com.pansky.webservice.xfire.study;
public interface SayHiService{
public String sayHi(String name);
}

这个接口是告诉服务器你的WebService哪些方法可以被用户调用的。下面我们再来写一个SayHiService的实现类，以完成业务逻辑：

Java代码

1. package cn.com.pansky.webservice.xfire.study;   
2.   
3. public class SayHiServiceImpl implements SayHiService{   
4.   public String sayHi(String name){   
5.     if(name==null){   
6.       return "连名字也不肯告诉我吗？";   
7.     }   
8.     return name+", 你吃了吗？没吃回家吃去吧。";   
9.   }   
10.   
11.   public String 不告诉你(){   
12.     return "我的名字不告诉你！";   
13.   }   
14. }  

package cn.com.pansky.webservice.xfire.study;
public class SayHiServiceImpl implements SayHiService{
public String sayHi(String name){
if(name==null){
return "连名字也不肯告诉我吗？";
}
return name+", 你吃了吗？没吃回家吃去吧。";
}
public String 不告诉你(){
return "我的名字不告诉你！";
}
}

 这个类实现了sayHi方法，该方法是可以通过WebService调用访问到的。另外还实现了一个方法“不告诉你”，该方法因为没有在接口SayHiService中定义，所以不能被WebService调用到。
   这个例子足够简单吧，就跟我们刚学Java时写的"Hello world"没什么两样。
到这里为止，我们做的跟平时的Java开发没啥区别，该如何来发布WebService呢？

3、把JAVA类发布为WebService：
在WEB-INF/classes目录下新建文件夹：META-INF/xfire，然后在该文件夹下新建一个XML文件：services.xml，文件内容如下：

Xml代码

1. <beans xmlns="http://xfire.codehaus.org/config/1.0">  
2.   <service>  
3.     <name>SayHiService</name>  
4.     <namespace>http://cn.com.pansky/SayHiService</namespace>  
5.     <serviceClass>cn.com.pansky.webservice.xfire.study.SayHiService</serviceClass>  
6.     <implementationClass>cn.com.pansky.webservice.xfire.study.SayHiServiceImpl</implementationClass>  
7.   </service>  
8. </beans>  

<beans xmlns="http://xfire.codehaus.org/config/1.0">
<service>
<name>SayHiService</name>
<namespace>http://cn.com.pansky/SayHiService</namespace>
<serviceClass>cn.com.pansky.webservice.xfire.study.SayHiService</serviceClass>
<implementationClass>cn.com.pansky.webservice.xfire.study.SayHiServiceImpl</implementationClass>
</service>
</beans>

 这个文件定义一个WebService: SayHiService，并同时定义了接口和实现类。
好了，该建的文件基本建完了，现在想办法把src下的java文件编译成class，并复制到WEB-INF/classes目录下

4、启动Tomcat，测试WebService
如果Tomcat还没配置好，抽两分钟再配一下。再把Tomcat启动起来。
再打开浏览器，输入：
http://localhost/stove/services
，服务器返回的结果如下：
Available Services:
    * SayHiService [wsdl]
     Generated by XFire ( http://xfire.codehaus.org )
我们看到我们的WebService已经布署成功了，我们再看看它的WSDL信息：

Xml代码

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <wsdl:definitions targetNamespace="http://cn.com.pansky/SayHiService" xmlns:tns="http://cn.com.pansky/SayHiService" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenc11="http://schemas.xmlsoap.org/soap/encoding/" xmlns:soapenc12="http://www.w3.org/2003/05/soap-encoding" xmlns:soap11="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">  
3.   <wsdl:types>  
4. <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" attributeFormDefault="qualified" elementFormDefault="qualified" targetNamespace="http://cn.com.pansky/SayHiService">  
5. <xsd:element name="sayHi">  
6. <xsd:complexType>  
7. <xsd:sequence>  
8. <xsd:element maxOccurs="1" minOccurs="1" name="in0" nillable="true" type="xsd:string"/>  
9. </xsd:sequence>  
10. </xsd:complexType>  
11. </xsd:element>  
12. <xsd:element name="sayHiResponse">  
13. <xsd:complexType>  
14. <xsd:sequence>  
15. <xsd:element maxOccurs="1" minOccurs="1" name="out" nillable="true" type="xsd:string"/>  
16. </xsd:sequence>  
17. </xsd:complexType>  
18. </xsd:element>  
19. </xsd:schema>  
20.   </wsdl:types>  
21.   <wsdl:message name="sayHiRequest">  
22.     <wsdl:part name="parameters" element="tns:sayHi">  
23.     </wsdl:part>  
24.   </wsdl:message>  
25.   <wsdl:message name="sayHiResponse">  
26.     <wsdl:part name="parameters" element="tns:sayHiResponse">  
27.     </wsdl:part>  
28.   </wsdl:message>  
29.   <wsdl:portType name="SayHiServicePortType">  
30.     <wsdl:operation name="sayHi">  
31.       <wsdl:input name="sayHiRequest" message="tns:sayHiRequest">  
32.     </wsdl:input>  
33.       <wsdl:output name="sayHiResponse" message="tns:sayHiResponse">  
34.     </wsdl:output>  
35.     </wsdl:operation>  
36.   </wsdl:portType>  
37.   <wsdl:binding name="SayHiServiceHttpBinding" type="tns:SayHiServicePortType">  
38.     <wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>  
39.     <wsdl:operation name="sayHi">  
40.       <wsdlsoap:operation soapAction=""/>  
41.       <wsdl:input name="sayHiRequest">  
42.         <wsdlsoap:body use="literal"/>  
43.       </wsdl:input>  
44.       <wsdl:output name="sayHiResponse">  
45.         <wsdlsoap:body use="literal"/>  
46.       </wsdl:output>  
47.     </wsdl:operation>  
48.   </wsdl:binding>  
49.   <wsdl:service name="SayHiService">  
50.     <wsdl:port name="SayHiServiceHttpPort" binding="tns:SayHiServiceHttpBinding">  
51.       <wsdlsoap:address location="http://localhost/stove/services/SayHiService"/>  
52.     </wsdl:port>  
53.   </wsdl:service>  
54. </wsdl:definitions>  

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://cn.com.pansky/SayHiService" xmlns:tns="http://cn.com.pansky/SayHiService" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenc11="http://schemas.xmlsoap.org/soap/encoding/" xmlns:soapenc12="http://www.w3.org/2003/05/soap-encoding" xmlns:soap11="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
<wsdl:types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" attributeFormDefault="qualified" elementFormDefault="qualified" targetNamespace="http://cn.com.pansky/SayHiService">
<xsd:element name="sayHi">
<xsd:complexType>
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="1" name="in0" nillable="true" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="sayHiResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="1" name="out" nillable="true" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</wsdl:types>
<wsdl:message name="sayHiRequest">
<wsdl:part name="parameters" element="tns:sayHi">
</wsdl:part>
</wsdl:message>
<wsdl:message name="sayHiResponse">
<wsdl:part name="parameters" element="tns:sayHiResponse">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="SayHiServicePortType">
<wsdl:operation name="sayHi">
<wsdl:input name="sayHiRequest" message="tns:sayHiRequest">
</wsdl:input>
<wsdl:output name="sayHiResponse" message="tns:sayHiResponse">
</wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="SayHiServiceHttpBinding" type="tns:SayHiServicePortType">
<wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="sayHi">
<wsdlsoap:operation soapAction=""/>
<wsdl:input name="sayHiRequest">
<wsdlsoap:body use="literal"/>
</wsdl:input>
<wsdl:output name="sayHiResponse">
<wsdlsoap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="SayHiService">
<wsdl:port name="SayHiServiceHttpPort" binding="tns:SayHiServiceHttpBinding">
<wsdlsoap:address location="http://localhost/stove/services/SayHiService"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

 这个文件跟我们用Axis生成的基本是一样的。

5、享受美味的时刻
WebService这道大餐算是烹制好了，现在是享用美餐的时候了。
我们写一个客户端吃掉这道大餐：

Java代码

1. package cn.com.pansky.webservice.xfire.study;   
2.   
3. import java.net.MalformedURLException;   
4. import java.util.Map;   
5.   
6. import org.codehaus.xfire.client.Client;   
7. import org.codehaus.xfire.client.XFireProxyFactory;   
8. import org.codehaus.xfire.service.Service;   
9. import org.codehaus.xfire.service.binding.ObjectServiceFactory;   
10. import org.codehaus.xfire.transport.http.CommonsHttpMessageSender;   
11.   
12. public class SayHiClient{   
13.   public static void main(String args[]) {   
14.     String serviceURL = "http://localhost/stove/services/SayHiService";   
15.     Service serviceModel = new ObjectServiceFactory().create(SayHiService.class,null,"http://cn.com.pansky/SayHiService",null);   
16.   
17.     XFireProxyFactory serviceFactory = new XFireProxyFactory();   
18.   
19.     try{   
20.       SayHiService service = (SayHiService) serviceFactory.create(serviceModel, serviceURL);   
21.       Client client = Client.getInstance(service);   
22.       //client.addOutHandler(new OutHeaderHandler());   
23.   
24.       // disable timeout   
25.       client.setProperty(CommonsHttpMessageSender.HTTP_TIMEOUT, "1");   
26.   
27.       String hello = service.sayHi("张山疯");   
28.       System.out.println("服务器对[张山疯] 的回答是：" + hello );   
29.   
30.       hello = service.sayHi(null);   
31.       System.out.println("服务器胡言乱语说：" + hello );   
32.   
33.     } catch (MalformedURLException e) {   
34.       e.printStackTrace();   
35.     }   
36.   }   
37. }  

package cn.com.pansky.webservice.xfire.study;
import java.net.MalformedURLException;
import java.util.Map;
import org.codehaus.xfire.client.Client;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
import org.codehaus.xfire.transport.http.CommonsHttpMessageSender;
public class SayHiClient{
public static void main(String args[]) {
String serviceURL = "http://localhost/stove/services/SayHiService";
Service serviceModel = new ObjectServiceFactory().create(SayHiService.class,null,"http://cn.com.pansky/SayHiService",null);
XFireProxyFactory serviceFactory = new XFireProxyFactory();
try{
SayHiService service = (SayHiService) serviceFactory.create(serviceModel, serviceURL);
Client client = Client.getInstance(service);
//client.addOutHandler(new OutHeaderHandler());
// disable timeout
client.setProperty(CommonsHttpMessageSender.HTTP_TIMEOUT, "1");
String hello = service.sayHi("张山疯");
System.out.println("服务器对[张山疯] 的回答是：" + hello );
hello = service.sayHi(null);
System.out.println("服务器胡言乱语说：" + hello );
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}

 编译这个类，再执行一下，服务器服务的结果是：

2008-5-22 17:39:17 org.apache.commons.httpclient.HttpMethodBase writeRequest
信息: 100 (continue) read timeout. Resume sending the request
2008-5-22 17:39:17 org.apache.commons.httpclient.HttpMethodBase readResponse
信息: Discarding unexpected response: HTTP/1.1 100 Continue
服务器对[张山疯] 的回答是：张山疯, 你吃了吗？没吃回家吃去吧。
2008-5-22 17:39:20 org.apache.commons.httpclient.HttpMethodBase writeRequest
信息: 100 (continue) read timeout. Resume sending the request
2008-5-22 17:39:20 org.apache.commons.httpclient.HttpMethodBase readResponse
信息: Discarding unexpected response: HTTP/1.1 100 Continue
服务器胡言乱语说：连名字也不肯告诉我吗？

好了，WebService布署成功。

与Spring整合，无须生成一堆文件，无须打包独立war，直接将应用中的Pojo导出为Web服务。
Aegis--超简约的默认Java XML 绑定机制，且可以Plugin其他绑定机制。
JSR181--annotatiton驱动的POJO WebService配置。
基于Stax的高性能框架。
脱离Web服务器的单元测试能力。
   网上的文档与例子总是不新，请大家抛开所有的文档，所有的Axis习惯，单看这份代表XFire1.2.2最简约做法的指南。

2. 生火指南
2.1 修改web.xml，在Web应用中增加XFire的入口
   注意XFire有了自己的Servlet，不再依赖Spring MVC的DispatchServlet，也就远离了大家不熟悉的Spring MVC URL Mapping，与Spring达致完美的整合。

   这里指定了路径为/service/* ，即WebService的URL会被默认生成为http://www.xxx.com/yyy/service/BookServiceservice/ServiceName，其中ServiceName默认为下文中的接口名。

xml 代码<servlet>       <servlet-name>xfireservlet-name>       <servlet-class>org.codehaus.xfire.spring.XFireSpringServletservlet-class>   servlet>   <servlet-mapping>       <servlet-name>xfireservlet-name>       <url-pattern>/service/*url-pattern>      servlet-mapping>        如果应用使用了Hibernate，使用了OpenSessionInView Filter，注意配置OSIV Filter Filter覆盖xfire servlet的路径，即本例中的/service/*.2.2 编写窄接口，抽取POJO中要导出的服务
   从已有的BookManager.java中，抽取出一个窄接口，仅暴露需要导出为Web Service的方法。而BookManger.java是POJO，不需要任何WebService相关代码。

  窄接口一方面满足了安全要求，不用整个BookManager所有方法导出为Web Service；另一方面，XFire暂时也只支持基于接口的Proxy。

public interface BookService {
   List findBooksByCategory(String cateoryId);
} 2.3 配置Java-XML Binding
   XFire默认的Aegis Binding语法非常简单，在SpringSide的例子里几乎一行配置都不用写，是我见过最简单的binding定义，大大优于其他以设计复杂为终极目标的方案。

   对象的属性、函数的参数和返回值如果为int、String、Date等普通类型以及由普通类型组成的复杂对象都无需定义。我见到只有两种情况需要定义：

无法使用泛型定义Collection中元素的类型时--如List findBooks()。如果能写成List<org.springside.bookstore.domain.Book> findBooks()就也不需要了。
需要为属性定义不同的名字，或者定义复杂对象里的某些属性不要输出。
     如果实在需要aegis配置， XFire以约定俗成代替配置(CoC)，所有Service和Entity Bean的binding文件要求命名为xxx.aegis.xml，而且要和原来的类sit together在同一目录里。

<mapping>  
          
        <method name="findBooksByName">  
            <return-type componentType="org.springside.bookstore.domain.Book"/>  
        method>  
         
       <property name="products" ignore="true"/>  
mapping>  

   其他语法详见Aegis 参考。

2.4 配置Spring导出
    为了节约配置代码，先配置一个基类。注意导出Web服务的Bean不能lazy-init：

xml 代码  <import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>    <bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">    <property name="serviceFactory" ref="xfire.serviceFactory"/>    <property name="xfire" ref="xfire"/>   bean>    每个Web服务的定义：parent为前面定义的基类，serviceClass 为Web Service的接口，serviceBean为Web Service的接口实现类。

xml 代码
<bean id="bookService" parent="baseWebService">  
  <property name="serviceBean" ref="bookManager"/>  
  <property name="serviceClass" value="org.springside.bookstore.components.xfire.server.simple.BookService"/>  
 bean>  

--------------------------------------------------------------------------------

Web服务导出完毕，用户可在http://localhost/service/BookService?WSDL查看自动生成的WSDL

1. JSR181

     JSR181式通过annotated POJO ，零配置文件的导出Web服务，是BEA倡导的，JavaEE5里的正规方式， XFire作了良好的支持。

     但是，XFire关于JSR181方式的文档还不够清晰，请完整阅读本节以避免其中的陷阱。

1.1 参考文章

• Spring, Hibernate and XFire 
• Webservices with Spring, XFire and jsr181 
• Basic Spring Web services with XFire and JSR 181 
• XFire JSR181参考文档 

1.2 ApplicationContext.xml

    因为Web服务配置都写在了annotation，applicationContext.xml文件的内容变得比较固定。需要注意JSR181WebAnnotations与HandlerMapping不能lazy init。

java 代码



    
default-autowire="byName">   
    
     
    
 <import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>    
    
  
    
    
    
 "webAnnotations" class="org.codehaus.xfire.annotations.jsr181.Jsr181WebAnnotations"  lazy-init="false"/>   
    
  
    
  
    
    
    
 "jsr181HandlerMapping" class="org.codehaus.xfire.spring.remoting.Jsr181HandlerMapping"  lazy-init="false">   
    
  "xfire" ref="xfire"/>   
    
  "webAnnotations" ref="webAnnotations"/>   
    
    
    
  
    

1.3 Interface+Impl模式

   不同于XFire传统模式，窄接口不是必须的，只是考虑到有个接口，配置都在接口上做，对原来的Manager类侵入较少。

   如果采用Interface，Interface将担任主要的配置工作。

   首先定义@WebService，可定义自己的NameSpace，如果不定义将采用默认的生成算法。

   接口中的函数将默认全部导出，不需要再用@WebMethod注释，也可以如下例般进行关于Param，Result的更进一步配置：

java 代码



    
@WebService(targetNamespace = "http://www.springside.org.cn")   
    
public interface BookService {   
    
  @WebResult(name = "SearchResult")   
    
  List findBooksByCategory(@WebParam(name = "category", header = true)String cateoryId);   
    
}  
    

       Manager不是纯粹的POJO，需要带上@WebService注释，指明接口。

java 代码



    
@WebService(serviceName = "BookService", endpointInterface = "org.springside.bookstore.components.xfire.server.jsr181.BookService")   
    
public class BookManager implements BookService {   
    
...   
    
}  
    

      陷阱一：XFire JSR181参考文档  中在Interface中以@WebService(name="BookService")来定义ServiceName，这个做法看起来也比较合理，但实际上需要在Manager中以@WebService(serviceName ="BookService") 来定义，比较古怪。

1.4 纯POJO模式

    参考文档中的例子，需要配置@WebMethod 指定需要导出的函数。

java 代码



    
@WebService(name = "EchoService", targetNamespace = "http://www.openuri.org/2004/04/HelloWorld")   
    
        public class Jsr181EchoService   
    
{   
    
    @WebMethod(operationName = "echoString", action = "urn:EchoString")   
    
    @WebResult(name = "echoResult")   
    
    public String echo(@WebParam(name = "echoParam", header = true) String input)   
    
    {   
    
        return input;   
    
    }   
    
}  
    

1.5 Client注意事项

    陷阱二：和传统模式的client有一点最大的区别，serviceModel需要实际的Manager类而不是接口类来做参数：

1. Service serviceModel = new AnnotationServiceFactory().create(BookManager.class);  

2. Client

XFire的Client并不算强项，一共有三种模式：

2.1 Client开发者拥有Web服务端的class

  Client与Server是同一个开发团队也好，Server端团队以jar形式提供开发包也好，反正如果能拿到服务端的接口Class和Entity类及aegis 配置文件的话。

  传统POJO模式：

  JSR181模式，注意这里Server端开发组需要向Client提供BookService的实现类BookManager，而不止于接口，有点危险： 

  SpringSide 用泛型封装了一个XFireClientFactory，调用代码如下：

2.2 动态模式

    动态模式不需要服务端的class，不过性能和复杂对象映射等估计做得不会太好。

2.3 根据WSDL生成Client Stub

    这才是Web Service Client的王道，可以访问任意编写下的Web Service，将在下一个版本中演示。

3. 测试

XFiire很重要的一个特性是提供了无须启动Web容器也能进行单元测试的能力。

原理就是利用XFire的JVM模式，以xfire.local://BookService 而不是http://localhost/service/BookService 来访问服务。

测试的方式分两种：

一种是纯服务器角度，不编写客户端代码，以SOAP XML形式发送请求，返回的也是SOAP XML字串，直接对XML进行测试。

一种是编写2.1 中Client代码来进行测试。

前一种的测试的隔离度较高，而后一种比较简便。

3.1 测试基类 

无论那种方式，都使用Xfire的AbstractXFireSpringTest基类，实现createContext()回调函数。

另外测试基类还要完成一个很重要的工作就是要解决Hibernate的LazyLoad问题，做到OpenSession In Test。因此，SpringSide专门封装了一个XFireTestCase的基类。

3.2 用Client代码直接测试

     下文直接用client代码调用findBooksByCategory方法，得到返回值后进行各种Assert判断。

     注意和普通client code的两处区别：servericeURL换成local，factory须加入getXFire()作参数。

3.3 纯服务端测试

   编写一段SOAP XML，以任意命名保存，下文以"Java"作参数，调用findBooksByName方法。

xml 代码



    
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">  
    
    <env:Header/>  
    
    <env:Body>  
    
        <findBooksByName xmlns="http://www.springside.org.cn">  
    
            <in1>Javain1>  
    
        findBooksByName>  
    
    env:Body>  
    
env:Envelope>