1
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
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 }