存�Cookies

在Django中处��久化，大部分时候你会更愿�用高层些的session 和/或 ���讨论的user 框架。但在此之�，我们需��下�在底层看看如何读写cookies。这会帮助你�解本章节���讨论的工具是如何工作的，而且如果你需�自己�作cookies，这也会有所帮助。

读�已�设置好的cookies�其简�，�个request对象都有一个 COOKIES 对象，�以象使用字典般使用它，你�以读�任何�览器�给视图(view)的任何cookies:

def show_color(request):
    if "favorite_color" in request.COOKIES:
        return HttpResponse("Your favorite color is %s" % \
            request.COOKIES["favorite_color"])
    else:
        return HttpResponse("You don't have a favorite color.")

写cookies�微��点，需�用 HttpResponse 对象的 set_cookie() 方法�写。这儿有个基于 GET �数�设置 favorite_color cookie的例�：

def set_color(request):
    if "favorite_color" in request.GET:

        # Create an HttpResponse object...
        response = HttpResponse("Your favorite color is now %s" % \
            request.GET["favorite_color"])

        # ... and set a cookie on the response
        response.set_cookie("favorite_color",
                            request.GET["favorite_color"])

        return response

    else:
        return HttpResponse("You didn't give a favorite color.")

你�以给 response.set_cookie() 传递一些�选的�数�控制cookie的行为，详�表12-1。

好���的Cookies

也许你已�注�到了，cookies的工作方��能导致的问题，一起�看看其中一些��的方�：

cookies存�完全是�强制性的，�览器���这一点。事实上，所有的�览器都让用户自己控制 是�接�cookies。如果你想知�cookies对于web应用有多��，你�以试�打开这个�览器的 选项：�示我接��次cookie。

尽管cookies广为使用，但�被认为是���的的。这�味�，开�者使用cookies之�必须 检查用户是��以接收cookie。

更��的是，*永远* 也��在cookie中存储��的数�。开�者在cookie中存储了���� 的数�，而�览器�因为��原因将cookie中的数�清得一干二净，这样令人�指的故事在 Web世界中比比皆是。

Cookie(特别是那些没通过HTTPS传输的)是�常�安全的。因为HTTP数�是以明文��的，所以 特别容易�到嗅探攻击。也就是说，嗅探攻击者�以在网络中拦截并读�cookies，因此你� �对��在cookies中存储�感信�。

还有一ç§�被称为”中间人”的攻击更阴险，攻击者拦截一个cookie并将其用于å�¦ä¸€ä¸ªç”¨æˆ·ã€‚ 第19章将深入讨论这ç§�攻击的本质以å�Šå¦‚何é�¿å…�。

�使从预想中的接收者返回的cookie也是�安全的，因为大多数�览器都�供了很方便的方法� 修改cookies的内容，有技术背景的用户甚至�以用�mechanize ( http://wwwsearch.sourceforge.net/mechanize/ ) 这样的工具�手工构造HTTP请求。

因此�能在cookies中存储�能会被篡改的�感数�，“�典�错误是：在cookies中存储 IsLoggedIn=1 ，以标识用户已�登录。犯这类错误的站点数�多的令人难以置信； 绕过这些网站的安全系统也是易如�掌。

打开 Sessions功能

Sessions 功能是通过一个中间件(middleware)和一个模型(model)�实现的。�打开sessions功能，需�以下几步�作：

1. 编辑 MIDDLEWARE_CLASSES �置，确� MIDDLEWARE_CLASSES 中包� 'django.contrib.sessions.middleware.SessionMiddleware'

2. 确认 INSTALLED_APPS 中有 'django.contrib.sessions' (如果你是刚打开这个应用，别忘了�行 manage.py syncdb )

如果项目是用 startproject �创建的，�置文件中都已�安装了这些东西，除�你自己删除，正常情况下，你无需任何设置就�以使用session功能。

如果�需�session功能，你�以删除 MIDDLEWARE_CLASSES 设置中的 SessionMiddleware 和 INSTALLED_APPS 设置中的 'django.contrib.sessions' 。虽然这�会节�很少的开销，但积少�多啊。

在视图中使用Session

SessionMiddleware 激活�，�个传给视图(view)函数的第一个�数``HttpRequest`` 对象都有一个 session 属性，这是一个字典型的对象。你�以象用普通字典一样�用它。例如，在视图(view)中你�以这样用：

# Set a session value:
request.session["fav_color"] = "blue"

# Get a session value -- this could be called in a different view,
# or many requests later (or both):
fav_color = request.session["fav_color"]

# Clear an item from the session:
del request.session["fav_color"]

# Check if the session has a given key:
if "fav_color" in request.session:
    ...

其他的映射方法，如 keys() 和 items() 对 request.session �样有效：

下�是一些有效使用Django sessions的简�规则：

• 用正常的字符串作为keyæ�¥è®¿é—®å­—å…¸ request.session ， 而ä¸�是整数ã€�对象或其它什么的。 è¿™ä¸�是什么强硬的æ�¡è§„，但值得é�µå¾ªã€‚

• Session字典中以下划线开头的key值是Django内部ä¿�ç•™key值。框架å�ªä¼šç”¨å¾ˆå°‘的几个下划线 开头的sessionå�˜é‡�，除é�žä½ çŸ¥é�“他们的具体å�«ä¹‰ï¼Œè€Œä¸”æ„¿æ„�跟上Djangoçš„å�˜åŒ–，å�¦åˆ™ï¼Œæœ€å¥½ ä¸�è¦�用这些下划线开头的å�˜é‡�，它们会让Djangoæ�…乱你的应用。

• ä¸�è¦�用一个新对象æ�¥æ›¿æ�¢æŽ‰ request.session ，也ä¸�è¦�å­˜å�–其属性，象用普通Python字典一样用它。

我们�看个简�的例�。这是个简�到�能�简�的例�：在用户�了一次评论�将 has_commented 设置为 True ，这是个简�（但�很安全）的�防止用户多次评论的方法。

def post_comment(request, new_comment):
    if request.session.get('has_commented', False):
        return HttpResponse("You've already commented.")
    c = comments.Comment(comment=new_comment)
    c.save()
    request.session['has_commented'] = True
    return HttpResponse('Thanks for your comment!')

下�是一个很简�的站点登录视图(view)：

def login(request):
    try:
        m = Member.objects.get(username__exact=request.POST['username'])
        if m.password == request.POST['password']:
            request.session['member_id'] = m.id
            return HttpResponse("You're logged in.")
    except Member.DoesNotExist:
        return HttpResponse("Your username and password didn't match.")

这是退出登录，根� login() :

def logout(request):
    try:
        del request.session['member_id']
    except KeyError:
        pass
    return HttpResponse("You're logged out.")

注�

在实践中，这是很烂的用户登录方�，��讨论的认�(authentication )框架会帮你以更�壮和有利的方��处�这些问题。这些�常简�的例��是想让你知�这一切是如何工作的。

设置测试Cookies

就����到的，你�能指望所有的�览器都�以接�cookie，因此，Django为了方便，也�供了检查用户�览器是�接�cookie的简�方法。你�需在视图(view)中调用 request.session.set_test_cookie() ，并在�续的视图(view)�而�是当�的视图(view)中检查 request.session.test_cookie_worked() 。

虽然把 set_test_cookie() 和 test_cookie_worked() 分开的�法看起�有些笨拙，但由于cookie的工作方�，这无���。当设置一个cookie时候，�能等�览器下次访问的时候，你�能知��览器是�接�cookie。

检查cookie是��以正常工作�，你得自己用 delete_test_cookie() �清除它，这是个好习惯。

这是个典型例�：

def login(request):

    # If we submitted the form...
    if request.method == 'POST':

        # Check that the test cookie worked (we set it below):
        if request.session.test_cookie_worked():

            # The test cookie worked, so delete it.
            request.session.delete_test_cookie()

            # In practice, we'd need some logic to check username/password
            # here, but since this is an example...
            return HttpResponse("You're logged in.")

        # The test cookie failed, so display an error message. If this
        # was a real site we'd want to display a friendlier message.
        else:
            return HttpResponse("Please enable cookies and try again.")

    # If we didn't post, send the test cookie along with the login form.
    request.session.set_test_cookie()
    return render_to_response('foo/login_form.html')

注�

�次强调，内置的认�函数会帮你�检查的。

在视图(View)外使用Session

从内部�看，�个session都�是一个普通的Django model（在 django.contrib.sessions.models 中定义)。�个session都由一个�机的32字节哈希串�标识，并存储于数�库中。由于这是一个普通的model，你�以用一般的Django 数�库API�读�session。

>>> from django.contrib.sessions.models import Session
>>> s = Session.objects.get(pk='2b1189a188b44ad18c35e113ac6ceead')
>>> s.expire_date
datetime.datetime(2005, 8, 20, 13, 35, 12)

你得用 get_decoded() �读�实际的session数�，因为session字典�过了编�存储。

>>> s.session_data
'KGRwMQpTJ19hdXRoX3VzZXJfaWQnCnAyCkkxCnMuMTExY2ZjODI2Yj...'
>>> s.get_decoded()
{'user_id': 42}

何时�存Session

缺�的情况下，Django�会在session�生�化的时候�会存入数�库，比如说，字典赋值或删除。

# Session is modified.
request.session['foo'] = 'bar'

# Session is modified.
del request.session['foo']

# Session is modified.
request.session['foo'] = {}

# Gotcha: Session is NOT modified, because this alters
# request.session['foo'] instead of request.session.
request.session['foo']['bar'] = 'baz'

你�以设置 SESSION_SAVE_EVERY_REQUEST 为 True �改�这一缺�行为。如果 SESSION_SAVE_EVERY_REQUEST 设置为 True ，Django 会在�次请求的时候都把session存到数�库中，�使没有任何改�。

注�，会�cookie�会在创建和修改的时候�会�出。但如果 SESSION_SAVE_EVERY_REQUEST 设置为 True ，会�cookie会在�次请求的时候都会�出。�时，�次会�cookie�出的时候，其 expires �数都会更新。

�览器关闭�失效会� vs. �久会�

你�能注�到了，Google给我们��的cookie中有 expires=Sun, 17-Jan-2038 19:14:07 GMT; cookie�以有过期时间，这样�览器就知�什么时候�以删除cookie了。如果cookie没有设置过期时间，当用户关闭�览器的时候，cookie就自动过期了。你�以改� SESSION_EXPIRE_AT_BROWSER_CLOSE 的设置�控制session框架的这一行为。

缺�情况下， SESSION_EXPIRE_AT_BROWSER_CLOSE 设置为 False ，这样，会�cookie�以在用户�览器中��有效达 SESSION_COOKIE_AGE 秒（缺�设置是两周，�1,209,600 秒）。如果你�想用户�次打开�览器都必须�新登陆的�，用这个�数�帮你。

如果 SESSION_EXPIRE_AT_BROWSER_CLOSE 设置为 True ，当�览器关闭时，Django会使cookie失效。

其他的Session设置

除了上��到的设置，还有一些其他的设置�以影�Django session框架如何使用cookie，详�表 12-2.

技术细节

如果你还是好奇的�，下�是一些关于session框架内部工作方�的技术细节：

session 字典和普通Python对象一样，支��列化，详�Python文档中内置 pickle 模�的部分。

Session 数�存在数�库表 django_session 中

Session 数�在需�的时候�会读�，如果你从�使用 request.session ， Django�会动相关数�库表的一根毛。

Django �在需�的时候��出cookie。如果你压根儿就没有设置任何会�数�，它�会 �出会�cookie(除� SESSION_SAVE_EVERY_REQUEST 设置为 True )

Django session 框架完全而且�能基于cookie，�会�退到把会�ID编�在URL中。（��些工具(PHP,JSP)那样）

这是一个有æ„�而为之的设计，把session放在URL中ä¸�å�ªæ˜¯éš¾çœ‹ï¼Œæ›´é‡�è¦�的是这让你的站点 很容易å�—到攻击——通过 Referer header进行session ID”窃å�¬”而实施的攻击。

如果你还是好奇，阅读�代�是最直接办法，详� django.contrib.sessions 。

打开认�支�

�session工具一样，认�支�也是一个Django应用，放在 django.contrib 中，所以也需�安装。与session系统相似，它也是缺�安装的，但如果它已�被删除了，通过以下步骤也能�新安装上：

1. 根�本章早�的部分确认已�安装了session 框架，需�确认用户使用cookie，这样sesson 框架�能正常使用。

2. 将 'django.contrib.auth' 放在你的 INSTALLED_APPS 设置中，然��行 manage.py syncdb

3. 确认 SessionMiddleware ��的 MIDDLEWARE_CLASSES 设置中包� 'django.contrib.auth.middleware.AuthenticationMiddleware'

这样安装�，我们就�以在视图(view)的函数中用处�user了。在视图中存�users，主�用 request.user ；这个对象表示当�已登录的用户，如果用户还没登录，这就是一个 匿� 对象(细节�下)

你�以很容易的通过 is_authenticated() 方法�判断一个用户是�已�登录了

if request.user.is_authenticated():
    # Do something for authenticated users.
else:
    # Do something for anonymous users.

使用User对象

User 实例一般从 request.user ，或是其他下��将�讨论到的方法�得，它有很多属性和方法。 AnonymousUser 对象模拟了 部分 的接�，但�是全部，在把它当�真正的user对象 使用�，你得检查一下 user.is_authenticated()

最�， User 对象有两个多对多的属性： groups 和 permissions 。 User 对象�以 象使用其他多对多属性的方法一样使用它们。

# Set a user's groups:
myuser.groups = group_list

# Add a user to some groups:
myuser.groups.add(group1, group2,...)

# Remove a user from some groups:
myuser.groups.remove(group1, group2,...)

# Remove a user from all groups:
myuser.groups.clear()

# Permissions work the same way
myuser.permissions = permission_list
myuser.permissions.add(permission1, permission2, ...)
myuser.permissions.remove(permission1, permission2, ...)
myuser.permissions.clear()

登录和退出

Django �供内置的视图(view)函数用于处�登录和退出 (以�其他奇技淫巧)，但在开始�，我们�看看如何手工登录和退出，Django 在 django.contrib.auth 中�供了两个函数�处�这些事情—— authenticate() 和 login() 。

认�给出的用户�和密�，使用 authenticate() 函数。它接�两个�数，用户� username 和 密� password ，并在密�对用给出的用户�是�法的情况下返回一个 User 对象。当给出的密���法的时候 authenticate() 函数返回 None ：

>>> from django.contrib import auth
>>> user = auth.authenticate(username='john', password='secret')
>>> if user is not None:
...     print "Correct!"
... else:
...     print "Oops, that's wrong!"

authenticate() �是验�一个用户的�书而已。而�登录一个用户，使用 login() 。该函数接�一个 HttpRequest 对象和一个 User 对象作为�数并使用Django的会�（ session ）框架把用户的ID�存在该会�中。

下�的例�演示了如何在一个视图中�时使用 authenticate() 和 login() 函数：

from django.contrib import auth

def login(request):
    username = request.POST['username']
    password = request.POST['password']
    user = auth.authenticate(username=username, password=password)
    if user is not None and user.is_active:
        # Correct password, and the user is marked "active"
        auth.login(request, user)
        # Redirect to a success page.
        return HttpResponseRedirect("/account/loggedin/")
    else:
        # Show an error page
        return HttpResponseRedirect("/account/invalid/")

注销一个用户，在你的视图中使用 django.contrib.auth.logout() 。该函数接�一个 HttpRequest 对象作为�数，没有返回值。

from django.contrib import auth

def logout(request):
    auth.logout(request)
    # Redirect to a success page.
    return HttpResponseRedirect("/account/loggedout/")

注�，�使用户没有登录， logout() 也�会抛出任何异常。

在实际中，你一般�需�自己写登录/登出的函数；认�系统�供了一系例视图用�处�登录和登出。

使用认�视图的第一步是把它们写在你的URLconf中。 你需�这样写：

from django.contrib.auth.views import login, logout

urlpatterns = patterns('',
    # existing patterns here...
    (r'^accounts/login/$',  login),
    (r'^accounts/logout/$', logout),
)

/accounts/login/ 和 /accounts/logout/ 是Django�供的视图的默认URL。

缺�情况下， login 视图渲染 registragiton/login.html 模�(�以通过视图的�外�数 template_name 修改这个模��称)。这个表�必须包� username 和 password 域。如下示例：

{% extends "base.html" %}

{% block content %}

  {% if form.errors %}
    <p class="error">Sorry, that's not a valid username or password</p>
  {% endif %}

  <form action='.' method='post'>
    <label for="username">User name:</label>
    <input type="text" name="username" value="" id="username">
    <label for="password">Password:</label>
    <input type="password" name="password" value="" id="password">

    <input type="submit" value="login" />
    <input type="hidden" name="next" value="{{ next|escape }}" />
  <form action='.' method='post'>

{% endblock %}

如果用户登录�功，缺�会�定�到 /accounts/profile 。表�中有一个hidden字段� next ，�以用在登录�指定url。也�以把这个值（指定的url）作为 GET �数传递给login视图，这个�数会�为Context中�为 next 的��，你�以把这个��设置给表�中对应的��字段。

logout视图有一些��。缺�的它渲染 registration/logged_out.html 模�（这个视图一般包�你已��功退出的信�）。视图中还�以包�一个�数 next_page 用于退出��定�。

�制已登录用户的访问

有很多原因需�控制用户访问站点的�部分。

一个简�原始的�制方法是检查 request.user.is_authenticated() ,然��定�到登陆页�：

from django.http import HttpResponseRedirect

def my_view(request):
    if not request.user.is_authenticated():
        return HttpResponseRedirect('/login/?next=%s' % request.path)
    # ...

或者显示一个出错信�：

def my_view(request):
    if not request.user.is_authenticated():
        return render_to_response('myapp/login_error.html')
    # ...

作为一个快�方�, 你�以使用便�的 login_required 修饰符:

from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
    # ...

login_required �下�的事情:

• 如果用户没有登录, é‡�定å�‘到 /accounts/login/ , 把当å‰�ç»�对URL作为 next 在查询字符串中传递过去, 例如: /accounts/login/?next=/polls/3/ .

• 如果用户已ç»�登录, 正常地执行视图函数. 视图代ç �å°±å�¯ä»¥å�‡å®šç”¨æˆ·å·²ç»�登录了.

对通过测试的用户�制访问

�制访问�以基于����，�些检查或者为login视图�供��的�置，这些实现方�大致相�

一般的方法是直接在视图的 request.user 上�行检查。例如，下�视图检查用户登陆并是�有 polls.can_vote 的��：

def vote(request):
    if request.user.is_authenticated() and request.user.has_perm('polls.can_vote')):
        # vote here
    else:
        return HttpResponse("You can't vote in this poll.")

并且Django有一个称为 user_passes_test 的简�方�。它根�情况使用�数并且产生特殊装饰符。

def user_can_vote(user):
    return user.is_authenticated() and user.has_perm("polls.can_vote")

@user_passes_text(user_can_vote, login_url="/login/")
def vote(request):
    # Code here can assume a logged-in user with the correct permission.
    ...

user_passes_test 使用一个必需的�数：一个�调用的方法，当存在 User 对象并当此用户�许查看该页�时返回 True 。 注� user_passes_test �会自动检查 User 是�认�，你应该自己�这件事。

例�中我们也展示了第二个�选的�数 login_url ，它让你指定你的登录页�的URL（默认为 /accounts/login/ ）。

既然检查用户是�有一个特殊��是相对常�的任务，Django为这�情形�供了一个�径： permission_required() 装饰器 使用这个装饰器，��的例��以这样写:

from django.contrib.auth.decorators import permission_required

@permission_required('polls.can_vote', login_url="/login/")
def vote(request):
    # ...

注�, permission_required() 也有一个�选的 login_url �数, 这个�数默认为 '/accounts/login/' 。

�制通用视图的访问

在Django用户邮件列表中问到最多的问题是关于对通用视图的�制性访问。为实现这个功能，你需�自己包装视图，并且在URLconf中，将你自己的版本替�通用视图：

from dango.contrib.auth.decorators import login_required
from django.views.generic.date_based import object_detail

@login_required
def limited_object_detail(*args, **kwargs):
    return object_detail(*args, **kwargs)

当然, 你�以用任何其他�定修饰符�替� login_required 。

管� Users, Permissions 和 Groups

管�认�系统最简�的方法是通过管�界�。 第六章讨论了怎样使用Django的管�界��编辑用户和控制他们的��和�访问性，并且大多数时间你都会�使用这个界�。

然而，当你需��对的控制�的时候，有一些低层 API 需�深入专研，我们将在下�的章节中讨论它们。

>>> from django.contrib.auth.models import User
>>> user = User.objects.create_user(username='john',
...                                 email='jlennon@beatles.com',
...                                 password='glass onion')

>>> user.is_staff = True
>>> user.save()

>>> user = User.objects.get(username='john')
>>> user.set_password('goo goo goo joob')
>>> user.save()

hashtype$salt$hash

sha1$a1976$a36cc8cbf81742a8fb52e221aaeab48ed7f58ab4

from django import oldforms as forms
from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response
from django.contrib.auth.forms import UserCreationForm

def register(request):
    form = UserCreationForm()

    if request.method == 'POST':
        data = request.POST.copy()
        errors = form.get_validation_errors(data)
        if not errors:
            new_user = form.save(data)
            return HttpResponseRedirect("/books/")
    else:
        data, errors = {}, {}

    return render_to_response("registration/register.html", {
        'form' : forms.FormWrapper(form, data, errors)
    })

{% extends "base.html" %}

{% block title %}Create an account{% endblock %}

{% block content %}
  <h1>Create an account</h1>
  <form action="." method="post">
    {% if form.error_dict %}
      <p class="error">Please correct the errors below.</p>
    {% endif %}

    {% if form.username.errors %}
      {{ form.username.html_error_list }}
    {% endif %}
    <label for="id_username">Username:</label> {{ form.username }}

    {% if form.password1.errors %}
      {{ form.password1.html_error_list }}
    {% endif %}
    <label for="id_password1">Password: {{ form.password1 }}

    {% if form.password2.errors %}
      {{ form.password2.html_error_list }}
    {% endif %}
    <label for="id_password2">Password (again): {{ form.password2 }}

    <input type="submit" value="Create the account" />
  </label>
{% endblock %}

在模�中使用认�数�

当�登入的用户以�他（她）的���以通过 RequestContext 在模�的context中使用（详�第10章）。

备注

从技术上�说，�有当你使用了 RequestContext 并且 TEMPLATE_CONTEXT_PROCESSORS 设置包�了 "django.core.context_processors.auth" （默认情况就是如此）时，这些���能在模�context中使用。更详细的内容，也请�考第10章。

当使用 RequestContext 时, 当�用户 (是一个 User 实例或一个 AnonymousUser 实例) 存储在模��� {{ user }} 中:

{% if user.is_authenticated %}
  <p>Welcome, {{ user.username }}. Thanks for logging in.</p>
{% else %}
  <p>Welcome, new user. Please log in.</p>
{% endif %}

这些用户的��信�存储在 {{ perms }} 模���中。这是一个在模�中使用很方便的代�，其中包�一些��相关函数的简写。

你有两�方��使用 perms 对象。你�以使用类似于 {{ perms.polls }} 的形��检查，对于�个特定的应用，一个用户是�具有 任� ��；你也�以使用 {{ perms.polls.can_vote }} 这样的形�，�检查一个用户是�拥有特定的��。

这样你就�以在模�中的 {% if %} 语�中检查��:

{% if perms.polls %}
  <p>You have permission to do something in the polls app.</p>
  {% if perms.polls.can_vote %}
    <p>You can vote!</p>
  {% endif %}
{% else %}
  <p>You don't have permission to do anything in the polls app.</p>
{% endif %}

��

���以很方便地标识用户和用户组�以执行的�作。它们被Django的admin管�站点所使用，你也�以在你自己的代�中使用它们。

Django的admin站点如下使用��：

• å�ªæœ‰è®¾ç½®äº† add æ�ƒé™�的用户æ‰�能使用添加表å�•ï¼Œæ·»åŠ å¯¹è±¡çš„视图。

• å�ªæœ‰è®¾ç½®äº† change æ�ƒé™�的用户æ‰�能使用å�˜æ›´åˆ—表，å�˜æ›´è¡¨æ ¼ï¼Œå�˜æ›´å¯¹è±¡çš„视图。

• å�ªæœ‰è®¾ç½®äº† delete æ�ƒé™�的用户æ‰�能删除一个对象。

��是根��一个类型的对象而设置的，并�具体到对象的特定实例。例如，我们�以�许Mary改�新故事，但是目�还��许设置Mary�能改�自己创建的新故事，或者根�给定的状�，出版日期或者ID��选择��。

这三个基本��：添加，�更和删除，会被自动添加到所有的Django模型中，��该模型包� class Admin 。当你执行 manage.py syncdb 的时候，这些就被自动添加到 auth_permission 数�表中。

��以 "<app>.<action>_<object_name>" 的形�出现。如果你有一个 polls 的应用，包�一个 Choice 模型，你就有以下三个��，分别�� "polls.add_choice" ， "polls.change_choice" ，和 "polls.delete_choice" 。

注�，如果当你�行 syncdb 时，模型中没有包� class Admin ，该模型对应的��就�会被创建。如果你在�始化数�库以�，�在自己的模型中加入了 class Admin ，你就需��新�行 syncdb �为应用加入��。

你也�以通过设置 Meta 中的 permissions 属性，�为给定的模型定制��。下�的例�创建了三个自定义的��：

class USCitizen(models.Model):
    # ...
    class Meta:
        permissions = (
            # Permission identifier     human-readable permission name
            ("can_drive",               "Can drive"),
            ("can_vote",                "Can vote in elections"),
            ("can_drink",               "Can drink alcohol"),
        )

当你�行 syncdb 时，�外的���会被加入；你需�自己在视图中添加��相关的代�。

就跟用户一样，��也就是Django模型中的 django.contrib.auth.models 。因此如果你愿�，你也�以通过Django的数�库API直接�作��。

组

组�供了一�通用的方��让你按照一定的��规则和其他标签将用户分类。一个用户�以隶属于任何数�的组。

在一个组中的用户自动获得了赋予该组的��。例如， Site editors 组拥有 can_edit_home_page ��，任何在该组中的用户都拥有这个��。

组也�以通过给定一些用户特殊的标记，�扩展功能。例如，你创建了一个 'Special users' 组，并且�许组中的用户访问站点的一些VIP部分，或者��VIP的邮件消�。

和用户管�一样，admin接�是管�组的最简�的方法。然而，组也就是Django模型 django.contrib.auth.models ，因此你�以使用Django的数�库API，在底层访问这些组。

消�

消�系统会为给定的用户接收消�。�个消�都和一个 User 相关�。其中没有超时或者时间戳的概念。

在�个�功的�作以�，Django的admin管�接�就会使用消�机制。例如，当你创建了一个对象，你会在admin页�的顶上看到 The object was created successfully 的消�。

你也�以使用相�的API在你自己的应用中排队接收和显示消�。API�常地简�：

• è¦�创建一æ�¡æ–°çš„消æ�¯ï¼Œä½¿ç”¨ user.message_set.create(message='message_text') 。

• è¦�获得/删除消æ�¯ï¼Œä½¿ç”¨ user.get_and_delete_messages() ，这会返回一个 Message 对象的列表，并且从队列中删除返回的项。

在例�视图中，系统在创建了播放�（playlist）以�，为用户�存了一�消�。

def create_playlist(request, songs):
    # Create the playlist with the given songs.
    # ...
    request.user.message_set.create(
        message="Your playlist was added successfully."
    )
    return render_to_response("playlists/create.html",
        context_instance=RequestContext(request))

当使用 RequestContext ，当�登录的用户以�他（她）的消�，就会以模��� {{ messages }} 出现在模�的context中。下�是显示消�的一个例�模�代�：

{% if messages %}
<ul>
    {% for message in messages %}
    <li>{{ message }}</li>
    {% endfor %}
</ul>
{% endif %}

需�注�的是 RequestContext 会在��调用 get_and_delete_messages ，因此�使你没有显示它们，它们也会被删除掉。

最�注�，这个消�框架�能�务于在用户数�库中存在的用户。如果��匿�用户��消�，请直接使用会�框架。

档案

最�一个难题是档案系统.为了�解什么是档案,让我们先看看问题.

简��说，许多网站需�存储比标准 User 对象更多的用户信�。为了解决这个问题，大多数网站都会有��的�外字段。所以，Django�供一个轻�级的方�定义档案对象链接到指定的用户。这个档案对象在�个项目中�以是��的，甚至�以为�一数�库�务的��的站点处���的档案。

创建档案的第一步是定义一个模型（model）�存储档案信�。Django对这个模型所�的唯一的�制是，必须�包�唯一的一个对 User 模型的 ForeignKey ，而且这个字段必须��� user 。其他的字段�以由你自己掌控。下�是一个档案模型的例�：

from django.db import models
from django.contrib.auth.models import User

class MySiteProfile(models.Model):
    # This is the only required field
    user = models.ForeignKey(User, unique=True)

    # The rest is completely up to you...
    favorite_band = models.CharField(maxlength=100, blank=True)
    favorite_cheese = models.CharField(maxlength=100, blank=True)
    lucky_number = models.IntegerField()

下一步，你需�告诉Django去哪里查找档案对象。你�以通过设置模型中的 AUTH_PROFILE_MODULE ��达到这个目的。因此，如果你的模型包�在 myapp 这个应用中，你就需�如下编写你的设置文件：

AUTH_PROFILE_MODULE = "myapp.mysiteprofile"

一旦完�，你就�以通过调用 user.get_profile() 函数�获得用户档案。如果 AUTH_PROFILE_MODULE ��没有设置，这个函数�能会抛出 SiteProfileNotAvailable 异常；如果这个用户�存在档案，也�能会抛出 DoesNotExist 异常（通常情况下，你会�获这个异常并在当时创建一个新的档案）。