RxJava/RxAndroid:retry(long times, Predicate<? super Throwable> predicate)

简介: RxJava/RxAndroid:retry(long times, Predicate

RxJava/RxAndroid:retry(long times, Predicate<? super Throwable> predicate)


import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import java.net.Socket;
import java.util.concurrent.Callable;

import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Predicate;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.schedulers.Schedulers;

public class MainActivity extends AppCompatActivity {
    private String TAG = "输出";

    private DisposableObserver mDisposableObserver = new DisposableObserver<Socket>() {
        @Override
        public void onNext(Socket socket) {
            Log.d(TAG, "onNext:" + socket);
        }

        @Override
        public void onComplete() {
            Log.d(TAG, "onComplete");
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, e.toString(), e);
        }
    };

    private Socket mSocket = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Observable.fromCallable(new Callable<Socket>() {
            @Override
            public Socket call() throws Exception {
                Log.d(TAG, "call");
                mSocket = new Socket("127.0.0.1",80);
                return mSocket;
            }
        }).retry(3, new Predicate<Throwable>() {
            @Override
            public boolean test(Throwable throwable) throws Exception {
                Log.d(TAG, "test:" + throwable.toString());

                if (mSocket != null && mSocket.isConnected()) {
                    return false;
                } else {
                    return true;
                }
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(mDisposableObserver);
    }
}


output:

01-22 12:34:16.481 29902-29955/zhangphil.book D/输出: call
01-22 12:34:16.483 29902-29955/zhangphil.book D/输出: test:java.net.ConnectException: Connection refused
01-22 12:34:16.483 29902-29955/zhangphil.book D/输出: call
01-22 12:34:16.485 29902-29955/zhangphil.book D/输出: test:java.net.ConnectException: Connection refused
01-22 12:34:16.485 29902-29955/zhangphil.book D/输出: call
01-22 12:34:16.486 29902-29955/zhangphil.book D/输出: test:java.net.ConnectException: Connection refused
01-22 12:34:16.486 29902-29955/zhangphil.book D/输出: call
01-22 12:34:16.592 29902-29902/zhangphil.book E/输出: java.net.ConnectException: Connection refused
                                                    java.net.ConnectException: Connection refused
                                                        at java.net.PlainSocketImpl.socketConnect(Native Method)
                                                        at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:334)
                                                        at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:196)
                                                        at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:178)
                                                        at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:356)
                                                        at java.net.Socket.connect(Socket.java:592)
                                                        at java.net.Socket.connect(Socket.java:541)
                                                        at java.net.Socket.<init>(Socket.java:427)
                                                        at java.net.Socket.<init>(Socket.java:210)
                                                        at zhangphil.book.MainActivity$3.call(MainActivity.java:46)
                                                        at zhangphil.book.MainActivity$3.call(MainActivity.java:42)
                                                        at io.reactivex.internal.operators.observable.ObservableFromCallable.subscribeActual(ObservableFromCallable.java:42)
                                                        at io.reactivex.Observable.subscribe(Observable.java:11040)
                                                        at io.reactivex.internal.operators.observable.ObservableRetryPredicate$RepeatObserver.subscribeNext(ObservableRetryPredicate.java:111)
                                                        at io.reactivex.internal.operators.observable.ObservableRetryPredicate.subscribeActual(ObservableRetryPredicate.java:41)
                                                        at io.reactivex.Observable.subscribe(Observable.java:11040)
                                                        at io.reactivex.internal.operators.observable.ObservableSubscribeOn$SubscribeTask.run(ObservableSubscribeOn.java:96)
                                                        at io.reactivex.Scheduler$DisposeTask.run(Scheduler.java:463)
                                                        at io.reactivex.internal.schedulers.ScheduledRunnable.run(ScheduledRunnable.java:66)
                                                        at io.reactivex.internal.schedulers.ScheduledRunnable.call(ScheduledRunnable.java:57)
                                                        at java.util.concurrent.FutureTask.run(FutureTask.java:237)
                                                        at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:272)
                                                        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
                                                        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
                                                        at java.lang.Thread.run(Thread.java:776)


相关文章
RxJava/RxAndroid:timer(long delay, TimeUnit unit)
RxJava/RxAndroid:timer(long delay, TimeUnit unit) timer起到定时器的作用,本例使用timer延迟3秒执行一个输出任务: package com.
1414 0
|
Android开发
RxJava/RxAndroid:ConnectableObservable &amp; replay(long time, TimeUnit unit)
RxJava/RxAndroid:ConnectableObservable & replay(long time, TimeUnit unit) import android.
1136 0
RxJava/RxAndroid:ConnectableObservable &amp; replay(int bufferSize, long time, TimeUnit unit)
RxJava/RxAndroid:ConnectableObservable & replay(int bufferSize, long time, TimeUnit unit) import android.
1111 0
|
Java Android开发
RxJava/RxAndroid : buffer(long timespan, TimeUnit unit)
RxJava/RxAndroid : buffer(long timespan, TimeUnit unit) 以timespan个unit时间单位作为缓冲周期,一轮一轮的把数据流中的数据分批发射出去。
1162 0
|
JSON JavaScript 前端开发
解决js中Long类型数据在请求与响应过程精度丢失问题(springboot项目中)
解决js中Long类型数据在请求与响应过程精度丢失问题(springboot项目中)
1525 0
|
编译器 C语言
c语言中long的作用类型
c语言中long的作用类型
463 0
|
11月前
|
编译器 C#
c# - 运算符<<不能应用于long和long类型的操作数
在C#中,左移运算符的第二个操作数必须是 `int`类型,因此需要将 `long`类型的位移计数显式转换为 `int`类型。这种转换需要注意数据丢失和负值处理的问题。通过本文的详细说明和示例代码,相信可以帮助你在实际开发中正确使用左移运算符。
123 3
|
11月前
|
编译器 C#
c# - 运算符<<不能应用于long和long类型的操作数
在C#中,左移运算符的第二个操作数必须是 `int`类型,因此需要将 `long`类型的位移计数显式转换为 `int`类型。这种转换需要注意数据丢失和负值处理的问题。通过本文的详细说明和示例代码,相信可以帮助你在实际开发中正确使用左移运算符。
223 2
|
11月前
|
编译器 C#
c# - 运算符<<不能应用于long和long类型的操作数
在C#中,左移运算符的第二个操作数必须是 `int`类型,因此需要将 `long`类型的位移计数显式转换为 `int`类型。这种转换需要注意数据丢失和负值处理的问题。通过本文的详细说明和示例代码,相信可以帮助你在实际开发中正确使用左移运算符。
104 0
|
前端开发 Java 数据库
Java系列之 Long类型返回前端精度丢失
这篇文章讨论了Java后端实体类中Long类型数据在传递给前端时出现的精度丢失问题,并提供了通过在实体类字段上添加`@JsonSerialize(using = ToStringSerializer.class)`注解来确保精度的解决方法。

热门文章

最新文章