View Javadoc

1   /*
2    * $Id: MuleProxyListener.java 7963 2007-08-21 08:53:15Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.extras.client;
12  
13  import org.mule.MuleException;
14  import org.mule.extras.client.i18n.ClientMessages;
15  import org.mule.umo.UMOException;
16  import org.mule.umo.UMOMessage;
17  import org.mule.umo.transformer.UMOTransformer;
18  
19  import java.lang.reflect.InvocationHandler;
20  import java.lang.reflect.Method;
21  import java.lang.reflect.Proxy;
22  
23  /**
24   * <code>MuleProxyListener</code> is a generic listent proxy that can be used to
25   * foward calls as Mule events from any Observer/Observerable implementation.
26   */
27  
28  public class MuleProxyListener implements InvocationHandler
29  {
30      private Class listenerClass;
31      private AbstractEventTransformer eventTransformer;
32      private String componentName;
33      private Object proxy;
34      private MuleClient client;
35  
36      public MuleProxyListener(Class listenerClass, String componentName) throws UMOException
37      {
38          setListenerClass(listenerClass);
39          setEventTransformer(new EventObjectTransformer());
40          setComponentName(componentName);
41          setClient(new MuleClient());
42          createProxy();
43      }
44  
45      public MuleProxyListener(Class listenerClass,
46                               AbstractEventTransformer eventTransformer,
47                               String componentName) throws UMOException
48      {
49          setListenerClass(listenerClass);
50          setEventTransformer(eventTransformer);
51          setComponentName(componentName);
52          setClient(new MuleClient());
53          createProxy();
54      }
55  
56      public MuleProxyListener(Class listenerClass,
57                               AbstractEventTransformer eventTransformer,
58                               String componentName,
59                               MuleClient client)
60      {
61          setListenerClass(listenerClass);
62          setEventTransformer(eventTransformer);
63          setComponentName(componentName);
64          setClient(client);
65          createProxy();
66      }
67  
68      protected void createProxy()
69      {
70          proxy = Proxy.newProxyInstance(listenerClass.getClassLoader(), new Class[]{listenerClass}, this);
71      }
72  
73      public Class getListenerClass()
74      {
75          return listenerClass;
76      }
77  
78      public void setListenerClass(Class listenerClass)
79      {
80          this.listenerClass = listenerClass;
81      }
82  
83      public UMOTransformer getEventTransformer()
84      {
85          return eventTransformer;
86      }
87  
88      public void setEventTransformer(AbstractEventTransformer eventTransformer)
89      {
90          this.eventTransformer = eventTransformer;
91      }
92  
93      public String getComponentName()
94      {
95          return componentName;
96      }
97  
98      public void setComponentName(String componentName)
99      {
100         this.componentName = componentName;
101     }
102 
103     public MuleClient getClient()
104     {
105         return client;
106     }
107 
108     public void setClient(MuleClient client)
109     {
110         this.client = client;
111     }
112 
113     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
114     {
115         if (args.length == 0)
116         {
117             throw new MuleException(ClientMessages.noArgsForProxy());
118         }
119         UMOMessage message = eventTransformer.transform(args[0], method);
120         if (!"void".equals(method.getReturnType().getName()))
121         {
122             UMOMessage result = client.sendDirect(componentName, null, message);
123             if (UMOMessage.class.equals(method.getReturnType()))
124             {
125                 return result;
126             }
127             else
128             {
129                 return (result == null ? null : result.getPayload());
130             }
131         }
132         else
133         {
134             client.dispatchDirect(componentName, message);
135             return null;
136         }
137     }
138 
139     public Object getProxy()
140     {
141         return proxy;
142     }
143 }