Manchmal erfordern Projekte von uns, innovative Lösungen zu finden. Kürzlich mussten wir eine Kern-REST-Ressource in Drupal 8 überschreiben, und aufgrund der begrenzten verfügbaren Dokumentation haben wir uns entschieden, unsere Lösung zu teilen.

Die Voraussetzungen für eine Überschreibung in Drupal 8

Drupal 8 handhabt die Konfiguration auf einheitliche Weise, wobei mehr Funktionen im Kern gespeichert sind als in früheren Versionen. Diese architektonische Wahl bedeutet, dass das Überschreiben von Kernfunktionen eine sorgfältige Überlegung erfordert, um Systemschäden zu vermeiden.

Während Drupal 8 globale `$config` Überschreibungen durch `Drupal\Core\Config\ConfigFactory::get()` unterstützt, erfordern REST-Ressourcen-Überschreibungen einen anderen Ansatz. Der Kern von Drupal 8 bietet grundlegende REST-Ressourcen für Systementitäten, aber komplexe Operationen erfordern oft das Erweitern dieser Basisklassen.

Schritt-für-Schritt-Anleitung zur Überschreibung einer REST-Ressource

1. Erstellen Sie eine neue Klasse

Erstellen Sie zuerst eine Klasse, die die `EntityResource` Klasse erweitert:

namespace Drupal\my_module\Plugin\rest\resource;
use Drupal\rest\Plugin\ResourceBase;
use Drupal\rest\ResourceResponse;
use Drupal\node\Entity\Node;
/**
* @RestResource(
*   id = "my_custom_node_rest_resource",
*   label = @Translation("Custom Node REST Resource"),
*   uri_paths = {
*     "canonical" = "/api/v1/node/{node}",
*     "create" = "/api/v1/node"
*   }
* )
*/
class MyCustomNodeResource extends EntityResource {
....
}

2. Implementieren Sie die erforderlichen Methoden

Überschreiben Sie die notwendigen Methoden der übergeordneten Klasse:

/**
  * Reagiert auf POST-Anfragen.
  *
  * @param array $data
  *   Die Anfragedaten.
  *
  * @return \Drupal\rest\ResourceResponse
  *   Die Antwort, die den Knoten enthält.
  */
 public function post($data) {
   // Ihre benutzerdefinierte POST-Logik hier
   $response = new ResourceResponse($result, 201);
   return $response;
 }
 /**
  * Reagiert auf PATCH-Anfragen.
  *
  * @param \Drupal\Core\Entity\EntityInterface $entity
  *   Die Entität.
  * @param array $data
  *   Die Anfragedaten.
  *
  * @return \Drupal\rest\ResourceResponse
  *   Die Antwort.
  */
 public function patch($entity, array $data) {
   // Ihre benutzerdefinierte PATCH-Logik hier
   return new ResourceResponse($entity, 200);
 }

3. Konfigurieren Sie die Einstellungen der REST-Ressource

Fügen Sie Folgendes zur Konfiguration Ihres Moduls hinzu:

# config/install/rest.resource.my_custom_node_rest_resource.yml
langcode: en
status: true
dependencies:
 module:
   - my_module
   - serialization
id: my_custom_node_rest_resource
plugin_id: my_custom_node_rest_resource
granularity: resource
configuration:
 methods:
   - GET
   - POST
   - PATCH
 formats:
   - json
 authentication:
   - basic_auth

4. Implementieren Sie Zugriffskontrollen

Fügen Sie eine ordnungsgemäße Zugriffsprüfung hinzu:

/**
  * {@inheritdoc}
  */
 public function access($operation, array $args = []) {
   $entity = isset($args['entity']) ? $args['entity'] : NULL;
   
   switch ($operation) {
     case 'create':
       return $this->checkCreateAccess();
     case 'update':
       return $this->checkUpdateAccess($entity);
     default:
       return parent::access($operation, $args);
   }
 }
```

5. Ausnahmen behandeln

Implementieren Sie eine ordnungsgemäße Fehlerbehandlung:

protected function handleException(\Exception $e) {
   watchdog_exception('my_module', $e);
   
   return new ResourceResponse([
     'error' => [
       'message' => $this->t('Bei der Verarbeitung der Anfrage ist ein Fehler aufgetreten.'),
       'code' => 500,
     ],
   ], 500);
 }

Best Practices

1. Bewahren Sie immer die Rückwärtskompatibilität, wenn möglich
2. Dokumentieren Sie Ihre benutzerdefinierten Endpunkte gründlich
3. Implementieren Sie ordnungsgemäße Zugriffskontrollen
4. Fügen Sie umfassende Fehlerbehandlung hinzu
5. Verwenden Sie Dependency Injection anstelle von statischen Serviceaufrufen
6. Fügen Sie eine ordnungsgemäße Anforderungsvalidierung hinzu
7. Fügen Sie geeignete Antwort-Header hinzu

Testen Ihrer benutzerdefinierten Ressource

Fügen Sie PHPUnit-Tests hinzu, um sicherzustellen, dass Ihre Ressource wie erwartet funktioniert:

namespace Drupal\Tests\my_module\Functional;
use Drupal\Tests\rest\Functional\ResourceTestBase;
class MyCustomNodeResourceTest extends ResourceTestBase {
 // Testimplementierung
}
Häufige Fallstricke vermeiden

• Nicht alle HTTP-Methoden ordnungsgemäß behandeln
• Vergessen, die REST-Konfiguration nach Änderungen zu aktualisieren
• Unzureichende Fehlerbehandlung
• Fehlende Zugriffskontrollen
• Keine Validierung der Eingabedaten
• Ungeeignete Formatierung der Antwort

Indem Sie diese Schritte und Best Practices befolgen, können Sie erfolgreich Drupal 8 Kern-REST-Ressourcen überschreiben und dabei die Systemstabilität und -sicherheit aufrechterhalten.