Retrofit+Okhttp+RxJava

很多朋友接手项目都开始带有Retrofit +Okhttp+RxJava搭建的网络请求框架，甚至有的还在尝试准备使用这个，接下来就来介绍一下这个网络请求框架的大致使用方法，和具体搭建方法。

直接上代码，首先是BaseView

 

public interface BaseView1 {
    /**
     * 显示操作进度
     */
    public void showProgress();
    /**
     * 关闭进度
     */
    public void closeProgress();

    /**
     * 成功回调
     */
    public void excuteErrSuccessCallBack(String s);
    /**
     * 失败回调
     */
    public void excuteErrFailedCallBack(String s);

}

然后就是写实现BaseView的Api了，一般是将自己网络请求原地址写上去

 

 

import android.os.Build;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.lvgou.distribution.bean.CallBackVo;
import com.lvgou.distribution.presenter.ErrorLogPresenter;
import com.lvgou.distribution.view.BaseView1;
import com.squareup.okhttp.OkHttpClient;

import java.util.concurrent.TimeUnit;

import retrofit.GsonConverterFactory;
import retrofit.Retrofit;
import retrofit.RxJavaCallAdapterFactory;
import rx.Subscriber;

/**
 * Created by Administrator on 2016/9/9.
 */
public class Api implements BaseView1 {

    private static Api ourInstance;

    private IServiceAPI gankService;
    private ErrorLogPresenter errorLogPresenter;


    public static Api getInstance() {
        if (ourInstance == null) ourInstance = new Api();
        return ourInstance;
    }

    public boolean isOne = true;

    private Api() {
        OkHttpClient okHttpClient = new OkHttpClient();
        okHttpClient.setReadTimeout(7676, TimeUnit.MILLISECONDS);
        errorLogPresenter = new ErrorLogPresenter(this);
        isOne = true;
        /*
         * 查看网络请求发送状况
         */
//            if (EasyApplication.getInstance().log) {
//                okHttpClient.interceptors().add(chain -> {
//                    Response response = chain.proceed(chain.request());
//                    com.orhanobut.logger.Logger.d(chain.request().urlString());
//                    return response;
//                });
//            }
        Gson mGson = new GsonBuilder()
                .registerTypeAdapter(String.class, new DeserializerData())
                .create();
        Retrofit retrofit = new Retrofit.Builder().baseUrl("原网络请求地址")
                .addCallAdapterFactory(
                        RxJavaCallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create(mGson))
                .client(okHttpClient)
                .build();
        this.gankService = retrofit.create(IServiceAPI.class);
    }


    public IServiceAPI getGankService() {
        return gankService;
    }

    /**
     * 创建 Subscriber
     *
     * @param mICallBackListener
     * @return Subscriber
     */
    public Subscriber createSubscriber(final ICallBackListener mICallBackListener) {
        Subscriber mSubscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
//                Log.i(TAG, "[onCompleted]");
            }

            @Override
            public void onError(Throwable e) {
//                Log.e(TAG, "[onError]" + e.getMessage());
                CallBackVo mCallBackVo = new CallBackVo();
//                mCallBackVo.setResCode("400");
//                mCallBackVo.setResMsg("请求失败");
//                mCallBackVo.setResObj(null);
               

                return;
            }

            @Override
            public void onNext(String s) {
                Gson gosn = new Gson();
                CallBackVo mCallBackVo = gosn.fromJson(s, CallBackVo.class);
                if (mCallBackVo.getStatus().equals("1")) {
                    mICallBackListener.onSuccess(s);
                } else {
                    
                    mICallBackListener.onFaild(mCallBackVo.getMessage());
                }
            }
        };
        return mSubscriber;
    }
    
    @SuppressWarnings("static-access")
    public static String GetDeviceName() {
        return new Build().MODEL;
    }


    @Override
    public void showProgress() {

    }

    @Override
    public void closeProgress() {

    }

    @Override
    public void excuteErrSuccessCallBack(String s) {
    }

    @Override
    public void excuteErrFailedCallBack(String s) {
    }

}

这样就完成了第一步，接下来就是网上很多的retrofit的运用，怎么去传递参数问题，对于这个我只是举例我post上传的方式，其它的去网上其它位子copy一下就行了

 

 

public interface IServiceAPI {
@FormUrlEncoded
    @POST("网络请求链接尾")
    Observable<String> shareMedal(@Field("参数名字") String 参数值, @Field("参数名字") String 参数值);

}

剩下就来看怎么去调用这个网络请求了

 

 

public class ShareMedalImpl implements ShareMedalModel {

    @Override
    public void shareMedal(String 参数值,String 参数值, ICallBackListener callBackListener) {
        IServiceAPI mIServiceAPI = Api.getInstance().getGankService();
        mIServiceAPI.shareMedal(参数值, 参数值)
                // Subscriber前面执行的代码都是在I/O线程中运行
                .subscribeOn(Schedulers.io())
                // 操作observeOn之后操作主线程中运行.
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(Api.getInstance().createSubscriber(callBackListener));
    }
}

这个就是调用第一步，获取到callback，然后进行post那边的调用

 

后面那个Model实际就是一个interface,就写上

void shareMedal(String 参数值,String 参数值, ICallBackListener callBackListener)；

这个方法而已
接下来就是presenter层了，也就是最后层，就是对上面的这些的调用，然后想办法返回出去自己请求网络的结果，是失败还是成功什么的。

 

 

public class ShareMedalPresenter extends BasePresenter<ShareMedalView> {
    private ShareMedalImpl shareMedalImpl;
    private ShareMedalView shareMedalView;
    private Handler mHandler;

    public ShareMedalPresenter(ShareMedalView shareMedalView) {
        this.shareMedalView = shareMedalView;
        shareMedalImpl = new ShareMedalImpl();
        mHandler = new Handler(Looper.getMainLooper());
    }

    public void shareMedal(String 参数, String 参数) {
        shareMedalImpl.shareMedal(参数,参数, new ICallBackListener() {
            @Override
            public void onSuccess(final String s) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        shareMedalView.closeShareMedalProgress();
                        shareMedalView.OnShareMedalSuccCallBack("1", s);
                    }
                });
            }

            @Override
            public void onFaild(final String s) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        shareMedalView.closeShareMedalProgress();
                        shareMedalView.OnShareMedalFialCallBack("1", s);
                    }
                });
            }
        });
    }

}参数,参数, new ICallBackListener() {
            @Override
            public void onSuccess(final String s) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        shareMedalView.closeShareMedalProgress();
                        shareMedalView.OnShareMedalSuccCallBack("1", s);
                    }
                });
            }

            @Override
            public void onFaild(final String s) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        shareMedalView.closeShareMedalProgress();
                        shareMedalView.OnShareMedalFialCallBack("1", s);
                    }
                });
            }
        });
    }

}

接下来要写的ShareMedalView这个也就是你调用实例化presenter位子要实现这个接口，然后实现方法的位子，就是new  Presenter(this),这里this是让当前类实现方法，会实现三个方法，也就是下面view要写出来的抽象方法：

 

 

public interface ShareMedalView {
    /**
     * 成功回调
     *
     * @param state
     * @param respanse
     */
    void OnShareMedalSuccCallBack(String state, String respanse);

    /**
     * 失败回调
     *
     * @param state
     * @param respanse
     */
    void OnShareMedalFialCallBack(String state, String respanse);

    /**
     * 关闭弹窗
     */
    void closeShareMedalProgress();
}

对了，钓了一个basepresenter，这个也就是一个基类，写上也无妨

 

 

public abstract class BasePresenter<T> {
    public T mView;
    public CompositeSubscription mCompositeSubscription;
    public DataManager mDataManager;
    public void attach(T mView){
        this.mView=mView;
        this.mCompositeSubscription = new CompositeSubscription();
//        this.mDataManager = DataManager.getInstance();
    }
    public void dettach(){
        mView=null;
        this.mCompositeSubscription.unsubscribe();
        this.mCompositeSubscription = null;
//        this.mDataManager = null;
    }
    public boolean isViewAttached() {
        return mView != null;
    }


    public T getMvpView() {
        return mView;
    }


}

调用的时候实例化
shareMedalPresenter = new ShareMedalPresenter(this);

 

shareMedalPresenter .sharemedal()方法就行了

哈哈，就这么简单，再也不要为Retrofit+Okhttp+RxJava这个框架烦恼了，其实也没什么高端的，不会用的时候永远觉得遥不可及，当切身使用就觉得没什么难的了。