001    /**
002     * Copyright (c) 2000-present 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.concurrent.ConcurrentHashSet;
018    import com.liferay.portal.kernel.util.StringPool;
019    import com.liferay.portal.kernel.util.Validator;
020    
021    import java.util.Collections;
022    import java.util.Set;
023    
024    /**
025     * @author Michael C. Han
026     * @author Shuyang Zhou
027     */
028    public abstract class BaseDestination implements Destination {
029    
030            @Override
031            public boolean addDestinationEventListener(
032                    DestinationEventListener destinationEventListener) {
033    
034                    return _destinationEventListeners.add(destinationEventListener);
035            }
036    
037            public void afterPropertiesSet() {
038                    if (Validator.isNull(name)) {
039                            throw new IllegalArgumentException("Name is null");
040                    }
041            }
042    
043            @Override
044            public void close() {
045                    close(false);
046            }
047    
048            @Override
049            public void close(boolean force) {
050            }
051    
052            @Override
053            public void copyDestinationEventListeners(Destination destination) {
054                    for (DestinationEventListener destinationEventListener :
055                                    _destinationEventListeners) {
056    
057                            destination.addDestinationEventListener(destinationEventListener);
058                    }
059            }
060    
061            @Override
062            public void copyMessageListeners(Destination destination) {
063                    for (MessageListener messageListener : messageListeners) {
064                            InvokerMessageListener invokerMessageListener =
065                                    (InvokerMessageListener)messageListener;
066    
067                            destination.register(
068                                    invokerMessageListener.getMessageListener(),
069                                    invokerMessageListener.getClassLoader());
070                    }
071            }
072    
073            @Override
074            public void destroy() {
075                    close(true);
076    
077                    removeDestinationEventListeners();
078    
079                    unregisterMessageListeners();
080            }
081    
082            @Override
083            public DestinationStatistics getDestinationStatistics() {
084                    throw new UnsupportedOperationException();
085            }
086    
087            @Override
088            public int getMessageListenerCount() {
089                    return messageListeners.size();
090            }
091    
092            @Override
093            public Set<MessageListener> getMessageListeners() {
094                    return Collections.unmodifiableSet(messageListeners);
095            }
096    
097            @Override
098            public String getName() {
099                    return name;
100            }
101    
102            @Override
103            public boolean isRegistered() {
104                    if (getMessageListenerCount() > 0) {
105                            return true;
106                    }
107                    else {
108                            return false;
109                    }
110            }
111    
112            @Override
113            public void open() {
114            }
115    
116            @Override
117            public boolean register(MessageListener messageListener) {
118                    InvokerMessageListener invokerMessageListener =
119                            new InvokerMessageListener(messageListener);
120    
121                    return registerMessageListener(invokerMessageListener);
122            }
123    
124            @Override
125            public boolean register(
126                    MessageListener messageListener, ClassLoader classloader) {
127    
128                    InvokerMessageListener invokerMessageListener =
129                            new InvokerMessageListener(messageListener, classloader);
130    
131                    return registerMessageListener(invokerMessageListener);
132            }
133    
134            @Override
135            public boolean removeDestinationEventListener(
136                    DestinationEventListener destinationEventListener) {
137    
138                    return _destinationEventListeners.remove(destinationEventListener);
139            }
140    
141            @Override
142            public void removeDestinationEventListeners() {
143                    _destinationEventListeners.clear();
144            }
145    
146            @Override
147            public void send(Message message) {
148                    throw new UnsupportedOperationException();
149            }
150    
151            public void setName(String name) {
152                    this.name = name;
153            }
154    
155            @Override
156            public boolean unregister(MessageListener messageListener) {
157                    InvokerMessageListener invokerMessageListener =
158                            new InvokerMessageListener(messageListener);
159    
160                    return unregisterMessageListener(invokerMessageListener);
161            }
162    
163            public boolean unregister(
164                    MessageListener messageListener, ClassLoader classloader) {
165    
166                    InvokerMessageListener invokerMessageListener =
167                            new InvokerMessageListener(messageListener, classloader);
168    
169                    return unregisterMessageListener(invokerMessageListener);
170            }
171    
172            @Override
173            public void unregisterMessageListeners() {
174                    for (MessageListener messageListener : messageListeners) {
175                            unregisterMessageListener((InvokerMessageListener)messageListener);
176                    }
177            }
178    
179            protected void fireMessageListenerRegisteredEvent(
180                    MessageListener messageListener) {
181    
182                    for (DestinationEventListener destinationEventListener :
183                                    _destinationEventListeners) {
184    
185                            destinationEventListener.messageListenerRegistered(
186                                    getName(), messageListener);
187                    }
188            }
189    
190            protected void fireMessageListenerUnregisteredEvent(
191                    MessageListener messageListener) {
192    
193                    for (DestinationEventListener listener : _destinationEventListeners) {
194                            listener.messageListenerUnregistered(getName(), messageListener);
195                    }
196            }
197    
198            protected boolean registerMessageListener(
199                    InvokerMessageListener invokerMessageListener) {
200    
201                    boolean registered = messageListeners.add(invokerMessageListener);
202    
203                    if (registered) {
204                            fireMessageListenerRegisteredEvent(
205                                    invokerMessageListener.getMessageListener());
206                    }
207    
208                    return registered;
209            }
210    
211            protected boolean unregisterMessageListener(
212                    InvokerMessageListener invokerMessageListener) {
213    
214                    boolean unregistered = messageListeners.remove(invokerMessageListener);
215    
216                    if (unregistered) {
217                            fireMessageListenerUnregisteredEvent(
218                                    invokerMessageListener.getMessageListener());
219                    }
220    
221                    return unregistered;
222            }
223    
224            protected Set<MessageListener> messageListeners = new ConcurrentHashSet<>();
225            protected String name = StringPool.BLANK;
226    
227            private final Set<DestinationEventListener> _destinationEventListeners =
228                    new ConcurrentHashSet<>();
229    
230    }