java-design-patterns/localization/de/step-builder

shortTitle, category, language, tag

shortTitle	category	language	tag
Step Builder	Creational	de	Code simplification Domain Encapsulation Extensibility Instantiation Interface

Alternativbezeichnung

• Fluent Builder

Zweck

Das Step-Builder-Pattern ist eine erweiterte Technik, um komplexe Objekte übersichtlich und flexibel zu erzeugen. Es ist ideal für Szenarien, in denen die Objekterzeugung schrittweise und äußerst genau zu erfolgen hat.

Detaillierte Erklärung

Vergleichsbeispiel:

Betrachten wir den Zusammenbau eines individuell konfigurierten Computers. Dafür sind mehrere Schritte nötig: Die CPU muss ausgewählt werden, ein Motherboard, dazu kommen Arbeitsspeicher, Grafikkarte und Festplatte, die nach und nach ins Gehäuse eingebaut werden müssen. Jeder Schritt folgt auf den anderen, bis schließlich ein funktionsfähiger Rechner entsteht. Dieser schrittweise Konstruktionsprozess entspricht dem Step-Builder-Pattern und sorgt dafür, dass alle nötigen Komponenten richtig zusammengebaut werden und anforderungsgemäß funktionieren.

In einfachen Worten

Das Step-Builder-Pattern konstruiert komplexe Objekte nach und nach durch eine Reihe definierter Schritte. Das macht den Vorgang übersichtlich und flexibel.

Wikipedia sagt

Step Builder ist eine Variante des Builder-Patterns mit dem Ziel, eine flexible Lösung zur schrittweisen Konstruktion komplexer Objekte anzubieten. Sie ist besonders hilfreich, wenn ein Objekt viele Initialisierungsschritte benötigt, die der Klarheit und Flexibilität wegen einzeln abgearbeitet werden können.

Ablaufdiagramm

Programmbeispiel

Als Erweiterung des Builder-Patterns führt Step Builder den Nutzer Schritt für Schritt durch den Erzeugungsprozess eines Objekts. Es werden immer nur die nächsten verfügbaren Schritte angezeigt, und die build-Methode ist erst dann verfügbar, wenn das Objekt tatsächlich bereit zum Bau ist.

Betrachten wir eine Klasse Character mit vielen Attributen wie name, fighterClass, wizardClass, weapon, spell, und abilities.

public class Character {

  private String name;
  private String fighterClass;
  private String wizardClass;
  private String weapon;
  private String spell;
  private List<String> abilities;

  public Character(String name) {
    this.name = name;
  }

}

Die Konstruktion ist wegen der vielen Attribute komplex. Darum verwenden wir Step Builder.

Wir schreiben eine Klasse CharacterStepBuilder, um den Benutzer durch den Konstruktionsprozess zu führen.

public class CharacterStepBuilder {

  // neuer Builder startet mit dem Schritt Namensvergabe
  public static NameStep newBuilder() {
    return new CharacterSteps();
  }

}

Die Klasse CharacterStepBuilder enthält eine Reihe von Interfaces, die jeweils einen Schritt des Konstruktionsprozesses repräsentieren. Indem jedes Interface eine Methode für den folgenden Schritt deklariert, wird der Benutzer durch den Prozess geführt.

// nach der Namensvergabe kommt die Auswahl der wizardClass oder fighterClass
public interface NameStep {
  ClassStep name(String name);
}

// nach der Klassenwahl wird entweder eine Waffe oder ein Zauberspruch zugewiesen
public interface ClassStep {
  WeaponStep fighterClass(String fighterClass);
  SpellStep wizardClass(String wizardClass);
}

// Weitere Schritte weggelassen

Die Klasse Steps implementiert all diese Interfaces und baut schließlich das Character-Object.

private static class Steps implements NameStep, ClassStep, WeaponStep, SpellStep, BuildStep {

  private String name;
  private String fighterClass;
  private String wizardClass;
  private String weapon;
  private String spell;
  private List<String> abilities;

  // Die Implementationen der Methoden für die einzelnen Schritte sind hier weggelassen

  @Override
  public Character build() {
    return new Character(name, fighterClass, wizardClass, weapon, spell, abilities);
  }
}

Jetzt ist die Erzeugung eines Character-Objekts ein geführter Prozess.

public static void main(String[] args) {

    var warrior = CharacterStepBuilder
            .newBuilder()
            .name("Amberjill")
            .fighterClass("Paladin")
            .withWeapon("Sword")
            .noAbilities()
            .build();

    LOGGER.info(warrior.toString());

    var mage = CharacterStepBuilder
            .newBuilder()
            .name("Riobard")
            .wizardClass("Sorcerer")
            .withSpell("Fireball")
            .withAbility("Fire Aura")
            .withAbility("Teleport")
            .noMoreAbilities()
            .build();

    LOGGER.info(mage.toString());

    var thief = CharacterStepBuilder
            .newBuilder()
            .name("Desmond")
            .fighterClass("Rogue")
            .noWeapon()
            .build();

    LOGGER.info(thief.toString());
}

Konsolenausgabe:

12:58:13.887 [main] INFO com.iluwatar.stepbuilder.App -- This is a Paladin named Amberjill armed with a Sword.
12:58:13.889 [main] INFO com.iluwatar.stepbuilder.App -- This is a Sorcerer named Riobard armed with a Fireball and wielding [Fire Aura, Teleport] abilities.
12:58:13.889 [main] INFO com.iluwatar.stepbuilder.App -- This is a Rogue named Desmond armed with a with nothing.

Verwendung

• Wenn die Konstruktion eines Objekts viele Initialisierungsschritte benötigt.
• Wenn die Objektkonstruktion komplex ist und viele Parameter enthält.
• Um einen übersichtlichen, lesbaren und wartbaren Objekterzeugungsprozess bereitzustellen.

Tutorials

• Step Builder (Marco Castigliego)

Reale Anwendungen in Java

• Komplexe Konfigurationseinstellungen in Java-Anwendungen.
• Konstruktion von Objekten für Datenbankeinträge mit vielen Feldern.
• Konstruktion von GUI-Elementen, wo jeder Schritt einen anderen Teil der Schnittstelle festlegt.

Vor- und Nachteile

Vorteile

• Code wird lesbarer und wartbarer durch übersichtliche und prägnante Objektkonstruktion.
• Erhöhte Flexibilität bei der Objekterzeugung durch Varianten im Konstruktionsprozess.
• Unterstützt unveränderbare Objekte durch Abtrennung ihrer Erzeugung.ntation.

Nachteile

• Code kann durch zusätzliche Klassen und Interfaces komplexer werden.
• Langatmiger Code bei vielen Konstruktionsschritten.

Verwandte Patterns

• Builder: Beide Patterns dienen der Konstruktion komplexer Objekte. Step Builder ist eine Variante mit Betonung auf schrittweisem Vorgehen.
• Fluent Interface: Wird oft zusammen mit Step Builder verwendet, um eine sprechende API mit Methodenverkettung zur Konstruktion bereitzustellen.
• Factory Method: Wird manchmal im Step-Builder-Pattern genutzt, um die Konstruktion des Builders selbst zu kapseln.

Quellen

• Clean Code: A Handbook of Agile Software Craftsmanship
• Effective Java
• Design Patterns: Elements of Reusable Object-Oriented Software