求助：如何在不使用ViewSets的情况下基于Django REST Framework实现Elastic Search？及elasticsearch-dsl与elasticsearch-dsl-drf详细使用指南

Hey there! Let's break down your two Django REST Framework + Elasticsearch questions clearly, since I’ve spent a lot of time working with this stack and know how tricky these setup details can be.

ViewSets are convenient, but you can absolutely build a custom ES integration using basic DRF views. Here's a step-by-step implementation:

Step 1: Install Required Packages #

First, get the core dependencies:

pip install django djangorestframework elasticsearch elasticsearch-dsl

Step 2: Configure Elasticsearch Connection #

Add this to your Django settings.py to point to your ES instance:

ELASTICSEARCH_DSL = {
    'default': {
        'hosts': 'localhost:9200'  # Update with your ES host/port
    },
}

Step 3: Define an Elasticsearch Document #

Create a documents.py file in your app to map your Django model to an ES index. This acts as the bridge between your database and Elasticsearch:

from elasticsearch_dsl import Document, Text, Date, Integer, Keyword
from elasticsearch_dsl.connections import connections
from django.conf import settings
from .models import BlogPost  # Replace with your model

# Initialize the ES connection
connections.configure(**settings.ELASTICSEARCH_DSL)

class BlogPostDocument(Document):
    # Define ES fields (match your model's data types)
    title = Text(fields={'raw': Keyword()})  # Raw keyword for exact matches/sorting
    content = Text()
    published_date = Date()
    author_id = Integer()

    # Configure the ES index
    class Index:
        name = 'blog_posts'
        settings = {
            'number_of_shards': 1,
            'number_of_replicas': 0
        }

    # Sync with Django model
    class Django:
        model = BlogPost
        fields = ['id']  # Additional model fields to sync
        ignore_signals = False  # Auto-sync on model save/delete
        auto_refresh = True  # Refresh index immediately after changes

Step 4: Create a DRF Serializer #

Build a serializer to format ES search results into DRF-compatible responses:

from rest_framework import serializers

class BlogPostSearchSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField()
    content = serializers.CharField()
    published_date = serializers.DateTimeField()
    author_id = serializers.IntegerField()

Step 5: Build a Custom DRF View #

Use APIView to handle search requests, build ES queries, and return paginated results:

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.pagination import PageNumberPagination
from .documents import BlogPostDocument

class CustomSearchPagination(PageNumberPagination):
    page_size = 10
    page_size_query_param = 'page_size'
    max_page_size = 100

class BlogSearchView(APIView):
    pagination_class = CustomSearchPagination

    def get(self, request):
        # Extract query parameters from the request
        search_query = request.query_params.get('q', '')
        page = request.query_params.get('page', 1)
        page_size = request.query_params.get('page_size', 10)

        # Build the ES search query
        search = BlogPostDocument.search().query(
            "multi_match", 
            query=search_query, 
            fields=['title', 'content']  # Fields to search across
        )

        # Apply pagination
        start_idx = (int(page) - 1) * int(page_size)
        end_idx = start_idx + int(page_size)
        es_response = search[start_idx:end_idx].execute()

        # Serialize results
        serializer = BlogPostSearchSerializer(es_response.hits, many=True)

        # Format paginated response
        paginated_data = {
            'count': es_response.hits.total.value,
            'next': self.pagination_class().get_next_link(request) if end_idx < es_response.hits.total.value else None,
            'previous': self.pagination_class().get_previous_link(request) if start_idx > 0 else None,
            'results': serializer.data
        }

        return Response(paginated_data)

Step 6: Wire Up URLs #

Add this to your app's urls.py:

from django.urls import path
from .views import BlogSearchView

urlpatterns = [
    path('search/', BlogSearchView.as_view(), name='blog-search'),
]

Let’s break down the key components of these libraries and walk through a complete usage flow:

Core elasticsearch-dsl Components #

These handle the low-level interaction with Elasticsearch:

• Document: The backbone of your ES integration. It defines the index schema (mapping), links to a Django model for auto-sync, and provides methods to search, create, or update documents. Think of it as the ES equivalent of a Django Model.
• Fields: Mirror Elasticsearch’s native field types:
  • Text(): For full-text search (automatically tokenized into keywords).
  • Keyword(): For exact matches, sorting, or filtering (no tokenization—great for tags, IDs, or categories).
  • Date(), Integer(), Float(): For structured data types.
• Search: A class to build complex queries. Chain methods like .query(), .filter(), .sort(), or .highlight() to refine results.
• Q: A helper for boolean queries. Combine conditions with & (AND) or | (OR), e.g., Q("match", title="django") & Q("term", author_id=1).
• DjangoIntegration: The nested Django class inside a Document handles syncing between your Django model and ES index. It auto-refreshes the index when models are saved/deleted and specifies which fields to sync.

elasticsearch-dsl-drf Components #

This library bridges elasticsearch-dsl with DRF, adding DRF-style tools for search/filtering:

• DocumentSerializer: A DRF serializer built specifically for ES Documents. It auto-maps ES fields to DRF fields, handles nested data, and supports field filtering.
• FilterBackends: Translate request parameters into ES queries/filters:
  • SearchFilterBackend: Handles full-text search via the ?q= parameter.
  • FilteringFilterBackend: Applies exact-match or range filters (e.g., ?author_id=1).
  • OrderingFilterBackend: Lets users sort results via ?ordering=published_date.
• BaseDocumentViewSet: A pre-built ViewSet that provides CRUD + search operations out of the box. Even if you avoid ViewSets, understanding this helps replicate its functionality with custom views.

Full Usage Example with elasticsearch-dsl-drf #

1. Install the Package:

pip install elasticsearch-dsl-drf

2. Define Document (same as Step 3 above)

3. Create a DocumentSerializer:

from elasticsearch_dsl_drf.serializers import DocumentSerializer
from .documents import BlogPostDocument

class BlogPostDocumentSerializer(DocumentSerializer):
    class Meta:
        document = BlogPostDocument
        fields = ('id', 'title', 'content', 'published_date', 'author_id')

4. Build a Generic DRF View (No ViewSets)
   Use DRF’s GenericAPIView to leverage elasticsearch-dsl-drf’s filter backends:

from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from elasticsearch_dsl_drf.filter_backends import (
    SearchFilterBackend,
    FilteringFilterBackend,
    OrderingFilterBackend
)
from elasticsearch_dsl_drf.pagination import PageNumberPagination
from .documents import BlogPostDocument
from .serializers import BlogPostDocumentSerializer

class BlogSearchGenericView(GenericAPIView):
    serializer_class = BlogPostDocumentSerializer
    filter_backends = [SearchFilterBackend, FilteringFilterBackend, OrderingFilterBackend]
    
    # Configure search/filter/sort parameters
    search_fields = ('title', 'content')
    filter_fields = {
        'author_id': 'author_id',
        'published_date': 'published_date',
    }
    ordering_fields = ('published_date', 'id')
    pagination_class = PageNumberPagination

    def get_queryset(self):
        return BlogPostDocument.search()

    def get(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())
        page = self.paginate_queryset(queryset)
        
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

Pro Tips #

• Sync Existing Data: Run python manage.py search_index --rebuild to create your ES index and sync existing Django model data.
• Test Queries: Use Kibana’s Dev Tools to test ES queries before implementing them in code.
• Error Handling: Add try-except blocks around ES operations to handle connection errors or invalid queries gracefully.
• Performance: Use ES’s explain() method on search results to debug slow queries, and add keyword sub-fields (like title.raw) for fast sorting/filtering.

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