val rxCache:RxCache by lazy {

    RxCache.config {                     // 初始化 RxCache, 并配置二级缓存
        RxCache.Builder().memory {
            FIFOMemoryImpl()
        }.persistence {
            val cacheDirectory = File(diskCache) // rxCache 持久层存放地址
            if (!cacheDirectory.exists()) {
                cacheDirectory.mkdir()
            }
            OkioImpl(cacheDirectory)
        }
    }

    RxCache.getRxCache()
}

        RxCache.config(RxCache.Builder())

        val rxCache = RxCache.getRxCache()

        val list = ArrayList<User>()

        val u1 = User()
        u1.name = "tony1"
        u1.password = "123456"
        list.add(u1)

        val u2 = User()
        u2.name = "tony2"
        u2.password = "123456"
        list.add(u2)
        rxCache.save<List<User>>("test", list)

        val observable = rxCache.load2Observable<List<User>>("test")

        observable.subscribe {
            val recordDataList = it.data

            if (Preconditions.isNotBlank(recordDataList)) {

                val user = recordDataList[0]
                println(user.name)
                println(user.password)
            }
        }

    RxCache.config(RxCache.Builder())

    val rxCache = RxCache.getRxCache()

    rxCache.saveFunc("test1") {
        val u = User()
        u.name = "tony"
        u.password = "123456"
        u
    }

    rxCache.get<User>("test1")?.let {

        val u = it.data

        println(u.name)
        println(u.password)
    }

    rxCache.saveFunc("test2",5, TimeUnit.SECONDS) {

        val u = User()
        u.name = "tony"
        u.password = "123456"
        u
    }

    try {
        Thread.sleep(2300)
    } catch (e: InterruptedException) {
        e.printStackTrace()
    }

    println("ttl=" + rxCache.ttl("test2", User::class.java))
}

fun main() = runBlocking {

    RxCache.config(RxCache.Builder())

    val rxCache = RxCache.getRxCache()

    rxCache.saveFunc("test1") {
        val u = User()
        u.name = "tony"
        u.password = "123456"
        u
    }

    rxCache.saveFunc("test2") {
        "hello world"
    }

    rxCache.saveFunc("test3") {
        0
    }

    val deferred1 =  rxCache.getDeferred<User>("test1",User::class.java)

    val deferred2 = rxCache.getDeferred<String>("test2",String::class.java)

    println(deferred1.await().name + "," + deferred2.await())

    rxCache.getFlow<Int>("test3",String::class.java)
            .map {
                var sum = it
                for (i in 1..100) {
                    sum += i
                }
                sum
            }
            .flowOn(IO)
            .collect{
                println(it)
            }
}

    RxCache.config(RxCache.Builder())

    val rxCache = RxCache.getRxCache()

    rxCache.saveFunc("test1") {
        val u = User()
        u.name = "tony"
        u.password = "123456"
        u
    }

    rxCache.getResult<User>("test1").get()?.takeIf { it is User }?.let {
        it as User

        print(it.name)
        println(it.password)
    }

    rxCache.saveFunc("test2") {
        "hello world"
    }

    rxCache.getResult<String>("test2").get()?.takeIf { it is String }?.let {
        println(it)
    }

    val result = rxCache.getResult<String>("test2").map {
        it + ", hello kotlin"
    }.get()

    println(result)