NioChannel (Apache Tomcat 8.0.15 API Documentation)

java.lang.Object
- org.apache.tomcat.util.net.NioChannel

All Implemented Interfaces:

Closeable, AutoCloseable, ByteChannel, Channel, ReadableByteChannel, WritableByteChannel

Direct Known Subclasses:

SecureNioChannel
```
public class NioChannel
extends Object
implements ByteChannel
```
Base class for a SocketChannel wrapper used by the endpoint. This way, logic for a SSL socket channel remains the same as for a non SSL, making sure we don't need to code for any exception cases.

Version:

1.0

Field Summary

Fields
Modifier and Type	Field and Description
`protected SecureNioChannel.ApplicationBufferHandler`	`bufHandler`
`protected static ByteBuffer`	`emptyBuf`
`protected NioEndpoint.Poller`	`poller`
`protected SocketChannel`	`sc`
`protected boolean`	`sendFile`
`protected static StringManager`	`sm`

Constructor Summary

Constructors
Constructor and Description

NioChannel(SocketChannel channel, SecureNioChannel.ApplicationBufferHandler bufHandler)

Constructors
Constructor and Description
`NioChannel(SocketChannel channel, SecureNioChannel.ApplicationBufferHandler bufHandler)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`checkInterruptStatus()` This method should be used to check the interrupt status before attempting a write.
`void`	`close()` Closes this channel.
`void`	`close(boolean force)`
`boolean`	`flush(boolean block, Selector s, long timeout)` Returns true if the network buffer has been flushed out and is empty.
`boolean`	`flushOutbound()` Return true if the buffer wrote data
`Object`	`getAttachment(boolean remove)`
`int`	`getBufferSize()`
`SecureNioChannel.ApplicationBufferHandler`	`getBufHandler()`
`SocketChannel`	`getIOChannel()`
`int`	`getOutboundRemaining()`
`NioEndpoint.Poller`	`getPoller()`
`int`	`handshake(boolean read, boolean write)` Performs SSL handshake hence is a no-op for the non-secure implementation.
`boolean`	`isClosing()`
`boolean`	`isHandshakeComplete()`
`boolean`	`isOpen()` Tells whether or not this channel is open.
`boolean`	`isSendFile()`
`int`	`read(ByteBuffer dst)` Reads a sequence of bytes from this channel into the given buffer.
`void`	`reset()` Reset the channel
`void`	`setIOChannel(SocketChannel IOChannel)`
`void`	`setPoller(NioEndpoint.Poller poller)`
`void`	`setSendFile(boolean s)`
`String`	`toString()`
`int`	`write(ByteBuffer src)` Writes a sequence of bytes to this channel from the given buffer.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - sm
```
protected static final StringManager sm
```
  - emptyBuf
```
protected static ByteBuffer emptyBuf
```
  - sc
```
protected SocketChannel sc
```
  - bufHandler
```
protected SecureNioChannel.ApplicationBufferHandler bufHandler
```
  - poller
```
protected NioEndpoint.Poller poller
```
  - sendFile
```
protected boolean sendFile
```
- Constructor Detail
  - NioChannel
```
public NioChannel(SocketChannel channel,
          SecureNioChannel.ApplicationBufferHandler bufHandler)
```
- Method Detail
  - reset
```
public void reset()
           throws IOException
```
    Reset the channel
    
    Throws:
    
    IOException - If a problem was encountered resetting the channel
  - getBufferSize
```
public int getBufferSize()
```
  - flush
```
public boolean flush(boolean block,
            Selector s,
            long timeout)
              throws IOException
```
    Returns true if the network buffer has been flushed out and is empty.
    
    Parameters:
    block - Unused. May be used when overridden
    s - Unused. May be used when overridden
    timeout - Unused. May be used when overridden
    
    Returns:
    Always returns true since there is no network buffer in the regular channel
    
    Throws:
    
    IOException
  - close
```
public void close()
           throws IOException
```
    Closes this channel.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Channel
    
    Throws:
    
    IOException - If an I/O error occurs
  - close
```
public void close(boolean force)
           throws IOException
```
    Throws:
    
    IOException
  - isOpen
```
public boolean isOpen()
```
    Tells whether or not this channel is open.
    
    Specified by:
    
    isOpen in interface Channel
    
    Returns:
    true if, and only if, this channel is open
  - write
```
public int write(ByteBuffer src)
          throws IOException
```
    Writes a sequence of bytes to this channel from the given buffer.
    
    Specified by:
    
    write in interface WritableByteChannel
    
    Parameters:
    src - The buffer from which bytes are to be retrieved
    
    Returns:
    The number of bytes written, possibly zero
    
    Throws:
    
    IOException - If some other I/O error occurs
  - read
```
public int read(ByteBuffer dst)
         throws IOException
```
    Reads a sequence of bytes from this channel into the given buffer.
    
    Specified by:
    
    read in interface ReadableByteChannel
    
    Parameters:
    dst - The buffer into which bytes are to be transferred
    
    Returns:
    The number of bytes read, possibly zero, or -1 if the channel has reached end-of-stream
    
    Throws:
    
    IOException - If some other I/O error occurs
  - getAttachment
```
public Object getAttachment(boolean remove)
```
  - getBufHandler
```
public SecureNioChannel.ApplicationBufferHandler getBufHandler()
```
  - getPoller
```
public NioEndpoint.Poller getPoller()
```
  - getIOChannel
```
public SocketChannel getIOChannel()
```
  - isClosing
```
public boolean isClosing()
```
  - isHandshakeComplete
```
public boolean isHandshakeComplete()
```
  - handshake
```
public int handshake(boolean read,
            boolean write)
              throws IOException
```
    Performs SSL handshake hence is a no-op for the non-secure implementation.
    
    Parameters:
    read - Unused in non-secure implementation
    write - Unused in non-secure implementation
    
    Returns:
    Always returns zero
    
    Throws:
    
    IOException
  - setPoller
```
public void setPoller(NioEndpoint.Poller poller)
```
  - setIOChannel
```
public void setIOChannel(SocketChannel IOChannel)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getOutboundRemaining
```
public int getOutboundRemaining()
```
  - flushOutbound
```
public boolean flushOutbound()
                      throws IOException
```
    Return true if the buffer wrote data
    
    Throws:
    
    IOException
  - isSendFile
```
public boolean isSendFile()
```
  - setSendFile
```
public void setSendFile(boolean s)
```
  - checkInterruptStatus
```
protected void checkInterruptStatus()
                             throws IOException
```
    This method should be used to check the interrupt status before attempting a write. If a thread has been interrupted and the interrupt has not been cleared then an attempt to write to the socket will fail. When this happens the socket is removed from the poller without the socket being selected. This results in a connection limit leak for NIO as the endpoint expects the socket to be selected even in error conditions.
    
    Throws:
    
    IOException

Class NioChannel

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sm

emptyBuf

sc

bufHandler

poller

sendFile

Constructor Detail

NioChannel

Method Detail

reset

getBufferSize

flush

close

close

isOpen

write

read

getAttachment

getBufHandler

getPoller

getIOChannel

isClosing

isHandshakeComplete

handshake

setPoller

setIOChannel

toString

getOutboundRemaining

flushOutbound

isSendFile

setSendFile

checkInterruptStatus