TomyZhang
TomyZhang

网络编程 -- Retrofit + RxJava

一、概念

Retrofit之所以作为现在最流行的网络请求库，其中一个主要原因是支持RxJava，即Retrofit除了提供传统的网络请求方式外，还提供RxJava版本的网络请求方式。两种方式在使用上最大的区别在于：传统方式采用了Callback接口，而RxJava方式则采用了Observable接口。

主要体现在：
1.用于描述网络请求的接口的设置

// 传统方式：Call<..>接口形式
public interface GetRequest_Interface {
    @GET("url地址")
    Call getCall();
    // 注解里传入 网络请求 的部分URL地址
    // getCall()是接受网络请求数据的方法
}


// RxJava方式：Observable<..>接口形式
@GET("url地址")
Observable getCall();

2.网络请求的封装形式和发送形式

// 传统方式
// 1. 创建 网络请求接口 的实例
GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

// 2. 采用Call<..>接口 对 发送请求 进行封装
Call call = request.getCall();

// 3. 发送网络请求(异步)
call.enqueue(new Callback() {
    // 请求成功时回调
    @Override
    public void onResponse(Call call, Response response) {
         ...  
    }

    // 请求失败时回调
    @Override
    public void onFailure(Call call, Throwable throwable) {
        ....
    }
});


// RxJava方式
// 1. 创建 网络请求接口 的实例
GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

// 2. 采用Observable<...>形式 对 网络请求 进行封装
Observable observable = request.getCall();

// 3. 发送网络请求(异步)
observable.subscribeOn(Schedulers.io())               // 在IO线程进行网络请求
          .observeOn(AndroidSchedulers.mainThread())  // 回到主线程 处理请求结果
          .subscribe(new Observer() {

            // 发送请求后调用该复写方法（无论请求成功与否）
            @Override
            public void onSubscribe(Disposable d) {
                ...// 初始化工作
              }
            
            // 发送请求成功后调用该复写方法
            @Override
            public void onNext(Translation result) {
                ...// 对返回结果Translation类对象 进行处理
            }

            // 发送请求成功后，先调用onNext（）再调用该复写方法
            @Override
            public void onComplete() {
                Log.d(TAG, "请求成功");
            }
            // 发送请求失败后调用该复写方法
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "请求失败");
            }

        });
}

二、使用

1.基本使用

步骤1：添加依赖及网络权限

//添加依赖
// Android 支持 Rxjava
// 此处一定要注意使用RxJava2的版本
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

// Android 支持 Retrofit
compile 'com.squareup.retrofit2:retrofit:2.1.0'

// 衔接 Retrofit & RxJava
// 此处一定要注意使用RxJava2的版本
compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'

// 支持Gson解析
compile 'com.squareup.retrofit2:converter-gson:2.1.0'


//添加网络权限

步骤2：创建 接收服务器返回数据 的类

public class Translation {
    private int status;

    private content content;
    private static class content {
        private String from;
        private String to;
        private String vendor;
        private String out;
        private int errNo;
    }

    //定义 输出返回数据 的方法
    public void show() {
        System.out.println( "Rxjava翻译结果：" + status);
        System.out.println("Rxjava翻译结果：" + content.from);
        System.out.println("Rxjava翻译结果：" + content.to);
        System.out.println("Rxjava翻译结果：" + content.vendor);
        System.out.println("Rxjava翻译结果：" + content.out);
        System.out.println("Rxjava翻译结果：" + content.errNo);
    }
}

步骤3：创建 用于描述网络请求 的接口（区别于传统形式）
采用 注解 + Observable<...>接口描述 网络请求参数。

public interface GetRequest_Interface {

    @GET("ajax.php?a=fy&f=auto&t=auto&w=hi%20world")
    Observable getCall();
     // 注解里传入 网络请求 的部分URL地址
    // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里
    // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略
    // 采用Observable<...>接口 
    // getCall()是接受网络请求数据的方法
}

步骤4：创建 Retrofit 实例

Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                .build();

步骤5：创建 网络请求接口 实例

GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

步骤6：对 网络请求 进行封装
采用Observable<...>形式 。

Observable observable = request.getCall();

步骤7：发送网络请求
步骤8：对返回的数据进行处理

// 步骤7：发送网络请求
observable.subscribeOn(Schedulers.io())               // 在IO线程进行网络请求
          .observeOn(AndroidSchedulers.mainThread())  // 回到主线程处理请求结果
          .subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Translation result) {
                // 步骤8：对返回的数据进行处理
                result.show() ;
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "请求失败");
            }

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

2.无条件网络请求轮询

public class RxJavafixRxjava extends AppCompatActivity {

    private static final String TAG = "Rxjava";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /*
         * 步骤1：采用interval（）延迟发送
         * 注：此处主要展示无限次轮询，若要实现有限次轮询，仅需将interval（）改成intervalRange（）即可
         **/
        Observable.interval(2,1, TimeUnit.SECONDS)
                // 参数说明：
                // 参数1 = 第1次延迟时间；
                // 参数2 = 间隔时间数字；
                // 参数3 = 时间单位；
                // 该例子发送的事件特点：延迟2s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个）

                 /*
                  * 步骤2：每次发送数字前发送1次网络请求（doOnNext（）在执行Next事件前调用）
                  * 即每隔1秒产生1个数字前，就发送1次网络请求，从而实现轮询需求
                  **/
                 .doOnNext(new Consumer() {
            @Override
            public void accept(Long integer) throws Exception {
                Log.d(TAG, "第 " + integer + " 次轮询" );

                 /*
                  * 步骤3：通过Retrofit发送网络请求
                  **/
                  // a. 创建Retrofit对象
                Retrofit retrofit = new Retrofit.Builder()
                        .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                        .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                        .build();

                  // b. 创建 网络请求接口 的实例
                GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

                  // c. 采用Observable<...>形式 对 网络请求 进行封装
                  Observable observable = request.getCall();
                  // d. 通过线程切换发送网络请求
                  observable.subscribeOn(Schedulers.io())               // 切换到IO线程进行网络请求
                        .observeOn(AndroidSchedulers.mainThread())  // 切换回到主线程 处理请求结果
                        .subscribe(new Observer() {
                            @Override
                            public void onSubscribe(Disposable d) {
                            }

                            @Override
                            public void onNext(Translation result) {
                                // e.接收服务器返回的数据
                                result.show() ;
                            }

                            @Override
                            public void onError(Throwable e) {
                                Log.d(TAG, "请求失败");
                            }

                            @Override
                            public void onComplete() {

                            }
                        });

            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }
            @Override
            public void onNext(Long value) {

            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });


    }
}

3.有条件网络请求轮询

public class RxJavafixRetrofit extends AppCompatActivity {

    private static final String TAG = "Rxjava";

    // 设置变量 = 模拟轮询服务器次数
    private int i = 0 ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // 步骤1：创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                .build();

        // 步骤2：创建 网络请求接口 的实例
        GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

        // 步骤3：采用Observable<...>形式 对 网络请求 进行封装
        Observable observable = request.getCall();

        // 步骤4：发送网络请求 & 通过repeatWhen（）进行轮询
        observable.repeatWhen(new Function, ObservableSource>() {
            @Override
            // 在Function函数中，必须对输入的 Observable进行处理，此处使用flatMap操作符接收上游的数据
            public ObservableSource apply(@NonNull Observable objectObservable) throws Exception {
                // 将原始 Observable 停止发送事件的标识（Complete（） /  Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable）
                // 以此决定是否重新订阅 & 发送原来的 Observable，即轮询
                // 此处有2种情况：
                // 1. 若返回1个Complete（） /  Error（）事件，则不重新订阅 & 发送原来的 Observable，即轮询结束
                // 2. 若返回其余事件，则重新订阅 & 发送原来的 Observable，即继续轮询
                return objectObservable.flatMap(new Function>() {
                    @Override
                    public ObservableSource apply(@NonNull Object throwable) throws Exception {

                        // 加入判断条件：当轮询次数 = 5次后，就停止轮询
                        if (i > 3) {
                            // 此处选择发送onError事件以结束轮询，因为可触发下游观察者的onError（）方法回调
                            return Observable.error(new Throwable("轮询结束"));
                        }
                        // 若轮询次数＜4次，则发送1Next事件以继续轮询
                        // 注：此处加入了delay操作符，作用 = 延迟一段时间发送（此处设置 = 2s），以实现轮询间间隔设置
                        return Observable.just(1).delay(2000, TimeUnit.MILLISECONDS);
                    }
                });

            }
        }).subscribeOn(Schedulers.io())               // 切换到IO线程进行网络请求
                .observeOn(AndroidSchedulers.mainThread())  // 切换回到主线程 处理请求结果
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(Translation result) {
                        // e.接收服务器返回的数据
                        result.show() ;
                        i++;
                    }

                    @Override
                    public void onError(Throwable e) {
                        // 获取轮询结束信息
                        Log.d(TAG,  e.toString());
                    }

                    @Override
                    public void onComplete() {

                    }
                });

    }
}
 
 
4.网络请求嵌套回调
 
 
未用操作符，代码如下：
 
 
// 发送注册网络请求的函数方法
private void register() {
    api.register(new RegisterRequest())
            .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
            .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求结果
            .subscribe(new Consumer() {
                @Override
                public void accept(RegisterResponse registerResponse) throws Exception {
                    Toast.makeText(MainActivity.this, "注册成功", Toast.LENGTH_SHORT).show();
                    login();   //注册成功, 调用登录的方法
                }
            }, new Consumer() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    Toast.makeText(MainActivity.this, "注册失败", Toast.LENGTH_SHORT).show();
                }
            });
}


// 发送登录网络请求的函数方法
private void login() {
    api.login(new LoginRequest())
            .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
            .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求结果
            .subscribe(new Consumer() {
                @Override
                public void accept(LoginResponse loginResponse) throws Exception {
                    Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                }
            }, new Consumer() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
                }
            });
} 

 
 
使用flatMap操作符，代码如下：
 
 
public class MainActivity extends AppCompatActivity {

        private static final String TAG = "Rxjava";

        // 定义Observable接口类型的网络请求对象
        Observable observable1;
        Observable observable2;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            // 步骤1：创建Retrofit对象
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                    .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                    .build();

            // 步骤2：创建 网络请求接口 的实例
            GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

            // 步骤3：采用Observable<...>形式 对 2个网络请求 进行封装
            observable1 = request.getCall();
            observable2 = request.getCall_2();


            observable1.subscribeOn(Schedulers.io())               // （初始被观察者）切换到IO线程进行网络请求1
                       .observeOn(AndroidSchedulers.mainThread())  // （新观察者）切换到主线程 处理网络请求1的结果
                       .doOnNext(new Consumer() {
                        @Override
                        public void accept(Translation1 result) throws Exception {
                            Log.d(TAG, "第1次网络请求成功");
                            result.show();
                            // 对第1次网络请求返回的结果进行操作 = 显示翻译结果
                        }
                    })

                    .observeOn(Schedulers.io())                 // （新被观察者，同时也是新观察者）切换到IO线程去发起登录请求
                                                                // 特别注意：因为flatMap是对初始被观察者作变换，所以对于旧被观察者，它是新观察者，所以通过observeOn切换线程
                                                                // 但对于初始观察者，它则是新的被观察者
                    .flatMap(new Function>() { // 作变换，即作嵌套网络请求
                        @Override
                        public ObservableSource apply(Translation1 result) throws Exception {
                            // 将网络请求1转换成网络请求2，即发送网络请求2
                            return observable2;
                        }
                    })

                    .observeOn(AndroidSchedulers.mainThread())  // （初始观察者）切换到主线程 处理网络请求2的结果
                    .subscribe(new Consumer() {
                        @Override
                        public void accept(Translation2 result) throws Exception {
                            Log.d(TAG, "第2次网络请求成功");
                            result.show();
                            // 对第2次网络请求返回的结果进行操作 = 显示翻译结果
                        }
                    }, new Consumer() {
                        @Override
                        public void accept(Throwable throwable) throws Exception {
                            System.out.println("登录失败");
                        }
                    });
    }
}

 
 
5.合并数据源 & 同时展示
 
 
使用merge操作符：
 
 
// 用于存放最终展示的数据
String result = "数据源来自 = " ;

/*
 * 设置第1个Observable：通过网络获取数据
 * 此处仅作网络请求的模拟
 **/
Observable network = Observable.just("网络");

/*
 * 设置第2个Observable：通过本地文件获取数据
 * 此处仅作本地文件请求的模拟
 **/
Observable file = Observable.just("本地文件");

/*
 * 通过merge（）合并事件 & 同时发送事件
 **/
Observable.merge(network, file)
        .subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String value) {
                Log.d(TAG, "数据源有： "+ value  );
                result += value + "+";
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            // 接收合并事件后，统一展示
            @Override
            public void onComplete() {
                Log.d(TAG, "获取数据完成");
                Log.d(TAG,  result  );
            }
        });

 
 
使用zip操作符：
 
 
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Rxjava";

    // 定义Observable接口类型的网络请求对象
    Observable observable1;
    Observable observable2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 步骤1：创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                .build();

        // 步骤2：创建 网络请求接口 的实例
        GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

        // 步骤3：采用Observable<...>形式 对 2个网络请求 进行封装
        observable1 = request.getCall().subscribeOn(Schedulers.io()); // 新开线程进行网络请求1
        observable2 = request.getCall_2().subscribeOn(Schedulers.io());// 新开线程进行网络请求2
        // 即2个网络请求异步 & 同时发送

        // 步骤4：通过使用zip（）对两个网络请求进行合并再发送
        Observable.zip(observable1, observable2,
                new BiFunction() {
                    // 注：创建BiFunction对象传入的第3个参数 = 合并后数据的数据类型
                    @Override
                    public String apply(Translation1 translation1,
                                        Translation2 translation2) throws Exception {
                        return translation1.show() + " & " +translation2.show();
                    }
                }).observeOn(AndroidSchedulers.mainThread()) // 在主线程接收 & 处理数据
                .subscribe(new Consumer() {
                    // 成功返回数据时调用
                    @Override
                    public void accept(String combine_infro) throws Exception {
                        // 结合显示2个网络请求的数据结果
                        Log.d(TAG, "最终接收到的数据是：" + combine_infro);
                    }
                }, new Consumer() {
                    // 网络请求错误时调用
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        System.out.println("登录失败");
                    }
                });
    }
}

 
 
6.从磁盘 / 内存缓存中获取缓存数据
 
 
// 该2变量用于模拟内存缓存 & 磁盘缓存中的数据
String memoryCache = null;
String diskCache = "从磁盘缓存中获取数据";

/*
 * 设置第1个Observable：检查内存缓存是否有该数据的缓存
 **/
Observable memory = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {

        // 先判断内存缓存有无数据
        if (memoryCache != null) {
            // 若有该数据，则发送
            emitter.onNext(memoryCache);
        } else {
            // 若无该数据，则直接发送结束事件
            emitter.onComplete();
        }

    }
});

/*
 * 设置第2个Observable：检查磁盘缓存是否有该数据的缓存
 **/
Observable disk = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {

        // 先判断磁盘缓存有无数据
        if (diskCache != null) {
            // 若有该数据，则发送
            emitter.onNext(diskCache);
        } else {
            // 若无该数据，则直接发送结束事件
            emitter.onComplete();
        }

    }
});

/*
 * 设置第3个Observable：通过网络获取数据
 **/
Observable network = Observable.just("从网络中获取数据");
// 此处仅作网络请求的模拟

/*
 * 通过concat（） 和 firstElement（）操作符实现缓存功能
 **/

// 1. 通过concat（）合并memory、disk、network 3个被观察者的事件（即检查内存缓存、磁盘缓存 & 发送网络请求）
//    并将它们按顺序串联成队列
Observable.concat(memory, disk, network)
        // 2. 通过firstElement()，从串联队列中取出并发送第1个有效事件（Next事件），即依次判断检查memory、disk、network
        .firstElement()
        // 即本例的逻辑为：
        // a. firstElement()取出第1个事件 = memory，即先判断内存缓存中有无数据缓存；由于memoryCache = null，即内存缓存中无数据，所以发送结束事件（视为无效事件）
        // b. firstElement()继续取出第2个事件 = disk，即判断磁盘缓存中有无数据缓存：由于diskCache ≠ null，即磁盘缓存中有数据，所以发送Next事件（有效事件）
        // c. 即firstElement()已发出第1个有效事件（disk事件），所以停止判断。
        
        // 3. 观察者订阅
        .subscribe(new Consumer() {
            @Override
            public void accept( String s) throws Exception {
                Log.d(TAG,"最终获取的数据来源 =  "+ s);
            }
        });

 
 
7.联合判断多个事件
 
 
/*
 * 步骤1：设置控件变量 & 绑定
 **/
EditText name,age,job;
Button list;

name = (EditText) findViewById(R.id.name);
age = (EditText) findViewById(R.id.age);
job = (EditText) findViewById(R.id.job);
list = (Button) findViewById(R.id.list);

/*
 * 步骤2：为每个EditText设置被观察者，用于发送监听事件
 * 说明：
 * 1. 此处采用了RxBinding：RxTextView.textChanges(name) = 对对控件数据变更进行监听（功能类似TextWatcher），需要引入依赖：compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
 * 2. 传入EditText控件，点击任1个EditText撰写时，都会发送数据事件 = Function3（）的返回值（下面会详细说明）
 * 3. 采用skip(1)原因：跳过 一开始EditText无任何输入时的空值
 **/
Observable nameObservable = RxTextView.textChanges(name).skip(1);
Observable ageObservable = RxTextView.textChanges(age).skip(1);
Observable jobObservable = RxTextView.textChanges(job).skip(1);

/*
 * 步骤3：通过combineLatest（）合并事件 & 联合判断
 **/
Observable.combineLatest(nameObservable,ageObservable,jobObservable,new Function3() {
    @Override
    public Boolean apply(@NonNull CharSequence charSequence, @NonNull CharSequence charSequence2, @NonNull CharSequence charSequence3) throws Exception {

        /*
         * 步骤4：规定表单信息输入不能为空
         **/
        // 1. 姓名信息
        boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) ;
        // 除了设置为空，也可设置长度限制
        // boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) && (name.getText().toString().length() > 2 && name.getText().toString().length() < 9);

        // 2. 年龄信息
        boolean isUserAgeValid = !TextUtils.isEmpty(age.getText());
        // 3. 职业信息
        boolean isUserJobValid = !TextUtils.isEmpty(job.getText()) ;

        /*
         * 步骤5：返回信息 = 联合判断，即3个信息同时已填写，"提交按钮"才可点击
         **/
        return isUserNameValid && isUserAgeValid && isUserJobValid;
    }

        }).subscribe(new Consumer() {
    @Override
    public void accept(Boolean s) throws Exception {
        /*
         * 步骤6：返回结果 & 设置按钮可点击样式
         **/
        Log.e(TAG, "提交按钮是否可点击： "+s);
        list.setEnabled(s);
    }
});

 
 
8.线程控制（切换 / 调度）
 
 
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Rxjava";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //步骤4：创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                .build();

        // 步骤5：创建 网络请求接口 的实例
        GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

        // 步骤6：采用Observable<...>形式 对 网络请求 进行封装
        Observable observable = request.getCall();

        // 步骤7：发送网络请求
        observable.subscribeOn(Schedulers.io())               // 在IO线程进行网络请求
                  .observeOn(AndroidSchedulers.mainThread())  // 回到主线程 处理请求结果
                  .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Translation result) {
                        // 步骤8：对返回的数据进行处理
                        result.show() ;
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "请求失败");
                    }

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

 
 
9.网络请求出错重连
 
 
public class RxJavafixRetrofit2 extends AppCompatActivity {

    private static final String TAG = "RxJava";

    // 设置变量
    // 可重试次数
    private int maxConnectCount = 10;
    // 当前已重试次数
    private int currentRetryCount = 0;
    // 重试等待时间
    private int waitRetryTime = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 步骤1：创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
                .addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
                .build();

        // 步骤2：创建 网络请求接口 的实例
        GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);

        // 步骤3：采用Observable<...>形式 对 网络请求 进行封装
        Observable observable = request.getCall();

        // 步骤4：发送网络请求 & 通过retryWhen（）进行重试
        // 注：主要异常才会回调retryWhen（）进行重试
        observable.retryWhen(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(@NonNull Observable throwableObservable) throws Exception {
                // 参数Observable中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
                return throwableObservable.flatMap(new Function>() {
                    @Override
                    public ObservableSource apply(@NonNull Throwable throwable) throws Exception {

                        // 输出异常信息
                        Log.d(TAG,  "发生异常 = "+ throwable.toString());

                        /**
                         * 需求1：根据异常类型选择是否重试
                         * 即，当发生的异常 = 网络异常 = IO异常 才选择重试
                         */
                        if (throwable instanceof IOException){

                            Log.d(TAG,  "属于IO异常，需重试" );

                            /**
                             * 需求2：限制重试次数
                             * 即，当已重试次数 < 设置的重试次数，才选择重试
                             */
                            if (currentRetryCount < maxConnectCount){

                                // 记录重试次数
                                currentRetryCount++;
                                Log.d(TAG,  "重试次数 = " + currentRetryCount);

                                /**
                                 * 需求2：实现重试
                                 * 通过返回的Observable发送的事件 = Next事件，从而使得retryWhen（）重订阅，最终实现重试功能
                                 *
                                 * 需求3：延迟1段时间再重试
                                 * 采用delay操作符 = 延迟一段时间发送，以实现重试间隔设置
                                 *
                                 * 需求4：遇到的异常越多，时间越长
                                 * 在delay操作符的等待时间内设置 = 每重试1次，增多延迟重试时间1s
                                 */
                                // 设置等待时间
                                waitRetryTime = 1000 + currentRetryCount* 1000;
                                Log.d(TAG,  "等待时间 =" + waitRetryTime);
                                return Observable.just(1).delay(waitRetryTime, TimeUnit.MILLISECONDS);


                            }else{
                                // 若重试次数已 > 设置重试次数，则不重试
                                // 通过发送error来停止重试（可在观察者的onError（）中获取信息）
                                return Observable.error(new Throwable("重试次数已超过设置次数 = " +currentRetryCount  + "，即 不再重试"));

                            }
                        }

                        // 若发生的异常不属于I/O异常，则不重试
                        // 通过返回的Observable发送的事件 = Error事件 实现（可在观察者的onError（）中获取信息）
                        else{
                            return Observable.error(new Throwable("发生了非网络异常（非I/O异常）"));
                        }
                    }
                });
            }
        }).subscribeOn(Schedulers.io())               // 切换到IO线程进行网络请求
                .observeOn(AndroidSchedulers.mainThread())  // 切换回到主线程 处理请求结果
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(Translation result) {
                        // 接收服务器返回的数据
                        Log.d(TAG,  "发送成功");
                        result.show();
                    }

                    @Override
                    public void onError(Throwable e) {
                        // 获取停止重试的信息
                        Log.d(TAG,  e.toString());
                    }

                    @Override
                    public void onComplete() {

                    }
                });

    }
} 

 
 
三、例子
 
 
//build.gradle
implementation 'com.squareup.retrofit2:retrofit:2.0.2'
implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
implementation 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
implementation 'io.reactivex.rxjava2:rxjava:2.0.1'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

//AndroidManifest.xml


//Gist
public class Gist {
    Map files;

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[Gist]: ");
        if(files != null && files.size() > 0) {
            for(Map.Entry entry : files.entrySet()) {
                stringBuilder.append(entry.getKey())
                        .append(":")
                        .append(entry.getValue())
                        .append(" ");
            }
        } else {
            stringBuilder.append("null");
        }
        return stringBuilder.toString();
    }

    private static class GistFile {
        String content;

        @Override
        public String toString() {
            return content;
        }
    }
}

//HttpService
public interface HttpService {

    @GET("gists/c2a7c39532239ff261be")
    Observable getInfo();
}

//MainActivity
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "Retrofit";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "zwm, onCreate");
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://api.github.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
        HttpService httpService = retrofit.create(HttpService.class);
        Observable observable = httpService.getInfo();
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "zwm, onSubscribe, thread: " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onNext(Gist value) {
                        Log.d(TAG, "zwm, onNext, thread: " + Thread.currentThread().getName());
                        Log.d(TAG, "zwm, onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "zwm, onError, thread: " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "zwm, onComplete, thread: " + Thread.currentThread().getName());
                    }
                });
    }
}

//输出log
2019-12-31 10:20:38.748 7719-7719/com.example.sourcecodetest D/Retrofit: zwm, onCreate
2019-12-31 10:20:38.963 7719-7719/com.example.sourcecodetest D/Retrofit: zwm, onSubscribe, thread: main
2019-12-31 10:20:41.654 7719-7719/com.example.sourcecodetest D/Retrofit: zwm, onNext, thread: main
2019-12-31 10:20:41.656 7719-7719/com.example.sourcecodetest D/Retrofit: zwm, onNext: [Gist]: OkHttp.txt:
                             \\           //
                              \\  .ooo.  //
                               .@@@@@@@@@.
                             :@@@@@@@@@@@@@:
                            :@@. '@@@@@' .@@:
                            @@@@@@@@@@@@@@@@@
                            @@@@@@@@@@@@@@@@@
    
                       :@@ :@@@@@@@@@@@@@@@@@. @@:
                       @@@ '@@@@@@@@@@@@@@@@@, @@@
                       @@@ '@@@@@@@@@@@@@@@@@, @@@
                       @@@ '@@@@@@@@@@@@@@@@@, @@@
                       @@@ '@@@@@@@@@@@@@@@@@, @@@
                       @@@ '@@@@@@@@@@@@@@@@@, @@@
                       @@@ '@@@@@@@@@@@@@@@@@, @@@
                            @@@@@@@@@@@@@@@@@
                            '@@@@@@@@@@@@@@@'
                               @@@@   @@@@
                               @@@@   @@@@
                               @@@@   @@@@
                               '@@'   '@@'
    
         :@@@.
       .@@@@@@@:   +@@       `@@      @@`   @@     @@
      .@@@@'@@@@:  +@@       `@@      @@`   @@     @@
      @@@     @@@  +@@       `@@      @@`   @@     @@
     .@@       @@: +@@   @@@ `@@      @@` @@@@@@ @@@@@@  @@;@@@@@
     @@@       @@@ +@@  @@@  `@@      @@` @@@@@@ @@@@@@  @@@@@@@@@
     @@@       @@@ +@@ @@@   `@@@@@@@@@@`   @@     @@    @@@   :@@
     @@@       @@@ +@@@@@    `@@@@@@@@@@`   @@     @@    @@#    @@+
     @@@       @@@ +@@@@@+   `@@      @@`   @@     @@    @@:    @@#
      @@:     .@@` +@@@+@@   `@@      @@`   @@     @@    @@#    @@+
      @@@.   .@@@  +@@  @@@  `@@      @@`   @@     @@    @@@   ,@@
       @@@@@@@@@   +@@   @@@ `@@      @@`   @@@@   @@@@  @@@@#@@@@
        @@@@@@@    +@@   #@@ `@@      @@`   @@@@:  @@@@: @@'@@@@@
                                                         @@:
                                                         @@:
                                                         @@: 
2019-12-31 10:20:41.656 7719-7719/com.example.sourcecodetest D/Retrofit: zwm, onComplete, thread: main

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(网络编程 -- Retrofit + RxJava)

        

            

                
    
                    
  • 如何用Java轻松解析DNS报文
                        字节王德发
java技术javapython开发语言
                        
    在网络编程中，DNS（域名系统）是一个至关重要的部分。它负责将人类易于记忆的域名转换为计算机可以识别的IP地址。了解如何解析DNS报文，对于网络开发和调试都很有帮助。今天，我们就来聊聊如何利用Java来解析DNS报文，帮助你轻松理解这一过程。DNS报文的基本结构在开始之前，先简单介绍一下DNS报文的结构。DNS报文分为请求和响应两种类型，通常包含以下几个部分：头部（Header）：包含一些基本信息
    
                    
    • 
                    
  • 仙境传说(RO)私人服务器端源代码实战指南
                        你这人真狗

                        
    本文还有配套的精品资源，点击获取简介：《仙境传说(RO)》是一款韩国MMORPG游戏，其私人服务器端源代码让游戏爱好者能自定义游戏环境。源代码使用DELPHI语言编写，涵盖游戏核心功能如玩家移动、战斗和交易等，并支持定制化游戏体验。该代码包含网络通信机制，允许高效的数据交换和游戏状态更新。DELPHI开发者可利用第三方网络库实现服务器与客户端间的通信。该源代码下载需要一定的编程基础和网络编程知识，
    
                    
    • 
                    
  • 构造下载请求详解
                        web安全工具库
python
                        
    各类资料学习下载合集https://pan.quark.cn/s/8c91ccb5a474在现代网络编程中，下载请求的构造是一个重要的主题，尤其是在实现文件传输协议（如HTTP,FTP,TFTP等）时。在本篇博客中，我们将重点讨论如何在TFTP（TrivialFileTransferProtocol）中构造一个下载请求（ReadRequest，RRQ），并展示详细的代码实现和运行结果。1.TFTP
    
                    
    • 
                    
  • Centos离线安装perl
                        为什么要做囚徒
linux运维linuxcentosperllinux运维
                        
    文章目录Centos离线安装perl1.perl是什么？2.Perl下载地址3.perl的安装4.安装结果验证Centos离线安装perl1.perl是什么？Perl是一种高级脚本语言，诞生于1987年，以强大的文本处理能力和灵活性著称，常用于系统管理、Web开发、网络编程等领域2.Perl下载地址perl整体打包下载地址CentOS-7所有rpm包的仓库地址：perl-5.16.3-297.el
    
                    
    • 
                    
  • Linux----网络tcp编程
                        weixin_51790712
linux网络tcp/ip
                        
    网络编程编程linux操作系统[用户空间]应用层//程序员实现------------------------------------------------------[内核空间]传输层[网络协议栈]//内核已经实现好的属于网络功能网络层数据链路层物理层程序发送数据系统调用---通过系统调用来使用操作系统提供的网络功能函数接口---socketsocket:1.操作系统提供的函数接口//通过这个
    
                    
    • 
                    
  • 嵌入式Linux网络编程实战：基于DNS解析的HTTP客户端实现
                        银河码
Linux网络编程网络linuxhttpc语言windowsvscodejson
                        
    嵌入式Linux网络编程实战：基于DNS解析的HTTP客户端实现【本文代码已在树莓派4B（Linux内核5.10）平台验证通过，适用于物联网设备数据上报等场景】一、需求场景与功能亮点1.1典型物联网通信场景嵌入式设备DNS服务器云服务器域名解析请求返回目标IP发送传感器数据返回HTTP响应嵌入式设备DNS服务器云服务器1.2代码核心功能DNS智能解析：支持域名自动转换为IPv4地址协议合规性：严格
    
                    
    • 
                    
  • Android开源库——RxJava和RxAndroid
                        松仔log
#Android开源库android开源rxjava
                        
    RxJava和RxAndroid是什么？RxJava是基于JVM的响应式扩展，用于编写异步代码RxAndroid是关于Android的RxJava绑定RxJava和RxAndroid使用依赖implementation'io.reactivex.rxjava3:rxjava:3.1.0'implementation'io.reactivex.rxjava3:rxandroid:3.0.2'使用过程
    
                    
    • 
                    
  • python socket库详解
                        mosquito_lover1
pythonwebsocket
                        
    socket是Python标准库中的一个模块，提供了对底层网络通信的接口，允许开发者进行网络编程。通过socket你可以创建客户端和服务器应用程序，实现网络通信。1.基本概念-Socket：是网络通信的端点，用于在不同主机之间或同一主机上的不同进程之间进行数据传输。-IP地址：标识网络中的设备。-端口号：标识设备上的特定进程或服务。-协议：常用的协议有TCP（传输控制协议）和UDP（用户数据报协议
    
                    
    • 
                    
  • 【Java网络编程】OSI七层网络模型与TCP/IP协议簇
                        xiaoli8748_软件开发
网络通信网络tcp/ip网络协议
                        
    1.1、OSI七层网络模型OSI七层网络模型中，每层的功能如下：应用层：人与计算机网络交互的窗口。表示层：负责数据格式的封装，如加密、压缩、编解码等。会话层：建立、终止、管理不同端间的会话连接。传输层：提供端到端（两台机器）之间的传输机制，以及提供流量控制、出错效验。网络层：逻辑寻址，IP地址，在下两层的基础上向资源子网提供服务。数据链路层：负责建立和管理节点间的链路，将数据封装成帧，进行可靠传输
    
                    
    • 
                    
  • kotlin与MVVM结合使用总结（一）
                        每次的天空
kotlin开发语言android
                        
    一、Kotlin与MVVM结合的核心优势代码简洁性数据类（dataclass）简化Model层定义，自动生成equals/hashCode/toString扩展函数简化View层逻辑（如点击事件扩展）lateinit/bylazy优化ViewModel属性初始化异步处理优化协程（Coroutines）替代RxJava，轻量且代码可读性强withContext(Dispatchers.IO)切换线程
    
                    
    • 
                    
  • Java与Python详细比对 -- Java与Python优缺点
                        知之为
python开发语言java
                        
    系列文章-Java与PythonPython和Java都是比较流行的编程语言，它们各自有着独特的特性和应用场景。python用途最多的是脚本，java用途最多的是web。文章目录系列文章目录-Java与Python前言一、Java与Python整体区别二、Java与Python详细区别2.1语法结构方面2.2编程特性方面2.3语言执行及内存管理方面2.4多线程及网络编程方面2.5开发工具及相关功能
    
                    
    • 
                    
  • 理解 Retrofit 请求头与 GsonConverterFactory 的自动处理机制
                        居然是阿宋
retrofit
                        
    在现代Web开发中，特别是在与RESTfulAPI进行交互时，我们经常会遇到JSON格式的数据交换。为了确保请求的正确解析和响应的准确返回，通常需要通过HTTP请求头明确指定请求体的数据类型。而Content-Type:application/json就是用来告诉服务器，当前请求体中的数据格式是JSON。为什么需要明确指定Content-Type:application/json？数据格式的明确性
    
                    
    • 
                    
  • Java网络编程：TCP的socket编程
                        想作会飞的鱼
Java网络编程网络编程socketjavatcp
                        
    一、Java中的网络编程协议相当于相互通信的程序间达成的一种约定，它规定了分组报文的结构、交换方式、包含的意义以及怎样对报文所包含的信息进行解析，TCP/IP协议族有IP协议、TCP协议和UDP协议。现在TCP/IP协议族中的主要socket类型为流套接字（使用TCP协议）和数据报套接字（使用UDP协议）。TCP协议提供面向连接的服务，通过它建立的是可靠地连接。Java为TCP协议提供了两个类：S
    
                    
    • 
                    
  • 【python】网络编程socket TCP UDP
                        草莓泰面包
python网络pythontcp/ip
                        
    文章目录socket常用方法TCP客户端服务器UDP客户端服务器网络编程就是实现两台计算机的通信互联网协议族即通用标准协议，任何私有网络只要支持这个协议，就可以接入互联网。socketsocke模块的socket()函数importsocketsock=socket.socket(AddressFamily,type)参数说明：AddressFamily：指定套接字家族（AddressFamily
    
                    
    • 
                    
  • 序列化和反序列化
                        南林yan
Linux学习网络
                        
    目录一、什么是序列化和反序列化？二、利用Jsoncpp实现序列化和反序列化1.序列化(1)使用Json::Value的toStyledString方法(2)使用Json::StreamWriterf方法(3)使用Json::FastWriterff方法2.反序列化(1)使用Json::Reader方法三、数据封装（消息定界）——解决TCP通信粘包问题一、什么是序列化和反序列化？我们之前进行网络编程
    
                    
    • 
                    
  • 2024年最新【Rust指南】快速入门 开发环境 hello world_rust开发是啥(3)
                        2301_79772893
程序员rust开发语言后端
                        
    2、与其他编程语言相比较C/C++性能很好，但是系统类型和内存都不太安全。Java/C#，拥有GC机制，能保证内存安全，特性也优秀，但是性能不行Rust：安全无需GC代码安全高效，易于维护、调试3、Rust特别擅长的领域高性能WebServiceWebAssembly命令行工具网络编程嵌入式设备系统编程4、Rust的用户和案例Google：新操作系统Fuschia，其中Rust代码量约占30%Am
    
                    
    • 
                    
  • SpringBoot整合Netty
                        晚上睡不着！
#SpringBootspringbootniowebsockettcp/iphttp
                        
    前言Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高并发协议服务器和客户端。Netty主要基于JavaNIO实现，提供了异步和事件驱动的网络编程工具，简化了TCP和UDP服务器的编程。Netty广泛应用于分布式系统、实时通信、游戏开发等领域，例如，知名的Elasticsearch和Dubbo框架内部都采用了Netty。Netty吸收了多种协议的实现经验，经过精心设计，
    
                    
    • 
                    
  • Android Retrofit + RxJava + OkHttp 网络请求高效封装方案
                        tangweiguo03051987
retrofitrxjavaokhttp
                        
    Retrofit+RxJava+OkHttp是Android开发中常用的网络请求库组合。Retrofit是一个类型安全的HTTP客户端，RxJava是一个响应式编程库，OkHttp是一个高效的HTTP客户端。Retrofit+RxJava+OkHttp的组合可以提供以下功能：职责清晰RetrofitClient负责Retrofit和OkHttp的初始化。ApiServiceHelper负责动态创建
    
                    
    • 
                    
  • Python 网络编程实战：5分钟实现多线程下载工具与 Web 服务器
                        吴师兄大模型
pythonWeb服务器多线程下载工具网络编程人工智能开发语言PYTHON
                        
    Langchain系列文章目录01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南02-玩转LangChainMemory模块：四种记忆类型详解及应用场景全覆盖03-全面掌握LangChain：从核心链条构建到动态任务分配的实战指南04-玩转LangChain：从文档加载到高效问答系统构建的全程实战05-玩转LangChain：深度评估问答系统的三种高效方法（示例生成、手
    
                    
    • 
                    
  • 网络编程--协议、协议族、地址族
                        SNAKEpc12138
C++#网络编程网络网络协议
                        
    写在前面这里先介绍下socket函数（Windows版本）的函数声明，后续内容均围绕该声明展开：#include//af:指定该套接字的协议族//type:指定该套接字的数据传输方式//protocol:指定该套接字的最终协议//返回值：失败返回INVALID_SOCKET，否则为成功SOCKETsocket(intaf,inttype,intprotocol);协议和协议族协议：协议就是为了完成
    
                    
    • 
                    
  • Android Retrofit 框架适配器模块深入源码分析(五)
                        &有梦想的咸鱼&
AndroidRetrofit原理androidretrofit
                        
    AndroidRetrofit框架适配器模块深入源码分析一、引言在Android开发中，网络请求是一个常见且重要的功能。Retrofit作为一个强大的网络请求框架，以其简洁的API和高度的可定制性受到了广泛的欢迎。适配器模块（CallAdapter）是Retrofit框架中非常重要的一部分，它负责将Call对象转换为其他类型，如Observable、Completable、Single等，从而实现
    
                    
    • 
                    
  • Java【网络原理】（2）初识网络续与网络编程
                        爱吃烤鸡翅的酸菜鱼
网络javajava-ee后端
                        
    目录1.前言2.正文2.1TCP协议与UDP协议2.2socketAPI进行网络编程2.2.1DatagramPacket类2.2.1.1发送数据报2.2.1.2接收数据报2.2.1.3获取数据报内容2.2.1.4设置数据报内容2.2.2DatagramSocket类2.2.2.1构造方法2.2.2.2常用方法2.2.3具体代码与解释3.小结1.前言哈喽大家好吖，今天继续给大家分享计算机网络相关的
    
                    
    • 
                    
  • 打造AI流式处理利器：用SSE和RxJava搞定实时数据流
                        程序媛雪儿
人工智能rxjava前端
                        
    大家好，我是程序媛雪儿。现在AI已经在各大软件中广泛应用，你们有没有想过如何在AI应用中实时处理数据流？今天咱们聊聊怎么用SSE+Rxjava处理实时数据流。一、SSE是什么SSE（后端主动推送给前端）前端发请求并和后端建立连接，后端实时推动数据给前端SSE的重要特点单向通信：SSE只支持服务器向客户端的单向通信文本格式：SSE使用纯文本格式传输数据，HTTP响应的text/event-strea
    
                    
    • 
                    
  • 网络编程基础知识总结
                        老梁学Android&HarmonyOS
网络编程网络
                        
    1、网络编程的基础知识总结网络编程说的是在不同计算机之间进行数据传输和通信。本文主要是一些基础知识的总结：本文的“计算机”包含电脑、手机、平板、手表、汽车等可以联网的设备。1.1网络协议1.1.1描述：网络协议是计算机网络中通信双方共同遵守的规则和约定，就是马路上的红绿灯约定红灯停绿灯行一样，专门用于指导数据的传输和处理。1.1.2协议层次：协议通常有两种说法，分别是OSI七层模型或TCP/IP四
    
                    
    • 
                    
  • 从零手撸工业级Qt文件传输系统：TCP粘包/断点续传/SSL加密全解
                        十年编程老舅
QT开发qt项目qt项目实战c++项目qt计算机毕设项目qt文件传输qt教程
                        
    很多初学者都会遇到这个坎，如何将Windows数据结构、网络编程等知识整合为完整的项目。本文将深入解析一个基于C++Qt开发的企业级文件传输系统，涵盖TCP通信、断点续传、SSL加密、SQLite持久化等核心技术。（项目源码来文章底部拿）一、系统核心功能1.基础通信能力双工消息传输（支持中文字符）文件传输进度条同步（4KB分块策略）传输完整性验证（安装包可执行性测试）2.高级特性断点续传（记录已传
    
                    
    • 
                    
  • 【新手向】从零开始学习Java（Day29）Java 网络编程
                        星河天欲瞩
从零开始学习Java学习java开发语言jvm网络后端
                        
    每天二十分钟，成就Java大神，点点关注不迷路！今天是第二十九天，给坚持到这里的小伙伴点个赞！对抗混乱即修行，共勉！目录网络编程基础概念Socket（套接字）ServerSocket类（服务器端）构造方法常用方法Socket类构造方法常用方法InetAddress类本地实例服务端客户端运行步骤下节预告网络编程基础概念网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。网络模
    
                    
    • 
                    
  • 有趣的学习Python-第十篇：Python的“魔法宝库”：标准库之旅
                        王盼达
有趣的学习Python学习python开发语言
                        
    Python不仅是一门强大的编程语言，更像是一座充满宝藏的“魔法宝库”，里面装满了各种各样的“魔法工具”（标准库）。这些“魔法工具”可以帮助你轻松地完成各种任务，从文件操作到网络编程，从数据处理到性能优化。接下来，让我们一起探索Python的“魔法宝库”，看看这些“魔法工具”到底有多神奇！10.1操作系统接口：与“魔法世界”互动os模块就像是一个“魔法接口”，可以帮助你与操作系统进行互动。你可以用
    
                    
    • 
                    
  • Android Retrofit 框架注解定义与解析模块深度剖析(一)
                        &有梦想的咸鱼&
AndroidRetrofit原理androidretrofit
                        
    一、引言在现代Android和Java开发中，网络请求是不可或缺的一部分。Retrofit作为Square公司开源的一款强大的类型安全的HTTP客户端，凭借其简洁易用的API和高效的性能，在开发者社区中广受欢迎。Retrofit的核心特性之一便是通过注解来定义HTTP请求，这种方式使得代码更加清晰、易读且易于维护。本文将深入Retrofit框架的源码，对其注解定义与解析模块进行全面且细致的分析，揭
    
                    
    • 
                    
  • Python ipaddress 模块：IP 地址处理的全面指南
                        tekin
Python网络编程pythontcp/ip
                        
    Pythonipaddress模块：IP地址处理的全面指南在网络编程和系统管理中，对IP地址进行操作和管理是一项常见任务。Python的ipaddress模块为开发者提供了强大而便捷的工具，用于创建、操作和验证IPv4和IPv6地址。本教程将结合Python官方文档（https://docs.python.org/zh-cn/3.12/library/ipaddress.html），详细介绍ipa
    
                    
    • 
                    
  • 【网络编程】完成端口 IOCP
                        浅慕Antonio
网络编程网络c++服务器
                        
    10.11完成端口10.11.1基本概念完成端口的全称是I/O完成端口，英文为IOCP(I/OCompletionPort)。IOCP是一个异步I/O的API,可以高效地将I/O事件通知给应用程序。与使用select()或是其他异步方法不同的是，一个套接字与一个完成端口关联了起来，然后就可以继续进行正常的Winsock操作了。然而，当一个事件发生的时候，此完成端口就将被操作系统加入一个队列中。然后
    
                    
    • 
                                
  • web前段跨域nginx代理配置
                                    刘正强
nginxcmsWeb
                                    
    nginx代理配置可参考server部分 
 
server { 
        listen       80; 
        server_name  localhost; 
 

    
                                
    • 
                                
  • spring学习笔记
                                    caoyong
spring
                                    
    一、概述 
    a>、核心技术 : IOC与AOP 
 b>、开发为什么需要面向接口而不是实现 
     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 
 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式) 
    
                                
    • 
                                
  • Eclipse打开workspace提示工作空间不可用
                                    0624chenhong
eclipse
                                    
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 
1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 
解决办法，删掉.fileTableLock文件，重
    
                                
    • 
                                
  • Javascript 面向对面写法的必要性？
                                    一炮送你回车库
JavaScript
                                    
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 
这是javascript层的mvc框架哦,不是j2ee的mvc框架 
  
我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
    
                                
    • 
                                
  • js array对象的迭代方法
                                    换个号韩国红果果
array
                                    
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 
使用该函数  return 语句失效 
 

function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
 
2.every 该方法接受一个返回值为布尔类型
    
                                
    • 
                                
  • 对Hibernate缓存机制的理解
                                    归来朝歌
session一级缓存对象持久化
                                    
    在hibernate中session一级缓存机制中，有这么一种情况： 
问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 
session.save()方法，在提交事务后，会出现这样的情况： 
1：在数据库中有默认属性的字段的值为空 
2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 
通过调试后解决方案如下： 
对于问题一，如你在数据库里设置了
    
                                
    • 
                                
  • WebService调用错误合集
                                    darkranger
webservice
                                    
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton   
调用接口出错， 
一个简单的WebService 
import org.apache.axis.client.Call;import org.apache.axis.client.Service; 
首先必不可
    
                                
    • 
                                
  • JSP和Servlet的中文乱码处理
                                    aijuans
Java Web
                                    
    JSP和Servlet的中文乱码处理 
前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 
一、表单提交时出现乱码： 
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
    
                                
    • 
                                
  • 面试经典六问
                                    atongyeye
工作面试
                                    
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 
 
以下是人事了解应聘者情况的最典型的六个问题： 
 
 
1 简单自我介绍  
 
关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 
 
我的回答：(针对技术面试回答，如果是人事面试，可以就掌
    
                                
    • 
                                
  • contentResolver.query()参数详解
                                    百合不是茶
androidquery()详解
                                    
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 
一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。    
[java]  
view plain 
copy       
 
 public void fetchAllContacts() {   
    
    
                                
    • 
                                
  • ora-00054:resource busy and acquire with nowait specified解决方法
                                    bijian1013
oracle数据库killnowait
                                    
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 
1.下面的语句
    
                                
    • 
                                
  • web 开发乱码
                                    征客丶
springWeb
                                    
    以下前端都是 utf-8 字符集编码 
 
一、后台接收 
1.1、 get 请求乱码 
get 请求中，请求参数在请求头中； 
乱码解决方法： 
a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 
 
1.2、post 请求乱码 
post 请求中，请求参数分两部份， 
1.2.1、url？参数，
    
                                
    • 
                                
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式
                                    bit1129
spark
                                    
    Spark SQL数据源和表的Schema 
 
  case class  
  apply schema  
  parquet  
  json  
 JSON数据源 准备源数据 
{"name":"Jack", "age": 12, "addr":{"city":"beijing&
    
                                
    • 
                                
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss
                                    BlueSkator
-Xss-Xmn-Xms-Xmx
                                    
      
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： 
 
 java -Xmx355
    
                                
    • 
                                
  • jqGrid 各种参数 详解(转帖)
                                    BreakingBad
jqGrid
                                    
      
jqGrid 各种参数 详解   分类： 
源代码分享 
个人随笔请勿参考 
解决开发问题 2012-05-09 20:29   84282人阅读   
评论(22)   
收藏   
举报   
jquery 
服务器 
parameters 
function 
ajax 
string      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 下面
    
                                
    • 
                                
  • 应用升级iOS8中遇到的一些问题
                                    chenhbc
ios8升级iOS8
                                    
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 
-(void)viewWillAppear:(BOOL)animated 
 中写的，最终的解决办法是把判断写在 
-(void
    
                                
    • 
                                
  • 工作流与自组织的关系？
                                    comsci
设计模式工作
                                    
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？ 
 
  这里有篇论文，摘要是：“针对网格中的服务
    
                                
    • 
                                
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX
                                    daizj
oracle
                                    
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 
 
转自：http://space.itpub.net/18922393/viewspace-752123 
 
在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
    
                                
    • 
                                
  • 二叉树:堆
                                    dieslrae
二叉树
                                    
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 
    一个节点的父节点下标为: (当前下标 - 1)/2 
    一个节点的左节点下标为: 当前下标 * 2 + 1 
  &
    
                                
    • 
                                
  • C语言学习八结构体
                                    dcj3sjt126com
c
                                    
    为什么需要结构体，看代码 
# include <stdio.h>

struct Student	//定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量
{
	int age;
	float score;
	char sex;
}

int main(void)
{
	struct Student st = {80, 66.6,
    
                                
    • 
                                
  • centos安装golang
                                    dcj3sjt126com
centos
                                    
    #在国内镜像下载二进制包 
wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz 
tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz 
  
#把golang的bin目录加入全局环境变量 
cat >>/etc/profile<
    
                                
    • 
                                
  • 10.性能优化-监控-MySQL慢查询
                                    frank1234
性能优化MySQL慢查询
                                    
    1.记录慢查询配置 
show variables where variable_name like 'slow%' ; --查看默认日志路径 
查询结果：--不用的机器可能不同 
slow_query_log_file=/var/lib/mysql/centos-slow.log 
 
修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
    
                                
    • 
                                
  • Java父类取得子类类名
                                    happyqing
javathis父类子类类名
                                    
      
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ 
  
package com.urthinker.module.test;

import org.junit.Test;

abstract class BaseDao<T> {
	public void 
    
                                
    • 
                                
  • Spring3.2新注解@ControllerAdvice
                                    jinnianshilongnian
@Controller
                                    
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： 
  
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Co
    
                                
    • 
                                
  • Java spring mvc多数据源配置
                                    liuxihope
spring
                                    
    转自：http://www.itpub.net/thread-1906608-1-1.html 
 
 
1、首先配置两个数据库 
 
<bean id="dataSourceA"         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
    
                                
    • 
                                
  • 第12章 Ajax（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BW / Universe Mappings
                                    blueoxygen
BO
                                    
          
BW Element    
OLAP Universe Element      
Cube  Dimension    
Class      
Charateristic    
A class with dimension and detail objects (Detail objects for key and desription)      
Hi
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
java多线程工作单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 推行国产操作系统的优劣
                                    yananay
windowslinux国产操作系统
                                    
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 
 
先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
    
                                
    •