Utilisation de l'API JavaMail
[40 mn de lecture - paru le 9/4/2003 - Public : Débutant]
|
   
|
Auteur
2. Présentation des classes importantes de l’API JavaMail
JavaMail propose des classes et interfaces qui encapsulent ou définissent les
objets liés à l'utilisation des mails ainsi que les protocoles utilisés pour les
échanger.
2.1 La classe Session
La classe Session établit la connexion avec le serveur de mail. C'est elle
qui encapsule les données liées à la connexion (options de configuration et
données d'authentification : login, password, nom du serveur).
C'est à partir d'un objet Session que toutes les actions concernant
les mails sont réalisées. En effet, avant n'importe quelle action, il faut récupérer
une Session.
Une session peut être unique ou partagée par plusieurs entités.
Pour créer ces sessions on utilise les méthodes :
getInstance( Properties, Authenticator) : session unique
getDefaultInstance(Properties, Authenticator ) : session partagée
Pour obtenir une session, deux paramètres sont attendus :
Un objet Properties
qui contient les paramètres d'initialisation. Un tel objet est obligatoire
Un objet Authenticator
optionnel qui permet d'authentifier l'utilisateur auprès du serveur de mail.
// création d'une
session unique
Session session = Session.getInstance(props,authenticator);
// Récupère la session partagée par défaut
Session defaultSession = session.getDefaultInstance(props,authenticator); |
La méthode setDebug() qui attend en paramètre un booléen est
très pratique pour debugger car avec le paramètre true, elle affiche des informations
lors de l'utilisation de la session notamment le détail des commandes envoyées
au serveur de mail.
2.2 La classe Message
La classe Message est une classe abstraite qui encapsule un message.
Lorsque vous avez votre objet Session, le message peut être
créé.
Avant de commencer, il faut savoir qu'un message est composé de deux parties
:
Une en-tête qui contient un
ensemble d'attributs (auteur, destinataire, sujet ...)
Ces attributs peuvent être:
TO : Adresse Internet
du destinataire
FROM
: Adresse Internet de l’expéditeur
Date : date et heure de
l’expédition
Subject : Le sujet du
message
Message-ID : numéro d’identification
du message
Un corps qui contient les
données à envoyer (contenu)
Pour la plupart de ces données, la classe Message implémente
l'interface Part qui encapsule les attributs nécessaires
à la distribution du message (auteur, destinataire, sujet ...) et le corps
du message.
Le contenu du message est stocké sous forme d'octets.
Pour accéder à son contenu, il faut utiliser un objet du JavaBean Activation
Framework (JAF) : DataHandler.
Ceci permet une séparation des données nécessaires à la transmission et du contenu
du message. Ce dernier peut ainsi prendre n'importe quel format.( texte, Html,
image ....)
La classe Message ne connaît pas directement le type du contenu
du corps du message.
JavaMail fournit en standard une classe fille nommée MimeMessage
pour les messages possédant un type MIME.
Il y a deux façons d'obtenir un objet de type Message : instancier
un objet de type MimeMessage pour créer un nouveau message
ou utiliser un objet de type Folder pour obtenir un message
existant.
La classe Message définie deux constructeurs en plus du constructeur
par défaut :
| Constructeurs |
Rôles |
| Message(session) |
Créer un nouveau message |
| Message(Folder, int) |
Créer un message à partir d'un message existant |
La classe Message possède de nombreuses méthodes pour initialiser
les données du message :
| Méthodes |
Rôles |
| void addFrom(Address[]) |
Ajouter des émetteurs au message |
| void addRecipient(RecepientType, Address[]) |
Ajouter des destinataires à un type d'envoi (direct, en copie ou en copie
cachée) |
| Flags getFlags() |
Retourne les états du message |
| Adress[] getFrom() |
Retourne les émetteurs |
| int getLineCount() |
Retourne le nombre ligne du message |
| Address[] getRecipients(RecepientType) |
Retourne les destinataires du type fourni en paramètre |
| int getSize() |
Retourne la taille du message |
| String getSubject() |
Retourne le sujet du message |
| Address getReplyTo() |
Renvoie les mails pour la réponse |
| Message reply(boolean) |
Créer un message pour la réponse : le booléen indique si la réponse ne
doit être faite qu'à l'emetteur |
| void set content(Object, String) |
Mettre à jour le contenu du message en précisant son type
mime |
| void seFrom(Address) |
Mettre a jour l'emetteur |
| void setRecipients(RecepientsType, Address[]) |
Mettre a jour les destinataires d'un type |
| void setSendDate(Date) |
Mettre a jour la date d'envoi |
| void setText(String) |
Mettre à jour le contenu du message avec le type mime « text/plain
» |
| void setReply(Address) |
Mettre à jour le destinataire de la réponse |
| void writeTo(OutputStream) |
Envoie le message au format RFC 822 dans un flux. Très pratique
pour visualiser le message sur la console en passant en paramètre
(System.out) |
La méthode setText() permet de facilement mettre une chaîne
de caractères dans le corps du message avec un type MIME « text/plain
». (voir définition du protocole chapitre 1)
Pour envoyer un message dans un format différent, par exemple HTML, il utilise
la méthode setContent() qui prend en paramètre un objet et
un chaîne qui contient le type MIME du message.
MultiPart Message : Un message peut contenir plusieurs objets,
dans ce cas l'objet DataHandler contient un objet Multipart.
Cet objet à son tour contient des objets BodyPart. La
structure d'un objet BodyPart ressemble à celle d'un simple
objet Message. Donc chaque objet BodyPart contient des attributs
et un contenu.

Vous retrouverez l'utilisation de ces différents points au chapitre
suivant.
2.3 La classe Transport
La classe Transport se charge d'envoyer le message avec le
protocole adéquat grâce à sa méthode send().
C'est une classe abstraite.
Il est possible d'obtenir un objet Transport dédié
au protocole particulier utilisé par la session en utilisant la méthode
getTransport() d'un objet Session. Dans ce
cas, il faut :
1. Etablir la connexion en utilisant la méthode connect() avec
le nom du serveur, le nom de l'utilisateur et son mot de passe
2. envoyer le message en utilisant la méthode sendMessage()
avec le message et les destinataires. La méthode getAllRecipients()
de la classe message permet d'obtenir ceux contenus dans le message.
3. fermer la connexion en utilisant la méthode close()

Il est préférable d'utiliser une instance de Transport tel
qu'expliqué ci dessus lorsqu'il y a plusieurs mails à envoyer car on peut maintenir a connexion avec le serveur ouverte pendant les envois.
La méthode static send() ouvre et ferme la connexion à chacun
de ces appels.
2.4 La classe Adress 
La classe Address est une classe abstraite dont héritent
toutes les classes qui encapsulent une adresse dans un message.
Deux classes filles sont actuellement définies :
InternetAddress
NewsAddress
Un objet InternetAddress est nécessaire pour chaque émetteur
et destinataire de mail.
Cependant JavaMail ne vérifie pas l’existence des adresses, c’est le serveur
mail qui s’en chargera.
Pour créer une adresse mail, il suffit de passer cette adresse au constructeur
:
| Address address = new InternetAddress("julie.muesser@ineo.com"); |
Si vous désirez que le nom apparaisse à coté de l’adresse mail, il suffit
de passer au constructeur, l’adresse et le nom:
| Address address = new InternetAddress("julie.muesseer@ineo.com",
"Julie Muesser"); |
Vous devez aussi précisez l’adresse de l’expéditeur du message. Pour identifier
cet expéditeur, on peut utiliser les méthodes setFrom() et
setReplyTo() de la classe Message.
| message.setFrom(address) ; |
Si votre message doit montrer plusieurs adresses d’expéditeur, alors on utilise
la méthode addFrom() en passant en paramètre un tableau d’adresse
:
| Address address[] = ...; message.addFrom(address); |
Il existe trois types prédéfinis de la classe Adress:
Message.RecipientType.TO
: destinataire direct
Message.RecipientType.CC
: copie conforme
Message.RecipientType.BCC
: copie cachée
Ainsi la méthode addRecipient() permet de préciser, le destinataire
et le type d’envoi.
Address toAddress = new InternetAddress("julie.muesser@ineo.com");
Address ccAddress = new InternetAddress("ineo-groupe@ineo.com");
message.addRecipient(Message.RecipientType.TO,toAddress);
message.addRecipient(Message.RecipientType.CC, ccAddress); |
La classe NewsAddress encapsule une adresse news
(forum de discussion) respectant le format RFC1036. Elle contient deux champs
: host qui contient le nom du serveur et newsgroup
qui le nom du forum.
2.5 Les classes Store et Folder 
La classe abstraite Store représente un système de stockage de messages ou « messagerie
».
Pour se connecter à cette « messagerie » et ainsi pourvoir consulter vos messages,
vous devez obtenir une instance de la classe Store avec la
méthode getStore() de votre session, en lui donnant comme paramètre
le protocole utilisé.
| Store store = session.getStore("pop3"); |
Ensuite vous n’avez plus qu’a vous connecter avec la méthode connect(),
en lui précisant le nom du serveur, le nom d'utilisateur et le mot de passe.
| store.connect(host, username, password); |
La méthode close() permet de libérer la connexion avec le
serveur.
La classe abstraite Folder représente un répertoire dans
lequel les messages sont stockés.
Pour obtenir un instance de cette classe, il faut utiliser la méthode getFolder()
d'un objet de type Store en lui précisant le nom du répertoire.
Le protocole « POP3 » ne gère qu'un seul répertoire « INBOX
».
| Folder folder = store.getFolder("INBOX"); |
Si vous utilisez le protocole “ IMAP”, vous pouvez alors avoir
d’autres répertoires.
Ensuite, on appelle la méthode open() en précisant le mode
d'utilisation : READ_ONLY ou READ_WRITE.
READ_ONLY donne les droits de lecture au répertoire
alors que le mode READ_WRITE permet la lecture et la modification.
| folder.open(Folder.READ_ONLY); |
Pour obtenir les messages contenus dans le répertoire, il faut appeler la
méthode getMessages().
Cette méthode renvoie un tableau de Message qui peut être null si aucun message
n'est renvoyé.
| Message message[] = folder.getMessages(); |
Une fois les opérations terminées, il faut fermer le répertoire en utilisant
la méthode close(). folder.close();
2.6 La classe Authenticator
La classe Authenticator est une classe abstraite qui contient
des méthodes afin d’authentifier un utilisateur.
Pour l’utiliser on devra créer une classe fille qui se chargera de collecter
les informations.
Voici les méthodes ce cette classe :
| Méthodes |
Rôles |
| String getDefaultUserName() |
Retourne le login |
| PasswordAuthentication getPasswordAuthentication() |
Retourne null par défaut, sinon le mot de passe de l'utilisateur |
| int getRequestingPort() |
|
| String getRequestingPort() |
|
| String getRequestingProtocol() |
Retourne le protocole réclamé pour la connexion |
| InetAddress getRequestingSite() |
|
L’objet Authentificator est enregistré avec la session quand
celle-ci est crée.
L’Authentification ne sera pas toujours nécessaire c’est pourquoi dans les autres
exemples, nous avons toujours passé en paramètre "null".
Pour obtenir les informations(login et mots de passe), vous pouvez très bien
ouvrir une popup afin de se renseigner sur l’utilisateur ou bien lire les informations
dans un fichier de configuration et ainsi retourner l’objet PasswordAuthentication
Properties props = new Properties();
Authenticator auth = new MyAuthenticator();
Session session = Session.getDefaultInstance(props, auth); |
2.7 L'interface Part
L’interface Part est très importante. En effet, les classes
Message et BodyPart implémentent cette interface.
Elle définie des attributs et un contenu.
Voyons les méthodes qu’elle contient :
| Méthodes |
Rôles |
| int getSize() |
Retourne la taille du contenu |
| int getLineCount() |
Retourne le nombre de lignes du contenu |
| String getContentType() |
Retourne le type du contenu (InputStream, DataHandler ou Object) |
| String getDescription() |
Retourne la déscription |
| void setDescription(String) |
Modification la déscription |
| InputStream getInputStream() |
Retourne le contenu sous la forme d'un flux |
| DataHandler getDataHandler() |
Retourne le contenu sous la forme d'un objet DataHandler |
| Object getContent() |
Retourne le contenu sous la forme d'un objet |
| void setText(String) |
Modification du contenu |
2.8 Les propriétés d'environnement
Cette partie va permettre de lister les propriétés d’environnement utilisées
par JavaMail.
Ces propriétés sont stockées dans un objet Properties.
| Propriétés |
Description |
Valeur par défaut |
| mail.store.protocol |
Spécifie le protocole d'accès au message. Session.getStore()
retourne un objet Store qui implémente ce protocole. |
Premier protocole du fichier de configuration |
| mail.transport.protocol |
Spécifie le protocole de transport Session.getTransport()
retourne un objet Transport qui implémente ce protocole. |
Premier protocole du fichier de configuration |
| mail.host |
Spécifie le serveur de mail par défaut. Les méthodes
de connexion des objets Store et Transport
utilisent cette propriété. |
localhost |
| mail.user |
Spécifie le nom d'utilisateur afin de se connecter au serveur de mail.
Les méthodes de connexion des objets Store et Transport
utilisent cette propriété. |
User.name |
| mail.protocol.host |
Spécifie le protocole par défaut du serveur mail |
mail.host |
| mail.protocol.user |
Spécifie le protocole utilisateur par défaut pour se connecter
au serveur mail |
mail.user |
| mail.from |
Spécifie l'adresse de retour de l'utilisateur courant. Elle est utilisée
par la méthode InternetAddress.getLocalAddress afin de
spécifier l'adresse email de l'utilisateur courant . |
Username@host |
| mail.debug |
Spécifie le mode Debug initial. |
false |
|