Zum Inhalt
wannacode

Factory Method und Simple Factory

Kurz gesagt: Eine Factory hält die Entscheidung, welche Klasse erzeugt wird, an einer Stelle: Simple Factory legt die Wahl an einen Ort, und Factory Method lässt eine Unterklasse entscheiden, welches Objekt entsteht.

Problem

Drei Stellen kennen jede Lieferart

Die Bestellung sagt, wie sie zum Kunden kommt: "address" (an die Haustür), "office" (in einer Kurierfiliale) oder "locker" (in einer Packstation). Jede Art hat eine Klasse mit eigenem Preis und eigenem Etikett:

class AddressDelivery {
  price = 5.9;


  label(recipient) {
    return `${recipient}, an die Haustür`;
  }
}


class OfficeDelivery {
  price = 3.9;


  label(recipient) {
    return `${recipient}, in einer Kurierfiliale`;
  }
}


class LockerDelivery {
  price = 2.9;


  label(recipient) {
    return `${recipient}, in einer Packstation`;
  }
}

Drei Teile des Shops brauchen die Lieferung: die Kasse, die Preisvorschau und der Etikettendrucker. Jeder entscheidet selbst, welche Klasse er erzeugt:

function checkout(type, items) {
  let delivery;
  if (type === "address") {
    delivery = new AddressDelivery();
  } else if (type === "office") {
    delivery = new OfficeDelivery();
  } else if (type === "locker") {
    delivery = new LockerDelivery();
  } else {
    throw new Error(type);
  }
  return items + delivery.price;
}


function previewPrice(type) {
  let delivery;
  if (type === "address") {
    delivery = new AddressDelivery();
  } else if (type === "office") {
    delivery = new OfficeDelivery();
  } else if (type === "locker") {
    delivery = new LockerDelivery();
  } else {
    throw new Error(type);
  }
  return delivery.price;
}


function printLabel(type, recipient) {
  let delivery;
  if (type === "office") {
    delivery = new OfficeDelivery();
  } else {
    delivery = new AddressDelivery();
  }
  return delivery.label(recipient);
}
console.log(`Bestellung: ${checkout("locker", 40).toFixed(2)} €`);
console.log(`Vorschau: Lieferung ${previewPrice("locker").toFixed(2)} €`);
console.log("Etikett: " + printLabel("locker", "Maria"));
Ausgabe
Bestellung: 42.90 €
Vorschau: Lieferung 2.90 €
Etikett: Maria, an die Haustür

Letzten Monat kamen die Packstationen dazu. Jemand hat "locker" in der Kasse und in der Vorschau ergänzt. Der Etikettendrucker wurde davor geschrieben und hat für die Adresse ein else. Maria hat die Lieferung an eine Packstation bezahlt, und der Kurier ist zu ihrer Adresse gefahren.

Eine neue Art sind drei Änderungen, und eine wird vergessen. Die Wahl „welche Klasse für welche Art“ ist kopiert, und die Kopien wissen nichts voneinander.

Die Idee

Simple Factory: new lebt an einer Stelle

Die Wahl „welche Klasse für welche Art“ ist eine einzige Entscheidung, also lebt sie an einer Stelle: in einer Factory. Sie bekommt die Art und gibt ein neues Objekt zurück. Der Aufrufer schreibt kein new und kennt die Klasse nicht: Er bekommt ein Objekt mit price und label.

Die Rollen:

  • das Produkt: die gemeinsame Form, price und label(recipient), die jede Klasse hat;
  • die konkreten Produkte: AddressDelivery, OfficeDelivery, LockerDelivery;
  • die Factory: createDelivery(type), die einzige Stelle, die weiß, welche Klasse zu welcher Art gehört;
  • die Clients: die Kasse, die Vorschau, das Etikett. Sie fragen nur.

Das heißt Simple Factory. Es stammt nicht aus dem Buch der Gang of Four, ist aber die häufigste Form. Factory Method aus dem Buch ist etwas anderes und kommt weiter hinten in der Lektion.

Eine Regel: Eine unbekannte Art ist ein Fehler, kein stiller Standardwert. Eine Factory, die die Art nicht kennt, wirft eine Exception mit einer klaren Meldung. Sonst verschwindet der Fehler nicht, er fährt mit dem Kurier zur falschen Adresse.

In JavaScript ist die Factory eine Tabelle Art → Klasse. Eine Klasse ist ein Wert wie jeder andere, also hält die Tabelle die Klassen selbst, und new Delivery() erzeugt ein Objekt aus der, die sie genommen hat.

Die Tabelle „Name → Strategie“ aus der Lektion zu Strategy ist dasselbe: eine Factory, die dir zu einem Stück Text ein Objekt gibt.

Sieh es dir an

Eine Factory für die drei Stellen

const deliveries = new Map([
  ["address", AddressDelivery],
  ["office", OfficeDelivery],
  ["locker", LockerDelivery],
]);


function createDelivery(type) {
  const Delivery = deliveries.get(type);
  if (Delivery === undefined) {
    throw new Error(`Unbekannte Lieferart: ${type}`);
  }
  return new Delivery();
}

Die Kasse, die Vorschau und das Etikett wählen nicht mehr, sie fragen:

function checkout(type, items) {
  return items + createDelivery(type).price;
}


function previewPrice(type) {
  return createDelivery(type).price;
}


function printLabel(type, recipient) {
  return createDelivery(type).label(recipient);
}
console.log(`Bestellung: ${checkout("locker", 40).toFixed(2)} €`);
console.log(`Vorschau: Lieferung ${previewPrice("locker").toFixed(2)} €`);
console.log("Etikett: " + printLabel("locker", "Maria"));
Ausgabe
Bestellung: 42.90 €
Vorschau: Lieferung 2.90 €
Etikett: Maria, in einer Packstation

Das Etikett ist für eine Packstation. Die Wahl steht an einer Stelle, also kann sie nicht an der Kasse stimmen und auf dem Etikett falsch sein.

Genauer, für Neugierige

Warum new Delivery() und nicht einfach Delivery()? In JavaScript lässt sich eine Klasse nicht wie eine Funktion aufrufen. Ohne new bricht das Programm ab mit:

Fehler
TypeError: Class constructor AddressDelivery cannot be invoked without 'new'

Darum kann die Tabelle auch Funktionen halten, die das Objekt erzeugen: ["address", () => new AddressDelivery()]. Dann ruft die Factory make() ohne new auf.

Sieh es dir an

Eine neue Art: eine Klasse und eine Zeile

Der Shop führt die Abholung im Geschäft ein: Art "pickup", kostenlos. Neu ist eine Klasse:

class PickupDelivery {
  price = 0;


  label(recipient) {
    return `${recipient}, im Geschäft`;
  }
}

und eine Zeile in der Factory, hier hervorgehoben:

const deliveries = new Map([
  ["address", AddressDelivery],
  ["office", OfficeDelivery],
  ["locker", LockerDelivery],
  ["pickup", PickupDelivery],
]);


function createDelivery(type) {
  const Delivery = deliveries.get(type);
  if (Delivery === undefined) {
    throw new Error(`Unbekannte Lieferart: ${type}`);
  }
  return new Delivery();
}
const home = createDelivery("address");
console.log(`${home.label("Maria")}: ${home.price.toFixed(2)} €`);


const locker = createDelivery("locker");
console.log(`${locker.label("Maria")}: ${locker.price.toFixed(2)} €`);


const pickup = createDelivery("pickup");
console.log(`${pickup.label("Maria")}: ${pickup.price.toFixed(2)} €`);
Ausgabe
Maria, an die Haustür: 5.90 €
Maria, in einer Packstation: 2.90 €
Maria, im Geschäft: 0.00 €

const home = createDelivery("address");
console.log(`${home.label("Maria")}: ${home.price.toFixed(2)} €`);


const locker = createDelivery("locker");
console.log(`${locker.label("Maria")}: ${locker.price.toFixed(2)} €`);


const pickup = createDelivery("pickup");
console.log(`${pickup.label("Maria")}: ${pickup.price.toFixed(2)} €`);
Schritt für Schritt, in Worten
  1. createDelivery("address") bekommt nur den Text aus der Bestellung. Die Factory sucht die passende Form dafür.
  2. Aus der Form kommt ein neues AddressDelivery. Der Aufrufer fragt nicht, welche Klasse es ist: Er benutzt nur price und label().
  3. Dieselbe Factory, ein anderer Text: „locker“ geht an den anderen Formen vorbei und hält bei LockerDelivery.
  4. Das Etikett sagt jetzt Packstation: Die Klasse wird an einer Stelle gewählt, und die Kasse, die Vorschau und das Etikett fragen alle diese Stelle.
  5. Eine neue Art: die Klasse PickupDelivery und eine Zeile mehr in der Factory. Die Zeilen, die createDelivery aufrufen, ändern sich nicht.
  6. „pickup“ läuft durch wie jede andere Art. Die neue Art wurde an einer Stelle hinzugefügt.

Die Kasse, die Vorschau und das Etikett werden nicht angefasst. Sie erfahren von der neuen Art, wenn eine Bestellung sie verlangt.

Sieh es dir an

Unbekannte Art

Die Art kommt von außen: aus einem Formular, von der Seite eines Partners, aus einer alten Datei. Früher oder später taucht eine Art auf, die es nicht gibt:

try {
  const delivery = createDelivery("drone");
  console.log(delivery.label("Maria"));
} catch (e) {
  console.log(e.message);
}
Ausgabe
Unbekannte Lieferart: drone

Der Fehler sagt, welche Art unbekannt ist. Er wird dort abgefangen, wo die Bestellung in den Shop kommt, und der Kunde sieht eine Meldung statt eines Pakets am falschen Ort.

Und ohne die Prüfung? deliveries.get(type) gibt undefined zurück, und der Fehler sagt weder welche Art noch was gesucht wurde:
function createDelivery(type) {
  const Delivery = deliveries.get(type);
  return new Delivery();
}
Fehler
TypeError: Delivery is not a constructor

Sieh es dir an

Factory Method: die Unterklasse entscheidet

Simple Factory wählt nach Text. Manchmal richtet sich die Wahl aber nicht nach Text, sondern danach, welches Objekt fragt.

Der Verkaufsbericht wird als CSV (für die Buchhaltung) und als HTML-Tabelle (in einer E-Mail) verschickt. Beide tun dasselbe: Jedes Produkt ist eine Zeile, und am Ende steht eine Zeile „Gesamt“. Nur die Datei, in die die Zeilen geschrieben werden, ist anders:

class CsvFile {
  lines = ["Produkt;Summe"];


  add(product, total) {
    this.lines.push(`${product};${total.toFixed(2)}`);
  }


  text() {
    return this.lines.join("\n");
  }
}


class HtmlFile {
  rows = [];


  add(product, total) {
    this.rows.push(`<tr><td>${product}</td><td>${total.toFixed(2)}</td></tr>`);
  }


  text() {
    return "<table>\n" + this.rows.join("\n") + "\n</table>";
  }
}
Der gemeinsame Algorithmus steht in der Basisklasse. Der Schritt „eine Datei erzeugen“ ist die Methode createFile, die die Unterklasse überschreibt.
class ReportExporter {
  createFile() {
    return new CsvFile();
  }


  export(sales) {
    const file = this.createFile();
    let overall = 0;
    for (const [product, total] of sales) {
      file.add(product, total);
      overall += total;
    }
    file.add("Gesamt", overall);
    return file.text();
  }
}


class HtmlExporter extends ReportExporter {
  createFile() {
    return new HtmlFile();
  }
}
const sales = [["Kaffee", 12.5], ["Tee", 8]];
console.log(new ReportExporter().export(sales));
console.log(new HtmlExporter().export(sales));
Ausgabe
Produkt;Summe
Kaffee;12.50
Tee;8.00
Gesamt;20.50
<table>
<tr><td>Kaffee</td><td>12.50</td></tr>
<tr><td>Tee</td><td>8.00</td></tr>
<tr><td>Gesamt</td><td>20.50</td></tr>
</table>

Das ist Factory Method: Die Basisklasse ruft eine Methode auf, die das Objekt erzeugt (this.createFile()), und die Unterklasse entscheidet, welche Klasse genau.

Warum nicht eine fertige Datei hineingeben? Die Datei sammelt Zeilen. Jeder export muss mit einer leeren Datei beginnen, also hält der Bericht keine Datei, er weiß, wie man eine neue erzeugt.

Wann genügt Simple Factory? Factory Method lohnt sich, wenn es um die Erzeugung herum einen gemeinsamen Algorithmus gibt, den die Unterklassen nicht wiederholen sollen (hier: die Zeilen und die Summe). Willst du nur ein Objekt nach Art, ohne Algorithmus drumherum, ist Simple Factory klarer. Und eine Unterklasse, die nur existiert, um ein neues Objekt zurückzugeben, ist Zeremonie. Dann gib die Klasse selbst mit: new ReportExporter(HtmlFile).

Probier es aus

Was kommt heraus?

Die Arten kommen aus einem Formular auf der Seite. Was gibt das Programm aus?

for (const type of ["office", "Locker", "locker"]) {
  try {
    console.log(createDelivery(type).label("Maria"));
  } catch (e) {
    console.log(e.message);
  }
}
Antwort

Probier es aus

Finde den Fehler

Ein anderer Entwickler hat die Factory so geschrieben:

const deliveries = new Map([
  ["office", OfficeDelivery],
  ["locker", LockerDelivery],
]);


function createDelivery(type) {
  const Delivery = deliveries.get(type) ?? AddressDelivery;
  return new Delivery();
}

Die Bestellung kommt von der Seite eines Partners, die die Art mit großem Anfangsbuchstaben sendet:

const delivery = createDelivery("Locker");
console.log("Etikett: " + delivery.label("Maria"));
console.log(`Lieferung: ${delivery.price.toFixed(2)} €`);
Ausgabe
Etikett: Maria, an die Haustür
Lieferung: 5.90 €

Maria hat eine Packstation gewählt. Sie hat 5,90 € statt 2,90 € für die Lieferung bezahlt, und das Paket ging an ihre Adresse. In welcher Zeile steckt der Fehler?

Wähle die Zeile mit dem Fehler.

Die Idee

Wann du es nicht brauchst

Eine Factory ist ein Sprung mehr beim Lesen: Um zu sehen, welche Klasse erzeugt wird, gehst du woandershin. Es lohnt sich nicht, wenn:

  • diese Stelle immer dieselbe Klasse braucht. new OfficeDelivery() dort, wo die Lieferung immer an eine Filiale geht, ist klarer als eine Factory;
  • die Art beim Schreiben des Codes bekannt ist und nicht als Daten hereinkommt (aus einer Bestellung, einer Datei, einem Formular);
  • du eine Klasse DeliveryFactory mit nur einer statischen Methode schreibst. Eine Tabelle und eine Funktion genügen;
  • eine Factory Method eine Unterklasse „für die Zukunft“ hat.

Es lohnt sich, wenn die Art als Daten hereinkommt und die Wahl der Klasse sonst an mehreren Stellen kopiert würde. Oder wenn es um die Erzeugung herum einen gemeinsamen Algorithmus gibt und nur der Schritt „welches Objekt“ anders ist.

Übung

Expresslieferung

Löse das in deinem Editor.

Expresslieferung. Der Shop führt die Expresslieferung an die Haustür ein: Art "express", 9,90 €, Etikett „…, Express an die Haustür“. Füge eine Klasse ExpressDelivery hinzu und mach sie über die Factory verfügbar. Die Kasse, die Vorschau und das Etikett werden nicht angefasst. Erzeuge eine Expresslieferung für Maria und gib sie aus wie in der Karte „Eine neue Art“:

Ausgabe
Maria, Express an die Haustür: 9.90 €

Weitere Aufgaben

  • Großbuchstaben und Leerzeichen. Das Formular sendet "Locker" und " locker ". Lass die Factory sie akzeptieren und ändere nur die Factory. Unbekannte Arten müssen weiter einen Fehler ergeben.
  • Ein JSON-Bericht. Füge dem Bericht aus der Karte „Factory Method“ ein JSON-Format hinzu: [{"product": "Kaffee", "total": 12.50}, …]. Welche Klassen schreibst du, und welche fasst du nicht an?
  • Preis nach Gewicht. Packstationen nehmen Pakete bis 20 kg, und über 5 kg kostet die Lieferung an die Haustür mehr. Wohin gehört das Gewicht: in die Factory oder in die Preismethode? Überlege, warum.

Test

Teste dich

1. Der Shop führt Drohnenlieferung ein, Art "drone". Was schreibst du mit Simple Factory?
2. Die Factory bekommt eine Art, die sie nicht kennt. Was soll sie tun?
3. Wann ist Factory Method besser als Simple Factory?
4. Um Speicher zu sparen, hält die Tabelle für jede Art ein fertiges Objekt, und die Factory gibt es zurück. Das Objekt hält den Empfänger in einem Feld. Was passiert bei zwei Packstation-Bestellungen hintereinander?
5. Wann brauchst du keine Factory?

Erstellt von Ivo Gergov im Rahmen der Kampagne von Evo Tech für zugängliche Programmierausbildung ·