View Javadoc

    1   /*
    2    * Copyright 2009 Red Hat, Inc.
    3    *
    4    * Red Hat licenses this file to you under the Apache License, version 2.0
    5    * (the "License"); you may not use this file except in compliance with the
    6    * License.  You may obtain a copy of the License at:
    7    *
    8    *    http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
    13   * License for the specific language governing permissions and limitations
    14   * under the License.
    15   */
    16  package org.jboss.netty.channel;
    17
    18  import java.net.SocketAddress;
    19
    20
    21  /**
    22   * A {@link ChannelDownstreamHandler} which provides an individual handler
    23   * method for each event type.  This handler down-casts the received downstream
    24   * event into more meaningful sub-type event and calls an appropriate handler
    25   * method with the down-cast event.  The names of the methods starts with the
    26   * name of the operation and ends with {@code "Requested"}
    27   * (e.g. {@link #writeRequested(ChannelHandlerContext, MessageEvent) writeRequested}.)
    28   * <p>
    29   * Please use {@link SimpleChannelHandler} if you need to implement both
    30   * {@link ChannelUpstreamHandler} and {@link ChannelDownstreamHandler}.
    31   *
    32   * <h3>Overriding the {@link #handleDownstream(ChannelHandlerContext, ChannelEvent) handleDownstream} method</h3>
    33   * <p>
    34   * You can override the {@link #handleDownstream(ChannelHandlerContext, ChannelEvent) handleDownstream}
    35   * method just like overriding an ordinary Java method.  Please make sure to
    36   * call {@code super.handleDownstream()} so that other handler methods are
    37   * invoked properly:
    38   * </p>
    39   * <pre>public class MyChannelHandler extends {@link SimpleChannelDownstreamHandler} {
    40   *
    41   *     {@code @Override}
    42   *     public void handleDownstream({@link ChannelHandlerContext} ctx, {@link ChannelEvent} e) throws Exception {
    43   *
    44   *         // Log all channel state changes.
    45   *         if (e instanceof {@link MessageEvent}) {
    46   *             logger.info("Writing:: " + e);
    47   *         }
    48   *
    49   *         <strong>super.handleDownstream(ctx, e);</strong>
    50   *     }
    51   * }</pre>
    52   *
    53   * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
    54   * @author <a href="http://gleamynode.net/">Trustin Lee</a>
    55   *
    56   * @version $Rev: 2122 $, $Date: 2010-02-02 11:00:04 +0900 (Tue, 02 Feb 2010) $
    57   */
    58  public class SimpleChannelDownstreamHandler implements ChannelDownstreamHandler {
    59
    60      /**
    61       * Creates a new instance.
    62       */
    63      public SimpleChannelDownstreamHandler() {
    64          super();
    65      }
    66
    67      /**
    68       * {@inheritDoc}  Down-casts the received downstream event into more
    69       * meaningful sub-type event and calls an appropriate handler method with
    70       * the down-casted event.
    71       */
    72      public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e)
    73              throws Exception {
    74
    75          if (e instanceof MessageEvent) {
    76              writeRequested(ctx, (MessageEvent) e);
    77          } else if (e instanceof ChannelStateEvent) {
    78              ChannelStateEvent evt = (ChannelStateEvent) e;
    79              switch (evt.getState()) {
    80              case OPEN:
    81                  if (!Boolean.TRUE.equals(evt.getValue())) {
    82                      closeRequested(ctx, evt);
    83                  }
    84                  break;
    85              case BOUND:
    86                  if (evt.getValue() != null) {
    87                      bindRequested(ctx, evt);
    88                  } else {
    89                      unbindRequested(ctx, evt);
    90                  }
    91                  break;
    92              case CONNECTED:
    93                  if (evt.getValue() != null) {
    94                      connectRequested(ctx, evt);
    95                  } else {
    96                      disconnectRequested(ctx, evt);
    97                  }
    98                  break;
    99              case INTEREST_OPS:
    100                 setInterestOpsRequested(ctx, evt);
    101                 break;
    102             default:
    103                 ctx.sendDownstream(e);
    104             }
    105         } else {
    106             ctx.sendDownstream(e);
    107         }
    108     }
    109
    110     /**
    111      * Invoked when {@link Channel#write(Object)} is called.
    112      */
    113     public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    114         ctx.sendDownstream(e);
    115     }
    116
    117     /**
    118      * Invoked when {@link Channel#bind(SocketAddress)} was called.
    119      */
    120     public void bindRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    121         ctx.sendDownstream(e);
    122
    123     }
    124
    125     /**
    126      * Invoked when {@link Channel#connect(SocketAddress)} was called.
    127      */
    128     public void connectRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    129         ctx.sendDownstream(e);
    130
    131     }
    132
    133     /**
    134      * Invoked when {@link Channel#setInterestOps(int)} was called.
    135      */
    136     public void setInterestOpsRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    137         ctx.sendDownstream(e);
    138     }
    139
    140     /**
    141      * Invoked when {@link Channel#disconnect()} was called.
    142      */
    143     public void disconnectRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    144         ctx.sendDownstream(e);
    145
    146     }
    147
    148     /**
    149      * Invoked when {@link Channel#unbind()} was called.
    150      */
    151     public void unbindRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    152         ctx.sendDownstream(e);
    153
    154     }
    155
    156     /**
    157      * Invoked when {@link Channel#close()} was called.
    158      */
    159     public void closeRequested(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    160         ctx.sendDownstream(e);
    161     }
    162 }