Retrofit2 Условие обработки, когда код состояния 200, но структура json отличается от класса datamodel

Ответ 1

Таким образом, у вас есть два разных успешного ответа (код состояния 200) от одной и той же конечной точки. Один из них является фактической моделью данных, а одна из них является ошибкой (как в виде такой структуры json:

Действительный ответ LoginBean:

{
  "id": 1234,
  "something": "something"
}

Ошибка ответа

{
  "error": "error message"
}

Что вы можете сделать, это иметь сущность, которая обертывает оба случая и использует собственный десериализатор.

class LoginBeanResponse {
  @Nullable private final LoginBean loginBean;
  @Nullable private final ErrorMessage errorMessage;

  LoginBeanResponse(@Nullable LoginBean loginBean, @Nullable ErrorMessage errorMessage) {
    this.loginBean = loginBean;
    this.errorMessage = errorMessage;
  }
  // Add getters and whatever you need
}

Обертка для ошибки:

class ErrorMessage {
  String errorMessage;
  // And whatever else you need
  // ...
}

Затем вам понадобится JsonDeserializer:

public class LoginBeanResponseDeserializer implements JsonDeserializer<LoginBeanResponse> {

  @Override
  public LoginBeanResponse deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {

    // Based on the structure you check if the data is valid or not
    // Example for the above defined structures:

    // Get JsonObject
    final JsonObject jsonObject = json.getAsJsonObject();
    if (jsonObject.has("error") {
      ErrorMessage errorMessage = new Gson().fromJson(jsonObject, ErrorMessage.class);
      return new LoginBeanResponse(null, errorMessage)
    } else {
      LoginBean loginBean = new Gson().fromJson(jsonObject, LoginBean.class):
      return new LoginBeanResponse(loginBean, null);
    }
  }
}

Затем добавьте этот десериализатор в GsonConverterFactory:

GsonBuilder gsonBuilder = new GsonBuilder().registerTypeAdapter(LoginBeanResponse.class, new LoginBeanResponseDeserializer()).create():

apiClient = new Retrofit.Builder()
    .baseUrl(url)
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .addConverterFactory(GsonConverterFactory.create(gsonBuilder))
    .client(httpClient)
    .build();

Это единственный способ, которым я могу придумать эту работу. Но, как уже упоминалось, такой дизайн API просто ошибочен, потому что коды статуса есть по какой-то причине. Я все еще надеюсь, что это поможет.

EDIT: то, что вы можете сделать в классе, в котором вы делаете вызов этой дооснащения (если вы уже преобразовали из Call<LoginBeanResponse> в Single<LoginBeanResponse> с помощью RxJava), фактически возвращает правильную ошибку. Что-то вроде:

Single<LoginBean> getLoginResponse(Map<String, String> queryMap) {
    restApi.getLoginResponse(queryMap)
        .map(loginBeanResponse -> { if(loginBeanResponse.isError()) {
            Single.error(new Throwable(loginBeanResponse.getError().getErrorMessage()))
        } else { 
            Single.just(loginBeanReponse.getLoginBean()) 
        }})
}

Ответ 2

Похоже, что использование Retrofit's Gson по умолчанию упрощает добавление пользовательского десериализации для обработки части документа JSON, которая была проблемой.

Пример кода

@FormUrlEncoded
    @POST(GlobalVariables.LOGIN_URL)
    void Login(@Field("email") String key, @Field("password") String value, Callback<Response> callback);

getService().Login(email, password, new MyCallback<Response>(context, true, null)
{
    @Override
    public void failure(RetrofitError arg0)
     {
        // TODO Auto-generated method stub
        UtilitySingleton.dismissDialog((BaseActivity<?>) context);
        System.out.println(arg0.getResponse());
      }

    @Override
    public void success(Response arg0, Response arg1)
    {
         String result = null;
         StringBuilder sb = null;
         InputStream is = null;
         try
         {
                is = arg1.getBody().in();
                BufferedReader reader = new BufferedReader(new InputStreamReader(is));
                sb = new StringBuilder();
                String line = null;
                while ((line = reader.readLine()) != null)
                {
                    sb.append(line + "\n");
                    result = sb.toString();
                    System.out.println("Result :: " + result);
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    });

Ответ 3

Вы можете просто сделать это, сделав это

try
{
String error = response.errorBody().string();
error = error.replace("\"", "");
Toast.makeText(getContext(), error, Toast.LENGTH_LONG).show();
}
catch (IOException e)
{
e.printStackTrace();
}

Ответ 4

Одно из возможных решений заключается в том, чтобы сбой Gson при неизвестных свойствах. Похоже, что проблема уже поднята (https://github.com/google/gson/issues/188). Вы можете использовать обходной путь, указанный на странице проблемы. Итак, шаги следующие:

Добавьте обходной путь ValidatorAdapterFactory к базе кода:

public class ValidatorAdapterFactory implements TypeAdapterFactory {

@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    // If the type adapter is a reflective type adapter, we want to modify the implementation using reflection. The
    // trick is to replace the Map object used to lookup the property name. Instead of returning null if the
    // property is not found, we throw a Json exception to terminate the deserialization.
    TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);

    // Check if the type adapter is a reflective, cause this solution only work for reflection.
    if (delegate instanceof ReflectiveTypeAdapterFactory.Adapter) {

        try {
            // Get reference to the existing boundFields.
            Field f = delegate.getClass().getDeclaredField("boundFields");
            f.setAccessible(true);
            Map boundFields = (Map) f.get(delegate);

            // Then replace it with our implementation throwing exception if the value is null.
            boundFields = new LinkedHashMap(boundFields) {

                @Override
                public Object get(Object key) {

                    Object value = super.get(key);
                    if (value == null) {
                        throw new JsonParseException("invalid property name: " + key);
                    }
                    return value;

                }

            };
            // Finally, push our custom map back using reflection.
            f.set(delegate, boundFields);

        } catch (Exception e) {
            // Should never happen if the implementation doesn't change.
            throw new IllegalStateException(e);
        }

    }
    return delegate;
    }

}

Создайте объект Gson с помощью этого TypeAdaptorFactory:

Gson gson = new GsonBuilder().registerTypeAdapterFactory(new ValidatorAdapterFactory()).create()

И затем используйте этот экземпляр gson в GsonConverterFactory, как показано ниже:

apiClient = new Retrofit.Builder()
                .baseUrl(url)
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create(gson)) //Made change here
                .client(httpClient)
                .build();

Это должно вызывать ошибку, если шаг unmarshalling обнаруживает неизвестное свойство, в этом случае структуру ответа на ошибку.

Ответ 5

Вот еще одна попытка. Общая идея: создать пользовательский Converter.Factory на основе GsonConverterFactory и настраиваемый Converter<ResponseBody, T> конвертер на основе GsonRequestBodyConverter для синтаксического анализа всего тела 2 раза: первый раз как ошибка и второй раз как фактический ожидаемый тип ответа. Таким образом, мы можем анализировать ошибки в одном месте и сохранять дружественный внешний API. Это на самом деле похоже на ответ @anstaendig, но с гораздо меньшим количеством шаблонов: нет необходимости в дополнительной оболочке bean для каждого ответа и других подобных материалов.

Первый класс ServerError, который является моделью для вашей "ошибки JSON" и настраиваемого исключения ServerErrorException, чтобы вы могли получить все детали

public class ServerError
{ 
    // add here actual format of your error JSON
    public String errorMsg;
}

public class ServerErrorException extends RuntimeException
{
    private final ServerError serverError;

    public ServerErrorException(ServerError serverError)
    {
        super(serverError.errorMsg);
        this.serverError = serverError;
    }

    public ServerError getServerError()
    {
        return serverError;
    }
}

Очевидно, вы должны изменить класс ServerError, чтобы он соответствовал вашему фактическому формату данных.

И вот основной класс GsonBodyWithErrorConverterFactory:

public class GsonBodyWithErrorConverterFactory extends Converter.Factory
{
    private final Gson gson;
    private final GsonConverterFactory delegate;
    private final TypeAdapter<ServerError> errorTypeAdapter;


    public GsonBodyWithErrorConverterFactory()
    {
        this.gson = new Gson();
        this.delegate = GsonConverterFactory.create(gson);
        this.errorTypeAdapter = gson.getAdapter(TypeToken.get(ServerError.class));
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit)
    {
        return new GsonBodyWithErrorConverter<>(gson.getAdapter(TypeToken.get(type)));
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit)
    {
        return delegate.requestBodyConverter(type, parameterAnnotations, methodAnnotations, retrofit);
    }

    @Override
    public Converter<?, String> stringConverter(Type type, Annotation[] annotations, Retrofit retrofit)
    {
        return delegate.stringConverter(type, annotations, retrofit);
    }


    class GsonBodyWithErrorConverter<T> implements Converter<ResponseBody, T>
    {
        private final TypeAdapter<T> adapter;

        GsonBodyWithErrorConverter(TypeAdapter<T> adapter)
        {
            this.adapter = adapter;
        }

        @Override
        public T convert(ResponseBody value) throws IOException
        {
            // buffer whole response so we can safely read it twice
            String contents = value.string();

            try
            {
                // first parse response as an error
                ServerError serverError = null;
                try
                {
                    JsonReader jsonErrorReader = gson.newJsonReader(new StringReader(contents));
                    serverError = errorTypeAdapter.read(jsonErrorReader);
                }
                catch (Exception e)
                {
                    // ignore and try to read as actually required type
                }
                // checked that error object was parsed and contains some data
                if ((serverError != null) && (serverError.errorMsg != null))
                    throw new ServerErrorException(serverError);

                JsonReader jsonReader = gson.newJsonReader(new StringReader(contents));
                return adapter.read(jsonReader);
            }
            finally
            {
                value.close();
            }
        }
    }
}

Основная идея состоит в том, что factory делегирует другие вызовы стандартным GsonConverterFactory, но перехватывает responseBodyConverter, чтобы создать пользовательский GsonBodyWithErrorConverter. GsonBodyWithErrorConverter выполняет основной трюк:

• Сначала он читает весь ответ как String. Это необходимо для обеспечения буферизации тела ответа, поэтому мы можем безопасно перечитать его 2 раза. Если ваш ответ на самом деле может содержать некоторые двоичные файлы, вы должны читать и буферировать ответ как двоичный, и, к сожалению, retrofit2.Utils.buffer не является общедоступным методом, но вы можете создать подобный. Я просто прочитал тело как строку, поскольку он должен работать в простых случаях.
• Создайте jsonErrorReader из буферизованного тела и попробуйте прочитать тело как ServerError. Если мы сможем это сделать, у нас есть ошибка, поэтому бросьте наш пользовательский ServerErrorException. Если мы не можем прочитать его в этом формате - просто проигнорируйте исключение, так как это, вероятно, просто нормальный успешный ответ
• На самом деле попробуйте прочитать буферизованное тело (второй раз) в качестве запрошенного типа и вернуть его.

Обратите внимание, что если ваш фактический формат ошибки не JSON, вы все равно можете делать все те же вещи. Вам просто нужно изменить логику анализа ошибок внутри GsonBodyWithErrorConverter.convert на все, что вам нужно.

Итак, теперь в вашем коде вы можете использовать его как следующий

.addConverterFactory(new GsonBodyWithErrorConverterFactory()) // use custom factory
//.addConverterFactory(GsonConverterFactory.create()) //old, remove

Примечание. Я на самом деле не пробовал этот код, поэтому могут возникнуть ошибки, но я надеюсь, что вы получите эту идею.