Java XContentBuilder.builder方法代码示例

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public void testXContentRoundTrip() throws IOException {
    /*
     * Note that this round trip isn't 100% perfect - status will always be read as RawTaskStatus. Since this test uses RawTaskStatus
     * as the status we randomly generate then we can assert the round trip with .equals.
     */
    TaskResult result = randomTaskResult();
    TaskResult read;
    try (XContentBuilder builder = XContentBuilder.builder(randomFrom(XContentType.values()).xContent())) {
        result.toXContent(builder, ToXContent.EMPTY_PARAMS);
        try (XContentBuilder shuffled = shuffleXContent(builder);
                XContentParser parser = createParser(shuffled)) {
            read = TaskResult.PARSER.apply(parser, null);
        }
    } catch (IOException e) {
        throw new IOException("Error processing [" + result + "]", e);
    }
    assertEquals(result, read);
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public void testParser() throws IOException {
    ContextParser<Void, PipelineConfiguration> parser = PipelineConfiguration.getParser();
    XContentType xContentType = randomFrom(XContentType.values());
    final BytesReference bytes;
    try (XContentBuilder builder = XContentBuilder.builder(xContentType.xContent())) {
        new PipelineConfiguration("1", new BytesArray("{}".getBytes(StandardCharsets.UTF_8)), XContentType.JSON)
            .toXContent(builder, ToXContent.EMPTY_PARAMS);
        bytes = builder.bytes();
    }

    XContentParser xContentParser = xContentType.xContent().createParser(NamedXContentRegistry.EMPTY, bytes);
    PipelineConfiguration parsed = parser.parse(xContentParser, null);
    assertEquals(xContentType, parsed.getXContentType());
    assertEquals("{}", XContentHelper.convertToJson(parsed.getConfig(), false, parsed.getXContentType()));
    assertEquals("1", parsed.getId());
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
private void testFiltering(Settings source, Settings filtered, String... patterns) throws IOException {
    SettingsFilter settingsFilter = new SettingsFilter(Settings.EMPTY, Arrays.asList(patterns));

    // Test using direct filtering
    Settings filteredSettings = settingsFilter.filter(source);
    assertThat(filteredSettings.getAsMap().entrySet(), equalTo(filtered.getAsMap().entrySet()));

    // Test using toXContent filtering
    RestRequest request = new FakeRestRequest();
    settingsFilter.addFilterSettingParams(request);
    XContentBuilder xContentBuilder = XContentBuilder.builder(JsonXContent.jsonXContent);
    xContentBuilder.startObject();
    source.toXContent(xContentBuilder, request);
    xContentBuilder.endObject();
    String filteredSettingsString = xContentBuilder.string();
    filteredSettings = Settings.builder().loadFromSource(filteredSettingsString, xContentBuilder.contentType()).build();
    assertThat(filteredSettings.getAsMap().entrySet(), equalTo(filtered.getAsMap().entrySet()));
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public void testParseAliasAndAliasesThrowsError() throws IOException {
    XContentBuilder b = XContentBuilder.builder(randomFrom(XContentType.values()).xContent());
    b.startObject(); {
        b.startObject(randomFrom("add", "remove")); {
            b.field("index", randomAsciiOfLength(5));
            b.field("alias", randomAsciiOfLength(5));
            b.array("aliases", generateRandomStringArray(10, 5, false, false));
        }
        b.endObject();
    }
    b.endObject();
    try (XContentParser parser = createParser(b)) {
        Exception e = expectThrows(ParsingException.class, () -> AliasActions.PARSER.apply(parser, null));
        assertThat(e.getCause().getCause(), instanceOf(IllegalArgumentException.class));
        assertEquals("Only one of [alias] and [aliases] is supported", e.getCause().getCause().getMessage());
    }
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
protected Function<String, String> createFunction(Object resolved) {
    return s -> {
        if (resolved == null) {
            return null;
        }
        try (XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent())) {
            if (resolved == null) {
                builder.nullValue();
            } else if (resolved instanceof Iterable) {
                builder.startArray();
                for (Object o : (Iterable) resolved) {
                    builder.value(o);
                }
                builder.endArray();
            } else if (resolved instanceof Map) {
                builder.map((Map<String, ?>) resolved);
            } else {
                // Do not handle as JSON
                return oh.stringify(resolved);
            }
            return builder.string();
        } catch (IOException e) {
            throw new MustacheException("Failed to convert object to JSON", e);
        }
    };
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
private static BytesReference parseSourceBytes(XContentParser parser) throws IOException {
    try (XContentBuilder builder = XContentBuilder.builder(parser.contentType().xContent())) {
        // the original document gets slightly modified: whitespaces or
        // pretty printing are not preserved,
        // it all depends on the current builder settings
        builder.copyCurrentStructure(parser);
        return builder.bytes();
    }
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
private static String arrayToParsableString(String[] array) {
    try {
        XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent());
        builder.startArray();
        for (String element : array) {
            builder.value(element);
        }
        builder.endArray();
        return builder.string();
    } catch (IOException ex) {
        throw new ElasticsearchException(ex);
    }
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
private ScriptMetaData randomScriptMetaData(XContentType sourceContentType) throws IOException {
    ScriptMetaData.Builder builder = new ScriptMetaData.Builder(null);
    int numScripts = scaledRandomIntBetween(0, 32);
    for (int i = 0; i < numScripts; i++) {
        String lang = randomAsciiOfLength(4);
        XContentBuilder sourceBuilder = XContentBuilder.builder(sourceContentType.xContent());
        sourceBuilder.startObject().field("script", randomAsciiOfLength(4)).endObject();
        builder.storeScript(randomAsciiOfLength(i + 1),
            StoredScriptSource.parse(lang, sourceBuilder.bytes(), sourceBuilder.contentType()));
    }
    return builder.build();
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
private static RawTaskStatus randomRawTaskStatus() throws IOException {
    try (XContentBuilder builder = XContentBuilder.builder(Requests.INDEX_CONTENT_TYPE.xContent())) {
        builder.startObject();
        int fields = between(0, 10);
        for (int f = 0; f < fields; f++) {
            builder.field(randomAsciiOfLength(5), randomAsciiOfLength(5));
        }
        builder.endObject();
        return new RawTaskStatus(builder.bytes());
    }
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public void testParseRemove() throws IOException {
    String[] indices = generateRandomStringArray(10, 5, false, false);
    String[] aliases = generateRandomStringArray(10, 5, false, false);
    XContentBuilder b = XContentBuilder.builder(randomFrom(XContentType.values()).xContent());
    b.startObject(); {
        b.startObject("remove"); {
            if (indices.length > 1 || randomBoolean()) {
                b.array("indices", indices);
            } else {
                b.field("index", indices[0]);
            }
            if (aliases.length > 1 || randomBoolean()) {
                b.array("aliases", aliases);
            } else {
                b.field("alias", aliases[0]);
            }
        }
        b.endObject();
    }
    b.endObject();
    b = shuffleXContent(b);
    try (XContentParser parser = createParser(b)) {
        AliasActions action = AliasActions.PARSER.apply(parser, null);
        assertEquals(AliasActions.Type.REMOVE, action.actionType());
        assertThat(action.indices(), equalTo(indices));
        assertThat(action.aliases(), equalTo(aliases));
    }
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public void testIndex() throws IOException {
    String index = randomAsciiOfLengthBetween(3, 10);
    String type = randomAsciiOfLengthBetween(3, 10);
    IndexRequest indexRequest = new IndexRequest(index, type);

    String id = randomBoolean() ? randomAsciiOfLengthBetween(3, 10) : null;
    indexRequest.id(id);

    Map<String, String> expectedParams = new HashMap<>();

    String method = "POST";
    if (id != null) {
        method = "PUT";
        if (randomBoolean()) {
            indexRequest.opType(DocWriteRequest.OpType.CREATE);
        }
    }

    setRandomTimeout(indexRequest, expectedParams);
    setRandomRefreshPolicy(indexRequest, expectedParams);

    // There is some logic around _create endpoint and version/version type
    if (indexRequest.opType() == DocWriteRequest.OpType.CREATE) {
        indexRequest.version(randomFrom(Versions.MATCH_ANY, Versions.MATCH_DELETED));
        expectedParams.put("version", Long.toString(Versions.MATCH_DELETED));
    } else {
        setRandomVersion(indexRequest, expectedParams);
        setRandomVersionType(indexRequest, expectedParams);
    }

    if (frequently()) {
        if (randomBoolean()) {
            String routing = randomAsciiOfLengthBetween(3, 10);
            indexRequest.routing(routing);
            expectedParams.put("routing", routing);
        }
        if (randomBoolean()) {
            String parent = randomAsciiOfLengthBetween(3, 10);
            indexRequest.parent(parent);
            expectedParams.put("parent", parent);
        }
        if (randomBoolean()) {
            String pipeline = randomAsciiOfLengthBetween(3, 10);
            indexRequest.setPipeline(pipeline);
            expectedParams.put("pipeline", pipeline);
        }
    }

    XContentType xContentType = randomFrom(XContentType.values());
    int nbFields = randomIntBetween(0, 10);
    try (XContentBuilder builder = XContentBuilder.builder(xContentType.xContent())) {
        builder.startObject();
        for (int i = 0; i < nbFields; i++) {
            builder.field("field_" + i, i);
        }
        builder.endObject();
        indexRequest.source(builder);
    }

    Request request = Request.index(indexRequest);
    if (indexRequest.opType() == DocWriteRequest.OpType.CREATE) {
        assertEquals("/" + index + "/" + type + "/" + id + "/_create", request.endpoint);
    } else if (id != null) {
        assertEquals("/" + index + "/" + type + "/" + id, request.endpoint);
    } else {
        assertEquals("/" + index + "/" + type, request.endpoint);
    }
    assertEquals(expectedParams, request.params);
    assertEquals(method, request.method);

    HttpEntity entity = request.entity;
    assertNotNull(entity);
    assertTrue(entity instanceof ByteArrayEntity);

    try (XContentParser parser = createParser(xContentType.xContent(), entity.getContent())) {
        assertEquals(nbFields, parser.map().size());
    }
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
private static XContentBuilder randomXContentBuilder() throws IOException {
    XContentType xContentType = randomFrom(XContentType.values());
    return XContentBuilder.builder(XContentFactory.xContent(xContentType));
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public static GetResult fromXContentEmbedded(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.nextToken();
    ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser::getTokenLocation);

    String currentFieldName = parser.currentName();
    String index = null, type = null, id = null;
    long version = -1;
    boolean found = false;
    BytesReference source = null;
    Map<String, GetField> fields = new HashMap<>();
    while((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (_INDEX.equals(currentFieldName)) {
                index = parser.text();
            } else if (_TYPE.equals(currentFieldName)) {
                type = parser.text();
            } else if (_ID.equals(currentFieldName)) {
                id = parser.text();
            }  else if (_VERSION.equals(currentFieldName)) {
                version = parser.longValue();
            } else if (FOUND.equals(currentFieldName)) {
                found = parser.booleanValue();
            } else {
                fields.put(currentFieldName, new GetField(currentFieldName, Collections.singletonList(parser.objectText())));
            }
        } else if (token == XContentParser.Token.START_OBJECT) {
            if (SourceFieldMapper.NAME.equals(currentFieldName)) {
                try (XContentBuilder builder = XContentBuilder.builder(parser.contentType().xContent())) {
                    //the original document gets slightly modified: whitespaces or pretty printing are not preserved,
                    //it all depends on the current builder settings
                    builder.copyCurrentStructure(parser);
                    source = builder.bytes();
                }
            } else if (FIELDS.equals(currentFieldName)) {
                while(parser.nextToken() != XContentParser.Token.END_OBJECT) {
                    GetField getField = GetField.fromXContent(parser);
                    fields.put(getField.getName(), getField);
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        }
    }
    return new GetResult(index, type, id, version, found, source, fields);
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public static XContentBuilder contentBuilder() throws IOException {
    return XContentBuilder.builder(yamlXContent);
}
 

import org.elasticsearch.common.xcontent.XContentBuilder; //导入方法依赖的package包/类
public static XContentBuilder contentBuilder() throws IOException {
    return XContentBuilder.builder(cborXContent);
}