class IOStream(object):                    def read_until(self, delimiter, callback):        """Call callback when we read the given delimiter."""        assert not self._read_callback, "Already reading"        #终止界定 \r\n\r\n        self._read_delimiter = delimiter        #回调函数，即：HTTPConnection的 _on_headers 方法        self._read_callback = stack_context.wrap(callback)        while True:            #代码概述：            #先从socket中读取信息并保存到buffer中            #然后再读取buffer中的数据，以其为参数执行回调函数（HTTPConnection的 _on_headers 方法）            #buffer其实是一个线程安装的双端队列collections.deque                       #从buffer中读取数据，并执行回调函数。            #注意：首次执行时buffer中没有数据            if self._read_from_buffer():                return            self._check_closed()            #从socket中读取信息到buffer（线程安全的一个双向消息队列）            if self._read_to_buffer() == 0:                break                        self._add_io_state(self.io_loop.READ)

class IOStream(object):    def _read_to_buffer(self):        #省略部分代码        chunk = self._read_from_socket()        self._read_buffer.append(chunk)        return len(chunk)            def _read_from_socket(self):        #socket对象的recv函数接收数据                #read_chunk_size在构造函数中默认设置为：4096        chunk = self.socket.recv(self.read_chunk_size)        if not chunk:            self.close()            return None        return chunk

class IOStream(object):    def _read_from_buffer(self):        """Attempts to complete the currently-pending read from the buffer.        Returns True if the read was completed.        """        #构造函数中默认设置为None        if self._read_bytes:                        if self._read_buffer_size() >= self._read_bytes:                num_bytes = self._read_bytes                callback = self._read_callback                self._read_callback = None                self._read_bytes = None                self._run_callback(callback, self._consume(num_bytes))                return True        #_read_delimiter的值为 \r\n\r\n        elif self._read_delimiter:            #buffer列表首元素合并，合并详细见_merge_prefix函数            _merge_prefix(self._read_buffer, sys.maxint)            #获取 \r\n\r\n 所在 buffer 首元素的位置索引            loc = self._read_buffer[0].find(self._read_delimiter)                        if loc != -1:                #如果在请求中找到了 \r\n\r\n                                #self._read_callback 是HTTPConnection对象的 _on_headers 方法                callback = self._read_callback                delimiter_len = len(self._read_delimiter) #获取  \r\n\r\n 的长度                self._read_callback = None                self._read_delimiter = None                #============ 执行HTTPConnection对象的 _on_headers 方法 =============                #self._consume(loc + delimiter_len)用来获取 buffer 的首元素（请求的信息其实就被封装到了buffer的首个元素中）                self._run_callback(callback,self._consume(loc + delimiter_len))                return True        return False

class HTTPRequest(object):    def __init__(self, method, uri, version="HTTP/1.0", headers=None,                 body=None, remote_ip=None, protocol=None, host=None,                 files=None, connection=None):        self.method = method        self.uri = uri        self.version = version        self.headers = headers or httputil.HTTPHeaders()        self.body = body or ""        if connection and connection.xheaders:            # Squid uses X-Forwarded-For, others use X-Real-Ip            self.remote_ip = self.headers.get(                "X-Real-Ip", self.headers.get("X-Forwarded-For", remote_ip))            # AWS uses X-Forwarded-Proto            self.protocol = self.headers.get(                "X-Scheme", self.headers.get("X-Forwarded-Proto", protocol))            if self.protocol not in ("http", "https"):                self.protocol = "http"        else:            self.remote_ip = remote_ip            if protocol:                self.protocol = protocol            elif connection and isinstance(connection.stream,                                            iostream.SSLIOStream):                self.protocol = "https"            else:                self.protocol = "http"        self.host = host or self.headers.get("Host") or "127.0.0.1"        self.files = files or {}        self.connection = connection        self._start_time = time.time()        self._finish_time = None        scheme, netloc, path, query, fragment = urlparse.urlsplit(uri)        self.path = path        self.query = query        arguments = cgi.parse_qs(query)        self.arguments = {}        for name, values in arguments.iteritems():            values = [v for v in values if v]            if values: self.arguments[name] = values

class Application(object):     def __call__(self, request):        """Called by HTTPServer to execute the request."""        transforms = [t(request) for t in self.transforms]        handler = None        args = []        kwargs = {}        #根据请求的目标主机，匹配主机模版对应的正则表达式和Handlers        handlers = self._get_host_handlers(request)        if not handlers:            handler = RedirectHandler(                self, request, url="http://" + self.default_host + "/")        else:            for spec in handlers:                match = spec.regex.match(request.path)                if match:                    # None-safe wrapper around url_unescape to handle                    # unmatched optional groups correctly                    def unquote(s):                        if s is None: return s                        return escape.url_unescape(s, encoding=None)                    handler = spec.handler_class(self, request, **spec.kwargs) #创建RquestHandler对象                    # Pass matched groups to the handler.  Since                    # match.groups() includes both named and unnamed groups,                    # we want to use either groups or groupdict but not both.                    # Note that args are passed as bytes so the handler can                    # decide what encoding to use.                    kwargs = dict((k, unquote(v))                                  for (k, v) in match.groupdict().iteritems())                    if kwargs:                        args = []                    else:                        args = [unquote(s) for s in match.groups()]                    break            if not handler:                handler = ErrorHandler(self, request, status_code=404)         # In debug mode, re-compile templates and reload static files on every        # request so you don‘t need to restart to see changes        if self.settings.get("debug"):            if getattr(RequestHandler, "_templates", None):                for loader in RequestHandler._templates.values():                    loader.reset()            RequestHandler._static_hashes = {}        #＝＝＝＝ 执行RequestHandler的_execute方法 ＝＝＝＝        handler._execute(transforms, *args, **kwargs)        return handler

class Application(object):    def _get_host_handlers(self, request):        #将请求的host和handlers中的主机模型进行匹配        host = request.host.lower().split(‘:‘)[0]        for pattern, handlers in self.handlers:            if pattern.match(host):                return handlers        # Look for default host if not behind load balancer (for debugging)        if "X-Real-Ip" not in request.headers:            for pattern, handlers in self.handlers:                if pattern.match(self.default_host):                    return handlers        return None

class RequestHandler(object):    SUPPORTED_METHODS = ("GET", "HEAD", "POST", "DELETE", "PUT", "OPTIONS")     def __init__(self, application, request, **kwargs):        self.application = application        self.request = request        self._headers_written = False        self._finished = False        self._auto_finish = True        self._transforms = None  # will be set in _execute        #获取在application中设置的 ui_modules 和ui_method        self.ui = _O((n, self._ui_method(m)) for n, m in                     application.ui_methods.iteritems())        self.ui["modules"] = _O((n, self._ui_module(n, m)) for n, m in                                application.ui_modules.iteritems())        self.clear() #设置服务器、内容类型编码和连接        # Check since connection is not available in WSGI        #检查连接是否可用，应该是长短连接有关。        if hasattr(self.request, "connection"):            self.request.connection.stream.set_close_callback(self.on_connection_close)        self.initialize(**kwargs)     def initialize(self):        pass    def clear(self):        """Resets all headers and content for this response."""        self._headers = {            "Server": "TornadoServer/%s" % tornado.version,            "Content-Type": "text/html; charset=UTF-8",        }        if not self.request.supports_http_1_1():            if self.request.headers.get("Connection") == "Keep-Alive":                self.set_header("Connection", "Keep-Alive")        self._write_buffer = []        self._status_code = 200

class RequestHandler(object):     def _execute(self, transforms, *args, **kwargs):        """Executes this request with the given output transforms."""        self._transforms = transforms        with stack_context.ExceptionStackContext(            self._stack_context_handle_exception):            if self.request.method not in self.SUPPORTED_METHODS:                raise HTTPError(405)            # If XSRF cookies are turned on, reject form submissions without            # the proper cookie            if self.request.method not in ("GET", "HEAD") and                self.application.settings.get("xsrf_cookies"):                self.check_xsrf_cookie()            self.prepare()            if not self._finished:                #通过反射的方法，执行 RequestHandler 派生类的的 get、post、put方法                getattr(self, self.request.method.lower())(*args, **kwargs)                if self._auto_finish and not self._finished:                    self.finish()

class RequestHandler(object):    def write(self, chunk):        assert not self._finished        if isinstance(chunk, dict):            chunk = escape.json_encode(chunk)            self.set_header("Content-Type", "text/javascript; charset=UTF-8")        chunk = _utf8(chunk)        self._write_buffer.append(chunk)