通过Redrofit和Rxjava的结合使用把子线程请求的数据加载到RecyclerView并创建单例模式的Retrofit

最新推荐文章于 2024-05-20 11:54:40 发布

Dosjanas

最新推荐文章于 2024-05-20 11:54:40 发布

阅读量198

点赞数 3

文章标签： rxjava 单例模式 retrofit android

本文链接：https://blog.csdn.net/weixin_52318455/article/details/133812554

版权

使用单例模式创建Retrofit

单例模式是一种设计模式，它的作用是一个类只有一个示例。

在使用retrofit的单例模式时，有饿汉式单例模式和懒汉式结合synchronized的双检锁/双重校验锁模式

1. 饿汉式优点：
  1. 线程安全
  2. 简单
2. 双检锁/双重校验锁模式优点
  1. 节省内存，当在第一次使用时创建retrofit。
使用饿汉式

public class RetrofitClient {

    private static String URL = "https://xxx.com.cn";

    private static final Retrofit retrofit = new Retrofit.Builder()

            .baseUrl(URL)

            .addConverterFactory(GsonConverterFactory.create())//解析转换GSON代码

            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

            .build();



    public RetrofitClient() {

    }

    public static Retrofit getRetrofit() {

        return retrofit;

    }

}

使用双检锁/双重校验锁（DCL, Double Checked Locking）：这种方式下，单例实例在第一次使用时创建。它结合了懒汉式和synchronized锁。

public class RetrofitClient {

    private static final String BASE_URL = "https://example.com/api/";

    private static volatile Retrofit retrofit = null;



    private RetrofitClient() {

    }  // 私有化构造函数



    public static Retrofit getInstance() {

        if (retrofit == null) {

            synchronized (RetrofitClient.class) {

                if (retrofit == null) {

                    retrofit = new Retrofit.Builder()

                        .baseUrl(BASE_URL)

                        .addConverterFactory(GsonConverterFactory.create())

                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

                        .build();

                }

            }

        }

        return retrofit;

    }

}

1. volatile
  1. volatile是Java中的一个关键字，用于声明一个变量为"易变的"。在Java并发编程中，它有以下的重要特性：
    1. 可见性：当一个共享变量被声明为volatile，它可以确保修改的值立即对其他线程可见。这意味着，当一个线程修改了一个volatile变量的值，其他线程读取这个变量时会看到最新的修改。
    2. 禁止指令重排：在Java中，为了提高程序的执行效率，编译器和处理器可能会对指令进行重排序。但有时这可能会导致多线程程序的不正确行为。声明变量为volatile可以确保对该变量的读/写操作不会与其它读/写操作重排序。
加载

Retrofit retrofit = RetrofitClient.getRetrofit();

GetPostRequest request = retrofit.create(GetPostRequest.class);

使用RxJava进行异步操作

retrofit的接口方法为

public interface GetPostRequest {

@POST("/xxx/xxx")

Flowable<TranslateListBean> requestGetListResult(@Body okhttp3.RequestBody params);

}

解释以上代码内容：

@POST("xxxxxxx")：
1. @POST:是一个Retrofit的注解，它指示这个方法会发送一个HTTP POST请求。
2. "xxxxxxx":是请求的相对URL。假设您在Retrofit的创建时设置的基础URL为https://api.example.com/，那么完整的请求URL将是https://api.example.com/xxxxxx。
Flowable<TranslateListBean>：
1. Flowable:是RxJava 2中的一个类，它表示一个异步操作的结果。这表示该方法不会立即返回结果，而是返回一个表示结果的Flowable对象。
2. TranslateListBean:是这个异步操作的结果类型。这通常是一个POJO（Plain Old Java Object），它可以通过Gson或其他JSON解析库将服务器的响应解析成Java对象。
3. 在这里TranslateListBean是一个javaBean对象，通常是根据服务器返回的数据类型而创建的JavaBean类
requestGetListResult(@Body okhttpRequestBody params)：
1. requestGetListResult:是这个方法的名称。
2. @Body: 是一个Retrofit的注解，它指示后面的参数params应该作为请求的消息体发送。
3. okhttp3.RequestBody:是OkHttp库中的一个类，它表示一个HTTP请求的消息体。您可以使用它来发送JSON、XML或其他类型的数据。

为什么用RxJava

在android中如果你要更新UI相关操作，那么你必须在主线程中进行，如果你的数据在IO当中，那么你有以下两种方法实现方式：
1. 使用 Handler

Handler handler = new Handler(Looper.getMainLooper());



new Thread(new Runnable() {

    @Override

    public void run() {

        //进行网络请求或其他操作

        final String result = "你要返回的数据"

        handler.post(new Runnable() {

            @Override

            public void run() {

                translateUg = result;

                Log.d(TAG, "run: " + translateUg);

            }

        });

    }

}).start();

1. 使用 runOnUiThread
  1. 如果你在Activity或Fragment的上下文中，你可以直接调用runOnUiThread方法：

new Thread(new Runnable() {

    @Override

    public void run() {

         //进行网络请求或其他操作

        final String result = "你要返回的数据"

        runOnUiThread(new Runnable() {

            @Override

            public void run() {

                translateUg = result;

                Log.d(TAG, "run: " + translateUg);

            }

        });

    }

}).start();

使用RxJava是因为完美解决在子线程进行网络请求之后把获取到的数据返回给主线程，更新UI。

RxJava使用

以下我使用Retrofit进行网络请求时结合RxJava实现子线程请求数据在主线程更新UI

首先引入依赖（在module:Gradle文件当中引入）

dependencies {

    //Retrofit

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'

    //Gson

    implementation "com.squareup.retrofit2:converter-gson:2.0.2"

    //RxJava设配器

    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'

    implementation 'io.reactivex.rxjava2:rxjava:2.2.21'

    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'           

}

在Retrofit时

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

使用

request.requestGetListResult(requestBody)

        .subscribeOn(Schedulers.io())//执行在io线程上

        .observeOn(AndroidSchedulers.mainThread())

        .subscribe(new Consumer<TranslateListBean>() {

            @Override

            public void accept(TranslateListBean translateListBean) throws Exception {

                //在这里更新UI

            }

        }, new Consumer<Throwable>() {

            @Override

            public void accept(Throwable throwable) throws Exception {

                //处理情况，或异常

                Log.d(TAG, "失败:" + throwable);

            }

        });

以上代码详细介绍

request.requestGetListResult(requestBody):这是你Retrofit服务接口中的一个方法调用，返回一个Observable<TranslateListBean>或类似的RxJava类型。Observable是RxJava中表示一个异步操作的核心抽象。
.subscribeOn(Schedulers.io()):subscribeOn指定Observable本身（即数据发射、数据流产生）在哪个调度器（Scheduler）上执行。Schedulers.io()是RxJava提供的一种调度器，它内部具有一个无界的线程池，因此可以处理大量的IO-bound工作。在这种情况下，你希望网络请求在IO线程上执行，避免在主线程上进行IO操作，因为这可能会导致UI卡顿。
.observeOn(AndroidSchedulers.mainThread()):observeOn指定Observable发射的数据在哪个调度器上被消费，即你的观察者（Observer）在哪个线程上接收和处理数据。AndroidSchedulers.mainThread()是RxAndroid提供的特殊调度器，它指定观察者运行在Android主线程上。这在Android开发中是很重要的，因为UI操作（如更新视图）必须在主线程上执行。
.subscribe(...):这是你开始观察Observable发射的数据的地方。当你订阅一个Observable时，你实际上启动了整个异步操作流。你提供了两个Consumer给subscribe方法：
1. 第一个

Consumer处理成功的数据，即TranslateListBean类型的数据。当Retrofit成功完成网络请求并且数据被解析为TranslateListBean对象时，这个Consumer会被调用，并将TranslateListBean作为参数传递。

1. 第二个

Consumer处理错误。如果在整个数据流中的任何地方出现错误，比如网络故障、数据解析错误等，这个Consumer会被调用，并将错误的Throwable作为参数传递。

总结：这段代码使用Retrofit和RxJava进行异步网络请求。请求在IO线程上执行，成功或失败的结果在Android主线程上处理。这使得你可以方便地在主线程上更新UI，而不用担心手动管理线程或处理Android的AsyncTask。

Map转换成Json并创建requestBody对象

Map<String, String> maps = new HashMap<>();

maps.put("content", content);

maps.put("source", "izdaxIME_Android");

maps.put("source_flag", "cn.izdax.ime");

//Map键值对转换成Json

String jsonParams = new Gson().toJson(maps);

//创建requestBody对象

RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);

到这里完整代码

我是使用了饿汉式单例模式

public class RetrofitClient {

    private static String URL = "xxx/ds/ds/cn";

    private static final Retrofit retrofit = new Retrofit.Builder()

            .baseUrl(URL)

            .addConverterFactory(GsonConverterFactory.create())//解析转换GSON代码

            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

            .build();



    public RetrofitClient() {

    }

    public static Retrofit getRetrofit() {

        return retrofit;

    }

}

public interface GetPostRequest {

    @POST("/xxx/ds")

    Flowable<TranslateListBean> requestGetListResult(@Body okhttp3.RequestBody params);

}

public class NetworkRequest {

    private static final String TAG = "NetworkRequest";

    //回调方法



    public void RetrofitUgToZh(String content) {

        Map<String, String> maps = new HashMap<>();

        maps.put("content", content);

        maps.put("source", "dddd");

        maps.put("source_flag", "xxxx");

        //Map键值对转换成Json

        String jsonParams = new Gson().toJson(maps);

        //创建requestBody对象

        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);

        //加载Retrofit（单例模式）

        Retrofit retrofit = RetrofitClient.getRetrofit();



        GetPostRequest request = retrofit.create(GetPostRequest.class);

        //引用RxJava

        request.requestGetListResult(requestBody)

                .subscribeOn(Schedulers.io())//执行在io线程上

                .observeOn(AndroidSchedulers.mainThread())//安卓主线程

                .subscribe(new Consumer<TranslateListBean>() {

                    @Override

                    public void accept(TranslateListBean translateListBean) throws Exception {

                           //在这里更新UI

                    }

                }, new Consumer<Throwable>() {

                    @Override

                    public void accept(Throwable throwable) throws Exception {

                       //处理情况，或异常

                            Log.d(TAG, "失败:" + throwable);

                    }

                });

    }
}

简单介绍RxJava

RxJava简介

RxJava是响应式编程的Java实现。响应式编程是一个编程范例，目的是对异步数据流进行建模。RxJava能够简化异步操作的处理，特别是在处理复杂的链式异步操作时。

RxJava的主要组件

Observable (被观察者)
Observer (观察者)
Schedulers
Operators

RxJava的用途

简化异步代码
链式操作
统一错误处理
线程切换

什么情况下使用RxJava

复杂的异步操作
处理流式数据
当你需要复用、组合或转换异步操作的结果

总结

RxJava为异步和基于事件的程序提供了一种强大而灵活的方式，允许开发者更容易地构建和理解复杂的数据流和操作链。但是，与所有工具一样，它在某些场景下可能是过度的。如果你只是进行简单的异步任务，使用其他方法，如Android的AsyncTask或Java的Future，可能会更简单。但是，当你需要处理更复杂的异步操作时，RxJava会成为一个非常有价值的工具。

使用子线程请求的数据

下面我将在RecyclerView中使用这些数据（这些返回的数据是TranslateListBean类）

浅认识安卓中的单向数据绑定

单向绑定是安卓单中非常有用的概念，它可以把JavaBean数据自动反映在UI界面，当这个数据发生变化时UI上的数据也发生实时变化，从而无需再布局页面上手动更内容。

在当前module的gradle中添加以下代码

android {

dataBinding {

enable=true

}

修改布局文件：

<layout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    >

    <data>

        <variable

            name="ui_info"

            type="com.example.translate1.bean.InputTranslateText" />

    </data>

    <RelativeLayout

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:background="@color/WhiteSmoke"

        android:clipChildren="false">

    </RelativeLayout>

</layout>

将根元素替换为layout,当我们添加<data>标签时当前页面自动设别为数据绑定布局，并自动生成和当前布局文件的名字改成驼峰命名法，以下划线后首字母大写+Binding为命名的类。例如：

布局名actytity_main.xml--->生成ActivityMainBinding的类。

绑定数据模型

ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);

MyViewModel viewModel = new MyViewModel();

binding.setViewModel(viewModel);

InputTranslateText的内容

public class InputTranslateText {

    private String inputText;

    public String getInputText() {

        return inputText;

    }

    public void setInputText(String inputText) {

        this.inputText = inputText;

    }

}

使用

<layout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    >

    <data>

        <variable

            name="ui_info"

            type="com.example.translate1.bean.InputTranslateText" />

    </data>

    <RelativeLayout

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:background="@color/WhiteSmoke"

        android:clipChildren="false">

        <TextView

            android:layout_width="match_parent"

            android:layout_height="match_parent"

            android:gravity="center"

            android:text="@{ui_info.inputText}"

            android:textColor="@color/DodgerBlue" />

    </RelativeLayout>

</layout>

用@{}使用数据

在RecyclerView中使用数据绑定

在onCreateViewHolder中初始化绑定：

@Override

public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {

    LayoutInflater inflater = LayoutInflater.from(parent.getContext());

    TranslateItemBinding binding = DataBindingUtil.inflate(inflater, R.layout.translate_item, parent, false);

    return new ViewHolder(binding);

}

ViewHolder的定义：你的ViewHolder的构造函数应该接受一个绑定对象，并从绑定对象中获取itemView。

public static class ViewHolder extends RecyclerView.ViewHolder {

    final TranslateItemBinding binding;



    public ViewHolder(TranslateItemBinding binding) {

        super(binding.getRoot());

        this.binding = binding;

    }

}

在onBindViewHolder中绑定数据：

@Override

public void onBindViewHolder(@NonNull ViewHolder holder, int position) {

    TranslateListBean item = list.get(position);

    holder.binding.setTranslate(item);

    holder.binding.executePendingBindings(); // 确保立即执行绑定

}

完整代码

public class TranslateRecyclerAdapter extends RecyclerView.Adapter<TranslateRecyclerAdapter.ViewHolder> {

    private static final String TAG = "TranslateRecyclerAdapter";

    List<TranslateListBean> list;

    Context context;



    private TranslateItemBinding binding;



    public TranslateRecyclerAdapter(List<TranslateListBean> list, Context context) {

        this.list = list;

        this.context = context;

    }



    @NonNull

    @Override

    public TranslateRecyclerAdapter.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {

        LayoutInflater inflater = LayoutInflater.from(parent.getContext());

        binding = DataBindingUtil.inflate(inflater, R.layout.translate_item, parent, false);

        return new ViewHolder(binding);

    }



    @Override

    public void onBindViewHolder(@NonNull TranslateRecyclerAdapter.ViewHolder holder, int position) {

        TranslateListBean translateListBean = list.get(position);

        //执行绑定

        holder.binding.setTranslate(translateListBean);

        holder.binding.executePendingBindings();

        holder.binding.transitionInputText.setText(zh);

    }



    @Override

    public int getItemCount() {

        return list.size();

    }



    public static class ViewHolder extends RecyclerView.ViewHolder {

        final TranslateItemBinding binding;

        public ViewHolder(TranslateItemBinding binding) {

            super(binding.getRoot());

            this.binding = binding;



        }

    }

}

通过回调在activity中获得请求的数据并传给RecyclerView

public interface TranslateCallback {

    void Success(TranslateListBean translateListBean);

}

public class NetworkRequest {

    private static final String TAG = "NetworkRequest";

    public void RetrofitUgToZh(String content,TranslateCallback callback) {

        Map<String, String> maps = new HashMap<>();

        maps.put("content", content);

        maps.put("source", "xxx");

        maps.put("source_flag", "xx/cc");

        //Map键值对转换成Json

        String jsonParams = new Gson().toJson(maps);

        //创建requestBody对象

        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);

        //加载Retrofit（单例模式）

        Retrofit retrofit = RetrofitClient.getRetrofit();



        GetPostRequest request = retrofit.create(GetPostRequest.class);

        //引用RxJava

        request.requestGetListResult(requestBody)

                .subscribeOn(Schedulers.io())//执行在io线程上

                .observeOn(AndroidSchedulers.mainThread())

                .subscribe(new Consumer<TranslateListBean>() {

                    @Override

                    public void accept(TranslateListBean translateListBean) throws Exception {

                        callback.Success(translateListBean);

                    }

                }, new Consumer<Throwable>() {

                    @Override

                    public void accept(Throwable throwable) throws Exception {

                        Log.d(TAG, "失败:" + throwable);

                    }

                });

    }

}

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private NetworkRequest networkRequest;

    private ActivityMainBinding binding;

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        binding = DataBindingUtil.setContentView(this, R.layout.activity_main);

        networkRequest = new NetworkRequest();

            networkRequest.RetrofitUgToZh(text, new TranslateCallback() {

                @Override

                public void Success(TranslateListBean translateListBean) {

                    //将新添加的元素显示在最上面，translateListBean就是从服务器请求的数据。

                    list.add(0,translateListBean);

                    RecyclerView transitionRecycler = binding.transitionRecycler;

                    transitionRecycler.setAdapter(new TranslateRecyclerAdapter(list, MainActivity.this));

                    transitionRecycler.setLayoutManager(new LinearLayoutManager(MainActivity.this));

                }

            });

    }

   }

Dosjanas

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
通过Redrofit和Rxjava的结合使用把子线程请求的数据加载到RecyclerView并创建单例模式的Retrofit

RxJava是响应式编程的Java实现。响应式编程是一个编程范例，目的是对异步数据流进行建模。RxJava能够简化异步操作的处理，特别是在处理复杂的链式异步操作时。RxJava的主要组件Observable (被观察者)Observer (观察者)SchedulersOperatorsRxJava的用途简化异步代码链式操作统一错误处理线程切换什么情况下使用RxJava复杂的异步操作处理流式数据当你需要复用、组合或转换异步操作的结果总结。
复制链接

扫一扫