You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mina.apache.org by tr...@apache.org on 2007/12/11 08:06:31 UTC
svn commit: r603158 - in
/mina/trunk/core/src/main/java/org/apache/mina/handler/demux:
DemuxingIoHandler.java ExceptionHandler.java MessageHandler.java
Author: trustin
Date: Mon Dec 10 23:06:13 2007
New Revision: 603158
URL: http://svn.apache.org/viewvc?rev=603158&view=rev
Log:
* Replaced messageReceived and messageSent handler methods in MessageHandler with handleMessage() method
* DemuxingIoHandler.add/removeMessageHandler have been split into two; one for receivedMessages and the other for sentMessages.
* Added ExceptionHandler.CLOSE for convenience
Modified:
mina/trunk/core/src/main/java/org/apache/mina/handler/demux/DemuxingIoHandler.java
mina/trunk/core/src/main/java/org/apache/mina/handler/demux/ExceptionHandler.java
mina/trunk/core/src/main/java/org/apache/mina/handler/demux/MessageHandler.java
Modified: mina/trunk/core/src/main/java/org/apache/mina/handler/demux/DemuxingIoHandler.java
URL: http://svn.apache.org/viewvc/mina/trunk/core/src/main/java/org/apache/mina/handler/demux/DemuxingIoHandler.java?rev=603158&r1=603157&r2=603158&view=diff
==============================================================================
--- mina/trunk/core/src/main/java/org/apache/mina/handler/demux/DemuxingIoHandler.java (original)
+++ mina/trunk/core/src/main/java/org/apache/mina/handler/demux/DemuxingIoHandler.java Mon Dec 10 23:06:13 2007
@@ -35,8 +35,8 @@
* to the appropriate {@link MessageHandler}.
* <p>
* You can freely register and deregister {@link MessageHandler}s using
- * {@link #addMessageHandler(Class, MessageHandler)} and
- * {@link #removeMessageHandler(Class)}.
+ * {@link #addReceivedMessageHandler(Class, MessageHandler)} and
+ * {@link #removeReceivedMessageHandler(Class)}.
* </p>
* <p>
* When <code>message</code> is received through a call to
@@ -70,8 +70,8 @@
* </p>
* <p>
* For efficiency searches will be cached. Calls to
- * {@link #addMessageHandler(Class, MessageHandler)} and
- * {@link #removeMessageHandler(Class)} clear this cache.
+ * {@link #addReceivedMessageHandler(Class, MessageHandler)} and
+ * {@link #removeReceivedMessageHandler(Class)} clear this cache.
* </p>
*
* @author The Apache MINA Project (dev@mina.apache.org)
@@ -79,10 +79,16 @@
*/
public class DemuxingIoHandler extends IoHandlerAdapter {
- private final Map<Class<?>, MessageHandler<?>> messageHandlerCache =
+ private final Map<Class<?>, MessageHandler<?>> receivedMessageHandlerCache =
new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
- private final Map<Class<?>, MessageHandler<?>> messageHandlers =
+ private final Map<Class<?>, MessageHandler<?>> receivedMessageHandlers =
+ new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
+
+ private final Map<Class<?>, MessageHandler<?>> sentMessageHandlerCache =
+ new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
+
+ private final Map<Class<?>, MessageHandler<?>> sentMessageHandlers =
new ConcurrentHashMap<Class<?>, MessageHandler<?>>();
private final Map<Class<?>, ExceptionHandler<?>> exceptionHandlerCache =
@@ -98,32 +104,58 @@
}
/**
- * Registers a {@link MessageHandler} that receives the messages of
+ * Registers a {@link MessageHandler} that handles the received messages of
* the specified <code>type</code>.
*
* @return the old handler if there is already a registered handler for
* the specified <tt>type</tt>. <tt>null</tt> otherwise.
*/
@SuppressWarnings("unchecked")
- public <E> MessageHandler<? super E> addMessageHandler(Class<E> type,
+ public <E> MessageHandler<? super E> addReceivedMessageHandler(Class<E> type,
MessageHandler<? super E> handler) {
- messageHandlerCache.clear();
- return (MessageHandler<? super E>) messageHandlers.put(type, handler);
+ receivedMessageHandlerCache.clear();
+ return (MessageHandler<? super E>) receivedMessageHandlers.put(type, handler);
}
/**
- * Deregisters a {@link MessageHandler} that receives the messages of
- * the specified <code>type</code>.
+ * Deregisters a {@link MessageHandler} that handles the received messages
+ * of the specified <code>type</code>.
*
* @return the removed handler if successfully removed. <tt>null</tt> otherwise.
*/
@SuppressWarnings("unchecked")
- public <E> MessageHandler<? super E> removeMessageHandler(Class<E> type) {
- messageHandlerCache.clear();
- return (MessageHandler<? super E>) messageHandlers.remove(type);
+ public <E> MessageHandler<? super E> removeReceivedMessageHandler(Class<E> type) {
+ receivedMessageHandlerCache.clear();
+ return (MessageHandler<? super E>) receivedMessageHandlers.remove(type);
}
/**
+ * Registers a {@link MessageHandler} that handles the sent messages of the
+ * specified <code>type</code>.
+ *
+ * @return the old handler if there is already a registered handler for
+ * the specified <tt>type</tt>. <tt>null</tt> otherwise.
+ */
+ @SuppressWarnings("unchecked")
+ public <E> MessageHandler<? super E> addSentMessageHandler(Class<E> type,
+ MessageHandler<? super E> handler) {
+ sentMessageHandlerCache.clear();
+ return (MessageHandler<? super E>) sentMessageHandlers.put(type, handler);
+ }
+
+ /**
+ * Deregisters a {@link MessageHandler} that handles the sent messages of
+ * the specified <code>type</code>.
+ *
+ * @return the removed handler if successfully removed. <tt>null</tt> otherwise.
+ */
+ @SuppressWarnings("unchecked")
+ public <E> MessageHandler<? super E> removeSentMessageHandler(Class<E> type) {
+ sentMessageHandlerCache.clear();
+ return (MessageHandler<? super E>) sentMessageHandlers.remove(type);
+ }
+
+ /**
* Registers a {@link MessageHandler} that receives the messages of
* the specified <code>type</code>.
*
@@ -157,15 +189,23 @@
*/
@SuppressWarnings("unchecked")
public <E> MessageHandler<? super E> getMessageHandler(Class<E> type) {
- return (MessageHandler<? super E>) messageHandlers.get(type);
+ return (MessageHandler<? super E>) receivedMessageHandlers.get(type);
}
/**
* Returns the {@link Map} which contains all messageType-{@link MessageHandler}
- * pairs registered to this handler.
+ * pairs registered to this handler for received messages.
*/
- public Map<Class<?>, MessageHandler<?>> getMessageHandlerMap() {
- return Collections.unmodifiableMap(messageHandlers);
+ public Map<Class<?>, MessageHandler<?>> getReceivedMessageHandlerMap() {
+ return Collections.unmodifiableMap(receivedMessageHandlers);
+ }
+
+ /**
+ * Returns the {@link Map} which contains all messageType-{@link MessageHandler}
+ * pairs registered to this handler for sent messages.
+ */
+ public Map<Class<?>, MessageHandler<?>> getSentMessageHandlerMap() {
+ return Collections.unmodifiableMap(sentMessageHandlers);
}
/**
@@ -178,28 +218,30 @@
/**
* Forwards the received events into the appropriate {@link MessageHandler}
- * which is registered by {@link #addMessageHandler(Class, MessageHandler)}.
+ * which is registered by {@link #addReceivedMessageHandler(Class, MessageHandler)}.
*/
@Override
public void messageReceived(IoSession session, Object message)
throws Exception {
- MessageHandler<Object> handler = findMessageHandler(message.getClass());
+ MessageHandler<Object> handler = findReceivedMessageHandler(message.getClass());
if (handler != null) {
- handler.messageReceived(session, message);
+ handler.handleMessage(session, message);
} else {
throw new UnknownMessageTypeException(
- "No message handler found for message: " + message);
+ "No message handler found for message type: " +
+ message.getClass().getSimpleName());
}
}
@Override
public void messageSent(IoSession session, Object message) throws Exception {
- MessageHandler<Object> handler = findMessageHandler(message.getClass());
+ MessageHandler<Object> handler = findSentMessageHandler(message.getClass());
if (handler != null) {
- handler.messageSent(session, message);
+ handler.handleMessage(session, message);
} else {
throw new UnknownMessageTypeException(
- "No handler found for message: " + message.getClass().getName());
+ "No handler found for message type: " +
+ message.getClass().getSimpleName());
}
}
@@ -210,12 +252,17 @@
handler.exceptionCaught(session, cause);
} else {
throw new UnknownMessageTypeException(
- "No handler found for exception: " + cause.getClass().getName());
+ "No handler found for exception type: " +
+ cause.getClass().getSimpleName());
}
}
- protected MessageHandler<Object> findMessageHandler(Class<?> type) {
- return findMessageHandler(type, null);
+ protected MessageHandler<Object> findReceivedMessageHandler(Class<?> type) {
+ return findReceivedMessageHandler(type, null);
+ }
+
+ protected MessageHandler<Object> findSentMessageHandler(Class<?> type) {
+ return findSentMessageHandler(type, null);
}
protected ExceptionHandler<Throwable> findExceptionHandler(Class<? extends Throwable> type) {
@@ -223,11 +270,19 @@
}
@SuppressWarnings("unchecked")
- private MessageHandler<Object> findMessageHandler(
+ private MessageHandler<Object> findReceivedMessageHandler(
+ Class type, Set<Class> triedClasses) {
+
+ return (MessageHandler<Object>) findHandler(
+ receivedMessageHandlers, receivedMessageHandlerCache, type, triedClasses);
+ }
+
+ @SuppressWarnings("unchecked")
+ private MessageHandler<Object> findSentMessageHandler(
Class type, Set<Class> triedClasses) {
return (MessageHandler<Object>) findHandler(
- messageHandlers, messageHandlerCache, type, triedClasses);
+ sentMessageHandlers, sentMessageHandlerCache, type, triedClasses);
}
@SuppressWarnings("unchecked")
Modified: mina/trunk/core/src/main/java/org/apache/mina/handler/demux/ExceptionHandler.java
URL: http://svn.apache.org/viewvc/mina/trunk/core/src/main/java/org/apache/mina/handler/demux/ExceptionHandler.java?rev=603158&r1=603157&r2=603158&view=diff
==============================================================================
--- mina/trunk/core/src/main/java/org/apache/mina/handler/demux/ExceptionHandler.java (original)
+++ mina/trunk/core/src/main/java/org/apache/mina/handler/demux/ExceptionHandler.java Mon Dec 10 23:06:13 2007
@@ -32,11 +32,22 @@
*/
public interface ExceptionHandler<E extends Throwable> {
/**
- * A {@link ExceptionHandler} that does nothing. This is usefule when
- * you want to ignore messages of the specific type silently.
+ * A {@link ExceptionHandler} that does nothing. This is useful when
+ * you want to ignore an exception of a specific type silently.
*/
static ExceptionHandler<Throwable> NOOP = new ExceptionHandler<Throwable>() {
public void exceptionCaught(IoSession session, Throwable cause) {}
+ };
+
+ /**
+ * A {@link ExceptionHandler} that closes the session immediately.
+ * This is useful when you want to close the session when an exception of
+ * a specific type is raised.
+ */
+ static ExceptionHandler<Throwable> CLOSE = new ExceptionHandler<Throwable>() {
+ public void exceptionCaught(IoSession session, Throwable cause) {
+ session.close();
+ }
};
/**
Modified: mina/trunk/core/src/main/java/org/apache/mina/handler/demux/MessageHandler.java
URL: http://svn.apache.org/viewvc/mina/trunk/core/src/main/java/org/apache/mina/handler/demux/MessageHandler.java?rev=603158&r1=603157&r2=603158&view=diff
==============================================================================
--- mina/trunk/core/src/main/java/org/apache/mina/handler/demux/MessageHandler.java (original)
+++ mina/trunk/core/src/main/java/org/apache/mina/handler/demux/MessageHandler.java Mon Dec 10 23:06:13 2007
@@ -23,9 +23,10 @@
/**
* A handler interface that {@link DemuxingIoHandler} forwards
- * <code>messageReceived</code> events to. You have to register your
- * handler with the type of message you want to get notified using
- * {@link DemuxingIoHandler#addMessageHandler(Class, MessageHandler)}.
+ * <tt>messageReceived</tt> or <tt>messageSent</tt> events to. You have to
+ * register your handler with the type of the message you want to get notified
+ * using {@link DemuxingIoHandler#addReceivedMessageHandler(Class, MessageHandler)}
+ * or {@link DemuxingIoHandler#addSentMessageHandler(Class, MessageHandler)}.
*
* @author The Apache MINA Project (dev@mina.apache.org)
* @version $Rev$, $Date$
@@ -33,22 +34,15 @@
public interface MessageHandler<E> {
/**
* A {@link MessageHandler} that does nothing. This is useful when
- * you want to ignore messages of the specific type silently.
+ * you want to ignore a message of a specific type silently.
*/
static MessageHandler<Object> NOOP = new MessageHandler<Object>() {
- public void messageReceived(IoSession session, Object message) {}
- public void messageSent(IoSession session, Object message) {}
+ public void handleMessage(IoSession session, Object message) {}
};
/**
- * Invoked when the specific type of message is received from the
- * specified <code>session</code>.
+ * Invoked when the specific type of message is received from or sent to
+ * the specified <code>session</code>.
*/
- void messageReceived(IoSession session, E message) throws Exception;
-
- /**
- * Invoked when the specific type of message is sent out to the
- * specified <code>session</code>.
- */
- void messageSent(IoSession session, E message) throws Exception;
+ void handleMessage(IoSession session, E message) throws Exception;
}