大型分佈式 Java 應用

時間 2019-11-18

原文原文鏈接

當應用從集中式步入分佈式，隨着系統功能的愈來愈豐富，應用就逐步從一個由 10 個系統如下構成的應用逐步發展爲 100 個，甚至 1000 個系統構成的應用，隨着系統愈來愈多，如何管理和運維好一個如此龐大的系統就將成爲一個大問題，這其中包括了開發、調試、測試、部署、升級等衆多的過程，同時，高可用性以及高性能也會一直伴隨着這個發展過程，隨着系統的愈來愈多，數據的不斷增長，訪問量的不斷攀升，要作到高可用性以及高性能的難度也會不斷的提高，最能體現這樣發展過程的無疑是互聯網網站，多數成功的互聯網網站都經歷着如上的發展過程。java

SOA

一、統一系統間的交互方式
SOA 強調系統之間的交互都以 Service 的方式進行交互，當系統須要對外提供功能時，經過 Service 的方式提供，當系統須要訪問其餘系統提供的功能時，也經過 Service 的方式訪問，開發人員無需關心是如何實現這個交互過程的，交互過程當中所採用的通訊協議、交互方
式（例如同步、異步）、如何找到提供 Service 的系統、通訊中的問題處理（例如超時）等等全部交互的問題都由 SOA 框架來完成，在解決了系統間的交互方式後，大型分佈式 Java 應用中的開發問題就沒有那麼突出了。
二、管理基於 SOA 構建的分佈式系統
SOA 把這個管理稱爲服務治理，在 SOA 中經過將全部的服務註冊到統一的服務中心，例如一般可見的技術爲 UDDI，基於此得知目前系統中全部的 Service，進而分析它們之間的依賴關係以及調用路徑等。儘管 SOA 沒有徹底解決高度可管理的系統所需面對的問題，但它指明瞭方向，所以 SOA仍然是在大型分佈式應用中比較好的選擇，即便不採用 SOA 框架來實現大型分佈式的 Java應用，其思想仍然是值得參考的，實現 SOA 的技術有不少不少種，在 Java 的 SOA 體系中，重要的有 SCA（ Service Component Architecture）標準以及 ESB（ Enterprise Service Bus），下面就來看看 SCA 和 ESB 對構建高度可管理性應用的知足程度，評判標準仍然是對於開發、測試以及部署三方面的支持程度，因爲性能主要取決於具體的實現，所以性能方面則不在此
處進行判斷。web

SCA

在 SOA 思想推廣了幾年後，業界對於 SOA 的評價均爲思想不錯，但沒有實際的實現方法指導，因而業界領先的幾家廠商： IBM、 Oracle（包括以前的 Bea、 Sun）、 RedHat、 SAP 以及 Siemens 等成立了一個組織，負責制定 SOA 的具體實現規範，在 2007 年 3 月左右完成了
此規範的大部份內容的制定，規範的名字定爲了 Service-Component Architecture，簡稱 SCA，規範的版本爲 1.0，下面就具體來看看 SCA 標準對於構建高度可管理性系統的知足程度。ajax

開發

因爲 SOA 中系統間交互均爲 service 方式進行，同時 SOA 多數狀況下應用於分佈式場景，所以從開發角度而言，須要關注的主要是如何發佈Service，如何調用 Service、支持的通訊協議以及交互方式這四個方面，分別來看看。
發佈 Service
Service 遵守 SOA，以接口方式對外提供，發佈 Service 首先要求系統自己已經有相應的接口實現，在 SCA 中，爲了減小對系統實現的侵入，經過 XML 定義 Component 來映射到系統自己的接口實現上， SCA 支持了多種的映射方式，並容許自行擴展，所以系統可採用 java、spring bean 等多種方式來實現接口，在定義了 Component 後，便可將 Component 實現的接口以 Service 的方式發佈，以一個具體的例子來看看如何將系統中的接口實現發佈爲 SCAService。
系統中有一個名爲 chapter2.component.DefaultHelloWorld 的類，其實現了chapter2.service.HelloWorld 接口，要將此 Java 類發布爲 SCA service ，提供chapter2.service.HelloWorld 接口定義的功能，編寫一個以下格式的XML 文件便可：spring

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" targetNamespace="http://foo.com" name="HelloWorldComposite">
  <component name="」HelloWorldComponent」">
    <implementation.java class="」">
      <service name="」HelloWorldService」" promote="」HelloWorldComponent」">
        <interface.java interface="」"></interface.java>
      </service>
    </implementation.java>
  </component>
</composite>

在以上 XML 文件中， composite 是 SCA 定義的最小部署單位，每一個 XML 文件其根元素必須爲 composite，在 composite 下能夠有多個 component 以及多個 service 標籤，來具體看看omponent 標籤和 service 標籤。
component 標籤
component 標籤主要經過 implementation 子標籤訂義和已有系統的集成， SCA 提供了對多種實現集成的支持，例如 Spring、 Java 或 C 等。
除了 implementation 子標籤外， component 中還可定義 service、 reference 等子標籤，service 子標籤用於代表當前 component 對外提供了什麼 service， reference 子標籤用於代表當前 component 引用了什麼 service。
service 標籤
service 標籤表明了對外提供服務的描述，包含了 name、 promote、 requires 和 policySets四個屬性，其中 promote 屬性指定了提供此服務的 Component， Component 能夠多種方式實現，如純 Java 方式，或 Spring 方式等。service 標籤下增長 interface 子標籤便可定義對外提供的接口， SCA 標準規定支持三種方式對外提供接口： Java 語言方式的接口、 WSDL 1.1 以及 WSDL 2.0 方式，可將 interface 標籤寫爲 interface.java 或 interface.wsdl， java 方式的狀況還支持callbackInterface 屬性，以知足雙向的服務交互的須要。
對於發佈的服務，可經過配置 binding 標籤來指定其發佈的方式， SCA 默認支持的方式有 sca、 Webservice 以及 JMS 三種，如不指定則以服務的實現方式來決定。從 service 標籤來看，在採用 SCA 的狀況下，能夠很方便的將各類方式實現的功能以多
種方式對外提供，對系統的侵入很是小，從這方面來看， SCA 仍是作的不錯的。
調用 Service
調用 Service 的方式也一樣爲經過簡單的定義 xml 便可實現，例如須要在 spring 中調用上面的 HelloWorldService，只需定義以下的 xml 文件便可：apache

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" targetNamespace="http://foo.com" name="HelloWorldComposite">
  <component name="」HelloWorldComponent」">
    <implementation.spring location="」beans.xml」" />
    <reference name="」HelloWorldService」" target="」HelloWorldService」" />
  </component>
  <reference name="」HelloWorldService」" promote="」HelloWorldComponent」">
    <interface.java interface="」">Spring 的 beans.xml 定義以下： 
    <beans>
      <sca:reference name="」HelloWorldService」" type="」"></sca:reference>
    </beans></interface.java>
  </reference>
</composite>

經過這樣的方式就能夠直接在 Spring 獲取 HelloWorldService bean 來調用 SCA Service 了，來具體看看 reference 標籤。
reference 標籤
reference 標籤表明了調用其餘服務的描述，包含了 name、 promote、 requires、 policySets、multiplicity、 target 和 wiredByImpl 等屬性，經過設置 promote 和 name 來指定此引用到的服務須要注入的 Component 以及其屬性名， multiplicity 可用於指定須要引用的服務的數量：0..一、 1..一、 0..n 或 1..n。
和 service 標籤同樣， reference 標籤經過 interface 標籤來指定須要引用的服務的接口，經過 bindings 標籤來指定引用服務的方式，例如 sca、 Webservice 或 JMS 方式。從 reference 標籤來看，和 service 標籤同樣， SCA 能夠在不侵入系統的情況下以多種方式引用 SCA 服務，並將其注入到須要引用服務的系統中，這些系統一樣能夠以各類方式實
現： Java、 Spring 或 C++等。
支持的通訊方式
從以前對於發佈 Service 和調用 Service 的描述中可看到， SCA 標準默認提供的通訊方式爲 sca、 Webservice 和 JMS 三種，其中Webservice 的實現爲 http 方式， JMS 則能夠以多種方式來實現，例如 tcp/ip、 http 等，這點取決於具體的 SCA 框架了。
除了以上三種外，在 SCA 中也可很是方便的擴展其餘的通訊方式。
支持的交互方式
在交互方式上， SCA 標準中沒有明確的定義。
除了以上主要的四點外，對於分系統以後帶來的跨系統之間的事務問題， SCA 也提供了跨系統之間的事務保證的編程規範，在編程規範中 SCA 將跨子系統的操做的事務分爲globalTransaction 、 localTransaction 、 noManagedTransaction 、 propagatesTransaction 、suspendsTransaction、 transactedOneWay 以及 immediateOneway 幾種類型，當開始調用操做時，如操做位於 globalTransaction 範圍，則能夠作到整個調用都處於同一個事務。結合以上內容綜合來看，在遵循 SCA 標準的狀況下，能夠很是容易的將不一樣實現方式的系統中的功能以多種通訊方式對外提供，一樣，也能夠很是容易的實現對 SCA Service 的調用，而且具有了很好的擴展性，例如通訊方式的擴展等，儘管在交互方式上未提供明確的
支持，但從開發角度衡量而言， SCA 標準是能夠知足要求的。編程

測試及跟蹤

在測試以及跟蹤方面 SCA 未定義相關的支持，須要自行實現。json

部署

SCA 規範中定義了 SCA 組件的部署方式，能夠 zip 等方式進行打包，但 SCA 中並未提供
分析服務依賴關係的方法，所以要解決上面列出的部署方面的問題會比較複雜。
從以上三方面來看， SCA 標準對於構建具有高度可管理性的應用而言能有很大的幫助，但同時也有其不足的地方。ruby

ESB

ESB 和 SCA 不一樣，它並非由多個廠家聯合制定的 SOA 實現的標準，而且也不能把 ESB稱爲 SOA 的實現思想，這在業界爭論了很是多年，和 SOA 同樣，它也是沒有標準的定義的，所以能夠認爲 ESB 只是個概念，其核心思想爲基於消息中間件來實現系統間的交互，基於消
息中間件所構建的此係統交互的中間場所稱爲總線，系統間交互的數據格式採用統一的消息格式，由總線完成消息的轉化、路由，發送到相應的目標應用，圖示以下：
服務器

來看看業界公認的 ESB 框架最基本的要具有如下五個要素：
標準的消息通訊格式；
消息的路由功能；
支持多種的消息交互類型（例如請求/響應、發佈/訂閱等）；
支持多種傳輸協議（例如 tcp/ip、 udp/ip 等）；
支持多種數據格式並可以進行相互轉換。
仍然從開發、測試和部署三個角度來衡量基於 ESB 構建高度可管理的應用的知足程度。

開發

開發角度考察的仍然爲發佈 Service、調用 Service、支持的通訊方式和支持的交互方式四個方面。
發佈 Service
ESB 概念中未明確的定義如何發佈 Service，只是說起到要求全部的 Service 都發布到總線上，從而構成服務倉庫。
調用 Service
對於如何調用 Service， ESB 也只是規定了全部的調用都經過總線來完成，但未定義更多的細節。
支持的通訊方式
按照業界公認的 ESB 框架而言， ESB 會提供多種通訊方式的支持，包括 tcp/ip、 udp/ip等。
支持的交互方式這點上 ESB 沒有明確的定義。
根據上面的分析來看，能夠認爲 ESB 只是定義了發佈 Service 和調用 Service 的方式，但沒有具體到細節，這也是因爲 ESB 只是個概念的緣由。markdown

測試及跟蹤

在此方面 ESB 未作明確的定義。

部署

儘管 ESB 未對此方面作明確的定義，但因爲 ESB 構建了服務倉庫，所以很容易基於此作到服務的依賴關係分析等，進而作到部署的管理。
SOA 思想中並未限定 Service 發佈和調用的方式，但 ESB 對此作了限定，我的以爲能夠認爲 ESB 是 SOA 中的一個子集，僅從上面的評判而言，很難判斷 ESB 是不是構建高度可管理系統的合理選擇；而儘管 SCA 是一個成文的標準，但其對於通訊方式、交互方式、測試以及部署等並無明確的規定，也很難徹底判斷 SCA 是否就是合理的選擇；爲了更好的作出判斷，仍是須要分別從 SCA 和 ESB 的實現框架來加深對於 SCA 以及 ESB 的理解和掌握，並更加準確的判斷此兩類框架對於構建高度可管理性框架的知足程度，以根據不一樣的場景作出相應的選擇。

Tuscany

在 SCA 實現框架中，本書選擇了 Tuscany 1.5 來進行分析， Tuscany 是 IBM 和 Bea 捐獻給Apache 的產品，目前在衆多的 SCA 實現框架中也能夠算得上是首屈一指的，先看一個例子：在這個例子中將提供一個 HelloWorld 接口的實現，配置爲 Spring Bean，並基於 Tuscany
將其發佈爲 WebService 方式的 SCA Service，，先來看看這部分是如何實現的：
HelloWorld 的接口定義以下：

@Remotable
public interface HelloWorld
{
    public String sayHello(String name);
}

HelloWorld 接口實現的代碼以下：

public class DefaultHelloWorld implements HelloWorld {
    public String sayHello(String name)
    {
        System. out.println("Server receive: " + name);
        return "Server response: Hello " + name;
    }
}

Spring Bean xml 的配置以下：

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sca="http://www.springframework.org/schema/sca" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www. springframework.org/schema/sca http://www.osoa.org/xmlns/sca/1.0/spring-sca.xsd">
  <sca:service name="HelloWorldService" type="chapter2. sca. tuscany.demo.HelloWorld" target="HelloWorldServiceBean" />
  <bean id="HelloWorldServiceBean" class="chapter2. sca. tuscany.demo. impl.DefaultHelloWorld"></bean>
</beans>

將以上文件保存至 resources/spring 目錄下，命名爲 beans.xml。
基於 Tuscany 將其發佈爲 Webservice 的配置以下：

<composite name="HelloWorld" targetNamespace="http://tuscany.apache.org/xmlns/sca/1.0" xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:ns1="http://www.osoa.org/xmlns/sca/1.0">
  <service name="HelloWorldService" promote="HelloWorldComponent">
    <interface.java interface="chapter2.sca.tuscany.demo.HelloWorld" />
    <binding.ws uri="http://localhost:8080/services/HelloWorldService" />
  </service>
  <component name="HelloWorldComponent">
    <implementation.spring location="resources/spring/beans.xml" />
  </component>
</composite>

將以上文件保存至 src 目錄下，命名爲 publishservice.composite。
完成了上面的步驟後，編寫一個啓動類來完成服務的發佈，代碼示例以下：

public static void main(String[] args) throws Exception
{
    SCADomain. newInstance("publishservice.composite");
    System. out.println("Server Started");
    while(true)
    {
        Thread. sleep(1000000);
    }
}

執行此代碼後在 console 中可看到 Server Started 的信息，通過瀏覽器訪問http://localhost:8080/services/HelloWorldService?wsdl 即可看到 HelloWorldService 的Webservice 描述信息。
接着來完成調用 HelloWorld Service 的代碼，一樣在 Spring Bean 中來調用此 Service，首先編寫一個須要注入 HelloWorld Service 的測試用的 spring bean，代碼以下：

private HelloWorld service = null;
public void setService(HelloWorld service)
{
    this. service = service;
}
public String execute(String name)
{
    return service.sayHello(name);
}

爲了便於在 Tuscany 啓動後在代碼中獲取到 Spring 的 ApplicationContext，從而獲取相應的 Spring bean 進行測試，編寫一個實現 ApplicationContextAware 接口的類，代碼以下：

public static ApplicationContext context = null;
@Override
public void setApplicationContext(ApplicationContext context)
throws BeansException
{
    SpringApplicationContextHolder. context = context;
}

按照 Tuscany 與 Spring 集成的實現， Spring 配置文件以下：

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sca="http://www.springframework.org/schema/sca" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/sca http://www.osoa.org/xmlns/sca/1.0/spring-sca.xsd">
  <sca:reference name="HelloWorldService" type="chapter2. sca. tuscany.demo.HelloWorld" />
  <bean id="HelloWorldConsumer" class="chapter2. sca. tuscany.demo. impl.HelloWorldConsumer">
    <property name="service">
      <ref bean="HelloWorldService" />
    </property>
  </bean>
  <bean id="SpringBeanFactoryHolder" class="chapter2. sca. tuscany.demo.SpringApplicationContextHolder" />
</beans>

綁定 SCA Service 的配置文件編寫以下：

<composite name="HelloWorld" targetNamespace="http://tuscany.apache.org/xmlns/sca/1.0" xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:ns1="http://www.osoa.org/xmlns/sca/1.0">
  <component name="HelloWorldComponent">
    <implementation.spring location="resources/spring/consumebeans.xml" />
    <reference name="HelloWorldService">
      <binding.ws uri="http://localhost:8080/services/HelloWorldService" />
    </reference>
  </component>
</composite>

用於測試 SCA Service 調用的類編寫以下：

public static void main(String[] args) throws Exception
{
    SCADomain. newInstance("consumeservice.composite");
    System. out.println("Client Started");
    HelloWorldConsumer consumer = (HelloWorldConsumer)
                                  SpringApplicationContextHolder. context.getBean("HelloWorldConsumer");
    System. out.println(consumer.execute("BlueDavy"));
}

在啓動了發佈 SCA Service 的代碼後，再啓動上面調用 SCA Service 的代碼，便可看到console 上看到相應的執行信息，基於上面這些步驟就很容易的實現了在 Spring 中以Webservice 的方式發佈和調用 SCA Service，但以上例子只是粗略的展現了 Tuscany，下面更加詳細的從開發、測試和部署三個角度來評估下 Tuscany。

開發

仍然從發佈 Service、調用 Service、支持的通訊方式以及交互方式四個方面來進行介紹。
發佈 Service
Tuscany 遵照 SCA 標準而編寫，所以其發佈 Service 的方式和上面 SCA 標準中發佈 Service的方式是同樣的，這個從上面的例子中可看出，但它支持了將更多種實現方式的系統中的功能發佈爲 SCA Service，這包括了 java、 xquery、 script、 spring、 resource、 bpel 和 OSGi。在發佈的方式，也支持了更多種的發佈方式，包括髮布爲 webservice、 ajax、 corba、 erlang、jms、 jsonrpc、 rmi、 ejb、 http 以及 rss 方式。
從提供了這麼多的擴展能夠看出， SCA 標準在擴展的支持上作的確實不錯。
調用 Service
在調用 Service 的方式，和 SCA 標準中調用 Service 的方式是同樣，但就如發佈 Service同樣，它支持了更多種和應用集成的方式以及更多種的調用方式，而且包括了更多種語言的支持，例如對於 ruby 的支持等。
支持的通訊方式
在上面發佈 Service 中能夠看到， Tuscany 支持的通訊方式比 SCA 標準中多出了不少，例如流行的 ajax、 jsonrpc、 rmi 等都提供了支持。
支持的交互方式
在 Tuscany 中可經過設置 CallbackEndpoint 來實現異步調用，但這須要對代碼有一些改動，所以 Tuscany 仍然沒有作到透明的支持多種交互方式的需求。根據上面四方面的介紹，僅從開發角度而言，如基於 Tuscany 來實現大型的分佈式 Java系統，只需在支持的交互方式上提供更好的支持便可，性能方面則須要根據 Tuscany 對於各類通訊方式的實現進行判斷，在本書中就不進行分析了。

測試及跟蹤

在測試方面， Tuscany 可經過例子中的方式進行測試，當調用的服務端拋出異常時，此異常信息會提供給調用端，所以調用端可基於此判斷服務器端出現異常的緣由。在跟蹤方面， Tuscany 並無定義跟蹤服務錯誤信息的方法。

部署

Tuscany 沒有把服務註冊到統一的中心，而且調用時也是直接調用，所以很難明確的知道系統中有哪些服務，發佈一個服務時會影響到哪些服務，在採用 Tuscany 時這個方面仍需自行實現進行增強。
通過上面的分析，能夠看出， Tuscany 是個嚴格遵守 SCA 實現的框架，其只是在和應用的集成方式以及通訊方式上作了擴展，但其餘方面並無作出更多的擴展，所以基於 Tuscany來實現大型分佈式的 Java 應用仍然須要自行實現一些功能。在看完了 Tuscany 後來看看 ESB 中著名的實現框架： Mule。

Mule

首先來看看基於 Mule 2.2.1 如何實現 Tuscany 章節中的例子，先仍然是以 Webservice 的方式對外提供 HelloWorldService，和 Tuscany 中不一樣的地方在於配置文件和啓動代碼兩方面，配置文件上去掉 publishservice.composite，改成遵循 Mule 編寫以下配置文件：

<?xml version="1.0" encoding="utf-8"?>
<mule xmlns="http://www.mulesource.org/schema/mule/core/2.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:spring="http://www.springframework.org/schema/beans" xmlns:soap="http://www.mulesource.org/schema/mule/soap/2.2" xmlns:axis="http://www.mulesource.org/schema/mule/axis/2.2" xmlns:vm="http://www.mulesource.org/schema/mule/vm/2.2" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.mulesource.org/schema/mule/core/2.2 http://www.mulesource.org/schema/mule/core/2.2/mule.xsd http://www.mulesource.org/schema/mule/soap/2.2 http://www.mulesource.org/schema/mule/soap/2.2/mule-soap.xsd http://www.mulesource.org/schema/mule/axis/2.2 http://www.mulesource.org/schema/mule/axis/2.2/mule-axis.xsd http://www.mulesource.org/schema/mule/vm/2.2 http://www.mulesource.org/schema/mule/vm/2.2/mule-vm.xsd">
  <spring:beans>
    <spring:import resource="resources/spring/mulepublisherbeans. xml" />
  </spring:beans>
  <model name="HelloWorld">
    <service name="HelloWorldService">
      <inbound>
        <axis:inbound-endpoint address="http://localhost:12345/services">
          <soap:http-to-soap-request-transformer />
        </axis:inbound-endpoint>
      </inbound>
      <component>
        <spring-object bean="HelloWorldBean" />
      </component>
    </service>
  </model>
</mule>

將上面文件保存爲 publishservice.xml。
發佈服務的啓動代碼遵循 Mule 改成以下方式：

MuleContext muleContext = new
DefaultMuleContextFactory().createMuleContext("publishservice.xml ");
muleContext.start();
System. out.println("Server Started");

執行以上代碼後，經過http://localhost:12345/services/HelloWorldService?wsdl 可看到
HelloWorldService 的 Webservice 描述符，代表已發佈成功。
繼續來看看怎麼按照 Mule Service 的方式來調用這個 Webservice， Mule 要求全部的component 被觸發執行的條件爲 inbound 中的信息，而除了上面經過 webservice 的觸發方法外，其餘就只能經過消息機制去觸發了，支持的有 vm 內的，或 jms 方式等，在這裏選擇用vm 內的方式去實現例子，首先對 HelloWorldConsumer 的 execute 稍作了修改：

public String execute(String name)
{
    String response = service.sayHello(name);
    System. out.println(response);
    return response;
}

因爲必須經過消息才能觸發，在例子中就直接用 MuleClient 來發送消息觸發了，所以去掉了 Spring bean 的配置文件 ApplicationContextAware 接口實現類的配置， Mule 方式的 Service
配置文件內容以下：

<spring:beans>
  <spring:import resource="resources/spring/muleconsumebeans. xml" />
</spring:beans>
<model name="HelloWorld">
  <service name="HelloWorldService">
    <inbound>
      <vm:inbound-endpoint path="helloworld.queue" />
    </inbound>
    <component>
      <spring-object bean="HelloWorldConsumer"></spring-object>
      <binding interface="chapter2. esb.mule.demo.HelloWorld" method="sayHello">
        <axis:outbound-endpoint address="http://localhost:12345/services/HelloWorldService?method=say Hello" synchronous="true" />
      </binding>
    </component>
  </service>
</model>

根據上面的配置，必須先發送消息至 vm://helloworld.queue 才能觸發HelloWorldConsumer 的執行，代碼以下：

MuleContext muleContext = new
DefaultMuleContextFactory().createMuleContext("consumeservice.xml ");
muleContext.start();
MuleClient client = new MuleClient();
client.send("vm://helloworld.queue", "BlueDavy", null);

執行以上代碼即實現了以 Mule Service 的方式調用遠端經過 Mule Service 發佈爲Webservice 的功能。
例子只簡單的反應了一個使用的情況，下面就從開發、測試及跟蹤、部署三個方面再來詳細的看看。

開發

仍然從發佈 Service、調用 Service、支持的通訊方式以及交互方式四個方面來進行介紹。
發佈 Service
在發佈 Service 上 Mule 支持以 webservice、 jms 等方式將 spring 或普通的 java 對象發佈爲 Mule Service，配置上較爲簡單，但和 Tuscany 比顯得仍是相對弱了點。
調用 Service
在調用 Service 上 Mule 的用法相對比較麻煩，但這也是因爲 Mule 遵循 ESB 而形成的，如要作到更好的使用，需自行進行擴展。
支持的通訊方式
通訊方式上支持 webservice 以及 jms 兩種。
支持的交互方式
在交互方式上， Mule 有明確的指定 synchronous 的參數，所以這點上 Mule 較 Tuscany強一些。
從開發角度來看， Mule 比 Tuscany 整體更弱一些，須要自行擴展的地方會更多一些。

測試及跟蹤

當服務器端拋出異常時，帶回客戶端的異常信息會不完整，可能會影響到查錯，在跟蹤方面 Mule 未提供明確的支持。

部署

在部署方面的支持上， Mule 自己未提供直接的支持，但 Mule 所在的 MuleSoft 同時還提供了一個開源的服務治理框架： MuleGalaxy1，開發人員可將服務元數據信息註冊到MuleGalaxy， MuleGalaxy 提供了服務信息查詢、依賴分析等功能，而依賴分析將對部署提供很大的支持，在這點上 Mule 贏過 Tuscany。根據上面的分析，不管是 SCA 標準，仍是 ESB 概念，或 SCA 標準的實現框架： Tuscany，仍是 ESB 概念的實現框架： Mule，它們都可以對構建高度可管理的應用提供一些支持，但同時也會有一些不足，所以在實際的實現中，必須根據需求來進行相應的選擇，從而進行擴展來知足需求，而且在上面的分析中未從高可用性以及高性能角度來進行分析，這兩個角度也會很大程度影響您的選擇，在學習了構建高度可管理的應用可選的技術後，接着來學習高性能所需的相關技術了。