Rxjava+Retrofit 2.0实现网络框架

在网上看到Rxjava，Retrofit身为android人，不去学习新的技术是要落伍的，何况这已经不是新技术，本人对这两个还不太熟悉，只是自己查资料自己摸索整理一份资料，用于以后的学习。
Rxjava和Retrofit就不解释了这里推荐几个学习的地址：
是时候学习RxJavale http://www.jianshu.com/p/8cf84f719188
给 Android 开发者的 RxJava 详解
http://gank.io/post/560e15be2dca930e00da1083#toc_1
Android Retrofit 2.0 使用
http://wuxiaolong.me/2016/06/18/retrofits/
上代码：
首先我们写一个HttpMethods，个人理解其实就是初始化okhttp和Retrofit，添加响应头利用RxJava实现异步操作

import android.util.Log;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import cn.szg.library.action.ResultBean;
import cn.szg.library.action.ResultStringBean;
import jiyun.committee.activity.base.BaseActivity;
import jiyun.committee.bean.User;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

/**
 * Created by JY-G40 on 2016/8/24.
 */
public class HttpMethods {
    public static final String BASE_URL = HttpUtils.Url;
    private static final int DEFAULT_TIMEOUT = 5;//超时时间
    private Retrofit retrofit;
    private CommitteeService committeeService;
//    private UserInfo info;
    //构造方法私有
    private HttpMethods() {

//        info=new UserInfo();
        OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
        httpClientBuilder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
        httpClientBuilder.addInterceptor(headerInterceptor);
        retrofit = new Retrofit.Builder()
                .client(httpClientBuilder.build())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .baseUrl(BASE_URL)
                .build();

        committeeService=retrofit.create(CommitteeService.class);

    }

    //在访问HttpMethods时创建单例
    private static class SingletonHolder{
        private static final HttpMethods INSTANCE = new HttpMethods();
    }

    //获取单例
    public static HttpMethods getInstance(){
        return SingletonHolder.INSTANCE;
    }

    public void getUser(Subscriber<ResultBean<User>> subscriber, String username, String password){
        committeeService.Login(username,password)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriber);

    }

    public void getChagepass(Subscriber<ResultStringBean> subscriber,String newpass){
        committeeService.ChagePass(newpass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriber);
    }


    /**
     * 设置头
     */
    Interceptor headerInterceptor = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request originalRequest = chain.request();
            Request.Builder requestBuilder = originalRequest.newBuilder()
                    .header("app-agent", BaseActivity.headinfo)
                    .header("Content-Type", "application/json")
                    .header("Accept", "application/json")
                    .header("token", BaseActivity.token)
                    .method(originalRequest.method(), originalRequest.body());
            Request request = requestBuilder.build();
            return chain.proceed(request);
        }
    };
}

CommitteeService是一个接口，里面主要放与服务器交互的接口

public interface  CommitteeService {
    @GET("user?")
    Observable<ResultBean<User>> Login(@Query("username") String username, @Query("password") String password);

    @PATCH("user")
    Observable<ResultStringBean> ChagePass(@Body String pass);

    @POST("inspection")
    Observable<ResultStringBean> Inspection(@Body User user);

    @PUT("user")
    Observable<ResultStringBean> ChagePhone(@Body String phone);


}

然后是一个事件处理类，也就是开始交互接口我们需要在开始的时候显示ProgressDialog，结束隐藏

public class ProgressSubscriber<T> extends Subscriber<T> implements ProgressCancelListener {

    private SubscriberOnNextListener mSubscriberOnNextListener;
    private ProgressDialogHandler mProgressDialogHandler;

    private Context context;

    public ProgressSubscriber(SubscriberOnNextListener mSubscriberOnNextListener, Context context) {
        this.mSubscriberOnNextListener = mSubscriberOnNextListener;
        this.context = context;
        mProgressDialogHandler = new ProgressDialogHandler(context, this, true);
    }

    private void showProgressDialog(){
        if (mProgressDialogHandler != null) {
            mProgressDialogHandler.obtainMessage(ProgressDialogHandler.SHOW_PROGRESS_DIALOG).sendToTarget();
        }
    }

    private void dismissProgressDialog(){
        if (mProgressDialogHandler != null) {
            mProgressDialogHandler.obtainMessage(ProgressDialogHandler.DISMISS_PROGRESS_DIALOG).sendToTarget();
            mProgressDialogHandler = null;
        }
    }

    /**
     * 订阅开始时调用
     * 显示ProgressDialog
     */
    @Override
    public void onStart() {
        showProgressDialog();
    }

    /**
     * 完成，隐藏ProgressDialog
     */
    @Override
    public void onCompleted() {
        dismissProgressDialog();
        Toast.makeText(context, "Get Top Movie Completed", Toast.LENGTH_SHORT).show();
    }

    /**
     * 对错误进行统一处理
     * 隐藏ProgressDialog
     * @param e
     */
    @Override
    public void onError(Throwable e) {
        if (e instanceof SocketTimeoutException) {
            Toast.makeText(context, "网络中断，请检查您的网络状态", Toast.LENGTH_SHORT).show();
        } else if (e instanceof ConnectException) {
            Toast.makeText(context, "网络中断，请检查您的网络状态", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "error:" + e.getMessage(), Toast.LENGTH_SHORT).show();
        }
        dismissProgressDialog();

    }

    /**
     * 将onNext方法中的返回结果交给Activity或Fragment自己处理
     *
     * @param t 创建Subscriber时的泛型类型
     */
    @Override
    public void onNext(T t) {
        if (mSubscriberOnNextListener != null) {
            mSubscriberOnNextListener.onNext(t);
        }
    }

    /**
     * 取消ProgressDialog的时候，取消对observable的订阅，同时也取消了http请求
     */
    @Override
    public void onCancelProgress() {
        if (!this.isUnsubscribed()) {
            this.unsubscribe();
        }
    }
}

然后创建一个onNext，此为RxJava的知识点，相应成功后会调这个接口

public interface  SubscriberOnNextListener<T> {
    void onNext(T t);
}

自定义一个ProgressDialog

public class ProgressDialogHandler extends Handler {

    public static final int SHOW_PROGRESS_DIALOG = 1;
    public static final int DISMISS_PROGRESS_DIALOG = 2;

    private ProgressDialog pd;

    private Context context;
    private boolean cancelable;
    private ProgressCancelListener mProgressCancelListener;

    public ProgressDialogHandler(Context context, ProgressCancelListener mProgressCancelListener,
                                 boolean cancelable) {
        super();
        this.context = context;
        this.mProgressCancelListener = mProgressCancelListener;
        this.cancelable = cancelable;
    }

    private void initProgressDialog(){
        if (pd == null) {
            pd = new ProgressDialog(context);

            pd.setCancelable(cancelable);

            if (cancelable) {
                pd.setOnCancelListener(new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(DialogInterface dialogInterface) {
                        mProgressCancelListener.onCancelProgress();
                    }
                });
            }

            if (!pd.isShowing()) {
                pd.show();
            }
        }
    }

    private void dismissProgressDialog(){
        if (pd != null) {
            pd.dismiss();
            pd = null;
        }
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case SHOW_PROGRESS_DIALOG:
                initProgressDialog();
                break;
            case DISMISS_PROGRESS_DIALOG:
                dismissProgressDialog();
                break;
        }
    }

}

取消Progress的回调接口

public interface ProgressCancelListener {
    void onCancelProgress();
}

接下来以登录来演示在activity中怎么用

public class LoginActivity extends BaseActivity implements CompoundButton.OnCheckedChangeListener{
    @InView(R.id.login_user_name)
    private EditText login_user_name;
    @InView(R.id.login_user_pass)
    private EditText login_user_pass;
    @InView(R.id.login_check)
    private CheckBox login_check;
    @InView(R.id.login_landing)
    private ImageView login_landing;
    private SubscriberOnNextListener getTopMovieOnNext;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        initView("登录");


    }

    @Override
    protected void initView(String title) {
        super.initView(title);
        getTopMovieOnNext = new SubscriberOnNextListener<ResultBean<User>>() {
            @Override
            public void onNext(ResultBean<User> subjects) {
                user = subjects.getValue();
                uInfo.setUser(true, JsonUtils.beanToJson(user));
                uInfo.setToken(subjects.getValue().getToken());
                commonUtil.startActivity(A_ChangePassword.class);
                commonUtil.shortToast(subjects.getMessage());
                finish();




            }
        };
        login_landing.setOnClickListener(this);
        login_check.setOnCheckedChangeListener(this);
    }

    @Override
    public void onClick(View v) {
        super.onClick(v);
        switch (v.getId()){
            case R.id.login_landing:
                if("".equals(login_user_name.getText().toString())){
                    commonUtil.shortToast("请输入用户名");
                    login_user_name.requestFocus();
                    return;
                }

                if ("".equals(login_user_pass.getText().toString())){
                    commonUtil.shortToast("请输入密码");
                    login_user_pass.requestFocus();
                    return;
                }

                Login();
                break;
        }
    }

    public void Login(){
        HttpMethods.getInstance().getUser(new ProgressSubscriber(getTopMovieOnNext, LoginActivity.this), login_user_name.getText().toString(), login_user_pass.getText().toString());
    }


    @Override
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
        boolean remember_username = false;//设置是否记住密码（true 记住 false 不记住）
        if (isChecked){

        }

    }
}

到这里基本就完成了，本人初识，所以对于这个了解不是很深刻，有意者可以摘取对自己有用的，如果觉得水文没用，大家请谅解，记录这个是单纯意义上用于自己学习，谢谢啦。