基于LeanCloud平台的REST API封装

最新推荐文章于 2023-11-10 00:14:00 发布

Bertram丶Tan

最新推荐文章于 2023-11-10 00:14:00 发布

阅读量1.9k

点赞数

分类专栏：封装文章标签： android okhttp3 retrofit2 rxjava2

本文链接：https://blog.csdn.net/tan958013863/article/details/78647440

版权

封装专栏收录该内容

1 篇文章 0 订阅

订阅专栏

自从知道了LeanCloud这个平台后，的确省了后台开发，可以直接操作云数据库，LeanCloud的数据是基于MongoDB搭建的，所以也是挺方便的，足够可以开发个人APP了，如果要用起来那肯定是一个框架用着舒服的，以后还是会慢慢完善的，现在只是一个基本的。

好了，废话不多说，首先看LeanCloud的文档，看到有数据存储，并且LeanCloud是只是REST API的，那么我们就针对这两个封装就好了，首先是LeanCloud自己提供的SDK，因为LeanCloud SDK中已经封装好了很多对象，可以直接用，而且配置好就能够直接使用，很方便，但是有些时候不想引用SDK去减轻APP的质量，所以必须要针对REST API去封装了，这里使用的是Retrofit 2 + OkHttp 3 + RxJava2 去封装的，途中算是遇到很多坑了，都一一踩了，我也很无奈啊！

我是LeanCloud SDK+LeanCloud 提供的REST API混合使用的

现在开始吧：
首先是引入Retrofit2
很明显，我们需要把retrofit提供的rxjava2也导进去，不然是不能配合rxjava2的

//retrofit2.0
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'
    compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

这里说明一下，要注意rxjava 还是rxjava2，这两个是有直接区别的，一开始我就引入的rxjava，然后发现一只出异常，后来自己检查一下，发现是引入的时候引入的是rxjava而不是rxjava2，这个是细心的问题
OK，接下来是引入rxjava2的包

//Rx
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'io.reactivex.rxjava2:rxjava:2.1.5'

引入这个没什么坑的，然后要引入Okhttp3的包
这里我直接用动态引入包了，但是推荐不要这样做，因为会增加编译时间的，最好选择固定的版本
目前官网最新的版本是3.9.1，需要可以直接写上去

//OkHttp包
    compile 'com.squareup.okhttp3:okhttp:3.+'
    compile 'com.squareup.okio:okio:1.13.0'
    compile 'com.squareup.okhttp3:logging-interceptor:3.+'

导入了之后，为了查看log更加美观，肯定少不了Logger的，现在我们来引入Logger的包

//Logger日志工具包
    compile 'com.orhanobut:logger:2.1.1'

基本的包都有了，现在开始配置Application类，然后绑定到Manefest文件中去
首先先定义一个基本的Common类，保存LeanCloud的Id和Key

public class Common {
    public static final String APP_ID = "LeanCloud的ID";
    public static final String APP_KEY = "LeanCloud的Key";

    public static final String x_LC_Id = "X-LC-Id:" + APP_ID;
    public static final String x_LC_Key = "X-LC-Key:" + APP_KEY;
    public static final String x_Lc_Key_Master = "X-LC-Key: LeanCloud中的master Key,master";//一般不要保存在本地
    private static String curTime = String.valueOf(System.currentTimeMillis());
    public static final String x_LC_Sign = "X-LC-Sign:" + MD5Utils.md5(curTime+APP_KEY)+","+curTime;
    //定义全局请求baseUrl
    public static String baseUrl = "https://"+APP_ID.substring(0,8)+".api.lncld.net/";
}

填好了之后，就开始写Application类了

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        //如果只使用REST API着不需要初始化AVOSloud
        AVOSCloud.initialize(this,CommonConfig.APP_ID, CommonConfig.APP_KEY);
        // 放在 SDK 初始化语句 AVOSCloud.initialize() 后面，只需要调用一次即可
        AVOSCloud.setDebugLogEnabled((getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0);
        // 直播 SDK 初始化（不使用直播就不需要配置LCLiveKit）
        LCLiveKit.getInstance().setProfileProvider(LCLKAppProvider.getInstance());
  LCLiveKit.getInstance().init(getApplicationContext(),CommonConfig.APP_ID,CommonConfig.APP_KEY);
        //初始化日志工具类
        Logger.addLogAdapter(new AndroidLogAdapter());
    }
}

接下来再Manefest文件中如何配置全局Application大家都懂，我就不填代码了，现在开始封装一个RetrofitHelper

public class RetrofitHelper {
    private static final int DEFAULT_TIMEOUT = 15;
    private static OkHttpClient client = null;
    //这里初始化OkHttpClient，当client为null才执行
    static {
        if (client == null) {
            client = new OkHttpClient.Builder()
                    .addInterceptor(chain -> {
                        Request request = chain.request();
                        RequestBody requestBody = request.body();
                        if (requestBody != null) {
                            Charset charset = Charset.forName("UTF-8");
                            MediaType contentType = requestBody.contentType();
                            if (contentType != null) {
                                charset = contentType.charset(UTF8);
                            }
                            String paramsStr = "";
                            Buffer buffer = new Buffer();
                            requestBody.writeTo(buffer);
                            paramsStr = buffer.readString(charset);
                            LogUtils.e(String.format("%s request params%n%s", request.method(), paramsStr));
                        }
                        long t1 = System.nanoTime();
                        Response response = chain.proceed(request);
                        long t2 = System.nanoTime();
                        LogUtils.e(String.format(Locale.getDefault(), "Received response for %s in %.1fms%n%s",
                                response.request().url(), (t2 - t1) / 1e6d, response.headers()));
                        MediaType mediaType = response.body().contentType();
                        String content = response.body().string();
                        LogUtils.json(content);
                        return response.newBuilder()
                                .body(okhttp3.ResponseBody.create(mediaType, content))
                                .build();
                    })
                    .addNetworkInterceptor(chain -> {
                        Request request = chain.request();
                        Response response = chain.proceed(request);
                        if (!response.isSuccessful()) {
                            MediaType mediaType = response.body().contentType();
                            String content = response.body().string();
                            return response.newBuilder().code(200).body(ResponseBody.create(mediaType, content)).build();
                        } else {
                            return response;
                        }
                    })
                    .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                    .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                    .retryOnConnectionFailure(true)
                    .build();
        }
    }

    public static <T> T getDefault(Class<T> clazz) {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(Api.baseUrl)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
        return retrofit.create(clazz);
    }
}

代码贴了，这里说明几个关键的问题，一个很坑的问题，一旦请求头跟请求参数有一个不匹配服务器会直接返回400 Bad Request，例如注册用户的时候，如果用户已经存在的话，他还是返回400的，所以这里要做下处理，在Okhttp中，添加普通拦截器去打印Log，查看请求头，然后请求参数，然后还有响应头和返回来的数据。

然后接下来处理返回400的问题，让我们能够接收400返回之后的数据，因为LeanCloud错误返回的固定格式{“code”:201,”error”:”error message”}所以我们需要修改response的响应码，让我们可以获取到返回的数据，所以就需要添加一下okhttp的网络拦截器，在里面判断一下response的code是不是400，如果是的话，就把response.body().string()和response.contentType()取出来保存，然后返回一个response.newBuilder().code(200).body(ResponseBody.create(mediaType,content)).build()，这样就可以把400返回的数据返回成功

然后通过LeanCloud的文档我们可以知道每次请求一个数据，返回都会有objectId,updateAt,createAt，我们就可以根据这些去写一个通用的实体类BaseResp

public abstract class BaseResp {
    private int code = -1;
    private String error;
    private String objectId;
    private String createAt;
    private String updateAt;

    public String getObjectId() {
        return objectId;
    }

    public void setObjectId(String objectId) {
        this.objectId = objectId;
    }

    public String getCreateAt() {
        return createAt;
    }

    public void setCreateAt(String createAt) {
        this.createAt = createAt;
    }

    public String getUpdateAt() {
        return updateAt;
    }

    public void setUpdateAt(String updateAt) {
        this.updateAt = updateAt;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }

    public abstract boolean isSuccess();
}

这里我把code付了一个初值为-1，然后这个BaseResp是一个抽象类，里面有个抽象方法是isSuccess()，在子类中我们可以用这个判断是否请求成功，重写方法是这样的：

@Override
    public boolean isSuccess() {
        return getCode() == -1 && !TextUtils.isEmpty(getObjectId());
    }

一旦是请求失败的话，那么我们就需要处理显示getError()就好了

然后就是和Service关联起来，我们都知道，使用Retrofit是需要retrofit.create(Service.class)，所以我写了个方法，初始化Retrofit并且利用泛型去关联Service Class，就是下面这个方法：

public static <T> T getDefault(Class<T> clazz) {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(Api.baseUrl)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
        return retrofit.create(clazz);
    }

其中要注意RxJava2CallAdapterFactory，这个是要配合rxjava2使用的，rxjava则是RxJavaCallAdapterFactory

OK，封装好这些之后，我们要去处理Model类，然后还有rxJava中Observable的处理
我们先看看Model怎么写
一开始定义一个接口，然后写上接口方法

public interface IUserModel {

    Observable<UserEntity> login(REQ_login body);

    Observable<UserRegisterEntity> register(REQ_register body);
}

public class UserModel implements IUserModel {

    @Override
    public Observable<UserEntity> login(REQ_login body) {
        return RetrofitHelper.getDefault(UserService.class).login(body);
    }

    @Override
    public Observable<UserRegisterEntity> register(REQ_register body) {
        return RetrofitHelper.getDefault(UserService.class).register(body);
    }
}

我们之前封装好的就直接这样用起来就好了，很简单，然后再Activity中需要的地方，直接new Model().login()就可以了，然后就是rxjava的处理方式了：

/**
     * login
     * @param context context
     * @param username username
     */
    public void login(Context context,String username){
        REQ_login body = new REQ_login();
        body.setUsername(username);
        body.setPassword(username);
        new UserModel().login(body)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new HandlerObserve<UserEntity>() {
                    @Override
                    public void onNext(@NonNull UserEntity userEntity) {
                        if (userEntity.isSuccess()){
                            UserHelper.saveUserData(context,userEntity);
                            if(UserHelper.isLogin(context)){
                                UIUtils.ToastMsg(context,"登录成功");
                            }
                        }else{
                            UIUtils.ToastMsg(context,userEntity.getError());
                        }
                    }
                });
    }

在rxJava处理这里，我重写了Observe，然后我们只需要处理onNext()就好了，很方便，如果需要和生命周期绑定，请移步去看RxLifecycle，只需要添加一个compose方法，就可以了，这样处理更灵活，配合APP的生命周期使用会很舒服的

其实封装Observe也是挺简单的，用抽象类去做处理：

public abstract class HandlerObserve<T> implements Observer<T> {
    @Override
    public void onSubscribe(@NonNull Disposable d) {
        //do something in subscribe
    }

    @Override
    public void onError(@NonNull Throwable e) {
        //do something on error
        e.printStackTrace();
    }

    @Override
    public void onComplete() {
        //do something on complete
    }
}