能否将Django用户认证系统与Neo4j（neomodel）结合？若不能该如何实现？

我目前处于一个新项目的初期阶段，后端采用Django框架，使用Neo4j（neomodel）作为图数据库处理用户间各类关系。当前正面临用户认证实现难题，现咨询：

1. 是否可将Django用户认证系统与neomodel（Neo4j）结合使用？若可以，具体该如何操作？
2. 若无法结合，该如何实现用户认证系统？

当前的用户Profile模型代码：

class Profile(StructuredNode):
    GENDERS = {"M": "Male", "F": "Female", "O": "Other"}
    # Properties
    uid = UniqueIdProperty()
    email = EmailProperty(required=True)
    password = StringProperty(required=True)
    username = StringProperty(unique_index=True, required=True)
    name = StringProperty()
    age = IntegerProperty()
    gender = StringProperty(choices=GENDERS)
    date_of_birth = DateProperty()
    creation_date = DateTimeProperty(default_now=True)

问题1：Django认证系统与neomodel的结合方案 #

完全可以结合使用，核心思路是自定义Django认证后端，让Django的认证系统从neomodel的Profile节点而非默认SQL数据库读取用户信息。具体步骤如下：

1. 完善Profile模型的认证方法 #

让Profile类实现Django认证所需的核心方法，包括密码加密、验证及用户标识：

from django.contrib.auth.hashers import check_password, make_password
from neomodel import StructuredNode, UniqueIdProperty, EmailProperty, StringProperty, IntegerProperty, DateProperty, DateTimeProperty

class Profile(StructuredNode):
    GENDERS = {"M": "Male", "F": "Female", "O": "Other"}
    uid = UniqueIdProperty()
    email = EmailProperty(required=True)
    password = StringProperty(required=True)
    username = StringProperty(unique_index=True, required=True)
    name = StringProperty()
    age = IntegerProperty()
    gender = StringProperty(choices=GENDERS)
    date_of_birth = DateProperty()
    creation_date = DateTimeProperty(default_now=True)

    # 密码加密存储
    def set_password(self, raw_password):
        self.password = make_password(raw_password)
        self.save()

    # 密码验证逻辑
    def check_password(self, raw_password):
        return check_password(raw_password, self.password)

    # 适配Django认证的主键要求
    @property
    def pk(self):
        return self.uid

    # 标识用户状态（可根据业务调整）
    @property
    def is_active(self):
        return True

    @property
    def is_authenticated(self):
        return True

2. 编写自定义认证后端 #

在项目中创建backends.py文件，实现从Neo4j查找用户的认证逻辑：

from django.contrib.auth.backends import BaseBackend
from .models import Profile

class Neo4jAuthBackend(BaseBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        try:
            # 支持用户名或邮箱登录
            if '@' in username:
                user = Profile.nodes.get(email=username)
            else:
                user = Profile.nodes.get(username=username)
            if user.check_password(password):
                return user
        except Profile.DoesNotExist:
            return None

    def get_user(self, user_id):
        try:
            return Profile.nodes.get(uid=user_id)
        except Profile.DoesNotExist:
            return None

3. 配置Django使用自定义后端 #

在项目settings.py中添加认证后端配置：

AUTHENTICATION_BACKENDS = [
    'your_app.backends.Neo4jAuthBackend',
    # 若需要兼容默认SQL用户，可保留以下配置
    # 'django.contrib.auth.backends.ModelBackend',
]

# 告诉Django认证系统使用自定义用户模型（可选但推荐）
AUTH_USER_MODEL = 'your_app.Profile'

4. 测试认证流程 #

现在可正常使用Django原生认证函数，比如authenticate()、login()：

from django.contrib.auth import authenticate, login
from .models import Profile

# 创建测试用户
user = Profile(email='test@example.com', username='testuser')
user.set_password('testpass123')
user.save()

# 执行认证
authenticated_user = authenticate(username='testuser', password='testpass123')
if authenticated_user:
    login(request, authenticated_user)

问题2：无法结合时的替代方案 #

若因限制无法使用Django默认认证系统，可自行实现轻量认证流程，核心包含以下模块：

1. 密码安全处理 #

沿用Django的密码哈希工具确保存储安全：

from django.contrib.auth.hashers import make_password, check_password

2. 登录接口（基于JWT） #

编写视图处理登录请求，验证后返回JWT令牌：

from django.http import JsonResponse
from rest_framework_simplejwt.tokens import RefreshToken
from .models import Profile

def login_view(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        try:
            user = Profile.nodes.get(email=username) if '@' in username else Profile.nodes.get(username=username)
            if check_password(password, user.password):
                refresh = RefreshToken.for_user(user)
                return JsonResponse({
                    'refresh': str(refresh),
                    'access': str(refresh.access_token),
                })
            return JsonResponse({'error': '密码错误'}, status=400)
        except Profile.DoesNotExist:
            return JsonResponse({'error': '用户不存在'}, status=404)
    return JsonResponse({'error': '请求方法错误'}, status=405)

3. 认证中间件 #

编写中间件验证JWT令牌，保护接口：

from django.http import JsonResponse
from rest_framework_simplejwt.authentication import JWTAuthentication

class Neo4jAuthMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        auth = JWTAuthentication()
        try:
            user, token = auth.authenticate(request)
            request.user = user
        except Exception:
            # 非保护接口可跳过，或返回未认证错误
            pass
        response = self.get_response(request)
        return response

4. 注册接口 #

处理用户注册请求，加密密码后存储到Neo4j：

from django.http import JsonResponse
from .models import Profile

def register_view(request):
    if request.method == 'POST':
        email = request.POST.get('email')
        username = request.POST.get('username')
        password = request.POST.get('password')
        
        if Profile.nodes.filter(email=email).exists() or Profile.nodes.filter(username=username).exists():
            return JsonResponse({'error': '用户已存在'}, status=400)
            
        user = Profile(email=email, username=username)
        user.set_password(password)
        user.save()
        return JsonResponse({'message': '注册成功'}, status=201)
    return JsonResponse({'error': '请求方法错误'}, status=405)

内容的提问来源于stack exchange，提问作者Tom