Android平台如何在Realm DB中存储HashMap<String, Any>类型数据？

Realm本身不原生支持Any类型属性，也无法直接存储无类型约束的HashMap，需通过封装多态数据模型实现，以下是具体方案：

1. 设计基础数据节点模型 #

定义一个统一的基类，用来覆盖所有可能的Value类型：

open class RealmValueNode : RealmObject() {
    // 标记节点类型，用于后续解析
    var type: String = ""

    // 存储基本类型（按需扩展）
    var stringValue: String? = null
    var intValue: Long? = null
    var boolValue: Boolean? = null
    var doubleValue: Double? = null

    // 存储自定义Realm对象
    var objectValue: RealmObject? = null

    // 存储列表类型：元素也可能是Any，所以用RealmValueNode列表
    var listValue: RealmList<RealmValueNode>? = RealmList()

    // 存储嵌套HashMap：用键值对模型存储
    var mapValue: RealmList<RealmMapEntry>? = RealmList()
}

// HashMap键值对模型
class RealmMapEntry : RealmObject() {
    var key: String = ""
    var value: RealmValueNode? = null
}

2. 处理自定义对象类型 #

如果Any包含自定义对象，需让对象继承RealmObject，比如：

class User : RealmObject() {
    var name: String = ""
    var age: Int = 0
}

存储时将RealmValueNode的type设为"object"，并把objectValue赋值为对应实例即可。

3. 封装HashMap的存储与读取 #

编写工具方法完成普通HashMap和Realm模型的双向转换：

存储转换 #

fun hashMapToRealmMap(hashMap: HashMap<String, Any>): RealmList<RealmMapEntry> {
    val realmMap = RealmList<RealmMapEntry>()
    hashMap.forEach { (key, value) ->
        val entry = RealmMapEntry().apply {
            this.key = key
            this.value = anyToRealmValueNode(value)
        }
        realmMap.add(entry)
    }
    return realmMap
}

fun anyToRealmValueNode(value: Any): RealmValueNode {
    val node = RealmValueNode()
    when (value) {
        is String -> {
            node.type = "string"
            node.stringValue = value
        }
        is Int -> {
            node.type = "int"
            node.intValue = value.toLong()
        }
        is Boolean -> {
            node.type = "bool"
            node.boolValue = value
        }
        is Double -> {
            node.type = "double"
            node.doubleValue = value
        }
        is RealmObject -> {
            node.type = "object"
            node.objectValue = value
        }
        is List<*> -> {
            node.type = "list"
            node.listValue = RealmList<RealmValueNode>().apply {
                value.forEach { item ->
                    item?.let { add(anyToRealmValueNode(it)) }
                }
            }
        }
        is HashMap<*, *> -> {
            node.type = "map"
            node.mapValue = hashMapToRealmMap(value as HashMap<String, Any>)
        }
    }
    return node
}

读取解析 #

fun realmMapToHashMap(realmMap: RealmList<RealmMapEntry>?): HashMap<String, Any>? {
    if (realmMap == null) return null
    val hashMap = HashMap<String, Any>()
    realmMap.forEach { entry ->
        entry.value?.let {
            hashMap[entry.key] = realmValueNodeToAny(it)
        }
    }
    return hashMap
}

fun realmValueNodeToAny(node: RealmValueNode): Any {
    return when (node.type) {
        "string" -> node.stringValue!!
        "int" -> node.intValue!!.toInt()
        "bool" -> node.boolValue!!
        "double" -> node.doubleValue!!
        "object" -> node.objectValue!!
        "list" -> node.listValue?.map { realmValueNodeToAny(it) } ?: emptyList()
        "map" -> realmMapToHashMap(node.mapValue) ?: emptyMap()
        else -> throw IllegalArgumentException("Unknown value type: ${node.type}")
    }
}

4. 关键注意事项 #

• Realm不支持泛型对象存储，若自定义对象类型多，可在type字段记录类名，解析时通过反射实例化。
• 避免过深的嵌套层级，会影响查询性能。
• 写入Realm时，所有关联的RealmObject必须是Realm管理的实例（通过realm.copyToRealm()或realm.createObject()创建）。

内容的提问来源于stack exchange，提问作者Emre Memil