Hvad er skabelonmetodens designmønster?

Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission.

Skabelonmetodens designmønster giver dig mulighed for at definere trinene i en algoritme inden for en enkelt metode i en klasse. Dette giver dig mulighed for at begrænse specifikke operationer af en applikation til en enkelt metode.

Hvert trin i algoritmen, som skabelonmetoden definerer, er en indre metode. Skabelonmetoden håndterer dog kun implementeringen af ​​nogle af dens indre metoder. Underklasser implementerer normalt en eller flere af skabelonmetodens indre metoder.

---

---

hvordan man starter i bios windows 8.1

MAKEUSE AF DAGENS VIDEO

En underklasse kan implementere en abstrakt metode, men den kan ikke omdefinere algoritmen implementeret af en endelig metode.

Sådan fungerer skabelonmetoden

Et typisk skabelonmetodemønster vil have følgende struktur:

final void templateMethod() { 
    abstractOperation1(); 
    abstractOperation2(); 
  
    concreteOperation1(); 
    concreteOperation2(); 
  
    hook(); 
}

Den første vigtige ting at bemærke er, at templateMethod() er endelig, så ingen underklasse kan tilsidesætte denne metode. Den anden vigtige ting at bemærke er de tre typer metoder, som skabelonmetodemønsteret bruger: konkret, abstrakt og krog.

Den abstrakte klasse, der huser skabelonmetoden, implementerer alle dens konkrete metoder, mens konkrete underklasser implementerer dens abstrakte metoder. Hook-metoden gør normalt ikke noget som standard, men en underklasse har mulighed for at tilsidesætte disse metoder, når det er nødvendigt.

Implementering af skabelonmetodemønsteret i Java

Skabelonmetodemønsteret fungerer som en ramme for en applikation. Så du vil ofte se dette mønster i softwarerammer, der giver planen for applikationsudvikling.

---

---

For eksempel kan du forbinde din applikation til et af mange databasesystemer. Trinnene til at oprette forbindelse til og bruge en database følger en lignende skabelon:

public abstract class Database { 
    // template method 
    final void databaseTemplate() { 
        // abstract methods 
        setDBDriver(); 
        setCredentials(); 
  
        // concrete method 
        connect(); 
  
        // abstract methods 
        createDB(); 
        setData(); 
        readData(); 
  
        // hook methods 
        if (userWantsToUpdate()) { 
            updateData(); 
        } 
  
        if (userWantsToDelete()) { 
            deleteData(); 
        } 
  
        // concrete method 
        closeConnection(); 
    } 
  
    abstract void setDBDriver(); 
    abstract void setCredentials(); 
    abstract void createDB(); 
    abstract void setData(); 
    abstract void readData(); 
    abstract void updateData(); 
    abstract void deleteData(); 
  
    void connect() { 
        System.out.println("Connecting to database..."); 
    } 
  
    void closeConnection() { 
        System.out.println("Destroying database connection..."); 
    } 
  
    boolean userWantsToUpdate() { 
        return false; 
    } 
  
    boolean userWantsToDelete() { 
        return false; 
    } 
} 

Dette eksempel på databaseklassen bruger skabelonmetodemønsteret til at oprette en skabelon, som du kan bruge med enhver database. For at bruge en database skal din applikation oprette forbindelse til den og derefter ødelægge forbindelsen efter brug. Disse aktiviteter er normalt de samme for alle databaser. Derfor kan den abstrakte databaseklasse implementere Opret forbindelse() og closeConnection() metoder.

---

---

De andre metoder i skabelonmetoden vil afvige afhængigt af databasetypen. For eksempel gemmer en MySQL-database data i tabeller, mens en MongoDB-databasen gemmer data i samlinger . Hvis du vil bruge en MySQL-database i Java , skal du blot oprette en ny MySQL-klasse, der udvider Database-klassen:

public class MySQL extends Database { 
    @Override 
    void setDBDriver() { 
        System.out.println("Selecting MySQL driver..."); 
    } 
  
    @Override 
    void setCredentials() { 
        System.out.println("Setting MySQL database Credential..."); 
    } 
  
    @Override 
    void createDB() { 
        System.out.println("Creating a new table..."); 
    } 
  
    @Override 
    void setData() { 
        System.out.println("Inserting data into database..."); 
    } 
  
    @Override 
    void readData() { 
        System.out.println("Retrieving data from database..."); 
    } 
  
    @Override 
    void updateData() { 
        System.out.println("Updating data in database..."); 
    } 
  
    @Override 
    void deleteData() { 
        System.out.println("Deleting data from database..."); 
    } 
} 

MySQL-klassen implementerer alle de abstrakte metoder i Database-klassen. Det kan også tilsidesætte nogle konkrete metoder. Den kan dog ikke røre ved databaseTemplate() metode, som bruger det endelige søgeord.

public class Main { 
    public static void main(String[] args) { 
        Database mySQLDB = new MySQL(); 
        mySQLDB.databaseTemplate(); 
    } 
} 

Denne hovedklasse opretter et nyt MySQL-databaseobjekt og bruger skabelonmetoden til at simulere, hvordan en applikation vil forbinde til databasen. Ved at køre hovedmetoden udskrives følgende output til konsollen:

I outputtet vil du bemærke, at applikationen aldrig kalder updateData() og deleteData() metoder. Det er derfor, krogmetoderne er vigtige. I en SQL-database vil du gerne oprette nye tabeller, indsætte data og se dine data. Du ønsker dog måske ikke at opdatere eller slette data. Derfor giver hook-metoderne underklasser mulighed for at kontrollere disse kritiske aspekter af algoritmen.

@Override 
boolean userWantsToUpdate() { 
    return true; 
}

Ved blot at tilføje koden ovenfor til MySQL-klassen, opdaterer applikationen nu dataene i databasen. Hvis du kører hovedklassen igen, vil den vise følgende opdaterede output:

Som du kan se, opdaterer applikationen nu dataene i databasen.

Fordelene ved at bruge skabelonmetodens designmønster

En stor fordel ved skabelonmetodemønsteret er, at det fremmer softwaregenanvendelighed. Dette designmønster understøtter også effektiv programmering. En underklasse behøver kun at implementere metoder, der er unikke for dens drift.

Derudover er en applikation, der bruger skabelonmetodemønsteret, mere sikker, da eksterne klasser ikke kan ændre dens operationsstruktur.