Java JsonReader类代码示例

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@FromJson
List<Applet> fromJson(JsonReader jsonReader, JsonAdapter<Applet> delegate) throws IOException {
    List<Applet> applets = new ArrayList<>();
    jsonReader.beginObject();
    while (jsonReader.hasNext()) {
        int index = jsonReader.selectName(OPTIONS);
        switch (index) {
            case -1:
                jsonReader.skipValue();
                break;
            case 0:
                jsonReader.beginArray();
                while (jsonReader.hasNext()) {
                    Applet applet = delegate.fromJson(jsonReader);
                    applets.add(applet);
                }
                jsonReader.endArray();
                break;
            default:
                throw new IllegalStateException("Unknown index: " + index);
        }
    }
    jsonReader.endObject();

    return applets;
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Override
public Folder fromJson(JsonReader in) throws IOException {
    if (in.peek() == JsonReader.Token.NULL) {
        in.nextNull();
        return null;
    }
    Folder folder = new Folder();
    in.beginObject();
    while (in.hasNext()) {
        String name = in.nextName();
        switch (name) {
            case "id":
                folder.setId(in.nextLong());
                break;
            case "name":
                folder.setName(in.nextString());
                break;
            default:
                Log.w(TAG, "Unknown value in folder json: " + name);
                in.skipValue();
                break;
        }
    }
    in.endObject();
    return folder;
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
private void readAvatar(JsonReader in, User user, String name) throws IOException {
    in.beginObject();
    while(in.hasNext()) {
        String avatarName = in.nextName();
        switch (avatarName) {
            case "data":
                user.setAvatar(in.nextString());
                break;
            case "mime":
                user.setAvatarMime(in.nextString());
                break;
            default:
                Log.w(TAG, "Unknown value in avatar json: " + name);
                in.skipValue();
                break;
        }
    }
    in.endObject();
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
private void readWarnings(JsonReader in, Status status) throws IOException {
    in.beginObject();
    while(in.hasNext()) {
        String name = in.nextName();
        switch (name) {
            case "improperlyConfiguredCron":
                status.setImproperlyConfiguredCron(in.nextBoolean());
                break;
            case "incorrectDbCharset":
                // TODO: 11/9/17 Show warning 
                in.skipValue();
                break;
            default:
                Log.w(TAG, "Unknown value in status warnings json: " + name);
                in.skipValue();
        }
    }
    in.endObject();
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Override protected List<String> compute() {
  try (Response response = client.newCall(describeElasticsearchDomain).execute()) {
    if (!response.isSuccessful()) {
      throw new IllegalStateException(response.body().string());
    }

    JsonReader endpointReader =
        enterPath(JsonReader.of(response.body().source()), "DomainStatus", "Endpoint");
    checkArgument(endpointReader != null, "DomainStatus.Endpoint wasn't present in response");

    String endpoint = endpointReader.nextString();
    if (!endpoint.startsWith("https://")) {
      endpoint = "https://" + endpoint;
    }
    log.fine("using endpoint " + endpoint);
    return Collections.singletonList(endpoint);
  } catch (IOException e) {
    throw new IllegalStateException("couldn't lookup domain endpoint", e);
  }
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Override
protected ListenableFuture<List<String>> collectBucketKeys(String[] indices,
    QueryBuilder query, AbstractAggregationBuilder... aggregations) {
  SearchSourceBuilder elasticQuery = new SearchSourceBuilder().query(query).size(0);
  for (AbstractAggregationBuilder aggregation : aggregations) {
    elasticQuery.aggregation(aggregation);
  }

  Call searchRequest = http.newCall(new Request.Builder().url(lenientSearch(indices, SPAN))
      .post(RequestBody.create(APPLICATION_JSON, elasticQuery.toString()))
      .tag("search-spansAggregations").build());

  return new CallbackListenableFuture<List<String>>(searchRequest) {
    List<String> convert(ResponseBody responseBody) throws IOException {
      Set<String> result = collectValuesNamed(JsonReader.of(responseBody.source()), "key");
      return Util.sortedList(result);
    }
  }.enqueue();
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Override
public Annotation fromJson(JsonReader reader) throws IOException {
  Annotation.Builder result = Annotation.builder();
  reader.beginObject();
  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "timestamp":
        result.timestamp(reader.nextLong());
        break;
      case "value":
        result.value(reader.nextString());
        break;
      case "endpoint":
        result.endpoint(ENDPOINT_ADAPTER.fromJson(reader));
        break;
      default:
        reader.skipValue();
    }
  }
  reader.endObject();
  return result.build();
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Nullable
public static JsonReader enterPath(JsonReader reader, String path) throws IOException {
  try {
    if (reader.peek() != JsonReader.Token.BEGIN_OBJECT) return null;
  } catch (EOFException e) {
    return null;
  }
  reader.beginObject();
  while (reader.hasNext()) {
    if (reader.nextName().equals(path) && reader.peek() != JsonReader.Token.NULL) {
      return reader;
    } else {
      reader.skipValue();
    }
  }
  reader.endObject();
  return null;
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Override
public ResourceIdentifier fromJson(JsonReader reader) throws IOException {
    ResourceIdentifier object = new ResourceIdentifier();
    reader.beginObject();
    while (reader.hasNext()) {
        switch (reader.nextName()) {
            case "id":
                object.setId(nextNullableString(reader));
                break;
            case "type":
                object.setType(nextNullableString(reader));
                break;
            case "meta":
                object.setMeta(nextNullableObject(reader, jsonBufferJsonAdapter));
                break;
            default:
                reader.skipValue();
                break;
        }
    }
    reader.endObject();
    return object;
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@Override
public HasOne<T> fromJson(JsonReader reader) throws IOException {
    HasOne<T> relationship = new HasOne<>();
    reader.beginObject();
    while (reader.hasNext()) {
        switch (reader.nextName()) {
            case "data":
                relationship.set(nextNullableObject(reader, resourceIdentifierJsonAdapter));
                break;
            case "meta":
                relationship.setMeta(nextNullableObject(reader, jsonBufferJsonAdapter));
                break;
            case "links":
                relationship.setLinks(nextNullableObject(reader, jsonBufferJsonAdapter));
                break;
            default:
                reader.skipValue();
                break;
        }
    }
    reader.endObject();
    return relationship;
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override public <T> T fromJson(File file, Class<T> classOfT) throws RuntimeException {
  BufferedSource bufferedSource = null;
  try {
    bufferedSource = Okio.buffer(Okio.source(file));
    JsonAdapter<T> jsonAdapter = moshi.adapter(classOfT);
    return jsonAdapter.fromJson(JsonReader.of(bufferedSource));
  } catch (IOException e) {
    throw new RuntimeException(e);
  } finally {
    if(bufferedSource != null){
      try {
        bufferedSource.close();
      } catch (IOException ignored) {
      }
    }
  }
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
private ServiceError jsonToServiceError(Response response)
{
    ServiceError serviceError = null;
    BufferedSource source = response.body()
            .source();
    JsonReader reader = JsonReader.of(source);
    try
    {
        reader.beginObject();
        while(reader.hasNext())
        {
            String name = reader.nextName();
            if(name.equals("requestError"))
            {
                ServiceException serviceException = getServiceException(reader);
                serviceError = initServiceError(serviceError, serviceException);
            }
        }
    }
    catch(IOException e)
    {
        e.printStackTrace();
    }
    return serviceError;
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@FromJson
public AnInterface read(JsonReader jsonReader) throws IOException {
    jsonReader.beginObject();

    String name = null;
    while (jsonReader.hasNext()) {
        switch (jsonReader.nextName()) {
            case "name":
                name = jsonReader.nextString();
                break;
        }
    }

    jsonReader.endObject();
    return new AnImplementation(name);
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@FromJson public AnInterface read(JsonReader jsonReader) throws IOException {
  jsonReader.beginObject();

  String name = null;
  while (jsonReader.hasNext()) {
    switch (jsonReader.nextName()) {
      case "name":
        name = jsonReader.nextString();
        break;
    }
  }

  jsonReader.endObject();
  return new AnImplementation(name);
}
 

import com.squareup.moshi.JsonReader; //导入依赖的package包/类
@FromJson @Qualifier public String readQualified(JsonReader reader) throws IOException {
  String string = reader.nextString();
  if (string.equals("qualified!")) {
    return "it worked!";
  }
  throw new AssertionError("Found: " + string);
}