Enable Discovery debug logging for production troubleshooting
- Add DISCOVERY_LOG_LEVEL=debug - Add DISCOVERY_SHOW_PROGRESS=true - Temporary changes for debugging InitializerProcessor fixes on production
This commit is contained in:
528
docs/architecture/components.md
Normal file
528
docs/architecture/components.md
Normal file
@@ -0,0 +1,528 @@
|
||||
# Hauptkomponenten
|
||||
|
||||
Diese Dokumentation beschreibt die Hauptkomponenten des Frameworks und ihre Verantwortlichkeiten. Jede Komponente ist so konzipiert, dass sie unabhängig verwendet oder durch eine benutzerdefinierte Implementierung ersetzt werden kann.
|
||||
|
||||
## Kernkomponenten
|
||||
|
||||
### Container
|
||||
|
||||
Der Container ist das Herzstück des Frameworks und verantwortlich für die Dependency Injection. Er bietet folgende Funktionen:
|
||||
|
||||
- Registrierung von Diensten
|
||||
- Auflösung von Abhängigkeiten
|
||||
- Verwaltung des Lebenszyklus von Diensten
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung des Containers
|
||||
$container = new Container();
|
||||
$container->bind(LoggerInterface::class, FileLogger::class);
|
||||
$container->singleton(DatabaseInterface::class, function () {
|
||||
return new Database(config('database'));
|
||||
});
|
||||
|
||||
$logger = $container->get(LoggerInterface::class);
|
||||
```
|
||||
|
||||
### Router
|
||||
|
||||
Der Router ist verantwortlich für das Mapping von HTTP-Anfragen zu Controller-Aktionen. Er unterstützt:
|
||||
|
||||
- Routendefinitionen für verschiedene HTTP-Methoden
|
||||
- Routengruppen mit gemeinsamen Präfixen und Middleware
|
||||
- Routenparameter und Einschränkungen
|
||||
- Namensräume für Routen
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung des Routers
|
||||
$router = new Router();
|
||||
$router->get('/users', [UserController::class, 'index']);
|
||||
$router->post('/users', [UserController::class, 'store']);
|
||||
$router->get('/users/{id}', [UserController::class, 'show'])->where('id', '[0-9]+');
|
||||
|
||||
$router->group('/admin', function (Router $router) {
|
||||
$router->get('/dashboard', [AdminController::class, 'dashboard']);
|
||||
})->middleware(AuthMiddleware::class);
|
||||
```
|
||||
|
||||
### Request
|
||||
|
||||
Die Request-Klasse kapselt eine HTTP-Anfrage und bietet Methoden für den Zugriff auf:
|
||||
|
||||
- Anfrageparameter
|
||||
- Header
|
||||
- Cookies
|
||||
- Dateien
|
||||
- Sitzungsdaten
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Request-Klasse
|
||||
$name = $request->input('name');
|
||||
$page = $request->query('page', 1);
|
||||
$token = $request->header('Authorization');
|
||||
$file = $request->file('avatar');
|
||||
$remember = $request->cookie('remember', false);
|
||||
$user = $request->session()->get('user');
|
||||
```
|
||||
|
||||
### Response
|
||||
|
||||
Die Response-Klasse repräsentiert eine HTTP-Antwort und bietet Methoden für:
|
||||
|
||||
- Setzen von Statuscodes
|
||||
- Hinzufügen von Headern
|
||||
- Setzen von Cookies
|
||||
- Umleitung zu anderen URLs
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Response-Klasse
|
||||
$response = new Response('Hello World', 200);
|
||||
$response->header('Content-Type', 'text/plain');
|
||||
$response->cookie('visited', true, 60 * 24);
|
||||
|
||||
$redirectResponse = new RedirectResponse('/dashboard');
|
||||
$jsonResponse = new JsonResponse(['name' => 'John']);
|
||||
$viewResponse = new ViewResponse('welcome', ['user' => $user]);
|
||||
```
|
||||
|
||||
### Middleware
|
||||
|
||||
Middleware-Komponenten verarbeiten Anfragen vor und nach der Controller-Aktion. Sie können:
|
||||
|
||||
- Anfragen validieren
|
||||
- Benutzer authentifizieren
|
||||
- Antworten transformieren
|
||||
- Anfragen protokollieren
|
||||
|
||||
```php
|
||||
// Beispiel für eine Middleware
|
||||
class AuthMiddleware implements MiddlewareInterface
|
||||
{
|
||||
public function process(Request $request, RequestHandlerInterface $handler): Response
|
||||
{
|
||||
if (!$this->isAuthenticated($request)) {
|
||||
return new RedirectResponse('/login');
|
||||
}
|
||||
|
||||
return $handler->handle($request);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Datenbankkomponenten
|
||||
|
||||
### Database
|
||||
|
||||
Die Database-Komponente bietet eine Abstraktionsschicht für Datenbankoperationen. Sie unterstützt:
|
||||
|
||||
- Verschiedene Datenbanktypen (MySQL, SQLite, PostgreSQL)
|
||||
- Abfragen mit einem Query Builder
|
||||
- Transaktionen
|
||||
- Migrationen
|
||||
- Seeding
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Database-Komponente
|
||||
$users = $database->table('users')
|
||||
->where('active', true)
|
||||
->orderBy('name')
|
||||
->limit(10)
|
||||
->get();
|
||||
|
||||
$database->transaction(function ($db) {
|
||||
$db->table('users')->insert(['name' => 'John']);
|
||||
$db->table('profiles')->insert(['user_id' => $db->lastInsertId()]);
|
||||
});
|
||||
```
|
||||
|
||||
### Model
|
||||
|
||||
Die Model-Komponente bietet eine objektorientierte Schnittstelle für Datenbankoperationen. Sie unterstützt:
|
||||
|
||||
- Active Record Pattern
|
||||
- Beziehungen zwischen Modellen
|
||||
- Attribute und Mutators
|
||||
- Ereignisse
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Model-Komponente
|
||||
$user = new User();
|
||||
$user->name = 'John';
|
||||
$user->email = 'john@example.com';
|
||||
$user->save();
|
||||
|
||||
$users = User::where('active', true)->get();
|
||||
$user = User::find(1);
|
||||
$posts = $user->posts()->where('published', true)->get();
|
||||
```
|
||||
|
||||
### Migration
|
||||
|
||||
Die Migration-Komponente ermöglicht die Versionierung der Datenbankstruktur. Sie unterstützt:
|
||||
|
||||
- Erstellen und Ändern von Tabellen
|
||||
- Hinzufügen und Entfernen von Indizes
|
||||
- Rollback von Änderungen
|
||||
|
||||
```php
|
||||
// Beispiel für eine Migration
|
||||
class CreateUsersTable extends Migration
|
||||
{
|
||||
public function up(): void
|
||||
{
|
||||
$this->schema->create('users', function (Blueprint $table) {
|
||||
$table->id();
|
||||
$table->string('name');
|
||||
$table->string('email')->unique();
|
||||
$table->string('password');
|
||||
$table->boolean('active')->default(true);
|
||||
$table->timestamps();
|
||||
});
|
||||
}
|
||||
|
||||
public function down(): void
|
||||
{
|
||||
$this->schema->dropIfExists('users');
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## HTTP-Komponenten
|
||||
|
||||
### Controller
|
||||
|
||||
Controller sind verantwortlich für die Verarbeitung von HTTP-Anfragen und die Rückgabe von Antworten. Sie bieten:
|
||||
|
||||
- Zugriff auf Request- und Response-Objekte
|
||||
- Validierung von Eingaben
|
||||
- Rendering von Views
|
||||
- Umleitung zu anderen URLs
|
||||
|
||||
```php
|
||||
// Beispiel für einen Controller
|
||||
class UserController extends Controller
|
||||
{
|
||||
public function index(Request $request): Response
|
||||
{
|
||||
$users = User::all();
|
||||
return $this->view('users.index', ['users' => $users]);
|
||||
}
|
||||
|
||||
public function store(Request $request): Response
|
||||
{
|
||||
$this->validate($request, [
|
||||
'name' => 'required|string|max:255',
|
||||
'email' => 'required|email|unique:users,email',
|
||||
]);
|
||||
|
||||
$user = User::create($request->only(['name', 'email']));
|
||||
return $this->redirect('/users')->with('success', 'User created');
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### View
|
||||
|
||||
Die View-Komponente ist verantwortlich für das Rendering von HTML-Templates. Sie unterstützt:
|
||||
|
||||
- Template-Dateien mit PHP-Syntax
|
||||
- Layouts und Partials
|
||||
- Template-Vererbung
|
||||
- Datenübergabe an Templates
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der View-Komponente
|
||||
$view = new View('users.show');
|
||||
$view->with('user', $user);
|
||||
$html = $view->render();
|
||||
|
||||
// Oder über den Controller
|
||||
return $this->view('users.show', ['user' => $user]);
|
||||
```
|
||||
|
||||
### Session
|
||||
|
||||
Die Session-Komponente verwaltet Benutzersitzungen. Sie unterstützt:
|
||||
|
||||
- Verschiedene Session-Backends (Datei, Datenbank, Redis)
|
||||
- Flash-Daten
|
||||
- Session-Regeneration
|
||||
- Session-Timeout
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Session-Komponente
|
||||
$session = new Session();
|
||||
$session->put('user_id', 1);
|
||||
$userId = $session->get('user_id');
|
||||
$session->flash('message', 'Welcome back!');
|
||||
$session->regenerate();
|
||||
$session->forget('user_id');
|
||||
```
|
||||
|
||||
### Cookie
|
||||
|
||||
Die Cookie-Komponente verwaltet HTTP-Cookies. Sie unterstützt:
|
||||
|
||||
- Setzen und Lesen von Cookies
|
||||
- Verschlüsselung von Cookie-Werten
|
||||
- Cookie-Parameter (Lebensdauer, Pfad, Domain, Secure, HttpOnly)
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Cookie-Komponente
|
||||
$cookie = new Cookie('name', 'value', 60 * 24); // 1 Tag
|
||||
$cookie->setPath('/');
|
||||
$cookie->setSecure(true);
|
||||
$cookie->setHttpOnly(true);
|
||||
|
||||
$response->setCookie($cookie);
|
||||
$value = $request->cookie('name');
|
||||
```
|
||||
|
||||
## Sicherheitskomponenten
|
||||
|
||||
### Validator
|
||||
|
||||
Die Validator-Komponente validiert Benutzereingaben. Sie unterstützt:
|
||||
|
||||
- Verschiedene Validierungsregeln
|
||||
- Benutzerdefinierte Validierungsregeln
|
||||
- Fehlermeldungen
|
||||
- Validierung von Arrays und verschachtelten Daten
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Validator-Komponente
|
||||
$validator = new Validator($data, [
|
||||
'name' => 'required|string|max:255',
|
||||
'email' => 'required|email|unique:users,email',
|
||||
'password' => 'required|string|min:8|confirmed',
|
||||
'age' => 'integer|min:18',
|
||||
]);
|
||||
|
||||
if ($validator->fails()) {
|
||||
$errors = $validator->errors();
|
||||
// Fehler behandeln
|
||||
}
|
||||
```
|
||||
|
||||
### Authentication
|
||||
|
||||
Die Authentication-Komponente verwaltet die Benutzerauthentifizierung. Sie unterstützt:
|
||||
|
||||
- Verschiedene Authentifizierungsmethoden (Session, Token, Basic)
|
||||
- Mehrere Authentifizierungsquellen
|
||||
- Remember-Me-Funktionalität
|
||||
- Passwort-Hashing und -Verifizierung
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Authentication-Komponente
|
||||
$auth = new Authentication();
|
||||
if ($auth->attempt(['email' => $email, 'password' => $password], $remember)) {
|
||||
// Erfolgreiche Anmeldung
|
||||
}
|
||||
|
||||
$user = $auth->user();
|
||||
$auth->logout();
|
||||
```
|
||||
|
||||
### Authorization
|
||||
|
||||
Die Authorization-Komponente verwaltet die Benutzerautorisierung. Sie unterstützt:
|
||||
|
||||
- Rollenbasierte Zugriffskontrolle
|
||||
- Fähigkeitsbasierte Zugriffskontrolle
|
||||
- Richtlinien für komplexe Autorisierungslogik
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Authorization-Komponente
|
||||
$authorization = new Authorization();
|
||||
$authorization->define('edit-post', function (User $user, Post $post) {
|
||||
return $user->id === $post->user_id || $user->hasRole('editor');
|
||||
});
|
||||
|
||||
if ($authorization->can($user, 'edit-post', $post)) {
|
||||
// Benutzer darf den Beitrag bearbeiten
|
||||
}
|
||||
```
|
||||
|
||||
### CSRF
|
||||
|
||||
Die CSRF-Komponente schützt vor Cross-Site Request Forgery. Sie unterstützt:
|
||||
|
||||
- Generierung von CSRF-Tokens
|
||||
- Validierung von CSRF-Tokens
|
||||
- Automatische Integration in Formulare
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der CSRF-Komponente
|
||||
$csrf = new CsrfProtection();
|
||||
$token = $csrf->generateToken();
|
||||
|
||||
// In einem Formular
|
||||
echo '<input type="hidden" name="_token" value="' . $token . '">';
|
||||
|
||||
// Validierung
|
||||
if (!$csrf->validateToken($request->input('_token'))) {
|
||||
// Ungültiges Token
|
||||
}
|
||||
```
|
||||
|
||||
### WAF
|
||||
|
||||
Die Web Application Firewall (WAF) schützt vor gängigen Angriffen. Sie unterstützt:
|
||||
|
||||
- Erkennung und Blockierung von SQL-Injection
|
||||
- Erkennung und Blockierung von XSS
|
||||
- Erkennung und Blockierung von Command Injection
|
||||
- Erkennung und Blockierung von Path Traversal
|
||||
- Maschinelles Lernen zur Erkennung von Anomalien
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der WAF-Komponente
|
||||
$waf = new WebApplicationFirewall();
|
||||
$waf->addRule(new SqlInjectionRule());
|
||||
$waf->addRule(new XssRule());
|
||||
|
||||
if ($waf->detect($request)) {
|
||||
// Angriff erkannt
|
||||
$waf->block($request);
|
||||
}
|
||||
```
|
||||
|
||||
## Weitere Komponenten
|
||||
|
||||
### Cache
|
||||
|
||||
Die Cache-Komponente bietet eine einheitliche Schnittstelle für verschiedene Cache-Backends. Sie unterstützt:
|
||||
|
||||
- Verschiedene Cache-Treiber (Datei, Redis, Memcached, Memory)
|
||||
- Cache-Tags
|
||||
- Cache-Invalidierung
|
||||
- Cache-Prefixing
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Cache-Komponente
|
||||
$cache = new Cache();
|
||||
$cache->put('key', 'value', 60); // 60 Minuten
|
||||
$value = $cache->get('key', 'default');
|
||||
$cache->has('key');
|
||||
$cache->forget('key');
|
||||
$cache->flush();
|
||||
|
||||
$cache->tags(['users', 'profiles'])->put('user:1', $user, 60);
|
||||
```
|
||||
|
||||
### Logger
|
||||
|
||||
Die Logger-Komponente protokolliert Anwendungsereignisse. Sie unterstützt:
|
||||
|
||||
- Verschiedene Log-Level (Debug, Info, Warning, Error, Critical)
|
||||
- Verschiedene Log-Handler (Datei, Syslog, Slack, E-Mail)
|
||||
- Kontextdaten für Log-Einträge
|
||||
- Log-Rotation
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Logger-Komponente
|
||||
$logger = new Logger();
|
||||
$logger->debug('Debug-Nachricht');
|
||||
$logger->info('Info-Nachricht');
|
||||
$logger->warning('Warnung', ['user_id' => 1]);
|
||||
$logger->error('Fehler', ['exception' => $exception]);
|
||||
$logger->critical('Kritischer Fehler', ['data' => $data]);
|
||||
```
|
||||
|
||||
### Event
|
||||
|
||||
Die Event-Komponente implementiert ein Publish-Subscribe-Muster. Sie unterstützt:
|
||||
|
||||
- Ereignisregistrierung und -auslösung
|
||||
- Ereignislistener
|
||||
- Ereignisabonnenten
|
||||
- Ereignispriorisierung
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Event-Komponente
|
||||
$eventDispatcher = new EventDispatcher();
|
||||
$eventDispatcher->addListener(UserRegistered::class, SendWelcomeEmail::class);
|
||||
$eventDispatcher->addListener(UserRegistered::class, function (UserRegistered $event) {
|
||||
// Benutzerdefinierte Logik
|
||||
});
|
||||
|
||||
$eventDispatcher->dispatch(new UserRegistered($user));
|
||||
```
|
||||
|
||||
### Console
|
||||
|
||||
Die Console-Komponente bietet ein Kommandozeilen-Interface für die Anwendung. Sie unterstützt:
|
||||
|
||||
- Benutzerdefinierte Befehle
|
||||
- Eingabeargumente und -optionen
|
||||
- Interaktive Eingabe
|
||||
- Ausgabeformatierung
|
||||
|
||||
```php
|
||||
// Beispiel für einen Konsolenbefehl
|
||||
class MigrateCommand extends Command
|
||||
{
|
||||
protected string $name = 'db:migrate';
|
||||
protected string $description = 'Run database migrations';
|
||||
|
||||
public function handle(Input $input, Output $output): int
|
||||
{
|
||||
$output->writeln('Running migrations...');
|
||||
// Migrationen ausführen
|
||||
$output->success('Migrations completed successfully');
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Filesystem
|
||||
|
||||
Die Filesystem-Komponente bietet eine Abstraktionsschicht für Dateisystemoperationen. Sie unterstützt:
|
||||
|
||||
- Lokale und entfernte Dateisysteme
|
||||
- Datei- und Verzeichnisoperationen
|
||||
- Dateimetadaten
|
||||
- Dateispeicherung und -abruf
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Filesystem-Komponente
|
||||
$filesystem = new Filesystem();
|
||||
$filesystem->write('path/to/file.txt', 'Inhalt');
|
||||
$content = $filesystem->read('path/to/file.txt');
|
||||
$filesystem->delete('path/to/file.txt');
|
||||
$filesystem->createDirectory('path/to/directory');
|
||||
$files = $filesystem->listContents('path/to/directory');
|
||||
```
|
||||
|
||||
### Queue
|
||||
|
||||
Die Queue-Komponente ermöglicht die asynchrone Verarbeitung von Aufgaben. Sie unterstützt:
|
||||
|
||||
- Verschiedene Queue-Treiber (Datenbank, Redis, Beanstalkd)
|
||||
- Verzögerte Aufgaben
|
||||
- Aufgabenpriorisierung
|
||||
- Fehlerbehandlung und Wiederholungsversuche
|
||||
|
||||
```php
|
||||
// Beispiel für die Verwendung der Queue-Komponente
|
||||
$queue = new Queue();
|
||||
$queue->push(new SendEmailJob($user, $message));
|
||||
$queue->later(60, new CleanupJob()); // 60 Sekunden verzögert
|
||||
|
||||
// Verarbeitung einer Aufgabe
|
||||
class SendEmailJob implements JobInterface
|
||||
{
|
||||
public function __construct(private User $user, private string $message) {}
|
||||
|
||||
public function handle(): void
|
||||
{
|
||||
// E-Mail senden
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Weitere Informationen
|
||||
|
||||
- [Architekturübersicht](overview.md): Überblick über die Architektur des Frameworks.
|
||||
- [Entwurfsmuster](patterns.md): Erläuterung der im Framework verwendeten Entwurfsmuster.
|
||||
- [Komponentendokumentation](../components/README.md): Detaillierte Dokumentation der einzelnen Komponenten.
|
||||
Reference in New Issue
Block a user