Java XContentType.JSON属性代码示例

/**
 * Returns the body as a string
 */
public String getBodyAsString() {
    if (bodyAsString == null && body != null) {
        //content-type null means that text was returned
        if (bodyContentType == null || bodyContentType == XContentType.JSON || bodyContentType == XContentType.YAML) {
            bodyAsString = new String(body, StandardCharsets.UTF_8);
        } else {
            //if the body is in a binary format and gets requested as a string (e.g. to log a test failure), we convert it to json
            try (XContentBuilder jsonBuilder = XContentFactory.jsonBuilder()) {
                try (XContentParser parser = bodyContentType.xContent().createParser(NamedXContentRegistry.EMPTY, body)) {
                    jsonBuilder.copyCurrentStructure(parser);
                }
                bodyAsString = jsonBuilder.string();
            } catch (IOException e) {
                throw new UncheckedIOException("unable to convert response body to a string format", e);
            }
        }
    }
    return bodyAsString;
}
 

/**
 * Ensure that the {@link IndexRequest}'s content type is supported by the Bulk API and that it conforms
 * to the current {@link BulkRequest}'s content type (if it's known at the time of this method get called).
 *
 * @return the {@link IndexRequest}'s content type
 */
static XContentType enforceSameContentType(IndexRequest indexRequest, @Nullable XContentType xContentType) {
    XContentType requestContentType = indexRequest.getContentType();
    if (requestContentType != XContentType.JSON && requestContentType != XContentType.SMILE) {
        throw new IllegalArgumentException("Unsupported content-type found for request with content-type [" + requestContentType
                + "], only JSON and SMILE are supported");
    }
    if (xContentType == null) {
        return requestContentType;
    }
    if (requestContentType != xContentType) {
        throw new IllegalArgumentException("Mismatching content-type found for request with content-type [" + requestContentType
                + "], previous requests have content-type [" + xContentType + "]");
    }
    return xContentType;
}
 

public void testEnforceSameContentType() {
    XContentType xContentType = randomFrom(XContentType.JSON, XContentType.SMILE);
    IndexRequest indexRequest = new IndexRequest().source(singletonMap("field", "value"), xContentType);
    assertEquals(xContentType, enforceSameContentType(indexRequest, null));
    assertEquals(xContentType, enforceSameContentType(indexRequest, xContentType));

    XContentType bulkContentType = randomBoolean() ? xContentType : null;

    IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () ->
            enforceSameContentType(new IndexRequest().source(singletonMap("field", "value"), XContentType.CBOR), bulkContentType));
    assertEquals("Unsupported content-type found for request with content-type [CBOR], only JSON and SMILE are supported",
            exception.getMessage());

    exception = expectThrows(IllegalArgumentException.class, () ->
            enforceSameContentType(new IndexRequest().source(singletonMap("field", "value"), XContentType.YAML), bulkContentType));
    assertEquals("Unsupported content-type found for request with content-type [YAML], only JSON and SMILE are supported",
            exception.getMessage());

    XContentType requestContentType = xContentType == XContentType.JSON ? XContentType.SMILE : XContentType.JSON;

    exception = expectThrows(IllegalArgumentException.class, () ->
            enforceSameContentType(new IndexRequest().source(singletonMap("field", "value"), requestContentType), xContentType));
    assertEquals("Mismatching content-type found for request with content-type [" + requestContentType + "], "
            + "previous requests have content-type [" + xContentType + "]", exception.getMessage());
}
 

public void testSlowLogParsedDocumentPrinterSourceToLog() throws IOException {
    BytesReference source = JsonXContent.contentBuilder().startObject().field("foo", "bar").endObject().bytes();
    ParsedDocument pd = new ParsedDocument(new NumericDocValuesField("version", 1), SeqNoFieldMapper.SequenceID.emptySeqID(), "id",
            "test", null, null, source, XContentType.JSON, null);
    Index index = new Index("foo", "123");
    // Turning off document logging doesn't log source[]
    SlowLogParsedDocumentPrinter p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 0);
    assertThat(p.toString(), not(containsString("source[")));

    // Turning on document logging logs the whole thing
    p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, Integer.MAX_VALUE);
    assertThat(p.toString(), containsString("source[{\"foo\":\"bar\"}]"));

    // And you can truncate the source
    p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 3);
    assertThat(p.toString(), containsString("source[{\"f]"));

    // And you can truncate the source
    p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 3);
    assertThat(p.toString(), containsString("source[{\"f]"));
    assertThat(p.toString(), startsWith("[foo/123] took"));
}
 

private ParsedDocument testParsedDocument(String id, String type, String routing,
                                          ParseContext.Document document, BytesReference source, Mapping mappingUpdate) {
    Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    Field versionField = new NumericDocValuesField("_version", 0);
    SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    return new ParsedDocument(versionField, seqID, id, type, routing, Arrays.asList(document), source, XContentType.JSON,
        mappingUpdate);
}
 

private ParsedDocument testParsedDocument(String id, String type, String routing, ParseContext.Document document, BytesReference source, Mapping mappingsUpdate) {
    Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    Field versionField = new NumericDocValuesField("_version", 0);
    SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    document.add(new LongPoint("point_field", 42)); // so that points report memory/disk usage
    return new ParsedDocument(versionField, seqID, id, type, routing, Arrays.asList(document), source, XContentType.JSON,
        mappingsUpdate);
}
 

/**
 * Creates a new {@link XContentBuilder} for a response to be sent using this channel. The builder's type is determined by the following
 * logic. If the request has a format parameter that will be used to attempt to map to an {@link XContentType}. If there is no format
 * parameter, the HTTP Accept header is checked to see if it can be matched to a {@link XContentType}. If this first attempt to map
 * fails, the request content type will be used if the value is not {@code null}; if the value is {@code null} the output format falls
 * back to JSON.
 */
@Override
public XContentBuilder newBuilder(@Nullable XContentType requestContentType, boolean useFiltering) throws IOException {
    // try to determine the response content type from the media type or the format query string parameter, with the format parameter
    // taking precedence over the Accept header
    XContentType responseContentType = XContentType.fromMediaTypeOrFormat(format);
    if (responseContentType == null) {
        if (requestContentType != null) {
            // if there was a parsed content-type for the incoming request use that since no format was specified using the query
            // string parameter or the HTTP Accept header
            responseContentType = requestContentType;
        } else {
            // default to JSON output when all else fails
            responseContentType = XContentType.JSON;
        }
    }

    Set<String> includes = Collections.emptySet();
    Set<String> excludes = Collections.emptySet();
    if (useFiltering) {
        Set<String> filters = Strings.splitStringByCommaToSet(filterPath);
        includes = filters.stream().filter(INCLUDE_FILTER).collect(toSet());
        excludes = filters.stream().filter(EXCLUDE_FILTER).map(f -> f.substring(1)).collect(toSet());
    }

    XContentBuilder builder = new XContentBuilder(XContentFactory.xContent(responseContentType), bytesOutput(), includes, excludes);
    if (pretty) {
        builder.prettyPrint().lfAtEnd();
    }

    builder.humanReadable(human);
    return builder;
}
 

/**
 * Returns a {@link SettingsLoader} based on the {@link XContentType}. Note only {@link XContentType#JSON} and
 * {@link XContentType#YAML} are supported
 *
 * @param xContentType The content type
 * @return A settings loader.
 */
public static SettingsLoader loaderFromXContentType(XContentType xContentType) {
    if (xContentType == XContentType.JSON) {
        return new JsonSettingsLoader(true);
    } else if (xContentType == XContentType.YAML) {
        return new YamlSettingsLoader(true);
    } else {
        throw new IllegalArgumentException("unsupported content type [" + xContentType + "]");
    }
}
 

public void testSerializationWithXContent() throws IOException {
    PutPipelineRequest request = new PutPipelineRequest("1", new BytesArray("{}".getBytes(StandardCharsets.UTF_8)), XContentType.JSON);
    assertEquals(XContentType.JSON, request.getXContentType());

    BytesStreamOutput output = new BytesStreamOutput();
    request.writeTo(output);
    StreamInput in = StreamInput.wrap(output.bytes().toBytesRef().bytes);

    PutPipelineRequest serialized = new PutPipelineRequest();
    serialized.readFrom(in);
    assertEquals(XContentType.JSON, serialized.getXContentType());
    assertEquals("{}", serialized.getSource().utf8ToString());
}
 

/**
 * Returns the sliced {@link BytesReference}. If the {@link XContentType} is JSON, the byte preceding the marker is checked to see
 * if it is a carriage return and if so, the BytesReference is sliced so that the carriage return is ignored
 */
private BytesReference sliceTrimmingCarriageReturn(BytesReference bytesReference, int from, int nextMarker, XContentType xContentType) {
    final int length;
    if (XContentType.JSON == xContentType && bytesReference.get(nextMarker - 1) == (byte) '\r') {
        length = nextMarker - from - 1;
    } else {
        length = nextMarker - from;
    }
    return bytesReference.slice(from, length);
}
 

public void testDispatchRequestAddsAndFreesBytesOnError() {
    int contentLength = BREAKER_LIMIT.bytesAsInt();
    String content = randomAsciiOfLength(contentLength);
    TestRestRequest request = new TestRestRequest("/error", content, XContentType.JSON);
    AssertingChannel channel = new AssertingChannel(request, true, RestStatus.BAD_REQUEST);

    restController.dispatchRequest(request, channel, new ThreadContext(Settings.EMPTY));

    assertEquals(0, inFlightRequestsBreaker.getTrippedCount());
    assertEquals(0, inFlightRequestsBreaker.getUsed());
}
 

public void testValidateNoIngestInfo() throws Exception {
    PutPipelineRequest putRequest = new PutPipelineRequest("_id", new BytesArray(
            "{\"processors\": [{\"set\" : {\"field\": \"_field\", \"value\": \"_value\"}}]}"), XContentType.JSON);
    Exception e = expectThrows(IllegalStateException.class, () -> store.validatePipeline(Collections.emptyMap(), putRequest));
    assertEquals("Ingest info is empty", e.getMessage());

    DiscoveryNode discoveryNode = new DiscoveryNode("_node_id", buildNewFakeTransportAddress(),
            emptyMap(), emptySet(), Version.CURRENT);
    IngestInfo ingestInfo = new IngestInfo(Collections.singletonList(new ProcessorInfo("set")));
    store.validatePipeline(Collections.singletonMap(discoveryNode, ingestInfo), putRequest);
}
 

@Override
public XContentType contentType() {
    return XContentType.JSON;
}
 

@Override
public XContentType xcontentType() {
    return XContentType.JSON;
}
 

/**
 * Parses and returns the given item.
 */
public static Item parse(XContentParser parser, Item item) throws IOException {
    XContentParser.Token token;
    String currentFieldName = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (currentFieldName != null) {
            if (Field.INDEX.match(currentFieldName)) {
                item.index = parser.text();
            } else if (Field.TYPE.match(currentFieldName)) {
                item.type = parser.text();
            } else if (Field.ID.match(currentFieldName)) {
                item.id = parser.text();
            } else if (Field.DOC.match(currentFieldName)) {
                item.doc = jsonBuilder().copyCurrentStructure(parser).bytes();
                item.xContentType = XContentType.JSON;
            } else if (Field.FIELDS.match(currentFieldName)) {
                if (token == XContentParser.Token.START_ARRAY) {
                    List<String> fields = new ArrayList<>();
                    while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                        fields.add(parser.text());
                    }
                    item.fields(fields.toArray(new String[fields.size()]));
                } else {
                    throw new ElasticsearchParseException(
                            "failed to parse More Like This item. field [fields] must be an array");
                }
            } else if (Field.PER_FIELD_ANALYZER.match(currentFieldName)) {
                item.perFieldAnalyzer(TermVectorsRequest.readPerFieldAnalyzer(parser.map()));
            } else if ("_routing".equals(currentFieldName) || "routing".equals(currentFieldName)) {
                item.routing = parser.text();
            } else if ("_version".equals(currentFieldName) || "version".equals(currentFieldName)) {
                item.version = parser.longValue();
            } else if ("_version_type".equals(currentFieldName) || "_versionType".equals(currentFieldName)
                    || "version_type".equals(currentFieldName) || "versionType".equals(currentFieldName)) {
                item.versionType = VersionType.fromString(parser.text());
            } else {
                throw new ElasticsearchParseException(
                        "failed to parse More Like This item. unknown field [{}]", currentFieldName);
            }
        }
    }
    if (item.id != null && item.doc != null) {
        throw new ElasticsearchParseException(
                "failed to parse More Like This item. either [id] or [doc] can be specified, but not both!");
    }
    if (item.id == null && item.doc == null) {
        throw new ElasticsearchParseException(
                "failed to parse More Like This item. neither [id] nor [doc] is specified!");
    }
    return item;
}