使用Retrofit进行连续的api调用并返回observable

import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import retrofit2.http.GET;
import io.reactivex.Observable;

public class ApiClient {

    private static final String BASE_URL = "https://api.example.com/";
    private static Retrofit retrofit = null;

    public static Retrofit getClient() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

interface ApiService {
    @GET("endpoint1")
    Observable<Response1> getResponse1();

    @GET("endpoint2")
    Observable<Response2> getResponse2();
}

public class Main {
    public static void main(String[] args) {
        ApiService apiService = ApiClient.getClient().create(ApiService.class);

        Observable.zip(apiService.getResponse1(), apiService.getResponse2(), (response1, response2) -> {
            // 处理两个响应的组合结果
            return new CombinedResponse(response1, response2);
        }).subscribe(combinedResponse -> {
            // 处理最终的组合结果
            System.out.println(combinedResponse);
        }, throwable -> {
            // 处理错误
            System.err.println("Error: " + throwable.getMessage());
        });
    }
}

apiService.getResponse1()
    .flatMap(response1 -> apiService.getResponse2().map(response2 -> new CombinedResponse(response1, response2)))
    .subscribe(combinedResponse -> {
        // 处理最终的组合结果
        System.out.println(combinedResponse);
    }, throwable -> {
        // 处理错误
        System.err.println("Error: " + throwable.getMessage());
    });