Vous êtes sur la page 1sur 13

JDIC

Zakaria BENTAHAR
Table des matières

1. Introduction ............................................................................................................................................ 3
2. Le Desktop Component ........................................................................................................................... 4
3. Le composant de type de fichiers ........................................................................................................... 5
4. Le composant navigateur ........................................................................................................................ 7
5. Le composant Packager......................................................................................................................... 10
6. Conclusion ............................................................................................................................................. 13
1. Introduction
Si vous êtes un développeur Java pour un temps vous pouvez avoir eu l'expérience d'être dit que Java
ne peut pas faire tout ce natif C peut. Vous avez peut être lutté avec le volet HMTL Editor tandis que les
développeurs de Windows au bout du couloir inclus Internet Explorer dans leurs programmes avec juste
quelques lignes de code. Je l'admets: aussi grand que Java est, il ya des fois où j'ai longtemps pour les
fonctionnalités et l'accès au système de la programmation autochtone. Eh bien, nous n'avons pas à
attendre plus longtemps.

Vous avez surement entendu parler des composants d'intégration JDesktop (JDIC). Cette nouvelle API
permet aux développeurs Java le genre de choses qu’ils ont toujours envié de nos frères indigènes. Ce
rapport va vous donner un aperçu complet des caractéristiques JDIC, avec un petit exemple de chacun,
et une liste de choses à télécharger pour démarrer.

JDesktop composants d'intégration, ou JDIC, est un projet fourre-tout pour un ensemble de modules qui
donne aux développeurs un accès aux fonctionnalités natives de Java à travers la Croix-API de la plate-
forme. Il a été lancé par le groupe Desktop chez Sun pour permettre aux applications Java une meilleure
intégration avec le bureau sur lequel ils fonctionnent. Ils ont fait JDIC open source comme un moyen
d'obtenir rapidement des commentaires des développeurs sur les fonctionnalités souhaitées, ainsi que
les rapports de bogues. Bien qu'il n'y ait actuellement aucun plan pour ce faire, l'équipe JDIC est à la
recherche en tirant partie des fonctionnalités JDIC dans une future version de la bibliothèque Java de
base.

JDIC est divisé en cinq composantes et un projet d'incubateur:

* Desktop: Lancement des programmes de bureau pour ouvrir, éditer, imprimer, et les fichiers de
courrier.
* Types de fichiers: Ensembles de bureau des associations de fichiers de type.
* Navigateur: embarque un navigateur web natif (Internet Explorer ou Mozilla) en une toile de l'AWT.
* Packager: outils ligne de commande pour la conversion de Java Web programmes Bon départ dans
les installateurs indigènes.
* Tray API: Support pour les icônes de plateau de système et pop-up menus.
* SaverBeans: Ecrans de veille du système en Java
2. Le Desktop Component
La composante Desktop est la plus simple et peut-être la plus utile des composants JDIC. Son
existence entière est consacrée aux services de bureau de base comme l'ouverture d'un fichier
dans l'éditeur de droite, à partir d'un message électronique ou l'envoi d'une URL dans le
navigateur web par défaut. Ce sont toutes les choses qui nécessitent beaucoup de travail sous
le capot de construction, mais très peu à utiliser. Si vous voulez indiquer à l'OS d'ouvrir un
document Microsoft Word, vous n'avez qu'à appeler Desktop.open (new File ( "bentahar.doc
"));.

Le paquet org.jdesktop.jdic.desktop n'a que trois classes: Desktop, le message et


DesktopException. La classe Desktop est statique et ne peut pas être instanciée. Elle a des
méthodes pour l'ouverture, l'édition et l'impression de fichiers. Vous pouvez également ouvrir
un nouvel e-mail et le remplir avec du texte. C'est là que la classe de message intervient, ce qui
vous permet de définir le destinataire, corps, pièces jointes, et l'ensemble des autres parties du
message électronique.

La meilleure chose qu’on peut dire sur le package de composants de bureau est qu’il est facile à
utiliser ; vous n'avez pas à enregistrer un pilote spécial ou changer la configuration qui d’ailleurs
basé sur la plateforme actuelle. Fini ce scénario car tout ceci se fait grâce à JDIC. Tant que le
fichier jdic.jar est dans votre classpath et les lib natives corrects se trouvent dans votre chemin
de bibliothèques, le code fonctionnera tout simplement.

En voici quelques exemples:

 Lancer un naviagteur ( i.e : Yahoo)


Desktop.browse(new URL("http://www.yahoo.com/"));
 Envoyer un email
LinkedList<String> addresse = new LinkedList<String>();
addresse.add("zakaria.bentahar@yahoo.com");
addresse.add("zakaria.bentahar@gmail.com"); Message
message = new Message();
message.setBody("je vous informe que les etudes vont commencer
le …");
message.setSubject("bonjour");
message.setToAddrs(addresse);
Desktop.mail(message);

 Ouvrir un document ( i.e word)


Desktop.open(new File("G://MQL//java//recherche//projet.docx"));
3. Le composant de type de fichiers

La prochaine composante de base de JDIC est le package de types de fichiers, qui définit les
associations de fichiers de type. Cela signifie que vous pouvez dire au système d'exploitation
quel programme à utiliser avec les fichiers, telles que l'ouverture toujours des fichiers texte en
utilisant Word au lieu de Bloc-notes. En utilisant cette API, vous pouvez interroger le système
afin de connaitre les associations existantes, et même de les supprimer.

Étant donné que les associations de types de fichiers sont généralement assez spécifique au
système d'exploitation, cette API est plus utile pour récupérer des associations ou
l'enregistrement de la requête elle-même plutôt que pour la création des associations. Par
exemple, l'association habituelle fichier texte sous Windows est d'appeler notepad.exe dans un
répertoire bien connu. Sous Gnome, il pourrait être de demander / usr / local / bin / gedit.
Comme il s'agit du système spécifique, il n'est probablement pas très utile de fixer des
associations à l'exception de lier une application Java à ses propres types de fichiers. Pourtant,
peu importe ce que vous faites avec elle, la composante Filetypes s'occupe de toutes les levage
lourd pour vous, qui traite du Registre et MIME-type base de données.

Voici un court exemple de la création des associations de fichiers:


Action action = new
Action("open","C:\\WINDOWS\\system32\\notepad.exe");

Association assoc = new Association();


assoc.addFileExtension(".BEN");
assoc.setMimeType("application/ben-chatter");
assoc.addAction(action);

AssociationService svc = new AssociationService();


svc.registerUserAssociation(assoc);

Les deux premières lignes permettent de créer une action qui va ouvrir le fichier avec
notepad.exe. Les quatre prochaines lignes pour créer une association entre l'action et
l'extension de fichier. BEN. J'ai jeté le type MIME, (Multipurpose Internet Mail Extensions est
un standard internet qui étend le format de données des courriels pour supporter des textes en
différents codage de caractères autres que l'ASCII), là-dedans pour faire une bonne mesure.
Dans le passé, la plupart des systèmes d'exploitation sont fondés exclusivement sur l'extension
du fichier ou des métadonnées de propriétés pour déterminer le type de fichier. Cependant, ces
jours-ci, , la plupart des systèmes d'exploitation évoluent vers des paramètres MIME pour tous
typage de fichiers, donc il est bon de commencer à les utiliser maintenant. Les deux dernières
lignes enregistrent réellement l'association sur système. Comme avec toutes les API JDIC, aussi
longtemps que la lib native est dans votre chemin de la bibliothèque, vous n'avez pas besoin de
faire quelque chose de spécial pour le faire travailler.
4. Le composant navigateur

La 3ème principale composante du JDIC est le navigateur. Contrairement aux deux précédentes,
ce qui vous donne juste l'accès aux services du système, ce volet vous donne un widget AWT
réelle à utiliser dans les applications graphiques. Auparavant, vous pouviez utiliser un tiers
composants intégrés ou tous les navigateurs Java, mais avec JDIC c’est une autre histoire car
elle permet d'intégrer les navigateurs web par défaut à l'intérieur de votre application, ouvrant
la porte à de nombreuses possibilités. En écrivant des choses comme les lecteurs RSS avec tout
le soutien du web devient possible. Le téléchargement sera aussi plus rapide, parce que vous
n'aurez pas à inclure le navigateur natif de votre demande.

L'API navigateur vous donne accès à un ensemble d'événements et de contrôle sur l'historique
de navigation (précédent, suivant, rafraîchissement). Les prochaines révisions de l'API sont
censés de fournir plus d’accès vers le navigateur et tous les documents chargés.

En utilisant le navigateur de votre application est vraiment très facile, voici un exemple:
WebBrowser browser = new WebBrowser();
browser.setURL(new URL("http://www.google.com"));

JFrame frame = new JFrame("Browser Test");


frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(browser);
frame.pack();
frame.setSize(500,500);
frame.setVisible(true);
Comme vous l’avez constaté, l'objet WebBrowser est juste un composant AWT que vous
pouvez mettre dans un JFrame standard. La première ligne crée un WebBrowser nouvelles et la
seconde met l'URL que vous voulez afficher. Le reste du code crée un cadre, ajoute le
navigateur, son écran ressemble à la figure 1.

Il ne faut pas oublier que le navigateur Web est un composant AWT natif, de sorte que vous
pouvez rencontrer des problèmes combinant avec Swing. Les deux règles pour réaliser ce
mélange est :

1) de ne jamais se chevaucher Swing et composants AWT

2) Appeller setLightWeightPopupEnabled(false) sur vos menus ou ils disparaitront derrière le


composant navigateur.

À l'heure actuelle, le composant navigateur utilisera l'utilisateur du navigateur Web par défaut,
ce qui signifie habituellement Internet Explorer ou Mozilla, mais vous ne pouvez pas regrouper
les éléments nécessaires de Mozilla avec votre application comme vous pouvez le faire avec
JRex. Ce comportement est probablement bien pour Windows, où IE est quasiment assuré
d'être là, mais ce sera plus problématique sous Linux où, le navigateur par défaut peut ne pas
être Mozilla (elle peut être Konquorer dans KDE, par exemple).
5. Le composant Packager

Contrairement au reste de JDIC, le module de package n'est pas une API. Au lieu de cela, c'est
un ensemble d'outils ligne de commande qui convertissent JNLP (Java Web Start) applications
dans les installateurs indigènes. (RPM pour Linux, pkgs pour Solaris, et MSI pour Windows). Cela
ne signifie pas que votre demande est refusée dans un fichier EXE. JSmooth, avec ou JExePack,
elle vous offre simplement un installateur cliquer pour une application Web Start. Une fois le
programme installé, il se mettra à jour sur Internet, utilisez le descripteur JNLP, et faire toutes
les autres choses que des applications Web Start faire.

La composante Packager exige J2SE 5.0 et les outils natifs. Pour Windows, vous aurez
également besoin d'installer Microsoft MSI SDK. Une fois que votre environnement est
configuré, vous pouvez utiliser la commande jnlp2msi outils en ligne, jnlp2rpm, et jnlp2pkg de
convertir votre application Web Start dans une plate-forme d'installation spécifique.

La barre d'état système (The System Tray)

La barre d'icône de l'API est utilisée pour constituer un projet d'incubateur, mais ce est grâce
aux efforts assidus de la communauté java.net, il a mûri et a été promu à un statut complet.
Son but est de créer pour nos programmes ces petits icônes en bas à droite de l'écran de votre
écran, en supposant que votre système d'exploitation dispose d'un concept de plateau de
système. Dans la pratique, cela signifie que Windows et Linux. Les utilisateurs Mac OS X ne sont
pas de chance (ou mieux, selon votre point de vue). Il soutient aussi des pop-up menus et les
info-bulles automatique pour les icônes. Comme le reste de JDIC, l'appui du système exige le
code natif, mais vous pouvez coder à l'encontre d'une API Java avec un pré-compilés
bibliothèque native.

Depuis l'API est une jolie petite envergure, il n'ya que deux classes: SystemTray et TrayIcon. La
classe SystemTray a une méthode de fabrique statique pour accéder à la barre d'état système
par défaut. TrayIcon vous permet de joindre une JPopupMenu et une icône pour le prochain
espace disponible sur le plateau de système. Enfin, appelez SystemTray.getDefaultSystemTray
(). AddTrayIcon () pour obtenir votre "pop-up apparaîtra. Examinons un petit exemple:
JPopupMenu menu = new JPopupMenu("Tray Icon Menu");
JMenuItem yahooItem = new JMenuItem("Yahoo");
menu.add(yahooItem);
menu.addSeparator();
JMenuItem quitItem = new JMenuItem("Quit");
quitItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
System.exit(0);
}
});
yahooItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null, "Redirection vers yahoo",
"About", JOptionPane.INFORMATION_MESSAGE);
try {
Desktop.browse(new URL("http://www.yahoo.com/"));
} catch (MalformedURLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (DesktopException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
});

menu.add(quitItem);

// Resource file "duke.gif" must exist at the same directory


// as this class file.
ImageIcon icon = new ImageIcon("yahoo.gif");
TrayIcon ti = new TrayIcon(icon, "Yahoo", menu);

// Action listener for left click.


ti.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

try {
Desktop.browse(new URL("http://www.yahoo.com/"));
} catch (MalformedURLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (DesktopException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
});

SystemTray tray = SystemTray.getDefaultSystemTray();


tray.addTrayIcon(ti);
}
Dans les premières lignes du constructeur SystemTrayTest nous créons un JPopupMenu avec
trois éléments de menu. Le dernier, quitter, ajoute un ActionListener pour quitter le
programme. Maintenant, au lieu d'ajouter le menu pour une barre de menu ou JComponent,
nous avons mis le menu dans le constructeur d'une TrayIcon. Le ImageIcon pour l'image de
plateau de système est également passé dans le TrayIcon, avec le texte d'une info-bulle. Enfin,
nous ajoutons le TrayIcon à la valeur par défaut SystemTray et le programme est terminé.
Compilez ce avec tray.jar dans votre classpath et tray.dll dans votre chemin de la bibliothèque
(généralement le répertoire de travail). L'icône et ses menus sont affichés dans la figure 2.

L'API Tray soutient également GIF animés et des icônes à cliquable à gauche. Avec cette API,
vous pouvez faire disparaître complètement votre application dans la barre des tâches jusqu'à
leur utilisation.
6. Conclusion

Bien que JDIC soit encore bêta, elle montre de grandes promesses. Des modifications ont été
arrivée à grand pas. Des travaux sont déjà en cours pour plier à des projets plus anciens,
corriger les bugs, à soutenir le Mac, et éventuellement migrer certaines parties de JDIC au
runtime de base.

Bien que cela semble venir de nulle part, JDIC est quelque chose que beaucoup de
développeurs Java attendent depuis longtemps. Maintenant que c'est ici, nous pouvons
vraiment développer des applications Java qui font tout ce que les programmes natifs peuvent
faire.