轻松解决Android复杂数据结构序列化

问题描述

当我编写quickupload库时，因为需要在 Service中进行上传任务，向Service传递时我发现需要传递的数据很多并且结构复杂，如果处理不好就会导致以下几个问题

• 耗时: 需要更多时间进行开发和测试以确保正确的数据处理。
• 容易出错: 由于手动序列化和反序列化逻辑，出现错误的风险更高。
• 维护: 维护和更新代码的工作量增加，尤其是数据结构发生变化时。

解决方案：

为了解决这个问题，需要编写 PersistableData

open class PersistableData() : Parcelable {
    protected val data = HashMap<String, Any>()

    override fun equals(other: Any?): Boolean {
        if (other == null || other !is PersistableData) return false

        return data == other.data
    }

    override fun hashCode() = data.hashCode()

    @SuppressLint("ParcelClassLoader")
    private constructor(parcel: Parcel) : this() {
        parcel.readBundle()?.let { bundle ->
            bundle.keySet().forEach { key ->
                when (val value = bundle[key]) {
                    is Boolean, is Double, is Int, is Long, is String -> data[key] = value
                }
            }
        }
    }

    override fun describeContents() = 0

    override fun writeToParcel(dest: Parcel, flags: Int) {
        toBundle().writeToParcel(dest, flags)
    }

    companion object CREATOR : Parcelable.Creator<PersistableData> {
        private const val separator = "$"
        override fun createFromParcel(parcel: Parcel) = PersistableData(parcel)
        override fun newArray(size: Int): Array<PersistableData?> = arrayOfNulls(size)

        /**
         * 从PersistableData JSON表示创建 [PersistableData]。
         */
        @JvmStatic
        fun fromJson(rawJsonString: String): PersistableData {
            val json = JSONObject(rawJsonString)
            val data = PersistableData()

            json.keys().forEach { key ->
                when (val value = json.get(key)) {
                    is Boolean, is Double, is Int, is Long, is String -> data.data[key] = value
                }
            }

            return data
        }
    }

    private fun String.validated(checkExists: Boolean = false): String {
        if (contains(separator))
            throw IllegalArgumentException("key cannot contain $separator as it's a reserved character, used for nested data")
        if (checkExists && !data.containsKey(this))
            throw IllegalArgumentException("no data found for key \"$this\"")
        return this
    }

    fun putBoolean(key: String, value: Boolean) {
        data[key.validated()] = value
    }

    fun getBoolean(key: String) = data[key.validated(checkExists = true)] as Boolean

    fun putDouble(key: String, value: Double) {
        data[key.validated()] = value
    }

    fun getDouble(key: String) = data[key.validated(checkExists = true)] as Double

    fun putInt(key: String, value: Int) {
        data[key.validated()] = value
    }

    fun getInt(key: String) = data[key.validated(checkExists = true)] as Int

    fun putLong(key: String, value: Long) {
        data[key.validated()] = value
    }

    fun getLong(key: String) = data[key.validated(checkExists = true)] as Long

    fun putString(key: String, value: String) {
        data[key.validated()] = value
    }

    fun getString(key: String) = data[key.validated(checkExists = true)] as String

    fun putData(key: String, data: PersistableData) {
        data.data.forEach { (dataKey, value) ->
            this.data["$key$separator$dataKey"] = value
        }
    }

    fun getData(key: String): PersistableData {
        val entries = data.entries.filter { it.key.startsWith("$key$separator") }
        if (entries.isEmpty()) return PersistableData()

        return PersistableData().also { extractedData ->
            entries.forEach { (entryKey, entryValue) ->
                extractedData.data[entryKey.removePrefix("$key$separator")] = entryValue
            }
        }
    }

    fun putArrayData(key: String, data: List<PersistableData>) {
        data.forEachIndexed { index, persistableData ->
            persistableData.data.forEach { (dataKey, value) ->
                this.data["$key$separator$index$separator$dataKey"] = value
            }
        }
    }

    fun getArrayData(key: String): List<PersistableData> {
        val entries = ArrayList(data.entries.filter { it.key.startsWith("$key$separator") })
        if (entries.isEmpty()) return emptyList()

        var index = 0

        var elements = entries.filter { it.key.startsWith("$key$separator$index$separator") }

        val outList = ArrayList<PersistableData>()

        while (elements.isNotEmpty()) {
            outList.add(PersistableData().also { extractedData ->
                elements.forEach { (entryKey, entryValue) ->
                    extractedData.data[entryKey.removePrefix("$key$separator$index$separator")] =
                        entryValue
                }
                entries.removeAll(elements)
            })

            index += 1
            elements = entries.filter { it.key.startsWith("$key$separator$index$separator") }
        }

        return outList
    }

    /**
     * 创建一个新的包，其中包含此 [PersistableData] 中存在的所有字段。
     */
    fun toBundle() = Bundle().also { bundle ->
        data.keys.forEach { key ->
            when (val value = data[key]) {
                is Boolean -> bundle.putBoolean(key, value)
                is Double -> bundle.putDouble(key, value)
                is Int -> bundle.putInt(key, value)
                is Long -> bundle.putLong(key, value)
                is String -> bundle.putString(key, value)
            }
        }
    }

    /**
     * 创建一个包含所有字段的JSON字符串表示
     * 在此 [PersistableData] 中。
     *
     * 这并不意味着人类可读，而是一种方便的方式来传递复杂的
     * 使用字符串的结构化数据。
     */
    fun toJson() = JSONObject().also { json ->
        data.keys.forEach { key ->
            when (val value = data[key]) {
                is Boolean, is Double, is Int, is Long, is String -> json.put(key, value)
            }
        }
    }.toString()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

简单总结一下：

• 存储各种类型的键值对（Boolean、Double、Int、Long、String）。
• 提供放入和获取数据的方法（putBoolean、getBoolean等）。
• 使用带有分隔符的键支持嵌套和数组数据结构。
  转换数据为Bundle和JSON格式，便于存储和检索。
• 实现Parcelable接口，允许在Android组件之间传递数据。

为了在使用时保持统一性

编写接口 Persistable

interface Persistable {
    fun toPersistableData(): PersistableData

    interface Creator<T> {
        fun createFromPersistableData(data: PersistableData): T
    }
}
1
2
3
4
5
6
7

简单总结一下：

• 定义了一个可以转换为PersistableData对象的契约。
• 确保数据对象的序列化和反序列化方式一致。

当需要对某个数据类进行序列化时只需要实现接口 Persistable，例如 UploadFile数据类

@Parcelize
data class UploadFile @JvmOverloads constructor(
    val path: String,
    val properties: LinkedHashMap<String, String> = LinkedHashMap()
) : Parcelable, Persistable {

    companion object : Persistable.Creator<UploadFile> {


        private object CodingKeys {
            const val path = "path"
            const val properties = "props"
        }

        override fun createFromPersistableData(data: PersistableData) = UploadFile(
            path = data.getString(CodingKeys.path),
            properties = LinkedHashMap<String, String>().apply {
                val bundle = data.getData(CodingKeys.properties).toBundle()
                bundle.keySet().forEach { propKey ->
                    put(propKey, bundle.getString(propKey)!!)
                }
            }
        )
    }
    
    override fun toPersistableData() = PersistableData().apply {
        putString(CodingKeys.path, path)
        putData(CodingKeys.properties, PersistableData().apply {
            properties.entries.forEach { (propKey, propVal) ->
                putString(propKey, propVal)
            }
        })
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

简单总结一下：

• 使用PersistableData存储其属性，使得状态的保存和恢复变得简单。
• 包含一个自定义Creator，用于从PersistableData创建UploadFile实例。

总结

我认为这样做 可以简化和优化在Android应用中管理复杂数据结构及其持久化的过程，如果对你有帮助记得点赞收藏！