com.squareup.moshi.Moshi Java Examples

@Test public void nonObjectDoesNotConsume() throws IOException {
  Moshi moshi = new Moshi.Builder()
      .add(PolymorphicJsonAdapterFactory.of(Message.class, "type")
          .withSubtype(Success.class, "success")
          .withSubtype(Error.class, "error"))
      .build();
  JsonAdapter<Message> adapter = moshi.adapter(Message.class);

  JsonReader reader = JsonReader.of(new Buffer().writeUtf8("\"Failure\""));
  try {
    adapter.fromJson(reader);
    fail();
  } catch (JsonDataException expected) {
    assertThat(expected).hasMessage("Expected BEGIN_OBJECT but was STRING at path $");
  }
  assertThat(reader.nextString()).isEqualTo("Failure");
  assertThat(reader.peek()).isEqualTo(JsonReader.Token.END_DOCUMENT);
}
 

public void run() throws Exception {
  String json = ""
      + "[\n"
      + "  {\n"
      + "    \"rank\": \"4\",\n"
      + "    \"suit\": \"CLUBS\"\n"
      + "  },\n"
      + "  {\n"
      + "    \"rank\": \"A\",\n"
      + "    \"suit\": \"HEARTS\"\n"
      + "  },\n"
      + "  {\n"
      + "    \"rank\": \"J\",\n"
      + "    \"suit\": \"SPADES\"\n"
      + "  }\n"
      + "]";

  Moshi moshi = new Moshi.Builder().build();

  Type listOfCardsType = Types.newParameterizedType(List.class, Card.class);
  JsonAdapter<List<Card>> jsonAdapter = moshi.adapter(listOfCardsType);

  List<Card> cards = jsonAdapter.fromJson(json);
  System.out.println(cards);
}
 

@Override public @Nullable JsonAdapter<?> create(
    Type type, Set<? extends Annotation> annotations, Moshi moshi) {
  if (!annotations.isEmpty()) {
    return null; // Annotations? This factory doesn't apply.
  }

  if (!(type instanceof ParameterizedType)) {
    return null; // No type parameter? This factory doesn't apply.
  }

  ParameterizedType parameterizedType = (ParameterizedType) type;
  if (parameterizedType.getRawType() != SortedSet.class) {
    return null; // Not a sorted set? This factory doesn't apply.
  }

  Type elementType = parameterizedType.getActualTypeArguments()[0];
  JsonAdapter<Object> elementAdapter = moshi.adapter(elementType);

  return new SortedSetAdapter<>(elementAdapter).nullSafe();
}
 

public void run() throws Exception {
  String json = ""
      + "{\n"
      + "  \"hidden_card\": {\n"
      + "    \"rank\": \"6\",\n"
      + "    \"suit\": \"SPADES\"\n"
      + "  },\n"
      + "  \"visible_cards\": [\n"
      + "    {\n"
      + "      \"rank\": \"4\",\n"
      + "      \"suit\": \"CLUBS\"\n"
      + "    },\n"
      + "    {\n"
      + "      \"rank\": \"A\",\n"
      + "      \"suit\": \"HEARTS\"\n"
      + "    }\n"
      + "  ]\n"
      + "}\n";

  Moshi moshi = new Moshi.Builder().build();
  JsonAdapter<BlackjackHand> jsonAdapter = moshi.adapter(BlackjackHand.class);

  BlackjackHand blackjackHand = jsonAdapter.fromJson(json);
  System.out.println(blackjackHand);
}
 

public <T extends ResourceIdentifier> JsonAdapter<Document> getDocumentAdapter(Class<T> typeParameter,
                                                                               Class<? extends Resource>... knownTypes) {
    Moshi moshi;
    if (typeParameter == null) {
        return (JsonAdapter) TestUtil.moshi(knownTypes).adapter(Document.class);
    } else if (typeParameter.getAnnotation(JsonApi.class) != null) {
        Class<? extends Resource>[] types = new Class[knownTypes.length + 1];
        types[0] = (Class) typeParameter;
        for (int i = 0; i != knownTypes.length; i++) {
            types[i + 1] = knownTypes[i];
        }
        moshi = TestUtil.moshi(types);
    } else {
        moshi = TestUtil.moshi(knownTypes);
    }
    return moshi.adapter(Types.newParameterizedType(Document.class, typeParameter));
}
 

public void run() throws Exception {
  // For some reason our JSON has date and time as separate fields. We will clean that up during
  // parsing: Moshi will first parse the JSON directly to an EventJson and from that the
  // EventJsonAdapter will create the actual Event.
  String json = ""
      + "{\n"
      + "  \"title\": \"Blackjack tournament\",\n"
      + "  \"begin_date\": \"20151010\",\n"
      + "  \"begin_time\": \"17:04\"\n"
      + "}\n";

  Moshi moshi = new Moshi.Builder().add(new EventJsonAdapter()).build();
  JsonAdapter<Event> jsonAdapter = moshi.adapter(Event.class);

  Event event = jsonAdapter.fromJson(json);
  System.out.println(event);
  System.out.println(jsonAdapter.toJson(event));
}
 

protected OAuthResponse(Response response) throws IOException {
    this.response = response;
    if (response != null) {
        responseBody = response.body().string();

        if (Utils.isJsonResponse(response)) {
            Moshi moshi = new Moshi.Builder().build();
            if (response.isSuccessful()) {
                token = moshi.adapter(Token.class).fromJson(responseBody);
                jsonParsed = true;

                if (token.expires_in != null)
                    expiresAt = (token.expires_in * 1000) + System.currentTimeMillis();
            } else {
                try {
                    error = moshi.adapter(OAuthError.class).fromJson(responseBody);
                    jsonParsed = true;
                } catch (Exception e) {
                    error = new OAuthError(e);
                    jsonParsed = false;

                }
            }
        }
    }
}
 

@Test public void unregisteredSubtype() {
  Moshi moshi = new Moshi.Builder()
      .add(PolymorphicJsonAdapterFactory.of(Message.class, "type")
          .withSubtype(Success.class, "success")
          .withSubtype(Error.class, "error"))
      .build();
  JsonAdapter<Message> adapter = moshi.adapter(Message.class);

  try {
    adapter.toJson(new EmptyMessage());
  } catch (IllegalArgumentException expected) {
    assertThat(expected).hasMessage("Expected one of [class"
        + " com.squareup.moshi.adapters.PolymorphicJsonAdapterFactoryTest$Success, class"
        + " com.squareup.moshi.adapters.PolymorphicJsonAdapterFactoryTest$Error] but found"
        + " EmptyMessage, a class"
        + " com.squareup.moshi.adapters.PolymorphicJsonAdapterFactoryTest$EmptyMessage. Register"
        + " this subtype.");
  }
}
 

@Test public void nonUniqueSubtypes() throws IOException {
  Moshi moshi = new Moshi.Builder()
      .add(PolymorphicJsonAdapterFactory.of(Message.class, "type")
          .withSubtype(Success.class, "success")
          .withSubtype(Success.class, "data")
          .withSubtype(Error.class, "error"))
      .build();

  JsonAdapter<Message> adapter = moshi.adapter(Message.class);

  assertThat(adapter.fromJson("{\"type\":\"success\",\"value\":\"Okay!\"}"))
      .isEqualTo(new Success("Okay!"));
  assertThat(adapter.fromJson("{\"type\":\"data\",\"value\":\"Data!\"}"))
      .isEqualTo(new Success("Data!"));
  assertThat(adapter.fromJson("{\"type\":\"error\",\"error_logs\":{\"order\":66}}"))
      .isEqualTo(new Error(Collections.<String, Object>singletonMap("order", 66d)));
  assertThat(adapter.toJson(new Success("Data!")))
      .isEqualTo("{\"type\":\"success\",\"value\":\"Data!\"}");
}
 

public void run() throws Exception {
  // We want to match any Stage that starts with 'in-progress' as Stage.IN_PROGRESS
  // and leave the rest of the enum values as to match as normal.
  Moshi moshi = new Moshi.Builder().add(new StageAdapter()).build();
  JsonAdapter<Stage> jsonAdapter = moshi.adapter(Stage.class);

  System.out.println(jsonAdapter.fromJson("\"not-started\""));
  System.out.println(jsonAdapter.fromJson("\"in-progress\""));
  System.out.println(jsonAdapter.fromJson("\"in-progress-step1\""));
}
 

public static void main(String[] args) throws Exception {
  Moshi moshi = new Moshi.Builder()
      .add(FallbackEnumJsonAdapter.FACTORY)
      .build();
  JsonAdapter<Example> adapter = moshi.adapter(Example.class);
  System.out.println(adapter.fromJson("{\"transportation\":\"CARS\"}"));
}
 

@Test
public void fromJson_shouldHandleAbsent_andNull_andNonNullValues() throws IOException {
    Moshi moshi = new Moshi.Builder().add(new BigDecimalAdapter()).build();

    JsonAdapter<BigDecimalModel> adapter = moshi.adapter(BigDecimalModel.class);
    BigDecimalModel model = adapter.fromJson("{\"nullDecimal\":null,\"presentDecimal\":1.23}");
    assertThat(model.absentDecimal).isNull();
    assertThat(model.nullDecimal).isNull();
    assertThat(model.presentDecimal).isEqualTo(new BigDecimal("1.23"));
}
 

@Test
public void toJson_shouldWork() {
    Moshi moshi = new Moshi.Builder().add(new BigDecimalAdapter()).build();
    JsonAdapter<BigDecimalModel> adapter = moshi.adapter(BigDecimalModel.class);
    BigDecimalModel bigDecimalModel = new BigDecimalModel();
    bigDecimalModel.presentDecimal = new BigDecimal("1.23");
    String json = adapter.toJson(bigDecimalModel);
    assertThat(json).isEqualTo("{\"presentDecimal\":1.23}");
}
 

@Test
public void whenDeserializing_thenTransientFieldIgnored() throws IOException {
    Moshi moshi = new Moshi.Builder()
      .build();
    JsonAdapter<Post> jsonAdapter = moshi.adapter(Post.class);

    String json = "{\"authored_by\":\"Baeldung\",\"title\":\"My Post\"}";
    Post post = jsonAdapter.fromJson(json);
    System.out.println(post);
}
 

public void run() throws Exception {
  String json = "[\"DIAMONDS\", \"STARS\", \"HEARTS\"]";

  Moshi moshi = new Moshi.Builder()
      .add(DefaultOnDataMismatchAdapter.newFactory(Suit.class, Suit.CLUBS))
      .build();
  JsonAdapter<List<Suit>> jsonAdapter = moshi.adapter(
      Types.newParameterizedType(List.class, Suit.class));

  List<Suit> suits = jsonAdapter.fromJson(json);
  System.out.println(suits);
}
 

@Test
public void whenSerializing_thenCorrectJsonProduced() {
    Moshi moshi = new Moshi.Builder()
      .add(new JsonDateTimeAdapter())
      .build();
    JsonAdapter<ZonedDateTime> jsonAdapter = moshi.adapter(ZonedDateTime.class);

    String json = jsonAdapter.toJson(ZonedDateTime.now());
    System.out.println(json);
}
 

@Test
public void whenSerializing_thenRenamedFieldsGetConsumed() throws IOException {
    Moshi moshi = new Moshi.Builder()
      .build();
    JsonAdapter<Post> jsonAdapter = moshi.adapter(Post.class);

    String json = "{\"authored_by\":\"Baeldung\",\"title\":\"My Post\"}";
    Post post = jsonAdapter.fromJson(json);
    System.out.println(post);
}
 

@Test public void nonStringLabelValue() throws IOException {
  Moshi moshi = new Moshi.Builder()
      .add(PolymorphicJsonAdapterFactory.of(Message.class, "type")
          .withSubtype(Success.class, "success")
          .withSubtype(Error.class, "error"))
      .build();
  JsonAdapter<Message> adapter = moshi.adapter(Message.class);

  try {
    adapter.fromJson("{\"type\":{},\"value\":\"Okay!\"}");
    fail();
  } catch (JsonDataException expected) {
    assertThat(expected).hasMessage("Expected a string but was BEGIN_OBJECT at path $.type");
  }
}
 

public static <T> Factory newFactory(final Class<T> type, final T defaultValue) {
  return new Factory() {
    @Override public @Nullable JsonAdapter<?> create(
        Type requestedType, Set<? extends Annotation> annotations, Moshi moshi) {
      if (type != requestedType) return null;
      JsonAdapter<T> delegate = moshi.nextAdapter(this, type, annotations);
      return new DefaultOnDataMismatchAdapter<>(delegate, defaultValue);
    }
  };
}
 

@Provides @Singleton Retrofit provideRetrofit(HttpUrl baseUrl, @Named("Api") OkHttpClient client,
    Moshi moshi) {
  return new Retrofit.Builder() //
      .client(client) //
      .baseUrl(baseUrl) //
      .addConverterFactory(MoshiConverterFactory.create(moshi)) //
      .addCallAdapterFactory(RxJavaCallAdapterFactory.create()) //
      .build();
}
 

public static InfluxDBException buildExceptionForErrorState(final String errorBody) {
  try {
    Moshi moshi = new Moshi.Builder().build();
    JsonAdapter<ErrorMessage> adapter = moshi.adapter(ErrorMessage.class).lenient();
    ErrorMessage errorMessage = adapter.fromJson(errorBody);
    return InfluxDBException.buildExceptionFromErrorMessage(errorMessage.error);
  } catch (Exception e) {
    return new InfluxDBException(errorBody);
  }
}
 

@Test
public void whenSerializing_thenAlternativeAdapterUsed() {
    Moshi moshi = new Moshi.Builder()
      .add(new EpochMillisAdapter())
      .build();
    JsonAdapter<Post> jsonAdapter = moshi.adapter(Post.class);

    String json = jsonAdapter.toJson(new Post("Introduction to Moshi Json", "Baeldung", Instant.now()));
    System.out.println(json);
}
 

@Test
public void whenDeserializing_thenCorrectJsonConsumed() throws IOException {
    Moshi moshi = new Moshi.Builder()
      .build();
    JsonAdapter<Post> jsonAdapter = moshi.adapter(Post.class);

    String json = "{\"author\":\"Baeldung\",\"text\":\"This is my post\",\"title\":\"My Post\"}";
    Post post = jsonAdapter.fromJson(json);
    System.out.println(post);
}
 

/** Builds an adapter that fallbacks to a default value in case there's a mismatch. */
public static <T> JsonAdapter.Factory newFactory(final Type type, final T defaultValue) {
  return new Factory() {
    @Override public JsonAdapter<?> create(Type requestedType,
        Set<? extends Annotation> annotations, Moshi moshi) {
      if (Types.equals(type, requestedType)) {
        JsonAdapter<T> delegate = moshi.nextAdapter(this, type, annotations);
        return new DefaultOnDataMismatchAdapter<>(delegate, defaultValue);
      }

      return null;
    }
  };
}
 

@Before
public void setUp() throws Exception {
    Moshi moshi = new Moshi.Builder().add(new BigDecimalAdapter()).build();

    service = new Retrofit.Builder()
            .addConverterFactory(MoshiConverterFactory.create(moshi))
            .client(new OkHttpClient.Builder()
                    .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
                    .build())
            .baseUrl("http://localhost:" + wireMockRule.port())
            .build()
            .create(RidesService.class);
}
 

@SafeVarargs
public static Moshi moshi(boolean strict, Class<? extends Resource>... types) {
    ResourceAdapterFactory.Builder factoryBuilder = ResourceAdapterFactory.builder();
    factoryBuilder.add(types);
    if (!strict) {
        factoryBuilder.add(Default.class);
    }
    return new Moshi.Builder().add(factoryBuilder.build()).add(new ColorAdapter()).build();
}
 

@Test public void failOnUnknownMissingTypeLabel() throws IOException {
  Moshi moshi = new Moshi.Builder()
      .add(PolymorphicJsonAdapterFactory.of(Message.class, "type")
          .withSubtype(MessageWithType.class, "success"))
      .build();
  JsonAdapter<Message> adapter = moshi.adapter(Message.class).failOnUnknown();

  MessageWithType decoded = (MessageWithType) adapter.fromJson(
      "{\"value\":\"Okay!\",\"type\":\"success\"}");
  assertThat(decoded.value).isEqualTo("Okay!");
}
 

@Test
public void deserialize_object_to_object_typed_document() throws Exception {
    Moshi moshi = TestUtil.moshi(Article.class);
    JsonAdapter<?> adapter = moshi.adapter(Types.newParameterizedType(ObjectDocument.class, Article.class));
    assertThat(adapter, instanceOf(ResourceAdapterFactory.DocumentAdapter.class));
    ObjectDocument<Article> objectDocument = ((ObjectDocument<Article>) adapter.fromJson(TestUtil.fromResource("/single.json")));
    assertThat(objectDocument, instanceOf(ObjectDocument.class));
    assertOnArticle1(objectDocument.<Article>asObjectDocument().get());
}
 

@Inject public OauthManager(IntentFactory intentFactory, OkHttpClient client, Moshi moshi,
    @AccessToken Preference<String> accessToken) {
  this.intentFactory = intentFactory;
  this.client = client;
  this.moshi = moshi;
  this.accessToken = accessToken;
}
 

public static String getRemoteVersion(){
    String data = RequestUtils.githubApi("releases/latest");
    Moshi moshi = new Moshi.Builder().build();
    JsonAdapter<GithubRelease> jsonAdapter = moshi.adapter(GithubRelease.class);
    try {
        GithubRelease release = jsonAdapter.fromJson(data);
        return release.tag_name;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "";
}