View Javadoc

    1   /*
    2    *  Licensed to the Apache Software Foundation (ASF) under one
    3    *  or more contributor license agreements.  See the NOTICE file
    4    *  distributed with this work for additional information
    5    *  regarding copyright ownership.  The ASF licenses this file
    6    *  to you under the Apache License, Version 2.0 (the
    7    *  "License"); you may not use this file except in compliance
    8    *  with the License.  You may obtain a copy of the License at
    9    *
    10   *    http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   *  Unless required by applicable law or agreed to in writing,
    13   *  software distributed under the License is distributed on an
    14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    15   *  KIND, either express or implied.  See the License for the
    16   *  specific language governing permissions and limitations
    17   *  under the License.
    18   *
    19   */
    20  package org.apache.mina.handler.demux;
    21
    22  import java.util.Collections;
    23  import java.util.Map;
    24  import java.util.Set;
    25  import java.util.concurrent.ConcurrentHashMap;
    26
    27  import org.apache.mina.common.IoHandler;
    28  import org.apache.mina.common.IoHandlerAdapter;
    29  import org.apache.mina.common.IoSession;
    30  import org.apache.mina.util.IdentityHashSet;
    31
    32  /**
    33   * A {@link IoHandler} that demuxes <code>messageReceived</code> events
    34   * to the appropriate {@link MessageHandler}.
    35   * <p>
    36   * You can freely register and deregister {@link MessageHandler}s using
    37   * {@link #addMessageHandler(Class, MessageHandler)} and
    38   * {@link #removeMessageHandler(Class)}.
    39   * </p>
    40   * <p>
    41   * When <code>message</code> is received through a call to
    42   * {@link #messageReceived(IoSession, Object)} the class of the
    43   * <code>message</code> object will be used to find a {@link MessageHandler} for
    44   * that particular message type. If no {@link MessageHandler} instance can be
    45   * found for the immediate class (i.e. <code>message.getClass()</code>) the
    46   * interfaces implemented by the immediate class will be searched in depth-first
    47   * order. If no match can be found for any of the interfaces the search will be
    48   * repeated recursively for the superclass of the immediate class
    49   * (i.e. <code>message.getClass().getSuperclass()</code>).
    50   * </p>
    51   * <p>
    52   * Consider the following type hierarchy (<code>Cx</code> are classes while
    53   * <code>Ix</code> are interfaces):
    54   * <pre>
    55   *     C3 - I7 - I9
    56   *      |    |   /\
    57   *      |   I8  I3 I4
    58   *      |
    59   *     C2 - I5 - I6
    60   *      |
    61   *     C1 - I1 - I2 - I4
    62   *      |         |
    63   *      |        I3
    64   *    Object
    65   * </pre>
    66   * When <code>message</code> is of type <code>C3</code> this hierarchy will be
    67   * searched in the following order:
    68   * <code>C3, I7, I8, I9, I3, I4, C2, I5, I6, C1, I1, I2, I3, I4, Object</code>.
    69   * </p>
    70   * <p>
    71   * For efficiency searches will be cached. Calls to
    72   * {@link #addMessageHandler(Class, MessageHandler)} and
    73   * {@link #removeMessageHandler(Class)} clear this cache.
    74   * </p>
    75   *
    76   * @author The Apache Directory Project (mina-dev@directory.apache.org)
    77   * @version $Rev: 555855 $, $Date: 2007-07-13 12:19:00 +0900 (Fri, 13 Jul 2007) $
    78   */
    79  public class DemuxingIoHandler extends IoHandlerAdapter {
    80      private final Map<Class, MessageHandler> findHandlerCache = new ConcurrentHashMap<Class, MessageHandler>();
    81
    82      private final Map<Class, MessageHandler> type2handler = new ConcurrentHashMap<Class, MessageHandler>();
    83
    84      /**
    85       * Creates a new instance with no registered {@link MessageHandler}s.
    86       */
    87      public DemuxingIoHandler() {
    88      }
    89
    90      /**
    91       * Registers a {@link MessageHandler} that receives the messages of
    92       * the specified <code>type</code>.
    93       *
    94       * @return the old handler if there is already a registered handler for
    95       *         the specified <tt>type</tt>.  <tt>null</tt> otherwise.
    96       */
    97      @SuppressWarnings("unchecked")
    98      public <E> MessageHandler<? super E> addMessageHandler(Class<E> type,
    99              MessageHandler<? super E> handler) {
    100         findHandlerCache.clear();
    101         return type2handler.put(type, handler);
    102     }
    103
    104     /**
    105      * Deregisters a {@link MessageHandler} that receives the messages of
    106      * the specified <code>type</code>.
    107      *
    108      * @return the removed handler if successfully removed.  <tt>null</tt> otherwise.
    109      */
    110     @SuppressWarnings("unchecked")
    111     public <E> MessageHandler<? super E> removeMessageHandler(Class<E> type) {
    112         findHandlerCache.clear();
    113         return type2handler.remove(type);
    114     }
    115
    116     /**
    117      * Returns the {@link MessageHandler} which is registered to process
    118      * the specified <code>type</code>.
    119      */
    120     @SuppressWarnings("unchecked")
    121     public <E> MessageHandler<? super E> getMessageHandler(Class<E> type) {
    122         return type2handler.get(type);
    123     }
    124
    125     /**
    126      * Returns the {@link Map} which contains all messageType-{@link MessageHandler}
    127      * pairs registered to this handler.
    128      */
    129     public Map<Class, MessageHandler> getMessageHandlerMap() {
    130         return Collections.unmodifiableMap(type2handler);
    131     }
    132
    133     /**
    134      * Forwards the received events into the appropriate {@link MessageHandler}
    135      * which is registered by {@link #addMessageHandler(Class, MessageHandler)}.
    136      */
    137     public void messageReceived(IoSession session, Object message)
    138             throws Exception {
    139         MessageHandler<Object> handler = findHandler(message.getClass());
    140         if (handler != null) {
    141             handler.messageReceived(session, message);
    142         } else {
    143             throw new UnknownMessageTypeException(
    144                     "No message handler found for message: " + message);
    145         }
    146     }
    147
    148     protected MessageHandler<Object> findHandler(Class type) {
    149         return findHandler(type, null);
    150     }
    151
    152     @SuppressWarnings("unchecked")
    153     private MessageHandler<Object> findHandler(Class type,
    154             Set<Class> triedClasses) {
    155         MessageHandler handler = null;
    156
    157         if (triedClasses != null && triedClasses.contains(type))
    158             return null;
    159
    160         /*
    161          * Try the cache first.
    162          */
    163         handler = findHandlerCache.get(type);
    164         if (handler != null)
    165             return handler;
    166
    167         /*
    168          * Try the registered handlers for an immediate match.
    169          */
    170         handler = type2handler.get(type);
    171
    172         if (handler == null) {
    173             /*
    174              * No immediate match could be found. Search the type's interfaces.
    175              */
    176
    177             if (triedClasses == null)
    178                 triedClasses = new IdentityHashSet<Class>();
    179             triedClasses.add(type);
    180
    181             Class[] interfaces = type.getInterfaces();
    182             for (int i = 0; i < interfaces.length; i++) {
    183                 handler = findHandler(interfaces[i], triedClasses);
    184                 if (handler != null)
    185                     break;
    186             }
    187         }
    188
    189         if (handler == null) {
    190             /*
    191              * No match in type's interfaces could be found. Search the
    192              * superclass.
    193              */
    194
    195             Class superclass = type.getSuperclass();
    196             if (superclass != null)
    197                 handler = findHandler(superclass);
    198         }
    199
    200         /*
    201          * Make sure the handler is added to the cache. By updating the cache
    202          * here all the types (superclasses and interfaces) in the path which
    203          * led to a match will be cached along with the immediate message type.
    204          */
    205         if (handler != null)
    206             findHandlerCache.put(type, handler);
    207
    208         return handler;
    209     }
    210 }