Was ist Software-Architektur?

Software-Architektur bezieht sich auf die Gesamtstruktur und Entwurfsprinzipien eines Systems. So wie Gebäude Baupläne benötigen, braucht Software systematisches Design.

Warum Architektur wichtig ist

Ergebnisse schlechter Architektur:

• Schwierig zu ändernder Code (Behebung eines Teils bricht einen anderen)
• Unmöglich, neue Funktionen hinzuzufügen
• Endlose Fehler
• Schwierige Teamzusammenarbeit

Vorteile guter Architektur:

• Einfache Wartung
• Skalierbar
• Einfach zu testen
• Reibungslose Teamzusammenarbeit

Kernkonzept: Trennung der Belange (Separation of Concerns)

Das wichtigste Prinzip ist jeden Teil so zu teilen, dass er nur eine Verantwortung übernimmt.

// Schlecht: Alles an einem Ort
function processOrder(orderId) {
  const order = db.query("SELECT * FROM orders WHERE id = ?", orderId);
  const total = order.items.reduce((sum, item) => sum + item.price, 0);
  document.getElementById("total").innerText = total;
  sendEmail(order.customer.email, "Bestellbestätigung");
}

// Gut: Nach Rolle getrennt
class OrderRepository {
  getOrder(orderId) {
    return db.query("SELECT * FROM orders WHERE id = ?", orderId);
  }
}

class OrderService {
  calculateTotal(order) {
    return order.items.reduce((sum, item) => sum + item.price, 0);
  }
}

Geschichtete Architektur

Das grundlegendste und am weitesten verbreitete Muster.

3-Schichten-Architektur

1. Präsentationsschicht

• Benutzeroberfläche (UI)
• Benutzereingabeverarbeitung
• Datenanzeige

2. Geschäftslogikschicht

• Kerngeschäftsregeln
• Datenverarbeitung und -transformation
• Validierung

3. Datenschicht

• Datenbankzugriff
• Externe API-Aufrufe
• Dateisystemzugriff

MVC-Muster (Model-View-Controller)

Am häufigsten verwendetes Muster in Webanwendungen.

Benutzer → View → Controller → Model → Datenbank
           ↑                      ↓
           └──────────────────────┘

Model: Daten und Geschäftslogik View: Benutzeroberfläche Controller: Anfrageverarbeitung und Ablaufsteuerung

Microservices-Architektur

Muster zur Aufteilung großer Anwendungen in kleine unabhängige Dienste.

Monolithisch vs Microservices

Monolithisch

┌─────────────────────────────┐
│   Eine große Anwendung      │
│  ┌─────┬─────┬─────┬─────┐ │
│  │Benut│Prod │Best │Zahl │ │
│  └─────┴─────┴─────┴─────┘ │
│    Eine Datenbank           │
└─────────────────────────────┘

Microservices

┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐
│Benutzer│  │Produkt │  │Bestell │  │Zahlung │
│Service │  │Service │  │Service │  │Service │
│  DB    │  │  DB    │  │  DB    │  │  DB    │
└────────┘  └────────┘  └────────┘  └────────┘

Entwurfsmuster

Bewährte Lösungen für häufig auftretende Probleme.

1. Singleton-Muster

class Database {
  static instance = null;
  
  static getInstance() {
    if (!Database.instance) {
      Database.instance = new Database();
    }
    return Database.instance;
  }
}

2. Factory-Muster

class UserFactory {
  createUser(type) {
    switch(type) {
      case 'admin': return new AdminUser();
      case 'customer': return new CustomerUser();
      default: return new GuestUser();
    }
  }
}

3. Observer-Muster

class EventEmitter {
  listeners = {};
  
  on(event, callback) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(callback);
  }
  
  emit(event, data) {
    if (this.listeners[event]) {
      this.listeners[event].forEach(cb => cb(data));
    }
  }
}

Lernpfad für Anfänger

Stufe 1: Grundkonzepte (1-2 Monate)

• Trennung der Belange
• Geschichtete Architektur
• MVC-Muster

Stufe 2: Praktische Anwendung (3-4 Monate)

• MVC auf kleine Projekte anwenden
• Repository-Muster verwenden
• Dependency Injection lernen

Stufe 3: Fortgeschrittene Muster (5-6 Monate)

• Entwurfsmuster lernen und anwenden
• Clean Architecture verstehen
• SOLID-Prinzipien lernen

Stufe 4: Großsysteme (6+ Monate)

• Microservices-Architektur
• Ereignisgesteuerte Architektur
• CQRS, Event Sourcing

Architektur-Auswahlhilfe

Software-Architektur kann nicht auf einmal perfekt entworfen werden. Sie muss kontinuierlich verbessert werden, wenn das Projekt wächst.

Kernprinzipien:

1. Belange trennen
2. Abhängigkeiten verwalten
3. Für Testbarkeit entwerfen
4. Einfachheit bewahren

Wenn Sie Anfänger sind, beginnen Sie mit geschichteter Architektur und MVC-Muster. Wenn Sie Erfahrung sammeln, indem Sie sie auf kleine Projekte anwenden, werden Sie natürlich komplexere Muster verstehen und anwenden.