IFT232_Exercices_Factory_sol

IFT 232 Méthodes de conception orientée objets
Séance d’exercices IV
Date : 31 janvier et 7 février 2005
Objectifs
 Comprendre et maîtriser le design pattern « Factory Method »
 Comprendre et maîtriser le design pattern « Abstract Factory»
Factory method design pattern
Enoncé :
Tout programme doit pouvoir rapporter les erreurs ou encore afficher des messages
servant pour le déverminage. Soit l’interface suivante
public interface Trace {
// turn on and off debugging
public void setDebug( boolean debug );
// write out a debug message
public void debug( String message );
// write out an error message
public void error( String message );
}
Question 1 :
Écrire une classe SystemTrace qui implémente Trace. Les instances de cette classe
affiche le résultat dans la fenêtre de commande en ligne.
public class SystemTrace implements Trace {
private boolean debug;
public void setDebug( boolean debug ) {
this.debug = debug;
}
public void debug( String message ) {
if( debug ) { // only print if debug is true
System.out.println( "DEBUG: " + message );
}
}
public void error( String message ) {
// always print out errors
System.out.println( "ERROR: " + message );
}
}

Question 2 :
Ajouter les instructions de déverminage nécessaires pour tracer sur la console chacun des
appels de méthodes de votre solution de la séance d’exercices III.
Dans la classe, il faut ajouter les instructions suivantes :
//... some code ...
SystemTrace log = new SystemTrace();
//... code ...
log.debug( "entering loog" );
// ... etc ...
Par contre dès que l’on voudra changer d’implémentation (par exemple, utiliser celle de
la Q3), il faudra modifier cette classe.
Question 3 :
Écrire une classe FileTrace qui implémente Trace. Les instances de cette classe
affiche le résultat dans un fichier.
public class FileTrace implements Trace {
private java.io.PrintWriter pw;
private boolean debug;
public FileTrace() throws java.io.IOException {
// a real FileTrace would need to obtain the filename
somewhere
// for the example I'll hardcode it
pw = new java.io.PrintWriter( new java.io.FileWriter(
"c:\trace.log" ) );
}
public void setDebug( boolean debug ) {
this.debug = debug;
}
public void debug( String message ) {
if( debug ) { // only print if debug is true
pw.println( "DEBUG: " + message );
pw.flush();
}
}
public void error( String message ) {
// always print out errors
pw.println( "ERROR: " + message );
pw.flush();
}
}

Question 4 :
Modifier votre réponse à la question 2 pour conserver la trace dans un fichier. Le nom de
ce fichier sera spécifié dans les propriétés du programme et chargé dans une instance de
ProgramProperties. Cette instance sera un Singleton créé à sa première utilisation.
Cette classe sera sous-classe de java.util.Properties.
Si vous n’êtes pas familier avec les alternatives permettant de déterminer les propriétés
d’un programme, voir
http://java.sun.com/docs/books/tutorial/essential/attributes/index.html
public class ProgramProperties extends Properties {
final static public String DEFAULT_FILE_NAME = "defaultProperties";
final static public String PROPS_FILE_NAME = "ex4.properties";
static private ProgramProperties instance__;
static synchronized public ProgramProperties getInstance() {
if (instance__ == null) {
// create and load default properties
ProgramProperties defaultProps = new ProgramProperties();
FileInputStream in;
try {
in = new FileInputStream(DEFAULT_FILE_NAME);
defaultProps.load(in);
in.close();
} catch (FileNotFoundException e2) {
e2.printStackTrace();
}
catch (IOException e3) {
e3.printStackTrace();
}
// create program properties with default
ProgramProperties applicationProps = new
ProgramProperties(defaultProps);
try {
// now load properties from last invocation
in = new FileInputStream(PROPS_FILE_NAME);
applicationProps.load(in);
try {
in.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e1) {
e1.printStackTrace();
}
instance__ = applicationProps;}
return instance__;
}
private ProgramProperties(ProgramProperties defaultProps){
super(defaultProps);
}
private ProgramProperties() {
super();
}
}

Question 5 :
Vous avez probablement dû modifier votre programme en plusieurs endroits dans
plusieurs classes. Afin de rassembler la création du système de trace en un seul endroit,
écrivez une classe TraceFactory possédant une méthode « factory » abstraite
getTrace().
Voir plus loin pour le code de la classe TraceFactory
Question 6 :
Ecrivez la classe SystemTraceFactory qui est une sous-classe de TraceFactory.
Cette classe rend une instance de la classe SystemTrace.
public class SystemTraceFactory extends TraceFactory {
public Trace getTrace() {
return new SystemTrace();
}
}
Question 7 :
Ecrivez la classe FileTraceFactory qui est une sous-classe de TraceFactory
Cette classe rend une instance de la classe FileTrace.
import java.io.IOException;
public class FileTraceFactory extends TraceFactory {
public Trace getTrace() {
try {
return new FileTrace();
} catch (IOException e) {
e.printStackTrace();
}
// pour au mons render de quoi faire la trace
return new SystemTrace(); }
}

Question 8 :
Transformez TraceFactory en Singleton. La classe de l’instance sera spécifée dans le
fichier de propriétés du programme. Par défaut, une instance de la classe
SystemTraceFactory.
public abstract class TraceFactory {
static private TraceFactory instance__;
private static TraceFactory createFactory() {
if (ProgramProperties.getInstance().getProperty("trace.file") != null)
return new FileTraceFactory();
return new SystemTraceFactory();
}
static synchronized public TraceFactory getInstance() {
if (instance__ == null)
instance__ = createFactory();
return instance__;
}
public abstract Trace getTrace();
}
Remarques
http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/
http://www.javaworld.com/javaworld/javaqa/2001-05/02-qa-0511-factory.html?