elasticsearch源码query和fetch的分水岭：RequestHandlerRegistry

1.RequestHandlerRegistry

public class RequestHandlerRegistry
private final TransportRequestHandler handler;
handler$SearchTransportService
处理query 和 fetch
handler.messageReceived(request, new TransportChannelWrapper(taskManager, task, channel), task);

  public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
        final Task task = taskManager.register(channel.getChannelType(), action, request);// 创建任务
        if (task == null) {
            handler.messageReceived(request, channel);// 启动会走这里
        } else {
            boolean success = false;
            try {
                handler.messageReceived(request, new TransportChannelWrapper(taskManager, task, channel), task);
                success = true;
            } finally {
                if (success == false) {
                    taskManager.unregister(task);
                }
            }
        }
    }

2.query

2.1SearchTransportService

public class SearchTransportService extends AbstractComponent
FetchSearchResult result = searchService.executeFetchPhase(request, (SearchTask)task);

 transportService.registerRequestHandler(QUERY_ACTION_NAME, ShardSearchTransportRequest::new, ThreadPool.Names.SAME,
            new TaskAwareTransportRequestHandler<ShardSearchTransportRequest>() {
                @Override
                public void messageReceived(ShardSearchTransportRequest request, TransportChannel channel, Task task) throws Exception {
                    searchService.executeQueryPhase(request, (SearchTask) task, new ActionListener<SearchPhaseResult>() {
                        @Override
                        public void onResponse(SearchPhaseResult searchPhaseResult) {
                            try {
                                channel.sendResponse(searchPhaseResult);
                            } catch (IOException e) {
                                throw new UncheckedIOException(e);
                            }
                        }
                    });
                }
            });

2.2SearchService

public class SearchService extends AbstractLifecycleComponent implements IndexEventListener
executeQueryPhase[重点]
executeQueryPhase(request, task);
loadOrExecuteQueryPhase(request, context);

 SearchPhaseResult executeQueryPhase(ShardSearchRequest request, SearchTask task) throws IOException {
        if (request instanceof ShardSearchTransportRequest) {
            ShardSearchTransportRequest shardSearchTransportRequest = (ShardSearchTransportRequest) request;
            if(!Objects.equals(shardSearchTransportRequest.shardId().getIndexName(),".kibana")){
                System.out.println("SearchService#executeQueryPhase");
            }
        }
        final SearchContext context = createAndPutContext(request); // 转成luence
        final SearchOperationListener operationListener = context.indexShard().getSearchOperationListener();
        context.incRef();
        boolean queryPhaseSuccess = false;
        try {
            context.setTask(task);
            operationListener.onPreQueryPhase(context);
            long time = System.nanoTime();
            contextProcessing(context);
            // 节点查询缓存
            loadOrExecuteQueryPhase(request, context);

            if (context.queryResult().hasSearchContext() == false && context.scrollContext() == null) {
                freeContext(context.id());
            } else {
                contextProcessedSuccessfully(context);
            }
            final long afterQueryTime = System.nanoTime();
            queryPhaseSuccess = true;
            operationListener.onQueryPhase(context, afterQueryTime - time);
            if (request.numberOfShards() == 1) {
                return executeFetchPhase(context, operationListener, afterQueryTime);
            }
            return context.queryResult();
        } catch (Exception e) {
        } finally {
            cleanContext(context);
        }
    }

private final QueryPhase queryPhase;
queryPhase.execute(context)

 private void loadOrExecuteQueryPhase(final ShardSearchRequest request, final SearchContext context) throws Exception {

        final boolean canCache = indicesService.canCache(request, context);
        context.getQueryShardContext().freezeContext();
        if (canCache) {
            System.out.println("NodeQueryCache【节点查询缓存】尝试从缓存中加载查询结果，如果缓存无法使用，则直接执行查询阶段");
            indicesService.loadIntoContext(request, context, queryPhase);
        } else {
            queryPhase.execute(context);
        }
    }

3.fetch

3.1SearchTransportService

public class SearchTransportService extends AbstractComponent
FetchSearchResult result = searchService.executeFetchPhase(request, (SearchTask)task);

      transportService.registerRequestHandler(FETCH_ID_ACTION_NAME, ShardFetchSearchRequest::new, ThreadPool.Names.SEARCH,
            new TaskAwareTransportRequestHandler<ShardFetchSearchRequest>() {
                @Override
                public void messageReceived(ShardFetchSearchRequest request, TransportChannel channel, Task task) throws Exception {
                    FetchSearchResult result = searchService.executeFetchPhase(request, (SearchTask)task);
                    channel.sendResponse(result);
                }
            });

3.2SearchService

public class SearchService extends AbstractLifecycleComponent implements IndexEventListener
executeFetchPhase[重点]
private final FetchPhase fetchPhase;
fetchPhase.execute(context);

 public FetchSearchResult executeFetchPhase(ShardFetchRequest request, SearchTask task) {
        final SearchContext context = findContext(request.id(), request);
        final SearchOperationListener operationListener = context.indexShard().getSearchOperationListener();
        context.incRef();
        try {
            context.setTask(task);
            contextProcessing(context);
            if (request.lastEmittedDoc() != null) {
                context.scrollContext().lastEmittedDoc = request.lastEmittedDoc();
            }
            context.docIdsToLoad(request.docIds(), 0, request.docIdsSize());
            operationListener.onPreFetchPhase(context);
            long time = System.nanoTime();
            fetchPhase.execute(context);
            if (fetchPhaseShouldFreeContext(context)) {
                freeContext(request.id());
            } else {
                contextProcessedSuccessfully(context);
            }
            operationListener.onFetchPhase(context, System.nanoTime() - time);
            return context.fetchResult();
        } catch (Exception e) {
            operationListener.onFailedFetchPhase(context);
            logger.trace("Fetch phase failed", e);
            processFailure(context, e);
            throw ExceptionsHelper.convertToRuntime(e);
        } finally {
            cleanContext(context);
        }
    }