done = (*slash == ‘ ’);
*slash = ‘ ’;
if (stat(path, &sb) != 0) {
// 执行创建文件夹的操作, C 中无 mkdirs 的操作, 需要一个一个文件夹的创建
if (errno != ENOENT || mkdir(path, 0777) != 0) {
MMKVWarning("%s : %s", path, strerror(errno));
return false;
}
}
// 若非文件夹, 则说明为非法路径
else if (!S_ISDIR(sb.st_mode)) {
MMKVWarning("%s: %s", path, strerror(ENOTDIR));
return false;
}
*slash = ‘/’;
}
return true;
}
以上是 Native 层创建文件路径的通用代码, 逻辑很清晰
好的, 文件目录创建好了之后, Native 层的初始化操作便结束了, 接下来看看 MMKV 实例构建的过程
三. 实例化public class MMKV implements SharedPreferences, SharedPreferences.Editor {
@Nullable
public static MMKV mmkvWithID(String mmapID, int mode, String cryptKey, String relativePath) {
…
// 执行 Native 初始化, 获取句柄值
long handle = getMMKVWithID(mmapID, mode, cryptKey, relativePath);
if (handle == 0) {
return null;
}
// 构建一个 Java 的壳对象
return new MMKV(handle);
}
private native static long
getMMKVWithID(String mmapID, int mode, String cryptKey, String relativePath);
// jni
private long nativeHandle;
private MMKV(long handle) {
nativeHandle = handle;
}
}
可以看到 MMKV 实例构建的主要逻辑通过 getMMKVWithID 方法实现, 看它内部做了什么
// native-bridge.cpp
namespace mmkv {
MMKV_JNI jlong getMMKVWithID(
JNIEnv *env, jobject, jstring mmapID, jint mode, jstring cryptKey, jstring relativePath) {
MMKV *kv = nullptr;
if (!mmapID) {
return (jlong) kv;
}
// 获取独立存储 id
string str = jstring2string(env, mmapID);
bool done = false;
if (cryptKey) {
// 获取秘钥
string crypt = jstring2string(env, cryptKey);
if (crypt.length() > 0) {
if (relativePath) {
// 获取相对路径
string path = jstring2string(env, relativePath);
// 通过 mmkvWithID 函数获取一个 MMKV 的对象
kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, &crypt, &path);
} else {
kv = MMKV::mmkvWithID(str, DEFAULT_MMAP_SIZE, (MMKVMode) mode, &crypt, nullptr);
}
done = true;
}
}
…
// 强转成句柄, 返回到 Java
return (jlong) kv;
}
}
可以看到最终通过 MMKV::mmkvWithID 函数获取到 MMKV 的对象
// MMKV.cpp
MMKV *MMKV::mmkvWithID(
const std::string &mmapID, int size, MMKVMode mode, string *cryptKey, string *relativePath) {
if (mmapID.empty()) {
return nullptr;
}
SCOPEDLOCK(g_instanceLock);
// 1. 通过 mmapID 和 relativePath, 组成最终的 mmap 文件路径的 key
auto mmapKey = mmapedKVKey(mmapID, relativePath);
// 2. 从全局缓存中查找
auto itr = g_instanceDic->find(mmapKey);
if (itr != g_instanceDic->end()) {
MMKV *kv = itr->second;
return kv;
}
// 3. 创建缓存文件
if (relativePath) {
// 根据 mappedKVPathWithID 获取 mmap 的最终文件路径
// mmapID 使用 md5 加密
auto filePath = mappedKVPathWithID(mmapID, mode, relativePath);
// 不存在则创建一个文件
if (!isFileExist(filePath)) {
if (!createFile(filePath)) {
return nullptr;
}
}
…
}
// 4. 创建实例对象
auto kv = new MMKV(mmapID, size, mode, cryptKey, relativePath);
// 5. 缓存这个 mmapKey
(*g_instanceDic)[mmapKey] = kv;
return kv;
}
mmkvWithID 函数的实现流程非常的清晰, 这里我们主要关注一下实例对象的创建流程
// MMKV.cpp
MMKV::MMKV(
const std::string &mmapID, int size, MMKVMode mode, string *cryptKey, string *relativePath)
: m_mmapID(mmapedKVKey(mmapID, relativePath))
// 拼装文件的路径
, m_path(mappedKVPathWithID(m_mmapID, mode, relativePath))
// 拼装 .crc 文件路径
, m_crcPath(crcPathWithID(m_mmapID, mode, relativePath))
// 1. 将文件摘要信息映射到内存， 4 kb 大小
, m_metaFile(m_crcPath, DEFAULT_MMAP_SIZE, (mode & MMKV_ASHMEM) ? MMAP_ASHMEM : MMAP_FILE)
…
, m_sharedProcessLock(&m_fileLock, SharedLockType)
…
, m_isAshmem((mode & MMKV_ASHMEM) != 0) {
…
// 判断是否为 Ashmem 跨进程匿名共享内存
if (m_isAshmem) {
// 创共享内存的文件
m_ashmemFile = new MmapedFile(m_mmapID, static_cast
m_fd = m_ashmemFile->getFd();
} else {
m_ashmemFile = nullptr;
}
// 根据 cryptKey 创建 AES 加解密的引擎
if (cryptKey && cryptKey->length() > 0) {
m_crypter = new AESCrypt((const unsigned char *) cryptKey->data(), cryptKey->length());
}
…
// sensitive zone
{
SCOPEDLOCK(m_sharedProcessLock);
// 2. 根据 m_mmapID 来加载文件中的数据
loadFromFile();
}
}
可以从 MMKV 的构造函数中看到很多有趣的信息, MMKV 是支持 Ashmem 共享内存的, 当我们不想将文件写入磁盘，但是又想进行跨进程通信，就可以使用 MMKV 提供的 MMAP_ASHMEM
不过这里我们主要关注两个关键点
m_metaFile 文件摘要的映射loadFromFile 数据的载入
接下来我们先看看, 文件摘要信息的映射
一) 文件摘要的映射// MmapedFile.cpp
MmapedFile::MmapedFile(const std::string &path, size_t size, bool fileType)
: m_name(path), m_fd(-1), m_segmentPtr(nullptr), m_segmentSize(0), m_fileType(fileType) {
// 用于内存映射的文件
if (m_fileType == MMAP_FILE) {
// 1. 打开文件
m_fd = open(m_name.c_str(), O_RDWR | O_CREAT, S_IRWXU);
if (m_fd < 0) {
MMKVError(“fail to open:%s, %s”, m_name.c_str(), strerror(errno));
} else {
// 2. 创建文件锁
FileLock fileLock(m_fd);
InterProcessLock lock(&fileLock, ExclusiveLockType);
SCOPEDLOCK(lock);
// 获取文件的信息
struct stat st = {};
if (fstat(m_fd, &st) != -1) {
// 获取文件大小
m_segmentSize = static_cast
}
// 3. 验证文件的大小是否小于一个内存页, 一般为 4kb
if (m_segmentSize < DEFAULT_MMAP_SIZE) {
m_segmentSize = static_cast
// 3.1 通过 ftruncate 将文件大小对其到内存页
// 3.2 通过 zeroFillFile 将文件对其后的空白部分用 0 填充
if (ftruncate(m_fd, m_segmentSize) != 0 || !zeroFillFile(m_fd, 0, m_segmentSize)) {
// 说明文件拓展失败了, 移除这个文件
close(m_fd);
m_fd = -1;
removeFile(m_name);
return;
}
}
// 4. 通过 mmap 将文件映射到内存, 获取内存首地址
m_segmentPtr =
(char *) mmap(nullptr, m_segmentSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
if (m_segmentPtr == MAP_FAILED) {
MMKVError(“fail to mmap [%s], %s”, m_name.c_str(), strerror(errno));
close(m_fd);
m_fd = -1;
m_segmentPtr = nullptr;
}
}
}
// 用于共享内存的文件
else {
…
}
}
MmapedFile 的构造函数处理的事务如下
打开指定的文件创建这个文件锁修正文件大小, 最小为 4kb前 4kb 用于统计数据总大小通过 mmap 将文件映射到内存
好的, 通过 MmapedFile 的构造函数, 我们便能够获取到映射后的内存首地址了, 操作这块内存时 Linux 内核会负责将内存中的数据同步到文件中
比起 SP 的数据同步, mmap 显然是要优雅的多, 即使进程意外死亡, 也能够通过 Linux 内核的保护机制, 将进行了文件映射的内存数据刷入到文件中, 提升了数据写入的可靠性
结下来看看数据的载入
二) 数据的载入// MMKV.cpp
void MMKV::loadFromFile() {
…// 忽略匿名共享内存相关代码
// 若已经进行了文件映射
if (m_metaFile.isFilevalid()) {
// 则获取相关数据
m_metaInfo.read(m_metaFile.getMemory());
}
// 获取文件描述符
m_fd = open(m_path.c_str(), O_RDWR | O_CREAT, S_IRWXU);
if (m_fd < 0) {
MMKVError(“fail to open:%s, %s”, m_path.c_str(), strerror(errno));
} else {
// 1. 获取文件大小
m_size = 0;
struct stat st = {0};
if (fstat(m_fd, &st) != -1) {
m_size = static_cast
}
// 1.1 将文件大小对其到内存页的整数倍
if (m_size < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) {
…
}
// 2. 获取文件映射后的内存地址
m_ptr = (char *) mmap(nullptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
if (m_ptr == MAP_FAILED) {
…
} else {
// 3. 读取内存文件的前 32 位, 获取存储数据的真实大小
memcpy(&m_actualSize, m_ptr, Fixed32Size);
…
bool loadFromFile = false, needFullWriteback = false;
if (m_actualSize > 0) {
// 4. 验证文件的长度
if (m_actualSize < m_size && m_actualSize + Fixed32Size <= m_size) {
// 5. 验证文件 CRC 的正确性
if (checkFileCRCValid()) {
loadFromFile = true;
} else {
// 若不正确, 则回调异常 CRC 异常
auto strategic = mmkv::onMMKVCRCCheckFail(m_mmapID);
if (strategic == OnErrorRecover) {
loadFromFile = true;
needFullWriteback = true;
}
}
} else {
// 回调文件长度异常
auto strategic = mmkv::onMMKVFileLengthError(m_mmapID);
if (strategic == OnErrorRecover) {
writeAcutalSize(m_size - Fixed32Size);
loadFromFile = true;
needFullWriteback = true;
}
}
}
// 6. 需要从文件获取数据
if (loadFromFile) {
…
// 构建输入缓存
MMBuffer inputBuffer(m_ptr + Fixed32Size, m_actualSize, MMBufferNoCopy);
if (m_crypter) {
// 解密输入缓冲中的数据
decryptBuffer(*m_crypter, inputBuffer);
}
// 从输入缓冲中将数据读入 m_dic
m_dic.clear();
MiniPBCoder::decodeMap(m_dic, inputBuffer);
// 构建输出数据
m_output = new CodedOutputData(m_ptr + Fixed32Size + m_actualSize,
m_size - Fixed32Size - m_actualSize);
// 进行重整回写, 剔除重复的数据
if (needFullWriteback) {
fullWriteback();
}
}
// 7. 说明文件中没有数据, 或者校验失败了
else {
SCOPEDLOCK(m_exclusiveProcessLock);
// 清空文件中的数据
if (m_actualSize > 0) {
writeAcutalSize(0);
}
m_output = new CodedOutputData(m_ptr + Fixed32Size, m_size - Fixed32Size);
// 重新计算 CRC
recaculateCRCDigest();
}
…
}
}
…
m_needLoadFromFile = false;
}
好的, 可以看到 loadFromFile 中对于 CRC 验证通过的文件, 会将文件中的数据读入到 m_dic 中缓存, 否则则会清空文件
因此用户恶意修改文件之后, 会破坏 CRC 的值, 这个存储数据便会被作废, 这一点要尤为注意从文件中读取数据到 m_dic 之后, 会将 mdic 回写到文件中, 其重写的目的是为了剔除重复的数据关于为什么会出现重复的数据, 在后面 encode 操作中再分析 三) 回顾
到这里 MMKV 实例的构建就完成了, 有了 m_dic 这个内存缓存, 我们进行数据查询的效率就大大提升了
从最终的结果来看它与 SP 是一致的, 都是初次加载时会将文件中所有的数据加载到散列表中, 不过 MMKV 多了一步数据回写的操作, 因此当数据量比较大时, 对实例构建的速度有一定的影响
// 写入 1000 条数据之后, MMVK 和 SharedPreferences 实例化的时间对比
E/TAG: create MMKV instance time is 4 ms
E/TAG: create SharedPreferences instance time is 1 ms
从结果上来看, MMVK 的确在实例构造速度上有一定的劣势, 不过得益于是将 m_dic 中的数据写入到 mmap 的内存, 其真正进行文件写入的时机由 Linux 内核决定, 再加上文件的页缓存机制, 所以速度上虽有劣势, 但不至于无法接受
四. encode关于 encode 即数据的添加与更新的流程, 这里以 encodeString 为例
public class MMKV implements SharedPreferences, SharedPreferences.Editor {
public boolean encode(String key, String value) {
return encodeString(nativeHandle, key, value);
}
private native boolean encodeString(long handle, String key, String value);
}
看看 native 层的实现
// native-bridge.cpp
namespace mmkv {
MMKV_JNI jboolean encodeString(JNIEnv *env, jobject, jlong handle, jstring oKey, jstring oValue) {
MMKV *kv = reinterpret_cast
if (kv && oKey) {
string key = jstring2string(env, oKey);
// 若是 value 非 NULL
if (oValue) {
// 通过 setStringForKey 函数, 将数据存入
string value = jstring2string(env, oValue);
return (jboolean) kv->setStringForKey(value, key);
}
// 若是 value 为 NULL, 则移除 key 对应的 value 值
else {
kv->removevalueForKey(key);
return (jboolean) true;
}
}
return (jboolean) false;
}
}
这里我们主要分析一下 setStringForKey 这个函数
// MMKV.cpp
bool MMKV::setStringForKey(const std::string &value, const std::string &key) {
if (key.empty()) {
return false;
}
// 1. 将数据编码成 ProtocolBuffer
auto data = MiniPBCoder::encodeDataWithObject(value);
// 2. 更新键值对
return setDataForKey(std::move(data), key);
}
这里主要分为两步操作
数据编码更新键值对 一) 数据的编码
MMKV 采用的是 ProtocolBuffer 编码方式, 这里就不做过多介绍了, 具体请查看 Google 官方文档
// MiniPBCoder.cpp
MMBuffer MiniPBCoder::getEncodeData(const string &str) {
// 1. 创建编码条目的集合
m_encodeItems = new vector();
// 2. 为集合填充数据
size_t index = prepareObjectForEncode(str);
PBEncodeItem *oItem = (index < m_encodeItems->size()) ? &(*m_encodeItems)[index] : nullptr;
if (oItem && oItem->compiledSize > 0) {
// 3. 开辟一个内存缓冲区, 用于存放编码后的数据
m_outputBuffer = new MMBuffer(oItem->compiledSize);
// 4. 创建一个编码操作对象
m_outputData = new CodedOutputData(m_outputBuffer->getPtr(), m_outputBuffer->length());
// 执行 protocolbuffer 编码, 并输出到缓冲区
writeRootObject();
}
// 调用移动构造函数, 重新创建实例返回
return move(*m_outputBuffer);
}
size_t MiniPBCoder::prepareObjectForEncode(const string &str) {
// 2.1 创建 PBEncodeItem 对象用来描述待编码的条目, 并添加到 vector 集合
m_encodeItems->push_back(PBEncodeItem());
// 2.2 获取 PBEncodeItem 对象
PBEncodeItem *encodeItem = &(m_encodeItems->back());
// 2.3 记录索引位置
size_t index = m_encodeItems->size() - 1;
{
// 2.4 填充编码类型
encodeItem->type = PBEncodeItemType_String;
// 2.5 填充要编码的数据
encodeItem->value.strValue = &str;
// 2.6 填充数据大小
encodeItem->valueSize = static_cast
}
// 2.7 计算编码后的大小
encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize;
return index;
}
可以看到, 再未进行编码操作之前, 编码后的数据大小就已经确定好了, 并且将它保存在了 encodeItem->compiledSize 中, 接下来我们看看执行数据编码并输出到缓冲区的操作流程
// MiniPBCoder.cpp
void MiniPBCoder::writeRootObject() {
for (size_t index = 0, total = m_encodeItems->size(); index < total; index++) {
PBEncodeItem *encodeItem = &(m_encodeItems)[index];
switch (encodeItem->type) {
// 主要关心编码 String
case PBEncodeItemType_String: {
m_outputData->writeString((encodeItem->value.strValue));
break;
}
…
}
}
}
// CodedOutputData.cpp
void CodedOutputdata::writeString(const string &value) {
size_t numberOfBytes = value.size();
…
// 1. 按照 varint 方式编码字符串长度, 会改变 m_position 的值
this->writeRawVarint32((int32_t) numberOfBytes);
// 2. 将字符串的数据拷贝到编码好的长度后面
memcpy(m_ptr + m_position, ((uint8_t *) value.data()), numberOfBytes);
// 更新 position 的值
m_position += numberOfBytes;
}
可以看到 CodedOutputData 的 writeString 中按照 protocol buffer 进行了字符串的编码操作
其中 m_ptr 是上面开辟的内存缓冲区的地址, 也就是说 writeString 执行结束之后, 数据就已经被写入缓冲区了
有了编码好的数据缓冲区, 接下来看看更新键值对的操作
二) 键值对的更新// MMKV.cpp
bool MMKV::setStringForKey(const std::string &value, const std::string &key) {
// 编码数据获取存放数据的缓冲区
auto data = MiniPBCoder::encodeDataWithObject(value);
// 更新键值对
return setDataForKey(std::move(data), key);
}
bool MMKV::setDataForKey(MMBuffer &&data, const std::string &key) {
…
// 将键值对写入 mmap 文件映射的内存中
auto ret = appendDataWithKey(data, key);
// 写入成功, 更新散列数据
if (ret) {
m_dic[key] = std::move(data);
m_hasFullWriteback = false;
}
return ret;
}
bool MMKV::appendDataWithKey(const MMBuffer &data, const std::string &key) {
// 1. 计算 key + value 的 ProtocolBuffer 编码后的长度
size_t keyLength = key.length();
size_t size = keyLength + pbRawVarint32Size((int32_t) keyLength);
size += data.length() + pbRawVarint32Size((int32_t) data.length());
SCOPEDLOCK(m_exclusiveProcessLock);
// 2. 验证是否有足够的空间, 不足则进行数据重整与扩容操作
bool hasEnoughSize = ensureMemorySize(size);
if (!hasEnoughSize || !isFilevalid()) {
return false;
}
// 3. 更新文件头的数据总大小
writeAcutalSize(m_actualSize + size);
// 4. 将 key 和编码后的 value 写入到文件映射的内存
m_output->writeString(key);
m_output->writeData(data);
// 5. 获取文件映射内存当前
auto ptr = (uint8_t *) m_ptr + Fixed32Size + m_actualSize - size;
if (m_crypter) {
// 加密这块区域
m_crypter->encrypt(ptr, ptr, size);
}
// 6. 更新 CRC
updateCRCDigest(ptr, size, KeepSequence);
return true;
}
好的, 可以看到更新键值对的操作还是比较复杂的, 首先将键值对数据写入到文件映射的内存中, 写入成功之后更新散列数据
关于写入到文件映射的过程, 上面代码中的注释也非常的清晰, 接下来我们 ensureMemorySize 是如何进行数据的重整与扩容的
数据的重整与扩容// MMKV.cpp
bool MMKV::ensureMemorySize(size_t newSize) {
…
// 计算新键值对的大小
constexpr size_t ItemSizeHolderSize = 4;
if (m_dic.empty()) {
newSize += ItemSizeHolderSize;
}
// 数据重写:
// 1. 文件剩余空闲空间少于新的键值对
// 2. 散列为空
if (newSize >= m_output->spaceLeft() || m_dic.empty()) {
// 计算所需的数据空间
static const int offset = pbFixed32Size(0);
MMBuffer data = MiniPBCoder::encodeDataWithObject(m_dic);
size_t lenNeeded = data.length() + offset + newSize;
if (m_isAshmem) {
…
} else {
//
// 计算每个键值对的平均大小
size_t avgItemSize = lenNeeded / std::max
// 计算未来可能会使用的大小(类似于 1.5 倍)
size_t futureUsage = avgItemSize * std::max
// 1. 所需空间 >= 当前文件总大小
// 2. 所需空间的 1.5 倍 >= 当前文件总大小
if (lenNeeded >= m_size || (lenNeeded + futureUsage) >= m_size) {
// 扩容为 2 倍
size_t oldSize = m_size;
do {
m_size *= 2;
} while (lenNeeded + futureUsage >= m_size);
…
}
}
…
// 进行数据的重写
writeAcutalSize(data.length());
…
}
return true;
}
从上面的代码我们可以了解到
数据的重写时机文件剩余空间少于新的键值对大小散列为空文件扩容时机 从上面的代码我们可以了解到 数据的重写时机文件剩余空间少于新的键值对大小散列为空文件扩容时机
isAshmem) {
…
} else {
//
// 计算每个键值对的平均大小
size_t avgItemSize = lenNeeded / std::max
// 计算未来可能会使用的大小(类似于 1.5 倍)
size_t futureUsage = avgItemSize * std::max
// 1. 所需空间 >= 当前文件总大小
// 2. 所需空间的 1.5 倍 >= 当前文件总大小
if (lenNeeded >= m_size || (lenNeeded + futureUsage) >= m_size) {
// 扩容为 2 倍
size_t oldSize = m_size;
do {
m_size *= 2;
} while (lenNeeded + futureUsage >= m_size);
…
}
}
…
// 进行数据的重写
writeAcutalSize(data.length());
…
}
return true;
}
