Was ist das Template Method Design Pattern?

Leser wie Sie helfen, MUO zu unterstützen. Wenn Sie über Links auf unserer Website einen Kauf tätigen, erhalten wir möglicherweise eine Affiliate-Provision.

Mit dem Entwurfsmuster für Vorlagenmethoden können Sie die Schritte eines Algorithmus innerhalb einer einzelnen Methode einer Klasse definieren. Dadurch können Sie bestimmte Operationen einer Anwendung auf eine einzige Methode beschränken.

Jeder Schritt des Algorithmus, den die Vorlagenmethode definiert, ist eine innere Methode. Die Template-Methode behandelt jedoch nur die Implementierung einiger ihrer inneren Methoden. Unterklassen implementieren normalerweise eine oder mehrere der inneren Methoden der Vorlagenmethode.

Eine Unterklasse kann eine abstrakte Methode implementieren, aber sie kann den von einer endgültigen Methode implementierten Algorithmus nicht neu definieren.

Wie die Template-Methode funktioniert

Ein typisches Template-Methodenmuster hat die folgende Struktur:

FinaleLeereVorlageMethode(){
 abstrakteOperation1();
 abstractOperation2();
konkreteOperation1();
 konkreteOperation2();
Haken();
}

Als Erstes ist zu beachten, dass templateMethod() final ist, sodass keine Unterklasse diese Methode überschreiben kann. Die andere wichtige Sache, die zu beachten ist, sind die drei Arten von Methoden, die das Template-Methodenmuster verwendet: konkret, abstrakt und Haken.

Die abstrakte Klasse, die die Vorlagenmethode beherbergt, implementiert alle ihre konkreten Methoden, während konkrete Unterklassen ihre abstrakten Methoden implementieren. Die Hook-Methode führt normalerweise standardmäßig nichts aus, aber eine Unterklasse hat die Möglichkeit, diese Methoden bei Bedarf zu überschreiben.

Implementieren des Vorlagenmethodenmusters in Java

Das Template-Methodenmuster fungiert als Rahmen für eine Anwendung. Sie werden dieses Muster also häufig in Software-Frameworks sehen, die die Blaupause für die Anwendungsentwicklung liefern.

Beispielsweise können Sie Ihre Anwendung mit einem von vielen Datenbanksystemen verbinden. Die Schritte zum Herstellen einer Verbindung mit und Verwenden einer Datenbank folgen einer ähnlichen Vorlage:

öffentlichabstraktKlasseDatenbank{
// Template-Methode
FinaleLeereDatenbankVorlage(){
// abstrakte Methoden
 setDBDriver();
 setCredentials();
// konkrete Methode
 verbinden();
// abstrakte Methoden
 createDB();
 setData();
 readData();
// Hook-Methoden
 if (userWantsToUpdate()) {
 Daten aktualisieren();
 }
if (userWantsToDelete()) {
 Daten löschen();
 }
// konkrete Methode
 Verbindung schließen();
 }
abstraktLeeresetDBDriver();
abstraktLeeresetCredentials();
abstraktLeerecreateDB();
abstraktLeeresetData();
abstraktLeerereadData();
abstraktLeereDaten aktualisieren();
abstraktLeereDaten löschen();
Leereverbinden(){
 System.out.println("Verbindung zur Datenbank herstellen...");
 }
LeereVerbindung schließen(){
 System.out.println("Datenbankverbindung wird zerstört...");
 }
booleschuserWantsToUpdate(){
zurückkehrenFALSCH;
 }
booleschuserWantsToDelete(){
zurückkehrenFALSCH;
 }
}

Diese beispielhafte Datenbankklasse verwendet das Vorlagenmethodenmuster, um eine Vorlage zu erstellen, die Sie mit jeder Datenbank verwenden können. Um eine Datenbank zu verwenden, muss Ihre Anwendung eine Verbindung zu ihr herstellen und die Verbindung nach der Verwendung zerstören. Diese Aktivitäten sind normalerweise für alle Datenbanken gleich. Daher kann die abstrakte Database-Klasse die implementieren verbinden() Und Verbindung schließen() Methoden.

Die anderen Methoden in der Vorlagenmethode unterscheiden sich je nach Datenbanktyp. Beispielsweise speichert eine MySQL-Datenbank Daten in Tabellen, während eine Die MongoDB-Datenbank speichert Daten in Sammlungen. Wenn Sie eine verwenden möchten MySQL-Datenbank in Java, erstellen Sie einfach eine neue MySQL-Klasse, die die Database-Klasse erweitert:

öffentlichKlasseMySQLerweitertDatenbank{
@Überschreiben
LeeresetDBDriver(){
 System.out.println("MySQL-Treiber auswählen...");
 }
@Überschreiben
LeeresetCredentials(){
 System.out.println("MySQL-Datenbank-Anmeldeinformationen werden festgelegt...");
 }
@Überschreiben
LeerecreateDB(){
 System.out.println("Neue Tabelle erstellen...");
 }
@Überschreiben
LeeresetData(){
 System.out.println("Daten in Datenbank einfügen...");
 }
@Überschreiben
LeerereadData(){
 System.out.println("Daten aus Datenbank abrufen...");
 }
@Überschreiben
LeereDaten aktualisieren(){
 System.out.println("Daten in Datenbank aktualisieren...");
 }
@Überschreiben
LeereDaten löschen(){
 System.out.println("Daten aus Datenbank löschen...");
 }
}

Die MySQL-Klasse implementiert alle abstrakten Methoden der Database-Klasse. Es kann auch einige konkrete Methoden überschreiben. Es kann jedoch nicht berührt werden databaseTemplate() -Methode, die das Schlüsselwort final verwendet.

öffentlichKlasseHauptsächlich{
öffentlichstatischLeerehauptsächlich(String[] Argumente){
 Datenbank mySQLDB = neu MySQL();
mySQLDB.databaseTemplate();
 }
}

Diese Hauptklasse erstellt ein neues MySQL-Datenbankobjekt und verwendet die Vorlagenmethode, um zu simulieren, wie eine Anwendung eine Verbindung zur Datenbank herstellen würde. Das Ausführen der main-Methode gibt die folgende Ausgabe auf der Konsole aus:

In der Ausgabe werden Sie feststellen, dass die Anwendung die niemals aufruft Daten aktualisieren() Und Daten löschen() Methoden. Deshalb sind die Hook-Methoden wichtig. In einer SQL-Datenbank möchten Sie neue Tabellen erstellen, Daten einfügen und Ihre Daten anzeigen. Möglicherweise möchten Sie jedoch keine Daten aktualisieren oder löschen. Daher geben die Hook-Methoden Unterklassen die Möglichkeit, diese kritischen Aspekte des Algorithmus zu steuern.

@Überschreiben
booleschuserWantsToUpdate(){
zurückkehrenWAHR;
}

Durch einfaches Hinzufügen des obigen Codes zur MySQL-Klasse aktualisiert die Anwendung nun die Daten in der Datenbank. Wenn Sie die Main-Klasse erneut ausführen, wird die folgende aktualisierte Ausgabe angezeigt:

Wie Sie sehen können, aktualisiert die Anwendung jetzt die Daten in der Datenbank.

Die Vorteile der Verwendung des Vorlagenmethode-Entwurfsmusters

Ein Hauptvorteil des Template-Methodenmusters besteht darin, dass es die Wiederverwendbarkeit von Software fördert. Dieses Entwurfsmuster unterstützt auch eine effiziente Programmierung. Eine Unterklasse muss nur Methoden implementieren, die für ihre Operation eindeutig sind.

Darüber hinaus ist eine Anwendung, die das Vorlagenmethodenmuster verwendet, sicherer, da externe Klassen ihre Operationsstruktur nicht ändern können.