AbstractCache (mica-net-utils 0.0.9 API)

java.lang.Object
- org.tio.utils.cache.AbstractCache<K,V>

类型参数:

K - 键类型

V - 值类型

所有已实现的接口:

Serializable, Cache<K,V>

直接已知子类:

StampedCache
```
public abstract class AbstractCache<K extends Serializable,V extends Serializable>
extends Object
implements Cache<K,V>
```
超时和限制大小的缓存的默认实现
继承此抽象缓存需要：
- 创建一个新的Map
- 实现 prune 策略
作者:

Looly, jodd

另请参阅:

序列化表格

字段概要

字段
限定符和类型	字段和说明
`protected boolean`	`existCustomTimeout` 每个对象是否有单独的失效时长，用于决定清理过期对象是否有必要。
`protected LongAdder`	`hitCount` 命中数，即命中缓存计数
`protected ConcurrentHashMap<K,Lock>`	`keyLockMap` 写的时候每个key一把锁，降低锁的粒度
`protected CacheListener<K,V>`	`listener` 缓存监听
`protected LongAdder`	`missCount` 丢失数，即未命中缓存计数

方法概要

所有方法实例方法抽象方法具体方法
限定符和类型	方法和说明
`protected Iterator<CacheObj<K,V>>`	`cacheObjIter()` 获取所有`CacheObj`值的`Iterator`形式
`int`	`capacity()` 返回缓存容量，`0`表示无大小限制
`void`	`clear()` 清空缓存
`V`	`get(K key, boolean isUpdateLastAccess, Supplier<V> supplier)` 从缓存中获得对象，当对象不在缓存中或已经过期返回Func0回调产生的对象调用此方法时，会检查上次调用时间，如果与当前时间差值大于超时时间返回`null`，否则返回值。
`long`	`getHitCount()`
`long`	`getMissCount()`
`protected CacheObj<K,V>`	`getWithoutLock(K key)` 获取键对应的`CacheObj`
`boolean`	`isEmpty()` 缓存是否为空
`boolean`	`isFull()` 缓存是否已满，仅用于有空间限制的缓存对象
`protected boolean`	`isPruneExpiredActive()` 只有设置公共缓存失效时长或每个对象单独的失效时长时清理可用
`Set<K>`	`keySet()` 返回所有键
`protected void`	`onRemove(K key, V cachedObject)` 对象移除回调。
`protected abstract int`	`pruneCache()` 清理实现子类实现此方法时无需加锁
`void`	`put(K key, V object)` 将对象加入到缓存，使用默认失效时长
`protected void`	`putWithoutLock(K key, V object, long timeout)` 加入元素，无锁
`protected CacheObj<K,V>`	`removeWithoutLock(K key, boolean withMissCount)` 移除key对应的对象，不加锁
`AbstractCache<K,V>`	`setListener(CacheListener<K,V> listener)` 设置监听
`int`	`size()` 缓存的对象数量
`long`	`timeout()` 缓存失效时长， `0` 表示没有设置，单位毫秒
`String`	`toString()`

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

从接口继承的方法 org.tio.utils.cache.Cache
containsKey, get, get, get, prune, put, remove

- 字段详细资料
  - keyLockMap
```
protected final ConcurrentHashMap<K extends Serializable,Lock> keyLockMap
```
    写的时候每个key一把锁，降低锁的粒度
  - existCustomTimeout
```
protected boolean existCustomTimeout
```
    每个对象是否有单独的失效时长，用于决定清理过期对象是否有必要。
  - hitCount
```
protected LongAdder hitCount
```
    命中数，即命中缓存计数
  - missCount
```
protected LongAdder missCount
```
    丢失数，即未命中缓存计数
  - listener
```
protected transient CacheListener<K extends Serializable,V extends Serializable> listener
```
    缓存监听
- 方法详细资料
  - put
```
public void put(K key,
                V object)
```
    从接口复制的说明: Cache
    
    将对象加入到缓存，使用默认失效时长
    
    指定者:
    
    put 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    参数:
    
    key - 键
    
    object - 缓存的对象
    
    另请参阅:
    
    Cache#put(Object, Object, long)
  - putWithoutLock
```
protected void putWithoutLock(K key,
                              V object,
                              long timeout)
```
    加入元素，无锁
    
    参数:
    
    key - 键
    
    object - 值
    
    timeout - 超时时长
    
    从以下版本开始:
    
    4.5.16
  - getHitCount
```
public long getHitCount()
```
    返回:
    
    命中数
  - getMissCount
```
public long getMissCount()
```
    返回:
    
    丢失数
  - get
```
public V get(K key,
             boolean isUpdateLastAccess,
             Supplier<V> supplier)
```
    从接口复制的说明: Cache
    
    从缓存中获得对象，当对象不在缓存中或已经过期返回Func0回调产生的对象
    调用此方法时，会检查上次调用时间，如果与当前时间差值大于超时时间返回null，否则返回值。
    每次调用此方法会可选是否刷新最后访问时间，true表示会重新计算超时时间。
    
    指定者:
    
    get 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    参数:
    
    key - 键
    
    isUpdateLastAccess - 是否更新最后访问时间，即重新计算超时时间。
    
    supplier - 如果不存在回调方法，用于生产值对象
    
    返回:
    
    值对象
  - getWithoutLock
```
protected CacheObj<K,V> getWithoutLock(K key)
```
    获取键对应的CacheObj
    
    参数:
    
    key - 键
    
    返回:
    
    CacheObj
  - pruneCache
```
protected abstract int pruneCache()
```
    清理实现
    子类实现此方法时无需加锁
    
    返回:
    
    清理数
  - capacity
```
public int capacity()
```
    从接口复制的说明: Cache
    
    返回缓存容量，0表示无大小限制
    
    指定者:
    
    capacity 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    返回:
    
    返回缓存容量，0表示无大小限制
  - timeout
```
public long timeout()
```
    从接口复制的说明: Cache
    
    缓存失效时长， 0 表示没有设置，单位毫秒
    
    指定者:
    
    timeout 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    返回:
    
    默认缓存失效时长。
    每个对象可以单独设置失效时长
  - isPruneExpiredActive
```
protected boolean isPruneExpiredActive()
```
    只有设置公共缓存失效时长或每个对象单独的失效时长时清理可用
    
    返回:
    
    过期对象清理是否可用，内部使用
  - isFull
```
public boolean isFull()
```
    从接口复制的说明: Cache
    
    缓存是否已满，仅用于有空间限制的缓存对象
    
    指定者:
    
    isFull 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    返回:
    
    缓存是否已满，仅用于有空间限制的缓存对象
  - clear
```
public void clear()
```
    从接口复制的说明: Cache
    
    清空缓存
    
    指定者:
    
    clear 在接口中 Cache<K extends Serializable,V extends Serializable>
  - size
```
public int size()
```
    从接口复制的说明: Cache
    
    缓存的对象数量
    
    指定者:
    
    size 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    返回:
    
    缓存的对象数量
  - isEmpty
```
public boolean isEmpty()
```
    从接口复制的说明: Cache
    
    缓存是否为空
    
    指定者:
    
    isEmpty 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    返回:
    
    缓存是否为空
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - setListener
```
public AbstractCache<K,V> setListener(CacheListener<K,V> listener)
```
    设置监听
    
    指定者:
    
    setListener 在接口中 Cache<K extends Serializable,V extends Serializable>
    
    参数:
    
    listener - 监听
    
    返回:
    
    this
  - keySet
```
public Set<K> keySet()
```
    返回所有键
    
    返回:
    
    所有键
    
    从以下版本开始:
    
    5.5.9
  - onRemove
```
protected void onRemove(K key,
                        V cachedObject)
```
    对象移除回调。默认无动作
    子类可重写此方法用于监听移除事件，如果重写，listener将无效
    
    参数:
    
    key - 键
    
    cachedObject - 被缓存的对象
  - removeWithoutLock
```
protected CacheObj<K,V> removeWithoutLock(K key,
                                          boolean withMissCount)
```
    移除key对应的对象，不加锁
    
    参数:
    
    key - 键
    
    withMissCount - 是否计数丢失数
    
    返回:
    
    移除的对象，无返回null
  - cacheObjIter
```
protected Iterator<CacheObj<K,V>> cacheObjIter()
```
    获取所有CacheObj值的Iterator形式
    
    返回:
    
    Iterator

类 AbstractCache<K extends Serializable,V extends Serializable>

字段概要

方法概要

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

从接口继承的方法 org.tio.utils.cache.Cache

字段详细资料

keyLockMap

existCustomTimeout

hitCount

missCount

listener

方法详细资料

put

putWithoutLock

getHitCount

getMissCount

get

getWithoutLock

pruneCache

capacity

timeout

isPruneExpiredActive

isFull

clear

size

isEmpty

toString

setListener

keySet

onRemove

removeWithoutLock

cacheObjIter