Kotlin-SharedPreference封裝

一、App

class App : Application() {
    companion object {
        lateinit var instance: Application
                     private set

    }

    override fun onCreate() {
        super.onCreate()
        instance = this

    }
}

二、SharedPreferences

class Preference<T>() {
    private var keyName: String? = null
    private var defaultValue: T? = null

    constructor(keyName: String,defaultValue: T) : this() {
        this.keyName = keyName
        this.defaultValue = defaultValue
    }

    private val prefs: SharedPreferences by lazy {
       App.instance.applicationContext.getSharedPreferences("default", Context.MODE_PRIVATE)
    }

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T  {
        Log.e("info", "調用$this 的getValue()")
        return findSharedPreference(keyName!!, defaultValue!!)
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        Log.e("info", "調用$this 的setValue() value參數值爲：$value")
        putSharedPreferences(keyName!!, value)
    }


    /**
     * 查找數據 返回一個具體的對象
     * 沒有查找到value 就返回默認的序列化對象，然後經過反序列化返回
     */
    @Suppress("UNCHECKED_CAST")
    private fun  findSharedPreference(name: String, default: T): T = with(prefs) {
        val res: Any = when (default) {
            is Long -> getLong(name, default)
            is String -> getString(name, default)
            is Int -> getInt(name, default)
            is Boolean -> getBoolean(name, default)
            is Float -> getFloat(name, default)
            else -> deSerialization(getString(name, serialize(default)))
        }
        res as T
    }

    @SuppressLint("CommitPrefEdits")
    private fun  putSharedPreferences(name: String, value: T) = with(prefs.edit()) {
        when (value) {
            is Long -> putLong(name, value)
            is String -> putString(name, value)
            is Int -> putInt(name, value)
            is Boolean -> putBoolean(name, value)
            is Float -> putFloat(name, value)
            else -> putString(name, serialize(value))
        }.apply()
    }


    /**
     * 刪除全部數據
     */
    fun clear() {
        Log.e("info", "調用$this clear()")
        prefs.edit().clear().commit()
    }

    /**
     * 根據key刪除存儲數據
     */
    fun remove(key: String) {
        Log.e("info", "調用$this remove()參數值爲：$key")
        prefs.edit().remove(key).commit()
    }

    /**
     * 序列化對象
     */
    @Throws(Exception::class)
    private fun <T> serialize(obj: T): String {
        val byteArrayOutputStream = ByteArrayOutputStream()
        val objectOutputStream = ObjectOutputStream(
                byteArrayOutputStream)
        objectOutputStream.writeObject(obj)
        var serStr = byteArrayOutputStream.toString("ISO-8859-1")
        serStr = java.net.URLEncoder.encode(serStr, "UTF-8")
        objectOutputStream.close()
        byteArrayOutputStream.close()
        return serStr
    }

    /**
     * 反序列化對象
     */
    @Throws(Exception::class)
    private fun <T> deSerialization(str: String): T {
        val redStr = java.net.URLDecoder.decode(str, "UTF-8")
        val byteArrayInputStream = ByteArrayInputStream(
                redStr.toByteArray(charset("ISO-8859-1")))
        val objectInputStream = ObjectInputStream(
                byteArrayInputStream)
        val obj = objectInputStream.readObject() as T
        objectInputStream.close()
        byteArrayInputStream.close()
        return obj
    }


}

三、使用

1 getValue

    private var numCodeValue by Preference("numCode_key", 0)
    private var booleanValue  by Preference("boolean_key", false)
    private var setValue  by Preference("set_key",setOf(""))
    private var stringValue  by Preference("string_key","")

2 putValue
numCodeValue = 1000
booleanValue = true
setValue = setOf(“abc”, “def”,“123”)
stringValue = “String”

3 獲取 SharedPreferences

   val prefs: Preference<String> = Preference()

4 remove

   prefs.remove("numCode_key")
   prefs.remove("string_key")

5 clear

        prefs.clear()
        //clear 之後再獲取， 獲取的值是默認值

參考
Kotlin偏好設置