• Android Kotlin Retrofit 与Flow。两个Flow用LiveData来进行分解

    这里用到了网络。。用的php构建的假数据

     核心代码如下

    2. // ---------------------------引入接口参数类(以用户实际路径为准)---------------------------------
    3. namespace App\Services\test;
    4.  
    5. use App\Common\Services\BaseService;
    6. use App\Http\Controllers\ExpressController;
    7. use App\Services\express\ExpressService;
    8. use App\Services\utils\IpServices;
    9.  
    10. class TestService extends BaseService
    11. {
    12.     public function index($key): \Illuminate\Http\JsonResponse
    13.     {
    14.  
    15.         $data = array();
    16.         $dataSub = array();
    17.         $dataSub['text'] = $key . "乱七八糟噢噢噢噢的数据";
    18.         $dataSub['id'] = 1;
    19.         $data[] = $dataSub;
    20.  
    21.         $dataSub['text'] = $key . "你说不用自作自受自己创造伤悲，写歌的人就应该有伤悲";
    22.         $dataSub['id'] = 2;
    23.         $data[] = $dataSub;
    24.  
    25.         $dataSub['text'] = $key . "去吗，配吗 这褴褛的披风";
    26.         $dataSub['id'] = 3;
    27.         $data[] = $dataSub;
    28.  
    29.  
    30.         return $this->apiSuccess("1", $data);
    31.  
    32.     }
    33.  
    34. }

    最后返回json结果如下

    1. {
    2. 	"code": 20000,
    3. 	"message": "1",
    4. 	"data": [{
    5. 		"text": "123乱七八糟噢噢噢噢的数据",
    6. 		"id": 0
    7. 	}, {
    8. 		"text": "123你说不用自作自受自己创造伤悲，写歌的人就应该有伤悲",
    9. 		"id": 1
    10. 	}, {
    11. 		"text": "123去吗，配吗 这褴褛的披风",
    12. 		"id": 1
    13. 	}]
    14. }

    好 正题开始咯

     

    1. package com.example.android_flow_practice.net
    2.  
    3. import com.example.android_flow_practice.model.Article
    4. import com.example.android_flow_practice.model.NetResponse
    5. import retrofit2.http.GET
    6. import retrofit2.http.Query
    7.  
    8.  
    9. interface ArticleApi {
    10.  
    11.     @GET("api/v1/open/test")
    12.     suspend fun searchArticles(
    13.         @Query("key") key: String
    14.     ): NetResponse>
    15. }

     

    1. package com.example.android_flow_practice.net
    2.  
    3. import okhttp3.OkHttpClient
    4. import retrofit2.Retrofit
    5. import retrofit2.converter.gson.GsonConverterFactory
    6. import retrofit2.create
    7.  
    8. object RetrofitClient {
    9.     val url = "https://xxx.xxx.com/";
    10.     private val instance: Retrofit by lazy {
    11.         Retrofit.Builder().client(OkHttpClient.Builder().build()).baseUrl(url)
    12.             .addConverterFactory(GsonConverterFactory.create()).build()
    13.     }
    14.  
    15.  
    16.     val articleApi: ArticleApi by lazy {
    17.         instance.create(ArticleApi::class.java)
    18.     }
    19. }

    依然是马赛克的url。。多余的靠自己

    准备adapter

    1. package com.example.android_flow_practice.adapter
    2.  
    3. import android.content.Context
    4. import android.view.LayoutInflater
    5. import android.view.ViewGroup
    6. import androidx.recyclerview.widget.RecyclerView
    7. import com.example.android_flow_practice.databinding.ItemArticleBinding
    8. import com.example.android_flow_practice.databinding.ItemUserBinding
    9. import com.example.android_flow_practice.db.User
    10. import com.example.android_flow_practice.model.Article
    11.  
    12. class ArticleAdapter(private val context: Context) : RecyclerView.Adapter() {
    13.  
    14.     private val data = ArrayList
      ()
    15.     fun setData(data: List<Article>) {
    16.         this.data.clear()
    17.         this.data.addAll(data);
    18.         notifyDataSetChanged()
    19.     }
    20.  
    21.     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BindingViewHolder {
    22.         val binding = ItemArticleBinding.inflate(LayoutInflater.from(context), parent, false)
    23.         return BindingViewHolder(binding = binding)
    24.     }
    25.  
    26.     override fun getItemCount(): Int {
    27.         return data.size
    28.     }
    29.  
    30.     override fun onBindViewHolder(holder: BindingViewHolder, position: Int) {
    31.         val item = data[position]
    32.         val binding = holder.binding as ItemArticleBinding
    33.         binding.text.text = "${item.id}, ${item.text}"
    34.  
    35.     }
    36. }

    对应的viewHolder

    1. package com.example.android_flow_practice.adapter
    2.  
    3. import androidx.recyclerview.widget.RecyclerView
    4. import androidx.viewbinding.ViewBinding
    6.  
    7. class BindingViewHolder(val binding: ViewBinding) : RecyclerView.ViewHolder(binding.root) {}

    布局

    1. <?xml version="1.0" encoding="utf-8"?>
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    3.     android:layout_width="match_parent"
    4.     android:layout_height="wrap_content"
    5.     android:orientation="vertical">
    6.  
    7.     <androidx.appcompat.widget.AppCompatTextView
    8.         android:id="@+id/text"
    9.         android:layout_width="match_parent"
    10.         android:layout_height="wrap_content"
    11.         android:layout_gravity="center"
    12.         android:gravity="center"
    13.         android:paddingVertical="4dp"
    14.         android:textSize="26sp" />
    15.  
    16. </LinearLayout>

    然后adapter是在Fragment当中的 

    Fragment布局

    1. <?xml version="1.0" encoding="utf-8"?>
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    3.     xmlns:tools="http://schemas.android.com/tools"
    4.     android:layout_width="match_parent"
    5.     android:layout_height="match_parent"
    6.     xmlns:app="http://schemas.android.com/apk/res-auto"
    7.     android:orientation="vertical"
    8.     tools:context=".fragment.UserFragment">
    9.  
    10.     <androidx.appcompat.widget.AppCompatEditText
    11.         android:id="@+id/ed_search"
    12.         android:layout_width="match_parent"
    13.         android:layout_height="wrap_content"
    14.         android:hint="Input keyword for search"
    15.         android:padding="8.dp"
    16.  
    17.         />
    18.  
    19.     <androidx.recyclerview.widget.RecyclerView
    20.         android:id="@+id/rv"
    21.         app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
    22.         android:layout_width="match_parent"
    23.         android:layout_height="match_parent" />
    24.  
    25.  
    26. </LinearLayout>

     布局完事以后代码

    1. package com.example.android_flow_practice.fragment
    2.  
    3. import android.os.Bundle
    4. import android.text.Editable
    5. import android.text.TextWatcher
    6. import android.util.Log
    7. import androidx.fragment.app.Fragment
    8. import android.view.LayoutInflater
    9. import android.view.View
    10. import android.view.ViewGroup
    11. import android.widget.TextView
    12. import androidx.fragment.app.viewModels
    13. import androidx.lifecycle.lifecycleScope
    14. import com.example.android_flow_practice.R
    15. import com.example.android_flow_practice.adapter.ArticleAdapter
    16. import com.example.android_flow_practice.databinding.FragmentArticleBinding
    17. import com.example.android_flow_practice.databinding.FragmentDownloadBinding
    18. import com.example.android_flow_practice.viewmodel.ArticleViewModel
    19. import com.example.android_flow_practice.viewmodel.UserViewModel
    20. import kotlinx.coroutines.channels.awaitClose
    21. import kotlinx.coroutines.flow.Flow
    22. import kotlinx.coroutines.flow.callbackFlow
    23. import kotlinx.coroutines.flow.collect
    24.  
    25.  
    26. class ArticleFragment : Fragment() {
    27.     private val TAG = "ArticleFragment"
    28.     private val viewModel: ArticleViewModel by viewModels()
    29.  
    30.     private val mBinding: FragmentArticleBinding by lazy {
    31.         FragmentArticleBinding.inflate(layoutInflater)
    32.     }
    33.  
    34.     override fun onCreateView(
    35.         inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
    36.     ): View? {
    37.         // Inflate the layout for this fragment
    38.         return mBinding.root
    39.     }
    40.  
    41.  
    42.     override fun onActivityCreated(savedInstanceState: Bundle?) {
    43.         super.onActivityCreated(savedInstanceState)
    44.         lifecycleScope.launchWhenCreated {
    45.             mBinding.edSearch.textWatcherFlow().collect {
    46.                 Log.e(TAG, "onActivityCreated: ${it}")
    47.                 viewModel.searchArticles(it)
    48.             }
    49.         }
    50.         context?.let {
    51.             val adapter = ArticleAdapter(it)
    52.             mBinding.rv.adapter = adapter
    53.             viewModel.articles.observe(viewLifecycleOwner, { artices ->
    54.                 adapter.setData(artices)
    55.             })
    56.         }
    57.  
    58.  
    59.     }
    60.  
    61.     //获取关键字
    62.  
    63.     fun TextView.textWatcherFlow(): Flow = callbackFlow {
    64.         val textWatcher = object : TextWatcher {
    65.             override fun beforeTextChanged(
    66.                 s: CharSequence?, start: Int, count: Int, after: Int
    67.             ) {
    68.             }
    69.  
    70.             override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
    71.             }
    72.  
    73.             override fun afterTextChanged(s: Editable?) {
    74.                 trySend(s.toString()).isSuccess
    75.  
    76.             }
    77.         }
    78.         addTextChangedListener(textWatcher)
    79.         awaitClose { removeTextChangedListener(textWatcher) }
    80.     }
    81. }

    核心代码存放与viewModel当中

    1. package com.example.android_flow_practice.viewmodel
    2.  
    3. import android.app.Application
    4. import androidx.lifecycle.AndroidViewModel
    5. import androidx.lifecycle.MutableLiveData
    6. import androidx.lifecycle.viewModelScope
    7. import com.example.android_flow_practice.model.Article
    8. import com.example.android_flow_practice.net.RetrofitClient
    9. import kotlinx.coroutines.Dispatchers
    10. import kotlinx.coroutines.flow.*
    11. import kotlinx.coroutines.launch
    12. import okhttp3.Dispatcher
    15. class ArticleViewModel(app: Application) : AndroidViewModel(app) {
    16.     val articles = MutableLiveData<List<Article>>()
    18.     fun searchArticles(key: String) {
    19.         viewModelScope.launch {
    20.             flow {
    21.                 val list = RetrofitClient.articleApi.searchArticles(key)
    22.                 emit(list)
    23.             }.flowOn(Dispatchers.IO).catch { e -> e.printStackTrace() }.collect {
    24.                 it.data.let {
    25.                     articles.setValue(it)
    26.                 }
    28.             }
    29.         }
    30.     }
    31. }

    这里简单拆析下这里

     使用flow 监听 

    afterTextChanged 将文本变动后的数据返回过来。

    又监听其关闭方法

    awaitClose 对textWather进行解除监听也就是释放

    这是其一

    其二 将viewModel的搜索列表数据弄到了articles

     然后再次对其进行监听 这样结构数据就不是collect{  collect{} }了

    那我们试下这种错误的写法看看会怎么样

    collect{  collect{} }

    viewModel中复制修改

    1.  
    2.     fun searchArticles2(key: String) = flow {
    3.         val list = RetrofitClient.articleApi.searchArticles(key)
    4.         emit(list)
    5.     }.flowOn(Dispatchers.IO).catch { e -> e.printStackTrace() }

    fragment也有所改变

    1.  override fun onActivityCreated(savedInstanceState: Bundle?) {
    2.         super.onActivityCreated(savedInstanceState)
    3.         lifecycleScope.launchWhenCreated {
    4.             mBinding.edSearch.textWatcherFlow().collect {
    5.                 Log.e(TAG, "onActivityCreated: ${it}")
    6.                 viewModel.searchArticles2(it).collect{ dataList->
    7.                     context?.let {
    8.                         val adapter = ArticleAdapter(it)
    9.                         mBinding.rv.adapter = adapter
    10.                         adapter.setData(dataList.data)
    11.                     }
    12.                 }
    13.             }
    14.         }

    这样做依然没有问题

    但是并不推荐。 

    因为collect{  collect{} } 并不是流的设计思想。。

    collect{  }

    collect{} 这种事

    你可以明显的感觉到 使用上述不推荐的写法

    collect{  collect{} } 这种写法。速度完全跟不上

    1. collect{  }
    2.  
    3. collect{}

  • 相关阅读:
    【系统性】 循序渐进学C++
    树、二叉树、堆及其应用（堆排序、top-k问题）
    GO语言gin框架实战-03-swagger和接口文档
    HBase RowKey 的设计原则？
    3D+AR技术的应用，让时尚行业玩出新花样！
    分布式.远程调用技术概述
    将博客搬至CSDN
    安全性归约（游戏）
    Linux静态IP、DNS配置（VM的三种网络模式）
    这个Spring Security登录插件牛啊，验证码、小程序、OAuth2都能快速接入
  • 原文地址：https://blog.csdn.net/mp624183768/article/details/126807181