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
package cn.flightfeather.thirdappmodule.common.database
 
import com.ping.greendao.gen.DaoSession
import org.greenrobot.greendao.AbstractDao
import retrofit2.Response
 
/**
 * @author riku
 * Date: 2019/4/25
 * 数据库操作步骤抽象
 */
 
/**
 * 向数据库保存实体信息
 * @param <T> Entity type
 * @param <K> Primary key (PK) type; use Void if entity does not have exactly one PK
 */
fun <E, K> flatMapDbSaveResult(dao: AbstractDao<E, K>, listener: FlatSaveInterface<E, K>): Boolean {
    val results = listener.onQuery(dao)
    try {
        return if (results.isEmpty()) {
            val entities = listener.onInsert()
            entities.forEach {
                dao.insert(it)
            }
            true
        } else {
            listener.onUpdate(results)
            results.forEach {
                dao.update(it)
            }
            true
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
    return false
}
 
interface FlatSaveInterface<E, K> {
    //保存前的步骤,查看要保存的数据是否存在
    fun onQuery(dao: AbstractDao<E, K>): List<E>
    //数据已存在,选择更新
    fun onUpdate(list: List<E>)
    //数据不存在,插入新的保存实体
    fun onInsert(): List<E>
}
 
/**
 * 向数据库保存网络获取的实体信息
 */
fun <E, K, T> FlatMapDbSaveResult(dao: AbstractDao<E, K>, response: Response<T>, listener: FlatSaveInterface<E, K>): Boolean {
    if (response.isSuccessful) {
        val results = listener.onQuery(dao)
        try {
            return if (results.isEmpty()) {
                val entities = listener.onInsert()
                entities.forEach {
                    dao.insert(it)
                }
                true
            } else {
                listener.onUpdate(results)
                results.forEach {
                    dao.update(it)
                }
                true
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    return false
}
 
/**
 * 获取数据库保存的列表信息
 */
fun<E, T, R> FlatMapDbReadList(daoSession: DaoSession, listener:FlatDbReadConversionListInterface<E, T, R>): ArrayList<R> {
    val result = listener.onQuery(daoSession)
    val list = ArrayList<T>()
    if (result.isNotEmpty()) {
        result.forEach {
            list.addAll(listener.onJson(it))
        }
    }
    val dataList = ArrayList<R>()
    list.forEach {
        dataList.add(listener.onConversion(it))
    }
    return dataList
}
 
//用于数据库中,需要将存储的字段按Json格式转换
interface FlatDbReadConversionListInterface<E,T, R> {
    //查询语句
    fun onQuery(d: DaoSession): List<E>
    //存储的Json转换为需要的实体
    fun onJson(e: E): List<T>
    //如果使用dataBinding, 则可以转换为对应的实体;或用于前端展示与网络传输的数据实体结构不同的情况
    fun onConversion(t: T): R
}
 
 
/**
 * 获取数据库保存的列表信息
 */
fun<E, T, R> FlatMapDbReadList(daoSession: DaoSession, listener:FlatDbReadConversionObjectInterface<E, T, R>): ArrayList<R> {
    val result = listener.onQuery(daoSession)
    val list = ArrayList<T>()
    if (result.isNotEmpty()) {
        result.forEach {
            list.add(listener.onBean(it))
        }
    }
    val dataList = ArrayList<R>()
    list.forEach {
        dataList.add(listener.onConversion(it))
    }
    return dataList
}
 
//用于数据库中,需要将完整的表转换为对应的bean实体
interface FlatDbReadConversionObjectInterface<E,T, R> {
    //查询语句
    fun onQuery(d: DaoSession): List<E>
    //存储的Json转换为需要的实体
    fun onBean(e: E): T
    //如果使用dataBinding, 则可以转换为对应的实体;或用于前端展示与网络传输的数据实体结构不同的情况
    fun onConversion(t: T): R
}