Lezione 7: Design Pattern Comportamentali

Lezione 23: Design
Pattern Comportamentali
Corso di Ingegneria del Software
Laurea Magistrale in Ing. Informatica
Università degli Studi di Salerno

1

Outline

✦ Design Pattern Comportamentali
• Template Method

• Chain of Responsibility

2

Design Pattern Comportamentali

3

Design Pattern Comportamentali

✦ Lo scopo comune è affrontare problemi
che riguardano il modo in cui un oggetto
svolge la sua funzione, o il modo in cui un
insieme di oggetti collaborano per
svolgere un determinato compito

4

Template Method

✦ Il problema
• Spesso capita di incontrare diversi problemi che si
risolvono con algoritmi che hanno la stessa
struttura, ma differiscono in alcune operazioni di
dettaglio
‣ ripetere più volte la struttura comune è una violazione del
principio DRY
‣ si vuole avere la possibilità di riutilizzare la struttura
comune per reimplementare più semplicemente nuovi
algoritmi dello stesso tipo

5

Template Method
✦ Esempio del problema

public int computeSum(int a[], int n) {
int sum=0;
int i;
for(i=0; i<n; i++)
sum=sum+a[i];
return sum;
}

public int computeProduct(int a[], int n) {
int product=1;
int i;
for(i=0; i<n; i++)
product=product*a[i];
return product;
}
6

Template Method
• la struttura comune:

public int computeXxx(int a[], int n) {
int valore=”valore iniziale”;
int i;
for(i=0; i<n; i++)
valore=”combinazione di valore e a[i]”
return valore;
}

7

Template Method
✦ Soluzione
• si definisce una classe “abstract” per lo schema di
algoritmo
• la struttura dell’algoritmo è definita in un metodo
(“template method”), che richiama altri metodi
(“hook methods”) per le parti che differiscono tra
i vari problemi
• gli hook methods possono avere una
implementazione di default, o essere metodi
“abstract”
• per ogni problema concreto si crea una
sottoclasse che implementa i metodi hook
8

Template Method
✦ Esempio di struttura

9

Template Method
✦ Esempio di soluzione
public abstract class Accumulator {
// Template method
public int compute(int a[], int n) {
int value=initialValue();
int i;
for(i=0; i<n; i++)
value=combine(value, a[i]);
return value;
}

// Hook method
public abstract int initialValue();

// Hook method
public abstract int combine(int currentValue, int element);
}
10

Template Method
✦ Esempio di soluzione (continua)

public class SumAccumulator extends Accumulator {
public int initialValue() {
return 0;
}

public int combine(int currentValue, int element) {
return currentValue+element;
}
}

11

Template Method

public class ProductAccumulator extends Accumulator {
return 1;
}

return currentValue*element;
}
}

12

Template Method

public class CountPositiveAccumulator extends Accumulator {
return 0;
}

if (element>0)
return currentValue+1;
else
return currentValue;
}

}

13

Template Method

✦ Conseguenze
• si separa la struttura generale comune a un
insieme di algoritmi dai dettagli che differiscono,
consentendo il riuso della prima
• si garantisce la coerenza tra le soluzioni a
problemi analoghi
• è possibile applicare la stessa struttura a problemi
nuovi, inizialmente non considerati

14

Template Method

✦ Esempi
• numerosi framework utilizzano questo pattern per
definire applicazioni in cui la struttura generale
dell’applicazione è fissata, e lo sviluppatore deve
specificare soltanto gli elementi peculiari
dell’applicazione corrente
‣ Applet
‣ Servlet

15

Template Method
✦ Nota
• questo pattern rappresenta un esempio di
applicazione del cosiddetto “Hollywood Principle”,
così denominato dalla “risposta standard” nei
provini di dilettanti a Hollywood:
“Don’t call us...We’ll call you.”
• l’idea di base di questo principio è che non è il
codice specifico dell’applicazione a richiamare il
codice generale presente in una libreria, ma il
contrario

16

Template Method
✦ Nota
• Qualunque passo di un algoritmo può essere
trasformato in un hook; tuttavia se il numero di
hook è eccessivo il template method risulta
difficile da comprendere e da utilizzare
• Per questo nella scelta di cosa trasformare in
hook occorre seguire la raccomandazione YAGNI:
la decisione va presa in base alle necessità
presenti, mentre per necessità future si ricorrerà
al refactoring

17

Chain of Responsibility

✦ Il problema
• una determinata richiesta potrebbe essere gestita
da più di un oggetto (Handler), e si vuole
disaccoppiare il client che genera la richiesta dalla
conoscenza di quale specifico handler la dovrà
gestire

18

• In un programma con una GUI, l’evento
“pressione di un tasto”, generato dal windowing
system, potrebbe essere gestito da diversi
oggetti:
‣ il controllo (es. bottone o text field) correntemente
selezionato
‣ il pannello in cui sono inseriti i controlli (es. per la
navigazione con TAB)
‣ la finestra in cui è inserito il pannello (es. per la gestione
dei menù)
‣ il windowing system stesso (es. per cambiare finestra con
Alt-TAB o attivare il Task Manager con Ctrl-Alt-DEL)

19

• il programma deve utilizzare alcuni parametri di
configurazione che ne determinano il
comportamento:
‣ ciascun parametro può essere specificato sulla linea di
comando
‣ se il parametro non è sulla linea di comando, può essere
letto da un file di configurazione
‣ se il parametro non è nemmeno nel file di configurazione,
si usa un valore di default “cablato” nel programma

• le classi che usano questi parametri non
dovrebbero preoccuparsi di qual è il modo in cui
l’utente li ha specificati
20


✦ Soluzione
• si definisce una classe astratta Handler, i cui
oggetti hanno un metodo per gestire la richiesta,
e mantengono un riferimento ad un altro Handler
(successore)
• la richiesta viene inviata a una catena di Handler
ciascuno dei quali può decidere se gestirla
direttamente o passarla all’Handler successivo

21

✦ Esempio di struttura

22

✦ Esempio di soluzione

public abstract class Parameters {
protected Parameters next;
protected Parameters(Parameters next) {
this.next = next;
}

public abstract String getParameter(String name);
}

23

public class CommandLineParameters extends Parameters {
private String args[];
public CommandLineParameters(String args[], Parameters next) {
super(next);
this.args=args;
}
public String getParameter(String name) {
String value=search(name);
if (value==null && next!=null)
value=next.getParameter(name);
return value;
}
private String search(String name) {
// Search the parameter in the command line
}
}
24


public class ConfigurationFileParameters extends Parameters {
private String fileName;
public ConfigurationFileParameters(String fileName, Parameters next) {
super(next);
this.fileName=fileName;
}
String value=search(name);
return value;
}
private String search(String name) {
// Search the parameter in the file
}
}

25

public class DefaultParameters extends Parameters {
private Map<String, String> map;
public DefaultParameters(Parameters next) {
super(next);
map=new HashMap<String,String>();
map.put("param1", "pluto");
map.put("param2", "paperino");
}
String value=map.get(name);
return value;
}
}

26


public static void main(String args[]) {
Parameters defaultParam=new DefaultParameters(null);
Parameters cfgFileParam=new
ConfigurationFileParameters("pippo.cfg",
defaultParam);
Parameters cmdLineParam=new CommandLineParameters(args,
cfgFileParam);

MyClass x=new MyClass(cmdLineParam);
}

27

✦ Conseguenze
• c’è un basso accoppiamento tra il client che
esegue una richiesta e la classe effettivamente
usata per gestire la richiesta
• ci sono più oggetti che hanno la possibilità di
gestire una richiesta, e ciascun handler seleziona
da solo le richieste che è in grado di gestire
• è possibile definire una priorità tra gli handler: gli
handler all’inizio della catena hanno una priorità
più alta rispetto a quelli alla fine della catena
• PROBLEMA: se il numero di handler è elevato,
overhead per scorrere la catena fino all’handler
giusto
28

Chain of Responsibilty

✦ Esempio
• nella versione 1.0 di AWT, gli eventi erano gestiti
dal metodo handleEvent della classe Component;
se un componente non voleva/poteva gestire
l’evento, la richiesta veniva inoltrata al
componente padre
✦ Esempio (non OOP)
• il PATH per la ricerca dei comandi nella shell dei
sistemi Unix-like

29

Chain of responsibility

✦ Note
• in genere è opportuno assicurarsi che alla fine
della catena ci sia un handler “catch-all”, che dà
una risposta a ogni richiesta non evasa dagli
handler precedenti
• la costruzione della catena degli handler può
essere realizzata usando un Factory Method, o un
Singleton

30

Lezione 7: Design Pattern Comportamentali

More Related Content

What's hot (18)

Similar to Lezione 7: Design Pattern Comportamentali (20)

More from Andrea Della Corte (11)

Lezione 7: Design Pattern Comportamentali