1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.kernel.messaging;
16  
17  import com.liferay.portal.kernel.messaging.sender.MessageSender;
18  import com.liferay.portal.kernel.messaging.sender.SynchronousMessageSender;
19  
20  /**
21   * <a href="MessageBusUtil.java.html"><b><i>View Source</i></b></a>
22   *
23   * @author Michael C. Han
24   */
25  public class MessageBusUtil {
26  
27      public static void addDestination(Destination destination) {
28          _instance._addDestination(destination);
29      }
30  
31      public static Message createResponseMessage(Message requestMessage) {
32          Message responseMessage = new Message();
33  
34          responseMessage.setDestinationName(
35              requestMessage.getResponseDestinationName());
36          responseMessage.setResponseId(requestMessage.getResponseId());
37  
38          return responseMessage;
39      }
40  
41      public static Message createResponseMessage(
42          Message requestMessage, Object payload) {
43  
44          Message responseMessage = createResponseMessage(requestMessage);
45  
46          responseMessage.setPayload(payload);
47  
48          return responseMessage;
49      }
50  
51      public static MessageBus getMessageBus() {
52          return _instance._messageBus;
53      }
54  
55      public static MessageSender getMessageSender() {
56          return _instance._messageSender;
57      }
58  
59      public static boolean hasMessageListener(String destination) {
60          return _instance._hasMessageListener(destination);
61      }
62  
63      public static void init(
64          MessageBus messageBus, MessageSender messageSender,
65          SynchronousMessageSender synchronousMessageSender) {
66  
67          _instance._init(messageBus, messageSender, synchronousMessageSender);
68      }
69  
70      public static void registerMessageListener(
71          String destinationName, MessageListener messageListener) {
72  
73          _instance._registerMessageListener(destinationName, messageListener);
74      }
75  
76      public static void removeDestination(String destinationName) {
77          _instance._removeDestination(destinationName);
78      }
79  
80      public static void sendMessage(String destinationName, Message message) {
81          _instance._sendMessage(destinationName, message);
82      }
83  
84      public static void sendMessage(String destinationName, Object payload) {
85          _instance._sendMessage(destinationName, payload);
86      }
87  
88      public static Object sendSynchronousMessage(
89              String destinationName, Message message)
90          throws MessageBusException {
91  
92          return _instance._sendSynchronousMessage(destinationName, message);
93      }
94  
95      public static Object sendSynchronousMessage(
96              String destinationName, Message message, long timeout)
97          throws MessageBusException {
98  
99          return _instance._sendSynchronousMessage(
100             destinationName, message, timeout);
101     }
102 
103     public static Object sendSynchronousMessage(
104             String destinationName, Object payload)
105         throws MessageBusException {
106 
107         return _instance._sendSynchronousMessage(
108             destinationName, payload, null);
109     }
110 
111     public static Object sendSynchronousMessage(
112             String destinationName, Object payload, long timeout)
113         throws MessageBusException {
114 
115         return _instance._sendSynchronousMessage(
116             destinationName, payload, null, timeout);
117     }
118 
119     public static Object sendSynchronousMessage(
120             String destinationName, Object payload,
121             String responseDestinationName)
122         throws MessageBusException {
123 
124         return _instance._sendSynchronousMessage(
125             destinationName, payload, responseDestinationName);
126     }
127 
128     public static Object sendSynchronousMessage(
129             String destinationName, Object payload,
130             String responseDestinationName, long timeout)
131         throws MessageBusException {
132 
133         return _instance._sendSynchronousMessage(
134             destinationName, payload, responseDestinationName, timeout);
135     }
136 
137     public static void shutdown() {
138         _instance._shutdown();
139     }
140 
141     public static void shutdown(boolean force) {
142         _instance._shutdown(force);
143     }
144 
145     public static boolean unregisterMessageListener(
146         String destinationName, MessageListener messageListener) {
147 
148         return _instance._unregisterMessageListener(
149             destinationName, messageListener);
150     }
151 
152     private MessageBusUtil() {
153     }
154 
155     private void _addDestination(Destination destination) {
156         _messageBus.addDestination(destination);
157     }
158 
159     private boolean _hasMessageListener(String destinationName) {
160         return _messageBus.hasMessageListener(destinationName);
161     }
162 
163     private void _init(
164         MessageBus messageBus, MessageSender messageSender,
165         SynchronousMessageSender synchronousMessageSender) {
166 
167         _messageBus = messageBus;
168         _messageSender = messageSender;
169         _synchronousMessageSender = synchronousMessageSender;
170     }
171 
172     private void _registerMessageListener(
173         String destinationName, MessageListener messageListener) {
174 
175         _messageBus.registerMessageListener(destinationName, messageListener);
176     }
177 
178     private void _removeDestination(String destinationName) {
179         _messageBus.removeDestination(destinationName);
180     }
181 
182     private void _sendMessage(String destinationName, Message message) {
183         _messageBus.sendMessage(destinationName, message);
184     }
185 
186     private void _sendMessage(String destinationName, Object payload) {
187         Message message = new Message();
188 
189         message.setPayload(payload);
190 
191         _sendMessage(destinationName, message);
192     }
193 
194     private Object _sendSynchronousMessage(
195             String destinationName, Message message)
196         throws MessageBusException {
197 
198         return _synchronousMessageSender.send(destinationName, message);
199     }
200 
201     private Object _sendSynchronousMessage(
202             String destinationName, Message message, long timeout)
203         throws MessageBusException {
204 
205         return _synchronousMessageSender.send(
206             destinationName, message, timeout);
207     }
208 
209     private Object _sendSynchronousMessage(
210             String destinationName, Object payload,
211             String responseDestinationName)
212         throws MessageBusException {
213 
214         Message message = new Message();
215 
216         message.setResponseDestinationName(responseDestinationName);
217         message.setPayload(payload);
218 
219         return _sendSynchronousMessage(destinationName, message);
220     }
221 
222     private Object _sendSynchronousMessage(
223             String destinationName, Object payload,
224             String responseDestinationName, long timeout)
225         throws MessageBusException {
226 
227         Message message = new Message();
228 
229         message.setResponseDestinationName(responseDestinationName);
230         message.setPayload(payload);
231 
232         return _sendSynchronousMessage(destinationName, message, timeout);
233     }
234 
235     private void _shutdown() {
236         _messageBus.shutdown();
237     }
238 
239     private void _shutdown(boolean force) {
240         _messageBus.shutdown(force);
241     }
242 
243     private boolean _unregisterMessageListener(
244         String destinationName, MessageListener messageListener) {
245 
246         return _messageBus.unregisterMessageListener(
247             destinationName, messageListener);
248     }
249 
250     private static MessageBusUtil _instance = new MessageBusUtil();
251 
252     private MessageBus _messageBus;
253     private MessageSender _messageSender;
254     private SynchronousMessageSender _synchronousMessageSender;
255 
256 }