基于Android+ Retrofit+MVP基础架构封装

最新推荐文章于 2022-01-20 10:57:33 发布
最新推荐文章于 2022-01-20 10:57:33 发布
阅读量331 收藏 1
点赞数
分类专栏： Android 文章标签： android android studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34993234/article/details/107280318
版权

前言

从事android开发也有一段时间了，如何封装基础架构在我们的开发中是必不可缺的技能。今天给大家分享的是基于retrofit+mvp封装的基础架构，适用于新手，大佬请忽略…………。其目的是做一个资源整合，如有不对之处请指教!

第一章：公共方法封装

一、封装 RetrofitWrapper.class

   1.新建RetrofitWrapper.class类

public class RetrofitWrapper {
    private Retrofit mRetrofit;
    private final OkHttpClient.Builder builder;
    HttpLoggingInterceptor loggingInterceptor;
    private  String mAddress="https://www.wanandroid.com/";
    public static RetrofitWrapper getInstance()
    {
        RetrofitWrapper instance;
        synchronized (RetrofitWrapper.class)
        {
        instance=new RetrofitWrapper();
        }
        return  instance;
    }

    private  RetrofitWrapper()
    {   builder = new OkHttpClient.Builder();
        //打印网络请求相关日志
        loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                //打印retrofit日志
                Log.i("retrofitLog: ", message);
            }
        });
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        builder.addInterceptor(loggingInterceptor);//
        OkHttpClient build = builder.build();
        initBuilder(mAddress,build);
        }

    private void initBuilder(String mAddress, OkHttpClient build) {
        initSSL();
        initTimeOut();

        if(BuildConfig.DEBUG){
            //不需要错误重连
            builder.retryOnConnectionFailure(false);
        }else {
            //错误重连
            builder.retryOnConnectionFailure(true);
        }
        //获取实例
        mRetrofit = new Retrofit
                //设置OKHttpClient,如果不设置会提供一个默认的
                .Builder()
                //设置baseUrl
                .baseUrl(mAddress)
                //添加转换器Converter(将json 转为JavaBean)，用来进行响应数据转化(反序列化)的ConvertFactory
                .addConverterFactory(GsonConverterFactory.create())
                //添加自定义转换器
//                .addConverterFactory(JsonConverterFactory.create())
                //添加rx转换器，用来生成对应"Call"的CallAdapter的CallAdapterFactory
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .client(build)
                .build();
    }
    /**
     * 初始化完全信任的信任管理器
     */
    @SuppressWarnings("deprecation")
    private void initSSL() {
        try {
            final TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

                }

                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {

                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[]{};
                }
            }};

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, trustAllCerts, new SecureRandom());
            SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
            builder.sslSocketFactory(sslSocketFactory);
            builder.hostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 设置读取超时时间，连接超时时间，写入超时时间值
     */
    private void initTimeOut() {
        builder.readTimeout(20000, TimeUnit.SECONDS);
        builder.connectTimeout(10000, TimeUnit.SECONDS);
        builder.writeTimeout(20000, TimeUnit.SECONDS);
        //错误重连
        builder.retryOnConnectionFailure(true);
    }
    public <T> T create(final  Class<T> tClass)
    {
        return mRetrofit.create(tClass);
    }
}

二、公共接口MvpView创建

public interface MvpView {
    Context getContext();
    void showLoadingDialog();
    void dismissLoadingDialog();
    void showLoadingBar();
    void dismissLoadingBar();
    void clearLoading();
}

三、公共接口BaseView 创建

public interface BaseView extends   MvpView{
}

四、公共抽象类MvpPresenter 创建

public abstract class MvpPresenter <V extends  MvpView> {
    protected Context context;
    private V baseView;

    public void attach(V baseView)
    {
    this.baseView=baseView;
    }

    public void detach() {
        baseView = null;
        context = null;
    }
    public  V getBaseView(){

        return baseView;
    }
    public boolean isAttach() {
        return baseView != null;
    }


    public Context getContext() {
        return context;
    }
    public void showLoadingDialog() {
        if (baseView != null) {
            baseView.showLoadingDialog();
        }
    }
    public void dismissLoadingDialog() {
        if (baseView != null) {
            baseView.dismissLoadingDialog();
        }
    }
    public void showLoadingBar() {
        if (baseView != null) {
            baseView.showLoadingBar();
        }
    }
    public void dismissLoadingBar() {
        if (baseView != null) {
            baseView.dismissLoadingBar();
        }
    }


}

五、公共抽象类MvpActivity 创建

public abstract class MvpActivity <P extends MvpPresenter> extends
        AppCompatActivity implements
        MvpView, View.OnClickListener {
    public  P presenter;
    private static Activity mCurrentActivity;// 对所有activity进行管理
    public static List<Activity> mActivities = new LinkedList<Activity>();
    protected Bundle savedInstanceState;
    private  static  long mPreTime;

    /**
     * 获取布局资源文件
     */
    protected abstract int getLayoutId();
    /**
     * 初始化presenter
     */
    @Nullable
    protected abstract P initPresenter();
    @Override
    public void onClick(View view) {

    }

    @Override
    public Context getContext() {
        return null;
    }

    @Override
    public void showLoadingDialog() {

    }

    @Override
    public void dismissLoadingDialog() {

    }

    @Override
    public void showLoadingBar() {

    }

    @Override
    public void dismissLoadingBar() {

    }

    @Override
    public void clearLoading() {

    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.savedInstanceState = savedInstanceState;
        synchronized (mActivities) {
            mActivities.add(this);
        }
        initWindow();
        if(getLayoutId()>0)
        {
            setContentView(getLayoutId());
        }
        //实例化P Presenter
        presenter=initPresenter();
        if(presenter!=null)
        {
            //实例化
            presenter.attach(this);
        }
        initialize();
    }

    private void initWindow() {
    }
    protected void initialize() {
        initView();
        loadData();
    }

    protected abstract void initView();
    protected abstract void loadData();

    @Override
    public void onBackPressed() {
//        if(mCurrentActivity instanceof MainActivity)
//        {
//            //如果是主页面
//            if (System.currentTimeMillis() - mPreTime > 2000) {// 两次点击间隔大于2秒
//
//                Toast.makeText(MyApp.getContext(), "再按一次，退出应用", Toast.LENGTH_SHORT).show();
//                mPreTime = System.currentTimeMillis();
//                return;
//            }
//            exitApp();
        }
//        if(mCurrentActivity instanceof LoginActivity)
//        {
//            exitApp();
//        }
//        super.onBackPressed();//finish()
//    }
public static void exitApp() {

    ListIterator<Activity> iterator = mActivities.listIterator();

    while (iterator.hasNext()) {
        Activity next = iterator.next();
        next.finish();
    }
}
    @Override
    protected void onResume() {
        super.onResume();
        mCurrentActivity = this;
    }

    @Override
    protected void onPause() {
        super.onPause();
        mCurrentActivity = null;
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        synchronized (mActivities)
        {
            mActivities.remove(this);
        }
        if(presenter!=null)
        {
            presenter.detach();
        }

    }
}

六、公共抽象方法BaseActivity

public abstract  class BaseActivity<P extends MvpPresenter> extends MvpActivity<P>{
    public BaseActivity mContext;
    private  boolean NetWork=false;
    private String netWorks;
    MyLoadingDialog myLoadingDialog;

    @Override
    protected void initialize() {
        super.initialize();
//        mUnbinder = ButterKnife.bind(this);
        //检测网络
        mContext=this;
        NetworkUtils networkUtils=new NetworkUtils(this);
        if(!networkUtils.isConnected()){
            NetWork=true;
        }

    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
//        if (mUnbinder != null) {
//            mUnbinder.unbind();
//        }
        clearLoading();
    }

    /**
     * 含有Bundle通过Class跳转界面
     **/
    public void startActivityBundle(Class<?> cls, Bundle bundle) {
        Intent intent = new Intent();
        intent.setClass(this, cls);
        if (bundle != null) {
            intent.putExtras(bundle);
        }
        startActivity(intent);
    }
    @Override
    public void showLoadingDialog() {
        super.showLoadingDialog();
        if(NetWork)
        {
            netWorks = "网络不可用^^";
        }
        else {
            netWorks = "加载中…";
        }
        if(myLoadingDialog==null)
        {
         myLoadingDialog =new MyLoadingDialog(this);
            myLoadingDialog.setMessage(netWorks);
            myLoadingDialog.show();
        }


    }

    @Override
    public void dismissLoadingDialog() {
        if(myLoadingDialog!=null)
        {
        myLoadingDialog.dismiss();
        }
    }

    @Override
    public void clearLoading() {
        //使用过后将其回收
    if(myLoadingDialog!=null)
    {
        myLoadingDialog.dismiss();
        myLoadingDialog=null;
    }
    }

}

第二章 Activity页面实现

1.自定义数据回调接口：

public interface MainView  extends MvpView {

void  getUserArticleList(ArticleListBean articleListBean);
}

2.自定义请求网络数据，并实现网络数据返回

public class MainPresenter extends MvpPresenter<MainView> {
    final ServiceApi serviceApi = RetrofitWrapper.getInstance().create(ServiceApi.class);

    public  void list(int page)
   {
       showLoadingDialog();
       serviceApi.getUserArticleList(page)
               .subscribeOn(Schedulers.newThread())
               .subscribeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ArticleListBean>() {
                   @Override
                   public void onSubscribe(Disposable d) {

                   }

                   @Override
                   public void onNext(ArticleListBean mJsonObject) {
                       Log.i("ssssssssssss",mJsonObject.getData().getDatas().size()+"");
//                       tvTitle.setText(mJsonObject.getData().getDatas().size()+"");
                       getBaseView().getUserArticleList(mJsonObject);
                   }

                   @Override
                   public void onError(final Throwable e) {
                       Log.i("ssssssssssss",e.toString());
                       dismissLoadingDialog();
                   }

                   @Override
                   public void onComplete() {
                       Log.i("ssssssssssss","******onComplete****");
                       dismissLoadingDialog();
                   }
               });
   }

}

3.Activity层实现

public class MainActivity extends BaseActivity<MainPresenter> implements MainView {
    ListView mListView;
    TextView tvTitle;
    private ListViewAdapter mTKTAdapter;
    private List<ItemBean> mTKTData;//这个集合保存的即是相应的EditText中你填写的值

    @Override
    protected int getLayoutId() {
        return R.layout.activity_main;
    }

    @Nullable
    @Override
    protected MainPresenter initPresenter() {
        return new MainPresenter();
    }


    @Override
    protected void initView() {
        tvTitle=findViewById(R.id.tvTitle);
        mListView=findViewById(R.id.list_item);
    }

    @Override
    protected void loadData() {

        mTKTData = new ArrayList<ItemBean>();
        for (int i=0;i<10;i++){
            ItemBean itemBean=new ItemBean();
            itemBean.setText("你好");
            mTKTData.add(itemBean);
        }
        mTKTAdapter = new ListViewAdapter(this, mTKTData);
        mListView.setAdapter(mTKTAdapter);
//        mTKTAdapter.notifyDataSetChanged();

        presenter.list(1);
    }

    @Override
    public void getUserArticleList(ArticleListBean articleListBean) {
        Log.i("测试",articleListBean.getData().getDatas().size()+"sss");
        tvTitle.setText(articleListBean.getData().getDatas().size()+"sss");
    }
}

4.网络请求ServiceApis

public interface ServiceApi {

    @GET("/mobileServer/mobile/login.smvc?")
    Observable<LoginBean> getCategoryDate(@QueryMap Map<String, String> map);
    //相当于 &key=?
    @POST("/user/register")
    Observable<User> register(@Query("name") String name,
                                     @Query("password") String password);
    @GET("user_article/list/{page}/json")
    Observable<ArticleListBean> getUserArticleList(@Path("page") int page);


}

第三章 Fragment基础框架封装

1.MvpFragment

public abstract class MvpFragment<T extends MvpPresenter> extends LazyFragment
        implements MvpView, View.OnClickListener {
    /**
     *T：表示任意类型对象
     */
    protected T presenter;
    protected abstract T initPresenter();
    /**
     * 获取布局资源文件
     *
     * @return int
     */
    @Override
    @LayoutRes
    protected abstract int getLayoutRes();
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {

        return super.onCreateView(inflater, container, savedInstanceState);
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        attachPresenter();
        initialize();
    }

    protected void initialize() {
    initView();
    loadData();
    }
    @Override
    public Context getContext() {
        return getActivity();
    }

    public Fragment getFragment() {
        return this;
    }
    protected abstract void loadData();

    protected abstract void initView();

    private void attachPresenter() {
        if(presenter==null)
        {
        presenter=initPresenter();
        }
        if(presenter!=null)
        {
        presenter.attach(this);
        }
    }
    @Override
    protected void onVisible(boolean isFirstVisible) {
        super.onVisible(isFirstVisible);
        attachPresenter();
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        if(presenter!=null)
        {
            presenter.detach();
        }
    }
}

2.BaseFragment

public abstract  class BaseFragment<P extends MvpPresenter>extends MvpFragment<P> {
    private  boolean NetWork=false;
    MyLoadingDialog myLoadingDialog;
    private String netWorks;
    @Override
    protected void initialize() {
//        if (getRootView() != null) {
//            mUnbinder = ButterKnife.bind(this, getRootView());
//        }
//        if (isRegisterEventBus()) {
//            EventBus.getDefault().register(this);
//        }
        NetworkUtils networkUtils=new NetworkUtils(getContext());
        if(!networkUtils.isConnected()){
            NetWork=true;
        }
        super.initialize();

    }

    /**
     * 通过bundle 数据传递
     * @param cls
     * @param bundle
     */
    public void startActivityBundle(Class<?> cls, Bundle bundle) {
        Intent intent = new Intent();
        intent.setClass(getContext(), cls);
        if (bundle != null) {
            intent.putExtras(bundle);
        }
        startActivity(intent);
    }

    @Override
    public void onDestroyView() {
        clearLoading();
        super.onDestroyView();

//        if (isRegisterEventBus()) {
//            EventBus.getDefault().unregister(this);
//        }
//        if (mUnbinder != null) {
//            mUnbinder.unbind();
//        }
    }

    @Override
    public void showLoadingDialog() {
        if(NetWork)
        {
            netWorks = "网络不可用^^";
        }
        else {
            netWorks = "加载中…";
        }
        if(myLoadingDialog==null)
        {
            myLoadingDialog =new MyLoadingDialog(getContext());
            myLoadingDialog.setMessage(netWorks);
            myLoadingDialog.show();
        }
    }
    @Override
    public void dismissLoadingDialog() {
        if(myLoadingDialog!=null)
        {
            myLoadingDialog.dismiss();
        }
    }
    @Override
    public void clearLoading() {
        //使用过后将其回收
        if(myLoadingDialog!=null)
        {
            myLoadingDialog.dismiss();
            myLoadingDialog=null;
        }
    }
}

 

如有不对之处请指正，谢谢！！

 

GuoXuxiong
关注
专栏目录
Android基于Retrofit2.0 +RxJava 封装的超好用的RetrofitClient工具类（六）
Tamic （大白）
07-19 4万+
csdn ：码小白 原文地址： http://blog.csdn.net/sk719887916/article/details/51958010 RetrofitClient基于Retrofit2.0封装的RetrofitClient. 避免重复创建Retrofit实列. 调用方便简洁. 无需重复设置属性的步骤. 可固定配置 Host 也可动态配置Url、请求头、参数等. 支持文件下
Retrofit源码分析以及MVP框架封装使用
JackWaiting
06-23 6535
阅读此文前请先阅读Retrofit+okhttp网络框架介绍 从上文中我们已经了解通过如下代码即可得到返回给我们call 以及 response对象，今天我们通过源码来分析这个过程是如何实现的。 /** * 获取天气数据 * @param cityname * @param key * @return */ @GET("/weather/in
Android中RxJava+Retrofit2.0+MVP模式的整合
东子的博客 细节决定成败，点滴铸就辉煌。
03-02 2万+
Android中MVP+RxJava+Retrofit2.0的整合转载请标明出处:http://blog.csdn.net/u010046908/article/details/50767904 本文出自:【李东的博客】MVP的工作原理以上是MVP的工作原理图。其中大家注意的Presenter操作View和Mode都是通过接口来实现直接的调用。MVP的工作流程Presenter负责逻辑的处理，
Rxjava+Retrofit+Mvp的使用实例（基于retrofit2.1.0）
tiandiwuya的专栏
04-14 1128
一套非常好用的Rxjava+Retrofit+Mvp完整实例使用攻略
Android 当中的 MVP 模式（二）封装
范二er
11-05 572
Android 当中的 MVP 模式（二）封装个人博客地址 ：CODER FRAMER BIGZ在Android当中的MVP模式（一）基本概念中，用了一个简单的的登录Demo展示了一下 MVP 模式的基本姿势，虽然项目结构是更加清晰了，但是代码量明显增多了，原来的网络请求操作只用 1 个类可以搞定，现在需要 4 个类，并且每当有不同作用的 model 出现时，我们就需要相应的为他们添加 presen
Android入门学习——Retrofit+MVP模式学习
英勇青铜5
05-10 1878
Android入门学习——Retrofit+MVP模式学习简单使用最近闲着无聊的时候在网上随意闲逛的时候，Retrofit、RxJava、RxAndroid这几个词，顺带着okHttp、MVP出现的频率蛮高。这些东西都不会，就赶紧学习一下。RxJava和RxAndroid暂时先放弃。先学习Retrofit+MVP模式进行开发。首先强烈感谢鸿洋大神和CSDN的另一位博主还不走A。Retrofit、ok
【android进阶篇】MVP+Retrofit+RxJava框架结合
热门推荐
大力哥的博客
08-15 2万+
【android进阶篇】【android进阶篇】MVP+Retrofit+RxJava框架结合 另一篇MVP优化，[android进阶篇]MVP模式优化，防止内存泄漏和空指针问题 一、前言MVP模式是当前比较主流的框架，主要是由它的优点来决定的吧。本文结合了MVP+Retrofit+RxJava三大主流框架(MVP应该叫模式吧)写了一个demo【里面从简单的“登录”例子，之后到“IP地址查询”，
Android 教你一步步搭建MVP+Retrofit+RxJava网络请求框架
wa2231a的博客
01-20 594
这里我们可以看到，先新建了一个Retrofit对象，然后给它设置一个我们前面说的baseUrlhttps://api.douban.com/v2/.因为接口返回的数据不是我们需要的实体类，我们需要调用addConverterFactory方法进行转换。由于返回的数据为json类型，所以在这个方法中传入Gson转换工厂GsonConverterFactory.create(new GsonBuilder().create())，这里我们需要在studio中添加Gson的依赖： compile ‘com.sq
Kotlin语言基于Mvp+Retrofit+RxJava封装的Android项目的基础依赖库
一个人的旅行的博客
02-27 850
主要针对使用 Kotlin 语言开发Android项目，使用 MVP+Retrofit+RxJava 架构封装的一些基础类（Activity/ListActivity,Fragment/ListFragment,Adapter），供开发时依赖使用，缩短项目准备时间。
android架构mvp + rxandroid + Retrofit2.0
03-07
在这个"android架构封装mvp + rxandroid + Retrofit2.0"的项目中，开发者可能实现了以下内容： 1. MVP架构的实现： - Model层：包含数据的获取和处理，可能包括与服务器的交互，数据库操作等。 - View层：Android...
Android-Lychee是一个基于Retrofit实现的轻量级网络请求库
08-13
Lychee 是一个基于Retrofit实现的轻量级网络请求库，支持多任务上传，下载，断点续传，使用简单，方便。使用注解简化了Retrofit原有的文件上传方式，支持添加通用请求参数，参数签名(文件使用md5)
Android基于retrofit封装的网络请求库以及baseActivity高度集成定制
04-26
基于retrofit的网络请求库封装，加入了接口日志打印、数据预处理、请求异常解析以及baseActivity的高度定制化需求
mvp+rxjava2+retrofit2.0+realm基础代码
08-28
在Android开发中，MVP（Model-View-Presenter）架构模式、RxJava 2.0、Retrofit 2.0 和 Realm 是四个重要的组件，它们分别处理应用的结构设计、异步编程、网络请求和本地数据存储。接下来，我们将详细讨论这些技术...
MVP+RxJava+Retrofit+Okhttp+ButterKnifer的快速开发框架
06-06
"MVP+RxJava+Retrofit+OkHttp+ButterKnife"是一个流行的组合，它提供了强大的功能和灵活性，使得开发者能够快速构建复杂的Android应用程序。下面我们将逐一解析这些组件及其在开发中的作用。 **Model-View-...
Android MVP+Retrofit2 简单的mvp学习框架
如果人生就像一场梦，那就希望你做个好梦！
01-26 293
目录说明 contract ： V层和P层之间方法锲约，方便管理V和P之间的方法调用。 entity ：实体类，管理网络请求的数据封装类。 fragment： Android的fragment类。 http：网络请求工具类封装。 model： mvp的M层，负责数据处理。 presenter： mvp的P层，负责业务逻辑的处理。 tools： 工具类 view： mvp的V层，负责数据呈现。 M层基本描述 public class JokerModel extends BaseModel { pu
一个小框架，基于rx_retrofit2_mvp
qq_15075579的博客
11-04 2024
离职在即，也没什么事情做，就鼓捣了一下，随意搭建了一个小框架，看看以后能不能搞出自己的一个model，好了，不说别的，上代码 1，先上依赖库 compile 'io.reactivex:rxandroid:1.2.1' compile 'com.squareup.okhttp3:okhttp:3.3.1' compile 'io.reactivex:rxandroid:
基于Retrofit、OkHttp、Gson封装通用网络框架
奔跑蜗牛牛的博客
01-05 474
背景android开发过程中网络请求作为最重要的组成部分之一,然而对于大部分android开发者在网络请求上有太多疑惑,不知道如何去选型?通过原生的HttpClient、HttpUrlConnection封装?还是通过第三方框架再封装?笔者以为采用广泛被使用的第三方网络框架再封装为上策,因为这些网络框架如retrofit、okhttp、volley等是被全球android开发者维护着,无论在功能上、
android+高阶封装,基于Android+ Retrofit+MVP基础架构封装
weixin_30456235的博客
05-30 292
前言从事android开发也有一段时间了，如何封装基础架构在我们的开发中是必不可缺的技能。今天给大家分享的是基于retrofit+mvp封装的基础架构，适用于新手，大佬请忽略…………。其目的是做一个资源整合，如有不对之处请指教!第一章：公共方法封装一、封装 RetrofitWrapper.class1.新建RetrofitWrapper.class类public class RetrofitWra...
Android中使用MVP的简单封装
javac
08-28 1264
这个周末我又重新把mvp的封装再捋了一遍,我简单点说吧,就是在之前的前面,把m,v,p,三个抽出了各自的基类,绑定方法和之前一样,同样是p中有m和v的引用,p通过m获取到数据后,传递给v,从而隔断了v和m之间的联系,实现了解耦1. 我这里所说的传递数据 都是指以接口回调的方式回传数据的,不是简单的return.2. Basepresenter中的我用软引用的方式来获取view对象的,并且也把获取mo
Android Rxjava +Retrofit +mvp网络框架封装
最新发布
07-13
对于Android项目中的网络请求，RxJava、Retrofit和MVP是常用的框架组合。下面是一个简单的网络框架封装示例： 首先，在项目中引入RxJava和Retrofit的依赖。 ``` implementation 'io.reactivex.rxjava2:rxjava:2.2.19' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0' ``` 然后，创建一个Retrofit的单例类，用于进行网络请求的初始化和配置。 ```java public class RetrofitClient { private static Retrofit retrofit; private static final String BASE_URL = "https://api.example.com/"; public static Retrofit getClient() { if (retrofit == null) { retrofit = new Retrofit.Builder() .baseUrl(BASE_URL) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .build(); } return retrofit; } } ``` 接下来，创建一个ApiService接口，定义网络请求的方法。 ```java public interface ApiService { @GET("users") Observable<List<User>> getUsers(); } ``` 然后，创建一个DataManager类，用于管理网络请求。 ```java public class DataManager { private ApiService apiService; public DataManager() { apiService = RetrofitClient.getClient().create(ApiService.class); } public Observable<List<User>> getUsers() { return apiService.getUsers(); } } ``` 最后，在MVP的Presenter中调用DataManager类进行网络请求。 ```java public class UserPresenter { private UserView userView; private DataManager dataManager; public UserPresenter(UserView userView) { this.userView = userView; dataManager = new DataManager(); } public void getUsers() { dataManager.getUsers() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<List<User>>() { @Override public void onSubscribe(Disposable d) { // 在请求开始时的操作 } @Override public void onNext(List<User> users) { // 请求成功返回数据时的操作 userView.showUsers(users); } @Override public void onError(Throwable e) { // 请求失败时的操作 userView.showError(e.getMessage()); } @Override public void onComplete() { // 请求完成时的操作 } }); } } ``` 这样，就完成了一个简单的Android RxJava + Retrofit + MVP网络框架封装。你可以根据自己的需要，进行进一步的封装和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值