AbstractSession (xmemcached 1.4.3 API)

java.lang.Object
- com.google.code.yanf4j.core.impl.AbstractSession

所有已实现的接口:

Session

直接已知子类:

AbstractNioSession
```
public abstract class AbstractSession
extends Object
implements Session
```
Base connection

作者:

dennis

嵌套类概要
- 从接口继承的嵌套类/接口 com.google.code.yanf4j.core.Session
  Session.SessionStatus

字段概要

字段
限定符和类型	字段和说明
`protected ConcurrentHashMap<String,Object>`	`attributes`
`protected boolean`	`closed`
`protected AtomicReference<WriteMessage>`	`currentMessage`
`protected CodecFactory.Decoder`	`decoder`
`protected Dispatcher`	`dispatchMessageDispatcher`
`protected CodecFactory.Encoder`	`encoder`
`protected Handler`	`handler`
`protected boolean`	`handleReadWriteConcurrently`
`AtomicLong`	`lastOperationTimeStamp`
`protected static org.slf4j.Logger`	`log`
`protected boolean`	`loopback`
`protected IoBuffer`	`readBuffer`
`protected AtomicLong`	`scheduleWritenBytes`
`protected long`	`sessionIdleTimeout`
`protected long`	`sessionTimeout`
`protected Statistics`	`statistics`
`protected boolean`	`useBlockingRead`
`protected boolean`	`useBlockingWrite`
`protected ReentrantLock`	`writeLock`
`protected Queue<WriteMessage>`	`writeQueue`

构造器概要

构造器
构造器和说明

AbstractSession(SessionConfig sessionConfig)

构造器
构造器和说明
`AbstractSession(SessionConfig sessionConfig)`

方法概要

方法
限定符和类型	方法和说明
`void`	`clearAttributes()` Clear attributes
`void`	`clearWriteQueue()`
`void`	`close()` Close session
`protected abstract void`	`closeChannel()`
`abstract void`	`decode()`
`protected void`	`dispatchReceivedMessage(Object message)`
`Object`	`getAttribute(String key)` Return attribute associated with key
`CodecFactory.Decoder`	`getDecoder()` Return current decoder
`Dispatcher`	`getDispatchMessageDispatcher()`
`CodecFactory.Encoder`	`getEncoder()` Return current encoder
`Handler`	`getHandler()`
`long`	`getLastOperationTimeStamp()` Return last operation timestamp,operation include read,write,idle
`IoBuffer`	`getReadBuffer()`
`ByteOrder`	`getReadBufferByteOrder()` Return the session read buffer's byte order,big end or little end.
`long`	`getScheduleWritenBytes()` Return the bytes in write queue,there bytes is in memory.Use this method to controll writing speed.
`long`	`getSessionIdleTimeout()`
`long`	`getSessionTimeout()`
`Statistics`	`getStatistics()`
`ReentrantLock`	`getWriteLock()`
`Queue<WriteMessage>`	`getWriteQueue()`
`boolean`	`isClosed()` Check if session is closed
`boolean`	`isExpired()` Return true if session is expired,session is expired beacause you set the sessionTimeout,if since session's last operation form now is over this vlaue,isExpired return true,and Handler.onExpired() will be invoked.
`boolean`	`isHandleReadWriteConcurrently()` Return true if allow handling read and write concurrently,default is true.
`boolean`	`isIdle()` Check if session is idle
`boolean`	`isLoopbackConnection()` return true if it is a loopback connection
`boolean`	`isUseBlockingRead()` Return true if using blocking read
`boolean`	`isUseBlockingWrite()` Return true if using blocking write
`protected void`	`onClosed()`
`protected void`	`onConnected()`
`protected void`	`onCreated()`
`void`	`onException(Throwable e)`
`void`	`onExpired()`
`protected void`	`onIdle()`
`protected void`	`onStarted()`
`protected WriteMessage`	`preprocessWriteMessage(WriteMessage writeMessage)` Pre-Process WriteMessage before writing to channel
`void`	`removeAttribute(String key)` Remove attribute
`void`	`setAttribute(String key, Object value)` Set a attribute attched with this session
`Object`	`setAttributeIfAbsent(String key, Object value)`
`void`	`setClosed(boolean closed)`
`void`	`setDecoder(CodecFactory.Decoder decoder)`
`void`	`setEncoder(CodecFactory.Encoder encoder)` Set encoder
`void`	`setHandleReadWriteConcurrently(boolean handleReadWriteConcurrently)`
`void`	`setReadBuffer(IoBuffer readBuffer)`
`void`	`setReadBufferByteOrder(ByteOrder readBufferByteOrder)`
`void`	`setSessionIdleTimeout(long sessionIdleTimeout)`
`void`	`setSessionTimeout(long sessionTimeout)`
`void`	`setUseBlockingRead(boolean useBlockingRead)`
`void`	`setUseBlockingWrite(boolean useBlockingWrite)` Set if using blocking write
`void`	`start()` Start session
`protected abstract void`	`start0()`
`long`	`transferFrom(long position, long count, FileChannel source)`
`long`	`transferTo(long position, long count, FileChannel target)`
`void`	`updateTimeStamp()`
`protected abstract WriteMessage`	`wrapMessage(Object msg, Future<Boolean> writeFuture)`
`void`	`write(Object packet)` Write a message,if you don't care when the message is written
`abstract void`	`writeFromUserCode(WriteMessage message)`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 com.google.code.yanf4j.core.Session
flush, getLocalAddress, getRemoteSocketAddress

- 字段详细资料
  - readBuffer
```
protected IoBuffer readBuffer
```
  - log
```
protected static final org.slf4j.Logger log
```
  - attributes
```
protected final ConcurrentHashMap<String,Object> attributes
```
  - writeQueue
```
protected Queue<WriteMessage> writeQueue
```
  - sessionIdleTimeout
```
protected volatile long sessionIdleTimeout
```
  - sessionTimeout
```
protected volatile long sessionTimeout
```
  - encoder
```
protected CodecFactory.Encoder encoder
```
  - decoder
```
protected CodecFactory.Decoder decoder
```
  - closed
```
protected volatile boolean closed
```
  - statistics
```
protected Statistics statistics
```
  - handler
```
protected Handler handler
```
  - loopback
```
protected boolean loopback
```
  - lastOperationTimeStamp
```
public AtomicLong lastOperationTimeStamp
```
  - scheduleWritenBytes
```
protected AtomicLong scheduleWritenBytes
```
  - dispatchMessageDispatcher
```
protected final Dispatcher dispatchMessageDispatcher
```
  - useBlockingWrite
```
protected volatile boolean useBlockingWrite
```
  - useBlockingRead
```
protected volatile boolean useBlockingRead
```
  - handleReadWriteConcurrently
```
protected volatile boolean handleReadWriteConcurrently
```
  - writeLock
```
protected ReentrantLock writeLock
```
  - currentMessage
```
protected AtomicReference<WriteMessage> currentMessage
```
- 构造器详细资料
  - AbstractSession
```
public AbstractSession(SessionConfig sessionConfig)
```
- 方法详细资料
  - getSessionIdleTimeout
```
public long getSessionIdleTimeout()
```
    指定者:
    
    getSessionIdleTimeout 在接口中 Session
  - setSessionIdleTimeout
```
public void setSessionIdleTimeout(long sessionIdleTimeout)
```
    指定者:
    
    setSessionIdleTimeout 在接口中 Session
  - getSessionTimeout
```
public long getSessionTimeout()
```
    指定者:
    
    getSessionTimeout 在接口中 Session
  - setSessionTimeout
```
public void setSessionTimeout(long sessionTimeout)
```
    指定者:
    
    setSessionTimeout 在接口中 Session
  - getWriteQueue
```
public Queue<WriteMessage> getWriteQueue()
```
  - getStatistics
```
public Statistics getStatistics()
```
  - getHandler
```
public Handler getHandler()
```
    指定者:
    
    getHandler 在接口中 Session
  - getDispatchMessageDispatcher
```
public Dispatcher getDispatchMessageDispatcher()
```
  - getWriteLock
```
public ReentrantLock getWriteLock()
```
  - decode
```
public abstract void decode()
```
  - updateTimeStamp
```
public void updateTimeStamp()
```
  - getLastOperationTimeStamp
```
public long getLastOperationTimeStamp()
```
    从接口复制的说明: Session
    
    Return last operation timestamp,operation include read,write,idle
    
    指定者:
    
    getLastOperationTimeStamp 在接口中 Session
    
    返回:
  - isHandleReadWriteConcurrently
```
public final boolean isHandleReadWriteConcurrently()
```
    从接口复制的说明: Session
    
    Return true if allow handling read and write concurrently,default is true.
    
    指定者:
    
    isHandleReadWriteConcurrently 在接口中 Session
    
    返回:
  - setHandleReadWriteConcurrently
```
public final void setHandleReadWriteConcurrently(boolean handleReadWriteConcurrently)
```
    指定者:
    
    setHandleReadWriteConcurrently 在接口中 Session
  - getScheduleWritenBytes
```
public long getScheduleWritenBytes()
```
    从接口复制的说明: Session
    
    Return the bytes in write queue,there bytes is in memory.Use this method to controll writing speed.
    
    指定者:
    
    getScheduleWritenBytes 在接口中 Session
    
    返回:
  - getEncoder
```
public CodecFactory.Encoder getEncoder()
```
    从接口复制的说明: Session
    
    Return current encoder
    
    指定者:
    
    getEncoder 在接口中 Session
    
    返回:
  - setEncoder
```
public void setEncoder(CodecFactory.Encoder encoder)
```
    从接口复制的说明: Session
    
    Set encoder
    
    指定者:
    
    setEncoder 在接口中 Session
  - getDecoder
```
public CodecFactory.Decoder getDecoder()
```
    从接口复制的说明: Session
    
    Return current decoder
    
    指定者:
    
    getDecoder 在接口中 Session
    
    返回:
  - getReadBuffer
```
public IoBuffer getReadBuffer()
```
  - setReadBuffer
```
public void setReadBuffer(IoBuffer readBuffer)
```
  - setDecoder
```
public void setDecoder(CodecFactory.Decoder decoder)
```
    指定者:
    
    setDecoder 在接口中 Session
  - getReadBufferByteOrder
```
public final ByteOrder getReadBufferByteOrder()
```
    从接口复制的说明: Session
    
    Return the session read buffer's byte order,big end or little end.
    
    指定者:
    
    getReadBufferByteOrder 在接口中 Session
    
    返回:
  - setReadBufferByteOrder
```
public final void setReadBufferByteOrder(ByteOrder readBufferByteOrder)
```
    指定者:
    
    setReadBufferByteOrder 在接口中 Session
  - onIdle
```
protected void onIdle()
```
  - onConnected
```
protected void onConnected()
```
  - onExpired
```
public void onExpired()
```
  - wrapMessage
```
protected abstract WriteMessage wrapMessage(Object msg,
                       Future<Boolean> writeFuture)
```
  - preprocessWriteMessage
```
protected WriteMessage preprocessWriteMessage(WriteMessage writeMessage)
```
    Pre-Process WriteMessage before writing to channel
    
    参数:
    writeMessage -
    
    返回:
  - dispatchReceivedMessage
```
protected void dispatchReceivedMessage(Object message)
```
  - isClosed
```
public final boolean isClosed()
```
    从接口复制的说明: Session
    
    Check if session is closed
    
    指定者:
    
    isClosed 在接口中 Session
    
    返回:
  - setClosed
```
public final void setClosed(boolean closed)
```
  - close
```
public void close()
```
    从接口复制的说明: Session
    
    Close session
    
    指定者:
    
    close 在接口中 Session
  - closeChannel
```
protected abstract void closeChannel()
                              throws IOException
```
    抛出:
    
    IOException
  - onException
```
public void onException(Throwable e)
```
  - onClosed
```
protected void onClosed()
```
  - setAttribute
```
public void setAttribute(String key,
                Object value)
```
    从接口复制的说明: Session
    
    Set a attribute attched with this session
    
    指定者:
    
    setAttribute 在接口中 Session
  - setAttributeIfAbsent
```
public Object setAttributeIfAbsent(String key,
                          Object value)
```
    指定者:
    
    setAttributeIfAbsent 在接口中 Session
  - removeAttribute
```
public void removeAttribute(String key)
```
    从接口复制的说明: Session
    
    Remove attribute
    
    指定者:
    
    removeAttribute 在接口中 Session
  - getAttribute
```
public Object getAttribute(String key)
```
    从接口复制的说明: Session
    
    Return attribute associated with key
    
    指定者:
    
    getAttribute 在接口中 Session
    
    返回:
  - clearAttributes
```
public void clearAttributes()
```
    从接口复制的说明: Session
    
    Clear attributes
    
    指定者:
    
    clearAttributes 在接口中 Session
  - start
```
public void start()
```
    从接口复制的说明: Session
    
    Start session
    
    指定者:
    
    start 在接口中 Session
  - start0
```
protected abstract void start0()
```
  - onStarted
```
protected void onStarted()
```
  - write
```
public void write(Object packet)
```
    从接口复制的说明: Session
    
    Write a message,if you don't care when the message is written
    
    指定者:
    
    write 在接口中 Session
  - writeFromUserCode
```
public abstract void writeFromUserCode(WriteMessage message)
```
  - isLoopbackConnection
```
public final boolean isLoopbackConnection()
```
    从接口复制的说明: Session
    
    return true if it is a loopback connection
    
    指定者:
    
    isLoopbackConnection 在接口中 Session
    
    返回:
  - isUseBlockingWrite
```
public boolean isUseBlockingWrite()
```
    从接口复制的说明: Session
    
    Return true if using blocking write
    
    指定者:
    
    isUseBlockingWrite 在接口中 Session
    
    返回:
  - setUseBlockingWrite
```
public void setUseBlockingWrite(boolean useBlockingWrite)
```
    从接口复制的说明: Session
    
    Set if using blocking write
    
    指定者:
    
    setUseBlockingWrite 在接口中 Session
  - isUseBlockingRead
```
public boolean isUseBlockingRead()
```
    从接口复制的说明: Session
    
    Return true if using blocking read
    
    指定者:
    
    isUseBlockingRead 在接口中 Session
    
    返回:
  - setUseBlockingRead
```
public void setUseBlockingRead(boolean useBlockingRead)
```
    指定者:
    
    setUseBlockingRead 在接口中 Session
  - clearWriteQueue
```
public void clearWriteQueue()
```
  - isExpired
```
public boolean isExpired()
```
    从接口复制的说明: Session
    
    Return true if session is expired,session is expired beacause you set the sessionTimeout,if since session's last operation form now is over this vlaue,isExpired return true,and Handler.onExpired() will be invoked.
    
    指定者:
    
    isExpired 在接口中 Session
    
    返回:
  - isIdle
```
public boolean isIdle()
```
    从接口复制的说明: Session
    
    Check if session is idle
    
    指定者:
    
    isIdle 在接口中 Session
    
    返回:
  - transferTo
```
public long transferTo(long position,
              long count,
              FileChannel target)
                throws IOException
```
    抛出:
    
    IOException
  - transferFrom
```
public long transferFrom(long position,
                long count,
                FileChannel source)
                  throws IOException
```
    抛出:
    
    IOException
  - onCreated
```
protected void onCreated()
```

类 AbstractSession

嵌套类概要

从接口继承的嵌套类/接口 com.google.code.yanf4j.core.Session

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 com.google.code.yanf4j.core.Session

字段详细资料

readBuffer

log

attributes

writeQueue

sessionIdleTimeout

sessionTimeout

encoder

decoder

closed

statistics

handler

loopback

lastOperationTimeStamp

scheduleWritenBytes

dispatchMessageDispatcher

useBlockingWrite

useBlockingRead

handleReadWriteConcurrently

writeLock

currentMessage

构造器详细资料

AbstractSession

方法详细资料

getSessionIdleTimeout

setSessionIdleTimeout

getSessionTimeout

setSessionTimeout

getWriteQueue

getStatistics

getHandler

getDispatchMessageDispatcher

getWriteLock

decode

updateTimeStamp

getLastOperationTimeStamp

isHandleReadWriteConcurrently

setHandleReadWriteConcurrently

getScheduleWritenBytes

getEncoder

setEncoder

getDecoder

getReadBuffer

setReadBuffer

setDecoder

getReadBufferByteOrder

setReadBufferByteOrder

onIdle

onConnected

onExpired

wrapMessage

preprocessWriteMessage

dispatchReceivedMessage

isClosed

setClosed

close

closeChannel

onException

onClosed

setAttribute

setAttributeIfAbsent

removeAttribute

getAttribute

clearAttributes

start

start0

onStarted

write

writeFromUserCode

isLoopbackConnection

isUseBlockingWrite

setUseBlockingWrite