import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
@Test
public void should_create_alias_with_filter() throws Exception {
    String index = "index_without_alias";
    createIndex(index);
    ensureGreen(index);

    // add a mapping so I can add a filter, else it will fail due to strict resolution of fields
    createSimpleDoc(index, THE_TYPE, THE_ID);
    ensureSearchable(index);

    IndicesAliasesRequest request = new IndicesAliasesRequest();
    TermFilterBuilder filter = termFilter("the_string_field", "some_value");

    request.addAlias("the_alias", filter, index);
    IndicesAliasesResponse response = httpClient.admin().indices().aliases(request).get();

    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetAliasesResponse finalState = transportClient.admin().indices().getAliases(new GetAliasesRequest()).actionGet();
    Assertions.assertThat(finalState.getAliases().get(index)).hasSize(1);
    Assertions.assertThat(finalState.getAliases().get(index).get(0).alias()).isEqualTo("the_alias");

    String requestFilter = request.getAliasActions().get(0).aliasAction().filter();
    CompressedString actualFilter = finalState.getAliases().get(index).get(0).filter();
    Assertions.assertThat(actualFilter.string()).isEqualTo(requestFilter);
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
@Cacheable("servicos-por-area-de-interesse")
default List<ServicoXML> findByAreaDeInteresse(AreaDeInteresse areaDeInteresse) {
    return search(new NativeSearchQueryBuilder()
            .withFilter(new TermFilterBuilder("areasDeInteresse", singletonList(areaDeInteresse)))
            .withSort(new FieldSortBuilder("nome").order(ASC))
            .build())
            .getContent();
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
@Cacheable("servicos-por-segmento-da-sociedade")
default List<ServicoXML> findBySegmentoDaSociedade(SegmentoDaSociedade segmentoDaSociedade) {
    return search(new NativeSearchQueryBuilder()
            .withFilter(new TermFilterBuilder("segmentosDaSociedade", singletonList(segmentoDaSociedade)))
            .withSort(new FieldSortBuilder("nome").order(ASC))
            .build())
            .getContent();
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
private FilterBuilder rarityOrFilter(List<Rarity> list) {
	List<TermFilterBuilder> filters = list.stream()
		.map(l -> termFilter("attributes.rarity", l.displayName()))
		.collect(Collectors.toList());
	TermFilterBuilder[] array = new TermFilterBuilder[filters.size()];
	array = filters.toArray(array); 
	return orFilter(array);
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
private TermFilterBuilder getTermFilter(String fieldName, String fieldValue)
{
    return FilterBuilders.termFilter(fieldName, fieldValue);
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
private TermFilterBuilder getTermFilter(final String fieldName, final String fieldValue)
{
    return FilterBuilders.termFilter(fieldName, fieldValue);
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
private TermFilterBuilder getTermFilter(final String fieldName,
		final String fieldValue) {
	return FilterBuilders.termFilter(fieldName, fieldValue);
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
@Override
public void visit( Equal op ) throws NoIndexException {
    final String name = op.getProperty().getValue().toLowerCase();
    final Object value = op.getLiteral().getValue();

    //special case so we support our '*' char with wildcard, also should work for uuids
    if ( value instanceof String || value instanceof UUID ) {
        String stringValue = ((value instanceof String) ? (String)value : value.toString()).toLowerCase().trim();

        // or field is just a string that does need a prefix us a query
        if ( stringValue.contains( "*" ) ) {

            //Because of our legacy behavior, where we match CCCC*, we need to use the unanalyzed string to ensure that
            //we start
            final WildcardQueryBuilder wildcardQuery =
                    QueryBuilders.wildcardQuery( IndexingUtils.FIELD_STRING_NESTED_UNANALYZED, stringValue );
            queryBuilders.push( fieldNameTerm( name, wildcardQuery ) );
            filterBuilders.push( NoOpFilterBuilder.INSTANCE );
            return;
        }

        // Usergrid query parser allows single quotes to be escaped in values
        if ( stringValue.contains("\\'")) {
            stringValue = stringValue.replace("\\'", "'");
        }

        //it's an exact match, use a filter
        final TermFilterBuilder termFilter =
                FilterBuilders.termFilter( IndexingUtils.FIELD_STRING_NESTED_UNANALYZED, stringValue );

        queryBuilders.push( NoOpQueryBuilder.INSTANCE );
        filterBuilders.push( fieldNameTerm( name, termFilter ) );

        return;
    }

    // assume all other types need prefix

    final TermFilterBuilder termQuery =
            FilterBuilders.termFilter(getFieldNameForType(value), sanitize(value));

    filterBuilders.push( fieldNameTerm( name, termQuery ) );

    queryBuilders.push( NoOpQueryBuilder.INSTANCE );
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
/**
 * Create a term filter for our sorts
 */
public static TermFilterBuilder sortPropertyTermFilter( final String propertyName ) {
    return FilterBuilders.termFilter( IndexingUtils.FIELD_NAME, propertyName );
}
 

import org.elasticsearch.index.query.TermFilterBuilder; //导入依赖的package包/类
/**
 * Create a sort for the property name and field name specified
 *
 * @param sortOrder The sort order
 * @param fieldName The name of the field for the type
 * @param propertyName The property name the user specified for the sort
 */
private FieldSortBuilder createSort( final SortOrder sortOrder, final String fieldName,
                                     final String propertyName ) {

    final TermFilterBuilder propertyFilter = sortPropertyTermFilter( propertyName );


    return SortBuilders.fieldSort( fieldName ).order( sortOrder ).setNestedFilter( propertyFilter );
}