| /* |
| * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.management; |
| |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.concurrent.CopyOnWriteArrayList; |
| import java.util.concurrent.Executor; |
| |
| import com.sun.jmx.remote.util.ClassLogger; |
| |
| /** |
| * <p>Provides an implementation of {@link |
| * javax.management.NotificationEmitter NotificationEmitter} |
| * interface. This can be used as the super class of an MBean that |
| * sends notifications.</p> |
| * |
| * <p>By default, the notification dispatch model is synchronous. |
| * That is, when a thread calls sendNotification, the |
| * <code>NotificationListener.handleNotification</code> method of each listener |
| * is called within that thread. You can override this default |
| * by overriding <code>handleNotification</code> in a subclass, or by passing an |
| * Executor to the constructor.</p> |
| * |
| * <p>If the method call of a filter or listener throws an {@link Exception}, |
| * then that exception does not prevent other listeners from being invoked. However, |
| * if the method call of a filter or of {@code Executor.execute} or of |
| * {@code handleNotification} (when no {@code Excecutor} is specified) throws an |
| * {@link Error}, then that {@code Error} is propagated to the caller of |
| * {@link #sendNotification sendNotification}.</p> |
| * |
| * <p>Remote listeners added using the JMX Remote API (see JMXConnector) are not |
| * usually called synchronously. That is, when sendNotification returns, it is |
| * not guaranteed that any remote listeners have yet received the notification.</p> |
| * |
| * @since 1.5 |
| */ |
| public class NotificationBroadcasterSupport implements NotificationEmitter { |
| /** |
| * Constructs a NotificationBroadcasterSupport where each listener is invoked by the |
| * thread sending the notification. This constructor is equivalent to |
| * {@link NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor, |
| * MBeanNotificationInfo[] info) NotificationBroadcasterSupport(null, null)}. |
| */ |
| public NotificationBroadcasterSupport() { |
| this(null, (MBeanNotificationInfo[]) null); |
| } |
| |
| /** |
| * Constructs a NotificationBroadcasterSupport where each listener is invoked using |
| * the given {@link java.util.concurrent.Executor}. When {@link #sendNotification |
| * sendNotification} is called, a listener is selected if it was added with a null |
| * {@link NotificationFilter}, or if {@link NotificationFilter#isNotificationEnabled |
| * isNotificationEnabled} returns true for the notification being sent. The call to |
| * <code>NotificationFilter.isNotificationEnabled</code> takes place in the thread |
| * that called <code>sendNotification</code>. Then, for each selected listener, |
| * {@link Executor#execute executor.execute} is called with a command |
| * that calls the <code>handleNotification</code> method. |
| * This constructor is equivalent to |
| * {@link NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor, |
| * MBeanNotificationInfo[] info) NotificationBroadcasterSupport(executor, null)}. |
| * @param executor an executor used by the method <code>sendNotification</code> to |
| * send each notification. If it is null, the thread calling <code>sendNotification</code> |
| * will invoke the <code>handleNotification</code> method itself. |
| * @since 1.6 |
| */ |
| public NotificationBroadcasterSupport(Executor executor) { |
| this(executor, (MBeanNotificationInfo[]) null); |
| } |
| |
| /** |
| * <p>Constructs a NotificationBroadcasterSupport with information |
| * about the notifications that may be sent. Each listener is |
| * invoked by the thread sending the notification. This |
| * constructor is equivalent to {@link |
| * NotificationBroadcasterSupport#NotificationBroadcasterSupport(Executor, |
| * MBeanNotificationInfo[] info) |
| * NotificationBroadcasterSupport(null, info)}.</p> |
| * |
| * <p>If the <code>info</code> array is not empty, then it is |
| * cloned by the constructor as if by {@code info.clone()}, and |
| * each call to {@link #getNotificationInfo()} returns a new |
| * clone.</p> |
| * |
| * @param info an array indicating, for each notification this |
| * MBean may send, the name of the Java class of the notification |
| * and the notification type. Can be null, which is equivalent to |
| * an empty array. |
| * |
| * @since 1.6 |
| */ |
| public NotificationBroadcasterSupport(MBeanNotificationInfo... info) { |
| this(null, info); |
| } |
| |
| /** |
| * <p>Constructs a NotificationBroadcasterSupport with information about the notifications that may be sent, |
| * and where each listener is invoked using the given {@link java.util.concurrent.Executor}.</p> |
| * |
| * <p>When {@link #sendNotification sendNotification} is called, a |
| * listener is selected if it was added with a null {@link |
| * NotificationFilter}, or if {@link |
| * NotificationFilter#isNotificationEnabled isNotificationEnabled} |
| * returns true for the notification being sent. The call to |
| * <code>NotificationFilter.isNotificationEnabled</code> takes |
| * place in the thread that called |
| * <code>sendNotification</code>. Then, for each selected |
| * listener, {@link Executor#execute executor.execute} is called |
| * with a command that calls the <code>handleNotification</code> |
| * method.</p> |
| * |
| * <p>If the <code>info</code> array is not empty, then it is |
| * cloned by the constructor as if by {@code info.clone()}, and |
| * each call to {@link #getNotificationInfo()} returns a new |
| * clone.</p> |
| * |
| * @param executor an executor used by the method |
| * <code>sendNotification</code> to send each notification. If it |
| * is null, the thread calling <code>sendNotification</code> will |
| * invoke the <code>handleNotification</code> method itself. |
| * |
| * @param info an array indicating, for each notification this |
| * MBean may send, the name of the Java class of the notification |
| * and the notification type. Can be null, which is equivalent to |
| * an empty array. |
| * |
| * @since 1.6 |
| */ |
| public NotificationBroadcasterSupport(Executor executor, |
| MBeanNotificationInfo... info) { |
| this.executor = (executor != null) ? executor : defaultExecutor; |
| |
| notifInfo = info == null ? NO_NOTIFICATION_INFO : info.clone(); |
| } |
| |
| /** |
| * Adds a listener. |
| * |
| * @param listener The listener to receive notifications. |
| * @param filter The filter object. If filter is null, no |
| * filtering will be performed before handling notifications. |
| * @param handback An opaque object to be sent back to the |
| * listener when a notification is emitted. This object cannot be |
| * used by the Notification broadcaster object. It should be |
| * resent unchanged with the notification to the listener. |
| * |
| * @exception IllegalArgumentException thrown if the listener is null. |
| * |
| * @see #removeNotificationListener |
| */ |
| public void addNotificationListener(NotificationListener listener, |
| NotificationFilter filter, |
| Object handback) { |
| |
| if (listener == null) { |
| throw new IllegalArgumentException ("Listener can't be null") ; |
| } |
| |
| listenerList.add(new ListenerInfo(listener, filter, handback)); |
| } |
| |
| public void removeNotificationListener(NotificationListener listener) |
| throws ListenerNotFoundException { |
| |
| ListenerInfo wildcard = new WildcardListenerInfo(listener); |
| boolean removed = |
| listenerList.removeAll(Collections.singleton(wildcard)); |
| if (!removed) |
| throw new ListenerNotFoundException("Listener not registered"); |
| } |
| |
| public void removeNotificationListener(NotificationListener listener, |
| NotificationFilter filter, |
| Object handback) |
| throws ListenerNotFoundException { |
| |
| ListenerInfo li = new ListenerInfo(listener, filter, handback); |
| boolean removed = listenerList.remove(li); |
| if (!removed) { |
| throw new ListenerNotFoundException("Listener not registered " + |
| "(with this filter and " + |
| "handback)"); |
| // or perhaps not registered at all |
| } |
| } |
| |
| public MBeanNotificationInfo[] getNotificationInfo() { |
| if (notifInfo.length == 0) |
| return notifInfo; |
| else |
| return notifInfo.clone(); |
| } |
| |
| |
| /** |
| * Sends a notification. |
| * |
| * If an {@code Executor} was specified in the constructor, it will be given one |
| * task per selected listener to deliver the notification to that listener. |
| * |
| * @param notification The notification to send. |
| */ |
| public void sendNotification(Notification notification) { |
| |
| if (notification == null) { |
| return; |
| } |
| |
| boolean enabled; |
| |
| for (ListenerInfo li : listenerList) { |
| try { |
| enabled = li.filter == null || |
| li.filter.isNotificationEnabled(notification); |
| } catch (Exception e) { |
| if (logger.debugOn()) { |
| logger.debug("sendNotification", e); |
| } |
| |
| continue; |
| } |
| |
| if (enabled) { |
| executor.execute(new SendNotifJob(notification, li)); |
| } |
| } |
| } |
| |
| /** |
| * <p>This method is called by {@link #sendNotification |
| * sendNotification} for each listener in order to send the |
| * notification to that listener. It can be overridden in |
| * subclasses to change the behavior of notification delivery, |
| * for instance to deliver the notification in a separate |
| * thread.</p> |
| * |
| * <p>The default implementation of this method is equivalent to |
| * <pre> |
| * listener.handleNotification(notif, handback); |
| * </pre> |
| * |
| * @param listener the listener to which the notification is being |
| * delivered. |
| * @param notif the notification being delivered to the listener. |
| * @param handback the handback object that was supplied when the |
| * listener was added. |
| * |
| */ |
| protected void handleNotification(NotificationListener listener, |
| Notification notif, Object handback) { |
| listener.handleNotification(notif, handback); |
| } |
| |
| // private stuff |
| private static class ListenerInfo { |
| NotificationListener listener; |
| NotificationFilter filter; |
| Object handback; |
| |
| ListenerInfo(NotificationListener listener, |
| NotificationFilter filter, |
| Object handback) { |
| this.listener = listener; |
| this.filter = filter; |
| this.handback = handback; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (!(o instanceof ListenerInfo)) |
| return false; |
| ListenerInfo li = (ListenerInfo) o; |
| if (li instanceof WildcardListenerInfo) |
| return (li.listener == listener); |
| else |
| return (li.listener == listener && li.filter == filter |
| && li.handback == handback); |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hashCode(listener); |
| } |
| } |
| |
| private static class WildcardListenerInfo extends ListenerInfo { |
| WildcardListenerInfo(NotificationListener listener) { |
| super(listener, null, null); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| assert (!(o instanceof WildcardListenerInfo)); |
| return o.equals(this); |
| } |
| |
| @Override |
| public int hashCode() { |
| return super.hashCode(); |
| } |
| } |
| |
| private List<ListenerInfo> listenerList = |
| new CopyOnWriteArrayList<ListenerInfo>(); |
| |
| // since 1.6 |
| private final Executor executor; |
| private final MBeanNotificationInfo[] notifInfo; |
| |
| private final static Executor defaultExecutor = new Executor() { |
| // DirectExecutor using caller thread |
| public void execute(Runnable r) { |
| r.run(); |
| } |
| }; |
| |
| private static final MBeanNotificationInfo[] NO_NOTIFICATION_INFO = |
| new MBeanNotificationInfo[0]; |
| |
| private class SendNotifJob implements Runnable { |
| public SendNotifJob(Notification notif, ListenerInfo listenerInfo) { |
| this.notif = notif; |
| this.listenerInfo = listenerInfo; |
| } |
| |
| public void run() { |
| try { |
| handleNotification(listenerInfo.listener, |
| notif, listenerInfo.handback); |
| } catch (Exception e) { |
| if (logger.debugOn()) { |
| logger.debug("SendNotifJob-run", e); |
| } |
| } |
| } |
| |
| private final Notification notif; |
| private final ListenerInfo listenerInfo; |
| } |
| |
| private static final ClassLogger logger = |
| new ClassLogger("javax.management", "NotificationBroadcasterSupport"); |
| } |