说在前面 本人能力有限，望高手勿喷。
golang
golang语言又叫go语言，是google公司为了适应高并发，兼顾开发效率而开发的一门语言。go语言的语法非常简单，适合做服务器端开发。所以我准备采用golang来做web后台。因为本节重点不是讲解go语言。所以会比较简单的介绍一下。
RxJava
RxJava也使用了很久，一直想记录一些使用过程，但是由于时间问题，一直没有写。RxJava是一种链接风格的编程体验，保证你使用后一定会非常喜欢。之前一直使用的是RxJava1 不过2016年11月份官方出了RxJava2，而且版本1也不会在更新维护了，所以我这里会使用版本2 。
Retrofit
Retrofit是一个网络请求框架，是对okhttp框架的再次封装。提供跟良好的使用体验。我这里采用的是retrofit2。
服务器端
服务器端我使用了go语言的一个框架 gin ,这个框架是两个外国人写的开源框架，用来写api非常方便。
package main
import (
"blog/src/enity"
"fmt"
"github.com/gin-gonic/gin"
)
func main() {
gin.SetMode(gin.ReleaseMode)
router := gin.Default()
router.POST("/", func(c *gin.Context) {
start := c.PostForm("start")
count := c.PostForm("count")
fmt.Println("start: ", start, " count:", count)
c.JSON(200, gin.H{
"code": "201",
"msg": "success",
"data": gin.H{
"name": "aa",
"age": 25,
"address": "成都",
"sex": 1},
})
})
router.Run(":8000")
}
该服务器端的接口非常简单，就是获取一个json数据。
APP端
引入依赖
//rxjava2 和rxAndroid
compile 'io.reactivex.rxjava2:rxjava:2.1.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
//retrofit2
compile 'com.squareup.retrofit2:retrofit:2.3.0'
// 自动解析json数据为实体的包
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
//retrofit支持转换为Rxjava的包
compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
//okhttp
compile 'com.squareup.okhttp3:okhttp:3.3.0'
compile 'com.squareup.okio:okio:1.8.0'
compile 'com.google.code.gson:gson:2.8.1'
rxjava中有一个 Observer类型这个就是一个观察者，也就是一个处理数据的类。还有一个是Observable类，这个类是被观察者类，改类就是产生数据的类。在apiservice接口类中，方法getUser()返回的就是一个被观察者，改类型使用了泛型，也就是我们可以自动解析json数据为我们的实体对象。
新建一个 apiservice接口类
public interface ApiService {
@Multipart
@POST("/")
Observable<BaseResponseDto<User>> getUser(@Part("start") int start, @Part("count") int count);
}
我们使用了result api风格的接口，一般我们接口返回json数据格式为。
{
code: "200",
msg: "success",
data: {
}
}
所以我们可以对这个数据进行封装。
public class BaseResponseDto<T> {
private String code;
private String msg;
private T data;
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String mag) {
this.msg = mag;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
@Override
public String toString() {
return "BaseResponseDto{" +
"code='" + code + '\'' +
", mag='" + msg + '\'' +
", data=" + data +
'}';
}
}
在app端请求网络数据时我们总会处理各种异常问题，比如网络异常，json解析异常等，为了少些异常处理代码，我们需要对这一部分进行封装。我们使用的是RxJava所以我们需要对观察者进行封装。
public abstract class DefaultObserver<T extends BaseResponseDto> implements Observer<T> {
private static String TAG="DefaultObserver";
private Context context;
private BaseViewImpl baseView;
private String message="";
private Disposable disposable;
public DefaultObserver(Context context){
this.context=context;
}
public DefaultObserver(Context context,BaseViewImpl baseView){
this.baseView=baseView;
this.context=context;
}
public DefaultObserver(Context context,BaseViewImpl baseView,String message){
this.baseView=baseView;
this.message=message;
this.context=context;
}
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.i(TAG,"======onSubscribe======");
disposable=d;
if(null!=baseView){
baseView.addDisposable(d);
baseView.showProgressDialog(message);
}
}
@Override
public void onNext(@NonNull T response) {
Log.i(TAG,"======onNext======");
mainThread();
if(null!=baseView){
baseView.removeDisposable(disposable);
baseView.dismissProgressDialog();
}else {
disposable.dispose();
}
if(response.getCode().equals("200")){
onSuccess(response);
}else{
onFail(response);
}
}
@Override
public void onError(@NonNull Throwable e) {
Log.i(TAG,"======onError======"+e.getMessage());
if(null !=baseView){
baseView.removeDisposable(disposable);
baseView.dismissProgressDialog();
}else {
disposable.dispose();
}
if (e instanceof HttpException) { // HTTP错误
ToastUtil.showShort(context,"http错误");
} else if (e instanceof ConnectException
|| e instanceof UnknownHostException) { // 连接错误
ToastUtil.showShort(context,"连接错误");
} else if (e instanceof InterruptedIOException) { // 连接超时
ToastUtil.showShort(context,"连接超时");
} else if (e instanceof JsonParseException
|| e instanceof JSONException
|| e instanceof ParseException) { // 解析错误
ToastUtil.showShort(context,"解析错误");
} else if(e instanceof IOException){
ToastUtil.showShort(context,"IO错误");
}else {
ToastUtil.showShort(context,"未知错误");
}
}
@Override
public void onComplete() {
}
/**
* 请求成功
* @param response
*/
abstract public void onSuccess(T response);
/**
* 请求成功后返回的数据错误
* @param response
*/
public void onFail(T response){
ToastUtil.showShort(context,response.getMsg());
}
}
这样封装后我们只需要子类实现 onSuccess()方法就可以了，我们只关注成功获取数据。如果想自己根据失败进行相关的操作也可以复写onFail()方法。
最后我们需要把之前封装的这几个类弄到一个网络请求类中，方便外面统一调用。使用创建了一个Htpp类。
public class Http {
private static final String TAG="Http";
private static final String BASE_URL="http://127.0.0.1:8000/";
private static final int DEFAULT_TIMEOUT=5;
private static Retrofit retrofit;
private ApiService apiService;
private Http(){
Gson gson = new GsonBuilder()
.setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
.create();//使用 gson coverter，统一日期请求格式
OkHttpClient.Builder builder=new OkHttpClient.Builder()
.addInterceptor(new LoggingInterceptor())
.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
retrofit=new Retrofit.Builder()
.baseUrl(BASE_URL)
.client(builder.build())
.addConverterFactory(GsonConverterFactory.create(gson))
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
apiService=retrofit.create(ApiService.class);
}
private static class SignleHolder{
private static final Http INSTANCE=new Http();
}
public static Http getInstance(){
return SignleHolder.INSTANCE;
}
private class LoggingInterceptor implements Interceptor{
@Override
public Response intercept(Chain chain) throws IOException {
Request request=chain.request();
Log.i(TAG,String.format("\n request: %s on %s \n %s %s",request.url(),chain.connection(),request.headers(),request.body().contentType()));
Response response=chain.proceed(request);
Log.i(TAG,String.format("\n response: %s \n body: %s \n",response.request().url(),""));
return response;
}
}
public void getUser(DefaultObserver<BaseResponseDto<User>> observer){
apiService.getUser(0,10)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(observer);
}
}
这样封装后 外部就可以直接使用htpp类进行调用。
public void testDefaultRxJava(){
Http.getInstance().getUser(new DefaultObserver<BaseResponseDto<User>>(MainActivity.this,this) {
@Override
public void onSuccess(BaseResponseDto<User> response) {
Log.i(TAG,"=====onSuccess======"+response.toString());
}
@Override
public void onFail(BaseResponseDto<User> response) {
super.onFail(response);
}
});
}
这样就轻松实现了RxJava2+Retrofit2 的封装。
