View Javadoc

    1   /*
    2    * Copyright 2012 The Netty Project
    3    *
    4    * The Netty Project licenses this file to you under the Apache License,
    5    * version 2.0 (the "License"); you may not use this file except in compliance
    6    * with the 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
    19  /**
    20   * Enables a {@link ChannelHandler} to interact with its {@link ChannelPipeline}
    21   * and other handlers.  A handler can send a {@link ChannelEvent} upstream or
    22   * downstream, modify the {@link ChannelPipeline} it belongs to dynamically.
    23   *
    24   * <h3>Sending an event</h3>
    25   *
    26   * You can send or forward a {@link ChannelEvent} to the closest handler in the
    27   * same {@link ChannelPipeline} by calling {@link #sendUpstream(ChannelEvent)}
    28   * or {@link #sendDownstream(ChannelEvent)}.  Please refer to
    29   * {@link ChannelPipeline} to understand how an event flows.
    30   *
    31   * <h3>Modifying a pipeline</h3>
    32   *
    33   * You can get the {@link ChannelPipeline} your handler belongs to by calling
    34   * {@link #getPipeline()}.  A non-trivial application could insert, remove, or
    35   * replace handlers in the pipeline dynamically in runtime.
    36   *
    37   * <h3>Retrieving for later use</h3>
    38   *
    39   * You can keep the {@link ChannelHandlerContext} for later use, such as
    40   * triggering an event outside the handler methods, even from a different thread.
    41   * <pre>
    42   * public class MyHandler extends {@link SimpleChannelHandler}
    43   *                        implements {@link LifeCycleAwareChannelHandler} {
    44   *
    45   *     <b>private {@link ChannelHandlerContext} ctx;</b>
    46   *
    47   *     public void beforeAdd({@link ChannelHandlerContext} ctx) {
    48   *         <b>this.ctx = ctx;</b>
    49   *     }
    50   *
    51   *     public void login(String username, password) {
    52   *         {@link Channels}.write(
    53   *                 <b>this.ctx</b>,
    54   *                 {@link Channels}.succeededFuture(<b>this.ctx.getChannel()</b>),
    55   *                 new LoginMessage(username, password));
    56   *     }
    57   *     ...
    58   * }
    59   * </pre>
    60   *
    61   * <h3>Storing stateful information</h3>
    62   *
    63   * {@link #setAttachment(Object)} and {@link #getAttachment()} allow you to
    64   * store and access stateful information that is related with a handler and its
    65   * context.  Please refer to {@link ChannelHandler} to learn various recommended
    66   * ways to manage stateful information.
    67   *
    68   * <h3>A handler can have more than one context</h3>
    69   *
    70   * Please note that a {@link ChannelHandler} instance can be added to more than
    71   * one {@link ChannelPipeline}.  It means a single {@link ChannelHandler}
    72   * instance can have more than one {@link ChannelHandlerContext} and therefore
    73   * the single instance can be invoked with different
    74   * {@link ChannelHandlerContext}s if it is added to one or more
    75   * {@link ChannelPipeline}s more than once.
    76   * <p>
    77   * For example, the following handler will have as many independent attachments
    78   * as how many times it is added to pipelines, regardless if it is added to the
    79   * same pipeline multiple times or added to different pipelines multiple times:
    80   * <pre>
    81   * public class FactorialHandler extends {@link SimpleChannelHandler} {
    82   *
    83   *   // This handler will receive a sequence of increasing integers starting
    84   *   // from 1.
    85   *   {@code @Override}
    86   *   public void messageReceived({@link ChannelHandlerContext} ctx, {@link MessageEvent} evt) {
    87   *     Integer a = (Integer) ctx.getAttachment();
    88   *     Integer b = (Integer) evt.getMessage();
    89   *
    90   *     if (a == null) {
    91   *       a = 1;
    92   *     }
    93   *
    94   *     ctx.setAttachment(Integer.valueOf(a * b));
    95   *   }
    96   * }
    97   *
    98   * // Different context objects are given to "f1", "f2", "f3", and "f4" even if
    99   * // they refer to the same handler instance.  Because the FactorialHandler
    100  * // stores its state in a context object (as an attachment), the factorial is
    101  * // calculated correctly 4 times once the two pipelines (p1 and p2) are active.
    102  * FactorialHandler fh = new FactorialHandler();
    103  *
    104  * {@link ChannelPipeline} p1 = {@link Channels}.pipeline();
    105  * p1.addLast("f1", fh);
    106  * p1.addLast("f2", fh);
    107  *
    108  * {@link ChannelPipeline} p2 = {@link Channels}.pipeline();
    109  * p2.addLast("f3", fh);
    110  * p2.addLast("f4", fh);
    111  * </pre>
    112  *
    113  * <h3>Additional resources worth reading</h3>
    114  * <p>
    115  * Please refer to the {@link ChannelHandler}, {@link ChannelEvent}, and
    116  * {@link ChannelPipeline} to find out what a upstream event and a downstream
    117  * event are, what fundamental differences they have, how they flow in a
    118  * pipeline,  and how to handle the event in your application.
    119  *
    120  * @apiviz.owns org.jboss.netty.channel.ChannelHandler
    121  */
    122 public interface ChannelHandlerContext {
    123
    124     /**
    125      * Returns the {@link Channel} that the {@link ChannelPipeline} belongs to.
    126      * This method is a shortcut to <tt>getPipeline().getChannel()</tt>.
    127      */
    128     Channel getChannel();
    129
    130     /**
    131      * Returns the {@link ChannelPipeline} that the {@link ChannelHandler}
    132      * belongs to.
    133      */
    134     ChannelPipeline getPipeline();
    135
    136     /**
    137      * Returns the name of the {@link ChannelHandler} in the
    138      * {@link ChannelPipeline}.
    139      */
    140     String getName();
    141
    142     /**
    143      * Returns the {@link ChannelHandler} that this context object is
    144      * serving.
    145      */
    146     ChannelHandler getHandler();
    147
    148     /**
    149      * Returns {@code true} if and only if the {@link ChannelHandler} is an
    150      * instance of {@link ChannelUpstreamHandler}.
    151      */
    152     boolean canHandleUpstream();
    153
    154     /**
    155      * Returns {@code true} if and only if the {@link ChannelHandler} is an
    156      * instance of {@link ChannelDownstreamHandler}.
    157      */
    158     boolean canHandleDownstream();
    159
    160     /**
    161      * Sends the specified {@link ChannelEvent} to the
    162      * {@link ChannelUpstreamHandler} which is placed in the closest upstream
    163      * from the handler associated with this context.  It is recommended to use
    164      * the shortcut methods in {@link Channels} rather than calling this method
    165      * directly.
    166      */
    167     void sendUpstream(ChannelEvent e);
    168
    169     /**
    170      * Sends the specified {@link ChannelEvent} to the
    171      * {@link ChannelDownstreamHandler} which is placed in the closest
    172      * downstream from the handler associated with this context.  It is
    173      * recommended to use the shortcut methods in {@link Channels} rather than
    174      * calling this method directly.
    175      */
    176     void sendDownstream(ChannelEvent e);
    177
    178     /**
    179      * Retrieves an object which is {@link #setAttachment(Object) attached} to
    180      * this context.
    181      *
    182      * @return {@code null} if no object was attached or
    183      *                      {@code null} was attached
    184      */
    185     Object getAttachment();
    186
    187     /**
    188      * Attaches an object to this context to store a stateful information
    189      * specific to the {@link ChannelHandler} which is associated with this
    190      * context.
    191      */
    192     void setAttachment(Object attachment);
    193 }