Java 日看一类（14）之IO包中的EOFException异常类和ExpiringCache内部类

EOFException无引入的包

继承自IOException

类头注释

/**
 * Signals that an end of file or end of stream has been reached
 * unexpectedly during input.
 * <p>
 * This exception is mainly used by data input streams to signal end of
 * stream. Note that many other input operations return a special value on
 * end of stream rather than throwing an exception.
 *
 * @author  Frank Yellin
 * @see     java.io.DataInputStream
 * @see     java.io.IOException
 * @since   JDK1.0
 */

大意如下：

在输入过程中意外到达文件末尾的信号

这个异常主要被数据输入流用来标记流的结束。

注意，其他输入操作返回一个特殊值在流的结束位置而不是抛出该异常

该类含有一个成员变量：序列号

private static final long serialVersionUID = 6433858223774886977L;

该类含有两个方法，均为构造方法：

默认构造方法

public EOFException() {
    super();
}

传入字符串（抛出时显示的字符串）

public EOFException(String s) {
    super(s);
}

异常类子类都比较简单，一目了然

ExpiringCache内部类无继承关系

引入了如下包：

import java.util.Iterator;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.Set;

作为内部类并没有注释和api可以查阅

该类看了下代码大致是做缓存条目记录“保鲜”的

该类含有五个成员变量：

缓冲到期时间

private long millisUntilExpiration;

条目查询表

private Map<String,Entry> map;

查询记数

private int queryCount;

查询溢出上限

private int queryOverflow = 300;

最大条目数

private int MAX_ENTRIES = 200;

该类含有七个方法：

默认构造函数（默认缓冲存在时间）

ExpiringCache() {
    this(30000);
}

构造函数

ExpiringCache(long millisUntilExpiration) {
    this.millisUntilExpiration = millisUntilExpiration;
    map = new LinkedHashMap<String,Entry>() {//初始化查询表
        protected boolean removeEldestEntry(Map.Entry<String,Entry> eldest) {//覆盖旧条目的判断函数
          return size() > MAX_ENTRIES;
        }
      };
}

获得键名对应的键值

synchronized String get(String key) {
    if (++queryCount >= queryOverflow) {//查询次数溢出
        cleanup();//清空查询记录
    }
    Entry entry = entryFor(key);//获得查询值
    if (entry != null) {
        return entry.val();
    }
    return null;
}

向查询表中加入新条目

synchronized void put(String key, String val) {
    if (++queryCount >= queryOverflow) {
        cleanup();
    }
    Entry entry = entryFor(key);
    if (entry != null) {//若该索引值存在就修改该索引对应值
        entry.setTimestamp(System.currentTimeMillis());//刷新时间
        entry.setVal(val);
    } else {//不存在就创建新对应关系
        map.put(key, new Entry(System.currentTimeMillis(), val));
    }
}

清空查询表

synchronized void clear() {
    map.clear();
}

查询键值

private Entry entryFor(String key) {
    Entry entry = map.get(key);
    if (entry != null) {
        long delta = System.currentTimeMillis() - entry.timestamp();//获得存在时间
        if (delta < 0 || delta >= millisUntilExpiration) {//缓存过期判定，过期就清理
            map.remove(key);
            entry = null;
        }
    }
    return entry;
}

清除查询栈（实际是查询表刷新提示，经过一定次数查询后刷新查询表）

private void cleanup() {
    Set<String> keySet = map.keySet();
    // Avoid ConcurrentModificationExceptions
    String[] keys = new String[keySet.size()];
    int i = 0;
    for (String key: keySet) {//获得所有键名
        keys[i++] = key;
    }
    for (int j = 0; j < keys.length; j++) {//清除过期或无效缓存
        entryFor(keys[j]);
    }
    queryCount = 0;
}

含有一个内部静态类（查询条目）

static class Entry {
    private long   timestamp;//条目创建时间
    private String val;//条目的值

    Entry(long timestamp, String val) {
        this.timestamp = timestamp;
        this.val = val;
    }

    long   timestamp()                  { return timestamp;           }
    void   setTimestamp(long timestamp) { this.timestamp = timestamp; }

    String val()                        { return val;                 }
    void   setVal(String val)           { this.val = val;             }
}