官方的解释这个类为：
/**
* A simple, durable, atomic K/V database. *Very inefficient*, should only be
* used for occasional reads/writes. Every read/write hits disk.
*/
简单来理解就是这个类每次读写都会将一个Map<Object, Object>的对象序列化存储到磁盘中，读的时候将其反序列化。
构造函数指定的参数就是你在磁盘中存储的目录，同时也作为VersionedStore的构造函数的参数。
这些文件在目录中是以一个long类型的id进行命名
public LocalState(String backingDir) throws IOException {
_vs = new VersionedStore(backingDir);
}
snapshot函数，找到最近的版本，将其反序列化
public synchronized Map<Object, Object> snapshot() throws IOException {
int attempts = 0;
while (true) {
String latestPath = _vs.mostRecentVersionPath(); //获取最近的版本
if (latestPath == null)
return new HashMap<Object, Object>();
try {
return (Map<Object, Object>) Utils.deserialize(FileUtils
.readFileToByteArray(new File(latestPath)));
} catch (IOException e) {
attempts++;
if (attempts >= 10) {
throw e;
}
}
}
}
public Object get(Object key) throws IOException {
return snapshot().get(key);
}
public synchronized void put(Object key, Object val) throws IOException {
put(key, val, true);
}
public synchronized void put(Object key, Object val, boolean cleanup)
throws IOException {
Map<Object, Object> curr = snapshot();
curr.put(key, val);
persist(curr, cleanup); //persist会将其写入到磁盘中
}
public synchronized void remove(Object key) throws IOException {
remove(key, true);
}
public synchronized void remove(Object key, boolean cleanup)
throws IOException {
Map<Object, Object> curr = snapshot();
curr.remove(key);
persist(curr, cleanup);
}
public synchronized void cleanup(int keepVersions) throws IOException {
_vs.cleanup(keepVersions);
}
可以看到，基本暴露的接口都通过synchronized关键字来保证串行化的操作，同时多次调用了以下的persist方法，
private void persist(Map<Object, Object> val, boolean cleanup)
throws IOException {
byte[] toWrite = Utils.serialize(val);
String newPath = _vs.createVersion(); //创建一个新的版本号
FileUtils.writeByteArrayToFile(new File(newPath), toWrite);
_vs.succeedVersion(newPath); //如果写入成功，那么会生成 id.version 文件来声明该文件写入成功
if (cleanup)
_vs.cleanup(4); //默认保留4个版本
}
接下来看看VersionedStore这个类，它是进行实际存储操作的类，提供了接口给LocalState
public void succeedVersion(String path) throws IOException {
long version = validateAndGetVersion(path); //验证一下这个文件是否存在
// should rewrite this to do a file move
createNewFile(tokenPath(version)); //创建对应的 id.version 文件说明写入成功
}
path的值是一个long类型的id，表示对应的文件
private long validateAndGetVersion(String path) {
Long v = parseVersion(path);
if (v == null)
throw new RuntimeException(path + " is not a valid version");
return v;
}
//解析出版本号，如果以.version结尾的，去掉.version
private Long parseVersion(String path) {
String name = new File(path).getName();
if (name.endsWith(FINISHED_VERSION_SUFFIX)) {
name = name.substring(0,
name.length() - FINISHED_VERSION_SUFFIX.length());
}
try {
return Long.parseLong(name);
} catch (NumberFormatException e) {
return null;
}
}
createNewFile(tokenPath(version)); //创建对应的 id.version 文件说明写入成功
token file就是一种标志文件，用于标志对应的文件已经写入成功，以.version 结尾
private String tokenPath(long version) {
return new File(_root, "" + version + FINISHED_VERSION_SUFFIX)
.getAbsolutePath();
}
private void createNewFile(String path) throws IOException {
new File(path).createNewFile();
}
cleanup函数，保留versionsToKeep版本，清除其他的版本
public void cleanup(int versionsToKeep) throws IOException {
List<Long> versions = getAllVersions(); //获取所有的版本，这个返回的是以倒序排列的，最新的版本在最前面
if (versionsToKeep >= 0) {
versions = versions.subList(0,
Math.min(versions.size(), versionsToKeep)); //所以可以用subList来得到需要的版本
}
HashSet<Long> keepers = new HashSet<Long>(versions); //存在HashSet中方便快速存取
for (String p : listDir(_root)) {
Long v = parseVersion(p);
if (v != null && !keepers.contains(v)) {
deleteVersion(v); //删除其他的版本
}
}
}
getAllVersions，注意这里是获取所有以version结尾的文件，也就是说所有写入成功的文件，不包括某些还没写成功的文件
/**
* Sorted from most recent to oldest
*/
public List<Long> getAllVersions() throws IOException {
List<Long> ret = new ArrayList<Long>();
for (String s : listDir(_root)) { //获取该目录下的所有文件
if (s.endsWith(FINISHED_VERSION_SUFFIX)) {
ret.add(validateAndGetVersion(s)); //验证该文件是否存在
}
}
Collections.sort(ret);
Collections.reverse(ret); //逆序排列
return ret;
}
删除对应的version文件和token文件
public void deleteVersion(long version) throws IOException {
File versionFile = new File(versionPath(version));
File tokenFile = new File(tokenPath(version));
if (versionFile.exists()) {
FileUtils.forceDelete(versionFile);
}
if (tokenFile.exists()) {
FileUtils.forceDelete(tokenFile);
}
}
在最开始的地方，snapshot()函数调用了 mostRecentVersionPath() 来获取最近的版本，也就是调用getAllVersions，然后拿到最新的version
public String mostRecentVersionPath() throws IOException {
Long v = mostRecentVersion();
if (v == null)
return null;
return versionPath(v);
}
public Long mostRecentVersion() throws IOException {
List<Long> all = getAllVersions();
if (all.size() == 0)
return null;
return all.get(0);
}
如果提供了version号的话，可以看到是取出了比这个version号小的最大的version
public String mostRecentVersionPath(long maxVersion) throws IOException {
Long v = mostRecentVersion(maxVersion);
if (v == null)
return null;
return versionPath(v);
}
public Long mostRecentVersion(long maxVersion) throws IOException {
List<Long> all = getAllVersions();
for (Long v : all) {
if (v <= maxVersion) //取出比maxVersion小的最大version
return v;
}
return null;
}