Valhalla.fr
Sic Itur Ad Absurdum
30 Sept 2001 Ouvrir et enregistrer du texte en Java

Enregistrer…

Vous pouvez remplacer "TextArea" par "composant
texte" dans le titre de ce tutoriel, car le code ci-dessous fonctionne
avec tous les composants texte: TextArea, JTextArea, JTextPane, JEditorPane.
(Avec TextArea le titre est plus parlant)

Le but de cet article est de montrer comment récupérer
le contenu d’un composant texte pour l’enregistrer dans un fichier, avec ou
sans JFileChooser pour choisir le nom du fichier de sortie.

Le code d’enregistrement est extrèmement simple:

// A insérer dans un bloc try...catch
try

{ FileWriter lu = new FileWriter(monFichier);
// Créer un objet java.io.FileWriter avec comme argument le mon du
fichier dans lequel enregsitrer

   BufferedWriter out = new BufferedWriter(lu);
// Mettre le flux en tampon (en cache)

   out.write(textArea.getText()); //
Balancer dans le flux le contenu de la zone de texte

   out.close(); // Fermer le flux (c'est
toujours mieux de le fermer explicitement)

 } catch (IOException er) {;}

On suppose que l’on a:
- un String du nom de "monFichier" indiquant le nom du fichier dans
lequel enregistrer le texte
ex: String monFichier = "monFichier.txt";
- Un composant de texte du nom de textArea
ex: JTextArea textArea = new JTextArea();

Le code est complet et fonctionel ! On peut l’insérer
dans une méthode ou directement dans un gestionnaire d’évènements
!

Mais une fonction souvent nécessaire supplémentaire
est d’ajouter un JFileChooser en amont pour que l’utilisateur puisse spécifier
lui même le nom du fichier, sans que nous ayons à le lui imposer,
comme ici…

Voici donc la procédure:

try
{ JFileChooser filechoose = new JFileChooser();
// Créer un JFileChooser
   filechoose.setCurrentDirectory(new
File(".")); // Le répertoire
source du JFileChooser est le répertoire d'où est lancé
notre programme

   String approve = new String("ENREGISTRER");
// Le bouton pour valider l'enregistrement portera la
mention ENREGSITRER

   int resultatEnregistrer = filechoose.showDialog(filechoose,
approve); // Pour afficher le JFileChooser...
   if (resultatEnregistrer ==
JFileChooser.APPROVE_OPTION) // Si l'utilisateur clique
sur le bouton ENREGSITRER

   { String monFichier= new String(filechoose.getSelectedFile().toString());
// Récupérer le nom du fichier qu'il a spécifié

      if(monFichier.endsWith(".txt")
|| monFichier.endsWith(".TXT")) {;}
// Si ce nom de fichier finit par .txt ou .TXT, ne rien faire et passer à
a suite

      else (monFichier = monFichier+ ".txt");
// Sinon renommer le fichier pour qu'il porte l'extension .txt

      { // INSERER
ICI LE CODE EXPLIQUE CI-DESSUS POUR ENREGISTRER LE FICHIER

      }
   }
} catch (IOException er) {;}

Et voilà, on a un beau petit JFileChooser
qui nous demande de taper le nom du fichier que l'on veut enregsitrer !


</p>

Ouvrir…

Vous pouvez remplacer "TextArea" par "composant
texte" dans le titre de ce tutoriel, car le code ci-dessous fonctionne
avec tous les composants texte: TextArea, JTextArea, JTextPane, JEditorPane.
(Avec TextArea le titre est plus parlant)

Ce tutoriel explique comment ouvrir le contenu d’un fichier
dans un JTextArea, avec ou sans JFileChooser.

Le code d’ouverture est très simple:

try
{ FileInputStream fis = new FileInputStream(monFichier);
// Créer un flux d'entrée avec comme paramètre le nom
du fichier à ouvrir

   int n;
   while ((n = fis.available())
> 0) // tant qu'il y a des données dans le flux...
   { byte[] b = new
byte[n]; // récupérer
le byte à l'endroit n et le stocker dans un tableau de bytes

      int result
= fis.read(b); // lire ce tableau de byte à l'endroit
désiré

      if (result
== -1) break; // si le
byte est -1, c'est que le flux est arrivé à sa fin (par définition)

      String s = new String(b);
// assembler les bytes pour former une chaîne
      textArea.setText(s); //
insérer cette chaîne dans notre composant de texte

   }
} catch (Exception err) {;}

Ceci suppose que l’on a créé
- un String du nom de nonFichier pointant vers le fichier à ouvrir.
String monFichier = "C:\Mes Documents\le_beau_ficher.txt";
- un composant de texte dans lequel afficher le texte:
JTextArea textArea = new JTextArea();

 

Le code est complet et fonctionel ! On peut l’insérer
dans une méthode ou directement dans un gestionnaire d’évènements
!

Mais une fonction souvent nécessaire supplémentaire
est d’ajouter un JFileChooser en amont pour que l’utilisateur puisse spécifier
lui même le nom du fichier, sans que nous ayons à le lui imposer,
comme ici…

Voici donc la procédure:

try
{ JFileChooser filechoose = new JFileChooser();
// Créer un JFileChooser
   filechoose.setCurrentDirectory(new File("."));
// Le répertoire source
du JFileChooser est le répertoire d'où est lancé notre
programme

   String approve = new String("OUVRIR");
// Le bouton pour valider l'enregistrement
portera la mention OUVRIR

   String monFichier= null; //
On ne sait pas pour l'instant quel sera le fichier à ouvrir

   int resultatOuvrir = filechoose.showDialog(filechoose,
approve); // Pour afficher
le JFileChooser...

   if(resultatOuvrir == filechoose.APPROVE_OPTION)
// Si l'utilisateur clique
sur le bouton OUVRIR

   {
  monFichier =
filechoose.getSelectedFile().toString();

// Récupérer
le nom du fichier qu'il a spécifié


       // INSERER ICI LE CODE EXPLIQUE CI-DESSUS
POUR OUVRIR LE FICHIER

   }
}catch (IOException er) {;}

 

Et voilà, on a un beau petit JFileChooser
qui nous demande de sélectionner le fichier à ouvrir !

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com
/ www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Ecrit à Montpellier le 30 septembre 2001

• 1073 mots • #programmation #java
30 Sept 2001 Comment utiliser un ResourceBundle sous JBuilder pour l'internationalisation d'un logiciel ?

Parmi les nombreuses fonctionnalités des versions Pro et Entreprise de JBuilder 5, on peut trouver un outil ("Wizard") très utile, qui permet de "ressources les Strings" de vos programmes.
Un exemple est le bienvenu pour montrer l’ampleur d’une telle fonction: vous créez votre programme avec une interface en français, et, par exemple, une fenêtre (classe héritant de JFrame) avec pour titre "Bienvenue dans mon logiciel !", par l’instruction this.setTitle("Bienvenue dans mon logiciel !");. Si vous décidez de traduire votre logiciel dans plusieurs autres langues, vous devrez ré-écrire votre code en remplaçant à chaque fois votre phrase par sa traductions dans les langues désirées. Vous allez donc devoir créer X versions de votre code source et les compiler… c’est long et contraignant.
Le créer des "Strings ressourcés" permet de remédier à ce problème. En effet, la procédure change du tout au tout: tous les messages sont créés dans un fichier texte brut que l’on peut éditer sous n’importe quel bloc-notes. Pour distribuer des versions dans des langues étrangères, il suffira donc de créer plusieurs versions de ce fichier texte ! Le code lui même n’est pas changé.

Note: on utilise ici la version US de JBuilder… la procédure est similaire dans la version française.

Voici donc la procédure en images:

1) Une fois votre classe implémentée, lancer l’assistant dans JBuilder, c’est la dernière entrée du menu "Wizard": "Resource Strings"

RessourcesStrings

2) Une fenêtre s’ouvre, on est invité à spécifier le nom du "ResourceBundle", en général Res est le nom par défaut.

RessourcesStrings

On doit ensuite spécifier que l’on veut créer des ressources à partir des chaînes dures de notre classe, en cochant le premier Radio. On clique ensuite sur Next (Suivant).

3) Une fenêtre s’ouvre avec toutes les chaînes dures de votre classe, on peut choisir de décocher les chaînes que l’on ne veut pas voir exporter (j’ai décoché ici n’importe quoi sans faire attention de qui il s’agissait).

Tout est coché par défaut.

L’ instruction dans laquelle se trouve le String sélectionné est affichée en bas de la fenêtre. Ici le String vide (qui correspond à 1 espace de la barre d’espace) se trouve dans l’appel de la méthode updateTitle(""); (et on voit bien qu’elle admet ici comme argument une chaîne vide).

RessourcesStrings

NOTE: dans la suite de cet article je n’ai pas gardé les mêmes chaînes que celles que vous pouvez voir sur cette capture d’écran, en effet, il n’est d’aucun intérêt de ressources les chaînes affichées ci-contre. J’utilise dans la suite de ce tutoriel un exemple concret, sur une URL, ce qui est vraiment plus utile: pas besoin de recompiler le programme à chaque changement d’adresse du site !!

On clique ensuite sur Finish (Terminer).

4) L’opération est terminée.

RessourcesStrings

Nous allons maintenant nous intéresser à ce qu’a fait JBuilder.

On voit pour commencer qu’il a créé un objet statique ResourceBundle nommé "res" et qui est créé avec pour argument la chaîne "Res" qui en en fait le nom du fichier texte brut dans lequel sont stockées les chaînes.

5) En parcourant le code de notre classe, on s’aperçoit que certaines instructions ont été changées. Ici, l’instruction était:

jTextPane1.setPage("http://perso.wanadoo.fr/guillaume/cadre_droit.htm");

qui a été modifiée en ce qu’on voit sur la capture d’écran.

RessourcesStrings

On conclue que notre URL ci-dessus correspond à l’entrée "ACTU_ADDRESS" dans le fichier texte brut sur lequel pointe notre objet REsourceBundle "res".

6) Nous allons donc voir ce fichier texte brut pour savoir comment il est formé. On peut le trouver dans la liste des fichiers du projet, en haut à gauche de la fenêtre de JBuilder.

On l’ouvre en double-cliquant dessus.

RessourcesStrings

7) Et voilà notre fichier.

RessourcesStrings

La première ligne est un commentaire (syntaxe des commentaires Unix: ligne débutant par dièse #). Les autres lignes sont simplement les correspondances des chaînes que nous avions dans nos classes. On peut voir la chaîne représentée par l’entrée ACTU_ADDRESS, chaîne que j’ai citée plus haut. On note aussi la syntaxe un peu particulière: "http://" au lieu de"http://". Ceci s’explique par le fait que les deux points (:) sont un caractère spécial et que l’anti-slash () sert à signaler la présence d’un caractère spécial. N’y faites pas attention, mais respectez la syntaxe si vous changez votre URL. Je tiens à dire, pour terminer, que cet exemple est fonctionnel, puis qu’il s’agit du fichier de ressources qu’utilise ML. (regardez dans le JAR de ML…).

Conclusion:

Pour reprendre notre premier exemple, on oppose:

</tr> </table>

Tutoriel distribué pour le FAQ Java de Java-France www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Écrit à Montpellier le 30 septembre 2001

Sans les Strings ressourcés (3 compilations) Avec les Strings ressourcés (1 compilation)

this.setTitle("Bienvenue dans mon logiciel</p>

!");
this.setTitle("Welcome in my Soft !");
this.setTitle("Bienvenido en mi programa !"); </font>

</td>
this.setTitle(res.getString("BONJOUR"));

Dans le fichier de propriétés:
BONJOUR=Bienvenue dans mon logiciel !
BONJOUR=Welcome in my Soft !
BONJOUR=Bienvenido en mi programa !

• 864 mots • #programmation #java
31 Août 2001 Trouver les premiers nombres premiers

Ceci ne concerne pas vraiment une technique de programmation, c’est plutôt un exercice pour se former l’esprit, et c’est aussi la démonstration que Java peut servir pour le calcul mathématique.

L’algo mis en place est le plus simple dans le genre: on premd un nombre impair, on le divise par chaque entier impair entre 3 et sa racine carrée. S’il n’a aucun diviseur il est premier.

// Le nombre candidat de départ, mettez la valeur que vous désirez, ce sera le nombre de départ et le programme ira en choisissant des nombres de plus en plus grands
long candidat = 1000;

while (true) // ou for (;;) sont des boucles infinies qui ne vérifient pas de condition
{
// on invoque la méthode estPremier() qui renvoie un booleen: oui ou non le nombre qu’on lui soumet est premier, l’instruction if(estPremier(candidate)) est équivalente
// à if (estPremier(candidate) == true)
if(estPremier(candidate)) {System.out.println(">Est premier le nombre: " + candidate);
}

private static boolean estPremier(long candidat)
{
// Diviser le nombre par tous les entiers impairs entre 3 et sa racine
double racine = Math.sqrt(candidate);
for (long i = 3; i <= sqrt; i += 2) // on incrémente de 2 pour sauter les pairs
{
// si le modulo, c-à-d le reste de la division euclidienne est 0, le nombre est divisible par i, i est donc un facteur, le nombre n’est pas premier.
if (candidat % i == 0) return false;
}
// Si la cdt ci-dessus n’est jamais vérifiée, alors le nombre est premier:
return true;
}

Et voilà, vous n’avez plus qu’à rédiger la méthode main() où à incorporer ce code dans une de vos classes, ici les premiers sont sortis en console. (System.out)

Tutoriel distribué pour le FAQ Java de www.jgflsoft.com ou www.java-france.com
Réédité pour Valhalla GFBLOG.
Ecrit à Montpellier le 31 août 2001

• 331 mots • #programmation #java
31 Août 2001 Comment naviguer sur Internet avec un JEditorPane ?

Cet article de la FAQ Java de l’association Java-France a pour but d’expliquer la procédure à suivre pour afficher des pages HTML, qui répondent aux liens, dans un JEditorPane ou un JTextPane (même procédure). En effet, ces deux composnats (JTextPane héritant de JEditorPane) implémentent des méthodes compliquées (plusieurs milliers de lignes de code) permettant de formater un document au format HTML, et de lancer une connexion pour afficher une nouvelle page si l’on clique sur un lien.

Nous allons donc voir, en 3 points, comment faire pour mettre en place un tel JEditorPane.

1) Le déclarer, l’insérer dans l’interface (dans un JScrollPane de préférence), et faire tout ce qu’il faut pour qu’il s’affiche dans ue fenêtre quand on lance le programme.

2) L’interdire en écriture: editorPane.setEditable(false);

3) Créer un gestionnaire d’évènements "HyperlinkListener".

editorPane.addHyperlinkListener(new HyperlinkListener()
{ public void hyperlinkUpdate(HyperlinkEvent event)
{ if (event.geteventType() == HyperlinkEvent.EventType.ACTIVATED)
{ try
{editorPane.setPage(event.getURL());
}catch(IOException ioe) {;}
}
}
}
});

Et voilà le travail !

Tutoriel distribué pour le FAQ Java de www.jgflsoft.com ou www.java-france.com
Réédité pour Valhalla GFBLOG.
Ecrit à Montpellier le 31 août 2001

• 196 mots • #programmation #java
30 Août 2001 Introduction à Java IDL

Article de Sun traduit et adapté en français.

Qu’est-ce que Java IDL ?

Java IDL est une technologie pour les "objets distribués", c’est-à-dire des objets interagissant avec différentes stations de travail d’un réseau. Java IDL est similaire à RMI (Remote Method Invocation) qui supporte des objets distribués écrits entièrement et exclusivement en langage Java. Cependant, Java IDL permet aux objets d’être utilisés même s’ils sont écrits dans un langage différent de Java, comme C/C++, Cobol, et bien d’autres.

Ceci est possible car Java IDL est basé sur l’architecture CORBA (Common Object Request Brokerage Architecture), un standard mondial de l’industrie dans la distribution d’objets sur un réseau. Une des composantes de Corba est IDL (Interface Definition Language), langage dit "neutre". Chaque langage de programmation supportant Corba implémente une IDL, d’où le nom de "Java IDL", l’implémentation IDL pour Java. Corba et IDL sont issus d’un consortium de trusts mondiaux (notamment IBM, Boeing, etc.) connus sous le nom de OMG (Object Management Group), et le fait que Sun Microsystems soit l’un des membres fondateurs explique que IDL soit si bien adapté à Java.

Pour permettre des interactions entre les objets de différents programmes d’un réseau, Java IDL "fourni" un ORB (Object Request Broker). Un ORB est une bibliothèque de classes qui permet une communication de bas niveau entre Java IDL et d’autres applications basées sur Corba.

L’architecture CORBA

Une interaction entre 2 objets sur un réseau a toujours 2 sens: le client et le serveur (entrée/sortie su vous préférez). Le serveur crée une "Remote Interface" (c’est à dire une porte d’entrée vers lui), et le client appelle et utilise cette "Remote Interface". Ceci est globalement la procédure généralisée utilisée par les standards d’objets distribués comme RMI ou Corba. On notera que les mots "client" et "serveur" désignent des interactions au niveau des objets et pas des applications: un logiciel peut être à la fois client et serveur selon s’il publie ou reçoit tel ou tel objet.

Du côté du client, l’application a une référence vers l’objet distribué. La référence a une méthode "stub" ("stub" signifie le "talon" d’un ticket en anglais) qui est une sorte des remplaçant pour la méthode appelée à distance. Le "stub" est installé dans l’ORB, l’appeler revient donc à activer les fonctions de communication de l’ORB qui se chargera de la connexion au serveur.

Du côté du serveur, l’ORB utilise un "squelette" de code pour traduire l’appel à distance en un appel de méthode sur un objet local. Le squelette se charge de bien traduire la requête dans le format attendu par l’objet local. Quand la méthode finit (à comprendre: quand elle retourne) le squelette se charge de traduire la valeur de retour ou les erreurs et de les transmettre à l’ORB qui les transmet à son tour au client.
Entre les ORB, la communication est établie grâce à un protocole spécial: IIOP (Internet Inter-ORB Protocol). IIOP, basé sur le standard TCP/IP, définit comment des ORB pour Corba échangent des informations. Tout comme Corba et IDL, IIOP est un standard définit par l’OMG (Object Management Group).

En plus des possibilités de communication exposées plus haut, les ORB basés sur Corba ont des fonctionnalités améliorées, des services définis par l’OMG. Ceci inclut la recherche d’objets par nom, la persistance d’objets, la possibilité d’échanger des messages, etc. Certains ORB supportent ces fonctions, celui fourni avec Java IDL supporte la recherche d’objets par nom.

Le processus de développement de Java IDL

1) Définir l’interface à distance
On définit l’interface à distance en utilisant le langage de définition de l’interface de l’OMG, c’est à dire IDL. On utilise IDL plutôt que Java car le compilateur idl-to-java travaille à partir d’un (code) source IDL, générant tous les fichiers "stub" et "squelette" avec le code d’infrastructure nécessaire à la connexion avec l’ORB. En utilisant IDL, on permet aux autres développeurs d’implémenter des clients et des serveurs dans d’autres langages compatibles Corba.

2) Compiler l’interface à distance
Quand on lance le compilateur idl-to-java sur le fichier source de définition de l’interface, il génère une version en Java de l’interface, comme il génère les stubs et les squelettes.

3) Implémenter le serveur
Une fois le compilateur idl-to-java lancé, on peut utiliser les squelettes générés pour assembler son serveur. En plus d’implémenter les méthode de l’interface à distance, le code du serveur inclut un mécanisme pour lancer l’ORB et attendre une requête d’un client.

4) Implémenter un client
De même on utilisera les stubs générés par le compilateur comme base pour l’application client. Le code client construit à partir des stubs lance l’ORB de son côté qui recherche une connexion vers le serveur utilisant le service de noms indiqué par Java IDL, obtient une référence vers l’objet à distance et invoque à distance ses méthodes.

5) Démarrer l’application
Une fois le serveur et le client créée, on peut lancer le service de noms, puis démarrer le serveur, et enfin lancer le client.

Notes:
1) Avec Java 1.3, idltojava compiler est remplacé par idlj compiler
2) Si vous désirez un exemple concret: HelloWorld! dans la suite de cet article de la FAQ. Article Sun ici.

Traduit et adapté de l’anglais par Narcanes, (article original de Jim Inscore Sun Microsystems)
pour l’association Java-France/Jgflsoft
www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Montpellier, 30 août 2001.

• 890 mots • #programmation #serveur #java