Plugin-Entwicklung

Shopware 6 Plugin entwickeln: Schritt-für-Schritt

Pascal Swertz  ·  4. März 2026  ·  ca. 10 min Lesezeit

Shopware 6 Plugin entwickeln – das klingt für Einsteiger komplex. Dieses Tutorial zeigt dir den gesamten Prozess: von der Plugin-Basis über Services, Events und Subscriber bis zur eigenen Admin-Oberfläche mit Vue.js.

---

Voraussetzungen

Um ein Shopware 6 Plugin zu entwickeln, benötigst du:

• PHP 8.1 oder höher
• Composer installiert
• Eine lokale Shopware 6 Entwicklungsumgebung (z. B. mit DDEV oder Docker)
• Grundkenntnisse in PHP und dem Symfony-Framework

Shopware 6 basiert auf Symfony – wer das Framework kennt, findet sich schnell zurecht. Plugins folgen dem Symfony-Bundle-Konzept und nutzen Dependency Injection, Services und Events.

Schritt 1: Plugin-Struktur anlegen

Ein Shopware 6 Plugin lebt im Verzeichnis custom/plugins/. Die minimale Struktur sieht so aus:

custom/plugins/MeinPlugin/
├── src/
│   └── MeinPlugin.php
└── composer.json

Die Hauptklasse erbt von Shopware\Core\Framework\Plugin. In der composer.json definierst du Name, Autoloading und die Abhängigkeit zu shopware/core.

Schritt 2: Plugin registrieren und aktivieren

Nach dem Anlegen der Dateien installierst und aktivierst du das Plugin über die Shopware-CLI:

bin/console plugin:refresh
bin/console plugin:install --activate MeinPlugin

Alternativ kannst du das Plugin im Admin-Bereich unter Erweiterungen → Meine Erweiterungen aktivieren. Bei jeder Codeänderung im DI-Bereich musst du den Cache leeren:

bin/console cache:clear

Schritt 3: Services und Dependency Injection

Services registrierst du in einer services.xml unter src/Resources/config/services.xml. Shopware nutzt den Symfony DI-Container – Services, Repositories und eigene Handler werden hier eingetragen:

<services>
  <service id="MeinPlugin\Service\MeinService">
    <argument type="service" id="product.repository"/>
  </service>
</services>

Das Produkt-Repository ist eines der am häufigsten genutzten Repositories in Shopware-Plugins. Über den Data Abstraction Layer (DAL) greifst du auf alle Entities zu.

Schritt 4: Events und Subscriber

Shopware 6 nutzt das Symfony EventDispatcher-System. Für eigene Logik bei Shop-Ereignissen (z. B. Bestellungsabschluss, Produktspeicherung) implementierst du einen Subscriber:

class MeinSubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents(): array
    {
        return [
            CheckoutOrderPlacedEvent::class => 'onOrderPlaced',
        ];
    }

    public function onOrderPlaced(CheckoutOrderPlacedEvent $event): void
    {
        // Deine Logik hier
    }
}

Der Subscriber wird in der services.xml mit dem Tag kernel.event_subscriber registriert. So greifst du sauber in den Shopware-Lifecycle ein, ohne Core-Klassen zu überschreiben.

Schritt 5: Admin-Oberfläche mit Vue.js

Für Admin-Erweiterungen nutzt Shopware 6 das eigene Vue.js-basierte Admin-Framework. Eine einfache Admin-Seite entsteht unter:

src/Resources/app/administration/src/
├── main.js
└── module/
    └── mein-modul/
        ├── index.js
        └── page/
            └── mein-page/
                └── index.vue

In der main.js registrierst du das Modul. Shopware baut die Admin-Assets über Webpack – nach Änderungen musst du mit bin/console administration:build neu bauen oder den Watch-Modus nutzen.

Schritt 6: Store API – Eigene Endpoints

Eigene API-Routen für die Storefront implementierst du über AbstractRoute-Klassen und registrierst sie als Store API-Controller. Dies ist besonders relevant für AJAX-Requests aus der Storefront oder für Headless-Commerce-Szenarien.

Häufige Fehler bei der Shopware Plugin-Entwicklung

• Cache nicht geleert: Nach DI-Änderungen immer cache:clear ausführen.
• Falsche Plugin-Version: Die Shopware-Version muss in der composer.json des Plugins angegeben sein.
• Core überschreiben statt erweitern: Nutze Decorator-Pattern und Events statt Core-Klassen zu verändern – so bleibt das Plugin updatefähig.
• Keine Dokumentation: Für Agentur-Übergaben ist technische Dokumentation essenziell.

Fazit

Shopware 6 Plugin-Entwicklung folgt dem Symfony-Standard – wer das Framework kennt, kann produktiv einsteigen. Der Schlüssel liegt in sauberer Domänenlogik: Services, Subscriber und Admin-Module klar trennen, Core nie direkt überschreiben und Plugins immer mit Blick auf Updatefähigkeit schreiben.

Du möchtest ein Shopware Plugin entwickeln lassen oder brauchst Unterstützung bei einem bestehenden Projekt? Jetzt Anfrage stellen.

---