Django 如何加载settings.py 的源码分析

Django加载setting.py的核心过程的源码分析

先简单总结一下大致的过程：

django项目启动编译，先加载global_settings.py中的配置，然后再加载根目录下的settings.py并利用反射机制进行覆盖。

原理步骤分析：

首先从入口manage.py分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import os
import sys


def main():
    # 将根目录下的setting.py文件利用基于字符串驱动的反射机制，添加到os.environ的字典中，以DJANGO_SETTINGS_MODULE作为键值。
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mblog.settings')
    try:
	    # 获取控制台启动命令，会检查是否导入所需要的模块
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)


if __name__ == '__main__':
    # 项目入口处
    main()

进入到django.conf中

settings = LazySettings()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class LazySettings(LazyObject):
    """
    A lazy proxy for either global Django settings or a custom settings object.
    The user can manually configure settings prior to using them. Otherwise,
    Django uses the settings module pointed to by DJANGO_SETTINGS_MODULE.
    """
	# 启动项
    def _setup(self, name=None):
        """
        Load the settings module pointed to by the environment variable. This
        is used the first time settings are needed, if the user hasn't
        configured settings manually.
        """
        # 利用反射机制字典中DJANGO_SETTINGS_MODULE键对应的根目录下的settings.py
        settings_module = os.environ.get(ENVIRONMENT_VARIABLE)
        if not settings_module:
            desc = ("setting %s" % name) if name else "settings"
            raise ImproperlyConfigured(
                "Requested %s, but settings are not configured. "
                "You must either define the environment variable %s "
                "or call settings.configure() before accessing settings."
                % (desc, ENVIRONMENT_VARIABLE))
        # 配置settings.py文件内容，进行文件的覆盖和初始化
        self._wrapped = Settings(settings_module)

    def __repr__(self):
        # Hardcode the class name as otherwise it yields 'Settings'.
        if self._wrapped is empty:
            return '<LazySettings [Unevaluated]>'
        return '<LazySettings "%(settings_module)s">' % {
            'settings_module': self._wrapped.SETTINGS_MODULE,
        }
	...

进入到setting中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
class Settings:
    def __init__(self, settings_module):
        # update this dict from global settings (but only for ALL_CAPS settings)
        # dir()获取当前模块的属性,方法列表
        for setting in dir(global_settings):
            if setting.isupper():
                # 通过反射机制获取global_settings的配置内让能够
                setattr(self, setting, getattr(global_settings, setting))

        # store the settings module in case someone later cares
        # 将根目录下的settings文件赋给self.SETTINGS_MODULE
        self.SETTINGS_MODULE = settings_module

        # 导入该配置模块
        mod = importlib.import_module(self.SETTINGS_MODULE)

        tuple_settings = (
            "INSTALLED_APPS",
            "TEMPLATE_DIRS",
            "LOCALE_PATHS",
        )
        self._explicit_settings = set()
        for setting in dir(mod):
            if setting.isupper():
                # 获取settings.py中的每项配置
                setting_value = getattr(mod, setting)

                if (setting in tuple_settings and
                        not isinstance(setting_value, (list, tuple))):
                    raise ImproperlyConfigured("The %s setting must be a list or a tuple. " % setting)
                # 利用反射将setting_value添加到self._explicit_settings集合中去
                setattr(self, setting, setting_value)
                self._explicit_settings.add(setting)

        if not self.SECRET_KEY:
		    # 检查是否存在密钥，每个django项目都有唯一的密钥
            raise ImproperlyConfigured("The SECRET_KEY setting must not be empty.")

        if self.is_overridden('DEFAULT_CONTENT_TYPE'):
            warnings.warn(DEFAULT_CONTENT_TYPE_DEPRECATED_MSG, RemovedInDjango30Warning)
        if self.is_overridden('FILE_CHARSET'):
            warnings.warn(FILE_CHARSET_DEPRECATED_MSG, RemovedInDjango31Warning)

        if hasattr(time, 'tzset') and self.TIME_ZONE:
		    # 配置self.TIME_ZONE
            # When we can, attempt to validate the timezone. If we can't find
            # this file, no check happens and it's harmless.
            zoneinfo_root = Path('/usr/share/zoneinfo')
            zone_info_file = zoneinfo_root.joinpath(*self.TIME_ZONE.split('/'))
            if zoneinfo_root.exists() and not zone_info_file.exists():
                raise ValueError("Incorrect timezone setting: %s" % self.TIME_ZONE)
            # Move the time zone info into os.environ. See ticket #2315 for why
            # we don't do this unconditionally (breaks Windows).
            os.environ['TZ'] = self.TIME_ZONE
            time.tzset()

    def is_overridden(self, setting):
        # 判断是否覆盖了默认的配置文件
        return setting in self._explicit_settings

    def __repr__(self):
	    # 直接调用对象的话就会调用__repr__内置方法
        return '<%(cls)s "%(settings_module)s">' % {
            'cls': self.__class__.__name__,
            'settings_module': self.SETTINGS_MODULE,
        }

总结：主要的初始化还是在Setting类中实现，我们还可以发先大多是的框架底层源码都会使用反射机制，
getattr,hasattr,setattr,delattr方法。