Discussion :

[themis]

re-Bonjour,

Je cherche à créer une classe qui me permettrait, selon le type de fichier que l'on charge, d'instancier un viewer bien spécifique (librairie externe style Batik, Adobe etc...) ; tout ça dans un JPanel par exemple.

Je ne sais pas trop comment me lancer, je me mélange un peu les pinceaux !

Est-ce que quelqu'un a déjà fait quelquechose du même style et pourrait me conseiller ?

Merci beaucoup.

[ Modéré par Bulbo ]
Ajout d'un tag dans le titre
Les Règles du Forum

[BainE]

Bonjour,
Comme ca de loin de loin je verrai assez bien l'implémentation du patern Factory.
Sinon en fesant une classe mère qui possede les traitements, objets ... commun (tous ce qui sera commun selon les divers fichiers) ainsi que les methodes virtuelles (traitement spécifiques selon le type de fichier) pour chaque classe fille s'occupant d'un type de fichier.

[bouye]

Yup.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public abstract class ViewerFactory {
  /** Factory cache.
   * <br>Maps fileformat ID -> factory.
   */
  private static final Map<String, ViewerFactory> FACTORY_CACHE = new HashMap<String, ViewerFactory>&#40;&#41;;

  /** Static initializer.
  */
  static &#123;
    // Register initial base factories.
    registerViewerFactory&#40;"pdf", new AdobeViewerFactory&#40;&#41;&#41;;
    ...
  &#125;

  /** Creates a viewer for given file.
  * @param file The target file.
  * @return A viewer, never <code>null</code>
  * @exception InvalidFileFormatException The file is invalid.
  * @exception UnsupportedFileFormatException The given file is not of a format supported by this factory.
  */
  public Viewer createViewer&#40;String file&#41; throws InvalidFileFormatException, UnsupportedFileFormat &#123;
   return createViewer&#40;new File&#40;file&#41;&#41;;  
 &#125;

  /** Creates a viewer for given file.
  * @param file The target file.
  * @return A viewer, never <code>null</code>
  * @exception InvalidFileFormatException The file is invalid.
  * @exception UnsupportedFileFormatException The given file is not of a format supported by this factory.
  */
  public abstract Viewer createViewer&#40;File file&#41; throws InvalidFileFormatException, UnsupportedFileFormat;

  /** Gets a factory for given file format.
  * @param filetype The fileformat identifier.
  * @return A <code>ViewerFactory</code> instance or <code>null</code> if giben filetype is <code>null</code>.
  * @exception UnsupportedFileFormat There is no factory for such file format.
  */
  public static final ViewerFactory getFactoryForFileFormat&#40;String filetype&#41; throws UnsupportedFileFormatException &#123;
    ...
  &#125;  
  
  /** Registers a factory for a given fileformat.
  * @param filetype The fileformat identifier.
  * @param factory The factory, must not be <code>null</code>
  * @exception NullPointerException Either the filetype or the factory parameter is <code>null</code>.
  */
  public static void registerViewerFactory&#40;String filetype, ViewerFactory factory&#41; throws NullPointerException &#123;
    ...
  &#125;

  /** Unregister a factory for a given fileformat.
  * @param filetype The fileformat identifier.
  * @exception NullPointerException The given filetype is <code>null</code>.
  */
  public static void unregisterViewerFactory&#40;String filetype&#41; &#123;
    ...
  &#125;
&#125;

public abstract class Viewer extends JPanel &#123;
  ...
&#125;

[themis]

J'avoue que je n'ai jamais utilisé ce genre de design pattern ...
Je ne vois pas trop comment utiliser ce code ...

Dans ma classe Viewer, je déclare un objet de type ViewerFactory et c'est dans ma classe ViewerFactory que je déclare les méthodes par exemple "load", "clear" etc... que je définirais dans les classes concrètes AdobeViewerFactory et autres ?

Je ne suis pas sûre d'avoir bien compris ... je fais des tests ... mais j'avoue que si vous avez des précisions : je suis preneuse !

Merci encore.

[sinok]

Et sinon pour la partie viewer il va falloir passer par JDIC si tu veux l'intégrer dans ton interface JAVA, sinon juste lancer l'application par le runtime avec les options appropriées

[bouye]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Dans ma classe Viewer, je déclare un objet de type ViewerFactory

Chaque class publique est dans son propre fichier .java
En gros la factory detache l'endroit ou l'on cree et instancie la Viewer du code principal. Commes les factory sont elles-memes abstraite on peut en creer un plusieurs types/variantes (une pour chaque viewer par exemple*).

*Rien n'empeche de faire une factory qui supporte plusieurs types de viewer. Ou un viewer qui supporte plusieurs formats de fichiers.

Ca evite de coder en dur dans le code de la GUI un truc de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
...
else if (extension.equals("pdf") {
  ...
}
else if (extension.equals(...

sur 3Km de long.

Ici cet unique et simple bloc peut instancier tout et nimporte quoi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Viewer viewer = null;
try {
  ViewerFactory factory = ViewerFactory.getFactoryForFileFormat(extension);
  viewer = factory.createViewer(file);
}
// File format not supported.
catch (UnsupportedFileFormat ufe) {
  ...
}
// File is BAD.
catch(InvalidFileFormatException  iffe) {
  ...
}
if (viewer != null) {
  // Add the viewer to the GUI
  ...
}

Mais rien ne t'oblige a utiliser ce pattern il est toujours possible de coder "normalement" meme si ce n'est pas toujours une solution "correcte" (tout depend tu point de vue et de la destination du programme. Trop de pattern nuit parfois.... pas assez egalement).

[SEMPERE Benjamin]

Oui la factory permet de découpler ton code de telle maniere que la création d'objets est déléguée aux sous classes (ce qui explique la méthode createViewer() qui est abstraite)

Ensuite dans toute sous classe qui étendra "ViewerFactory" tu devra implémenter ta propre createViewer

[bouye]

Il est vai que pour faire un peu plus complet j'aurai du egalement ajouter ces classes-ci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class AdobeViewerFactory extends ViewerFactory { 

  /** Creates a new instance.
  */
  public AdobeViewerFactory() {
  }

  /** @inheritDoc
   */ 
  @Override public Viewer createViewer(File file) throws InvalidFileFormatException, UnsupportedFileFormat {
    // MAY test if file format and extention is valid for this factory.
    // OR may delegate that to the viewer itself.
    ...
    try {
       return new AdobeViewer(file);
    }
    // Handle AbobeViewer-issued exceptions and convert them to this class' supported exceptions. 
    catch (....) {
       ...
    }
  }
} 

public class AdobeViewer extends Viewer { 
  /** Creates  a new instance.
   * @param file The target file.
   * @exception ... Exceptions specific to this viewer or to JDIC/native calls.
   */
  public AbobeViewer(File file) throws ...
    super();
    // Maybe we can use JDIC to call/include Adode Reader in the GUI?
    ...
   }

  ...
}