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))

Méthode 3 :

Django a conçu un décorateur pour cette situation : login_requierd()

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

Si l'utilisateur n'est pas connecté, il accédera à l'URL de connexion par défaut de Django '/accounts/login/' (cette valeur peut être modifiée dans le fichier de paramètres via LOGIN_URL). Et transmettez le chemin absolu de l’URL d’accès actuelle (après une connexion réussie, vous serez redirigé vers ce chemin).

objet utilisateur

Attributs de l'objet utilisateur : nom d'utilisateur, mot de passe (obligatoire) le mot de passe est enregistré dans la base de données à l'aide d'un algorithme de hachage

is_staff : indique si l'utilisateur dispose des droits d'administrateur sur le site Web.

is_active : indique si l'utilisateur est autorisé à se connecter, défini sur ``False``, vous pouvez interdire à l'utilisateur de se connecter sans supprimer le user

2.1. is_authenticated()

S'il s'agit d'un véritable objet User, la valeur de retour est toujours True. Utilisé pour vérifier si l'utilisateur a réussi l'authentification.

Réussir l'authentification ne signifie pas que l'utilisateur dispose d'autorisations, ni même vérifier si l'utilisateur est actif. Cela signifie simplement que l'utilisateur a réussi l'authentification. Cette méthode est très importante. Utilisez request.user.is_authenticated() en arrière-plan pour déterminer si l'utilisateur s'est connecté. Si vrai, request.user.name

2.2, créez un utilisateur

Utilisez la fonction auxiliaire create_user pour créer 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):
  ......

Lorsque l'utilisateur doit modifier le mot de passe, il doit d'abord saisir le mot de passe d'origine. Si la chaîne donnée réussit la vérification du mot de passe, renvoie True<🎜. >

Utilisez set_password() pour changer le mot de passe

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

2.5, exemple simple

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!