zoukankan      html  css  js  c++  java
  • 基于Django调用配置文件方式实现调用配置文件、Django源码分析

    在项目中有两套配置文件,一个是默认配置(如rest_framework中的settings),一个是用户配置(Django框架的settings)

    需求:

    如果用户配置过了某个参数,就用用户配置过的;如果用户没有配置过,就用默认配置中的参数

    实现:

    1、globalsetting.py

    DEBUG = True
    

    2、setting.py

    DEBUG = False
    

    3、在conf的__init__中

    # 参考Django源码,实现
    import importlib
    import os
    
    from conf import globalsetting
    
    class Setting:
        def __init__(self):
            # 从环境标量中取出用户配置
            user_setting = os.environ.get('user_setting')   # 字符串类型
            # print(user_setting)   # usersetting.setting
            # print(dir(globalsetting))
            # 将globalsetting转换为列表
            for setting in dir(globalsetting):
                if setting.isupper():
                    # getattr(globalsetting, setting) 获取globalsetting中setting对应的值
                    # setattr(...) 将获取到的值,赋给Setting对象的setting属性
                    setattr(self, setting, getattr(globalsetting, setting))
    
            # 将字符串类型的 . 数据,转换为文件路径,mod 即为 setting.py
            mod = importlib.import_module(user_setting)
            # print(mod)
            for setting in dir(mod):
                if setting.isupper():
                    # getattr(mod, setting) 获取mod中setting的值
                    # setattr(...) 将Setting对象的setting属性设置为获取的值,如果设置过默认的,用户又配置过,就会覆盖掉默认的值
                    setattr(self, setting, getattr(mod, setting))
    
    
    settings = Setting()
    

    4、test.py

    import os
    # 将用户配置文件加到环境变量中
    os.environ.setdefault('user_setting', 'usersetting.setting')
    from conf import settings
    
    print(settings.DEBUG)
    

     
     

    附:django配置文件调用的源码

    • __init__.py
    """
    Settings and configuration for Django.
    
    Read values from the module specified by the DJANGO_SETTINGS_MODULE environment
    variable, and then from django.conf.global_settings; see the global_settings.py
    for a list of all possible variables.
    """
    
    import importlib
    import os
    import time
    import warnings
    
    from django.conf import global_settings
    from django.core.exceptions import ImproperlyConfigured
    from django.utils.deprecation import RemovedInDjango30Warning
    from django.utils.functional import LazyObject, empty
    
    ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE"
    
    
    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.
            """
            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))
    
            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,
            }
    
        def __getattr__(self, name):
            """Return the value of a setting and cache it in self.__dict__."""
            if self._wrapped is empty:
                self._setup(name)
            val = getattr(self._wrapped, name)
            self.__dict__[name] = val
            return val
    
        def __setattr__(self, name, value):
            """
            Set the value of setting. Clear all cached values if _wrapped changes
            (@override_settings does this) or clear single values when set.
            """
            if name == '_wrapped':
                self.__dict__.clear()
            else:
                self.__dict__.pop(name, None)
            super().__setattr__(name, value)
    
        def __delattr__(self, name):
            """Delete a setting and clear it from cache if needed."""
            super().__delattr__(name)
            self.__dict__.pop(name, None)
    
        def configure(self, default_settings=global_settings, **options):
            """
            Called to manually configure the settings. The 'default_settings'
            parameter sets where to retrieve any unspecified values from (its
            argument must support attribute access (__getattr__)).
            """
            if self._wrapped is not empty:
                raise RuntimeError('Settings already configured.')
            holder = UserSettingsHolder(default_settings)
            for name, value in options.items():
                setattr(holder, name, value)
            self._wrapped = holder
    
        @property
        def configured(self):
            """Return True if the settings have already been configured."""
            return self._wrapped is not empty
    
    
    class Settings:
        def __init__(self, settings_module):
            # update this dict from global settings (but only for ALL_CAPS settings)
            for setting in dir(global_settings):
                if setting.isupper():
                    setattr(self, setting, getattr(global_settings, setting))
    
            # store the settings module in case someone later cares
            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():
                    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)
                    setattr(self, setting, setting_value)
                    self._explicit_settings.add(setting)
    
            if not self.SECRET_KEY:
                raise ImproperlyConfigured("The SECRET_KEY setting must not be empty.")
    
            if self.is_overridden('DEFAULT_CONTENT_TYPE'):
                warnings.warn('The DEFAULT_CONTENT_TYPE setting is deprecated.', RemovedInDjango30Warning)
    
            if hasattr(time, 'tzset') and 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 = '/usr/share/zoneinfo'
                if (os.path.exists(zoneinfo_root) and not
                        os.path.exists(os.path.join(zoneinfo_root, *(self.TIME_ZONE.split('/'))))):
                    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):
            return '<%(cls)s "%(settings_module)s">' % {
                'cls': self.__class__.__name__,
                'settings_module': self.SETTINGS_MODULE,
            }
    
    
    class UserSettingsHolder:
        """Holder for user configured settings."""
        # SETTINGS_MODULE doesn't make much sense in the manually configured
        # (standalone) case.
        SETTINGS_MODULE = None
    
        def __init__(self, default_settings):
            """
            Requests for configuration variables not in this class are satisfied
            from the module specified in default_settings (if possible).
            """
            self.__dict__['_deleted'] = set()
            self.default_settings = default_settings
    
        def __getattr__(self, name):
            if name in self._deleted:
                raise AttributeError
            return getattr(self.default_settings, name)
    
        def __setattr__(self, name, value):
            self._deleted.discard(name)
            if name == 'DEFAULT_CONTENT_TYPE':
                warnings.warn('The DEFAULT_CONTENT_TYPE setting is deprecated.', RemovedInDjango30Warning)
            super().__setattr__(name, value)
    
        def __delattr__(self, name):
            self._deleted.add(name)
            if hasattr(self, name):
                super().__delattr__(name)
    
        def __dir__(self):
            return sorted(
                s for s in list(self.__dict__) + dir(self.default_settings)
                if s not in self._deleted
            )
    
        def is_overridden(self, setting):
            deleted = (setting in self._deleted)
            set_locally = (setting in self.__dict__)
            set_on_default = getattr(self.default_settings, 'is_overridden', lambda s: False)(setting)
            return deleted or set_locally or set_on_default
    
        def __repr__(self):
            return '<%(cls)s>' % {
                'cls': self.__class__.__name__,
            }
    
    
    settings = LazySettings()
    
    

     
     

    Django配置文件调用源码分析

    在这里global_settings.py是django默认的配置文件,而我们项目中下的settings.py是提供给用户的自定义配置文件

    在实际开发中通过from django.conf import settings来导入django的配置文件

    • 这句化实则是导入__init__.py中的settings对象,这是一个单例模式的demo,每一次导入配置都是同一个对象

     

    • settings为一个LazySettings对象

      LazySettings对象,就是延迟获取配置内容。比如,我们定义了一个对象A,并对其添加了一些属性,对A初始化时,我们将A的属性的值设置为空,当我们要访问对象A其中的一个属性时,我们才加载属性的值,并将空值设置为对应的值,返回属性值,下次获取属性值时,属性值不为空,直接返回属性值。

     

    • settings.DEBUG调用setting中的配置

      此时响应的是LazySettings中的__getattr__方法,这里的name参数即DEBUG

      • self._wrapped的值为empty,由于LazySettings类继承LazyObject类,而LazySettings类中没有_wrapped属性,由父类决定。因此进入if中,执行self._setup(name),即self._setup('DEBUG')

         

      • 执行self._setup(name)

        • 首先从环境变量中获取key为DJANGO_SETTINGS_MODULE的值 (这个值是在我们项目的manage.py中设置进环境变量),获取结果实则是实际项目中的自定义配置文件,结合manag.py这里settings_module=SeMF.settings

        • 再到self._wrapped=Settings(settings_module)创建一个 Settings对象

         

        manage.py,在项目启动时,想将配置文件添加到环境变量中

     

    • 创建Settings对象

      先遍历默认配置中的变量,并将变量的值赋值给Settings对象中对应的属性;然后在遍历用户自定义配置,重新给Settings对象的属性赋值。因此,如果自定义配置文件中存在默认配置中的变量,就会覆盖Settings对象的对应属性的值

      setattr(obj, obj_attr, attr_value)

       

      • 这里的setting_module用户自定义的配置文件global_settingsdjango模块中默认的配置文件

        • 默认配置文件 中的循环所有变量、方法,(配置文件中属性均为大写),并将对应的值Settings对象中对应的属性

        • 导入用户自定义配置文件,for循环获取 自定义配置文件 中所有的变量、方法,并赋值给Settings对象中对应的属性。

          self._explicit_settings.add(setting)将每一个自定义配置中大写的变量全都添加到_explicit_settings集合中,只是用于后续的if判断条件。

     

    • Settings对象创建完成,回到LazySettings中的__getattr__中,执行val = getattr(self._wrapped, name),这里self._wrappedSettings对象。从Settings对象中取出对应属性name,并将值放入LazySettings对象的名称空间中,并返回值

  • 相关阅读:
    第06组 Beta冲刺 总结
    第06组 Beta冲刺 (5/5)
    第06组 Beta冲刺 (4/5)
    第06组 Beta冲刺 (3/5)
    第06组 Beta冲刺 (2/5)
    第06组 Beta冲刺 (1/5)
    第06组 alpha冲刺 总结
    第06组 Alpha冲刺 (6/6)
    数据采集第四次作业
    第06组(67)团队展示
  • 原文地址:https://www.cnblogs.com/linagcheng/p/13539836.html
Copyright © 2011-2022 走看看