LiveData+retrofit封装（Java版本）附源码

retrofit网络封装

对android开发来说，常用Volley、okhttp、retofit等网络框架接受服务端信息，其中，由以refrotit最为火热，通常有3种方法对其进行使用：
1.常规retrofit使用如下：

call.enqueue(new Callback<Translation>() {
        @Override
        public void onResponse(Call<Translation> call, Response<Translation> response) {
            response.body().show();
        }

        @Override
        public void onFailure(Call<Translation> call, Throwable t) {
            System.out.println("连接失败");
        }
    });

}

2.RxJava+retofit封装后就形成简洁的链式调用:

 RetrofitFactory.getInstence().API()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<BaseEntity<ABean>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        
                    }
 
                    @Override
                    public void onNext(BaseEntity<ABean> aBeanBaseEntity) {
 
                    }
 
                    @Override
                    public void onError(Throwable e) {
 
                    }
 
                    @Override
                    public void onComplete() {
 
                    }
                });

3.LiveData+retrofit进行二次封装，由于google大力推行kotlin，所以封装以kotlin版本居多，但是我kotlin不熟啊😂，要是在项目中大量使用kotlin，怕不是得删库跑路。
所以机智如我，根据kotlin改编了一下，效果如下：

     mainViewModel.getJokeLiveData().observe(this, new Observer<GetJoke>() {
            @Override
            public void onChanged(GetJoke getJoke) {
                if (getJoke != null) {
                    activityMainBinding.setJoke(getJoke.getResult().get(0));
                }
            }
        });

4.LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者, 当 Activity 和 Fragment 的生命周期被销毁时，系统会立即退订它们。与RxJava相比，具有门槛低，防止内存泄漏的优点。

封装讲解

下面开始正题，demo在末尾,可直接下载,下篇会加入LiveData和ObservableField双向绑定。

1. 定义接收格式，如下：

2.定义服务器地址以及RetrofitManager

3.封装LiveDataCallAdapter

public class LiveDataCallAdapter<T> implements CallAdapter<T, LiveData<T>> {

    private Type responseType;
    private boolean isApiResponse;

     LiveDataCallAdapter(Type responseType, boolean isApiResponse) {
        this.responseType = responseType;
        this.isApiResponse = isApiResponse;
    }

    @Override
    public Type responseType() {
        return responseType;
    }

    @Override
    public LiveData<T> adapt(final Call<T> call) {
        return new MyLiveData<>(call, isApiResponse);
    }

    private static class MyLiveData<T> extends LiveData<T> {
        private AtomicBoolean start = new AtomicBoolean(false);
        private final Call<T> call;
        private boolean isApiResponse;

        MyLiveData(Call<T> call, boolean isApiResponse) {
            this.call = call;
            this.isApiResponse = isApiResponse;
        }

        @Override
        protected void onActive() {
            super.onActive();
            if (start.compareAndSet(false, true)) {
                call.enqueue(new Callback<T>() {
                    @Override
                    public void onResponse(@Nullable Call<T> call, @Nullable Response<T> response) {
                        T body = response.body();
                        postValue(body);
                    }

                    @Override
                    public void onFailure(@Nullable Call<T> call, @Nullable Throwable t) {
                        if (isApiResponse) {
                            postValue((T) new ApiResponse<>(ApiResponse.CODE_ERROR, t.getMessage()));
                        } else {
                            postValue(null);
                        }
                    }
                });
            }
        }
    }
}

4.封装LiveDataCallAdapterFactory

public class LiveDataCallAdapterFactory extends CallAdapter.Factory {
    @Nullable
    @Override
    public CallAdapter<?, ?> get(@Nullable Type returnType, @Nullable Annotation[] annotations, @Nullable Retrofit retrofit) {
        if (getRawType(returnType) != LiveData.class) {
            return null;
        }
        Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
        Type rawType = getRawType(observableType);
        boolean isApiResponse = true;
        if (rawType != ApiResponse.class) {
            isApiResponse = false;
        }
        if (observableType instanceof ParameterizedType) {
            throw new IllegalArgumentException("resource must be parameterized");
        }
        return new LiveDataCallAdapter<>(observableType, isApiResponse);
    }
}

5.定义Api接口以及服务器地址

参考文章：LiveData+Retrofit网络请求实战

github地址： https://github.com/zcyyouminghuo/mvvmRetrofit
CSDN资源: https://download.csdn.net/download/qq_42625299/13011094