阅读django源码

从manage.py开始。
manage.py 比较简单就几句话。

1. #!/usr/bin/env python
2. #from django.core.management import execute_manager
3. import os
4. import sys
7. if __name__ == "__main__":
8. #加载配置文件
9. os.environ.setdefault("DJANGO_SETTINGS_MODULE","settings")
11. from django.core.management import execute_from_command_line
12. #执行配置
13. execute_from_command_line(sys.argv)

首先看os.environ.setdefault(),environ为类_Environ的一个实例，它继承自IterableUserDict，而IterableUserDict继承自UserDict，包括setdefault()这个方法也是UserDict的一个方法，看一下setdefault实现的功能：

1. def setdefault(self, key, failobj=None):
2. if key not in self:
3. self[key] = failobj
4. return self[key]

其中的key是 DJANGO_SETTINGS_MODULE，这里的self是一个字典，判断key是不是在里面，不在里面就做一个键值绑定。然后返回。

下面进入execute_from_command_line(sys.argv)，sys.argv位一个参数执行的列表，像我们执行python manage.py runserver时，manage.py位sys.argv[0],runserver为sys.argv[1],以此类推，如果有更多参数加的话。

进入django的core模块下，找到management模块。在__init__.py下可以找到该函数

1. def execute_from_command_line(argv=None):
2. """
3. A simple method that runs a ManagementUtility.
4. """
5. utility = ManagementUtility(argv)
6. utility.execute()

我们输入的参数便传到了这个函数里，其中ManagementUtility位一个类穿进去的参数列表会进入一个简单的初始化

1. def __init__(self, argv=None):
2. self.argv = argv or sys.argv[:]
3. self.prog_name = os.path.basename(self.argv[0])

将参数列表赋给argv，然后返回sys.argv[0]的文件名字给prog_name。
实例化完了之后，再看utility.execute()即类ManagementUtility的execute（）方法。

1. parser = LaxOptionParser(usage="%prog subcommand [options] [args]",
2. version=get_version(),
3. option_list=BaseCommand.option_list)
4. self.autocomplete()
5. try:
6. options, args = parser.parse_args(self.argv)
7. handle_default_options(options)
8. except:
9. pass # Ignore any option errors at this point.
11. try:
12. subcommand = self.argv[1]
13. except IndexError:
14. subcommand = 'help' # Display help if no arguments were given.
16. if subcommand == 'help':
18. if len(args) <= 2:
19. parser.print_lax_help()
20. sys.stdout.write(self.main_help_text() + '\n')
21. elif args[2] == '--commands':
22. sys.stdout.write(self.main_help_text(commands_only=True) + '\n')
23. else:
24. self.fetch_command(args[2]).print_help(self.prog_name, args[2])
25. elif subcommand == 'version':
26. sys.stdout.write(parser.get_version() + '\n')
27. # Special-cases: We want 'django-admin.py --version' and
28. # 'django-admin.py --help' to work, for backwards compatibility.
29. elif self.argv[1:] == ['--version']:
30. # LaxOptionParser already takes care of printing the version.
31. pass
32. elif self.argv[1:] in (['--help'], ['-h']):
33. parser.print_lax_help()
34. sys.stdout.write(self.main_help_text() + '\n')
35. else:
36. self.fetch_command(subcommand).run_from_argv(self.argv)

第一个语句为词法分析，可是找遍了LaxOptionParser这个类也没有找到入口，里面并没有init,只有几个函数，可是python也没有正式的构造函数重载的什么的，后来发现此类继承自OptionParser这个类，它来自于optparse模块，在OptionParser模块里有一个init()函数，会接受若干个参数，进行初始化，这里只是传递了3个参数，usage传递了一个字符串，version为版本，BaseCommand.option_list为一个关于命令行的元组，其中调用了make_option这个类init进行一些初始化，主要初始化_short_opts和_long_opts这两个参数，并且进行了一些检查。_short_opts为短命令，_long_opts为长命令，如-h，--help分别为短命令和长命令。
parser为LaxOptionParser的一个实例。 parser.parse_args(self.argv)这个函数会根据上面初始化的内容进行解析命令行参数，之后返回两个值：options，它是一个对象（，保存有命令行参数值。只要知道命令行参数名，如 file，就可以访问其对应的值： options.file 。args，它是一个由 positional arguments 组成的列表。

1. def handle_default_options(options):
2. """
3. Include any default options that all commands should accept here
4. so that ManagementUtility can handle them before searching for
5. user commands.
7. """
8. if options.settings:
9. os.environ['DJANGO_SETTINGS_MODULE'] = options.settings
10. if options.pythonpath:
11. sys.path.insert(0, options.pythonpath)

handle_default_options将解析出来的options对象当做参数，判断settings和pythonpath是否存在，然后
设置环境变量和python模块的搜索路径。

接下来是获得命令行的命令参数self.argv[1],并判断这个命令，包括错误处理，是否时help，是否是version，根据不同的情况展示不同的信息。

最重要的是最后一句，即前面的情况都不是，就进入self.fetch_command(subcommand).run_from_argv(self.argv)

1. def fetch_command(self, subcommand):
2. """
3. Tries to fetch the given subcommand, printing a message with the
4. appropriate command called from the command line (usually
5. "django-admin.py" or "manage.py") if it can't be found.
6. """
7. # Get commands outside of try block to prevent swallowing exceptions
8. commands = get_commands()
9. try:
10. app_name = commands[subcommand]
11. except KeyError:
12. sys.stderr.write("Unknown command: %r\nType '%s help' for usage.\n" %
13. (subcommand, self.prog_name))
14. sys.exit(1)
15. if isinstance(app_name, BaseCommand):
16. # If the command is already loaded, use it directly.
17. klass = app_name
18. else:
19. klass = load_command_class(app_name, subcommand)
20. return klass

获得django/core/management/commands目录下与INSTALLED_APPS/management/commands目录下的子命令对应的模块前缀

1. def load_command_class(app_name, name):
2. """
3. Given a command name and an application name, returns the Command
4. class instance. All errors raised by the import process
5. (ImportError, AttributeError) are allowed to propagate.
6. """
7. module = import_module('%s.management.commands.%s' % (app_name, name))
8. return module.Command()

返回Command类的实例。进入management/commands下进入每个文件会发现，每个都有Command类对应相应的命令。

self.fetch_command(subcommand).run_from_argv(self.argv)找到我们输入的命令参数，并且使用run_from_argv执行。

进入runserver这个命令下看一下，Command这个类继承了BaseCommand这个类，BaseCommand在Base.py中，里面有run_from_arv这个方法，在其他的命令里
有的重写了这个方法，不过runserver没有。

1. def run_from_argv(self, argv):
2. """
3. Set up any environment changes requested (e.g., Python path
4. and Django settings), then run this command. If the
5. command raises a ``CommandError``, intercept it and print it sensibly
6. to stderr. If the ``--traceback`` option is present or the raised
7. ``Exception`` is not ``CommandError``, raise it.
8. """
9. #设置环境变量，然后运行这个命令
10. #如python manage.py runserver, manage.py就是argv[0],runserver是argv[1]
11. #create_parser直接调用OptionParser(prog=prog_name,usage=self.usage(subcommand),version=self.get_version(),option_list=self.option_list)
12. #将manage.py 和runserver加入参数列表
13. #接下来用parser.parse_args进行解析，argv[2]之后为默认参数，ip地址还有端口号，我们也可以显示的传进去，默认是127.0.0.1，端口号8000.
14. #下面又到了handle_default_options函数。
15. #接下来是执行execute函数，还有异常捕获。
16. parser = self.create_parser(argv[0], argv[1])
17. options, args = parser.parse_args(argv[2:])
18. handle_default_options(options)
19. try:
20. self.execute(*args, **options.__dict__)
21. except Exception as e:
22. if options.traceback or not isinstance(e, CommandError):
23. raise
25. # self.stderr is not guaranteed to be set here
26. stderr = getattr(self, 'stderr', OutputWrapper(sys.stderr, self.style.ERROR))
27. stderr.write('%s: %s' % (e.__class__.__name__, e))
28. sys.exit(1)

下面进入execute函数，前边是一些设置和错误检查，最主要的是 output = self.handle(*args, **options），可以发现handle在BaseCommand里是空的，每个命令对其进行了重写。
runserver也是。看看runserver的handle：

1. def handle(self, addrport='', *args, **options):
2. #导入设置模块
3. from django.conf import settings
4. #DEBUG和ALLOWED_HOSTS的设置
5. if not settings.DEBUG and not settings.ALLOWED_HOSTS:
6. raise CommandError('You must set settings.ALLOWED_HOSTS if DEBUG is False.')
7. #ipv6的设置
8. self.use_ipv6 = options.get('use_ipv6')
9. if self.use_ipv6 and not socket.has_ipv6:
10. raise CommandError('Your Python does not support IPv6.')
11. if args:
12. raise CommandError('Usage is runserver %s' % self.args)
13. self._raw_ipv6 = False
14. if not addrport:
15. self.addr = ''
16. self.port = DEFAULT_PORT
17. else:
18. #如果设置了ip地址和端口号，用正则匹配出来
19. m = re.match(naiveip_re, addrport)
20. if m is None:
21. raise CommandError('"%s" is not a valid port number '
22. 'or address:port pair.' % addrport)
23. self.addr, _ipv4, _ipv6, _fqdn, self.port = m.groups()
24. if not self.port.isdigit():
25. raise CommandError("%r is not a valid port number." % self.port)
26. if self.addr:
27. if _ipv6:
28. self.addr = self.addr[1:-1]
29. self.use_ipv6 = True
30. self._raw_ipv6 = True
31. elif self.use_ipv6 and not _fqdn:
32. raise CommandError('"%s" is not a valid IPv6 address.' % self.addr)
33. if not self.addr:
34. #如果没有设置ip地址使用127.0.0.1代替
35. self.addr = '::1' if self.use_ipv6 else '127.0.0.1'
36. self._raw_ipv6 = bool(self.use_ipv6)
37. #运行命令
38. self.run(*args, **options)

runserver里的run方法主要时调用了inner_run(*args, **options）这个方法。

1. def inner_run(self, *args, **options):
2. #省略了部分代码
3. #很熟悉吧，这就是我们开始运行时，终端上输出的信息啊。
4. self.stdout.write((
5. "%(started_at)s\n"
6. "Django version %(version)s, using settings %(settings)r\n"
7. "Starting development server at http://%(addr)s:%(port)s/\n"
8. "Quit the server with %(quit_command)s.\n"
9. ) % {
10. "started_at": now,
11. "version": self.get_version(),
12. "settings": settings.SETTINGS_MODULE,
13. "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr,
14. "port": self.port,
15. "quit_command": quit_command,
16. })
17. #加载编码设置
18. translation.activate(settings.LANGUAGE_CODE)
20. try:
21. handler = self.get_handler(*args, **options)
22. run(self.addr, int(self.port), handler,
23. ipv6=self.use_ipv6, threading=threading)
25. #省略部分代码
29. def get_handler(self, *args, **options):
30. """
31. Returns the default WSGI handler for the runner.
32. """
33. return get_internal_wsgi_application()

get_internal__wsgi_application()和run(self.addr, int(self.port), handler,ipv6=self.use_ipv6, threading=threading)都在django.core.servers.basehttp中：

1. def get_internal_wsgi_application():
3. from django.conf import settings
4. #在settings模块中并没有找到WSGI_APPLICATION这个环境变量，因此app_path位空
5. app_path = getattr(settings, 'WSGI_APPLICATION')
6. if app_path is None:
7. return get_wsgi_application()

在django/core下wsig.py中的文件如下：就几句话

1. import django
2. from django.core.handlers.wsgi import WSGIHandler
5. def get_wsgi_application():
7. #setup是加载log和settings.INSTALLED_APPS
8. django.setup()
9. #返回WSGIHhadler类的一个实例
10. return WSGIHandler()
13. class WSGIHandler(base.BaseHandler):
14. #初始化一个线程锁
15. initLock = Lock()
16. #WSGIRequest为http.HttpRequest的一个子类，
17. #WSGIRequest实现了wsgi规范
18. request_class = WSGIRequest

下面进入run方法：run(self.addr, int(self.port), handler,ipv6=self.use_ipv6, threading=threading)，标准的wsgi实现：

1. def run(addr, port, wsgi_handler, ipv6=False, threading=False):
2. server_address = (addr, port)
3. if threading:
4. httpd_cls = type(str('WSGIServer'), (socketserver.ThreadingMixIn, WSGIServer), {})
5. else:
6. httpd_cls = WSGIServer
7. httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=ipv6)
8. httpd.set_app(wsgi_handler)
9. httpd.serve_forever()

httpd_cls(server_address, WSGIRequestHandler, ipv6=ipv6)为实例化一个WSGIServer类，最终的实例化方法在父类SocketServer中的TCPServer和BaseServer中。包括初始化线程，初始化网络句柄，像下面的__is_shut_down和__shutdown_request都是在其中初始化的

1. #处理一个http请求直到关闭
2. def serve_forever(self, poll_interval=0.5):
3. #__is_shut_down为一个初始化的threading.Event()的句柄，用于线程间通信
4. #.clear()将标识设置为false
5. self.__is_shut_down.clear()
6. try:
7. while not self.__shutdown_request:
8. #下面的函数就是一个封装好了的select函数，后面的四个为传递给select函数的参数，分别表示输入对象列表，输出对象列表，错误对象列表以及超时时间。
9. #返回值为三个列表，代表可写，可读，错误的事件的对象列表。
10. r, w, e = _eintr_retry(select.select, [self], [], [],
11. poll_interval)
12. #判断self事件是否在可读对象列表中，在就进入进行处理
13. if self in r:
14. #处理连接请求
15. self._handle_request_noblock()
16. finally:
17. self.__shutdown_request = False
18. #将标识设置为true
19. self.__is_shut_down.set()
21. #对select函数的封装
22. def _eintr_retry(func, *args):
23. """restart a system call interrupted by EINTR"""
24. while True:
25. try:
26. return func(*args)
27. except (OSError, select.error) as e:
28. if e.args[0] != errno.EINTR:
29. raise
32. def _handle_request_noblock(self):
34. try:
35. #返回请求句柄，客户端地址，get_request()中调用了self.socket.accept()来实现客户端的连接
36. request, client_address = self.get_request()
37. except socket.error:
38. return
39. if self.verify_request(request, client_address):
40. try:
41. #真正的处理连接请求的地方，调用了self.finish_request(request, client_address)
42. self.process_request(request, client_address)
43. except:
44. self.handle_error(request, client_address)
45. self.shutdown_request(request)
48. def finish_request(self, request, client_address):
49. """Finish one request by instantiating RequestHandlerClass."""
50. 此处的RequestHandlerClass为初始化的时候传进来的WSGIRequestHandler，实现了回调。
51. self.RequestHandlerClass(request, client_address, self)

在WSGIRequestHandler中实现下面的初始化函数：

1. def __init__(self, *args, **kwargs):
2. from django.conf import settings
3. self.admin_static_prefix = urljoin(settings.STATIC_URL, 'admin/')
4. # We set self.path to avoid crashes in log_message() on unsupported
5. # requests (like "OPTIONS").
6. self.path = ''
7. self.style = color_style()
8. #调用父类的WSGIRequestHandler进行初始化，它的父类是simple_server.py里的WSGIRequestHandler,它里面没有__init__,继续找它的父类
9. #如此重复，在最终的基类中可以找到__init__方法，位于SocketServer.py中的 BaseRequestHandler类。
10. super(WSGIRequestHandler, self).__init__(*args, **kwargs)
13. def __init__(self, request, client_address, server):
14. self.request = request
15. self.client_address = client_address
16. self.server = server
17. #setup函数
18. self.setup()
19. try:
20. self.handle()
21. finally:
22. self.finish()
24. def setup(self):
25. pass
27. def handle(self):
28. pass
30. def finish(self):
31. pass

可以看到里面的方法并没有实现，只是给出了定义，实现都在子类中。

再回到WSGIRequestHandler类中，在simple_server.py中实现了handle函数，实现对请求的处理

1. def handle(self):
2. """Handle a single HTTP request"""
4. self.raw_requestline = self.rfile.readline()
5. if not self.parse_request(): # An error code has been sent, just exit
6. return
7. #传入的参数，读，写，错误，环境变量。在其父类SimpleHandler中进行了初始化，并且打开了多线程和多进程选项
8. handler = ServerHandler(
9. self.rfile, self.wfile, self.get_stderr(), self.get_environ()
10. )
11. handler.request_handler = self # backpointer for logging
12. 在SimpleHandler的父类BaseHandler中含实现了run方法。此处get_app()是上面的run方法中我们传进去的wsgi_handler,httpd.set_app(wsgi_handler)
13. handler.run(self.server.get_app())
16. def run(self, application):
18. try:
19. #设置环境变量
20. self.setup_environ()
21. #执行WSGIHandler(self.environ,self.start_response)
22. #因为类中实现了__call__方法，调用类的实例就相当于调用了__call__方法
23. self.result = application(self.environ, self.start_response)
24. self.finish_response()
25. except:
26. try:
27. self.handle_error()
28. except:
29. # If we get an error handling an error, just give up already!
30. self.close()
31. raise # ...and let the actual server figure it out.
36. def __call__(self, environ, start_response):
37. # Set up middleware if needed. We couldn't do this earlier, because
38. # settings weren't available.
39. if self._request_middleware is None:
40. with self.initLock:
41. try:
42. # Check that middleware is still uninitialised.
43. if self._request_middleware is None:
44. #尝试加载中间件
45. self.load_middleware()
46. except:
47. # Unload whatever middleware we got
48. self._request_middleware = None
49. raise
50. #设置脚本路径
51. set_script_prefix(base.get_script_name(environ))
52. signals.request_started.send(sender=self.__class__)
53. try:
54. request = self.request_class(environ)
55. except UnicodeDecodeError:
56. logger.warning('Bad Request (UnicodeDecodeError)',
57. exc_info=sys.exc_info(),
58. extra={
59. 'status_code': 400,
60. }
61. )
62. response = http.HttpResponseBadRequest()
63. else:
64. response = self.get_response(request)
66. response._handler_class = self.__class__
68. status = '%s %s' % (response.status_code, response.reason_phrase)
69. response_headers = [(str(k), str(v)) for k, v in response.items()]
70. for c in response.cookies.values():
71. response_headers.append((str('Set-Cookie'), str(c.output(header=''))))
72. start_response(force_str(status), response_headers)
73. return response

以上为我阅读django源码的一些心得，大体了解了django的一点原理