elasticsearch源码关于TransportSearchAction【阶段一】

1.RestController
public class RestController extends AbstractComponent implements HttpServerTransport.Dispatcher {
RestController：方法1

   @Override
    public void dispatchRequest(RestRequest request, RestChannel channel, ThreadContext threadContext) {
        try {
            tryAllHandlers(request, channel, threadContext);
        } catch (Exception e) {
        
        }
 }

RestController：方法2

   void tryAllHandlers(final RestRequest request, final RestChannel channel, final ThreadContext threadContext) throws Exception {
     // Loop through all possible handlers, attempting to dispatch the request
        Iterator<MethodHandlers> allHandlers = getAllHandlers(request);
        for (Iterator<MethodHandlers> it = allHandlers; it.hasNext(); ) {
            final Optional<RestHandler> mHandler = Optional.ofNullable(it.next()).flatMap(mh ->         mh.getHandler(request.method()));
            // 判断
            requestHandled = dispatchRequest(request, channel, client, mHandler);
            if (requestHandled) {
                break;
            }
        }
    }

RestController：方法3

   /**
     * Dispatch the request, if possible, returning true if a response was sent or false otherwise.
     */
    boolean dispatchRequest(final RestRequest request, final RestChannel channel, final NodeClient client, final Optional<RestHandler> mHandler) throws Exception  
	   try {
               final RestHandler wrappedHandler = mHandler.map(h -> handlerWrapper.apply(h)).get();
                wrappedHandler.handleRequest(request, responseChannel, client);
                requestHandled = true;
            } catch (Exception e) {
                responseChannel.sendResponse(new BytesRestResponse(responseChannel, e));
                // We "handled" the request by returning a response, even though it was an error
                requestHandled = true;
            }
		}

2.BaseRestHandler
public abstract class BaseRestHandler extends AbstractComponent implements RestHandler

   @Override //RestMainAction
    public final void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
        final RestChannelConsumer action = prepareRequest(request, client);
        action.accept(channel);
    }

**3.RestSearchAction **
public class RestSearchAction extends BaseRestHandler{

    @Override
    public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
        SearchRequest searchRequest = new SearchRequest();
         //Action具体要执行的任务
        return channel -> client.search(searchRequest, new RestStatusToXContentListener<>(channel));
}

4.AbstractClient
public abstract class AbstractClient extends AbstractComponent implements Client

   @Override
    public void search(final SearchRequest request, final ActionListener<SearchResponse> listener) {
        execute(SearchAction.INSTANCE, request, listener);
    }

    @Override
    public final <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void execute(
        Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
        listener = threadedWrapper.wrap(listener);
        doExecute(action, request, listener);
    }

**5.NodeClient **
public class NodeClient extends AbstractClient

@Override
public void doExecute(Action<Request, Response, RequestBuilder> action, Request request,ActionListener<Response> listener) {
    executeLocally(action, request, listener);
}

```java
   public <    Request extends ActionRequest,
                Response extends ActionResponse
            > Task executeLocally(GenericAction<Request, Response> action, Request request, ActionListener<Response> listener) {
        return transportAction(action).execute(request, listener);
    }

6.TransportAction
public abstract class TransportAction<Request extends ActionRequest, Response extends ActionResponse> extends AbstractComponent
//TransportAction：方法1

 public final Task execute(Request request, ActionListener<Response> listener) {
        Task task = taskManager.register("transport", actionName, request);
        if (task == null) {
            execute(null, request, listener);
        } else {
            execute(task, request, new ActionListener<Response>() {
            });
        }
        return task;
    }

//TransportAction：方法2

// 执行任务
public final void execute(Task task, Request request, ActionListener<Response> listener) {
    //验证请求
    ActionRequestValidationException validationException = request.validate();
    if (validationException != null) {
        listener.onFailure(validationException);
        return;
    }

    if (task != null && request.getShouldStoreResult()) {
        listener = new TaskResultStoringActionListener<>(taskManager, task, listener);
    }

    RequestFilterChain<Request, Response> requestFilterChain = new RequestFilterChain<>(this, logger);
    //调用Action定义的doExecute函数执行用户定义的处理
    requestFilterChain.proceed(task, actionName, request, listener);
}

// TransportAction：方法3

  @Override
  public void proceed(Task task, String actionName, Request request, ActionListener<Response> listener) {
        int i = index.getAndIncrement();
        try {
            if (i < this.action.filters.length) {
                this.action.filters[i].apply(task, actionName, request, listener, this);
            } else if (i == this.action.filters.length) {
                // 执行对应的Action
                this.action.doExecute(task, request, listener);
            } else {
                listener.onFailure(new IllegalStateException("proceed was called too many times"));
            }
        } catch (Exception e) {
        }
    }
  }

**7.TransportSearchAction **
public class TransportSearchAction extends HandledTransportAction<SearchRequest, SearchResponse>
// 执行task的查询

@Override
protected void doExecute(Task task, SearchRequest searchRequest, ActionListener<SearchResponse> listener) {
    final ClusterState clusterState = clusterService.state();
    // 省略了发送远程得任务代码
    if (searchRequest.source() == null) {
        rewriteListener.onResponse(searchRequest.source());
    } else { // 获取数据重写
        Rewriteable.rewriteAndFetch(searchRequest.source(), searchService.getRewriteContext(timeProvider::getAbsoluteStartMillis),
            rewriteListener);
    }
}

8.Rewriteable
public interface Rewriteable

  static <T extends Rewriteable<T>> void rewriteAndFetch(T original, QueryRewriteContext context, ActionListener<T> rewriteResponse) {
        rewriteAndFetch(original, context, rewriteResponse, 0);
    }

static <T extends Rewriteable<T>> void rewriteAndFetch(T original, QueryRewriteContext context, ActionListener<T>
        rewriteResponse, int iteration) {
        T builder = original;
        try {
            for (T rewrittenBuilder = builder.rewrite(context); rewrittenBuilder != builder;
                 rewrittenBuilder = builder.rewrite(context)) {
                builder = rewrittenBuilder;
                if (context.hasAsyncActions()) {
                    T finalBuilder = builder;
                    final int currentIterationNumber = iteration;
                    context.executeAsyncActions(ActionListener.wrap(n -> rewriteAndFetch(finalBuilder, context, rewriteResponse,currentIterationNumber), rewriteResponse::onFailure));
                    return;
                }
            }
            rewriteResponse.onResponse(builder);
        } catch (IOException ex) {
            rewriteResponse.onFailure(ex);
        }
    }

**返回 7.TransportSearchAction **，本地还是发送到远程
public class TransportSearchAction extends HandledTransportAction<SearchRequest, SearchResponse>
返回 TransportSearchAction方法1

   @Override
    protected void doExecute(Task task, SearchRequest searchRequest, ActionListener<SearchResponse> listener) {
         final ClusterState clusterState = clusterService.state();
            final Map<String, OriginalIndices> remoteClusterIndices = remoteClusterService.groupIndices(searchRequest.indicesOptions(),
                searchRequest.indices(), idx -> indexNameExpressionResolver.hasIndexOrAlias(idx, clusterState));
            OriginalIndices localIndices = remoteClusterIndices.remove(RemoteClusterAware.LOCAL_CLUSTER_GROUP_KEY);
             if (remoteClusterIndices.isEmpty()) {
                // 此方法
                executeSearch((SearchTask)task, timeProvider, searchRequest, localIndices, remoteClusterIndices, Collections.emptyList(),
                    (clusterName, nodeId) -> null, clusterState, Collections.emptyMap(), listener, clusterState.getNodes()
                        .getDataNodes().size());
            }
            }

返回 TransportSearchAction方法2

private void executeSearch(SearchTask task, SearchTimeProvider timeProvider, SearchRequest searchRequest, OriginalIndices localIndices, Map<String, OriginalIndices> remoteClusterIndices, List<SearchShardIterator> remoteShardIterators,BiFunction<String, String, DiscoveryNode> remoteConnections, ClusterState clusterState,
Map<String, AliasFilter> remoteAliasMap, ActionListener<SearchResponse> listener, int nodeCount) {
 // 省略indexNameExpressionResolver在这里
    final DiscoveryNodes nodes = clusterState.nodes();
    BiFunction<String, String, Transport.Connection> connectionLookup = (clusterName, nodeId) -> {
        final DiscoveryNode discoveryNode = clusterName == null ? nodes.get(nodeId) : remoteConnections.apply(clusterName, nodeId);
        if (discoveryNode == null) {
            throw new IllegalStateException("no node found for id: " + nodeId);
        } // 通过发现节点获取连接
        return searchTransportService.getConnection(clusterName, discoveryNode);
    };
    boolean preFilterSearchShards = shouldPreFilterSearchShards(searchRequest, shardIterators);
    // 异步处理，看清楚，最后有个.start()
    searchAsyncAction(task, searchRequest, shardIterators, timeProvider, connectionLookup, clusterState.version(),
        Collections.unmodifiableMap(aliasFilter), concreteIndexBoosts, listener, preFilterSearchShards).start();
}

// 获取AbstractSearchAsyncAction 对象,

   private AbstractSearchAsyncAction searchAsyncAction(SearchTask task, SearchRequest searchRequest,
                                                        GroupShardsIterator<SearchShardIterator> shardIterators,
                                                        SearchTimeProvider timeProvider,
                                                        BiFunction<String, String, Transport.Connection> connectionLookup,
                                                        long clusterStateVersion, Map<String, AliasFilter> aliasFilter,
                                                        Map<String, Float> concreteIndexBoosts,
                                                        ActionListener<SearchResponse> listener, boolean preFilter) {
        Executor executor = threadPool.executor(ThreadPool.Names.SEARCH);
            AbstractSearchAsyncAction searchAsyncAction;
            switch (searchRequest.searchType()) {
                case DFS_QUERY_THEN_FETCH:
                    searchAsyncAction = new SearchDfsQueryThenFetchAsyncAction(logger, searchTransportService, connectionLookup,aliasFilter, concreteIndexBoosts, searchPhaseController, executor, searchRequest, listener, shardIterators,timeProvider, clusterStateVersion, task);
                    break;
                case QUERY_AND_FETCH:
                case QUERY_THEN_FETCH:
                    searchAsyncAction = new SearchQueryThenFetchAsyncAction(logger, searchTransportService, connectionLookup, aliasFilter, concreteIndexBoosts, searchPhaseController, executor, searchRequest, listener, shardIterators,timeProvider, clusterStateVersion, task);
                    break;
                default:
                    throw new IllegalStateException("Unknown search type: [" + searchRequest.searchType() + "]");
            }
            return searchAsyncAction;
        }
    }

Executor executor = threadPool.executor(ThreadPool.Names.SEARCH)