Kotlin属性委托的巧妙使用-埋点上报封装
概述
在实际的项目开发中，一定会有埋点上报的需求。可能每个项目上报的方式不一样，有些是通过自动化埋点，不需要开发手动上报，有些是需要开发自己上报。在我们业务的一个项目中，因为采用的是业务推动迭代的方式，有大量的跟业务相关的埋点，且变动比较大，所以我们基本上都是开发自己上报。
在之前的 Java 作为主力语言开发的时候，埋点参数上报的封装基本上是利用 Builder 模式，或者使用 Map 的方式来进行上报，而到了 Kotlin 作为主力开发语言后，可以利用 Kotlin 提供的一些语法，更好的封装实现埋点的上报，今天就来谈谈我在实际项目中封装的一种思路。
旧方式
原来的埋点上报，对于上报参数的组织，有些是通过 Builder，有些是利用 Map 来组织。我这里取神策埋点 SDK 的上报方式为例：
利用 JSONObject 构建 Json 数据的方式上报
1try {
2 JSONObject newProperties = new JSONObject();
3 newProperties.put("AdSource", "Email");
4 properties.put("AdSource", "XXX Store");
5
6 // 再次设定用户渠道，设定无效，"developer@sensorsdata.cn" 的 "AdSource" 属性值仍然是 "XXX Store"
7 SensorsDataAPI.sharedInstance().profileSetOnce(newProperties);
8} catch (JSONException e) {
9 e.printStackTrace();
10}利用 Map 集合的方式上报：
1// map集合
2Map<String, Number> properties = new HashMap<String, Number>();
3properties.put("UserPaid", 1);
4properties.put("PointEarned", 12.5);
5
6SensorsDataAPI.sharedInstance().profileIncrement(properties);个人在使用的时候，觉得这种上报参数的组织方式，比较零散，不易于管理，复用性不强。我们之前也是使用了差不多的上报方式，但是使用多了之后，发现不是很方便，因此基于 Kotlin 的委托的语法特性，重新进行了封装。
新思路
基础抽象类 BaseEventTrack
首先对于每个埋点，我们采用了类来进行管理，即每个埋点抽象成一个埋点类。下每个埋点类基础一个抽象类，这个抽象类，来定义一些基础的信息，大概如下：
1abstract class BaseEventTrack {
2 private val tag = "BaseEventTrack"
3 // 所有上报参数得收集，这一块可以自己定义和修改
4 private val paramsMap = hashMapOf<String, Any?>()
5 // 埋点名字
6 abstract val eventId: String
7 // 埋点的归类
8 abstract val eventTrackCategory: String
9
10 /**
11 * 触发上报当前的埋点
12 */
13 fun upload() {
14 //
15 EventTrack.stat(eventTrackCategory, eventId, paramsMap)
16 }
17 /**
18 * 定义每种类型的委托方法，控制它的get和set方法，如果有新增，可以在这里新增
19 */
20 protected fun int(): ReadWriteProperty<BaseEventTrack, Int?> = InnerReadWriteProperty<BaseEventTrack, Int?>(0)
21
22 protected fun string(): ReadWriteProperty<BaseEventTrack, String?> =
23 InnerReadWriteProperty<BaseEventTrack, String?>("")
24
25 protected fun long(): ReadWriteProperty<BaseEventTrack, Long?> = InnerReadWriteProperty<BaseEventTrack, Long?>(0)
26 protected fun boolean(): ReadWriteProperty<BaseEventTrack, Boolean?> =
27 InnerReadWriteProperty<BaseEventTrack, Boolean?>(false)
28
29 protected fun float(): ReadWriteProperty<BaseEventTrack, Float?> =
30 InnerReadWriteProperty<BaseEventTrack, Float?>(0F)
31
32 protected fun double(): ReadWriteProperty<BaseEventTrack, Double?> =
33 InnerReadWriteProperty<BaseEventTrack, Double?>(0.0)
34
35 // 代理类属性的处理
36 inner class InnerReadWriteProperty<T, V>(defaultValue: V) : ReadWriteProperty<T, V> {
37 private var currentValue: V = defaultValue
38 override fun getValue(thisRef: T, property: KProperty<*>): V {
39 Log.i(tag, "thisRef=${thisRef},property=${property}")
40 return currentValue
41 }
42
43 override fun setValue(thisRef: T, property: KProperty<*>, value: V) {
44 Log.i(tag, "thisRef=${thisRef},property=${property},value=${value}")
45 currentValue = value
46 paramsMap[property.name] = value
47 }
48 }
49
50}这个埋点抽象类主要的作用在：
- 定义了埋点一些基础属性，如
eventId等 - 利用 Kotlin 的
属性委托，定义每种常用的基础数据类型的委托代理方法 - 定义上报埋点的方法
这里新的思路就是：利用 Kotlin 中的属性委托类 ReadWriteProperty 来处理每个属性的 get 和 set，通过这个委托代理，收集和处理每个字段的值。其实就是起到一个拦截属性赋值和获取值的作用。
当有新的埋点时，我们可以这样定义埋点数据。比如我们常见的 Show 埋点：
1class ShowEvent : BaseEventTrack() {
2 override val eventId: String
3 get() = "show"
4 override val eventTrackCategory: String
5 get() = "10001"
6
7 /**
8 * 页面停留时间
9 */
10 var pageTime by long()
11
12 /**
13 * 场景
14 */
15 var sceneName by string()
16
17}触发上报
埋点数据类封装好了之后，那么怎么给数据赋值和触发上报呢？这里使用inline函数，定义一个全局的静态方法，具体内容如下：
1/**
2 * @param block 初始化函数
3 */
4inline fun <reified T : BaseEventTrack> uploadEvent(crossinline block: T.() -> Unit) {
5 kotlin.runCatching {
6 // 实例化泛型T
7 val clz = T::class.java
8 val instance = clz.getDeclaredConstructor()
9 instance.isAccessible = true
10 val tInstance = instance.newInstance()
11 // 触发对象初始化
12 block.invoke(tInstance)
13 // 触发上报
14 tInstance.upload()
15 }.onFailure {
16 // 抛出异常，或者使用兜底方案
17 Log.w("EventTrack", "upload event error,message=${it.message}")
18 }
19}这个方法的参数是一个类型 T 的扩展函数类型，这个函数内部主要做的是初始化埋点数据字段的值。而方法内部的逻辑主要有：
- 对泛型 T 进行实例化，构造对象
- 触发对象的初始化操做，即对埋点字段赋值
- 触发埋点的上报
注意：这里的方法中的
reified必须加上，否则我们无法实例话一个泛型类型，这也是和 Java 不同的地方
比如上面的 Show 埋点，我们在使用的时候，可以这么使用：
1fun uploadShowStat(){
2 uploadEvent<ShowEvent> {
3 sceneName = "七郎"
4 pageTime = 100
5 }
6}这样用起来是不是很方便呢~~~~
总结
这里的新思路，利用了 kotlin 的属性委托和reified的特性，实现了一种埋点参数封装的方式，这种方式优点是：使用管理起来非常的方便，每个埋点都对应一个类，代码可读性较好。缺点是：过程中可能会参数一些额外的类。
当然上面只是提供了一种思路，一些细节没有提到，比如一些异常处理，兜底逻辑，线程安全等，有兴趣的可以在上面的基础上实现。