Jetty9 源碼初解(2)——IO之EndPoint

1、概述

EndPoint做爲jetty-io的一個重要組成部分，是基於javaNIO的封裝，用於底層網絡的讀寫，一旦網絡讀寫準備好，會調用相應的connection的handle方法。

2、類分析

EndPoint源碼以下：

/**
 *
 * 一個傳輸端點
 *
 * <h3>異步方法</h3>
 */
public interface EndPoint extends Closeable
{
    /* ------------------------------------------------------------ */
    /**
     * @return <code>EndPoint</code>綁定的本地Inet地址，若是<code>EndPoint</code>沒有網絡鏈接則爲<code>null</code>
     */
    InetSocketAddress getLocalAddress();

    /* ------------------------------------------------------------ */
    /**
     * @return 上面方法的遠程封裝
     */
    InetSocketAddress getRemoteAddress();

    /* ------------------------------------------------------------ */
    boolean isOpen();

    /* ------------------------------------------------------------ */
    long getCreatedTimeStamp();

    /* ------------------------------------------------------------ */
    /** Shutdown the output.
     * <p>在該endpoint遠程結束須要讀取一次EOF時調用，意味着數據傳輸完畢了。可能在TCP/IP級別
     * 或是協議交換時關閉。
     * <p>
     * If the endpoint has {@link #isInputShutdown()} true, then this call has the same effect
     * as {@link #close()}.
     */
    void shutdownOutput();

    /* ------------------------------------------------------------ */
    /** Test if output is shutdown.
     * The output is shutdown by a call to {@link #shutdownOutput()}
     * or {@link #close()}.
     * @return true if the output is shutdown or the endpoint is closed.
     */
    boolean isOutputShutdown();

    /* ------------------------------------------------------------ */
    /** Test if the input is shutdown.
     * The input is shutdown if an EOF has been read while doing
     * a {@link #fill(ByteBuffer)}.   Once the input is shutdown, all calls to
     * {@link #fill(ByteBuffer)} will  return -1, until such time as the
     * end point is close, when they will return {@link EofException}.
     * @return True if the input is shutdown or the endpoint is closed.
     */
    boolean isInputShutdown();

    /**
     * Close any backing stream associated with the endpoint
     */
    @Override
    void close();

    /**
     * Fill the passed buffer with data from this endpoint.  The bytes are appended to any
     * data already in the buffer by writing from the buffers limit up to it's capacity.
     * The limit is updated to include the filled bytes.
     *
     * @param buffer The buffer to fill. The position and limit are modified during the fill. After the
     * operation, the position is unchanged and the limit is increased to reflect the new data filled.
     * @return an <code>int</code> value indicating the number of bytes
     * filled or -1 if EOF is read or the input is shutdown.
     * @throws IOException if the endpoint is closed.
     */
    int fill(ByteBuffer buffer) throws IOException;


    /**
     * Flush data from the passed header/buffer to this endpoint.  As many bytes as can be consumed
     * are taken from the header/buffer position up until the buffer limit.  The header/buffers position
     * is updated to indicate how many bytes have been consumed.
     * @param buffer the buffers to flush
     * @return True IFF all the buffers have been consumed and the endpoint has flushed the data to its
     * destination (ie is not buffering any data).
     * @throws IOException If the endpoint is closed or output is shutdown.
     */
    boolean flush(ByteBuffer... buffer) throws IOException;

    /* ------------------------------------------------------------ */
    /**
     * @return The underlying transport object (socket, channel, etc.)
     */
    Object getTransport();

    /* ------------------------------------------------------------ */
    /** Get the max idle time in ms.
     * <p>The max idle time is the time the endpoint can be idle before
     * extraordinary handling takes place.
     * @return the max idle time in ms or if ms &lt;= 0 implies an infinite timeout
     */
    long getIdleTimeout();

    /* ------------------------------------------------------------ */
    /** Set the idle timeout.
     * @param idleTimeout the idle timeout in MS. Timeout &lt;= 0 implies an infinite timeout
     */
    void setIdleTimeout(long idleTimeout);


    /**
     * <p>Requests callback methods to be invoked when a call to {@link #fill(ByteBuffer)} would return data or EOF.</p>
     *
     * @param callback the callback to call when an error occurs or we are readable.
     * @throws ReadPendingException if another read operation is concurrent.
     */
    void fillInterested(Callback callback) throws ReadPendingException;

    /**
     * @return whether {@link #fillInterested(Callback)} has been called, but {@link #fill(ByteBuffer)} has not yet
     * been called
     */
    boolean isFillInterested();

    /**
     * <p>Writes the given buffers via {@link #flush(ByteBuffer...)} and invokes callback methods when either
     * all the data has been flushed or an error occurs.</p>
     *
     * @param callback the callback to call when an error occurs or the write completed.
     * @param buffers one or more {@link ByteBuffer}s that will be flushed.
     * @throws WritePendingException if another write operation is concurrent.
     */
    void write(Callback callback, ByteBuffer... buffers) throws WritePendingException;

    /**
     * @return the {@link Connection} associated with this {@link EndPoint}
     * @see #setConnection(Connection)
     */
    Connection getConnection();

    /**
     * @param connection the {@link Connection} associated with this {@link EndPoint}
     * @see #getConnection()
     * @see #upgrade(Connection)
     */
    void setConnection(Connection connection);

    /**
     * <p>Callback method invoked when this {@link EndPoint} is opened.</p>
     * @see #onClose()
     */
    void onOpen();

    /**
     * <p>Callback method invoked when this {@link EndPoint} is close.</p>
     * @see #onOpen()
     */
    void onClose();

    /** Is the endpoint optimized for DirectBuffer usage
     * @return True if direct buffers can be used optimally.
     */
    boolean isOptimizedForDirectBuffers();


    /** Upgrade connections.
     * Close the old connection, update the endpoint and open the new connection.
     * If the oldConnection is an instance of {@link Connection.UpgradeFrom} then
     * a prefilled buffer is requested and passed to the newConnection if it is an instance
     * of {@link Connection.UpgradeTo}
     * @param newConnection The connection to upgrade to
     */
    public void upgrade(Connection newConnection);
}

EndPoint使用fill(Buffer buffer)方法進行數據寫入，做爲Connection的一個端點，用於存放內容信息。