RxJava+Retrofit使用

最新推荐文章于 2025-04-07 10:20:32 发布
最新推荐文章于 2025-04-07 10:20:32 发布
阅读量708 收藏 23
点赞数 11
分类专栏： 程序员 文章标签： rxjava retrofit echarts
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_84121627/article/details/137635333
版权

import com.yumakeji.rxjava.network.error.HttpThrowable;

import com.yumakeji.rxjava.network.handler.RetryWithDelay;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.TimeUnit;

import cc.network.rxjava.rxjava.ServiceApi;

import cc.network.rxjava.textbean.LoginBean;

import cc.network.rxjava.textbean.Top250Bean;

import cc.network.rxjava.viewmodel.RxjavaViewModel;

import cn.yumakeji.jetpackroomstudy.R;

import cn.yumakeji.lib_common.global.AppGlobals;

import cn.yumakeji.lib_common.utils.AppUtils;

import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;

import io.reactivex.rxjava3.annotations.NonNull;

import io.reactivex.rxjava3.core.Observable;

import io.reactivex.rxjava3.core.ObservableEmitter;

import io.reactivex.rxjava3.core.ObservableOnSubscribe;

import io.reactivex.rxjava3.core.ObservableSource;

import io.reactivex.rxjava3.core.Observer;

import io.reactivex.rxjava3.disposables.Disposable;

import io.reactivex.rxjava3.functions.Action;

import io.reactivex.rxjava3.functions.BiFunction;

import io.reactivex.rxjava3.functions.Consumer;

import io.reactivex.rxjava3.functions.Function;

import io.reactivex.rxjava3.schedulers.Schedulers;

/**

  • 防止多次点击

  • https://www.jianshu.com/p/ea45670a364f,

  • Retrofit

  • https://blog.youkuaiyun.com/huangxiaoguo1/article/details/65627293

  • Rxjava

  • https://www.jianshu.com/p/092452f287db

  • 不继承RxAppCompatActivity的情况下使用RxLifeCycle

  • https://blog.youkuaiyun.com/kevinscsdn/article/details/78980010

*/

public class RxjavaActivity extends BaseActivity {

private ListView mListView;

private List strings = new CopyOnWriteArrayList<>();

private final String TAG = “Rxjava”;

private RxjavaViewModel viewModel;

@Override

public void onDetachedFromWindow() {

super.onDetachedFromWindow();

getLifecycle().removeObserver(viewModel);

}

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_rxjava);

mListView = findViewById(R.id.list_item);

strings.add("Get方法 @Query ");

strings.add("Post方法 @Body ");

strings.add(“使用Rxjava切换线程”);

strings.add(“Rxjava（一）emitter”);

strings.add(“Rxjava（二）变换操作符Map”);

strings.add(“Rxjava（三）FlatMap”);

strings.add(“Rxjava（四）concatMap”);

strings.add(“Rxjava（五）接口顺序调用”);

strings.add(“Rxjava（六）接口顺序调用(内部发生错误)”);

strings.add(“Rxjava（七）Zip来打包”);

}

/**

  • 去体验Retrofit

  • @param view

*/

public void onRetrofitClick(View view) {

startActivity(new Intent(this, RetrofitActivity.class));

}

@Override

public void onAttachedToWindow() {

super.onAttachedToWindow();

viewModel = new RxjavaViewModel(this);

getLifecycle().addObserver(viewModel);

mListView.setAdapter(new ArrayAdapter(this, android.R.layout.simple_list_item_1, strings));

mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {

@Override

public void onItemClick(AdapterView<?> parent, View view, int position, long id) {

switch (position) {

case 0://Get方法 @Query

RetrofitClient.getInstance()

.create(ServiceApi.class)// 创建服务

.getSearchContent(“”, 5)//调用接口

.subscribeOn(Schedulers.io())// 指定被观察者的操作在io线程中完成

.doOnSubscribe(disposable -> viewModel.showProgressDialog(“正在请求中”))

.observeOn(AndroidSchedulers.mainThread())//指定观察者接收到数据，然后在Main线程中完成

.retryWhen(new RetryWithDelay(1, 1))//遇到错误时重试,第一个参数为重试几次,第二个参数为重试的间隔

.doAfterTerminate(() -> viewModel.hintProgressDialog())

.compose(rxLifecycle.bindUntilEvent(Lifecycle.Event.ON_DESTROY))//生命周期

.subscribe(new ConsumerCallback() {

@Override

public void onSucceed(Top250Bean result) {

// 成功获取数据

Toast.makeText(AppGlobals.getApplication().getApplicationContext(),

“成功了” + result, Toast.LENGTH_LONG).show();

}

@Override

public void onError(int code, String msg) {

// 获取数据失败

Toast.makeText(AppGlobals.getApplication().getApplicationContext(),

msg, Toast.LENGTH_LONG).show();

}

}, new ThrowableCallback() {

@Override

public void onError(HttpThrowable httpThrowable) {

// 获取数据失败

Log.i(TAG, httpThrowable.message);

}

});

break;

case 1://POST方法 @Body

ArrayMap<String, Object> map = new ArrayMap<>();

map.put(“jsCode”, “033sHaaK03pRwa2Bic9K0EmcaK0sHaaq”);

RetrofitClient.getInstance()

.create(ServiceApi.class)

.postCode2Session(map)

.subscribeOn(Schedulers.io())

.doOnSubscribe(disposable -> viewModel.showProgressDialog(“正在请求中”))

.observeOn(AndroidSchedulers.mainThread())

.compose(rxLifecycle.bindUntilEvent(Lifecycle.Event.ON_DESTROY))

.retryWhen(new RetryWithDelay(1, 1))//遇到错误时重试,第一个参数为重试几次,第二个参数为重试的间隔

.doAfterTerminate(() -> viewModel.hintProgressDialog())

.subscribe(new ObserverCallback() {

@Override

public void onSucceed(LoginBean result) {

// 成功获取数据

Toast.makeText(AppGlobals.getApplication().getApplicationContext(),

“成功了” + result, Toast.LENGTH_LONG).show();

}

@Override

public void onFail(int code, String msg) {

// 获取数据失败

Toast.makeText(AppGlobals.getApplication().getApplicationContext(),

msg, Toast.LENGTH_LONG).show();

}

@Override

public void onComplete() {

super.onComplete();

}

});

break;

case 2://使用Rxjava切换线程

Observable.empty().observeOn(Schedulers.io())

.doOnComplete(new Action() {

@Override

public void run() throws Throwable {

Log.i(TAG, “我是子线程：” + AppUtils.isMainThread());

Observable.timer(3, TimeUnit.SECONDS)

.observeOn(AndroidSchedulers.mainThread())

.doOnComplete(() -> msgManagement(10))

.subscribe();

Observable.empty().observeOn(AndroidSchedulers.mainThread())

.doOnComplete(() -> msgManagement(20)

).subscribe();

}

}).subscribe();

break;

case 3:

//Rxjava（一）emitter 发射器

/**

  • 借鉴：给初学者的RxJava2.0教程(一)

  • https://www.jianshu.com/p/464fa025229e

  • 规则：

  • 1、上游可以发送无限个onNext, 下游也可以接收无限个onNext.

  • 2、当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.

  • 3、当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.

  • 4、上游可以不发送onComplete或onError.

  • 5、最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError,

  • 也不能先发一个onComplete, 然后再发一个onError, 反之亦然

  • 注: 关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则,

  • **并不一定会导致程序崩溃. ** 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了,

  • 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.

*/

Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

Log.e(TAG, “是否是主线程=>” + AppUtils.isMainThread());

emitter.onNext(“huangxiaoguo1”);

emitter.onNext(“huangxiaoguo2”);

emitter.onNext(“huangxiaoguo3”);

emitter.onComplete();

}

})

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Observer() {

private Disposable mDisposable;

/**

  • 不带任何参数的subscribe() 表示下游不关心任何事件,你上游尽管发你的数据去吧, 老子可不管你发什么.

  • 带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件我假装没看见,

  • @param d

*/

@Override

public void onSubscribe(@NonNull Disposable d) {

Log.d(TAG, “subscribe”);

mDisposable = d;

}

@Override

public void onNext(@NonNull String s) {

/**

  • 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件.

  • 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件

*/

Log.e(TAG, “onNext 是否是主线程 ==>” + AppUtils.isMainThread());

Log.d(TAG, “onNext==>” + s);

if (s.equals(“huangxiaoguo2”)) {

mDisposable.dispose();

}

}

@Override

public void onError(@NonNull Throwable e) {

Log.d(TAG, “onError”);

}

@Override

public void onComplete() {

Log.d(TAG, "onComplete ");

}

});

break;

case 4:

//Rxjava（二）变换操作符Map

Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

Log.e(TAG, “subscribe 是否是主线程 ==>” + AppUtils.isMainThread());

emitter.onNext(1);

emitter.onNext(2);

emitter.onNext(3);

}

})

.subscribeOn(Schedulers.io())

.map(new Function<Integer, String>() {

@Override

public String apply(Integer integer) throws Throwable {

Log.e(TAG, “map 是否是主线程 ==>” + AppUtils.isMainThread());

return “我是在map中处理过了的===>” + String.valueOf(integer);

}

})

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(String s) throws Throwable {

Log.e(TAG, “accept 是否是主线程 ==>” + AppUtils.isMainThread());

Log.i(TAG, “accept===>” + s);

}

});

break;

case 5:

//flatMap 并不保证事件的顺序

Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

emitter.onNext(1);

emitter.onNext(2);

emitter.onNext(3);

}

}).flatMap(new Function<Integer, ObservableSource>() {

@Override

public ObservableSource apply(Integer integer) throws Throwable {

ArrayList strings = new ArrayList<>();

for (int i = 0; i < 3; i++) {

strings.add("I am value " + integer);

}

return Observable.fromIterable(strings).delay(2, TimeUnit.SECONDS);

}

}).subscribe(new Consumer() {

@Override

public void accept(String s) throws Throwable {

Log.d(TAG, s);

}

});

break;

case 6:

//concatMap 保证顺序

Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

emitter.onNext(1);

emitter.onNext(2);

emitter.onNext(3);

}

}).concatMap(new Function<Integer, ObservableSource>() {

@Override

public ObservableSource apply(Integer integer) throws Throwable {

ArrayList strings = new ArrayList<>();

for (int i = 0; i < 3; i++) {

strings.add("I am value " + integer);

}

return Observable.fromIterable(strings).delay(2, TimeUnit.SECONDS);

}

}).subscribe(new Consumer() {

@Override

public void accept(String s) throws Throwable {

Log.d(TAG, s);

}

});

break;

case 7:

//Rxjava（五）接口顺序调用

RetrofitClient.getInstance()

.create(ServiceApi.class)// 创建服务

.getSearchContent(“”, 5)//调用接口

.subscribeOn(Schedulers.io())// 指定被观察者的操作在io线程中完成

.doOnSubscribe(disposable -> viewModel.showProgressDialog(“正在请求中”))

.observeOn(AndroidSchedulers.mainThread())//指定观察者接收到数据，然后在Main线程中完成

.doOnNext(new ConsumerCallback() {

@Override

public void onSucceed(Top250Bean result) {

Log.e(TAG, result.toString());

}

@Override

public void onError(int code, String msg) {

}

})

.observeOn(Schedulers.io())

.flatMap(new Function<Result, Observable<Result>>() {

@Override

public Observable<Result> apply(Result result) throws Throwable {

Log.e(TAG, result.getMessage());

ArrayMap<String, Object> map = new ArrayMap<>();

map.put(“jsCode”, “033sHaaK03pRwa2Bic9K0EmcaK0sHaaq”);

return RetrofitClient.getInstance().create(ServiceApi.class).postCode2Session(map);

}

})

.retryWhen(new RetryWithDelay(1, 1))//遇到错误时重试,第一个参数为重试几次,第二个参数为重试的间隔

.compose(rxLifecycle.bindUntilEvent(Lifecycle.Event.ON_DESTROY))//生命周期

.observeOn(AndroidSchedulers.mainThread())

.doAfterTerminate(() -> viewModel.hintProgressDialog())

.subscribe(new ConsumerCallback() {

@Override

public void onSucceed(LoginBean result) {

Log.e(TAG, result.toString());

}

@Override

public void onError(int code, String msg) {

Log.e(TAG, msg);

}

}, new ThrowableCallback() {

@Override

public void onError(HttpThrowable httpThrowable) {

super.onError(httpThrowable);

}

});

break;

case 8:

//Rxjava（六）接口顺序调用(内部发生错误)

ArrayMap<String, Object> map1 = new ArrayMap<>();

map1.put(“jsCode”, “033sHaaK03pRwa2Bic9K0EmcaK0sHaaq”);

RetrofitClient.getInstance()

.create(ServiceApi.class)// 创建服务

.postCode2Session(map1)//调用接口

.subscribeOn(Schedulers.io())// 指定被观察者的操作在io线程中完成

.doOnSubscribe(disposable -> viewModel.showProgressDialog(“正在请求中”))

.observeOn(AndroidSchedulers.mainThread())//指定观察者接收到数据，然后在Main线程中完成

.doOnNext(new ConsumerCallback() {

@Override

public void onSucceed(LoginBean result) {

Log.e(TAG, result.toString());

}

@Override

public void onError(int code, String msg) {

Log.e(TAG, msg);

}

})

.observeOn(Schedulers.io())

.flatMap(new Function<Result, Observable<Result>>() {

@Override

public Observable<Result> apply(Result result) throws Throwable {

if (!result.isOk()) {

return null;

}

return RetrofitClient.getInstance().create(ServiceApi.class).getSearchContent(“”, 5);

}

})

.retryWhen(new RetryWithDelay(1, 1))//遇到错误时重试,第一个参数为重试的间隔,第二个参数为重试几次

.compose(rxLifecycle.bindUntilEvent(Lifecycle.Event.ON_DESTROY))//生命周期

.observeOn(AndroidSchedulers.mainThread())

.doAfterTerminate(() -> viewModel.hintProgressDialog())

.subscribe(new ConsumerCallback() {

@Override

public void onSucceed(Top250Bean result) {

Log.e(TAG, result.toString());

}

@Override

public void onError(int code, String msg) {

Log.e(TAG, msg);

}

}, new ThrowableCallback() {

@Override

public void onError(HttpThrowable httpThrowable) {

super.onError(httpThrowable);

}

});

break;

case 9:

//Rxjava（七）Zip来打包请求

Observable.zip(RetrofitClient.getInstance()

.create(ServiceApi.class)

.getSearchContent(“”, 1)

.subscribeOn(Schedulers.io()),

RetrofitClient.getInstance()

.create(ServiceApi.class)

.getSearchContent2(“”, 1)

.subscribeOn(Schedulers.io()),

new BiFunction<Result, Result, Top250Bean>() {

@Override

public Top250Bean apply(Result result, Result result2) throws Throwable {

Top250Bean data1 = JSON.parseObject(JSON.toJSONString(result.data), Top250Bean.class);

Top250Bean data2 = JSON.parseObject(JSON.toJSONString(result.data), Top250Bean.class);

data1.getRecords().addAll(data2.getRecords());

return data1;

}

}).observeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(Top250Bean result) throws Throwable {

Log.e(TAG, result.toString());

Log.e(TAG, result.getRecords().size()+“—”);

}

});

break;

}

}

});

}

/**

  • 代替Handler

  • @param what

*/

private void msgManagement(int what) {

if (what == 10) {

Log.i(TAG, “我是代替Handler 有延时” + AppUtils.isMainThread());

} else {

Log.i(TAG, “我是代替Handler 没有延时” + AppUtils.isMainThread());

}

}

}

  • MVVM中管理Rxjava的生命周期

可直接使用开源框架：rxjava-RxLife

//使用rxlife对viewModel生命周期执行支持（rxlifecycle在google jetpack的videModel中不太好用，针对的是MVP）

api ‘com.ljx.rxlife3:rxlife-rxjava:3.0.0’

注意: 一定要在Activity/Fragment通过以下方式获取ViewModel对象，否则RxLife接收不到生命周期的回调

viewModel = new ViewModelProvider(this).get(RxjavaViewModel.class);

Observable.interval(2, TimeUnit.SECONDS)

.observeOn(AndroidSchedulers.mainThread())

.to(RxLife.to(this))

.subscribe(new Consumer() {

@Override

public void accept(Long aLong) throws Throwable {

Log.e(“huangxiaoguo”, “接口轮询”);

}

});

其他设计到的类
  • error

package com.yumakeji.rxjava.network.error;

public class HttpThrowable extends Exception {

public int errorType;

public String message;

public Throwable throwable;

/**

  • 未知错误

*/

public static final int UNKNOWN = 1000;

/**

  • 解析错误

*/

public static final int PARSE_ERROR = 1001;

/**

  • 连接错误

*/

public static final int CONNECT_ERROR = 1002;

/**

  • DNS解析失败（无网络）

*/

public static final int NO_NET_ERROR = 1003;

/**

  • 连接超时错误

*/

public static final int TIME_OUT_ERROR = 1004;

/**

  • 网络（协议）错误

*/

public static final int HTTP_ERROR = 1005;

/**

  • 证书错误

*/

public static final int SSL_ERROR = 1006;

public HttpThrowable(int errorType, String message, Throwable throwable) {

super(throwable);

this.errorType = errorType;

this.message = message;

this.throwable = throwable;

}

}

import com.alibaba.fastjson.JSONException;

import com.google.gson.JsonParseException;

import java.net.ConnectException;

import java.net.SocketTimeoutException;

import java.net.UnknownHostException;

import retrofit2.HttpException;

public class ThrowableHandler {

public static HttpThrowable handleThrowable(Throwable throwable) {

if (throwable instanceof HttpException) {

return new HttpThrowable(HttpThrowable.HTTP_ERROR, “网络(协议)异常”, throwable);

} else if (throwable instanceof JsonParseException || throwable instanceof JSONException || throwable instanceof ParseException) {

return new HttpThrowable(HttpThrowable.PARSE_ERROR, “数据解析异常”, throwable);

} else if (throwable instanceof UnknownHostException) {

return new HttpThrowable(HttpThrowable.NO_NET_ERROR, “网络连接失败，请稍后重试”, throwable);

} else if (throwable instanceof SocketTimeoutException) {

return new HttpThrowable(HttpThrowable.TIME_OUT_ERROR, “连接超时”, throwable);

} else if (throwable instanceof ConnectException) {

return new HttpThrowable(HttpThrowable.CONNECT_ERROR, “连接异常”, throwable);

} else if (throwable instanceof javax.net.ssl.SSLHandshakeException) {

return new HttpThrowable(HttpThrowable.SSL_ERROR, “证书验证失败”, throwable);

} else {

return new HttpThrowable(HttpThrowable.UNKNOWN, throwable.getMessage(), throwable);

}

}

}

  • 误时重试

public class RetryWithDelay implements Function<Observable, ObservableSource<?>> {

private int retryDelaySeconds;//延迟重试的时间

private int retryCount;//记录当前重试次数

private int retryCountMax;//最大重试次数

public RetryWithDelay(int retryDelaySeconds, int retryCountMax) {

this.retryDelaySeconds = retryDelaySeconds;

this.retryCountMax = retryCountMax;

}

@Override

public ObservableSource<?> apply(Observable throwableObservable) throws Exception {

//方案一：使用全局变量来控制重试次数，重试3次后不再重试，通过代码显式回调onError结束请求

return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {

@Override

public ObservableSource<?> apply(Throwable throwable) throws Exception {

//如果失败的原因是UnknownHostException（DNS解析失败，当前无网络），则没必要重试，直接回调error结束请求即可

if (throwable instanceof UnknownHostException) {

return Observable.error(throwable);

}

//没超过最大重试次数的话则进行重试

if (++retryCount <= retryCountMax) {

//延迟retryDelaySeconds后开始重试

return Observable.timer(retryDelaySeconds, TimeUnit.SECONDS);

}

return Observable.error(throwable);

}

});

}

}

  • 拦截器

public class CacheIntercepter implements Interceptor {

@NotNull

@Override

public Response intercept(@NotNull Chain chain) throws IOException {

//对request的设置用来指定有网/无网下所走的方式

//对response的设置用来指定有网/无网下的缓存时长

Request request = chain.request();

if (!NetworkUtils.isNetWorkAvailable(AppGlobals.getApplication())) {

//无网络下强制使用缓存，无论缓存是否过期,此时该请求实际上不会被发送出去。

//有网络时则根据缓存时长来决定是否发出请求

request = request.newBuilder()

.cacheControl(CacheControl.FORCE_CACHE).build();

}

Response response = chain.proceed(request);

if (NetworkUtils.isNetWorkAvailable(AppGlobals.getApplication())) {

//有网络情况下，超过1分钟，则重新请求，否则直接使用缓存数据

int maxAge = 60; //缓存一分钟

String cacheControl = “public,max-age=” + maxAge;

//当然如果你想在有网络的情况下都直接走网络，那么只需要

//将其超时时间maxAge设为0即可

return response.newBuilder()

.header(“Cache-Control”, cacheControl)

.removeHeader(“Pragma”).build();

} else {

//无网络时直接取缓存数据，该缓存数据保存3天

int maxStale = 60 * 60 * 24 * 3; //无网络时，设置超时为3天

return response.newBuilder()

.header(“Cache-Control”, “public,only-if-cached,max-stale=” + maxStale)

.removeHeader(“Pragma”).build();

}

}

}

public class HeaderInterceptor implements Interceptor {

@NotNull

@Override

public Response intercept(@NotNull Chain chain) throws IOException {

Request originalRequest = chain.request();

Request.Builder builder = originalRequest.newBuilder();

//设置具体的header内容

builder.addHeader(“Content-Type”, “text/html;charset=UTF-8”);

builder.addHeader(“token”, “123456789”);

Request.Builder requestBuilder =

builder.method(originalRequest.method(), originalRequest.body());

Request request = requestBuilder.build();

return chain.proceed(request);

}

}

  • 绕过所有的证书

/**

  • 绕过所有的证书

*/

public class TrustAllCerts implements 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[0];

}

public static SSLSocketFactory createSSLSocketFactory() {

SSLSocketFactory factory = null;

try {

SSLContext context = SSLContext.getInstance(“TLS”);

context.init(null, new TrustManager[]{new TrustAllCerts()}, new SecureRandom());

factory = context.getSocketFactory();

} catch (Exception e) {

}

return factory;

}

public static class TrustAllHostnameVerifier implements HostnameVerifier {

@Override

public boolean verify(String hostname, SSLSession session) {

return true;

}

}

}

  • 网络状态

public class NetworkUtils {

/**

  • 网络不可用

*/

public static final int NO_NET_WORK = 0;

/**

  • 是wifi连接

*/

public static final int WIFI = 1;

/**

  • 不是wifi连接

*/

public static final int NO_WIFI = 2;

private NetworkUtils() {

/* cannot be instantiated */

throw new UnsupportedOperationException(“cannot be instantiated”);

}

/**

  • 判断是否打开网络

  • @param context

  • @return

*/

public static boolean isNetWorkAvailable(Context context) {

boolean isAvailable = false;

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

NetworkInfo networkInfo = cm.getActiveNetworkInfo();

if (networkInfo != null && networkInfo.isAvailable()) {

isAvailable = true;

}

return isAvailable;

}

/**

  • 获取网络类型

  • @param context

  • @return

*/

public static int getNetWorkType(Context context) {

if (!isNetWorkAvailable(context)) {

return NetworkUtils.NO_NET_WORK;

}

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

// cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

if (cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting())

return NetworkUtils.WIFI;

else

return NetworkUtils.NO_WIFI;

}

/**

  • 判断当前网络是否为wifi

  • @param context

  • @return 如果为wifi返回true；否则返回false

*/

@SuppressWarnings(“static-access”)

public static boolean isWiFiConnected(Context context) {

ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

NetworkInfo networkInfo = manager.getActiveNetworkInfo();

return networkInfo.getType() == manager.TYPE_WIFI ? true : false;

}

/**

  • 判断MOBILE网络是否可用

  • @param context

  • @return

  • @throws Exception

*/

public static boolean isMobileDataEnable(Context context) {

ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

boolean isMobileDataEnable = false;

isMobileDataEnable = manager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();

return isMobileDataEnable;

}

/**

  • 判断wifi 是否可用

  • @param context

  • @return

  • @throws Exception

*/

public static boolean isWifiDataEnable(Context context) {

ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

boolean isWifiDataEnable = false;

isWifiDataEnable = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();

return isWifiDataEnable;

}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

img

img

img

img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

分享一份NDK基础开发资料

详解：Linux网络虚拟化技术

分享内容包括不限于高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

ext.CONNECTIVITY_SERVICE);

boolean isMobileDataEnable = false;

isMobileDataEnable = manager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();

return isMobileDataEnable;

}

/**

  • 判断wifi 是否可用

  • @param context

  • @return

  • @throws Exception

*/

public static boolean isWifiDataEnable(Context context) {

ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

boolean isWifiDataEnable = false;

isWifiDataEnable = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();

return isWifiDataEnable;

}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-I1SdvShV-1712812250964)]

[外链图片转存中…(img-hxZ9oyEm-1712812250965)]

[外链图片转存中…(img-RtWObh1R-1712812250965)]

[外链图片转存中…(img-nMajTNEQ-1712812250966)]

[外链图片转存中…(img-d44krn0I-1712812250966)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

分享一份NDK基础开发资料

[外链图片转存中…(img-J4v6Hg4Y-1712812250966)]

分享内容包括不限于高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

MVP+Dagger2+Retrofit2.0+Rxjava看这一个例子就够了
这个时代，作为程序员可能要学习小程序
08-26 1万+
MVP+Dagger2+Retrofit2.0+Rxjava的案例
RxJava+Retrofit使用，详细解说
m0_66264881的博客
02-05 1312
public abstract class BaseActivity extends AppCompatActivity { /** 绑定生命周期 */ protected LifecycleProvider<Lifecycle.Event> rxLifecycle = AndroidLifecycle.createLifecycleProvider(this); @Override protected void onCreate(@Nullable Bundle savedInstance
retrofit2.0+okhtt3.0+gson+Rxjava
05-11
自己封装的一个retrofit2.0+okhtt3.0+gson+Rxjava网络框架 改改JSON网站和javaBean就好 混淆没什么东西 自己百度一下就行了 就不留 混淆了
Android Retrofit2.0+RxJava3.0 基本使用
ezconn的博客
10-24 9398
异常： Could not locate call adapter for io.reactivex.Observable<okhttp3.ResponseBody>. compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0' RxJava适配器是1.0 所以换成RxJava2.0就可以了，两种方式配置RxJava适配器2.0 1，第三方的提供的适配器2.0 compile 'com.jakewharton.retrofit:retro
Retrofit2+RxJava3使用
吃饭不玩手机的博客
01-02 793
Retrofit2+RxJava3使用
kotlin Rxjava3+retrofit2.0+RxLifecycle3封装
qq_34900897的博客
01-02 4038
在项目中一直都没有怎么用到过这是一大遗憾，只能在demo中使用了。 先给一个RxJAVA3的github 看看里面使用方法，详细就列出来了，可以看看里面解释： Rxjava3 Rxlifecyc Retrofit 这里贴上版本信息： Version 3.x (Javadoc) single dependency: Reactive-Streams Java 8+ (Android d...
Rxjava+Retrofit简单使用
qq_56611561的博客
01-08 776
retrofit通过网络线程获得的数据，数据只能在网络线程中使用，无法传递到主线程中。所以可以用rxjava的观察者模式使数据提取在主线程中使用。
手把手搭建Okhttp+Retrofit+RxJava+ARouter+MVVM+组件化Android项目框架
h5630的博客
12-26 1647
手把手搭建Okhttp+Retrofit+RxJava+ARouter+MVVM+组件化Android项目框架
RxJava+Retrofit使用，四年Android面试遇到的问题整理
m0_60607245的博客
03-17 1086
外链图片转存中…(img-tfR2fwvN-1710672471753)][外链图片转存中…(img-P8MLuNBf-1710672471753)][外链图片转存中…(img-ARuXqrQZ-1710672471754)][外链图片转存中…(img-pYwt3sfT-1710672471754)]
RxJava+Retrofit+OkHttp的简单使用
weixin_58124208的博客
08-22 369
android
RxJava+Retrofit+OkHttp实现多文件下载之断点续传
08-28
RxJava+Retrofit+OkHttp实现多文件下载之断点续传 本篇文章主要介绍了使用RxJava、Retrofit和OkHttp实现多文件下载之断点续传的技术。断点续传下载一直是移动开发中必不可少的一项重要的技术，通过RxJava和Retrofit...
深入浅出RxJava+Retrofit+OkHttp网络请求
01-05
浅谈RxJava+Retrofit+OkHttp 封装使用 之前发出后收到很多朋友的关注，原本只是自己学习后的一些经验总结，但是有同学运用到实战当中，这让我很惶恐，所有后续一直更新了很多次版本，有些地方难免有所变动导致之前的...
RxJava+Retrofit+OkHttp实现文件上传
08-28
RxJava+Retrofit+OkHttp实现文件上传 RxJava是一种基于观察者模式的响应式编程库，Retrofit是一个基于OkHttp的HTTP客户端库，OkHttp是一个高效的HTTP客户端库。今天，我们将学习如何使用RxJava、Retrofit和OkHttp来...
MVP+RxJava+Retrofit, 一个Android应用层快速开发基础框架.zip
02-09
在Android应用开发中，"MVP+RxJava+Retrofit"是一个常见的高效、灵活的基础架构组合，被广泛用于实现快速开发。这个框架结合了Model-View-Presenter（MVP）设计模式、Reactive Extensions（RxJava）编程库以及...
RxJava+Retrofit+okhttp上传图片给后台
12-08
4. **使用RxJava调用Retrofit服务**：创建Retrofit实例，然后订阅并执行上传方法。 ```java Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://your-server-url.com/") .addConverterFactory...
Android OkHttp+Retrofit+Rxjava+Hilt实现网络请求框架
2401_89791727的博客
01-24 840
/未知错误//解析错误//网络错误/连接错误//解析错误return ex;//网络错误return ex;//连接错误return ex;} else {//未知错误return ex;
低代码开发革命：用 ZKmall开源商城可视化逻辑编排实现业务流程再造
最新发布
04-07 889
ZKmall开源商城通过与，重新定义了企业级电商业务流程的构建与优化方式。本文将从技术架构、核心能力、实践案例及行业价值等维度，解析其如何以"低代码+流程引擎"组合拳实现业务流程再造的革命性突破。
Java反射机制，动态代理，hook以及在Retrofit源码中的应用
门徒07的博客
08-11 947
Java的反射机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。然后我们回过头来看反射机制是 基础，动态代理里面也是用反射来实现的，动态代理对类里面的所有方法统一动态加入操作代码，java使用更多是对接口的，是生成了你想往里面塞的代码，hook把hook对象勾出来，换成自己想塞进去的，是一种手法。1.1.3使用对象.getClass() 方法，返回对象所属的类的 Class 对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值