Java 如何修复预期的BEGIN_对象，但字符串已在改装中？

在我的应用程序中，我想使用改型从服务器获取一些数据。 我写了以下代码，但当运行应用程序和调用api时，会显示以下错误：

请查看我的上述代码并帮助我

来自服务器的API响应：

ApiService接口：

SocketPingBodySendData类：

---

如何解决此问题？

我认为当没有返回数据时，问题会返回字符串。后端通常会发生这样的错误。这个错误以前发生在我身上。当没有可用数据时，应检查json响应

改型是类型安全库。这意味着它只等待特定预定义类型的对象。如果服务器发送了其他内容，则会因错误而崩溃。这是你的案子。只要检查原始服务器响应，您就会发现问题所在。

尝试更改API调用

从

到

---

你得到的回应不是你所期望的。你希望得到JSONObject，但是你得到了其他东西，一些字符串。不幸的是，我不能，因为这可能是服务器问题，或者你的应用程序和服务器之间存在误解。没有人知道你的后端对你有什么期望，以及它会带来什么结果。我认为你必须指定内容类型是json。此外，这与您的问题无关，但这是一个建议：不要仅仅为了添加新的头而添加多个拦截器。您可以在一个截取中添加它们，但不知道您在哪里指定要发送JSON。。。尝试将@HeadersContent-Type:application/json添加到我签入的方法的签名之上，并在下面显示响应：{状态：ok，时间：0.0363459587097168}@Jungle-postmans在这种情况下答案不相关，因为post只显示原始响应。要查看应用程序中的错误响应，请检查response.body！=空{使用断点行并使用response.errorBody评估服务器应答，它将向您显示实际的服务器应答。我已签入邮递员并在下面显示我应答：{状态：确定，时间：0.0363459587097168}您能和邮递员一起检查应答案例中没有数据并在此处写入吗？如果不向邮递员发送数据，请在下面显示我{状态：错误，时间：0.01767897605895996}您误解了我的意思。您试图不发送任何数据，但我的意思是没有数据。是的，我的朋友，我没有数据，请在邮递员中显示上面的错误消息。使用您的代码在logcat中的响应上显示下面的消息。我在**onResponse**Log.esocketLogResponse中使用此代码，响应：+response.body；但在logcat上显示下面的消息：答复：

E/socketLogResponse: Err : com.google.gson.JsonSyntaxException: java.lang.IllegalStateException: Expected BEGIN_OBJECT but was STRING at line 1 column 1 path $

{
    "status": "ok",
    "time": 0.014972925186157227
}

@POST("api/log")
    Call<SocketPingResponse> getSocketPingLog(@Header("jwt") String jwt, @Body SocketPingBodySendData socketPingBodySendData);

public class SocketPingResponse {
    @SerializedName("status")
    @Expose
    private String status;
    @SerializedName("time")
    @Expose
    private Double time;

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public Double getTime() {
        return time;
    }

    public void setTime(Double time) {
        this.time = time;
    }
}

public class SocketPingBodySendData {
    @SerializedName("auction_id")
    @Expose
    int auction_id;
    @SerializedName("data")
    @Expose
    List<SocketPingEntity> data;

    public int getAuction_id() {
        return auction_id;
    }

    public void setAuction_id(int auction_id) {
        this.auction_id = auction_id;
    }

    public List<SocketPingEntity> getData() {
        return data;
    }

    public void setData(List<SocketPingEntity> data) {
        this.data = data;
    }
}

pingEntityList.addAll(socketPingDatabase.socketPingDao().getSocketPingEntityList());
                        SocketPingBodySendData pingBodySendData = new SocketPingBodySendData();
                        pingBodySendData.setAuction_id(auctionID);
                        pingBodySendData.setData(pingEntityList);
                        Toast.makeText(context, ""+pingEntityList.size(), Toast.LENGTH_SHORT).show();
                        Call<SocketPingResponse> pingResponseCall = apis.getSocketPingLog(jwtToken, pingBodySendData);
                        pingResponseCall.enqueue(new Callback<SocketPingResponse>() {
                            @Override
                            public void onResponse(Call<SocketPingResponse> call, Response<SocketPingResponse> response) {
                                    if (response.body() != null) {
                                        Toast.makeText(context, response.body().getStatus(), Toast.LENGTH_SHORT).show();
                                        if (response.body().getStatus().equals("ok")) {
                                            pingEntityList.clear();
                                            socketPingDatabase.socketPingDao().deleteAll();
                                        }
                                    }
                            }

                            @Override
                            public void onFailure(Call<SocketPingResponse> call, Throwable t) {
                                Log.e("socketLogResponse", "Err : " + t.toString());
                            }
                        });

public class ApiClient {
    private static final String BASE_URL = Constants.SERVER;
    private static Retrofit retrofit = null;
    private static Context context;

    public static Retrofit getClient() {

        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

        OkHttpClient.Builder client = new OkHttpClient.Builder();
        client.interceptors().add(interceptor);
        client.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request().newBuilder().addHeader("X-Client-Version", Constants.getAppVersionName()).build();
                return chain.proceed(request);
            }
        });
        client.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request().newBuilder().addHeader("uuid", Constants.getUUID(Constants.currentActivity)).build();
                return chain.proceed(request);
            }
        });

        client.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request().newBuilder().addHeader("agent", Constants.getAgent()).build();
                return chain.proceed(request);
            }
        });

        OkHttpClient client2 = client
                .connectTimeout(60, TimeUnit.SECONDS)
                .writeTimeout(60, TimeUnit.SECONDS)
                .readTimeout(60, TimeUnit.SECONDS)
                .build();

        Gson gson = new GsonBuilder()
                .setLenient()
                .create();

        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .client(client2)
                    .build();
        }
        return retrofit;
    }
}

@POST("api/log")
Call<SocketPingResponse> getSocketPingLog(@Header("jwt") String jwt, @Body SocketPingBodySendData socketPingBodySendData);

@POST("api/log")
Call<String> getSocketPingLog(@Header("jwt") String jwt, @Body SocketPingBodySendData socketPingBodySendData);


pingEntityList.addAll(socketPingDatabase.socketPingDao().getSocketPingEntityList());
                        SocketPingBodySendData pingBodySendData = new SocketPingBodySendData();
                        pingBodySendData.setAuction_id(auctionID);
                        pingBodySendData.setData(pingEntityList);
                        Toast.makeText(context, ""+pingEntityList.size(), Toast.LENGTH_SHORT).show();
                        Call<String> pingResponseCall = apis.getSocketPingLog(jwtToken, pingBodySendData);
                        pingResponseCall.enqueue(new Callback<String>() {
                            @Override
                            public void onResponse(Call<String> call, Response<String> response) {
                                    if (response.body() != null) {
                                        //Convert here your string response to Other POJO format
                                    }
                            }

                            @Override
                            public void onFailure(Call<String> call, Throwable t) {
                                Log.e("socketLogResponse", "Err : " + t.toString());
                            }
                        });