import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerScoreFunctions(List<SearchPlugin> plugins) {
    registerScoreFunction(new ScoreFunctionSpec<>(ScriptScoreFunctionBuilder.NAME, ScriptScoreFunctionBuilder::new,
            ScriptScoreFunctionBuilder::fromXContent));
    registerScoreFunction(
            new ScoreFunctionSpec<>(GaussDecayFunctionBuilder.NAME, GaussDecayFunctionBuilder::new, GaussDecayFunctionBuilder.PARSER));
    registerScoreFunction(new ScoreFunctionSpec<>(LinearDecayFunctionBuilder.NAME, LinearDecayFunctionBuilder::new,
            LinearDecayFunctionBuilder.PARSER));
    registerScoreFunction(new ScoreFunctionSpec<>(ExponentialDecayFunctionBuilder.NAME, ExponentialDecayFunctionBuilder::new,
            ExponentialDecayFunctionBuilder.PARSER));
    registerScoreFunction(new ScoreFunctionSpec<>(RandomScoreFunctionBuilder.NAME, RandomScoreFunctionBuilder::new,
            RandomScoreFunctionBuilder::fromXContent));
    registerScoreFunction(new ScoreFunctionSpec<>(FieldValueFactorFunctionBuilder.NAME, FieldValueFactorFunctionBuilder::new,
            FieldValueFactorFunctionBuilder::fromXContent));

    //weight doesn't have its own parser, so every function supports it out of the box.
    //Can be a single function too when not associated to any other function, which is why it needs to be registered manually here.
    namedWriteables.add(new NamedWriteableRegistry.Entry(ScoreFunctionBuilder.class, WeightBuilder.NAME, WeightBuilder::new));

    registerFromPlugin(plugins, SearchPlugin::getScoreFunctions, this::registerScoreFunction);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
public SearchModule(Settings settings, boolean transportClient, List<SearchPlugin> plugins) {
    this.settings = settings;
    this.transportClient = transportClient;
    registerSuggesters(plugins);
    highlighters = setupHighlighters(settings, plugins);
    registerScoreFunctions(plugins);
    registerQueryParsers(plugins);
    registerRescorers();
    registerSorts();
    registerValueFormats();
    registerSignificanceHeuristics(plugins);
    registerMovingAverageModels(plugins);
    registerAggregations(plugins);
    registerPipelineAggregations(plugins);
    registerFetchSubPhases(plugins);
    registerSearchExts(plugins);
    registerShapes();
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
public void testRegisterSuggester() {
    SearchModule module = new SearchModule(Settings.EMPTY, false, singletonList(new SearchPlugin() {
        @Override
        public List<SuggesterSpec<?>> getSuggesters() {
            return singletonList(new SuggesterSpec<>("custom", CustomSuggestionBuilder::new, CustomSuggestionBuilder::fromXContent));
        }
    }));
    assertEquals(1, module.getNamedXContents().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.match("term")).count());
    assertEquals(1, module.getNamedXContents().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.match("phrase")).count());
    assertEquals(1, module.getNamedXContents().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.match("completion")).count());
    assertEquals(1, module.getNamedXContents().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.match("custom")).count());

    assertEquals(1, module.getNamedWriteables().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.equals("term")).count());
    assertEquals(1, module.getNamedWriteables().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.equals("phrase")).count());
    assertEquals(1, module.getNamedWriteables().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.equals("completion")).count());
    assertEquals(1, module.getNamedWriteables().stream()
            .filter(e -> e.categoryClass.equals(SuggestionBuilder.class) && e.name.equals("custom")).count());
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private <T> void registerFromPlugin(List<SearchPlugin> plugins, Function<SearchPlugin, List<T>> producer, Consumer<T> consumer) {
    for (SearchPlugin plugin : plugins) {
        for (T t : producer.apply(plugin)) {
            consumer.accept(t);
        }
    }
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerSuggesters(List<SearchPlugin> plugins) {
    registerSmoothingModels(namedWriteables);

    registerSuggester(new SuggesterSpec<>("term", TermSuggestionBuilder::new, TermSuggestionBuilder::fromXContent));
    registerSuggester(new SuggesterSpec<>("phrase", PhraseSuggestionBuilder::new, PhraseSuggestionBuilder::fromXContent));
    registerSuggester(new SuggesterSpec<>("completion", CompletionSuggestionBuilder::new, CompletionSuggestionBuilder::fromXContent));

    registerFromPlugin(plugins, SearchPlugin::getSuggesters, this::registerSuggester);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private Map<String, Highlighter> setupHighlighters(Settings settings, List<SearchPlugin> plugins) {
    NamedRegistry<Highlighter> highlighters = new NamedRegistry<>("highlighter");
    highlighters.register("fvh",  new FastVectorHighlighter(settings));
    highlighters.register("plain", new PlainHighlighter());
    highlighters.register("postings", new PostingsHighlighter());
    highlighters.register("unified", new UnifiedHighlighter());
    highlighters.extractAndRegister(plugins, SearchPlugin::getHighlighters);

    return unmodifiableMap(highlighters.getRegistry());
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerSignificanceHeuristics(List<SearchPlugin> plugins) {
    registerSignificanceHeuristic(new SearchExtensionSpec<>(ChiSquare.NAME, ChiSquare::new, ChiSquare.PARSER));
    registerSignificanceHeuristic(new SearchExtensionSpec<>(GND.NAME, GND::new, GND.PARSER));
    registerSignificanceHeuristic(new SearchExtensionSpec<>(JLHScore.NAME, JLHScore::new, JLHScore::parse));
    registerSignificanceHeuristic(new SearchExtensionSpec<>(MutualInformation.NAME, MutualInformation::new, MutualInformation.PARSER));
    registerSignificanceHeuristic(new SearchExtensionSpec<>(PercentageScore.NAME, PercentageScore::new, PercentageScore::parse));
    registerSignificanceHeuristic(new SearchExtensionSpec<>(ScriptHeuristic.NAME, ScriptHeuristic::new, ScriptHeuristic::parse));

    registerFromPlugin(plugins, SearchPlugin::getSignificanceHeuristics, this::registerSignificanceHeuristic);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerMovingAverageModels(List<SearchPlugin> plugins) {
    registerMovingAverageModel(new SearchExtensionSpec<>(SimpleModel.NAME, SimpleModel::new, SimpleModel.PARSER));
    registerMovingAverageModel(new SearchExtensionSpec<>(LinearModel.NAME, LinearModel::new, LinearModel.PARSER));
    registerMovingAverageModel(new SearchExtensionSpec<>(EwmaModel.NAME, EwmaModel::new, EwmaModel.PARSER));
    registerMovingAverageModel(new SearchExtensionSpec<>(HoltLinearModel.NAME, HoltLinearModel::new, HoltLinearModel.PARSER));
    registerMovingAverageModel(new SearchExtensionSpec<>(HoltWintersModel.NAME, HoltWintersModel::new, HoltWintersModel.PARSER));

    registerFromPlugin(plugins, SearchPlugin::getMovingAverageModels, this::registerMovingAverageModel);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerFetchSubPhases(List<SearchPlugin> plugins) {
    registerFetchSubPhase(new ExplainFetchSubPhase());
    registerFetchSubPhase(new DocValueFieldsFetchSubPhase());
    registerFetchSubPhase(new ScriptFieldsFetchSubPhase());
    registerFetchSubPhase(new FetchSourceSubPhase());
    registerFetchSubPhase(new VersionFetchSubPhase());
    registerFetchSubPhase(new MatchedQueriesFetchSubPhase());
    registerFetchSubPhase(new HighlightPhase(settings, highlighters));
    registerFetchSubPhase(new ParentFieldSubFetchPhase());

    FetchPhaseConstructionContext context = new FetchPhaseConstructionContext(highlighters);
    registerFromPlugin(plugins, p -> p.getFetchSubPhases(context), this::registerFetchSubPhase);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
public void testRegisterHighlighter() {
    CustomHighlighter customHighlighter = new CustomHighlighter();
    SearchModule module = new SearchModule(Settings.EMPTY, false, singletonList(new SearchPlugin() {
        @Override
        public Map<String, Highlighter> getHighlighters() {
            return singletonMap("custom", customHighlighter);
        }
    }));

    Map<String, Highlighter> highlighters = module.getHighlighters();
    assertEquals(FastVectorHighlighter.class, highlighters.get("fvh").getClass());
    assertEquals(PlainHighlighter.class, highlighters.get("plain").getClass());
    assertEquals(PostingsHighlighter.class, highlighters.get("postings").getClass());
    assertSame(highlighters.get("custom"), customHighlighter);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
public void testRegisterAggregation() {
    SearchModule module = new SearchModule(Settings.EMPTY, false, singletonList(new SearchPlugin() {
        public List<AggregationSpec> getAggregations() {
            return singletonList(new AggregationSpec("test", TestAggregationBuilder::new, TestAggregationBuilder::fromXContent));
        }
    }));

    assertThat(
            module.getNamedXContents().stream()
                .filter(entry -> entry.categoryClass.equals(BaseAggregationBuilder.class) && entry.name.match("test"))
                .collect(toList()),
            hasSize(1));
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
public void testRegisterPipelineAggregation() {
    SearchModule module = new SearchModule(Settings.EMPTY, false, singletonList(new SearchPlugin() {
        public List<PipelineAggregationSpec> getPipelineAggregations() {
            return singletonList(new PipelineAggregationSpec("test",
                    TestPipelineAggregationBuilder::new, TestPipelineAggregator::new, TestPipelineAggregationBuilder::fromXContent));
        }
    }));

    assertThat(
            module.getNamedXContents().stream()
                .filter(entry -> entry.categoryClass.equals(BaseAggregationBuilder.class) && entry.name.match("test"))
                .collect(toList()),
            hasSize(1));
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerPipelineAggregations(List<SearchPlugin> plugins) {
    registerPipelineAggregation(new PipelineAggregationSpec(
            DerivativePipelineAggregationBuilder.NAME,
            DerivativePipelineAggregationBuilder::new,
            DerivativePipelineAggregator::new,
            DerivativePipelineAggregationBuilder::parse)
                .addResultReader(InternalDerivative::new));
    registerPipelineAggregation(new PipelineAggregationSpec(
            MaxBucketPipelineAggregationBuilder.NAME,
            MaxBucketPipelineAggregationBuilder::new,
            MaxBucketPipelineAggregator::new,
            MaxBucketPipelineAggregationBuilder.PARSER)
                // This bucket is used by many pipeline aggreations.
                .addResultReader(InternalBucketMetricValue.NAME, InternalBucketMetricValue::new));
    registerPipelineAggregation(new PipelineAggregationSpec(
            MinBucketPipelineAggregationBuilder.NAME,
            MinBucketPipelineAggregationBuilder::new,
            MinBucketPipelineAggregator::new,
            MinBucketPipelineAggregationBuilder.PARSER)
                /* Uses InternalBucketMetricValue */);
    registerPipelineAggregation(new PipelineAggregationSpec(
            AvgBucketPipelineAggregationBuilder.NAME,
            AvgBucketPipelineAggregationBuilder::new,
            AvgBucketPipelineAggregator::new,
            AvgBucketPipelineAggregationBuilder.PARSER)
                // This bucket is used by many pipeline aggreations.
                .addResultReader(InternalSimpleValue.NAME, InternalSimpleValue::new));
    registerPipelineAggregation(new PipelineAggregationSpec(
            SumBucketPipelineAggregationBuilder.NAME,
            SumBucketPipelineAggregationBuilder::new,
            SumBucketPipelineAggregator::new,
            SumBucketPipelineAggregationBuilder.PARSER)
                /* Uses InternalSimpleValue */);
    registerPipelineAggregation(new PipelineAggregationSpec(
            StatsBucketPipelineAggregationBuilder.NAME,
            StatsBucketPipelineAggregationBuilder::new,
            StatsBucketPipelineAggregator::new,
            StatsBucketPipelineAggregationBuilder.PARSER)
                .addResultReader(InternalStatsBucket::new));
    registerPipelineAggregation(new PipelineAggregationSpec(
            ExtendedStatsBucketPipelineAggregationBuilder.NAME,
            ExtendedStatsBucketPipelineAggregationBuilder::new,
            ExtendedStatsBucketPipelineAggregator::new,
            new ExtendedStatsBucketParser())
                .addResultReader(InternalExtendedStatsBucket::new));
    registerPipelineAggregation(new PipelineAggregationSpec(
            PercentilesBucketPipelineAggregationBuilder.NAME,
            PercentilesBucketPipelineAggregationBuilder::new,
            PercentilesBucketPipelineAggregator::new,
            PercentilesBucketPipelineAggregationBuilder.PARSER)
                .addResultReader(InternalPercentilesBucket::new));
    registerPipelineAggregation(new PipelineAggregationSpec(
            MovAvgPipelineAggregationBuilder.NAME,
            MovAvgPipelineAggregationBuilder::new,
            MovAvgPipelineAggregator::new,
            (n, c) -> MovAvgPipelineAggregationBuilder.parse(movingAverageModelParserRegistry, n, c))
                /* Uses InternalHistogram for buckets */);
    registerPipelineAggregation(new PipelineAggregationSpec(
            CumulativeSumPipelineAggregationBuilder.NAME,
            CumulativeSumPipelineAggregationBuilder::new,
            CumulativeSumPipelineAggregator::new,
            CumulativeSumPipelineAggregationBuilder::parse));
    registerPipelineAggregation(new PipelineAggregationSpec(
            BucketScriptPipelineAggregationBuilder.NAME,
            BucketScriptPipelineAggregationBuilder::new,
            BucketScriptPipelineAggregator::new,
            BucketScriptPipelineAggregationBuilder::parse));
    registerPipelineAggregation(new PipelineAggregationSpec(
            BucketSelectorPipelineAggregationBuilder.NAME,
            BucketSelectorPipelineAggregationBuilder::new,
            BucketSelectorPipelineAggregator::new,
            BucketSelectorPipelineAggregationBuilder::parse));
    registerPipelineAggregation(new PipelineAggregationSpec(
            SerialDiffPipelineAggregationBuilder.NAME,
            SerialDiffPipelineAggregationBuilder::new,
            SerialDiffPipelineAggregator::new,
            SerialDiffPipelineAggregationBuilder::parse));

    registerFromPlugin(plugins, SearchPlugin::getPipelineAggregations, this::registerPipelineAggregation);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerSearchExts(List<SearchPlugin> plugins) {
    registerFromPlugin(plugins, SearchPlugin::getSearchExts, this::registerSearchExt);
}
 

import org.elasticsearch.plugins.SearchPlugin; //导入依赖的package包/类
private void registerQueryParsers(List<SearchPlugin> plugins) {
    registerQuery(new QuerySpec<>(MatchQueryBuilder.NAME, MatchQueryBuilder::new, MatchQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchPhraseQueryBuilder.NAME, MatchPhraseQueryBuilder::new, MatchPhraseQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchPhrasePrefixQueryBuilder.NAME, MatchPhrasePrefixQueryBuilder::new,
            MatchPhrasePrefixQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MultiMatchQueryBuilder.NAME, MultiMatchQueryBuilder::new, MultiMatchQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(NestedQueryBuilder.NAME, NestedQueryBuilder::new, NestedQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(HasChildQueryBuilder.NAME, HasChildQueryBuilder::new, HasChildQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(HasParentQueryBuilder.NAME, HasParentQueryBuilder::new, HasParentQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(DisMaxQueryBuilder.NAME, DisMaxQueryBuilder::new, DisMaxQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(IdsQueryBuilder.NAME, IdsQueryBuilder::new, IdsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchAllQueryBuilder.NAME, MatchAllQueryBuilder::new, MatchAllQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(QueryStringQueryBuilder.NAME, QueryStringQueryBuilder::new, QueryStringQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(BoostingQueryBuilder.NAME, BoostingQueryBuilder::new, BoostingQueryBuilder::fromXContent));
    BooleanQuery.setMaxClauseCount(INDICES_MAX_CLAUSE_COUNT_SETTING.get(settings));
    registerQuery(new QuerySpec<>(BoolQueryBuilder.NAME, BoolQueryBuilder::new, BoolQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TermQueryBuilder.NAME, TermQueryBuilder::new, TermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TermsQueryBuilder.NAME, TermsQueryBuilder::new, TermsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FuzzyQueryBuilder.NAME, FuzzyQueryBuilder::new, FuzzyQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(RegexpQueryBuilder.NAME, RegexpQueryBuilder::new, RegexpQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(RangeQueryBuilder.NAME, RangeQueryBuilder::new, RangeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(PrefixQueryBuilder.NAME, PrefixQueryBuilder::new, PrefixQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(WildcardQueryBuilder.NAME, WildcardQueryBuilder::new, WildcardQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(ConstantScoreQueryBuilder.NAME, ConstantScoreQueryBuilder::new, ConstantScoreQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanTermQueryBuilder.NAME, SpanTermQueryBuilder::new, SpanTermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanNotQueryBuilder.NAME, SpanNotQueryBuilder::new, SpanNotQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanWithinQueryBuilder.NAME, SpanWithinQueryBuilder::new, SpanWithinQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanContainingQueryBuilder.NAME, SpanContainingQueryBuilder::new,
            SpanContainingQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FieldMaskingSpanQueryBuilder.NAME, FieldMaskingSpanQueryBuilder::new,
            FieldMaskingSpanQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanFirstQueryBuilder.NAME, SpanFirstQueryBuilder::new, SpanFirstQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanNearQueryBuilder.NAME, SpanNearQueryBuilder::new, SpanNearQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanOrQueryBuilder.NAME, SpanOrQueryBuilder::new, SpanOrQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MoreLikeThisQueryBuilder.NAME, MoreLikeThisQueryBuilder::new,
            MoreLikeThisQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(WrapperQueryBuilder.NAME, WrapperQueryBuilder::new, WrapperQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(CommonTermsQueryBuilder.NAME, CommonTermsQueryBuilder::new, CommonTermsQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(SpanMultiTermQueryBuilder.NAME, SpanMultiTermQueryBuilder::new, SpanMultiTermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FunctionScoreQueryBuilder.NAME, FunctionScoreQueryBuilder::new,
            FunctionScoreQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(SimpleQueryStringBuilder.NAME, SimpleQueryStringBuilder::new, SimpleQueryStringBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TypeQueryBuilder.NAME, TypeQueryBuilder::new, TypeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ScriptQueryBuilder.NAME, ScriptQueryBuilder::new, ScriptQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoDistanceQueryBuilder.NAME, GeoDistanceQueryBuilder::new, GeoDistanceQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoBoundingBoxQueryBuilder.NAME, GeoBoundingBoxQueryBuilder::new,
            GeoBoundingBoxQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoPolygonQueryBuilder.NAME, GeoPolygonQueryBuilder::new, GeoPolygonQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ExistsQueryBuilder.NAME, ExistsQueryBuilder::new, ExistsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchNoneQueryBuilder.NAME, MatchNoneQueryBuilder::new, MatchNoneQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ParentIdQueryBuilder.NAME, ParentIdQueryBuilder::new, ParentIdQueryBuilder::fromXContent));

    if (ShapesAvailability.JTS_AVAILABLE && ShapesAvailability.SPATIAL4J_AVAILABLE) {
        registerQuery(new QuerySpec<>(GeoShapeQueryBuilder.NAME, GeoShapeQueryBuilder::new, GeoShapeQueryBuilder::fromXContent));
    }

    registerFromPlugin(plugins, SearchPlugin::getQueries, this::registerQuery);
}