a  b  z
a  c  y
b  x  a
b  x  b
z  a  a

EventLoopGroup group=new NioEventLoopGroup();
try{
    Bootstrap b=new Bootstrap();
    b.group(group)
            .channel(NioSocketChannel.class)
            .remoteAddress(new InetSocketAddress(host,port))
            .handler(new ChannelInitializer<SocketChannel>() {

                protected void initChannel(SocketChannel ch) throws Exception {
                    
                    ch.pipeline().addLast(new EchoClientHandler());
                }
            });
    ChannelFuture f=b.connect().sync();
    f.channel().closeFuture().sync();
}finally {
    group.shutdownGracefully();
}

//根据url调用不同的handler来处理。
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
                //根据request找对应的HandlerExecutionChain
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
                //mappedHandler是Chain，里面有handler和interceptor,从handler中得到handlerAdapter.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				//chain中的所有前处理进行处理。
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
                //用HandlerAdapter处理请求，得到的是ModelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
                //调用postHandler进行处理。
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
            //有异常依然会执行afterCOmpletion
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
            //Interceptor中的afterCompletion方法
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        //抽象方法，在子类中实现。被欢迎页和AbstractUrlHandlerMapping实现了。
		Object handler = getHandlerInternal(request);
		if (handler == null) {
            //用默认的handler
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
        //反射调用从ApplicationContext中获得handler.
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}
		//从handler中得到HandlerExecutionChain;
		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
		………………………………………………

		if (CorsUtils.isCorsRequest(request)) {
			CorsConfiguration globalConfig = this.corsConfigurationSource.getCorsConfiguration(request);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}

		return executionChain;
	}


//Interceptorlist 是在这里被放进去的。因为url可能对应多个Interceptro，所以这里不用找最佳匹配。
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
    //如果handler是HandlerExecutionChain的子类，直接转换，不是的话放到Chain中的Handler变量中
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
		
		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
    //向HandlerExecutionChain添加拦截器集合。
    //this.adaptedInterceptors是在初始化的时候获得，有所有的
    //如果是MappedInterceptor,需要将url和设置的过滤条件对比。
		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
				//pathMatcher工具类。字符串路径匹配。
                if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}
		return chain;
	}

	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
        //查找handler
		Object handler = lookupHandler(lookupPath, request);
        //没有对应的handler
		if (handler == null) {
			// We need to care for the default handler directly, since we need to
			// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
			Object rawHandler = null;
			if ("/".equals(lookupPath)) {
                //rootHandler用来处理"/"
				rawHandler = getRootHandler();
			}
			if (rawHandler == null) {
                //默认handler
				rawHandler = getDefaultHandler();
			}
            
			if (rawHandler != null) {
				// Bean name or resolved handler?
				if (rawHandler instanceof String) {
					String handlerName = (String) rawHandler;
                    //应该是根据名字去找handler.
					rawHandler = obtainApplicationContext().getBean(handlerName);
				}
                //检验是否匹配。
				validateHandler(rawHandler, request);
                //注册拦截器。
				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
			}
		}
		return handler;
	}
-------------------------------------
//查找Handler
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
		// Direct match?
    //直接从map中找
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			// Bean name or resolved handler?
            //如果是beanname，容器中获取
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = obtainApplicationContext().getBean(handlerName);
			}
            //验证
			validateHandler(handler, request);
            //拦截器
			return buildPathExposingHandler(handler, urlPath, urlPath, null);
		}

		// Pattern match?
    //模式匹配
		List<String> matchingPatterns = new ArrayList<>();
		for (String registeredPattern : this.handlerMap.keySet()) {
            //工具包中的matcher,进行匹配。matcher.match(Pattern,path）
			if (getPathMatcher().match(registeredPattern, urlPath)) {
                //先把满足的加到list中，因为可能有多个。
				matchingPatterns.add(registeredPattern);
			}
            //要不要考虑末尾的斜杠
			else if (useTrailingSlashMatch()) {
                //
				if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
					matchingPatterns.add(registeredPattern +"/");
				}
			}
		}
		//从list中找出最匹配的。
		String bestMatch = null;
    //自定义比较器，比较器的具体实现在AntPathMatcher中
		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
		if (!matchingPatterns.isEmpty()) {
            //排序
			matchingPatterns.sort(patternComparator);
            
			if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
				logger.trace("Matching patterns " + matchingPatterns);
			}
            //获取第一个
			bestMatch = matchingPatterns.get(0);
		}
    //存在最佳匹配
		if (bestMatch != null) {
			handler = this.handlerMap.get(bestMatch);
            //map中没有对应的handler
			if (handler == null) {
                
				if (bestMatch.endsWith("/")) {
					handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
				}
				if (handler == null) {
                    //抛异常
					throw new IllegalStateException(
							"Could not find handler for best pattern match [" + bestMatch + "]");
				}
			}
			// Bean name or resolved handler?
            //多次出现了的语句。map中放的有的是String，（猜测：第一次用，还未初始化？？）。
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = obtainApplicationContext().getBean(handlerName);
			}
            //检测
			validateHandler(handler, request);
			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);

			// There might be multiple 'best patterns', let's make sure we have the correct URI template variables
			// for all of them
            //可能有多个最佳匹配。
			Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
			for (String matchingPattern : matchingPatterns) {
				if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
					Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
					Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
					uriTemplateVariables.putAll(decodedVars);
				}
			}
			return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
		}

		// No handler found...
		return null;
	}
-------------
    //用找到的handler构建一个HandlerExecutionChain,并注册两个两个拦截器PathExposingHandlerInterceptor，UriTemplateVariablesHandlerInterceptor
    
	protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
			String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) {

		HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
		chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
		if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
			chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
		}
		return chain;
	}

//部分函数	
protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
		Assert.notNull(urlPath, "URL path must not be null");
		Assert.notNull(handler, "Handler object must not be null");
		Object resolvedHandler = handler;

		// Eagerly resolve handler if referencing singleton via name.
    //非懒加载
		if (!this.lazyInitHandlers && handler instanceof String) {
			String handlerName = (String) handler;
			ApplicationContext applicationContext = obtainApplicationContext();
			if (applicationContext.isSingleton(handlerName)) {
				resolvedHandler = applicationContext.getBean(handlerName);
			}
		}
    		Object mappedHandler = this.handlerMap.get(urlPath);
		if (mappedHandler != null) {
            //已经有了
			if (mappedHandler != resolvedHandler) {
				throw new IllegalStateException(
						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
						"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
			}
		}
		else {
            //“/”注册的是rootHandler
			if (urlPath.equals("/")) 
				setRootHandler(resolvedHandler);
			}
            //  "/*"注册默认handler
			else if (urlPath.equals("/*")) {
				setDefaultHandler(resolvedHandler);
			}
			else {
                //加进去
				this.handlerMap.put(urlPath, resolvedHandler);
				}
			}
		}
	}

private final Object handler;//HandlerMethod

@Nullable
private HandlerInterceptor[] interceptors;

@Nullable
private List<HandlerInterceptor> interceptorList;//存在这里

private int interceptorIndex = -1;

//责任链，返回false，说明不用再往下继续了。之后的controller和interceptor都不用再执行了。直接执行afterCompletion	
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					//直接执行after了。
                    triggerAfterCompletion(request, response, null);
                    
					return false;
				}
                //最后一个interceptor的位置
				this.interceptorIndex = i;
			}
		}
		return true;
	}

	/**
	 * Apply postHandle methods of registered interceptors.
	 */
	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				interceptor.postHandle(request, response, this.handler, mv);
			}
		}
	}

	/**
	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
	 * Will just invoke afterCompletion for all interceptors whose preHandle invocation
	 * has successfully completed and returned true.
	 */
	void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = this.interceptorIndex; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				try {
					interceptor.afterCompletion(request, response, this.handler, ex);
				}
				catch (Throwable ex2) {
					logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
				}
			}
		}
	}

public int maxProfit(int[] prices) {
    // corner case
    if(prices == null || prices.length == 0) return 0;
    
    int m = 2;
    int n = prices.length; 
    int[][] DP = new int[m + 1][n];
    for(int i = 0; i < m + 1; i++){
        for(int j = 0; j < n; j++){
            if(i == 0 || j == 0) DP[i][j] = 0;
            else{
                for(int k = 0; k < j; k++){
                    int prev = k == 0 ? 0: DP[i - 1][k - 1];
                    DP[i][j] = Math.max(DP[i][j - 1], prev + prices[j] - prices[k]);
                }
            }
        }   
    }	
        
    return DP[m][n - 1];	
}

public void preOrder(Node node){
    LinkedList<Node> list=new LinkedList<>();
    Node p=node;
    
    while(p!=null||list.size()!=0){
        if(p!=null){
            System.out.print(p.val);//对节点进行处理
            list.push(p);
            p=p.left;
        }else{//p节点为空，说明左子树走到底了，出栈，处理右节点。
            Node node=list.pop;
            p=node.right;
        }
    }
}

if(root==null)return null;
        int numNow=1;
        int numNext=0;

        LinkedList<Node> queue=new LinkedList<>();
        queue.offer(root);
        while(queue.size()!=0){
            Node node=queue.poll();
            numNow--;
            if(node.left!=null){
                queue.offer(node.left);
                numNext++;
            }
            if(node.right!=null){
                queue.offer(node.right);
                numNext+=2;
            }
            if(numNow==0){
                numNow=numNext;
                numNext=0;
                //对节点进行处理。
            }else{
                //对节点进行处理
            }
        }
        return root;