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) + '\n')
             elif len(options.args) < 1: # print out the usages
                 sys.stdout.write(self.main_help_text() + '\n')
             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() + '\n')
         elif self.argv[1:] in (['--help'], ['-h']):
             sys.stdout.write(self.main_help_text() + '\n')
         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.\n")
             sys.stderr.write(
                 "Unknown command: %r\nType '%s help' for usage.\n"
                 % (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