django源码(2.0.2)粗解之命令行执行

前言

django的命令行在整个的django web开发中都会经常用到，而且是必须得用到。所以，能够了解下django的命令行实现其实是非常有帮助的。

如果大家比较关心django命令的详细说明和使用，可以查看这里。

命令行执行入口

django通过django-admin.py和manage.py来执行命令，以下是这两个文件的源码：

from django.core import management

if __name__ == "__main__":
    management.execute_from_command_line()

它们都调用了management模块下的execute_from_command_line()方法。

这个方法是在django/core/management/__init__.py中定义：

def execute_from_command_line(argv=None):
    """Run a ManagementUtility."""
    utility = ManagementUtility(argv)
    utility.execute()

实现非常简单：生成一个ManagementUtility对象，并让这个对象执行相应的命令行命令。所以主要的工作都是在ManagementUtility这个类中实现的。

ManagementUtility类

python是一门面向的对象的语言，django作为python的一个著名web框架，它所使用当然也是面向对象的思想。所以我们在分析源码的时候应该尽量用面向对象的思想去思考。

ManagementUtility具有3个属性，我们可以从它的__init__函数中看到。

    def __init__(self, argv=None):
        self.argv = argv or sys.argv[:] # 从传入的参数获得，如果没有传入参数就从sys.argv中去取
        self.prog_name = os.path.basename(self.argv[0])
        if self.prog_name == '__main__.py':
            self.prog_name = 'python -m django'
        self.settings_exception = None

self.argv：命令行信息，包括命令和参数

self.prog_name：程序名

self.settings_excepiton：settings的异常信息，发现settings的设置有异常，会将异常信息存在这个变量里面

ManagementUtility主要的方法是execute()，它完成了command执行的所有过程。

1. 我们知道，django的命令行是具有一定的格式的，都是 command subcommand [arguments]，arguments有时是可选的。所以execute方法第一步就是获得subcommand，以便确定后续执行什么任务。

        try:
            subcommand = self.argv[1]
        except IndexError:
            subcommand = 'help'  # Display help if no arguments were given.    

这里提一下，为什么不先获取command呢？其实command是系统用来找程序入口的。

2. 用命令解析器CommandParser解析命令行。CommandParser继承了argparse模块的ArgumentParser类，但它只是对ArgumentParser的异常处理进行了加强。

class CommandParser(ArgumentParser):
    """
    Customized ArgumentParser class to improve some error messages and prevent
    SystemExit in several occasions, as SystemExit is unacceptable when a
    command is called programmatically.
    """
    def __init__(self, cmd, **kwargs):
        self.cmd = cmd
        super().__init__(**kwargs)

    def parse_args(self, args=None, namespace=None):
        # Catch missing argument for a better error message
        if (hasattr(self.cmd, 'missing_args_message') and
                not (args or any(not arg.startswith('-') for arg in args))):
            self.error(self.cmd.missing_args_message)
        return super().parse_args(args, namespace)

    def error(self, message):
        if self.cmd._called_from_command_line:
            super().error(message)
        else:
            raise CommandError("Error: %s" % message)

argparse官方文档 | argparse用法总结

3. 解析器解析出了subcommand的arguments，然后fetch_command根据subcommand导入相应的command包并生成相应的command对象，然后调用command对象的print_help方法或者run_from_argv方法去执行相应的命令。

        if subcommand == 'help':
            if '--commands' in args:    # only print the commands only
                sys.stdout.write(self.main_help_text(commands_only=True) + '
')
            elif len(options.args) < 1: # print out the usages
                sys.stdout.write(self.main_help_text() + '
')
            else: 
                self.fetch_command(options.args[0]).print_help(self.prog_name, options.args[0])
        # Special-cases: We want 'django-admin --version' and
        # 'django-admin --help' to work, for backwards compatibility.
        elif subcommand == 'version' or self.argv[1:] == ['--version']:
            sys.stdout.write(django.get_version() + '
')
        elif self.argv[1:] in (['--help'], ['-h']):
            sys.stdout.write(self.main_help_text() + '
')
        else:
            self.fetch_command(subcommand).run_from_argv(self.argv)        

最后看一眼fetch_command的代码：

    def fetch_command(self, subcommand):
        """
        Try to fetch the given subcommand, printing a message with the
        appropriate command called from the command line (usually
        "django-admin" or "manage.py") if it can't be found.
        """
        # Get commands outside of try block to prevent swallowing exceptions
        commands = get_commands()
        try:
            app_name = commands[subcommand]
        except KeyError:
            if os.environ.get('DJANGO_SETTINGS_MODULE'):
                # If `subcommand` is missing due to misconfigured settings, the
                # following line will retrigger an ImproperlyConfigured exception
                # (get_commands() swallows the original one) so the user is
                # informed about it.
                settings.INSTALLED_APPS
            else:
                sys.stderr.write("No Django settings specified.
")
            sys.stderr.write(
                "Unknown command: %r
Type '%s help' for usage.
"
                % (subcommand, self.prog_name)
            )
            sys.exit(1)
        if isinstance(app_name, BaseCommand):
            # If the command is already loaded, use it directly.
            klass = app_name
        else:
            klass = load_command_class(app_name, subcommand)
        return klass

这里主要用了load_command_class去导入相应的subcommand模块，并生成了一个command类对象。

def load_command_class(app_name, name):
    """
    Given a command name and an application name, return the Command
    class instance. Allow all errors raised by the import process
    (ImportError, AttributeError) to propagate.
    """
    module = import_module('%s.management.commands.%s' % (app_name, name))
    #print("import %s %s" %(app_name, name))
    return module.Command()

我们可以去django/core/management/command/目录下随便找一个command模块看一眼，比如说check.py，每个模块都有一个command类并继承自BaseCommand。上面提到的print_help方法或者run_from_argv方法都是在BaseCommand类中实现。

class Command(BaseCommand):
    help = "Checks the entire Django project for potential problems."

    requires_system_checks = False
    
    #...

-------------------------------------------------

以上是我的一点粗浅的理解，如果有觉得不对的地方，请多多指教，非常感谢！

2018-03-21 17:57:17