application = tornado.web.Application([
    (r"/", MainHandler),
])

类application的作用：

A collection of request handlers that make up a web application.把许多请求处理器组合起来以实现web应用

###################################################
if transforms is None:
    self.transforms = []
    if settings.get("gzip"):
        self.transforms.append(GZipContentEncoding)
    self.transforms.append(ChunkedTransferEncoding)
else:
    self.transforms = transforms
###################################################

这里面主要包含了三个类:
    GZipContentEncoding(OutputTransform)        # gzip内容编码
    ChunkedTransferEncoding(OutputTransform)    # 分块传输编码
    OutputTransform()                           # 是上面两个类的父类
        解释：A transform modifies the result of an HTTP request(e.g., GZip encoding)
        主要是用来对一个http请求的结果进行转换的，可以是gzip压缩

self.handlers = []
self.named_handlers = {}
self.default_host = default_host
self.settings = settings
self.ui_modules = {}
self.ui_methods = {}
self._wsgi = wsgi

self._load_ui_modules(settings.get("ui_modules", {}))
self._load_ui_methods(settings.get("ui_methods", {}))

# 把传入的模块modules全部变成字典的形式封装到ui_modules变量中
def _load_ui_modules(self, modules):
    # types是一个.py文件，他主要是为了定义一些简单的函数，类似于内置函数可以直接拿来使用的
    # types里面关于ModuleType的描述是：ModuleType = type(sys) 也就是sys的类型<type ‘module‘>
    # 这里其实就是为了判断传出的modules是不是一个模块的类型，如果是就把它变成一个字典形式递归判断
    if type(modules) is types.ModuleType:
        self._load_ui_modules(dict((n, getattr(modules, n))
                                   for n in dir(modules)))
    #判断modules是不是一个列表，如果是列表，就把列表里面的元素重新代入方法中进行调用                             
    elif isinstance(modules, list):
        for m in modules: self._load_ui_modules(m)
    else:
        # 此处是一个断言机制，也就是说已经肯定了modules一定是一个字典形式的样子
        assert isinstance(modules, dict)
        # 因为modules是一个字典，所以就把键和值分别赋值给name和cls，然后判断每一个键的值cls是不是UIModule的一个子类，如果是
        # 就把这个值添加到前面封装的一个变量中self.ui_modules[name] = cls
        for name, cls in modules.iteritems():
            try:
                if issubclass(cls, UIModule):
                    self.ui_modules[name] = cls
            except TypeError:
                pass

# 定义了一系列的变量如handlers，path，static_url_prefix   
# 当settings中包含了static_path这个键的时候，才会去定义这些变量         
if self.settings.get("static_path"):
    path = self.settings["static_path"]
    handlers = list(handlers or [])
    static_url_prefix = settings.get("static_url_prefix",
                                     "/static/")
    handlers = [
        (re.escape(static_url_prefix) + r"(.*)", StaticFileHandler,
         dict(path=path)),
        (r"/(favicon\.ico)", StaticFileHandler, dict(path=path)),
        (r"/(robots\.txt)", StaticFileHandler, dict(path=path)),
    ] + handlers  

if handlers: self.add_handlers(".*$", handlers)

def add_handlers(self, host_pattern, host_handlers):
    # 添加给定的处理器到系统的处理器列表中，注意主机模式是按顺序进行处理的，直到第一个被匹配到的这就意味着所有给定主机的处理器必须被添加到处理器中
    """Appends the given handlers to our handler list.

    Note that host patterns are processed sequentially in the
    order they were added, and only the first matching pattern is
    used.  This means that all handlers for a given host must be
    added in a single add_handlers call.
    """
    # 如果给定主机模式不是以"$"结尾的，就添加$到结尾
    if not host_pattern.endswith("$"):
        host_pattern += "$"
    handlers = []
    # The handlers with the wildcard host_pattern are a special
    # case - they‘re added in the constructor but should have lower
    # precedence than the more-precise handlers added later.
    # If a wildcard handler group exists, it should always be last
    # in the list, so insert new groups just before it.
    # 带有通配符的handlers是一个特殊情况，他们本来在构造方法就已经被添加了，但是他们的优先级却低于一些重要的处理器，因此应该在之后被添加
    # 所以如果带有通配符的处理器组存在，就应该把他们放在一个列表的最后面，否则就插在他的前面
    # 下面这段代码就是这个意思，如果他的pattern是‘.*$‘开头的，代表他是没有通配符的，所以就把他插入最后一个的前面，否则有通配符的就直接添加到后面
    if self.handlers and self.handlers[-1][0].pattern == ‘.*$‘:
        self.handlers.insert(-1, (re.compile(host_pattern), handlers))
    else:
        self.handlers.append((re.compile(host_pattern), handlers))
    # 这个是对我们传入的host_handlers进行一个解析，把第一个采纳数给pattern，第二个给handler如果有三个，就赋值给kwargs如果没有第三个kwargs=={}
    for spec in host_handlers:
        if type(spec) is type(()):
            assert len(spec) in (2, 3)
            pattern = spec[0]
            handler = spec[1]
            if len(spec) == 3:
                kwargs = spec[2]
            else:
                kwargs = {}
            # 赋值完成之后就把这些参数封装到类URLSpec中
            spec = URLSpec(pattern, handler, kwargs)
        # 类URLSpec创建了对象spec之后，会重新给self.named_handlers添加一个handlers的键值对，如果键值本身就存在，就会往日志里面写入警告信息
        handlers.append(spec)
        if spec.name:
            if spec.name in self.named_handlers:
                logging.warning(
                    "Multiple handlers named %s; replacing previous value",
                    spec.name)
            self.named_handlers[spec.name] = spec

class URLSpec(object):
    # 这个类的作用主要是在url和handlers之间做一个特定的映射，主要的体现应该就是前面的变量name_handlers
    # 前面的赋值语句：self.named_handlers[spec.name] = spec
    
    """Specifies mappings between URLs and handlers."""
    def __init__(self, pattern, handler_class, kwargs={}, name=None):
        """Creates a URLSpec.

        Parameters:
        # 传递进来得主机模式
        pattern: Regular expression to be matched.  Any groups in the regex
            will be passed in to the handler‘s get/post/etc methods as
            arguments.
            
        # 这个不是特别懂，但是意思是RequestHandler的子类将被调用
        handler_class: RequestHandler subclass to be invoked.
        kwargs (optional): A dictionary of additional arguments to be passed
            to the handler‘s constructor.
            
        # 这个handler的名字，是一个额外的参数
        name (optional): A name for this handler.  Used by
            Application.reverse_url.
        """
        if not pattern.endswith(‘$‘):
            pattern += ‘$‘
        self.regex = re.compile(pattern)
        self.handler_class = handler_class
        self.kwargs = kwargs
        self.name = name
        self._path, self._group_count = self._find_groups()

def _find_groups(self):
    # 就是给特定的url返回一个元组，下面的就是例子，括号里面的内容都会转换成%s,后面的2代表小括号括号的个数
    """Returns a tuple (reverse string, group count) for a url.

    For example: Given the url pattern /([0-9]{4})/([a-z-]+)/, this method
    would return (‘/%s/%s/‘, 2).
    """
    # 得到pattern的字符串形式，去掉开头的^和结尾的$符号
    pattern = self.regex.pattern
    if pattern.startswith(‘^‘):
        pattern = pattern[1:]
    if pattern.endswith(‘$‘):
        pattern = pattern[:-1]

    # 如果正常情况下regex.groups的值应该是等于count的，除非特别复杂的url，会返回两个none
    if self.regex.groups != pattern.count(‘(‘):
        # The pattern is too complicated for our simplistic matching,
        # so we can‘t support reversing it.
        return (None, None)
        
    # 这个就是把url转换成元组的具体代码,代码实现的是把括号里面的内容全部转换成%s
    pieces = []
    for fragment in pattern.split(‘(‘):
        if ‘)‘ in fragment:
            paren_loc = fragment.index(‘)‘)
            if paren_loc >= 0:
                pieces.append(‘%s‘ + fragment[paren_loc + 1:])
        else:
            pieces.append(fragment)
    
    # 把picese重新拼接成字符，返回回去
    return (‘‘.join(pieces), self.regex.groups)

# 自动的去重载改变的模块，这个调用的是autorelaad模块实现的    
# Automatically reload modified modules
if self.settings.get("debug") and not wsgi:
    import autoreload
    autoreload.start()