django中的惰性求值

前言

---

1. 软件开发中遇到的所有问题，都可以通过增加一层抽象而得以解决。
2. 代理模式，为其他对象提供一种代理以控制对这个对象的访问。

django中的LazyObject

---

django.utils.functional.py

empty = object()
def new_method_proxy(func):
    def inner(self, *args):
        if self._wrapped is empty:
            self._setup()
        return func(self._wrapped, *args)
    return inner

class LazyObject(object):
    """
    A wrapper for another class that can be used to delay instantiation of the
    wrapped class.

	# 一个封装类，被封装的对象能够延迟实例化的时间

    By subclassing, you have the opportunity to intercept and alter the
    instantiation. If you don't need to do that, use SimpleLazyObject.

	# 通过继承此类，可以介入和改变被封装的实例。如果不需要这样做，可以使用SimpleLazyObject
    """
    def __init__(self):
        self._wrapped = empty

    __getattr__ = new_method_proxy(getattr)

    def __setattr__(self, name, value):
        if name == "_wrapped":
            # Assign to __dict__ to avoid infinite __setattr__ loops.
			# self._wrapped = value 的写法会导致无限循环调用 __setattr__
            self.__dict__["_wrapped"] = value
        else:
			# 进行赋值时，再通过 _setup 进行实例化
            if self._wrapped is empty:
                self._setup()
            setattr(self._wrapped, name, value)

    def __delattr__(self, name):
		# 进行取值时， 再通过 _setup 进行实例化
        if name == "_wrapped":
            raise TypeError("can't delete _wrapped.")
        if self._wrapped is empty:
            self._setup()
        delattr(self._wrapped, name)

    def _setup(self):
        """
        Must be implemented by subclasses to initialise the wrapped object.
        """
        raise NotImplementedError

    # introspection support:
    __dir__ = new_method_proxy(dir)

增加一个LazyObject类封装需要延迟实例化的对象，通过改写__getattr__、__setattr__和__delattr__进行代理和按需实例化。(代理模式ProxyPattern）。

django中的SimpleLazyObject

---

如LazyObject中所说，当只是简单的代理而不需要改变封装的_wrapped时，只需使用SimpleLazyObject。 这个代理类需要一个func参数，当需要实例化时调用。这个func参数可以是被封装的类、延迟求值的函数等，任何需要代理的对象。为了实际使用需要处理一些特殊方法，基本的实现框架如下:

class SimpleLazyObject(LazyObject):
	def __init__(self, func):
		self.__dict__['_setupfunc'] = func
	
	def _setup(self):
		self._wrapped = self._setupfunc()

真实的代理类

---

1. 重写_setup，被封装的类为 self._wrapped = Setting(settings_module)
2. 通过提供configure接口，可以由用户修改内部被封装的配置类·

django.conf.settings(django.conf.init.py)

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 we need any settings at all, if the user has not
        previously configured the settings manually.
        """
        try:
            settings_module = os.environ[ENVIRONMENT_VARIABLE]
            if not settings_module: # If it's set but is an empty string.
                raise KeyError
        except KeyError:
            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)
        self._configure_logging()

    def __getattr__(self, name):
        if self._wrapped is empty:
            self._setup(name)
        return getattr(self._wrapped, name)

    def _configure_logging(self):
        """
        Setup logging from LOGGING_CONFIG and LOGGING settings.
        """
        if not sys.warnoptions:
            try:
                # Route warnings through python logging
                logging.captureWarnings(True)
                # Allow DeprecationWarnings through the warnings filters
                warnings.simplefilter("default", DeprecationWarning)
            except AttributeError:
                # No captureWarnings on Python 2.6, DeprecationWarnings are on anyway
                pass

        if self.LOGGING_CONFIG:
            from django.utils.log import DEFAULT_LOGGING
            # First find the logging configuration function ...
            logging_config_path, logging_config_func_name = self.LOGGING_CONFIG.rsplit('.', 1)
            logging_config_module = importlib.import_module(logging_config_path)
            logging_config_func = getattr(logging_config_module, logging_config_func_name)

            logging_config_func(DEFAULT_LOGGING)

            if self.LOGGING:
                # Backwards-compatibility shim for #16288 fix
                compat_patch_logging_config(self.LOGGING)

                # ... then invoke it with the logging settings
                logging_config_func(self.LOGGING)

    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
        self._configure_logging()

    @property
    def configured(self):
        """
        Returns True if the settings have already been configured.
        """
        return self._wrapped is not empty

总结

---

1.通过增加一个代理类，封装了延迟求值(实例化)的对象。通过增加一个层解决问题。
2.再通过改写__setattr__、__getattr__和__delattr__方法，将对代理类的操作，直接委托给被代理的类。代理模式。