RxJava2编译报错：cannot find symbol method body() 求解决方案

Let's break down why you're hitting this compile error and walk through straightforward fixes:

Root Cause #

The issue boils down to RxJava's generic type inference breaking in your chained operator call, specifically after the retryWhen step. While your IDE can intuit the correct type for successResponse, the compiler loses track of the generic type context here.

When you use the anonymous Observer<Response<List<NewsFeed>>>, you explicitly spell out the generic type, so the compiler knows exactly what feeds is. But with the lambda, the flatMap inside retryWhen introduces ambiguity—depending on what Helper.refreshToken() returns, the compiler might infer the entire stream's type as Flowable<Object> instead of Flowable<Response<List<NewsFeed>>>, making body() an unknown method.

Solutions #

Solution 1: Explicitly Declare the Lambda Parameter Type

The quickest fix is to tell the compiler exactly what type successResponse is directly in the subscribe lambda:

mCompositeDisposable.add( 
    Flowable.just(Boolean.TRUE) 
        .flatMap( ignored -> service.getPosts(offset,limit, PreferencesUtils.getAccessTokenKey()) ) 
        .subscribeOn(Schedulers.io()) 
        .doOnNext(response -> { 
            if (!response.isSuccessful()) throw new IllegalAccessException(); 
        }) 
        .retryWhen( error -> error.flatMap( f -> { 
            if(f instanceof IllegalAccessException) 
                return Helper.refreshToken(); 
            else 
                return Flowable.error(f); 
        })) 
        .observeOn(AndroidSchedulers.mainThread()) 
        .subscribe( (Response<List<NewsFeed>> successResponse) -> { // Explicit type here
            if (!successResponse.body().isEmpty()) { 
                mView.showNewsFeedItems(successResponse.body()); 
            } 
        }, failResponse -> { 
            mView.showError(); 
        })
);

Solution 2: Fix Generic Type Consistency in retryWhen

If you prefer to avoid explicit type declarations in the lambda, ensure the flatMap inside retryWhen returns a Flowable with the correct generic type. You may need to adjust your refreshToken logic or explicitly define the Function's type:

.retryWhen( error -> error.flatMap(new Function<Throwable, Flowable<Response<List<NewsFeed>>>>() {
    @Override
    public Flowable<Response<List<NewsFeed>>> apply(Throwable f) throws Exception {
        if(f instanceof IllegalAccessException) {
            // Important: Make sure this returns a Flowable that triggers a retry.
            // If refreshToken only fetches a new token, chain the original request again:
            return Helper.refreshToken()
                .flatMap(ignored -> service.getPosts(offset, limit, PreferencesUtils.getAccessTokenKey()));
        } else {
            return Flowable.error(f);
        }
    }
}))

Quick Side Note: Remember retryWhen only retries the original stream when the returned Flowable emits an onNext event. If Helper.refreshToken() completes without emitting a value (e.g., returns Flowable<Void>), add concatWith(Flowable.just(true)) to trigger the retry.

Why the Anonymous Observer Works #

When you use new Observer<Response<List<NewsFeed>>>(), you're explicitly defining the generic type of the stream's emissions. This skips the type inference step that fails in the lambda chain, so the compiler immediately recognizes feeds has a body() method.

内容的提问来源于stack exchange，提问作者R R