2. Design Pattern secondo l'architetto Christopher Alexander
Opera in un contesto
particolare Insieme di forze in gioco in tale
Design pattern Contesto contesto (obiettivi e vincoli
spesso contrastanti che influenzano
la parte del progetto che il pattern
deve affrontare)
Descrive un problema
progettuale ricorrente
Forze
Forma o regole da applicare per
Problema Soluzione risolvere tali forze
Descrive come le classi
e gli oggetti del pattern
risolvono il problema
3. Design Pattern secondo la GoF
(Definizione dei design pattern in modo da facilitarne il riuso)
● Nome e classificazione: permette di identificare il design pattern;
● Intento: descrizione sul cosa fa il design pattern a quale problema di progettazione
si rivolge quando funziona la soluzione;
● Sinonimi: eventuali altri nomi che identificano il pattern;
● Motivazione: descrizione del problema progettuale e come il pattern fornisce una
soluzione;
● Applicabilità: contesti in cui si può applicare il pattern;
● Struttura: rappresentazione grafica tramite UML delle classi coinvolte;
– partecipanti: classi che partecipano al pattern, loro relazioni e responsabilità
(class diagram, object ed activity diagram);
– collaborazioni: Come collaborano le varie classi per raggiungere gli obiettivi
(sequence diagram);
4. Design Pattern secondo la GoF
(Definizione dei design pattern in modo da facilitarne il riuso)
● Conseguenze: costi e benefici dell'uso del pattern;
● Implementazione: suggerimenti e tecniche;
● Codice sorgente di esempio: frammenti di codice che mostrano una possibile
implementazione;
● Usi noti: pattern trovati in sistemi reali;
● Pattern correlati: differenze e relazioni con altri pattern;
5. Il pattern Template Method
● Nome: Template Method
● Classificazione: è un pattern comportamentale basato su classi (ereditarietà).
● Intento: definire un algoritmo (quindi la sequenza dei suoi passi), e delegare a
delle sottoclassi il compito di specificare/ridefinire alcuni dei suoi passi senza
cambiarne la struttura.
● Sinonimi: self-delegation.
● Motivazione: diversi problemi si risolvono con algoritmi che hanno la stessa
Motivazione
struttura, ma differiscono in alcune operazioni di dettaglio. Ripetere più volte la
struttura comune è una violazione del principio “Don't Repeat Yourself” (non
ripeterti). La soluzione è quella di separare l'algoritmo dai dettagli di contesto.
● Applicabilità: in tutti i contesti in cui si desidera definire uno schema rigido delle
operazioni da eseguire ma con la consapevolezza che alcune operazioni potranno
essere implementati in più modi diversi
7. Il pattern Template Method
● Struttura:
– Partecipanti:
● AbstractClass: è la superclasse che definisce lo scheletro dell'algoritmo attraverso il
metodo concreto templateMethod().
TemplateMethod() invoca i metodi privati concreteOperation(), invoca i metodi
primitivi astratti primitiveOperation() implementati nelle sottoclassi, e può invocare i
metodi hookOperation() (metodi di gancio) che le sottoclassi possono specializzare o
no in quanto rappresentano punti di estensione.
● ConcreteClass: un numero variabile di sottoclassi concrete che devono
implementare i metodi primitivi primitiveOperation() per eseguire i passi specifici
dell’algoritmo, e facoltativamente sovrascrivere i metodi hook
– Collaborazioni:
è un pattern comportamentale basato sull'ereditarietà di classi che è una relazione statica,
quindi la modellazione dinamica (diagrammi di sequenza) è poco rappresentativa.
8. Il pattern Template Method
● Conseguenza:
– Benefici:
● Centralizza ed evita la duplicazione del codice (principio “Don't Repeat
Yourself”)
● Fattorizzazione delle responsabilità.
● Possibilità di aggiungere altre funzionalità attraverso i metodi “hook”
(aggancio o uncino).
● Hollywood Principle: “Don’t call us...We’ll call you.”
non è il codice della classe specifica a richiamare il codice della
superclasse, ma il contrario la superclasse invoca la sottoclasse
(inversione di controllo).
– Costi: nessuno
9. Il pattern Template Method
● Implementazione:
– I metodi primitivi dovrebbero essere membri protetti;
– Il template method non dovrebbe essere ridefinito quindi in Java il metodo va
dichiarato “final”;
– Minimizzare il numero di metodi primitivi;
– Definire una naming convention per i nomi dei metodi di cui effettuare override;
10. Il pattern Template Method
Metodo template
per implementare le parti non variabili
● Codice sorgente di esempio: e lasciare alle sottoclassi
la responsabilità
di implementare i comportamenti
– Es1: Classe astratta Spumante che possono variare
Spumante.java
package it.tinn.nelson.designpattern.templatemethod.ex1;
public abstract class Spumante {
// template method
public final void produzioneSpumante() {
Metodo hook (di gancio)
preparazioneVinoBase(); che può essere implementato
ulterioreFase(); nelle sottoclassi.
processoDiSpumantizzazione();
imbottigliamento();
}
protected void preparazioneVinoBase(){
System.out.println("Le uve devono provenire da zone DOC...la raccolta
delle uve deve ...la pigiatura deve ...");
}
//metodo hook può essere implementato
protected void ulterioreFase(){ }
//metodo primitivo che deve essere implementato nelle sottoclassi
protected abstract void processoDiSpumantizzazione();
//metodo primitivo che deve essere implementato nelle sottoclassi
protected abstract void imbottigliamento();
Metodi primipivi
} che devono essere implementati
(a differenza dei metodi hook
che possono essere implementati
11. Il pattern Template Method
● Codice sorgente di esempio:
– Es1: Sottoclasse SpumanteChampenois
SpumanteChampenois.java
package it.tinn.nelson.designpattern.templatemethod.ex1;
public class SpumanteChampenois extends Spumante {
@Override
public void processoDiSpumantizzazione() {
System.out.println("Il processo di rifermentazione avviene
esclusivamente in bottiglia. Il tempo della fermentazione e più lungo, spesso
vengono assemblate più annate.");
}
@Override
public void imbottigliamento() {
System.out.println("Imbottigliato col tappo a corona per effettuare
poi la successiva stappatura per l’eliminazione del deposito formato dai
lieviti nel collo della bottiglia.");
}
}
12. Il pattern Template Method
● Codice sorgente di esempio:
– Es1: Sottoclasse SpumanteCharmat
SpumanteCharmat.java
package it.tinn.nelson.designpattern.templatemethod.ex1;
public class SpumanteCharmat extends Spumante {
@Override
public void ulterioreFase() {
System.out.println("operazioni di taglio, chiarificazione,
refrigerazione e filtrazione");
}
@Override
public void processoDiSpumantizzazione() {
System.out.println("Il processo di rifermentazione avviene in grandi
contenitori, autoclavi. Tempo di spumantizzazione è breve (pochi mesi)");
}
@Override
public void imbottigliamento() {
System.out.println("Messo in bottiglia in modo isobarico, ovvero
senza perdita di pressione, pronto per la commercializzazione.");
}
}
13. Il pattern Template Method
● Codice sorgente di esempio:
– Es1: Classe client
Demo.java
package it.tinn.nelson.designpattern.templatemethod.ex1;
public class Demo {
public static void main(String[] args) {
System.out.println("Un buon spumante moscato");
Spumante moscato = new SpumanteCharmat();
moscato.produzioneSpumante();
System.out.println();
System.out.println("Un buon spumante brut");
Spumante brut = new SpumanteChampenois();
brut.produzioneSpumante();
}
}
14. Il pattern Template Method
● Codice sorgente di esempio:
– Es1: Esecuzione classe client
$JAVA_HOME/bin/java it.tinn.nelson.designpattern.templatemethod.ex1.Demo.java
Un buon spumante moscato
Le uve devono provenire da zone DOC...la raccolta delle uve deve ...la pigiatura deve ...
operazioni di taglio, chiarificazione, refrigerazione e filtrazione
Il processo di rifermentazione avviene in grandi contenitori, autoclavi.
Tempo di spumantizzazione è breve (pochi mesi)
Messo in bottiglia in modo isobarico, ovvero senza perdita di pressione,
pronto per la commercializzazione.
Un buon spumante brut
Le uve devono provenire da zone DOC...la raccolta delle uve deve ...la pigiatura deve ...
Il processo di rifermentazione avviene esclusivamente in bottiglia.
Il tempo della fermentazione e più lungo, spesso vengono assemblate più annate.
Imbottigliato col tappo a corona per effettuare poi la successiva stappatura
per l’eliminazione del deposito formato dai lieviti nel collo della bottiglia.
15. Il pattern Template Method
● Codice sorgente di esempio:
– Es2: classe astratta
Array.java Metodo primipivo
che deve essere implementato
package it.tinn.nelson.designpattern.templatemethod.ex2;
(a differenza dei metodi hook
public abstract class Array { che possono essere implementati
protected int [] a;
//metodo primitivo che deve essere implementato
//nelle sottoclassi
protected abstract int compare(int i, int j);
Metodo template
//metodo template
final public void sort() { per implementare le parti non variabili
// ordinamento bubble sort o(n^2) e lasciare alle sottoclassi
for (int i = a.length -1;i >= 0;--i ) { la responsabilità
for (int j = 0;j < i; ++j ) { di implementare i comportamenti
if ( compare(a[j], a[j+1]) > 0 ) { che possono variare
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
}
}
16. Il pattern Template Method
● Codice sorgente di esempio:
– Es2 - sottoclasse ordinamento ascendente
AscSortedArray.java
package it.tinn.nelson.designpattern.templatemethod.ex2;
public class AscSortedArray extends Array {
protected int compare(int i, int j) {
return
( i == j )? 0:
( i > j )? +1: -1;
}
}
17. Il pattern Template Method
● Codice sorgente di esempio:
– Es2 - sottoclasse ordinamento discendente
DescSortedArray.java
package it.tinn.nelson.designpattern.templatemethod.ex2;
public class DescSortedArray extends Array {
protected int compare(int i, int j) {
return
( i == j )? 0:
( i < j )? +1: -1;
}
}
18. Il pattern Template Method
● Codice sorgente di esempio:
– Es2: Classe client
Client.java
package it.tinn.nelson.designpattern.templatemethod.ex2;
public class Client {
public static void main(String[] args) {
AscendingSortedArray asc = new AscendingSortedArray();
DescendingSortedArray desc = new DescendingSortedArray();
desc.a = new int[]{4,2,5,3,1};
asc.a = new int[]{2,1,4,5,3};
asc.sort();
desc.sort();
System.out.print("ordinamento ascendente:");
for (int i = 0; i < asc.a.length; i++) {
System.out.print(asc.a[i]+" ");
};
System.out.println();
System.out.print("ordinamento discendente:");
for (int i = 0; i < desc.a.length; i++) {
System.out.print(desc.a[i]+" ");
}
}
}
19. Il pattern Template Method
● Codice sorgente di esempio:
– Es2: Esecuzione classe client
$JAVA_HOME/bin/java it.tinn.nelson.designpattern.templatemethod.ex2.Client.java
ordinamento ascendente:1 2 3 4 5
ordinamento discendente:5 4 3 2 1
20. Il pattern Template Method
● Codice sorgente di esempio:
Esempi di altri autori:
http://shishirkumarblog.wordpress.com/designpattern/template-pattern/
21. Il pattern Template Method
● Usi noti:
E' un pattern molto diffuso utilizzato praticamente da tutti i framework.
I framework rappresentano la struttura di una applicazione customizzabile da uno sviluppatore e assumono il
controllo della applicazione e non il contrario (principio di inversione di controllo). Uno dei pattern per
realizzare l'inversione di controllo è il template method.
– Il framework Spring offre diverse possibilità per la persistenza dei dati mediante JDBC, la principale delle
quali è l’utilizzo della classe JDBCTemplate.
org.springframework.jdbc.core.JdbcTemplate questa classe implementa l’intero processo di accesso ai
dati attraverso template methods, rendendo possibile la personalizzazione di tutte le fasi di tale processo
mediante l’ovverride dei metodi specifici.
– Nel framework JUnit il metodo RunBare() della classe junit.framework.TestCase è un metodo template.
– L'utilizzo di questo pattern lo troviamo in diverse classi del Java Development Kit:
● esempio java.lang.Comparable prevede il metodo: int compareTo(Object o) con risultato positivo,
negativo o nullo e il template metodo Collections.sort() assume che gli oggetti della collezione
implementino compareTo();
● la classe javax.swing.SwingWorker ha come template method: public final void execute(), come
metodo primitivo che deve essere implementato nelle sottoclassi: doInBackground()
e come metodi che possono essere implementati (metodi hook) process(List), e done();
● la classe javax.servlet.http.HttpServlet ha come template method: public void service(), come metodi
primitivi da sovrascrivere doGet, doPost, doHead, doPut, doDelete, doTrace, doOptions;
● le classi java.util.AbstractList, java.util.AbstractSet e java.util.AbstractMap.
22. Il pattern Template Method
...
Author: Ing. Nelson Firmani (nfirmani@gmail.com)
Last updated: 04/04/2013
