netty学习之Channel接口

来源：互联网发布：java工程师职业寿命编辑：程序博客网时间：2024/05/16 18:59
正如javadoc所说的，一个channel给用户提供下面四个服务：
1. 当前channel的状态，是open还是connected
2. 这个channel的一些配置信息
3. 这个channel所支持的一些io操作
4. 和这个channel相关联的ChannelPipeline
Channel中所有的操作都是异步的，当发生io操作的时候将会返回一个
ChannelFutrue的接口，在这个里面可以处理操作成功、失败、取消后的动作。
在netty里面，随着Channel的创建者的不同可以分成不同的一些channel，比如它可以被ServerSocketChannel的accept之后，返回一个SocketChannel，这个SocketChannel的parent就是ServerSocketChannel了，在netty里面应该有三类Channel，这个会在以后详细讲解。
Channel里面的interestOps的和NIO里面的SelectionKey有点类似，这个会在以后进行详细的说明。
Java代码  
public interface Channel extends Comparable<Channel> {  
  
    /** 
     * The {@link #getInterestOps() interestOps} value which tells that only 
     * read operation has been suspended. 
     */  
    static int OP_NONE = 0;  
  
    /** 
     * The {@link #getInterestOps() interestOps} value which tells that neither 
     * read nor write operation has been suspended. 
     */  
    static int OP_READ = 1;  
  
    /** 
     * The {@link #getInterestOps() interestOps} value which tells that both 
     * read and write operation has been suspended. 
     */  
    static int OP_WRITE = 4;  
  
    /** 
     * The {@link #getInterestOps() interestOps} value which tells that only 
     * write operation has been suspended. 
     */  
    static int OP_READ_WRITE = OP_READ | OP_WRITE;  
  
    /** 
     * Returns the unique integer ID of this channel. 
     */  
    Integer getId();  
  
    /** 
     * Returns the {@link ChannelFactory} which created this channel. 
     */  
    ChannelFactory getFactory();  
  
    /** 
     * Returns the parent of this channel. 
     * 
     * @return the parent channel. 
     *         {@code null} if this channel does not have a parent channel. 
     */  
    Channel getParent();  
  
    /** 
     * Returns the configuration of this channel. 
     */  
    ChannelConfig getConfig();  
  
    /** 
     * Returns the {@link ChannelPipeline} which handles {@link ChannelEvent}s 
     * associated with this channel. 
     */  
    ChannelPipeline getPipeline();  
  
    /** 
     * Returns {@code true} if and only if this channel is open. 
     */  
    boolean isOpen();  
  
    /** 
     * Returns {@code true} if and only if this channel is bound to a 
     * {@linkplain #getLocalAddress() local address}. 
     */  
    boolean isBound();  
  
    /** 
     * Returns {@code true} if and only if this channel is connected to a 
     * {@linkplain #getRemoteAddress() remote address}. 
     */  
    boolean isConnected();  
  
    /** 
     * Returns the local address where this channel is bound to.  The returned 
     * {@link SocketAddress} is supposed to be down-cast into more concrete 
     * type such as {@link InetSocketAddress} to retrieve the detailed 
     * information. 
     * 
     * @return the local address of this channel. 
     *         {@code null} if this channel is not bound. 
     */  
    SocketAddress getLocalAddress();  
  
    /** 
     * Returns the remote address where this channel is connected to.  The 
     * returned {@link SocketAddress} is supposed to be down-cast into more 
     * concrete type such as {@link InetSocketAddress} to retrieve the detailed 
     * information. 
     * 
     * @return the remote address of this channel. 
     *         {@code null} if this channel is not connected. 
     *         If this channel is not connected but it can receive messages 
     *         from arbitrary remote addresses (e.g. {@link DatagramChannel}, 
     *         use {@link MessageEvent#getRemoteAddress()} to determine 
     *         the origination of the received message as this method will 
     *         return {@code null}. 
     */  
    SocketAddress getRemoteAddress();  
  
    /** 
     * Sends a message to this channel asynchronously.    If this channel was 
     * created by a connectionless transport (e.g. {@link DatagramChannel}) 
     * and is not connected yet, you have to call {@link #write(Object, SocketAddress)} 
     * instead.  Otherwise, the write request will fail with 
     * {@link NotYetConnectedException} and an {@code 'exceptionCaught'} event 
     * will be triggered. 
     * 
     * @param message the message to write 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         write request succeeds or fails 
     * 
     * @throws NullPointerException if the specified message is {@code null} 
     */  
    ChannelFuture write(Object message);  
  
    /** 
     * Sends a message to this channel asynchronously.  It has an additional 
     * parameter that allows a user to specify where to send the specified 
     * message instead of this channel's current remote address.  If this 
     * channel was created by a connectionless transport (e.g. {@link DatagramChannel}) 
     * and is not connected yet, you must specify non-null address.  Otherwise, 
     * the write request will fail with {@link NotYetConnectedException} and 
     * an {@code 'exceptionCaught'} event will be triggered. 
     * 
     * @param message       the message to write 
     * @param remoteAddress where to send the specified message. 
     *                      This method is identical to {@link #write(Object)} 
     *                      if {@code null} is specified here. 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         write request succeeds or fails 
     * 
     * @throws NullPointerException if the specified message is {@code null} 
     */  
    ChannelFuture write(Object message, SocketAddress remoteAddress);  
  
    /** 
     * Binds this channel to the specified local address asynchronously. 
     * 
     * @param localAddress where to bind 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         bind request succeeds or fails 
     * 
     * @throws NullPointerException if the specified address is {@code null} 
     */  
    ChannelFuture bind(SocketAddress localAddress);  
  
    /** 
     * Connects this channel to the specified remote address asynchronously. 
     * 
     * @param remoteAddress where to connect 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         connection request succeeds or fails 
     * 
     * @throws NullPointerException if the specified address is {@code null} 
     */  
    ChannelFuture connect(SocketAddress remoteAddress);  
  
    /** 
     * Disconnects this channel from the current remote address asynchronously. 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         disconnection request succeeds or fails 
     */  
    ChannelFuture disconnect();  
  
    /** 
     * Unbinds this channel from the current local address asynchronously. 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         unbind request succeeds or fails 
     */  
    ChannelFuture unbind();  
  
    /** 
     * Closes this channel asynchronously.  If this channel is bound or 
     * connected, it will be disconnected and unbound first.  Once a channel 
     * is closed, it can not be open again.  Calling this method on a closed 
     * channel has no effect.  Please note that this method always returns the 
     * same future instance. 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         close request succeeds or fails 
     */  
    ChannelFuture close();  
  
    /** 
     * Returns the {@link ChannelFuture} which will be notified when this 
     * channel is closed.  This method always returns the same future instance. 
     */  
    ChannelFuture getCloseFuture();  
  
    /** 
     * Returns the current {@code interestOps} of this channel. 
     * 
     * @return {@link #OP_NONE}, {@link #OP_READ}, {@link #OP_WRITE}, or 
     *         {@link #OP_READ_WRITE} 
     */  
    int getInterestOps();  
  
    /** 
     * Returns {@code true} if and only if the I/O thread will read a message 
     * from this channel.  This method is a shortcut to the following code: 
     * <pre> 
     * return (getInterestOps() & OP_READ) != 0; 
     * </pre> 
     */  
    boolean isReadable();  
  
    /** 
     * Returns {@code true} if and only if the I/O thread will perform the 
     * requested write operation immediately.  Any write requests made when 
     * this method returns {@code false} are queued until the I/O thread is 
     * ready to process the queued write requests.  This method is a shortcut 
     * to the following code: 
     * <pre> 
     * return (getInterestOps() & OP_WRITE) == 0; 
     * </pre> 
     */  
    boolean isWritable();  
  
    /** 
     * Changes the {@code interestOps} of this channel asynchronously. 
     * 
     * @param interestOps the new {@code interestOps} 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         {@code interestOps} change request succeeds or fails 
     */  
    ChannelFuture setInterestOps(int interestOps);  
  
    /** 
     * Suspends or resumes the read operation of the I/O thread asynchronously. 
     * This method is a shortcut to the following code: 
     * <pre> 
     * int interestOps = getInterestOps(); 
     * if (readable) { 
     *     setInterestOps(interestOps | OP_READ); 
     * } else { 
     *     setInterestOps(interestOps & ~OP_READ); 
     * } 
     * </pre> 
     * 
     * @param readable {@code true} to resume the read operation and 
     *                 {@code false} to suspend the read operation 
     * 
     * @return the {@link ChannelFuture} which will be notified when the 
     *         {@code interestOps} change request succeeds or fails 
     */  
    ChannelFuture setReadable(boolean readable);  
}  
0 0