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:
@@ -1,149 +0,0 @@
|
||||
# Projektstruktur-Dokumentation
|
||||
|
||||
## Übersicht
|
||||
|
||||
Diese Dokumentation bietet einen Überblick über die Architektur und Struktur des Projekts. Die Anwendung folgt einer modularen, serviceorientierten Architektur mit klarer Trennung von Verantwortlichkeiten.
|
||||
|
||||
## Hauptverzeichnisse
|
||||
|
||||
### `/src`
|
||||
|
||||
Das Hauptverzeichnis für den Anwendungscode, unterteilt in mehrere Unterverzeichnisse:
|
||||
|
||||
#### `/src/Framework`
|
||||
|
||||
Enthält das Framework mit grundlegenden Infrastrukturkomponenten:
|
||||
|
||||
- **Analytics**: System zur Erfassung und Analyse von Anwendungsdaten
|
||||
- **Attributes**: Attribute/Annotations für Metadaten
|
||||
- **Cache**: Caching-Mechanismen
|
||||
- **CommandBus**: Command-Handling-Komponenten
|
||||
- **Config**: Konfigurationsverwaltung
|
||||
- **Console**: Konsolenanwendung und -befehle
|
||||
- **Core**: Kernkomponenten und Events
|
||||
- **DI**: Dependency-Injection-Container
|
||||
- **ErrorHandling**: Fehlerbehandlungsmechanismen
|
||||
- **EventBus**: Event-Handling-System
|
||||
- **Exception**: Framework-Exceptions
|
||||
- **Filesystem**: Dateisystemoperationen
|
||||
- **Http**: HTTP-Request/Response-Handling
|
||||
- **HttpClient**: HTTP-Client für externe API-Aufrufe
|
||||
- **Logging**: Logging-Infrastruktur
|
||||
- **Performance**: Performance-Monitoring
|
||||
- **Queue**: Nachrichtenwarteschlangen
|
||||
- **Redis**: Redis-Integration
|
||||
- **Router**: URL-Routing
|
||||
- **StaticSite**: Statische Site-Generation
|
||||
- **Validation**: Datenvalidierung
|
||||
- **View**: Template-Rendering
|
||||
|
||||
#### `/src/Application`
|
||||
|
||||
Anwendungsspezifische Komponenten, die das Framework nutzen.
|
||||
|
||||
#### `/src/Domain`
|
||||
|
||||
Domain-Modelle, Entities und Business-Logik.
|
||||
|
||||
#### `/src/Infrastructure`
|
||||
|
||||
Infrastrukturkomponenten, die externe Systeme integrieren.
|
||||
|
||||
#### `/src/Config`
|
||||
|
||||
Konfigurationsdateien für verschiedene Module.
|
||||
|
||||
## Framework-Architektur
|
||||
|
||||
### Dependency Injection
|
||||
|
||||
Das System nutzt einen leistungsfähigen DI-Container zur Verwaltung von Services:
|
||||
|
||||
```php
|
||||
#[Initializer]
|
||||
class ServiceInitializer
|
||||
{
|
||||
public function __invoke(Container $container): Service
|
||||
{
|
||||
// Service erstellen und zurückgeben
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Event-System
|
||||
|
||||
Ein Event-System ermöglicht lose Kopplung zwischen Komponenten:
|
||||
|
||||
```php
|
||||
$eventDispatcher->addHandler(EventClass::class, function($event) {
|
||||
// Event verarbeiten
|
||||
});
|
||||
```
|
||||
|
||||
### HTTP-Pipeline
|
||||
|
||||
HTTP-Requests durchlaufen eine Middleware-Pipeline:
|
||||
|
||||
```php
|
||||
class CustomMiddleware implements Middleware
|
||||
{
|
||||
public function process(Request $request, callable $next): Response
|
||||
{
|
||||
// Request verarbeiten
|
||||
$response = $next($request);
|
||||
// Response verarbeiten
|
||||
return $response;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Module und ihre Interaktionen
|
||||
|
||||
### Analytics-Modul
|
||||
|
||||
Das Analytics-Modul erfasst und analysiert Anwendungsdaten:
|
||||
|
||||
- **Events tracken**: `$analytics->track('event_name', $properties)`
|
||||
- **HTTP-Tracking**: Automatisch durch `AnalyticsMiddleware`
|
||||
- **Error-Tracking**: Integration mit dem Error-Handling-System
|
||||
- **Dashboard**: Admin-Interface zur Datenvisualisierung
|
||||
|
||||
### Konfigurationssystem
|
||||
|
||||
Konfigurationen werden zentral verwaltet und injiziert:
|
||||
|
||||
```php
|
||||
class Service
|
||||
{
|
||||
public function __construct(private Configuration $config)
|
||||
{
|
||||
$settings = $this->config->get('module_name', $defaults);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Erweiterbarkeit
|
||||
|
||||
### Neue Module hinzufügen
|
||||
|
||||
1. Erstellen Sie ein neues Verzeichnis unter `/src/Framework`
|
||||
2. Implementieren Sie eine Initializer-Klasse mit dem `#[Initializer]`-Attribut
|
||||
3. Erstellen Sie eine entsprechende Konfigurationsdatei unter `/src/Config`
|
||||
|
||||
### Middleware hinzufügen
|
||||
|
||||
```php
|
||||
// In Ihrer Anwendungsklasse
|
||||
public function bootstrap(): void
|
||||
{
|
||||
$this->addMiddleware(YourMiddleware::class);
|
||||
}
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Dependency Injection**: Verwenden Sie Constructor-Injection für Abhängigkeiten
|
||||
- **Interfaces**: Definieren Sie Interfaces für alle Services
|
||||
- **Events**: Nutzen Sie Events für lose Kopplung zwischen Modulen
|
||||
- **Konfiguration**: Externalisieren Sie Konfigurationen in dedizierte Dateien
|
||||
- **Typsicherheit**: Nutzen Sie strenge Typisierung und readonly-Properties
|
||||
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.
|
||||
@@ -1,70 +0,0 @@
|
||||
# Architektur-Dokumentation
|
||||
|
||||
## Übersicht
|
||||
|
||||
Diese Dokumentation beschreibt die Architektur und Struktur des Projekts. Sie bietet einen Überblick über die wichtigsten Komponenten, deren Beziehungen und die zugrundeliegenden Architekturprinzipien.
|
||||
|
||||
## Inhalte
|
||||
|
||||
- [Projektstruktur](/architecture/STRUKTUR-DOKUMENTATION.md) - Überblick über die Struktur des Projekts
|
||||
|
||||
## Architekturprinzipien
|
||||
|
||||
Das Projekt folgt diesen grundlegenden Architekturprinzipien:
|
||||
|
||||
1. **Modulare Architektur**: Klare Trennung von Verantwortlichkeiten in Modulen
|
||||
2. **Service-orientiertes Design**: Funktionalitäten als unabhängige Services
|
||||
3. **Dependency Injection**: Abhängigkeiten werden explizit injiziert
|
||||
4. **Event-basierte Kommunikation**: Lose Kopplung durch Events
|
||||
5. **Schichtenarchitektur**: Trennung von Präsentation, Anwendungslogik und Daten
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### Framework-Kern
|
||||
|
||||
Der Framework-Kern stellt grundlegende Infrastrukturkomponenten bereit:
|
||||
|
||||
- **DI-Container**: Verwaltung von Service-Abhängigkeiten
|
||||
- **Event-System**: Event-basierte Kommunikation
|
||||
- **HTTP-Komponenten**: Request/Response-Handling
|
||||
- **Routing**: URL-zu-Controller-Mapping
|
||||
|
||||
### Anwendungsschicht
|
||||
|
||||
Die Anwendungsschicht implementiert die Geschäftslogik:
|
||||
|
||||
- **Services**: Implementierung von Anwendungsfunktionen
|
||||
- **Commands/Queries**: Command-Query-Separation-Prinzip
|
||||
- **Controllers**: HTTP-Request-Handling
|
||||
|
||||
### Domainschicht
|
||||
|
||||
Die Domainschicht enthält die Kerngeschäftslogik:
|
||||
|
||||
- **Entities**: Geschäftsobjekte mit Identität
|
||||
- **Value Objects**: Unveränderliche Wertobjekte
|
||||
- **Domain Services**: Domänenspezifische Logik
|
||||
|
||||
### Infrastrukturschicht
|
||||
|
||||
Die Infrastrukturschicht bietet technische Funktionen:
|
||||
|
||||
- **Persistenz**: Datenbankzugriff und -verwaltung
|
||||
- **Messaging**: Externe Kommunikation
|
||||
- **Integration**: Anbindung an externe Systeme
|
||||
|
||||
## Datenfluss
|
||||
|
||||
Ein typischer Datenfluss im System:
|
||||
|
||||
1. HTTP-Request wird vom Router empfangen
|
||||
2. Middleware-Pipeline verarbeitet den Request
|
||||
3. Controller erhält den Request und delegiert an Services
|
||||
4. Services implementieren die Geschäftslogik
|
||||
5. Domain-Objekte repräsentieren den Geschäftszustand
|
||||
6. Repositories speichern/laden Daten
|
||||
7. Response wird erstellt und zurückgegeben
|
||||
|
||||
## Weitere Informationen
|
||||
|
||||
Für detailliertere Informationen zur Architektur siehe die [Projektstruktur-Dokumentation](/architecture/STRUKTUR-DOKUMENTATION.md).
|
||||
226
docs/architecture/overview.md
Normal file
226
docs/architecture/overview.md
Normal file
@@ -0,0 +1,226 @@
|
||||
# Architekturübersicht
|
||||
|
||||
Diese Dokumentation bietet einen Überblick über die Architektur des Frameworks und erklärt die grundlegenden Konzepte und Designentscheidungen.
|
||||
|
||||
## Architekturprinzipien
|
||||
|
||||
Das Framework wurde nach folgenden Prinzipien entwickelt:
|
||||
|
||||
1. **Modularität**: Das Framework ist in unabhängige Module aufgeteilt, die einzeln verwendet oder ausgetauscht werden können.
|
||||
2. **Erweiterbarkeit**: Alle Komponenten sind so konzipiert, dass sie einfach erweitert oder angepasst werden können.
|
||||
3. **Testbarkeit**: Die Architektur ermöglicht einfaches Testen durch klare Schnittstellen und Dependency Injection.
|
||||
4. **Leistung**: Leistungsoptimierungen sind ein integraler Bestandteil des Designs, nicht nur eine nachträgliche Überlegung.
|
||||
5. **Sicherheit**: Sicherheitsmaßnahmen sind standardmäßig aktiviert und in die Kernkomponenten integriert.
|
||||
|
||||
## Schichtenarchitektur
|
||||
|
||||
Das Framework verwendet eine mehrschichtige Architektur, die eine klare Trennung der Verantwortlichkeiten ermöglicht:
|
||||
|
||||
```
|
||||
+-------------------+
|
||||
| Anwendung | <-- Anwendungsspezifischer Code (Controller, Models, Services)
|
||||
+-------------------+
|
||||
| Framework | <-- Framework-Komponenten (Routing, Validierung, Datenbank)
|
||||
+-------------------+
|
||||
| Infrastruktur | <-- Infrastrukturkomponenten (HTTP, Dateisystem, Cache)
|
||||
+-------------------+
|
||||
```
|
||||
|
||||
### Anwendungsschicht
|
||||
|
||||
Die Anwendungsschicht enthält den anwendungsspezifischen Code, der die Geschäftslogik implementiert. Diese Schicht umfasst:
|
||||
|
||||
- **Controller**: Verarbeiten HTTP-Anfragen und geben Antworten zurück
|
||||
- **Models**: Repräsentieren Geschäftsobjekte und Datenstrukturen
|
||||
- **Services**: Implementieren komplexe Geschäftslogik
|
||||
- **Repositories**: Kapseln den Datenzugriff
|
||||
|
||||
### Framework-Schicht
|
||||
|
||||
Die Framework-Schicht stellt die Kernfunktionalität bereit, die von der Anwendungsschicht verwendet wird. Diese Schicht umfasst:
|
||||
|
||||
- **Routing**: Leitet Anfragen an die entsprechenden Controller weiter
|
||||
- **Validierung**: Überprüft Benutzereingaben
|
||||
- **Datenbank**: Bietet Datenbankabstraktion und ORM-Funktionalität
|
||||
- **Authentifizierung**: Verwaltet Benutzerauthentifizierung und -autorisierung
|
||||
- **Caching**: Implementiert verschiedene Caching-Strategien
|
||||
|
||||
### Infrastrukturschicht
|
||||
|
||||
Die Infrastrukturschicht bietet grundlegende Dienste und Abstraktionen für die darüber liegenden Schichten. Diese Schicht umfasst:
|
||||
|
||||
- **HTTP**: Verarbeitet HTTP-Anfragen und -Antworten
|
||||
- **Dateisystem**: Bietet Abstraktionen für Dateisystemoperationen
|
||||
- **Cache**: Implementiert verschiedene Cache-Backends
|
||||
- **Logging**: Bietet Logging-Funktionalität
|
||||
- **Events**: Implementiert ein Event-System
|
||||
|
||||
## Anfragelebenszyklus
|
||||
|
||||
Der Lebenszyklus einer Anfrage im Framework durchläuft mehrere Phasen:
|
||||
|
||||
1. **Bootstrapping**: Die Anwendung wird initialisiert, Konfigurationen werden geladen und Dienste registriert.
|
||||
2. **Routing**: Die Anfrage wird an den entsprechenden Controller weitergeleitet.
|
||||
3. **Middleware**: Die Anfrage durchläuft die konfigurierten Middleware-Komponenten.
|
||||
4. **Controller**: Der Controller verarbeitet die Anfrage und gibt eine Antwort zurück.
|
||||
5. **Middleware (rückwärts)**: Die Antwort durchläuft die Middleware-Komponenten in umgekehrter Reihenfolge.
|
||||
6. **Antwort**: Die Antwort wird an den Client gesendet.
|
||||
|
||||
```
|
||||
+----------------+ +------------+ +------------+ +------------+ +----------------+
|
||||
| | | | | | | | | |
|
||||
| Bootstrapping | --> | Routing | --> | Middleware | --> | Controller | --> | Antwort senden |
|
||||
| | | | | | | | | |
|
||||
+----------------+ +------------+ +------------+ +------------+ +----------------+
|
||||
```
|
||||
|
||||
## Dependency Injection
|
||||
|
||||
Das Framework verwendet Dependency Injection (DI), um Abhängigkeiten zwischen Komponenten zu verwalten. Der DI-Container ist verantwortlich für:
|
||||
|
||||
1. **Registrierung**: Dienste werden im Container registriert.
|
||||
2. **Auflösung**: Der Container löst Abhängigkeiten automatisch auf.
|
||||
3. **Lebenszyklus**: Der Container verwaltet den Lebenszyklus von Diensten (Singleton, Transient, etc.).
|
||||
|
||||
Beispiel für die Verwendung des DI-Containers:
|
||||
|
||||
```php
|
||||
// Registrierung eines Dienstes
|
||||
$container->bind(UserRepositoryInterface::class, UserRepository::class);
|
||||
|
||||
// Auflösung eines Dienstes
|
||||
$userRepository = $container->get(UserRepositoryInterface::class);
|
||||
```
|
||||
|
||||
## Service Provider
|
||||
|
||||
Service Provider sind Klassen, die Dienste im DI-Container registrieren und konfigurieren. Sie bieten einen strukturierten Weg, um Komponenten zu initialisieren und zu konfigurieren.
|
||||
|
||||
Beispiel für einen Service Provider:
|
||||
|
||||
```php
|
||||
class DatabaseServiceProvider implements ServiceProviderInterface
|
||||
{
|
||||
public function register(Container $container): void
|
||||
{
|
||||
$container->singleton(ConnectionInterface::class, function () {
|
||||
return new Connection(config('database'));
|
||||
});
|
||||
|
||||
$container->bind(QueryBuilderInterface::class, QueryBuilder::class);
|
||||
}
|
||||
|
||||
public function boot(Container $container): void
|
||||
{
|
||||
// Initialisierungscode, der nach der Registrierung ausgeführt wird
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Ereignissystem
|
||||
|
||||
Das Framework implementiert ein Ereignissystem, das die Entkopplung von Komponenten ermöglicht. Das Ereignissystem besteht aus:
|
||||
|
||||
1. **Events**: Objekte, die Informationen über ein Ereignis enthalten.
|
||||
2. **Listeners**: Klassen, die auf bestimmte Ereignisse reagieren.
|
||||
3. **Dispatcher**: Verantwortlich für das Versenden von Ereignissen an registrierte Listener.
|
||||
|
||||
Beispiel für die Verwendung des Ereignissystems:
|
||||
|
||||
```php
|
||||
// Definieren eines Events
|
||||
class UserRegistered
|
||||
{
|
||||
public function __construct(public readonly User $user) {}
|
||||
}
|
||||
|
||||
// Definieren eines Listeners
|
||||
class SendWelcomeEmail implements ListenerInterface
|
||||
{
|
||||
public function handle(UserRegistered $event): void
|
||||
{
|
||||
// E-Mail an den neuen Benutzer senden
|
||||
}
|
||||
}
|
||||
|
||||
// Registrieren des Listeners
|
||||
$eventDispatcher->addListener(UserRegistered::class, SendWelcomeEmail::class);
|
||||
|
||||
// Auslösen des Events
|
||||
$eventDispatcher->dispatch(new UserRegistered($user));
|
||||
```
|
||||
|
||||
## Middleware-Pipeline
|
||||
|
||||
Das Framework verwendet eine Middleware-Pipeline, um Anfragen zu verarbeiten. Middleware-Komponenten können:
|
||||
|
||||
1. Anfragen vor der Verarbeitung durch den Controller modifizieren.
|
||||
2. Antworten nach der Verarbeitung durch den Controller modifizieren.
|
||||
3. Den Anfrage-/Antwort-Zyklus vollständig abbrechen.
|
||||
|
||||
Beispiel für eine Middleware:
|
||||
|
||||
```php
|
||||
class AuthenticationMiddleware implements MiddlewareInterface
|
||||
{
|
||||
public function process(Request $request, RequestHandlerInterface $handler): Response
|
||||
{
|
||||
if (!$this->isAuthenticated($request)) {
|
||||
return new RedirectResponse('/login');
|
||||
}
|
||||
|
||||
return $handler->handle($request);
|
||||
}
|
||||
|
||||
private function isAuthenticated(Request $request): bool
|
||||
{
|
||||
// Überprüfen, ob der Benutzer authentifiziert ist
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Konfigurationssystem
|
||||
|
||||
Das Framework verwendet ein flexibles Konfigurationssystem, das verschiedene Konfigurationsquellen unterstützt:
|
||||
|
||||
1. **Umgebungsvariablen**: Konfiguration über `.env`-Dateien.
|
||||
2. **Konfigurationsdateien**: PHP-Dateien, die Konfigurationsarrays zurückgeben.
|
||||
3. **Laufzeitkonfiguration**: Dynamische Konfiguration zur Laufzeit.
|
||||
|
||||
Das Konfigurationssystem unterstützt auch umgebungsspezifische Konfigurationen, sodass verschiedene Einstellungen für Entwicklung, Test und Produktion verwendet werden können.
|
||||
|
||||
## Erweiterbarkeit
|
||||
|
||||
Das Framework ist so konzipiert, dass es einfach erweitert werden kann:
|
||||
|
||||
1. **Interfaces**: Alle Kernkomponenten definieren Interfaces, die implementiert werden können.
|
||||
2. **Abstrakte Klassen**: Viele Komponenten bieten abstrakte Basisklassen, die erweitert werden können.
|
||||
3. **Hooks**: Das Framework bietet Hooks, an denen benutzerdefinierter Code ausgeführt werden kann.
|
||||
4. **Plugins**: Das Plugin-System ermöglicht die einfache Integration von Drittanbietercode.
|
||||
|
||||
## Sicherheitsarchitektur
|
||||
|
||||
Die Sicherheitsarchitektur des Frameworks umfasst mehrere Schichten:
|
||||
|
||||
1. **Eingabevalidierung**: Validierung aller Benutzereingaben.
|
||||
2. **Ausgabebereinigung**: Automatische Bereinigung von Ausgaben, um XSS zu verhindern.
|
||||
3. **CSRF-Schutz**: Schutz vor Cross-Site Request Forgery.
|
||||
4. **Authentifizierung**: Flexible Authentifizierungsmechanismen.
|
||||
5. **Autorisierung**: Rollenbasierte und fähigkeitsbasierte Zugriffskontrolle.
|
||||
6. **Web Application Firewall (WAF)**: Integrierte WAF zum Schutz vor gängigen Angriffen.
|
||||
|
||||
## Leistungsoptimierungen
|
||||
|
||||
Das Framework implementiert verschiedene Leistungsoptimierungen:
|
||||
|
||||
1. **Caching**: Mehrschichtiges Caching für Konfiguration, Routen, Views, etc.
|
||||
2. **Lazy Loading**: Komponenten werden erst geladen, wenn sie benötigt werden.
|
||||
3. **Kompilierung**: Views und Konfigurationen werden für schnelleren Zugriff kompiliert.
|
||||
4. **Pooling**: Verbindungspooling für Datenbanken und andere Ressourcen.
|
||||
5. **Optimierte Autoloading**: PSR-4-konformes Autoloading mit Optimierungen.
|
||||
|
||||
## Weitere Informationen
|
||||
|
||||
- [Komponenten](components.md): Detaillierte Informationen zu den Hauptkomponenten des Frameworks.
|
||||
- [Entwurfsmuster](patterns.md): Erläuterung der im Framework verwendeten Entwurfsmuster.
|
||||
- [Komponentendokumentation](../components/README.md): Dokumentation der einzelnen Komponenten.
|
||||
1137
docs/architecture/patterns.md
Normal file
1137
docs/architecture/patterns.md
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user