import org.apache.lucene.queries.BoostingQuery; //导入依赖的package包/类
@Override
public Query getQuery(Element e) throws ParserException {
  Element mainQueryElem = DOMUtils.getChildByTagOrFail(e, "Query");
  mainQueryElem = DOMUtils.getFirstChildOrFail(mainQueryElem);
  Query mainQuery = factory.getQuery(mainQueryElem);

  Element boostQueryElem = DOMUtils.getChildByTagOrFail(e, "BoostQuery");
  float boost = DOMUtils.getAttribute(boostQueryElem, "boost", DEFAULT_BOOST);
  boostQueryElem = DOMUtils.getFirstChildOrFail(boostQueryElem);
  Query boostQuery = factory.getQuery(boostQueryElem);

  BoostingQuery bq = new BoostingQuery(mainQuery, boostQuery, boost);

  bq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
  return bq;

}
 

import org.apache.lucene.queries.BoostingQuery; //导入依赖的package包/类
@Override
protected void doAssertLuceneQuery(BoostingQueryBuilder queryBuilder, Query query, SearchContext context) throws IOException {
    Query positive = queryBuilder.positiveQuery().toQuery(context.getQueryShardContext());
    Query negative = queryBuilder.negativeQuery().toQuery(context.getQueryShardContext());
    if (positive == null || negative == null) {
        assertThat(query, nullValue());
    } else {
        assertThat(query, instanceOf(BoostingQuery.class));
    }
}
 

import org.apache.lucene.queries.BoostingQuery; //导入依赖的package包/类
@Override
void flatten(Query sourceQuery, IndexReader reader, Collection<Query> flatQueries, float boost) throws IOException {
    if (sourceQuery instanceof BoostQuery) {
        BoostQuery bq = (BoostQuery) sourceQuery;
        sourceQuery = bq.getQuery();
        boost *= bq.getBoost();
        flatten(sourceQuery, reader, flatQueries, boost);
    } else if (sourceQuery instanceof SpanTermQuery) {
        super.flatten(new TermQuery(((SpanTermQuery) sourceQuery).getTerm()), reader, flatQueries, boost);
    } else if (sourceQuery instanceof ConstantScoreQuery) {
        flatten(((ConstantScoreQuery) sourceQuery).getQuery(), reader, flatQueries, boost);
    } else if (sourceQuery instanceof FunctionScoreQuery) {
        flatten(((FunctionScoreQuery) sourceQuery).getSubQuery(), reader, flatQueries, boost);
    } else if (sourceQuery instanceof MultiPhrasePrefixQuery) {
        flatten(sourceQuery.rewrite(reader), reader, flatQueries, boost);
    } else if (sourceQuery instanceof FiltersFunctionScoreQuery) {
        flatten(((FiltersFunctionScoreQuery) sourceQuery).getSubQuery(), reader, flatQueries, boost);
    } else if (sourceQuery instanceof MultiPhraseQuery) {
        MultiPhraseQuery q = ((MultiPhraseQuery) sourceQuery);
        convertMultiPhraseQuery(0, new int[q.getTermArrays().length], q, q.getTermArrays(), q.getPositions(), reader, flatQueries);
    } else if (sourceQuery instanceof BlendedTermQuery) {
        final BlendedTermQuery blendedTermQuery = (BlendedTermQuery) sourceQuery;
        flatten(blendedTermQuery.rewrite(reader), reader, flatQueries, boost);
    } else if (sourceQuery instanceof ESToParentBlockJoinQuery) {
        ESToParentBlockJoinQuery blockJoinQuery = (ESToParentBlockJoinQuery) sourceQuery;
        flatten(blockJoinQuery.getChildQuery(), reader, flatQueries, boost);
    } else if (sourceQuery instanceof BoostingQuery) {
        BoostingQuery boostingQuery = (BoostingQuery) sourceQuery;
        //flatten positive query with query boost
        flatten(boostingQuery.getMatch(), reader, flatQueries, boost);
        //flatten negative query with negative boost
        flatten(boostingQuery.getContext(), reader, flatQueries, boostingQuery.getBoost());
    } else if (sourceQuery instanceof SynonymQuery) {
        // SynonymQuery should be handled by the parent class directly.
        // This statement should be removed when https://issues.apache.org/jira/browse/LUCENE-7484 is merged.
        SynonymQuery synQuery = (SynonymQuery) sourceQuery;
        for (Term term : synQuery.getTerms()) {
            flatten(new TermQuery(term), reader, flatQueries, boost);
        }
    } else {
        super.flatten(sourceQuery, reader, flatQueries, boost);
    }
}
 

import org.apache.lucene.queries.BoostingQuery; //导入依赖的package包/类
@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    Query positive = positiveQuery.toQuery(context);
    Query negative = negativeQuery.toQuery(context);
    return new BoostingQuery(positive, negative, negativeBoost);
}
 

import org.apache.lucene.queries.BoostingQuery; //导入依赖的package包/类
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
    XContentParser parser = parseContext.parser();

    Query positiveQuery = null;
    boolean positiveQueryFound = false;
    Query negativeQuery = null;
    boolean negativeQueryFound = false;
    float boost = -1;
    float negativeBoost = -1;

    String currentFieldName = null;
    XContentParser.Token token;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token == XContentParser.Token.START_OBJECT) {
            if ("positive".equals(currentFieldName)) {
                positiveQuery = parseContext.parseInnerQuery();
                positiveQueryFound = true;
            } else if ("negative".equals(currentFieldName)) {
                negativeQuery = parseContext.parseInnerQuery();
                negativeQueryFound = true;
            } else {
                throw new QueryParsingException(parseContext, "[boosting] query does not support [" + currentFieldName + "]");
            }
        } else if (token.isValue()) {
            if ("negative_boost".equals(currentFieldName) || "negativeBoost".equals(currentFieldName)) {
                negativeBoost = parser.floatValue();
            } else if ("boost".equals(currentFieldName)) {
                boost = parser.floatValue();
            } else {
                throw new QueryParsingException(parseContext, "[boosting] query does not support [" + currentFieldName + "]");
            }
        }
    }

    if (positiveQuery == null && !positiveQueryFound) {
        throw new QueryParsingException(parseContext, "[boosting] query requires 'positive' query to be set'");
    }
    if (negativeQuery == null && !negativeQueryFound) {
        throw new QueryParsingException(parseContext, "[boosting] query requires 'negative' query to be set'");
    }
    if (negativeBoost == -1) {
        throw new QueryParsingException(parseContext, "[boosting] query requires 'negative_boost' to be set'");
    }

    // parsers returned null
    if (positiveQuery == null || negativeQuery == null) {
        return null;
    }

    BoostingQuery boostingQuery = new BoostingQuery(positiveQuery, negativeQuery, negativeBoost);
    if (boost != -1) {
        boostingQuery.setBoost(boost);
    }
    return boostingQuery;
}