XOOPS Architektur

Dieses Dokument bietet einen umfassenden Überblick über die XOOPS-Systemarchitektur und erläutert, wie die verschiedenen Komponenten zusammenarbeiten, um ein flexibles und erweiterbares Content-Management-System zu schaffen.

Übersicht

XOOPS folgt einer modularen Architektur, die Funktionen in verschiedene Schichten unterteilt. Das System basiert auf mehreren Kernprinzipien:

Modularität: Funktionalität ist in unabhängige, installierbare Module organisiert
Erweiterbarkeit: Das System kann ohne Änderung von Core-Code erweitert werden
Abstraktion: Datenbank- und Präsentationsschichten sind von der Geschäftslogik abstrahiert
Sicherheit: Integrierte Sicherheitsmechanismen schützen vor häufigen Schwachstellen

Systemschichten

graph TB
    subgraph Presentation["🎨 Presentation Layer"]
        Themes["Themes"]
        Templates["Smarty Templates"]
        Blocks["Blocks"]
    end

    subgraph Application["⚙️ Application Layer"]
        Modules["Modules"]
        Preloads["Preloads"]
        Controllers["Controllers"]
        BlockHandlers["Block Handlers"]
    end

    subgraph Domain["📦 Domain Layer"]
        XoopsObject["XoopsObject"]
        Handlers["Object Handlers"]
        Criteria["Criteria System"]
    end

    subgraph Infrastructure["🔧 Infrastructure Layer"]
        Database["XoopsDatabase"]
        Cache["Cache System"]
        Session["Session Manager"]
        Security["Security Layer"]
    end

    Presentation --> Application
    Application --> Domain
    Domain --> Infrastructure

    style Presentation fill:#e8f5e9,stroke:#388e3c
    style Application fill:#e3f2fd,stroke:#1976d2
    style Domain fill:#fff3e0,stroke:#f57c00
    style Infrastructure fill:#fce4ec,stroke:#c2185b

1. Präsentationsschicht

Die Präsentationsschicht behandelt die Benutzeroberflächen-Darstellung unter Verwendung der Smarty-Template-Engine.

Schlüsselkomponenten:

Themes: Visuelles Styling und Layout
Smarty Templates: Dynamische Content-Rendering
Blocks: Wiederverwendbare Content-Widgets

2. Anwendungsschicht

Die Anwendungsschicht enthält Geschäftslogik, Controller und Modulfunktionalität.

Schlüsselkomponenten:

Module: In sich geschlossene Funktionalitätspakete
Handler: Datenmanipulationsklassen
Preloads: Event-Listener und Hooks

3. Domain-Schicht

Die Domain-Schicht enthält Kerngeschäftsobjekte und -regeln.

Schlüsselkomponenten:

XoopsObject: Basisklasse für alle Domain-Objekte
Handler: CRUD-Operationen für Domain-Objekte

4. Infrastruktur-Schicht

Die Infrastruktur-Schicht stellt Kerndienste wie Datenbankzugriff und Caching bereit.

Request-Lebenszyklus

Das Verständnis des Request-Lebenszyklus ist entscheidend für effektive XOOPS-Entwicklung.

XOOPS 2.5.x Page Controller Flow

Das aktuelle XOOPS 2.5.x nutzt ein Page Controller Pattern, wobei jede PHP-Datei ihren eigenen Request verarbeitet. Globals ($xoopsDB, $xoopsUser, $xoopsTpl usw.) werden während des Bootstrap initialisiert und sind während der gesamten Ausführung verfügbar.

sequenceDiagram
    participant Browser
    participant Entry as modules/mymod/index.php
    participant Main as mainfile.php
    participant Kernel as XOOPS Kernel
    participant DB as $xoopsDB
    participant User as $xoopsUser
    participant Handler as MyObjectHandler
    participant Tpl as $xoopsTpl (Smarty)
    participant Theme

    Browser->>Entry: GET /modules/mymod/index.php

    rect rgb(240, 248, 255)
        Note over Entry,User: Bootstrap Phase (mainfile.php)
        Entry->>Main: include mainfile.php
        Main->>Kernel: Initialize Core
        Kernel->>DB: Create XoopsDatabase (singleton)
        Kernel->>User: Load Session → $xoopsUser
        Kernel->>Tpl: Initialize Smarty → $xoopsTpl
        Main-->>Entry: Globals Ready
    end

    rect rgb(255, 250, 240)
        Note over Entry,Handler: Page Controller Execution
        Entry->>Handler: xoops_getModuleHandler('myobject')
        Handler->>DB: query via Criteria
        DB-->>Handler: Result Set
        Handler-->>Entry: XoopsObject[]
    end

    rect rgb(240, 255, 240)
        Note over Entry,Theme: Rendering Phase
        Entry->>Tpl: $xoopsTpl->assign('items', $objects)
        Entry->>Theme: include header.php
        Entry->>Tpl: $xoopsTpl->display('mymod_index.tpl')
        Entry->>Theme: include footer.php
        Theme-->>Browser: Complete HTML Page
    end

Wichtige Globals in 2.5.x

Global	Typ	Initialisiert	Zweck
`$xoopsDB`	`XoopsDatabase`	Bootstrap	Datenbankverbindung (Singleton)
`$xoopsUser`	`XoopsUser\|null`	Session-Laden	Aktuell angemeldeter Benutzer
`$xoopsTpl`	`XoopsTpl`	Template-Init	Smarty-Template-Engine
`$xoopsModule`	`XoopsModule`	Module-Laden	Aktueller Modulkontext
`$xoopsConfig`	`array`	Config-Laden	Systemkonfiguration

1. Bootstrap-Phase

// mainfile.php ist der Einstiegspunkt
include_once XOOPS_ROOT_PATH . '/mainfile.php';

// Kern-Initialisierung
$xoops = Xoops::getInstance();
$xoops->boot();

Schritte:

Konfiguration laden (mainfile.php)
Autoloader initialisieren
Error Handling einrichten
Datenbankverbindung etablieren
Benutzersession laden
Smarty-Template-Engine initialisieren

2. Routing-Phase

// Request-Routing zu entsprechendem Modul
$module = $GLOBALS['xoopsModule'];
$controller = $module->getController();
$controller->dispatch($request);

Schritte:

Request-URL analysieren
Zielmodul identifizieren
Modulkonfiguration laden
Berechtigungen prüfen
Zu entsprechendem Handler routen

3. Ausführungsphase

// Controller-Ausführung
$data = $handler->getObjects($criteria);
$xoopsTpl->assign('items', $data);

Schritte:

Controller-Logik ausführen
Mit Datenschicht interagieren
Geschäftsregeln verarbeiten
View-Daten vorbereiten

4. Rendering-Phase

// Template-Rendering
include XOOPS_ROOT_PATH . '/header.php';
$xoopsTpl->display('db:module_template.tpl');
include XOOPS_ROOT_PATH . '/footer.php';

Schritte:

Theme-Layout anwenden
Modul-Template rendern
Blocks verarbeiten
Response ausgeben

Kernkomponenten

XoopsObject

Die Basisklasse für alle Datenobjekte in XOOPS.

<?php
class MyModuleItem extends XoopsObject
{
    public function __construct()
    {
        $this->initVar('id', XOBJ_DTYPE_INT, null, false);
        $this->initVar('title', XOBJ_DTYPE_TXTBOX, '', true, 255);
        $this->initVar('content', XOBJ_DTYPE_TXTAREA, '', false);
        $this->initVar('created', XOBJ_DTYPE_INT, time(), false);
    }
}

Wichtige Methoden:

initVar() - Objekteigenschaften definieren
getVar() - Eigenschaftswerte abrufen
setVar() - Eigenschaftswerte setzen
assignVars() - Massenweise aus Array zuweisen

XoopsPersistableObjectHandler

Verwaltet CRUD-Operationen für XoopsObject-Instanzen.

<?php
class MyModuleItemHandler extends XoopsPersistableObjectHandler
{
    public function __construct(\XoopsDatabase $db)
    {
        parent::__construct($db, 'mymodule_items', 'MyModuleItem', 'id', 'title');
    }

    public function getActiveItems($limit = 10)
    {
        $criteria = new CriteriaCompo();
        $criteria->add(new Criteria('status', 1));
        $criteria->setSort('created');
        $criteria->setOrder('DESC');
        $criteria->setLimit($limit);

        return $this->getObjects($criteria);
    }
}

Wichtige Methoden:

create() - Neue Objektinstanz erstellen
get() - Objekt nach ID abrufen
insert() - Objekt in Datenbank speichern
delete() - Objekt aus Datenbank entfernen
getObjects() - Mehrere Objekte abrufen
getCount() - Passendes Objekt zählen

Modul-Struktur

Jedes XOOPS-Modul folgt einer Standard-Verzeichnisstruktur:

modules/mymodule/
├── class/                  # PHP-Klassen
│   ├── MyModuleItem.php
│   └── MyModuleItemHandler.php
├── include/                # Include-Dateien
│   ├── common.php
│   └── functions.php
├── templates/              # Smarty-Templates
│   ├── mymodule_index.tpl
│   └── mymodule_item.tpl
├── admin/                  # Admin-Bereich
│   ├── index.php
│   └── menu.php
├── language/               # Übersetzungen
│   └── english/
│       ├── main.php
│       └── modinfo.php
├── sql/                    # Datenbankschema
│   └── mysql.sql
├── xoops_version.php       # Modul-Info
├── index.php               # Modul-Einstieg
└── header.php              # Modul-Header

Dependency Injection Container

Moderne XOOPS-Entwicklung kann Dependency Injection für bessere Testbarkeit nutzen.

Basis Container Implementation

<?php
class XoopsDependencyContainer
{
    private array $services = [];

    public function register(string $name, callable $factory): void
    {
        $this->services[$name] = $factory;
    }

    public function resolve(string $name): mixed
    {
        if (!isset($this->services[$name])) {
            throw new \InvalidArgumentException("Service not found: $name");
        }

        $factory = $this->services[$name];

        if (is_callable($factory)) {
            return $factory($this);
        }

        return $factory;
    }

    public function has(string $name): bool
    {
        return isset($this->services[$name]);
    }
}

PSR-11 kompatibler Container

<?php
namespace Xmf\Di;

use Psr\Container\ContainerInterface;

class BasicContainer implements ContainerInterface
{
    protected array $definitions = [];

    public function set(string $id, mixed $value): void
    {
        $this->definitions[$id] = $value;
    }

    public function get(string $id): mixed
    {
        if (!$this->has($id)) {
            throw new \InvalidArgumentException("Service not found: $id");
        }

        $entry = $this->definitions[$id];

        if (is_callable($entry)) {
            return $entry($this);
        }

        return $entry;
    }

    public function has(string $id): bool
    {
        return isset($this->definitions[$id]);
    }
}

Verwendungsbeispiel

<?php
// Service-Registrierung
$container = new XoopsDependencyContainer();

$container->register('database', function () {
    return XoopsDatabaseFactory::getDatabaseConnection();
});

$container->register('userHandler', function ($c) {
    return new XoopsUserHandler($c->resolve('database'));
});

// Service-Auflösung
$userHandler = $container->resolve('userHandler');
$user = $userHandler->get($userId);

Erweiterungspunkte

XOOPS bietet mehrere Erweiterungsmechanismen:

1. Preloads

Preloads ermöglichen es Modulen, sich in Core-Events einzuklinken.

<?php
class MymoduleCorePreload extends XoopsPreloadItem
{
    public static function eventCoreHeaderEnd($args)
    {
        // Ausführen, wenn die Header-Verarbeitung endet
    }

    public static function eventCoreFooterStart($args)
    {
        // Ausführen, wenn die Footer-Verarbeitung startet
    }
}

2. Plugins

Plugins erweitern spezifische Funktionalität innerhalb von Modulen.

<?php
class MymoduleNotifyPlugin
{
    public function onItemCreate($item)
    {
        // Benachrichtigung senden, wenn Item erstellt wird
    }
}

3. Filter

Filter ändern Daten, während sie das System durchlaufen.

<?php
// Content-Filter-Beispiel
$myts = MyTextSanitizer::getInstance();
$content = $myts->displayTarea($rawContent, 1, 1, 1);

Best Practices

Code-Organisation

Verwenden Sie Namespaces für neue Code:

namespace XoopsModules\MyModule;

class Item extends \XoopsObject
{
    // Implementierung
}

Folgen Sie PSR-4 Autoloading:

{
    "autoload": {
        "psr-4": {
            "XoopsModules\\MyModule\\": "class/"
        }
    }
}

Trennen Sie Belange:
- Domain-Logik in class/
- Präsentation in templates/
- Controller im Modul-Root

Performance

Verwenden Sie Caching für teure Operationen
Lazy Load Ressourcen wenn möglich
Minimieren Sie Datenbankabfragen durch Criteria-Batching
Optimieren Sie Templates durch Vermeidung komplexer Logik

Sicherheit

Validieren Sie alle Eingaben mit Xmf\Request
Escapen Sie Ausgabe in Templates
Verwenden Sie Prepared Statements für Datenbankabfragen
Prüfen Sie Berechtigungen vor sensiblen Operationen

XOOPS Architektur

Übersicht

Systemschichten

1. Präsentationsschicht

2. Anwendungsschicht

3. Domain-Schicht

4. Infrastruktur-Schicht

Request-Lebenszyklus

XOOPS 2.5.x Page Controller Flow

Wichtige Globals in 2.5.x

1. Bootstrap-Phase

2. Routing-Phase

3. Ausführungsphase

4. Rendering-Phase

Kernkomponenten

XoopsObject

XoopsPersistableObjectHandler

Modul-Struktur

Dependency Injection Container

Basis Container Implementation

PSR-11 kompatibler Container

Verwendungsbeispiel

Erweiterungspunkte

1. Preloads

2. Plugins

3. Filter

Best Practices

Code-Organisation

Performance

Sicherheit

Verwandte Dokumentation