Valhalla.fr

Sic Itur Ad Absurdum

"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
30 Sept 2001

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
"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
31 Août 2001

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
"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
31 Août 2001

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
"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
30 Août 2001

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
"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
28 Août 2001

Traduction (adaptation, simplification) d’un article de Sun.

Historique

Comment sommes-nous arrivés à un stade où l’orientation "online" des services et du matériel informatique est la préoccupation majeure des fabriquants ?

L’explication la plus évidente est notre meilleure connaissance de domaines scientifiques tels que la chimie ou l’électronique appliqués à la micro-informatique. De nos jours, un ordinateur personnel peut être fabriqué à partir d’un minimum de matériel et les serveurs d’entreprise ne sont plus ces gros amas de tôles et de câbles occupant des pièces entières.

Dans les années 60, seules les grosses entreprises pouvaient se payer le luxe d’un ordinateur (d’un de ces amas de tôles et de câbles).

Puis vient la miniaturisation et la création de terminaux: des écrans et des claviers, sans grosse unité centrale, reliés en réseau à un serveur. Cela résolvait pas mal de problèmes de place, et annoncait le début de la vague "online".

Les "stations de travail", ordinateurs du format de ceux d’aujourd’hui, firent leur apparition un peu plus tard. Ils offraient une puissance suffisante pour les travaux scientifiques tels que le dessin technique, le développement d’application scientifiques…

L’ordinateur personnel (PC) était également assez petit pour tenir sous une table et assez puissant pour offrir des fonctionnalités telles qu’une interface graphique à ses utilisateurs.

De nos jours la miniaturisation en est à un tel point que les voitures ont en moyenne une cinquantaine de microprocesseurs, et que l’on peut en trouver plus d’une centaine dans une maison.

Mais la création de ces ordinateurs toujours plus petits et moins cher a eu une retombée imprévue: la disparition d’une forme de vie en communauté. En effet, les ordinateurs étant plus disponibles, il n’était plus nécessaire des les partager entre plusieurs personnes, tout le monde pouvait avoir son ordinateur personnel, au travail comme à la maison.
Et l’internet domestique pallie à cet effet: les stations de travail et les ordinateurs pesonnels ne sont vraiment utiles dés lors qu’ils sont connectés entre eux afin de pouvoir communiquer.

Plus loin dans cette voie, les ordinateurs peuvent maintenant échanger des objets (comprenez: des classes Java) et supporter des langages orientés objet et communication. Pout la plupart des gens un ordinateur sert avant tout à chercher des informations sur internet, communiquer par e-mail, etc…

Comment fonctionne Jini ?

La technologie Jini est une architecture pour la construction de systèmes à partir d’objets (de classes…) et de réseaux. La technologie Jini permet aux programmes d’utiliser des services dans un réseau sans savoir quoi que ce soit du protocole de connexion de ce réseau. Une implémentation d’un système pourrait être basée sur les RMI, une autre sur XML et encore une autre sur CORBA. Le client Jini interroge les services qui lui répondent comment ils s’utilisent ! Un service est défini par une API, déclarée comme une interface de programmation Java.

Quand un service est "branché" à un réseau ou matériel basé sur l’architecture Jini, il s’identifie en publiant un objet Java qui implémente l’API du service concerné.
Le client trouve des services en cherchant un objet supportant l’API Jini. Une fois connecté au service, il télécharge un code qui lui indique comment communiquer avec ce service. Les programmeurs qui auront implémenté le service auront choisi comment transformer une requête de l’API en bits de manière à utiliser un protocole comme UPnP, RMI, Corba ou un protocole privé.

Créer une communauté autour de la technologie Jini

Quand internet fur créé, les deux préoccupations majeures étaient de définir et de perfectionner les protocoles de communication et les infrastructures du réseau, et de créer des services et des applications utilisant ce réseau. L’infrastructure d’internet inclu les protocoles TCP/IP, HTTP, SMTP, FTP (etc…), et leurs implémentations. Avec ces protocoles furent créée des logiciels comme les navigateurs, les clients e-mail ou les clients FTP, et même le Web lui même. Ce n’est pas une seule entreprise aui réussit à créer Internet, mais de nombreuses entreprises ayant adopté les mêmes protocoles, ayant des standars. C’est pourquoi pour que Jini réussisse, un grand nombre de personnes doit l’utiliser. Plus il sera utilisé plus facilement il devientra une technologie de référence.

La Sun Community Source License (SCSL) a été crée pour mettre en place une communauté autour de Jini. La SCSL donne libre accès au code source de la technologie Jini et de ses dévés, libres de droits en utilisation et modification.

Liens

Pour s’enregistrer http://www.sun.com/jini/licensing/
Des infos sur la communauté: http://www.sun.com/jini/community/

Traduit par Narcanes ([email protected])
à partir d’un article de Sun,
pour l’association Java-France / Jgflsoft
www.java-france.com / www.jgflsoft.com
Réédité pour Valhalla GFBLOG.
Montpellier, 28 août 2001.

• 771 mots • #programmation #serveur #java
"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
3 Juill 2001

Ce chapitre de la FAQ a pour but de montrer comment exporter, sous la forme d’une archive JAR, un programme Java (application, applet, servlet, web app, bean, etc…). Nous utiliserons ici la situation la plus simple: une application (avec méthode main()) exportée dans une archive JAR auto-exécutable. Nous détaillerons les étapes de la création d’une telle archive.

NOTE 1: Pour des raisons de temps notamment (JBuilder 5 n’est pas encore sortie en France à l’heure de la rédaction de cet article), la version de JBuilder utilisée sera la version US.

NOTE 2: cette page contient de nombreuses images, le temps de chargement peut être assez long…

1) Lancer l’outil, ou wizard, d’exportation: Menu WIZARDS -> ARCHIVE BUILDER

JarExport

2) Première étape de l’exportation: le choix d’un format.

JarExport

Nous choisissons ici le format "Application". On peut cependant prendre "Basic" (comme "Application" mais non auto-exécutable), Applet pour exporter des applets, Web Start pour exporter des Web App, etc… Une description de chaque option est faite dans la case de la fenêtre "Description".

3) Résolution des dépendances (1)

Un programme Java a la plupart du temps des dépendances, c’est à dire des classes ou des packages absolument nécessaires pour s’exécuter. Par exemple, un programme utilisant une interface graphique Swing devra absolument intégrer les classes du package Swing nécessaires. Pas besoin de spécifier ici les classes du package Swing ou de tout autre package "classique" fourni avec le JDK. Par contre, si vous utilisez des bibliothèques non fournies par défaut (par exemple le VerticalFlowLayout de Borland). C’est également ici que l’on ajoutera à l’archive tous les fichiers non-java nécessaires.

4) Résolution des dépendances (2)

JarExport

Vous ne ferez rien ici si aucun package autre que les packages par défaut de Sun n’est nécessaire à votre programme. Sinon vous devrez décider du niveau d’inclusion. Je conseille d’inclure toutes les classes et toutes les ressources, on perd un peu en taille du fichier, mais on est sûr que tout fonctionnera !

5) Créer un fichier MANIFEST

Cette étape n’est pas nécessaire dans tous les cas, par exemple si vous avez choisi "Basic" à l’écran (1), le fichier manifest ne sera par défaut pas créé. Par contre pour "Application" il est nécessaire: le fichier Manifest indique, entre autres, à l’interpréteur Java quelle classe contient la méthode main(), condition nécessaire à l’auto-exécution de l’archive.

JarExport

Vous pouvez choisir d’inclure un Manifest que vous avez créé vous même, amis pourquoi se compliquer la vie quand JBuilder le génère tout seul comme un grand ?!

6) Spécifier la classe main()

JarExport

Un package, une archive, peuvent contenir plusieurs classes implémentant une méthode main(). On définit ici laquelle des ces méthodes main() devra être signalée au Manifest. On laissera cochée la case "Use the main class specified in the default runtime" par défaut. Lors de la première exécution d’un programme (à moins que l’ossature de ce programme n’ait été créée par JBuilder lui-même), JBuilder vous demande quelle est la classe principale du programme, et c’est cette classe, contenant la méthode main() dans le cas d’une application, qui sera utilisée pour lancer le programme sous JBuilder (en runtime normal ou en debug), et qui sera ici considérée comme la classe principale du programme à signaler comme telle au Manifest.

7) Observer

JarExport

On voit une nouvelle icône dans l’inspecteur d’objets. Notre archive s’appelle "Application", mais ne contient pas encore de fichier Jar. Pour créer réellement le fichier Jar nous devons "reconstruire" le programme.

8) Reconstruire

JarExport

Pour "reconstruire" on peut soir faire un clic-droit sur l’icône "Application" et choisir "Reconstruire" (ou "Rebuild" en version US) afin de créer le fichier JAR. On peut aussi utiliser le bouton de la barre d’icônes.

Ceci est très pratique: à chaque compilation, JBuilder recrée automatiquement le fichier JAR. Un exemple de compilation ci-dessous où l’on voit que JBuilder est en train de créer l’archive. (j’ai dû m’y reprendre à plusieurs fois pour faire la capture d’écran tellement que la création de cette archive, pour notre petit programme exemple, est rapide !)

JarExport

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

• 717 mots • #programmation #java
"GF", "login"=>"gflorimond", "email"=>"[email protected]", "url"=>"http://www.valhalla.fr"}" itemtype="https://schema.org/Person" />
2 Juill 2001

Cet article de la FAQ a pour but de montrer comment télécharger un fichier depuis Internet vers son Disque Dur. On peut utiliser plusieurs méthodes, et celle à laquelle on pensera en premier lieu est sûrement d’implémenter un petit client FTP ou d’utiliser un JavaBean FTP comme celui d’IPWorks (dans JBuilder 5). Cependant, je propose ici une solution plus simple (beaucoup plus simple), à partir du moment où l’on connaît l’adresse exacte du fichier à télécharger. Cette méthode est également plus sécurisée, en cela que l’on a aucun besoin de spécifier un login et un mot de passe.

Nous allons donc utiliser une méthode avec URLConnection. Voici le code source commenté:

// Spécifier le chemin exact vers le fichier
URL u = new URL("http://www.monserveur.com:80/monrepertore/lisezmoi.txt");

// Ouvrir la connexion, début de la communication avec le serveur
URLConnection uc = u.openConnection();

// Récupérer la taille exacte en nombre d’octets du fichier désigné, et la stocker dans un int
int taille = uc.getContentLength();

// Créer un flux d’entrée pour le fichier
InputStream brut = uc.getInputStream();

// Mettre ce flux d’entrée en cache (pour un meilleur transfert, plus sûr et plus régulier).
InputStream entree = new BufferedInputStream(brut);

// Créer une matrice (un tableau) de bytes pour stocker tous les octets du fichier
byte[] donnees = new byte[taille];

// Pour l’instant aucun octet n’a encore été lu
int octetsLus = 0;

// Octets de déplacement, et octets déjà lus.
int deplacement = 0; float alreadyRead = 0;

// Boucle permettant de parcourir tous les octets du fichier à lire
while(deplacement < taille)
{
// utilisation de la methode "read" de la classe InputStream
octetsLus = entree.read(donnees, deplacement, donnees.length-deplacement);

// Petit calcul: mise à jour du nombre total d’octets lus par ajout au nombre d’octets lus au cours des précédents passages au nombre d’octets lus pendant ce passage
alreadyRead = alreadyRead + octetsLus;

// -1 marque par convention la fin d’un fichier, double opérateur "égale": = =
if(octetsLus == -1) break;

// se cadrer à un endroit précis du fichier pour lire les octets suivants, c’est le déplacement
deplacement += octetsLus;

}
// fermer le flux d’entrée.
entree.close();

// Récupérer le nom du fichier
String fichier = u.getFile();
fichier = fichier.substring(fichier.lastIndexOf(‘/’) + 1);

// Créer un fichier sur le DD afin d’y copier le contenu du fichier téléchargé (par un flux de sortie).
FileOutputStream fichierSortie = new FileOutputStream(fichier);

// copier…
fichierSortie.write(donnees);

// vider puis fermer le flux de sortie
fichierSortie.flush(); fichierSortie.close();

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

• 470 mots • #programmation #serveur #java