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.core.service.IoHandler;
    28  import org.apache.mina.core.service.IoHandlerAdapter;
    29  import org.apache.mina.core.session.IoSession;
    30  import org.apache.mina.core.session.UnknownMessageTypeException;
    31  import org.apache.mina.util.IdentityHashSet;
    32
    33  /**
    34   * A {@link IoHandler} that demuxes <code>messageReceived</code> events
    35   * to the appropriate {@link MessageHandler}.
    36   * <p>
    37   * You can freely register and deregister {@link MessageHandler}s using
    38   * {@link #addReceivedMessageHandler(Class, MessageHandler)} and
    39   * {@link #removeReceivedMessageHandler(Class)}.
    40   * </p>
    41   * <p>
    42   * When <code>message</code> is received through a call to
    43   * {@link #messageReceived(IoSession, Object)} the class of the
    44   * <code>message</code> object will be used to find a {@link MessageHandler} for
    45   * that particular message type. If no {@link MessageHandler} instance can be
    46   * found for the immediate class (i.e. <code>message.getClass()</code>) the
    47   * interfaces implemented by the immediate class will be searched in depth-first
    48   * order. If no match can be found for any of the interfaces the search will be
    49   * repeated recursively for the superclass of the immediate class
    50   * (i.e. <code>message.getClass().getSuperclass()</code>).
    51   * </p>
    52   * <p>
    53   * Consider the following type hierarchy (<code>Cx</code> are classes while
    54   * <code>Ix</code> are interfaces):
    55   * <pre>
    56   *     C3 - I7 - I9
    57   *      |    |   /\
    58   *      |   I8  I3 I4
    59   *      |
    60   *     C2 - I5 - I6
    61   *      |
    62   *     C1 - I1 - I2 - I4
    63   *      |         |
    64   *      |        I3
    65   *    Object
    66   * </pre>
    67   * When <code>message</code> is of type <code>C3</code> this hierarchy will be
    68   * searched in the following order:
    69   * <code>C3, I7, I8, I9, I3, I4, C2, I5, I6, C1, I1, I2, I3, I4, Object</code>.
    70   * </p>
    71   * <p>
    72   * For efficiency searches will be cached. Calls to
    73   * {@link #addReceivedMessageHandler(Class, MessageHandler)} and
    74   * {@link #removeReceivedMessageHandler(Class)} clear this cache.
    75   * </p>
    76   *
    77   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
    78   */
    79  public class DemuxingIoHandler extends IoHandlerAdapter {
    80
    81      private final Map<Class<?>, MessageHandler<?>> receivedMessageHandlerCache = new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
    82
    83      private final Map<Class<?>, MessageHandler<?>> receivedMessageHandlers = new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
    84
    85      private final Map<Class<?>, MessageHandler<?>> sentMessageHandlerCache = new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
    86
    87      private final Map<Class<?>, MessageHandler<?>> sentMessageHandlers = new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
    88
    89      private final Map<Class<?>, ExceptionHandler<?>> exceptionHandlerCache = new ConcurrentHashMap<Class<?>, ExceptionHandler<?>>();
    90
    91      private final Map<Class<?>, ExceptionHandler<?>> exceptionHandlers = new ConcurrentHashMap<Class<?>, ExceptionHandler<?>>();
    92
    93      /**
    94       * Creates a new instance with no registered {@link MessageHandler}s.
    95       */
    96      public DemuxingIoHandler() {
    97          // Do nothing
    98      }
    99
    100     /**
    101      * Registers a {@link MessageHandler} that handles the received messages of
    102      * the specified <code>type</code>.
    103      *
    104      * @return the old handler if there is already a registered handler for
    105      *         the specified <tt>type</tt>.  <tt>null</tt> otherwise.
    106      */
    107     @SuppressWarnings("unchecked")
    108     public <E> MessageHandler<? super E> addReceivedMessageHandler(Class<E> type, MessageHandler<? super E> handler) {
    109         receivedMessageHandlerCache.clear();
    110         return (MessageHandler<? super E>) receivedMessageHandlers.put(type, handler);
    111     }
    112
    113     /**
    114      * Deregisters a {@link MessageHandler} that handles the received messages
    115      * of the specified <code>type</code>.
    116      *
    117      * @return the removed handler if successfully removed.  <tt>null</tt> otherwise.
    118      */
    119     @SuppressWarnings("unchecked")
    120     public <E> MessageHandler<? super E> removeReceivedMessageHandler(Class<E> type) {
    121         receivedMessageHandlerCache.clear();
    122         return (MessageHandler<? super E>) receivedMessageHandlers.remove(type);
    123     }
    124
    125     /**
    126      * Registers a {@link MessageHandler} that handles the sent messages of the
    127      * specified <code>type</code>.
    128      *
    129      * @return the old handler if there is already a registered handler for
    130      *         the specified <tt>type</tt>.  <tt>null</tt> otherwise.
    131      */
    132     @SuppressWarnings("unchecked")
    133     public <E> MessageHandler<? super E> addSentMessageHandler(Class<E> type, MessageHandler<? super E> handler) {
    134         sentMessageHandlerCache.clear();
    135         return (MessageHandler<? super E>) sentMessageHandlers.put(type, handler);
    136     }
    137
    138     /**
    139      * Deregisters a {@link MessageHandler} that handles the sent messages of
    140      * the specified <code>type</code>.
    141      *
    142      * @return the removed handler if successfully removed.  <tt>null</tt> otherwise.
    143      */
    144     @SuppressWarnings("unchecked")
    145     public <E> MessageHandler<? super E> removeSentMessageHandler(Class<E> type) {
    146         sentMessageHandlerCache.clear();
    147         return (MessageHandler<? super E>) sentMessageHandlers.remove(type);
    148     }
    149
    150     /**
    151      * Registers a {@link MessageHandler} that receives the messages of
    152      * the specified <code>type</code>.
    153      *
    154      * @return the old handler if there is already a registered handler for
    155      *         the specified <tt>type</tt>.  <tt>null</tt> otherwise.
    156      */
    157     @SuppressWarnings("unchecked")
    158     public <E extends Throwable> ExceptionHandler<? super E> addExceptionHandler(Class<E> type,
    159             ExceptionHandler<? super E> handler) {
    160         exceptionHandlerCache.clear();
    161         return (ExceptionHandler<? super E>) exceptionHandlers.put(type, handler);
    162     }
    163
    164     /**
    165      * Deregisters a {@link MessageHandler} that receives the messages of
    166      * the specified <code>type</code>.
    167      *
    168      * @return the removed handler if successfully removed.  <tt>null</tt> otherwise.
    169      */
    170     @SuppressWarnings("unchecked")
    171     public <E extends Throwable> ExceptionHandler<? super E> removeExceptionHandler(Class<E> type) {
    172         exceptionHandlerCache.clear();
    173         return (ExceptionHandler<? super E>) exceptionHandlers.remove(type);
    174     }
    175
    176     /**
    177      * Returns the {@link MessageHandler} which is registered to process
    178      * the specified <code>type</code>.
    179      */
    180     @SuppressWarnings("unchecked")
    181     public <E> MessageHandler<? super E> getMessageHandler(Class<E> type) {
    182         return (MessageHandler<? super E>) receivedMessageHandlers.get(type);
    183     }
    184
    185     /**
    186      * Returns the {@link Map} which contains all messageType-{@link MessageHandler}
    187      * pairs registered to this handler for received messages.
    188      */
    189     public Map<Class<?>, MessageHandler<?>> getReceivedMessageHandlerMap() {
    190         return Collections.unmodifiableMap(receivedMessageHandlers);
    191     }
    192
    193     /**
    194      * Returns the {@link Map} which contains all messageType-{@link MessageHandler}
    195      * pairs registered to this handler for sent messages.
    196      */
    197     public Map<Class<?>, MessageHandler<?>> getSentMessageHandlerMap() {
    198         return Collections.unmodifiableMap(sentMessageHandlers);
    199     }
    200
    201     /**
    202      * Returns the {@link Map} which contains all messageType-{@link MessageHandler}
    203      * pairs registered to this handler.
    204      */
    205     public Map<Class<?>, ExceptionHandler<?>> getExceptionHandlerMap() {
    206         return Collections.unmodifiableMap(exceptionHandlers);
    207     }
    208
    209     /**
    210      * Forwards the received events into the appropriate {@link MessageHandler}
    211      * which is registered by {@link #addReceivedMessageHandler(Class, MessageHandler)}.
    212      *
    213      * <b>Warning !</b> If you are to overload this method, be aware that you
    214      * _must_ call the messageHandler in your own method, otherwise it won't
    215      * be called.
    216      */
    217     @Override
    218     public void messageReceived(IoSession session, Object message) throws Exception {
    219         MessageHandler<Object> handler = findReceivedMessageHandler(message.getClass());
    220         if (handler != null) {
    221             handler.handleMessage(session, message);
    222         } else {
    223             throw new UnknownMessageTypeException("No message handler found for message type: "
    224                     + message.getClass().getSimpleName());
    225         }
    226     }
    227
    228     /**
    229      * Invoked when a message written by IoSession.write(Object) is sent out.
    230      *
    231      * <b>Warning !</b> If you are to overload this method, be aware that you
    232      * _must_ call the messageHandler in your own method, otherwise it won't
    233      * be called.
    234      */
    235     @Override
    236     public void messageSent(IoSession session, Object message) throws Exception {
    237         MessageHandler<Object> handler = findSentMessageHandler(message.getClass());
    238         if (handler != null) {
    239             handler.handleMessage(session, message);
    240         } else {
    241             throw new UnknownMessageTypeException("No handler found for message type: "
    242                     + message.getClass().getSimpleName());
    243         }
    244     }
    245
    246     /**
    247      * Invoked when any exception is thrown by user IoHandler implementation
    248      * or by MINA. If cause is an instance of IOException, MINA will close the
    249      * connection automatically.
    250      *
    251      * <b>Warning !</b> If you are to overload this method, be aware that you
    252      * _must_ call the messageHandler in your own method, otherwise it won't
    253      * be called.
    254      */
    255     @Override
    256     public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
    257         ExceptionHandler<Throwable> handler = findExceptionHandler(cause.getClass());
    258         if (handler != null) {
    259             handler.exceptionCaught(session, cause);
    260         } else {
    261             throw new UnknownMessageTypeException("No handler found for exception type: "
    262                     + cause.getClass().getSimpleName());
    263         }
    264     }
    265
    266     protected MessageHandler<Object> findReceivedMessageHandler(Class<?> type) {
    267         return findReceivedMessageHandler(type, null);
    268     }
    269
    270     protected MessageHandler<Object> findSentMessageHandler(Class<?> type) {
    271         return findSentMessageHandler(type, null);
    272     }
    273
    274     protected ExceptionHandler<Throwable> findExceptionHandler(Class<? extends Throwable> type) {
    275         return findExceptionHandler(type, null);
    276     }
    277
    278     @SuppressWarnings("unchecked")
    279     private MessageHandler<Object> findReceivedMessageHandler(Class type, Set<Class> triedClasses) {
    280
    281         return (MessageHandler<Object>) findHandler(receivedMessageHandlers, receivedMessageHandlerCache, type,
    282                 triedClasses);
    283     }
    284
    285     @SuppressWarnings("unchecked")
    286     private MessageHandler<Object> findSentMessageHandler(Class type, Set<Class> triedClasses) {
    287
    288         return (MessageHandler<Object>) findHandler(sentMessageHandlers, sentMessageHandlerCache, type, triedClasses);
    289     }
    290
    291     @SuppressWarnings("unchecked")
    292     private ExceptionHandler<Throwable> findExceptionHandler(Class type, Set<Class> triedClasses) {
    293
    294         return (ExceptionHandler<Throwable>) findHandler(exceptionHandlers, exceptionHandlerCache, type, triedClasses);
    295     }
    296
    297     @SuppressWarnings("unchecked")
    298     private Object findHandler(Map handlers, Map handlerCache, Class type, Set<Class> triedClasses) {
    299
    300         Object handler = null;
    301
    302         if (triedClasses != null && triedClasses.contains(type)) {
    303             return null;
    304         }
    305
    306         /*
    307          * Try the cache first.
    308          */
    309         handler = handlerCache.get(type);
    310         if (handler != null) {
    311             return handler;
    312         }
    313
    314         /*
    315          * Try the registered handlers for an immediate match.
    316          */
    317         handler = handlers.get(type);
    318
    319         if (handler == null) {
    320             /*
    321              * No immediate match could be found. Search the type's interfaces.
    322              */
    323
    324             if (triedClasses == null) {
    325                 triedClasses = new IdentityHashSet<Class>();
    326             }
    327             triedClasses.add(type);
    328
    329             Class[] interfaces = type.getInterfaces();
    330             for (Class element : interfaces) {
    331                 handler = findHandler(handlers, handlerCache, element, triedClasses);
    332                 if (handler != null) {
    333                     break;
    334                 }
    335             }
    336         }
    337
    338         if (handler == null) {
    339             /*
    340              * No match in type's interfaces could be found. Search the
    341              * superclass.
    342              */
    343             Class superclass = type.getSuperclass();
    344             if (superclass != null) {
    345                 handler = findHandler(handlers, handlerCache, superclass, null);
    346             }
    347         }
    348
    349         /*
    350          * Make sure the handler is added to the cache. By updating the cache
    351          * here all the types (superclasses and interfaces) in the path which
    352          * led to a match will be cached along with the immediate message type.
    353          */
    354         if (handler != null) {
    355             handlerCache.put(type, handler);
    356         }
    357
    358         return handler;
    359     }
    360 }