基于Retrofit2.0+RxJava+Dragger2实现不一样的Android网络构架搭建（转载）

转载请注明出处：http://blog.csdn.net/finddreams/article/details/50849385#0-qzone-1-61707-d020d2d2a4e8d1a374a433f596ad1440

 

一起分享，一起进步。finddreams：http://blog.csdn.net/finddreams/article/details/50849385
众所周知，手机APP的核心就在于调用后台接口，展示相关信息，方便我们在手机上就能和外界交互。所以APP中网络框架的搭建一直是我们开发者所关心的问题，在Android中关于如何搭建网络框架分为两种：一种是不想重复造轮子使用第三方开源的网络框架；第二种就是喜欢造轮子的封装自己的网络框架。
自己封装实现网络框架这种行为固然不错，但是这需要自身具备比较高的能力，而很多时候我们没有那样的能力把它封装的足够好。这时我们使用开源的网络框架也未尝不是一件好事，github上面知名的网络框架已经经过了很多app的验证，在一定意义上是非常符合我们在实际的项目开发所需要的。
Android开发中几个知名的开源的网络框架有android-async-http，Volley,OkHttp等，国人 开发的xUtils快速开发框架也比较流行。android-async-http是个很老牌的网络框架，非常的经典。Volley官方推荐的，自不必说。OkHttp可以说是后起之秀，现在非常流行，Android系统底层api都有用到，所以是非常niubility.
我们很多开发者大都在小型公司，不了解大公司是怎么做Android网络框架的，也想知道那些用户量过千万的APP到底用了些什么技术，下面有两张图片，让我们一起来了解一下Android版的美团和Uber到底用了些什么技术。


美团 Uber
看完你会发现其实这些用户量过亿的APP也使用了很多的开源框架，而且这些开源框架中大多数其实都是我们平常在开发中所常用到的，并不陌生。可能大多数人对Retrofit，Rxjava这些还不太熟悉，那话不多说，今天我们就来讲讲怎么用Retrofit2.0+RxJava+Dragger2来实现Android网络构架搭建，给大家提供一种思路，供大家参考参考。
Retrofit2.0 GitHub:https://github.com/square/retrofit
Square开发的类型安全的REST安卓客户端请求库，网络请求默认使用的是OkHttp，具体介绍请看相关教程。
RxJava ＋RxAndroid GitHub地址： https://github.com/ReactiveX/RxJava
RxJava是一种响应式编程框架，采用观察者设计模式。最核心的是Observables（被观察者，事件源）和Subscribers（观察者）这两个东西，RxAndroid是Rxjava在Android上的实现。

Dragger2
是一种依赖注入框架，可以大大节省我们的代码量，便于维护。

在这里我就不费过多笔墨来介绍着三个东西了，今天的主题是提供一种如何搭建一个不一样的网络框架的思路。如果读者对这三个框架不是很了解的话，可以自行的Google脑补一下。
首先，就是开始把这些框架引入到咱们的项目中来作为依赖库，在app/build.gradle文件中添加

apply plugin: ‘com.android.application‘
apply plugin: ‘com.neenbedankt.android-apt‘

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"

    defaultConfig {
        applicationId "com.finddreams.retrofit"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile(‘proguard-android.txt‘), ‘proguard-rules.pro‘
        }
    }
}

dependencies {
    compile fileTree(include: [‘*.jar‘], dir: ‘libs‘)
    testCompile ‘junit:junit:4.12‘
    compile ‘com.android.support:appcompat-v7:23.1.1‘
    //retrofit
    compile ‘com.squareup.retrofit2:retrofit:2.0.0-beta4‘
    //gson解析
    compile ‘com.squareup.retrofit2:converter-gson:2.0.0-beta4‘
    //rxjava
    compile ‘io.reactivex:rxandroid:1.1.0‘
    compile ‘com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4‘
    //dragger2
    provided ‘org.glassfish:javax.annotation:10.0-b28‘
    apt ‘com.google.dagger:dagger-compiler:2.0.2‘
    compile ‘com.google.dagger:dagger:2.0.2‘
}

 

因为Dragger2是基于注解的，它会预先生成一些类文件，所以需要在整个项目的/build.gradle文件中加上apt工具:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath ‘com.android.tools.build:gradle:2.0.0-beta6‘
        classpath ‘com.neenbedankt.gradle.plugins:android-apt:1.8‘

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        jcenter()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

接着开始写一个提供Retrofit的单例类：

/**
 * Retrofit的实体类
 */
public class RestApiAdapter {
    private static Retrofit retrofit = null;

    public static Retrofit getInstance() {
        if (retrofit == null) {
            GsonConverterFactory gsonConverterFactory = GsonConverterFactory.create();
            OkHttpClient okHttpClient = new OkHttpClient();
            OkHttpClient.Builder builder = okHttpClient.newBuilder();
            builder.retryOnConnectionFailure(true);
            retrofit = new Retrofit.Builder().client(okHttpClient)
                    .baseUrl(ConstantApi.BaiduUrl)
                    .addConverterFactory(gsonConverterFactory)
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .build();
        }
        return retrofit;
    }
}


 

addCallAdapterFactory(RxJavaCallAdapterFactory.create()) 这个方法就是RxJava和Retrofit结合的关键。

接着我们为Retrofit 提供一个service接口，声明api接口地址和所需要的参数，这里我们使用百度API提供的天气接口，实现根据城市名称查询天气的功能，接口地址：http://apistore.baidu.com/apiworks/servicedetail/112.html 代码如下：

/**
 * 天气接口Api
 */
public interface WeatherApiService {
    /**
     * 查询天气
     */
    @GET("apistore/weatherservice/cityname")
    Observable<WeatherResultBean> queryWeather(@Header("apikey") String apikey, @Query("cityname") String cityname);
}

 

返回一个Observable被观察者/事件源的意思是交给RxJava来处理。

然后我们写一个BaseSubsribe观察者来管理网络请求开始结束，成功与失败：

/**
 * 观察者
 *
 * @author finddreams
 * @address http://blog.csdn.net/finddreams
 */
public abstract class BaseSubsribe<T> extends Subscriber<T> {
    private static final String TAG = "BaseSubsribe";

    @Override
    public void onStart() {
        super.onStart();
        Log.i(TAG, "onStart");

    }

    @Override
    public void onNext(T t) {
        Log.i(TAG, "response" + t.toString());

        onSuccess(t);
    }

    @Override
    public void onCompleted() {
        Log.i(TAG, "onCompleted");

    }

    public abstract void onSuccess(T result);

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        Log.i(TAG, "onError" + e.getMessage());

    }

}

 

接着我们写一个WeatherInteractor接口连接service类：

/**
 * 获取天气信息接口
 *
 * @author finddreams
 * @address http://blog.csdn.net/finddreams
 */
public interface WeatherInteractor {
    Subscription queryWeather(String apikey, String cityname, BaseSubsribe<WeatherResultBean> subsribe);
}

 

然后是这个接口的实现类：

/**
 * 获取天气信息实现类
 */
public class WeatherInteractorImpl implements WeatherInteractor {
    private final WeatherApiService api;

    @Inject
    public WeatherInteractorImpl(WeatherApiService myApi) {
        this.api = myApi;
    }

    @Override
    public Subscription queryWeather(String apikey, String cityname, BaseSubsribe<WeatherResultBean> subsribe) {
        Observable<WeatherResultBean> observable = api.queryWeather(apikey, cityname);
        Subscription subscribe = observable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(subsribe);
        return subscribe;
    }
}

 

接下来是如何使用Dragger2的时候，知道Dragger2的都知道有几个概念，一个是Module:主要提供依赖对象比如context, rest api …； 一个是@inject:注解，用在需要依赖对象的地方；另一个是Componet:用来连接Module和@inject

首先定义一个Module类，提供需要注入依赖的对象：

/**
 * Module类
 * 提供需要注入的类
 *
 * @author finddreams
 * @address http://blog.csdn.net/finddreams
 */
@Module
public class InteractorModule {
    @Provides
    public Retrofit provideRestAdapter() {
        return RestApiAdapter.getInstance();
    }

    @Provides
    public WeatherApiService provideHomeApi(Retrofit restAdapter) {
        return restAdapter.create(WeatherApiService.class);
    }

    @Provides
    public WeatherInteractor provideHomeInteractor(WeatherApiService myApi) {
        return new WeatherInteractorImpl(myApi);
    }
}

 

接着是写一个Componet类：

/**
 * 声明AppComponent组件
 *
 * @author finddreams
 * @address http://blog.csdn.net/finddreams
 */
@Singleton
@Component(
        modules = {
                InteractorModule.class,
        }
)
public interface AppComponent {
    void inject(App app);

    WeatherInteractor getWeatherInteractor();
}


 

然后我们在Application中初始化这个AppComponent：

/**
 * Application类
 *
 * @author finddreams
 * @address http://blog.csdn.net/finddreams
 */
public class App extends Application {
    private AppComponent component;

    @Override
    public void onCreate() {
        super.onCreate();

        setDraggerConfig();
    }

    public AppComponent component() {
        return component;
    }

    public static App get(Context context) {
        return (App) context.getApplicationContext();
    }

    /**
     * 初始化Dragger，DaggerAppComponent是自动生成，需要Rebuild
     */
    private void setDraggerConfig() {
        component = DaggerAppComponent.builder().interactorModule(new InteractorModule())
                .build();
        component.inject(this);
    }
}


 

这里需要注意的是，由于Dagger2是预编译生成一个类，所以我们需要Rebuild项目，才会生成DaggerAppComponent这个类。如果开发中出现

import com.finddreams.retrofit.api.config.DaggerAppComponent;
找不到这个类的错误

 

这时就需要重新的Rebuild项目

这是Rebuild项目之后生成的class文件，如图：

最后我们就可以在Activity中开始使用了：

/**
 * 主页
 *
 * @author finddreams
 * @address http://blog.csdn.net/finddreams
 */
public class MainActivity extends AppCompatActivity {

    private AppComponent component;
    private WeatherInteractor weatherInteractor;
    private EditText city;
    private TextView queryresult;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        city = (EditText) findViewById(R.id.city);
        queryresult = (TextView) findViewById(R.id.queryresult);
        //获取到AppComponent组件
        component = App.get(this).component();
        //通过AppComponent拿到WeatherInteractor
        weatherInteractor = component.getWeatherInteractor();
        findViewById(R.id.query).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                queryWeatherData();

            }

        });

    }

    public void queryWeatherData() {
        String content = city.getText().toString();
        //调用查询天气接口的方法
        Subscription subscription = weatherInteractor.queryWeather(ConstantApi.baiduKey, content, new BaseSubsribe<WeatherResultBean>() {
                    @Override
                    public void onSuccess(WeatherResultBean result) {

                        WeatherResultBean.RetDataEntity retData = result.getRetData();
                        queryresult.setText(retData.getCity() + ":" + retData.getWeather() + ":" + retData.getDate());
                    }

                    @Override
                    public void onError(Throwable e) {
                        super.onError(e);
                        queryresult.setText("查询失败");

                    }
                }
        );
        //取消请求
//        subscription.unsubscribe();
    }
}

 

我们看下项目运行的结果图：

附上源码给有需要的朋友参考一下，比较结合源码才能理解的更透彻，GitHub: https://github.com/finddreams/Retrofit2_Rxjava_Dagger2

时间： 2024-07-30 20:18:00

基于Retrofit2.0+RxJava+Dragger2实现不一样的Android网络构架搭建（转载）的相关文章

Retrofit2.0+RxJava+RxAndroid——强强联合的网络请求框架

最近看了很多关于Retrofit和Rxjava的文档介绍.终于在弄清Rxjava后顺利的弄懂了Retrofit. 网上有很多人都介绍了它们的联合使用,但是我看过之后理解不是太好.可能我太笨. 不过,今天写这篇博客的目的就是想来说说它们之间如何使用以及使用的时候遇到的坑. 这两者的关系并不大,但是联合在一起使用是非常简便的.Rxjava的响应式编程加上Retrofit的注解式请求用起来是非常爽的. 并且Retrofit内置的是Okhttp,所以这更加的让Retrofit变得强大. 如果在看这篇博客

Retrofit2.0+ RxJava 优雅的取消重复避免并取消请求（十一）

Tamic/文 地址:http://blog.csdn.net/sk719887916/article/details/54575137 前几篇主要介绍了retrofit基本使用,结合rxJava的案列,以及RxJava结合retrofit的封装,包括公用参数,局部参数请求头添加,缓存,https, 文件上下传,结果解析,异常处理等,还有一些技巧,那么还有一个比较关键的是取消问题. 两者结合技巧可点击阅读:http://blog.csdn.net/sk719887916/article/deta

Retrofit2.0+RxJava+MVP+Bmob的使用

本篇来总结一下学过的关于android方面的东西.梳理一下知识: 1.Retrofit2.0 Retrofit 是一个Square开发的类型安全的REST安卓客户端请求库.这个库为网络认证.API请求以及用OkHttp发送网络请求提供了强大的框架 . 2.RxJava/RxAndroid RxJava是一款响应式变成框架.RxAndroid在RxJava基础之上扩展了android线程调度.RxJava基本组成部分是Observables和Subscribers(事实上Observer才是最小的

Retrofit2.0通俗易懂的学习姿势，Retrofit2.0 + OkHttp3 + Gson + RxJava

Retrofit2.0通俗易懂的学习姿势,Retrofit2.0 + OkHttp3 + Gson + RxJava Retrofit,因为其简单与出色的性能,也是受到很多人的青睐,但是他和以往的通信框架还是有点区别,不过放心,因为他本身还是挺简单的,所有我相信你看完这篇文章,对基本的请求是没什么问题的,其实现在网上这样的文章也有很多了,好了,那我们直接开车吧! 一.相关资料 Github:https://github.com/square/retrofit 官网文档:http://square

Android网络框架之Retrofit + RxJava ＋ OkHttp 变化的时代

1.什么是Retrofit框架? 它是Square公司开发的现在非常流行的网络框架,所以我们在导入它的包的时候都可以看到这个公司的名字,目前的版本是2. 特点: 性能好,处理快,使用简单,Retrofit 是安卓上最流行的HTTP Client库之一 使用REST API设计风格 支持 NIO(new i/o) 默认使用OKHttp处理网络请求,我觉得可以看成是OKHttp的增强. 随着Google对HttpClient的摒弃,和Volley的逐渐没落,OkHttp开始异军突起,而Retrofi

Android 基于ijkplayer+Rxjava+Rxandroid+Retrofit2.0+MVP+Material Design的android万能播放器aaa

MDPlayer万能播放器 MDPlayer,基于ijkplayer+Rxjava+Rxandroid+Retrofit2.0+MVP+Material Design的android万能播放器,可以播放本地和在线视频,可以浏览宅男杀手妹纸图片,UI设计遵循 Material Design. GitHub地址:https://github.com/Dawish/MDPlayer UI浏览:         1.UI设计: 列表使用RecyclerView,item为CardView并设置rippl

继续趁热！！！Retrofit2使用（基于RxJava2.0）

引言 hello 大家好,没想到吧!我又回来了,回来了,来了,了(武器大师的话,我加了个特技,哈哈). 好了开始我们今天的主题吧,昨天有人问我,该用什么网络框架,怎么用,怎么保证内存不泄露? 看到这个,我还是很激动的,毕竟是我写博客到现在第一个问我的问题. 那好,我就拿我经常用的网络框架(Retrofit),慢慢欣赏吧(买好瓜子哈). OKHTTP 总结一句话-->"略",哈哈,别打我,我还是个孩子. 这个不是今天的重点,而且这个东西出来这么久了,大家估计都用了,所以我就不讲了,

Android 网络框架 Retrofit2.0介绍、使用和封装

前言 时至今日,Android的网络框架不再像之前那么到处都是,随着Google把 HttpClient直接删掉,似乎意味着Android越来越成熟.网络框架中的佼佼者Volley也不再那么光鲜,取而代之的是 Retrofit 和 okHttp. 感觉很像 OnePiece 中白胡子的离去象征着时代的变革,新时代的开始,多弗的垮台象征着七武海制度的取缔一样,不会使用Retrofit + okHttp + RxJava等一系列技术,就迈不进新时代的门槛,也不足以称为一个合格的开发者. 哈哈闲话不多

Retrofit2.0使用

随着Google对HttpClient 摒弃,和Volley的逐渐没落,OkHttp开始异军突起,而Retrofit则对okHttp进行了强制依赖. Retrofit是由Square公司出品的针对于Android和Java的类型安全的Http客户端, 如果看源码会发现其实质上就是对okHttp的封装,使用面向接口的方式进行网络请求,利用动态生成的代理类封装了网络接口请求的底层, 其将请求返回javaBean,对网络认证 REST API进行了很好对支持此,使用Retrofit将会极大的提高我们应