Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen.
Met het ontwerppatroon van de sjabloonmethode kunt u de stappen van een algoritme definiëren binnen een enkele methode van een klasse. Hierdoor kunt u specifieke bewerkingen van een toepassing beperken tot een enkele methode.
Elke stap van het algoritme dat door de sjabloonmethode wordt gedefinieerd, is een interne methode. De sjabloonmethode zorgt echter alleen voor de implementatie van enkele van zijn interne methoden. Subklassen implementeren meestal een of meer van de interne methoden van de sjabloonmethode.
Een subklasse kan een abstracte methode implementeren, maar kan het algoritme dat door een laatste methode wordt geïmplementeerd niet opnieuw definiëren.
Hoe de sjabloonmethode werkt
Een typisch sjabloonmethodepatroon heeft de volgende structuur:
laatsteleegtesjabloonMethode(){
abstractOperatie1();
abstractOperatie2();concreteOperation1();
concreteOperation2();
haak();
}
Het eerste belangrijke ding om op te merken is dat templateMethod() definitief is, dus geen enkele subklasse kan deze methode overschrijven. Het andere belangrijke om op te merken zijn de drie soorten methoden die het sjabloonmethodepatroon gebruikt: concreet, abstract en haak.
De abstracte klasse waarin de sjabloonmethode is ondergebracht, implementeert al zijn concrete methoden, terwijl concrete subklassen zijn abstracte methoden implementeren. De hook-methode doet standaard meestal niets, maar een subklasse heeft wel de mogelijkheid om deze methoden te overschrijven wanneer dat nodig is.
Implementatie van het sjabloonmethodepatroon in Java
Het sjabloonmethodepatroon fungeert als een raamwerk voor een toepassing. U zult dit patroon dus vaak zien in softwareframeworks die de blauwdruk vormen voor applicatie-ontwikkeling.
U kunt uw applicatie bijvoorbeeld koppelen aan een van de vele databasesystemen. De stappen om verbinding te maken met en een database te gebruiken volgen een vergelijkbaar sjabloon:
openbaarabstractklasDatabank{
// sjabloonmethode
laatsteleegtedatabaseSjabloon(){
// abstracte methoden
setDBDriver();
setCredentials();// concrete methode
aansluiten();// abstracte methoden
creëerDB();
setData();
leesGegevens();// hook-methoden
als (gebruikerWantsToUpdate()) {
gegevens bijwerken();
}als (gebruikerWantsToDelete()) {
Verwijder data();
}// concrete methode
hechte band();
}abstractleegtesetDBDriver();
abstractleegtesetCredentials();
abstractleegtecreëerDB();
abstractleegtesetData();
abstractleegteleesData();
abstractleegtegegevens bijwerken();
abstractleegteVerwijder data();leegteaansluiten(){
Systeem.uit.println("Verbinding maken met database...");
}leegtehechte band(){
Systeem.uit.println("Databaseverbinding verbreken...");
}booleaansgebruikerWantsToUpdate(){
opbrengstvals;
}
booleaansgebruikerWantsToDelete(){
opbrengstvals;
}
}
Deze voorbeelddatabaseklasse gebruikt het sjabloonmethodepatroon om een sjabloon te maken die u met elke database kunt gebruiken. Om een database te gebruiken, moet uw toepassing er verbinding mee maken en de verbinding na gebruik verbreken. Deze activiteiten zijn meestal hetzelfde voor alle databases. Daarom kan de abstracte Database-klasse de aansluiten() En hechte band() methoden.
De andere methoden in de sjabloonmethode verschillen afhankelijk van het type database. Een MySQL-database slaat bijvoorbeeld gegevens op in tabellen, terwijl een MongoDB-database slaat gegevens op in collecties. Als u een MySQL-database in Java, maak eenvoudig een nieuwe MySQL-klasse aan die de Database-klasse uitbreidt:
openbaarklasMySQLstrekt zich uitDatabank{
@Overschrijven
leegtesetDBDriver(){
Systeem.uit.println("MySQL-stuurprogramma selecteren...");
}@Overschrijven
leegtesetCredentials(){
Systeem.uit.println("MySQL-databasereferentie instellen...");
}@Overschrijven
leegtecreëerDB(){
Systeem.uit.println("Een nieuwe tabel maken...");
}@Overschrijven
leegtesetData(){
Systeem.uit.println("Gegevens in database invoeren...");
}@Overschrijven
leegteleesData(){
Systeem.uit.println("Gegevens ophalen uit database...");
}@Overschrijven
leegtegegevens bijwerken(){
Systeem.uit.println("Gegevens in database bijwerken...");
}
@Overschrijven
leegteVerwijder data(){
Systeem.uit.println("Gegevens verwijderen uit database...");
}
}
De klasse MySQL implementeert alle abstracte methoden van de klasse Database. Het kan ook enkele concrete methoden overschrijven. Het kan echter niet de databaseTemplate() methode, die het laatste trefwoord gebruikt.
openbaarklasVoornaamst{
openbaarstatischleegtevoornaamst(String[] argumenten){
Database mySQLDB = nieuw MySQL();
mijnSQLDB.databasesjabloon();
}
}
Deze klasse Main maakt een nieuw MySQL-databaseobject en gebruikt de sjabloonmethode om te simuleren hoe een toepassing verbinding maakt met de database. Als u de hoofdmethode uitvoert, wordt de volgende uitvoer naar de console afgedrukt:
In de uitvoer zult u merken dat de toepassing nooit de gegevens bijwerken() En Verwijder data() methoden. Daarom zijn de hook-methoden belangrijk. In een SQL-database wilt u nieuwe tabellen maken, gegevens invoegen en uw gegevens bekijken. Het is echter mogelijk dat u geen gegevens wilt bijwerken of verwijderen. Daarom geven de hook-methoden subklassen de mogelijkheid om deze kritieke aspecten van het algoritme te controleren.
@Overschrijven
booleaansgebruikerWantsToUpdate(){
opbrengstWAAR;
}Door simpelweg de bovenstaande code toe te voegen aan de MySQL-klasse, werkt de applicatie nu de gegevens in de database bij. Als u de klasse Main opnieuw uitvoert, wordt de volgende bijgewerkte uitvoer weergegeven:
Zoals u kunt zien, werkt de applicatie nu de gegevens in de database bij.
De voordelen van het gebruik van het ontwerppatroon van de sjabloonmethode
Een groot voordeel van het sjabloonmethodepatroon is dat het de herbruikbaarheid van software bevordert. Dit ontwerppatroon ondersteunt ook een efficiënte programmering. Een subklasse hoeft alleen methoden te implementeren die uniek zijn voor zijn werking.
Bovendien is een toepassing die het sjabloonmethodepatroon gebruikt veiliger, omdat externe klassen de bewerkingsstructuur niet kunnen wijzigen.