flask源码笔记：三，app.py模块（2）——Flask的基类_PackageBoundObject

Flask工厂类有1700度行代码，需要我们仔细研读
首先是类描述
class Flask(_PackageBoundObject):
    """The flask object implements a WSGI application and acts as the central
        object.  It is passed the name of the module or package of the
        application.  Once it is created it will act as a central registry for
        the view functions, the URL rules, template configuration and much more.


        The name of the package is used to resolve resources from inside the
        package or the folder the module is contained in depending on if the
        package parameter resolves to an actual python package (a folder with
        an `__init__.py` file inside) or a standard module (just a `.py` file).


        For more information about resource loading, see :func:`open_resource`.


        Usually you create a :class:`Flask` instance in your main module or
        in the `__init__.py` file of your package like this::


            from flask import Flask
            app = Flask(__name__)


        .. admonition:: About the First Parameter


            The idea of the first parameter is to give Flask an idea what
            belongs to your application.  This name is used to find resources
            on the file system, can be used by extensions to improve debugging
            information and a lot more.


            So it's important what you provide there.  If you are using a single
            module, `__name__` is always the correct value.  If you however are
            using a package, it's usually recommended to hardcode the name of
            your package there.


            For example if your application is defined in `yourapplication/app.py`
            you should create it with one of the two versions below::


                app = Flask('yourapplication')
                app = Flask(__name__.split('.')[0])


            Why is that?  The application will work even with `__name__`, thanks
            to how resources are looked up.  However it will make debugging more
            painful.  Certain extensions can make assumptions based on the
            import name of your application.  For example the Flask-SQLAlchemy
            extension will look for the code in your application that triggered
            an SQL query in debug mode.  If the import name is not properly set
            up, that debugging information is lost.  (For example it would only
            pick up SQL queries in `yourapplication.app` and not
            `yourapplication.views.frontend`)


        .. versionadded:: 0.7
           The `static_url_path`, `static_folder`, and `template_folder`
           parameters were added.


        .. versionadded:: 0.8
           The `instance_path` and `instance_relative_config` parameters were
           added.


    :param import_name: the name of the application package
    :param static_url_path: can be used to specify a different path for the
                            static files on the web.  Defaults to the name
                            of the `static_folder` folder.
    :param static_folder: the folder with static files that should be served
                          at `static_url_path`.  Defaults to the ``'static'``
                          folder in the root path of the application.
    :param template_folder: the folder that contains the templates that should
                            be used by the application.  Defaults to
                            ``'templates'`` folder in the root path of the
                            application.
    :param instance_path: An alternative instance path for the application.
                          By default the folder ``'instance'`` next to the
                          package or module is assumed to be the instance
                          path.
    :param instance_relative_config: if set to `True` relative filenames
                                     for loading the config are assumed to
                                     be relative to the instance path instead
                                     of the application root.
    """
首先是参数介绍：
import_name：必要参数，应用的名称，一般使用方法：Flask(__name__)
static_path:弃用，用static_url_path替代
static_url_path:静态资源的访问url设置，默认是/static
static_folder:静态资源的文件目录，默认是static
template_folder:html模板的文件目录
instance_path:假如实例的文件目录位置不在root_path，那么它的位置就可以在这里设置
instance_relative_config:假如确定要使用instance_path，那么本参数就设为True


接下来是基类_PackageBoundObject，该类位于flask/helpers.py 729行
class _PackageBoundObject(object):


    def __init__(self, import_name, template_folder=None):
        #: The name of the package or module.  Do not change this once
        #: it was set by the constructor.
        self.import_name = import_name     #设定应用的名称


        #: location of the templates.  `None` if templates should not be
        #: exposed.
        self.template_folder = template_folder    #设定html模板目录


        #: Where is the app root located?
        self.root_path = get_root_path(self.import_name)   #获取应用目录的绝对路径


        self._static_folder = None
        self._static_url_path = None


    def _get_static_folder(self):
        if self._static_folder is not None:
            return os.path.join(self.root_path, self._static_folder)
    def _set_static_folder(self, value):
        self._static_folder = value
    static_folder = property(_get_static_folder, _set_static_folder)
    del _get_static_folder, _set_static_folder
#以上几行，以property装饰器的方式，定义了属性static_folder——静态资源目录


    def _get_static_url_path(self):
        if self._static_url_path is None:
            if self.static_folder is None:
                return None
            return '/' + os.path.basename(self.static_folder)
        return self._static_url_path
    def _set_static_url_path(self, value):
        self._static_url_path = value
    static_url_path = property(_get_static_url_path, _set_static_url_path)
    del _get_static_url_path, _set_static_url_path
#以上几行，以property装饰器的方式，定义了属性static_url_path——静态资源访问URL


    @property
    def has_static_folder(self):
        """This is `True` if the package bound object's container has a
        folder named ``'static'``.


        .. versionadded:: 0.5
        """
        return self.static_folder is not None
#检查是否已设置static_folder


    @locked_cached_property
    def jinja_loader(self):
        """The Jinja loader for this package bound object.


        .. versionadded:: 0.5
        """
        if self.template_folder is not None:
            return FileSystemLoader(os.path.join(self.root_path,
                                                 self.template_folder))
#运用装饰器locked_cached_property来实现一个并发线程安全的且缓存的函数，返回值是jinja的文件系统类


    def get_send_file_max_age(self, filename):
        """Provides default cache_timeout for the :func:`send_file` functions.


        By default, this function returns ``SEND_FILE_MAX_AGE_DEFAULT`` from
        the configuration of :data:`~flask.current_app`.


        Static file functions such as :func:`send_from_directory` use this
        function, and :func:`send_file` calls this function on
        :data:`~flask.current_app` when the given cache_timeout is `None`. If a
        cache_timeout is given in :func:`send_file`, that timeout is used;
        otherwise, this method is called.


        This allows subclasses to change the behavior when sending files based
        on the filename.  For example, to set the cache timeout for .js files
        to 60 seconds::


            class MyFlask(flask.Flask):
                def get_send_file_max_age(self, name):
                    if name.lower().endswith('.js'):
                        return 60
                    return flask.Flask.get_send_file_max_age(self, name)


        .. versionadded:: 0.9
        """
        return current_app.config['SEND_FILE_MAX_AGE_DEFAULT']
#获取文件的缓存时间（秒），一般对静态文件使用缓存


    def send_static_file(self, filename):
        """Function used internally to send static files from the static
        folder to the browser.


        .. versionadded:: 0.5
        """
        if not self.has_static_folder:
            raise RuntimeError('No static folder for this object')
        # Ensure get_send_file_max_age is called in all cases.
        # Here, we ensure get_send_file_max_age is called for Blueprints.
        cache_timeout = self.get_send_file_max_age(filename)
        return send_from_directory(self.static_folder, filename,
                                   cache_timeout=cache_timeout)
#发送静态文件的函数，使用缓存


    def open_resource(self, resource, mode='rb'):
        """Opens a resource from the application's resource folder.  To see
        how this works, consider the following folder structure::


            /myapplication.py
            /schema.sql
            /static
                /style.css
            /templates
                /layout.html
                /index.html


        If you want to open the `schema.sql` file you would do the
        following::


            with app.open_resource('schema.sql') as f:
                contents = f.read()
                do_something_with(contents)


        :param resource: the name of the resource.  To access resources within
                         subfolders use forward slashes as separator.
        :param mode: resource file opening mode, default is 'rb'.
        """
        if mode not in ('r', 'rb'):
            raise ValueError('Resources can only be opened for reading')
        return open(os.path.join(self.root_path, resource), mode)
#以只读方式打开应用下的文件，返回一个文件对象


总的来说，基类_PackageBoundObject提供了部分基础属性的函数