Explication détaillée du module d'authentification de Django (authentification de l'utilisateur)

Cet article présente principalement l'explication détaillée du module d'authentification de Django (authentification des utilisateurs). Maintenant, je le partage avec vous et le donne comme référence. Jetons un coup d'œil ensemble

Le module d'authentification est une encapsulation de la méthode d'authentification de connexion. Auparavant, après avoir obtenu le nom d'utilisateur et le mot de passe saisis par l'utilisateur, nous devions demander s'il existe. est un utilisateur de la table user. Objets dont les noms et mots de passe correspondent,

Avec le module d'authentification, vous pouvez facilement vérifier si les informations de connexion de l'utilisateur existent dans la base de données.

De plus, auth encapsule également la session pour nous permettre de vérifier si l'utilisateur s'est connecté

Méthodes d'authentification

Si vous souhaitez utiliser la méthode du module auth, vous devez d'abord importer le module auth

from django.contrib import auth

django.contrib.auth propose de nombreuses méthodes, ici nous en présentons principalement quatre :

1, Authenticate()

fournit l'authentification de l'utilisateur, c'est-à-dire pour vérifier si le nom d'utilisateur et le mot de passe sont corrects, généralement le nom d'utilisateur est obligatoire Le mot de passe deux paramètres de mot-clé

Si les informations d'authentification sont valides, un objet Utilisateur sera renvoyé. Authenticate() définira un attribut sur l'objet User pour identifier quel backend d'authentification a authentifié l'utilisateur, et ces informations seront nécessaires dans le processus de connexion ultérieur. Lorsque nous essayons de nous connecter à un objet User provenant directement de la base de données sans authentifier(), une erreur sera signalée ! !

user = authenticate(username='someone',password='somepassword')

2, login(HttpRequest, user)

Cette fonction accepte un objet HttpRequest, et un Objet Utilisateur authentifié

Cette fonction utilise le framework de session de Django pour attacher l'identifiant de session et d'autres informations à un utilisateur authentifié.

from django.contrib.auth import authenticate, login
  
def my_view(request):
  username = request.POST['username']
  password = request.POST['password']
  user = authenticate(username=username, password=password)
  if user is not None:
    login(request, user)
    # Redirect to a success page.
    ...
  else:
    # Return an 'invalid login' error message.
    ...

3. déconnexion (demande) déconnecter l'utilisateur

Cette fonction accepte un objet HttpRequest et ne renvoie rien de valeur. Lorsque cette fonction est appelée, toutes les informations de session pour la requête en cours seront effacées. Même si l'utilisateur n'est pas connecté, aucune erreur ne sera signalée lors de l'utilisation de cette fonction.

from django.contrib.auth import logout
  
def logout_view(request):
  logout(request)
 # Redirect to a success page.

4. is_authenticated() de l'objet utilisateur

Exigences :

1 Les utilisateurs ne peuvent accéder à certaines pages qu'après s'être connectés.

2 Si l'utilisateur accède à la page sans se connecter, il passera directement à la page de connexion

3 Une fois que l'utilisateur a terminé la connexion dans le l'interface de connexion sautée, il accédera automatiquement à l'adresse précédemment visitée

Méthode 1 :

Vérifiez directement à l'aide de la méthode d'authentification is_authenticated()

def my_view(request):
   if not request.user.is_authenticated():
      return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))

Méthode 2 :

Vérifiez en fonction de request.user.username S'il est vide, cela signifie que vous n'êtes pas connecté

def my_view(request):
   if not request.user.username:
      return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))

from django.contrib.auth.decorators import login_required
   
@login_required
def my_view(request):
 ...

objet utilisateur

2.1. is_authenticated()

2.2, créez un utilisateur

from django.contrib.auth.models import User
user = User.objects.create_user（username='',password='',email=''）

2.3, check_password(passwd)

user = User.objects.get(username=' ')
if user.check_password(passwd):
  ......

Utilisez set_password() pour changer le mot de passe

user = User.objects.get(username='')
user.set_password(password='')
user.save　

Inscription :

def sign_up(request):
 
  state = None
  if request.method == 'POST':
 
    password = request.POST.get('password', '')
    repeat_password = request.POST.get('repeat_password', '')
    email=request.POST.get('email', '')
    username = request.POST.get('username', '')
    if User.objects.filter(username=username):
        state = 'user_exist'
    else:
        new_user = User.objects.create_user(username=username, password=password,email=email)
        new_user.save()
 
        return redirect('/book/')
  content = {
    'state': state,
    'user': None,
  }
  return render(request, 'sign_up.html', content)　　

Changer le mot de passe :

@login_required
def set_password(request):
  user = request.user
  state = None
  if request.method == 'POST':
    old_password = request.POST.get('old_password', '')
    new_password = request.POST.get('new_password', '')
    repeat_password = request.POST.get('repeat_password', '')
    if user.check_password(old_password):
      if not new_password:
        state = 'empty'
      elif new_password != repeat_password:
        state = 'repeat_error'
      else:
        user.set_password(new_password)
        user.save()
        return redirect("/log_in/")
    else:
      state = 'password_error'
  content = {
    'user': user,
    'state': state,
  }
  return render(request, 'set_password.html', content)

Créer un utilisateur par vous-mêmeIl est à noter que toutes les opérations ci-dessus concernent la table auth_user créée automatiquement par Django. Nous pouvons jeter un œil à la structure de cette table<. 🎜>

Il s'agit d'une table utilisateur créée automatiquement par Django pour nous. Si vous souhaitez utiliser le module auth, vous devez utiliser (ou hériter) de cette table.

继承表的好处是我们可以增加一些自己需要的字段，并且同时可以使用auth模块提供的接口、方法

下面就讲一下继承auth的方法：

1、导入AbstractUser类，并且写一个自定义的类，继承AbstractUser类，如下：

from django.contrib.auth.models import AbstractUser

class UserInfo(AbstractUser):
  """
  用户信息
  """
  nid = models.AutoField(primary_key=True)
  telephone = models.CharField(max_length=11, null=True, unique=True)
  ......

需要注意的是，UserInfo表里就不需要有auth_user里重复的字段了，比如说username以及password等，但是还是可以直接使用这些字段的，并且django会自动将password进行加密

2、这样写完之后，还需要在setting.py文件里配置：

AUTH_USER_MODEL = 'blog.UserInfo'

这样，django就知道从blog项目下的models去查找UserInfo这张表了

相关推荐：

Django的cookie使用详解

Django中的Ajax使用方法

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!