001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.messaging;
016    
017    import com.liferay.portal.kernel.messaging.sender.MessageSender;
018    import com.liferay.portal.kernel.messaging.sender.SynchronousMessageSender;
019    
020    /**
021     * @author Michael C. Han
022     */
023    public class MessageBusUtil {
024    
025            public static void addDestination(Destination destination) {
026                    _instance._addDestination(destination);
027            }
028    
029            public static Message createResponseMessage(Message requestMessage) {
030                    Message responseMessage = new Message();
031    
032                    responseMessage.setDestinationName(
033                            requestMessage.getResponseDestinationName());
034                    responseMessage.setResponseId(requestMessage.getResponseId());
035    
036                    return responseMessage;
037            }
038    
039            public static Message createResponseMessage(
040                    Message requestMessage, Object payload) {
041    
042                    Message responseMessage = createResponseMessage(requestMessage);
043    
044                    responseMessage.setPayload(payload);
045    
046                    return responseMessage;
047            }
048    
049            public static MessageBus getMessageBus() {
050                    return _instance._messageBus;
051            }
052    
053            public static MessageSender getMessageSender() {
054                    return _instance._messageSender;
055            }
056    
057            public static boolean hasMessageListener(String destination) {
058                    return _instance._hasMessageListener(destination);
059            }
060    
061            public static void init(
062                    MessageBus messageBus, MessageSender messageSender,
063                    SynchronousMessageSender synchronousMessageSender) {
064    
065                    _instance._init(messageBus, messageSender, synchronousMessageSender);
066            }
067    
068            public static void registerMessageListener(
069                    String destinationName, MessageListener messageListener) {
070    
071                    _instance._registerMessageListener(destinationName, messageListener);
072            }
073    
074            public static void removeDestination(String destinationName) {
075                    _instance._removeDestination(destinationName);
076            }
077    
078            public static void sendMessage(String destinationName, Message message) {
079                    _instance._sendMessage(destinationName, message);
080            }
081    
082            public static void sendMessage(String destinationName, Object payload) {
083                    _instance._sendMessage(destinationName, payload);
084            }
085    
086            public static Object sendSynchronousMessage(
087                            String destinationName, Message message)
088                    throws MessageBusException {
089    
090                    return _instance._sendSynchronousMessage(destinationName, message);
091            }
092    
093            public static Object sendSynchronousMessage(
094                            String destinationName, Message message, long timeout)
095                    throws MessageBusException {
096    
097                    return _instance._sendSynchronousMessage(
098                            destinationName, message, timeout);
099            }
100    
101            public static Object sendSynchronousMessage(
102                            String destinationName, Object payload)
103                    throws MessageBusException {
104    
105                    return _instance._sendSynchronousMessage(
106                            destinationName, payload, null);
107            }
108    
109            public static Object sendSynchronousMessage(
110                            String destinationName, Object payload, long timeout)
111                    throws MessageBusException {
112    
113                    return _instance._sendSynchronousMessage(
114                            destinationName, payload, null, timeout);
115            }
116    
117            public static Object sendSynchronousMessage(
118                            String destinationName, Object payload,
119                            String responseDestinationName)
120                    throws MessageBusException {
121    
122                    return _instance._sendSynchronousMessage(
123                            destinationName, payload, responseDestinationName);
124            }
125    
126            public static Object sendSynchronousMessage(
127                            String destinationName, Object payload,
128                            String responseDestinationName, long timeout)
129                    throws MessageBusException {
130    
131                    return _instance._sendSynchronousMessage(
132                            destinationName, payload, responseDestinationName, timeout);
133            }
134    
135            public static void shutdown() {
136                    _instance._shutdown();
137            }
138    
139            public static void shutdown(boolean force) {
140                    _instance._shutdown(force);
141            }
142    
143            public static boolean unregisterMessageListener(
144                    String destinationName, MessageListener messageListener) {
145    
146                    return _instance._unregisterMessageListener(
147                            destinationName, messageListener);
148            }
149    
150            private MessageBusUtil() {
151            }
152    
153            private void _addDestination(Destination destination) {
154                    _messageBus.addDestination(destination);
155            }
156    
157            private boolean _hasMessageListener(String destinationName) {
158                    return _messageBus.hasMessageListener(destinationName);
159            }
160    
161            private void _init(
162                    MessageBus messageBus, MessageSender messageSender,
163                    SynchronousMessageSender synchronousMessageSender) {
164    
165                    _messageBus = messageBus;
166                    _messageSender = messageSender;
167                    _synchronousMessageSender = synchronousMessageSender;
168            }
169    
170            private void _registerMessageListener(
171                    String destinationName, MessageListener messageListener) {
172    
173                    _messageBus.registerMessageListener(destinationName, messageListener);
174            }
175    
176            private void _removeDestination(String destinationName) {
177                    _messageBus.removeDestination(destinationName);
178            }
179    
180            private void _sendMessage(String destinationName, Message message) {
181                    _messageBus.sendMessage(destinationName, message);
182            }
183    
184            private void _sendMessage(String destinationName, Object payload) {
185                    Message message = new Message();
186    
187                    message.setPayload(payload);
188    
189                    _sendMessage(destinationName, message);
190            }
191    
192            private Object _sendSynchronousMessage(
193                            String destinationName, Message message)
194                    throws MessageBusException {
195    
196                    return _synchronousMessageSender.send(destinationName, message);
197            }
198    
199            private Object _sendSynchronousMessage(
200                            String destinationName, Message message, long timeout)
201                    throws MessageBusException {
202    
203                    return _synchronousMessageSender.send(
204                            destinationName, message, timeout);
205            }
206    
207            private Object _sendSynchronousMessage(
208                            String destinationName, Object payload,
209                            String responseDestinationName)
210                    throws MessageBusException {
211    
212                    Message message = new Message();
213    
214                    message.setResponseDestinationName(responseDestinationName);
215                    message.setPayload(payload);
216    
217                    return _sendSynchronousMessage(destinationName, message);
218            }
219    
220            private Object _sendSynchronousMessage(
221                            String destinationName, Object payload,
222                            String responseDestinationName, long timeout)
223                    throws MessageBusException {
224    
225                    Message message = new Message();
226    
227                    message.setResponseDestinationName(responseDestinationName);
228                    message.setPayload(payload);
229    
230                    return _sendSynchronousMessage(destinationName, message, timeout);
231            }
232    
233            private void _shutdown() {
234                    _messageBus.shutdown();
235            }
236    
237            private void _shutdown(boolean force) {
238                    _messageBus.shutdown(force);
239            }
240    
241            private boolean _unregisterMessageListener(
242                    String destinationName, MessageListener messageListener) {
243    
244                    return _messageBus.unregisterMessageListener(
245                            destinationName, messageListener);
246            }
247    
248            private static MessageBusUtil _instance = new MessageBusUtil();
249    
250            private MessageBus _messageBus;
251            private MessageSender _messageSender;
252            private SynchronousMessageSender _synchronousMessageSender;
253    
254    }