In einem unserer Drupal 8 Projekte mussten wir einen Batch-Prozess implementieren. Lassen Sie uns erkunden, was Batch-Prozesse in Drupal 8 sind und verstehen, wie und wann sie effektiv eingesetzt werden können.

Ein Batch-Prozess führt eine Reihe von Operationen aus, ohne dass eine Benutzerinteraktion erforderlich ist. Er verarbeitet Daten in diskreten "Batches" oder Eingabesätzen, daher der Name. Dieser Ansatz ermöglicht die Handhabung von groß angelegten Operationen, die sonst unpraktisch oder unmöglich in einer einzigen Anfrage abzuschließen wären.

Warum einen Batch-Prozess verwenden?

Batch-Prozesse sind besonders wertvoll bei der Handhabung großer Datenmengen, die normalerweise einen PHP-Timeout bei normaler Ausführung verursachen würden. Sie zerlegen umfangreiche Operationen in handhabbare Teile und gewährleisten eine zuverlässige Verarbeitung, während sie den Benutzern Fortschrittsfeedback geben.

Lassen Sie uns ein praktisches Szenario betrachten: Stellen Sie sich vor, Sie haben eine Ansicht, die Artikel-Inhaltstypen filtert, bei denen `field_boring` auf TRUE gesetzt ist, und Sie möchten alle löschen. Mit 500+ passenden Artikeln wäre die manuelle Löschung zeitaufwendig und ineffizient. Lassen Sie uns einen Batch-Prozess implementieren, um diese Aufgabe automatisch zu erledigen.

Erforderliche Komponenten

Um unseren Batch-Prozess zu implementieren, benötigen wir drei Dateien:

1. Einen Controller (Delete.php)
2. Modulinformationsdatei (module.info.yml)
3. Routing-Konfiguration (module.routing.yml)

Lassen Sie uns jede Komponente erstellen:

Zuerst erstellen Sie die Modulinformationsdatei:

# module.info.yml
name: Delete
description: 'Artikel löschen'
core: 8.x
type: module
package: Custom

Als nächstes richten Sie die Routing-Konfiguration ein, um Anfragen an '/delete-boring-articles' zu verarbeiten:

# module.routing.yml
module.delete:
 path: '/delete-boring-articles'
 defaults:
   _controller: '\Drupal\module\Controller\Delete::delete'
   _title: 'Langweilige Artikel löschen'
 requirements:
   _permission: 'administer node'

Schließlich erstellen wir unseren Controller, der den Löschprozess steuert:

<?php
namespace Drupal\module\Controller;
use Drupal\Core\Controller\ControllerBase;
use Drupal\node\Entity\Node;
use Symfony\Component\HttpFoundation\RedirectResponse;
/**
* Stellt Batch-Operationen zum Löschen von Artikeln bereit.
*/
class Delete extends ControllerBase {
 /**
  * Initiiert den Batch-Prozess zum Löschen von Artikeln.
  *
  * @return array
  *   Gibt ein Batch-Array zurück.
  */
 public function delete() {
   // Ergebnisse aus unserer Ansicht holen.
   $view_results = views_get_view_result('boring_articles', 'page_1');
   $operations = [];
   // Das Operations-Array aus den Ansichtsergebnissen erstellen.
   foreach ($view_results as $result) {
     $operations[] = [
       [$this, 'batchFunction'],
       [$result->_entity->id()],
     ];
   }
   $batch = [
     'title' => $this->t('Artikel löschen'),
     'operations' => $operations,
     'finished' => [$this, 'finishedCallback'],
     'progressive' => TRUE,
   ];
   batch_set($batch);
   return batch_process();
 }
 /**
  * Verarbeitet eine einzelne Knotenlöschung.
  *
  * @param int $id
  *   Die zu löschende Knoten-ID.
  * @param array $context
  *   Das Batch-Kontext-Array.
  */
 public function batchFunction($id, &$context) {
   try {
     $node = Node::load($id);
     if ($node) {
       $node->delete();
       $context['results'][] = $id;
       $context['message'] = $this->t('Artikel mit ID gelöscht: @id', ['@id' => $id]);
     }
   }
   catch (\Exception $e) {
     $context['error_messages'][] = $this->t('Fehler beim Löschen des Artikels @id: @message', [
       '@id' => $id,
       '@message' => $e->getMessage(),
     ]);
   }
 }
 /**
  * Handhabt den Abschluss des Batches.
  *
  * @param bool $success
  *   Gibt an, ob der Batch-Prozess erfolgreich abgeschlossen wurde.
  * @param array $results
  *   Ein Array von verarbeiteten Knoten-IDs.
  * @param array $operations
  *   Ein Array von nicht verarbeiteten Operationen.
  */
 public function finishedCallback($success, $results, $operations) {
   if ($success) {
     $message = $this->t('Erfolgreich @count Artikel gelöscht.', [
       '@count' => count($results),
     ]);
     $this->messenger()->addMessage($message);
   }
   else {
     $message = $this->t('Ein Fehler ist beim Löschen der Artikel aufgetreten.');
     $this->messenger()->addError($message);
   }
   return new RedirectResponse('/admin/content');
 }
}

Wesentliche Verbesserungen im Code

1. Ordentliche Fehlerbehandlung: Hinzugefügt try-catch Blöcke zur Behandlung von potenziellen Fehlern während der Knotenlöschung.
2. Kontextnutzung: Implementierte ordnungsgemäße Nutzung des Batch-Kontexts zur Nachverfolgung von Fortschritt und Ergebnissen.
3. Dependency Injection: Verwendete ordnungsgemäß die eingebauten Übersetzungs- und Messenger-Dienste von Drupal.
4. Typsicherheit: Hinzugefügt ordnungsgemäße Typ-Hinweise und Dokumentationsblöcke.
5. Fortschrittsverfolgung: Hinzugefügt aussagekräftige Fortschrittsmeldungen während der Batch-Ausführung.
6. Saubere Fertigstellung: Verbesserte den fertigen Callback, um nützliches Feedback zu liefern.

Wichtige Hinweise

1. Testen Sie Batch-Prozesse immer zuerst gründlich in einer Entwicklungsumgebung.
2. Erwägen Sie, einen Bestätigungsschritt vor der Initiierung des Batch-Prozesses hinzuzufügen.
3. Vergessen Sie nicht, Ihre Datenbank zu sichern, bevor Sie zerstörerische Operationen ausführen.
4. Überwachen Sie den Speicherverbrauch, wenn Sie mit sehr großen Datensätzen arbeiten.

Schlussfolgerung

Batch-Prozesse in Drupal 8 bieten eine robuste Lösung für die Handhabung von zeitaufwendigen Operationen, die sonst einen Timeout verursachen oder Serverressourcen belasten würden. Indem wir große Operationen in handhabbare Teile zerlegen, können wir große Datenmengen zuverlässig verarbeiten, während wir die Benutzer über den Fortschritt informieren.

Wenn Sie auf Probleme bei der Implementierung stoßen oder Fragen haben, hinterlassen Sie gerne einen Kommentar unten.