String componentName = "MyReceiver"; // The name of the receiving component. 
String transformers = null; // A comma-separated list of transformers
                            // to apply to the result message. 
String payload = "A test event"; // The payload of the event. 
java.util.Map messageProperties = null; // Any properties to be associated
                                        // with the payload.
MuleClient client = new MuleClient();
UMOMessage message = client.sendDirect(componentName,
                                       transformers,
                                       payload,
                                       messageProperties);
System.out.println("Event result: " + message.getPayloadAsString()); 

import org.mule.umo.lifecycle.Callable;

public class EchoComponent
   implements Callable
{
    public Object onCall(UMOEventContext context) throws Exception
    {
        String msg = context.getMessageAsString();
        // Print message to System.out
        System.out.println("Received synchronous message: " + msg);
        // Echo transformed message back to sender
        return context.getTransformedMessage();
    }
} 

connector=org.mule.providers.vm.VMConnector
dispatcher.factory=org.mule.providers.vm.VMMessageDispatcherFactory
message.receiver=org.mule.providers.vm.VMMessageReceiver
message.adapter=org.mule.providers.vm.VMMessageAdapter
endpoint.builder=org.mule.impl.endpoint.ResourceNameEndpointBuilder 

package com.jeffhanson.mule;

import org.mule.umo.FutureMessageResult;

public interface EventManager
{
   /**
    * Sends an event message synchronously to a given service.
    *
    * @param serviceName    The name of the service to which the event
    *                       message is to be sent.
    * @param payload        The content of the event message.
    * @return Object        The result, if any.
    * @throws EventException on error
    */
   public Object sendSynchronousEvent(String serviceName,
                                      Object payload)
      throws EventException;

   /**
    * Sends an event message asynchronously to a given service.
    *
    * @param serviceName    The name of the service to which the event
    *                       message is to be sent.
    * @param payload        The content of the event message.
    * @return FutureMessageResult The result, if any.
    * @throws EventException on error
    */
   public FutureMessageResult sendAsynchronousEvent(String serviceName,
                                                    Object payload)
      throws EventException;

   /**
    * Starts this event manager.
    */
   public void start();

   /**
    * Stops this event manager.
    */
   public void stop();

   /**
    * Retrieves the protocol this event manager uses.
    * @return
    */
   public String getProtocol();

   /**
    * Registers a service to receive event messages.
    *
    * @param serviceName      The name to associate with the service.
    * @param implementation   Either a container reference to the service
    *                         or a fully-qualified class name.
    */
   public void registerService(String serviceName,
                               String implementation)
      throws EventException;

   /**
    * Unregisters a service from receiving event messages.
    *
    * @param serviceName  The name associated with the service to unregister.
    */
   public void unregisterService(String serviceName)
      throws EventException;
} 

package com.jeffhanson.mule;

import org.mule.umo.*;
import org.mule.extras.client.MuleClient;
import org.mule.impl.endpoint.MuleEndpoint;
import org.mule.config.QuickConfigurationBuilder;

import java.util.HashMap;
import java.util.Map;

public class EventManagerFactory
{
   private static HashMap instances = new HashMap();


   /**
    * Retrieves the event manager instance for a given protocol.
    *
    * @param protocol      The protocol to use.
    * @return EventManager The event manager instance.
    */
   public static EventManager getInstance(String protocol)
   {
      EventManager instance = (EventManager)instances.get(protocol);

      if (instance == null)
      {
         instance = new EventManagerImpl(protocol);
         instances.put(protocol, instance);
      }

      return instance;
   }

   /**
    * A concrete implementation for a simple event manager.
    */
   private static class EventManagerImpl
      implements EventManager
   {
      private UMOManager manager = null;
      private QuickConfigurationBuilder builder = null;
      private MuleClient eventClient = null;
      private String protocol = null;
      private MuleEndpoint receiveEndpoint = null;
      private MuleEndpoint sendEndpoint = null;

      private EventManagerImpl(String protocol)
      {
         this.protocol = protocol;
      }

      /**
       * Starts this event manager.
       */
      public void start()
      {
         try
         {
            builder = new QuickConfigurationBuilder();
            manager = builder.createStartedManager(true,
                                                   protocol + "tmp/events");
            eventClient = new MuleClient();
            receiveEndpoint = new MuleEndpoint(protocol
                                               + "tmp/events/receive");
            sendEndpoint = new MuleEndpoint(protocol + "tmp/events/send");
         }
         catch (UMOException e)
         {
            System.err.println(e);
         }
      }

      /**
       * Stops this event manager.
       */
      public void stop()
      {
         try
         {
            manager.stop();
         }
         catch (UMOException e)
         {
            System.err.println(e);
         }
      }

      /**
       * Retrieves the protocol this event manager uses.
       * @return
       */
      public String getProtocol()
      {
         return protocol;
      }

      /**
       * Registers a service to receive event messages.
       *
       * @param serviceName      The name to associate with the service.
       * @param implementation   Either a container reference to the service
       *                         or a fully-qualified class name
       *                         to use as the component implementation.
       */
      public void registerService(String serviceName,
                                  String implementation)
         throws EventException
      {
         if (!manager.getModel().isComponentRegistered(serviceName))
         {
            try
            {
               builder.registerComponent(implementation,
                                         serviceName,
                                         receiveEndpoint,
                                         sendEndpoint);
            }
            catch (UMOException e)
            {
               throw new EventException(e.toString());
            }
         }
      }

      /**
       * Unregisters a service from receiving event messages.
       *
       * @param serviceName  The name associated with the service to unregister.
       */
      public void unregisterService(String serviceName)
         throws EventException
      {
         try
         {
            builder.unregisterComponent(serviceName);
         }
         catch (UMOException e)
         {
            throw new EventException(e.toString());
         }
      }

      /**
       * Sends an event message synchronously to a given service.
       *
       * @param serviceName    The name of the service to which the event
       *                       message is to be sent.
       * @param payload        The content of the event message
       * @return Object        The result, if any.
       * @throws EventException on error
       */
      public Object sendSynchronousEvent(String serviceName,
                                         Object payload)
         throws EventException
      {
         try
         {
            if (!manager.getModel().isComponentRegistered(serviceName))
            {
               throw new EventException("Service: " + serviceName
                                        + " is not registered.");
            }

            String transformers = null;
            Map messageProperties = null;
            UMOMessage result = eventClient.sendDirect(serviceName,
                                                       transformers,
                                                       payload,
                                                       messageProperties);
            if (result == null)
            {
               return null;
            }
            return result.getPayload();
         }
         catch (UMOException e)
         {
            throw new EventException(e.toString());
         }
         catch (Exception e)
         {
            throw new EventException(e.toString());
         }
      }

      /**
       * Sends an event message asynchronously.
       *
       * @param serviceName    The name of the service to which the event
       *                       message is to be sent.
       * @param payload        The content of the event message.
       * @return FutureMessageResult The result, if any
       * @throws EventException on error
       */
      public FutureMessageResult sendAsynchronousEvent(String serviceName,
                                                       Object payload)
         throws EventException
      {
         FutureMessageResult result = null;

         try
         {
            if (!manager.getModel().isComponentRegistered(serviceName))
            {
               throw new EventException("Service: " + serviceName
                                        + " is not registered.");
            }

            String transformers = null;
            Map messageProperties = null;
            result = eventClient.sendDirectAsync(serviceName,
                                                 transformers,
                                                 payload,
                                                 messageProperties);
         }
         catch (UMOException e)
         {
            throw new EventException(e.toString());
         }

         return result;
      }
   }
} 

package com.jeffhanson.mule;

import java.util.Date;

public class TestService
{
   public void receiveEvent(String eventMessage)
   {
      System.out.println("\n\nTestService.receiveEvent(String) received "
                         + "event message:  " + eventMessage + "\n\n");
   }

   public void receiveEvent(Integer eventMessage)
   {
      System.out.println("\n\nTestService.receiveEvent(Integer) received "
                         +"event message:  " + eventMessage + "\n\n");
   }

   public void receiveEvent(Date eventMessage)
   {
      System.out.println("\n\nTestService.receiveEvent(Date) received "
                         + "event message:  " + eventMessage + "\n\n");
   }
} 

package com.jeffhanson.mule;

import org.apache.log4j.Logger;
import org.apache.log4j.Level;
import org.apache.log4j.BasicConfigurator;

import java.util.Date;

public class EventClient
{
   static Logger logger = Logger.getLogger(EventClient.class);

   public static void main(String[] args)
   {
      // Set up a simple configuration that logs on the console.
      BasicConfigurator.configure();
      logger.setLevel(Level.ALL);

      try
      {
         EventManager eventManager =
            EventManagerFactory.getInstance("vm://");
         eventManager.start();

         String serviceName = TestService.class.getName();
         String implementation = serviceName;

         eventManager.registerService(serviceName, implementation);

         Object result =
            eventManager.sendSynchronousEvent(serviceName, "A test message");

         if (result != null)
         {
            System.out.println("Event result: " + result.toString());
         }

         result =
            eventManager.sendSynchronousEvent(serviceName, new Integer(23456));

         if (result != null)
         {
            System.out.println("Event result: " + result.toString());
         }

         result =
            eventManager.sendSynchronousEvent(serviceName, new Date());

         if (result != null)
         {
            System.out.println("Event result: " + result.toString());
         }

         eventManager.stop();
      }
      catch (EventException e)
      {
         System.err.println(e.toString());
      }
   }
} 

我们有许多方法可以实现面向服务的架构，无论最终目标是消除大型机还是简单地重用软件资产。匹兹堡大学医疗中心 (UPMC)和Starwood Hotels & Resorts Worldwide公司都有正在进行中的SOA项目，这无疑表明了SOA实施过程的多样性。对于这两种不同方向的工作，他们在本质上都是要建立集中的用于存储和编制软件资产的仓库。

对于匹兹堡大学医疗中心(UPMC)而言，一个目标就是在组织内部充分利用单个SOA 开发项目的价值，这同时也涉及到了管理问题。“我们已经做了很有价值的工作，但是在其他的领域却不能被普遍使用的。”UPMC企业中间件小组的主任 Duane Falk说。“我们朝着SOA的方向发展不仅仅是为了使用它的一些技术来帮助我们解决问题，我们也在努力朝着使资源重用性更高的方向发展。”

Falk 说我们选出了一些高级开发人员和架构师来讨论开始的最佳地点。“普遍的意见是把某些资产聚集在一起放进图书馆，在那里人们可以识别、存储、读取这些可以重用的代码和其他资源。”他说。

匹兹堡大学医疗中心(UPMC)正在使用匹兹堡市LogicLibrary公司提供的Logidex原数据仓库来小规模的实验一个项目。Falk 说一个研发小组正与一个海外开发人员联合重构程序来管理医疗器械资产。

“我们已经感觉到这样做是有优势的:确保在最后阶段我们把全部的代码和对象放在保存完好的中心位置，虽然开发中我们只用到了其中的一部分，但是放在这里我们以后可以继续重用。”

这个项目组使用Logidex来对系统设计、架构还有开发的其他服务进行分类。“其他小组，如企业中间件组，他们在写用于不同领域的Web服务和核心组件的代码，而且我们希望把那些代码也放到仓库中来。”Falk说。这个仓库也可能会帮助UMPC管理一致性问题，如Sarbanes-Oxley Act。

“我们这个小实验的一个主要目的就是:我们所有的开发人员都能够应用LogicLibrary，不仅仅是我们的项目可以访问，而且要做到其他组同样可以访问。即使他们只有一个或者两个服务，但是他们可以获得文档记录和发表方面的经验，并且这样做将会帮助我们决定是否继续朝着SOA的方向前进。”

记录和管理服务在Starwood Hotels & Resorts Worldwide公司也是中心论题，这里正在进行的SOA项目的目标是最大限度的消除大型机。

Starwood公司是通过一系列的合并和收购建立的，其中最大的是Sheraton子公司。

“那个时候，管理层做出决定:继续保留Sheraton系统并且作为主要的预订系统。我们终止了基于IBM技术、客户端控制系统(CICS)以及Cobol应用程序的大型机遗留系统，” srael del Rio说，Starwood公司的技术方案和架构高级副总裁。

大约三年以前，Starwood公司决定朝着SOA的方向发展，并且对Linux、J2EE和IBM WebSphere实现标准化。他说。“最开始的时候，我们通过在这些平台上开发新的应用程序，之后逐渐开始卸载一些大型机应用程序放到开放系统上来。这时我们也开始发展一些XML服务，但那并不是我们现在所见到的Web服务，”他说。

Del Rio说:一年半之前，Starwood 公司为消除大型机给出了致命一击。“一切都围绕着SOA的概念，”他说。并且没有移植的应用程序，他补充道。“所有的一切都是通过服务从零开始编写代码、进行设计。那是巨大的工作任务。”

为了管理不同的小组开发的服务，Starwood公司使用Systinet公司提供的Systinet注册信息表，这个公司位于麻省的伯灵顿。 “我们在注册信息表中(Registry)定义了80%到90%的服务。我们将结束数以百计的服务，” del Rio说。Starwood公司目前使用Systinet来进行支配和策略管理，同时使用Actional 公司的Looking Glass产品用于服务管理，Actional 公司位于加州的Mountain View市。

现在，服务都必须和内部系统绑定在一起，del Rio说，因此Starwood公司不再使用Systinet公司统一描述、发现和集成(UDDI)的功能。“但是知道他们公司有这个功能还是很好的。我们已经打算把一些服务做成公共服务。”

2006年的第一季度，Starwood公司将开始在新系统上实现一些独立属性，然后做集成测试。“我们研究的范围是建立在能够消除大型机的基础之上，”他说。这就是到2006年底实现的目标。

对于Starwood公司，SOA的道路是正确的，但是del Rio说这条路又是充满艰险的。“SOA是一个好的概念。我们应该朝着SOA的方向发展，尽管实现的过程是艰辛的。这就是成熟的历程。”