/* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package io.netty.channel; import io.netty.util.Attribute; import io.netty.util.AttributeKey; import io.netty.util.AttributeMap; import io.netty.util.concurrent.EventExecutor; import java.nio.channels.Channels; /** * Enables a {@link ChannelHandler} to interact with its {@link ChannelPipeline} * and other handlers. A handler can notify the next {@link ChannelHandler} in the {@link ChannelPipeline}, * modify the {@link ChannelPipeline} it belongs to dynamically. * *
* public class MyHandler extends {@link ChannelDuplexHandler} { * * private {@link ChannelHandlerContext} ctx; * * public void beforeAdd({@link ChannelHandlerContext} ctx) { * this.ctx = ctx; * } * * public void login(String username, password) { * ctx.write(new LoginMessage(username, password)); * } * ... * } ** *
* For example, the following handler will have as many independent attachments * as how many times it is added to pipelines, regardless if it is added to the * same pipeline multiple times or added to different pipelines multiple times: *
* public class FactorialHandler extends {@link ChannelInboundHandlerAdapter}<{@link Integer}> { * * private final {@link AttributeKey}<{@link Integer}> counter = * new {@link AttributeKey}<{@link Integer}>("counter"); * * // This handler will receive a sequence of increasing integers starting * // from 1. * {@code @Override} * public void messageReceived({@link ChannelHandlerContext} ctx, {@link Integer} integer) { * {@link Attribute}<{@link Integer}> attr = ctx.getAttr(counter); * Integer a = ctx.getAttr(counter).get(); * * if (a == null) { * a = 1; * } * * attr.set(a * integer)); * } * } * * // Different context objects are given to "f1", "f2", "f3", and "f4" even if * // they refer to the same handler instance. Because the FactorialHandler * // stores its state in a context object (as an attachment), the factorial is * // calculated correctly 4 times once the two pipelines (p1 and p2) are active. * FactorialHandler fh = new FactorialHandler(); * * {@link ChannelPipeline} p1 = {@link Channels}.pipeline(); * p1.addLast("f1", fh); * p1.addLast("f2", fh); * * {@link ChannelPipeline} p2 = {@link Channels}.pipeline(); * p2.addLast("f3", fh); * p2.addLast("f4", fh); ** *
* Please refer to the {@link ChannelHandler}, and * {@link ChannelPipeline} to find out more about inbound and outbound operations, * what fundamental differences they have, how they flow in a pipeline, and how to handle * the operation in your application. */ public interface ChannelHandlerContext extends AttributeMap, ChannelPropertyAccess, ChannelInboundInvoker, ChannelOutboundInvoker { /** * Return the {@link Channel} which is bound to the {@link ChannelHandlerContext}. */ Channel channel(); /** * The {@link EventExecutor} that is used to dispatch the events. This can also be used to directly * submit tasks that get executed in the event loop. For more informations please refer to the * {@link EventExecutor} javadocs. */ EventExecutor executor(); /** * The unique name of the {@link ChannelHandlerContext}.The name was used when then {@link ChannelHandler} * was added to the {@link ChannelPipeline}. This name can also be used to access the registered * {@link ChannelHandler} from the {@link ChannelPipeline}. */ String name(); /** * The {@link ChannelHandler} that is bound this {@link ChannelHandlerContext}. */ ChannelHandler handler(); /** * Return {@code true} if the {@link ChannelHandler} which belongs to this {@link ChannelHandler} was removed * from the {@link ChannelPipeline}. Note that this method is only meant to be called from with in the * {@link EventLoop}. */ boolean isRemoved(); @Override ChannelHandlerContext fireChannelRegistered(); @Override ChannelHandlerContext fireChannelUnregistered(); @Override ChannelHandlerContext fireChannelActive(); @Override ChannelHandlerContext fireChannelInactive(); @Override ChannelHandlerContext fireExceptionCaught(Throwable cause); @Override ChannelHandlerContext fireUserEventTriggered(Object event); @Override ChannelHandlerContext fireMessageReceived(Object msg); @Override ChannelHandlerContext fireMessageReceived(MessageList> msgs); @Override ChannelHandlerContext fireChannelReadSuspended(); @Override ChannelHandlerContext fireChannelWritabilityChanged(); }