import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
@Override
protected MultiTermVectorsResponse executeMultiTermVectors(MultiTermVectorsRequest mtvRequest) {
    try {
        MultiTermVectorsItemResponse[] responses = new MultiTermVectorsItemResponse[mtvRequest.size()];
        int i = 0;
        for (TermVectorsRequest request : mtvRequest) {
            TermVectorsResponse response = new TermVectorsResponse(request.index(), request.type(), request.id());
            response.setExists(true);
            Fields generatedFields;
            if (request.doc() != null) {
                generatedFields = generateFields(randomFields, request.doc().utf8ToString());
            } else {
                generatedFields = generateFields(request.selectedFields().toArray(new String[request.selectedFields().size()]), request.id());
            }
            EnumSet<TermVectorsRequest.Flag> flags = EnumSet.of(TermVectorsRequest.Flag.Positions, TermVectorsRequest.Flag.Offsets);
            response.setFields(generatedFields, request.selectedFields(), flags, generatedFields);
            responses[i++] = new MultiTermVectorsItemResponse(response, null);
        }
        return new MultiTermVectorsResponse(responses);
    } catch (IOException ex) {
        throw new ElasticsearchException("boom", ex);
    }
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
private static Fields[] getFieldsFor(MultiTermVectorsResponse responses) throws IOException {
    List<Fields> likeFields = new ArrayList<>();

    for (MultiTermVectorsItemResponse response : responses) {
        if (response.isFailed()) {
            continue;
        }
        TermVectorsResponse getResponse = response.getResponse();
        if (!getResponse.isExists()) {
            continue;
        }
        likeFields.add(getResponse.getFields());
    }
    return likeFields.toArray(Fields.EMPTY_ARRAY);
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
public void testTook() throws Exception {
    XContentBuilder mapping = jsonBuilder()
        .startObject()
            .startObject("type1")
                .startObject("properties")
                    .startObject("field")
                        .field("type", "text")
                        .field("term_vector", "with_positions_offsets_payloads")
                    .endObject()
                .endObject()
            .endObject()
        .endObject();
    createIndex("test", Settings.EMPTY, "type1", mapping);
    ensureGreen();

    client().prepareIndex("test", "type1", "0").setSource("field", "foo bar").setRefreshPolicy(IMMEDIATE).get();

    IndicesService indicesService = getInstanceFromNode(IndicesService.class);
    IndexService test = indicesService.indexService(resolveIndex("test"));
    IndexShard shard = test.getShardOrNull(0);
    assertThat(shard, notNullValue());

    List<Long> longs = Stream.of(abs(randomLong()), abs(randomLong())).sorted().collect(toList());

    TermVectorsRequest request = new TermVectorsRequest("test", "type1", "0");
    TermVectorsResponse response = TermVectorsService.getTermVectors(shard, request, longs.iterator()::next);

    assertThat(response, notNullValue());
    assertThat(response.getTookInMillis(), equalTo(TimeUnit.NANOSECONDS.toMillis(longs.get(1) - longs.get(0))));
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
public static Fields[] getFieldsFor(MultiTermVectorsResponse responses) throws IOException {
    List<Fields> likeFields = new ArrayList<>();

    for (MultiTermVectorsItemResponse response : responses) {
        if (response.isFailed()) {
            continue;
        }
        TermVectorsResponse getResponse = response.getResponse();
        if (!getResponse.isExists()) {
            continue;
        }
        likeFields.add(getResponse.getFields());
    }
    return likeFields.toArray(Fields.EMPTY_ARRAY);
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) throws Exception {
    TermVectorsRequest termVectorsRequest = new TermVectorsRequest(request.param("index"), request.param("type"), request.param("id"));
    if (RestActions.hasBodyContent(request)) {
        try (XContentParser parser = XContentFactory.xContent(RestActions.guessBodyContentType(request)).createParser(RestActions.getRestContent(request))){
            TermVectorsRequest.parseRequest(termVectorsRequest, parser);
        }
    }
    readURIParameters(termVectorsRequest, request);

    client.termVectors(termVectorsRequest, new RestToXContentListener<TermVectorsResponse>(channel));
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
private void writeStandardTermVector(TermVectorsResponse outResponse) throws IOException {

        Directory dir = LuceneTestCase.newDirectory();
        IndexWriterConfig conf = new IndexWriterConfig(new StandardAnalyzer());

        conf.setOpenMode(OpenMode.CREATE);
        IndexWriter writer = new IndexWriter(dir, conf);
        FieldType type = new FieldType(TextField.TYPE_STORED);
        type.setStoreTermVectorOffsets(true);
        type.setStoreTermVectorPayloads(false);
        type.setStoreTermVectorPositions(true);
        type.setStoreTermVectors(true);
        type.freeze();
        Document d = new Document();
        d.add(new Field("id", "abc", StringField.TYPE_STORED));
        d.add(new Field("plaintext", "the1 quick brown fox jumps over  the1 lazy dog comment", type));
        d.add(new Field("desc", "the1 quick brown fox jumps over  the1 lazy dog comment", type));

        writer.updateDocument(new Term("id", "abc"), d);
        writer.commit();
        writer.close();
        DirectoryReader dr = DirectoryReader.open(dir);
        IndexSearcher s = new IndexSearcher(dr);
        TopDocs search = s.search(new TermQuery(new Term("id", "abc")), 1);
        ScoreDoc[] scoreDocs = search.scoreDocs;
        int doc = scoreDocs[0].doc;
        Fields termVectors = dr.getTermVectors(doc);
        EnumSet<Flag> flags = EnumSet.of(Flag.Positions, Flag.Offsets);
        outResponse.setFields(termVectors, null, flags, termVectors);
        dr.close();
        dir.close();

    }
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
private Map<Integer,String> getTermVectorWithException(String field, String id) throws IOException {
    TermVectorsResponse response = client.prepareTermVector(indexName, documentType, id)
            .setOffsets(false).setPositions(true).setFieldStatistics(false)
            .setTermStatistics(false)
            .setSelectedFields(field).
                    execute().actionGet();

    Map<Integer,String> map = new HashMap<>();
    Terms terms = response.getFields().terms(field);
    if (terms==null){
        return map;
    }
    TermsEnum iterator = terms.iterator();
    PostingsEnum postings = null;
    
    for (BytesRef termBytes = null; (termBytes = iterator.next()) != null; ) {
    	String term = termBytes.utf8ToString();
    	
    	postings = iterator.postings(postings, PostingsEnum.ALL);
    	
    	//there can only be one doc since we are getting with id. get the doc and the position 
    	postings.nextDoc();
    	
    	int tf = postings.freq();
    	
    	for (int i = 0; i < tf; i++) {
    		int pos = postings.nextPosition();
            map.put(pos,term);
    	}
    	
    }
    
    return map;
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
public static TermVectorsResponse getTermVectors(IndexShard indexShard, TermVectorsRequest request) {
    return getTermVectors(indexShard, request, System::nanoTime);
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
@Override
public ActionFuture<TermVectorsResponse> termVectors(final TermVectorsRequest request) {
    return execute(TermVectorsAction.INSTANCE, request);
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
@Deprecated
@Override
public ActionFuture<TermVectorsResponse> termVector(final TermVectorsRequest request) {
    return termVectors(request);
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
@Override
public ActionFuture<TermVectorsResponse> termVectors(TermVectorsRequest request) {
	// TODO Auto-generated method stub
	return null;
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
@Override
public ActionFuture<TermVectorsResponse> termVector(TermVectorsRequest request) {
	// TODO Auto-generated method stub
	return null;
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
private boolean exists(TermVectorsResponse termVectorsResponse, GetResult getResult) {
    return ((termVectorsResponse != null && termVectorsResponse.isExists()) ||
            (getResult != null && getResult.isExists()));
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
private TermVectorsResponse getTermVectors(VectorizeRequest request) {
    // TODO: there is no need to actually to embed a term vector request
    return indexShard.termVectorsService().getTermVectors(request.getTermVectorsRequest(), indexShard.shardId().getIndex());
}
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
/**
 * An action that returns the term vectors for a specific document.
 *
 * @param request The term vector request
 * @return The response future
 */
ActionFuture<TermVectorsResponse> termVectors(TermVectorsRequest request);
 

import org.elasticsearch.action.termvectors.TermVectorsResponse; //导入依赖的package包/类
/**
 * An action that returns the term vectors for a specific document.
 *
 * @param request The term vector request
 * @return The response future
 */
@Deprecated
ActionFuture<TermVectorsResponse> termVector(TermVectorsRequest request);