ai.z.openapi.service

Class AbstractClientBaseService

java.lang.Object

ai.z.openapi.service.AbstractClientBaseService

Direct Known Subclasses:

AbstractAiClient

public abstract class AbstractClientBaseService
extends Object

Abstract base service class that provides common functionality for API client implementations. This class handles request execution, response processing, and error handling for both synchronous and streaming API calls.

Field Summary

Fields

Modifier and Type	Field and Description
protected static org.slf4j.Logger	logger
protected static com.fasterxml.jackson.databind.ObjectMapper	mapper

Constructor Summary

Constructors

Constructor and Description
AbstractClientBaseService()

Method Summary

Modifier and Type	Method and Description
abstract <Data,F,Param,TReq extends ClientRequest<Param>,TResp extends BiFlowableClientResponse<Data,F>> TResp	biStreamRequest(TReq request, FlowableRequestSupplier<Param,retrofit2.Call<okhttp3.ResponseBody>> requestSupplier, Class<TResp> tRespClass, Class<F> tStreamClass) Executes a streaming API request and returns a Flowable-based response.
static <T> T	execute(io.reactivex.rxjava3.core.Single<T> apiCall) Executes a Single API call synchronously and handles errors.
abstract <Data,Param,TReq extends ClientRequest<Param>,TResp extends ClientResponse<Data>> TResp	executeRequest(TReq request, RequestSupplier<Param,Data> requestSupplier, Class<TResp> tRespClass) Executes a synchronous API request.
static io.reactivex.rxjava3.core.Flowable<SSE>	stream(retrofit2.Call<okhttp3.ResponseBody> apiCall) Creates a streaming Flowable of SSE events without emitting done events.
static io.reactivex.rxjava3.core.Flowable<SSE>	stream(retrofit2.Call<okhttp3.ResponseBody> apiCall, boolean emitDone) Creates a streaming Flowable of SSE events with optional done event emission.
<T> io.reactivex.rxjava3.core.Flowable<T>	stream(retrofit2.Call<okhttp3.ResponseBody> apiCall, Class<T> cl) Creates a streaming Flowable that maps SSE data to the specified class type.
<T,Param,TReq extends ClientRequest<Param>,TResp extends FlowableClientResponse<T>> TResp	streamRequest(TReq request, FlowableRequestSupplier<Param,retrofit2.Call<okhttp3.ResponseBody>> requestSupplier, Class<TResp> tRespClass, Class<T> tClass) Executes a streaming API request with the same type for response body and stream element.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

protected static final org.slf4j.Logger logger

mapper

protected static final com.fasterxml.jackson.databind.ObjectMapper mapper

Constructor Detail

AbstractClientBaseService

public AbstractClientBaseService()

Method Detail

executeRequest

public abstract <Data,Param,TReq extends ClientRequest<Param>,TResp extends ClientResponse<Data>> TResp executeRequest(TReq request,
                                                                                                                       RequestSupplier<Param,Data> requestSupplier,
                                                                                                                       Class<TResp> tRespClass)

Executes a synchronous API request.

Type Parameters:

Data - the type of data returned by the API

Param - the type of parameters sent to the API

TReq - the type of the request object

TResp - the type of the response object

Parameters:

request - the request object containing parameters

requestSupplier - the supplier that creates the API call

tRespClass - the class of the response type

Returns:

the response object containing the API result

biStreamRequest

public abstract <Data,F,Param,TReq extends ClientRequest<Param>,TResp extends BiFlowableClientResponse<Data,F>> TResp biStreamRequest(TReq request,
                                                                                                                                      FlowableRequestSupplier<Param,retrofit2.Call<okhttp3.ResponseBody>> requestSupplier,
                                                                                                                                      Class<TResp> tRespClass,
                                                                                                                                      Class<F> tStreamClass)

Executes a streaming API request and returns a Flowable-based response. This unified version supports both: - simplified response where Data == stream element type (FlowableClientResponse) - and bi-type response where Data ≠ stream element type (BiFlowableClientResponse)

Type Parameters:

Data - type of response body

F - type of each element in the stream (can be same as Data)

Param - request param type

TReq - request type

TResp - response type (must extend BiFlowableClientResponse)

Parameters:

request - the request to send

requestSupplier - factory that creates the Retrofit call

tRespClass - the response class type

tStreamClass - the class of the stream element

Returns:

streaming client response

streamRequest

public <T,Param,TReq extends ClientRequest<Param>,TResp extends FlowableClientResponse<T>> TResp streamRequest(TReq request,
                                                                                                               FlowableRequestSupplier<Param,retrofit2.Call<okhttp3.ResponseBody>> requestSupplier,
                                                                                                               Class<TResp> tRespClass,
                                                                                                               Class<T> tClass)

Executes a streaming API request with the same type for response body and stream element.

Type Parameters:

T - data type for both response and stream

Param - request param type

TReq - request type

TResp - response type (must extend FlowableClientResponse)

execute

public static <T> T execute(io.reactivex.rxjava3.core.Single<T> apiCall)

Executes a Single API call synchronously and handles errors.

Type Parameters:

T - the type of the response

Parameters:

apiCall - the Single API call to execute

Returns:

the response from the API call

Throws:

ZAiHttpException - if an HTTP error occurs with a parseable error body

retrofit2.HttpException - if an HTTP error occurs that cannot be parsed

stream

public <T> io.reactivex.rxjava3.core.Flowable<T> stream(retrofit2.Call<okhttp3.ResponseBody> apiCall,
                                                        Class<T> cl)

Creates a streaming Flowable that maps SSE data to the specified class type.

Type Parameters:

T - the type to map the SSE data to

Parameters:

apiCall - the API call that returns streaming data

cl - the class to map the SSE data to

Returns:

a Flowable of the specified type

stream

public static io.reactivex.rxjava3.core.Flowable<SSE> stream(retrofit2.Call<okhttp3.ResponseBody> apiCall)

Creates a streaming Flowable of SSE events without emitting done events.

Parameters:

apiCall - the API call that returns streaming data

Returns:

a Flowable of SSE events

stream

public static io.reactivex.rxjava3.core.Flowable<SSE> stream(retrofit2.Call<okhttp3.ResponseBody> apiCall,
                                                             boolean emitDone)

Creates a streaming Flowable of SSE events with optional done event emission.

Parameters:

apiCall - the API call that returns streaming data

emitDone - whether to emit done events

Returns:

a Flowable of SSE events