Intégrer la fonctionnalité Email dans vos applications avec- Java Mail API /J2EE

Vue Architecturale de Java Mail API

Si vous êtes un développeur Java et souhaitez intégrer la fonctionnalité de messagerie dans votre application, mais vous n’avez jamais écrit quoi que ce soit lié à la messagerie auparavant. Voici donc un bon endroit pour commencer avec la programmation de courrier électronique en Java.

Comme toute autre technologie Java, nous devons prendre une bibliothèque et comprendre son API avant d’écrire et de tester du code réel. Bien que le JRE/JDK n’inclue pas d’API intégrée pour le courrier électronique, Oracle fournit un package optionnel appelé JavaMail qui est probablement le framework le plus populaire pour la programmation de courrier électronique avec la technologie Java.

Le JavaMail fait donc partie de la pile technologique de JavaEE.

Cela veut simplement dire que c'est une extension au JDK qui n'est donc pas fournie avec Java SE. Elle est intégrée à Java EE.

JavaMail est une API qui permet d'utiliser le courrier électronique (e-mail) dans une application écrite en Java (application cliente, applet, servlet, EJB, ... ). Son but est d'être facile à utiliser, de fournir une souplesse qui permette de la faire évoluer et de rester le plus indépendant possible des protocoles utilisés.

Le courrier électronique repose sur le concept du client/serveur. Ainsi, l'utilisation d'e-mails requiert deux composants :

èun client de mails (Mail User Agent : MUA) tel que Outlook, Messenger, Eudora, ...

èun serveur de mails (Mail Transport Agent : MTA) tel que SendMail

Les clients de mails s'appuient sur un serveur de mails pour obtenir et envoyer des messages. Les échanges entre clients et serveurs sont normalisés par des protocoles particuliers.

Les classes et interfaces sont regroupées dans quatre packages : javax.mail, javax.mail.event, javax.mail.internet, javax.mail.search.

Les principaux protocoles

Étant donné que JavaMail est basé sur des protocoles de messagerie standard tels que SMTP, IMAP et POP3, il est recommandé d’avoir une compréhension de base du fonctionnement de ces protocoles, ainsi que des avantages et des inconvénients de chaque protocole. Cela vous aiderait à implémenter votre code plus efficacement. Vous êtes donc libre de se rendre sur Wikipédia et consulter les liens suivants: SMTP, IMAP,POP, etc.

Voici ce que je vous conseille de retenir pour la compréhension pratique de cet article:

SMTP est l'acronyme de Simple Mail Transport Protocol. Ce protocole défini par la recommandation RFC 821 permet l'envoi de mails vers un serveur de mails qui supporte ce protocole.

POP est l'acronyme de Post Office Protocol. Ce protocole défini par la recommandation RFC 1939 permet la réception de mails à partir d'un serveur de mails qui implémente ce protocole. La version courante de ce protocole est 3. C'est un protocole très populaire sur Internet. Il définit une boîte aux lettres unique pour chaque utilisateur. Une fois que le message est reçu par le client, il est effacé du serveur.

IMAP est l'acronyme de Internet Message Acces Procol. Ce protocole défini par la recommandation RFC 2060 permet aussi la réception de mails à partir d'un serveur de mails qui implémente ce protocole. La version courante de ce protocole est 4. Ce protocole est plus complexe car il apporte des fonctionnalités supplémentaires : plusieurs répertoires par utilisateur, partage de répertoires entre plusieurs utilisateurs, maintien des messages sur le serveur, etc .

NNTP est l'acronyme de Network News Transport Protocol. Ce protocole est utilisé par les forums de discussions (news).

Bon passons à la pratique : préréquis pour l'utilisation

1.Utilisation de la bibliothèque JavaMail:

Pour compiler et exécuter du code qui utilise JavaMail, ajoutez le fichier mail.jar pour compiler classpath et runtime classpath.

Si vous utilisez Java 5 ou une version antérieure, vous devez télécharger JavaBeans Activation Framework (JAF) et ajouter le fichier activation.jar au chemin de classe(classpath). Le JAF n’est inclus dans JDK que depuis Java 6.

Si vous utilisez Maven, spécifiez simplement la dépendance suivante pour votre projet :

1

2

3

4

5

<dependency>
    <groupId>com.sun.mail</groupId>
    <artifactId>javax.mail</artifactId>
    <version>1.6.2</version>
</dependency>

Il faut savoir qu'il y a plusieurs types d'envois d'email, comme indiqué ci-dessous:

👉JavaMail - Envoi en texte brut

Pour envoyer un e-mail en texte brut à l’aide de JavaMail, appelez simplement la méthode setText(String) sur l’objet Message. La classe suivante, PlainTextEmailSender, implémente une méthode générale qui envoie un message électronique en texte brut à partir d’un serveur SMTP. Il nécessite de fournir des informations sur le serveur SMTP et le message :

-Pour le serveur SMTP : hôte, numéro de port, nom d’utilisateur (adresse e-mail) et mot de passe.

-Pour le message électronique : adresse du destinataire, objet et message.

Voici le code : sur GitHub et le lien dans YouTube.

👉JavaMail - Envoi en Format HTML

Dans le post Envoyer un e-mail en texte brut en utilisant JavaMail, vous savez comment envoyer un e-mail au format texte brut. Bien qu’il soit possible d’ajouter des balises HTML au contenu du corps de l’e-mail, cela ne suffit pas à faire interpréter l’e-mail comme un e-mail HTML dans un e-mail Web ou un programme client de messagerie. Ainsi, au lieu d’utiliser:

Message msg = new MimeMessage(session);
msg.setText(message);

Nous devons appeler la méthode setContent(Object obj, String type) de l’objet MimeMessage. La méthode setContent() spécifie explicitement le type MIME du contenu, et pour le format HTML, le paramètre type doit être « text/html » :

1 2	`Message msg =` `new` `MimeMessage(session);` `msg.setContent(message,` `"text/html");`

C’est ce qui fait la différence! Et voici le code source sur GitHub et le lien dans YouTube.

👉JavaMail - Envoi avec pièces jointes

Un message se compose d’un en-tête et d’un corps. Le corps doit être de type Multipart pour contenir des pièces jointes. L’objet Multipart contient plusieurs parties dans lesquelles chaque partie est représentée comme un type de BodyPart dont la sous-classe, MimeBodyPart, peut prendre un fichier comme contenu.

Les étapes pour créer un message partitionné avec plusieurs parties sont les suivantes :

Message message = new MimeMessage(session);
Multipart multipart = new MimeMultipart();
 
// creates body part for the message
MimeBodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setContent(message, "text/html");
 
// creates body part for the attachment
MimeBodyPart attachPart = new MimeBodyPart();
 
// code to add attachment...will be revealed later
 
// adds parts to the multipart
multipart.addBodyPart(messageBodyPart);
multipart.addBodyPart(attachPart);
 
// sets the multipart as message's content
message.setContent(multipart);

La classe MimeBodyPart fournit des méthodes pratiques pour joindre un fichier, mais la manière est différente entre JavaMail 1.3 et JavaMail 1.4.

Avec JavaMail 1.3, il faut écrire le code suivant pour ajouter une pièce jointe :

// JavaMail 1.3
MimeBodyPart attachPart = new MimeBodyPart();
String attachFile = "E:/Documents/nomFichierAudio.mp4";
 
DataSource source = new FileDataSource(attachFile);
attachPart.setDataHandler(new DataHandler(source));
attachPart.setFileName(new File(attachFile).getName());
 
multipart.addBodyPart(attachPart);

Avec JavaMail 1.4, l’ajout d’une pièce jointe est beaucoup plus simple avec les nouvelles méthodes suivantes introduites dans la classe MimeBodyPart :

void attachFile(Fichier fichier)

void attachFile(String filePath)

Donc, le code avec JavaMail 1.4 ressemblerait à ceci:

1

2

3

4

5

// JavaMail 1.4
MimeBodyPart attachPart = new MimeBodyPart();
String attachFile = "E:/Documents/nomFichierAudio.mp4";
attachPart.attachFile(attachFile);
multipart.addBodyPart(attachPart);

Le code de JavaMail 1.3 fonctionne toujours dans la version 1.4.

Maintenant, pour un exemple de programme, la classe suivante:

EmailAttachmentSender – implémente une méthode statique,

sendEmailWithAttachments() – qui peut être utilisée pour envoyer un message électronique avec certaines pièces jointes. Cette méthode requiert les paramètres suivants :

Pour les informations sur le serveur SMTP : hôte, numéro de port, nom d’utilisateur (adresse e-mail) et mot de passe.

Pour le message électronique : adresse e-mail, objet et message du destinataire.

Pour les fichiers joints : tableau de String pour les chemins d’accès aux fichiers.

Voici le code de la classe EmailAttachmentSender : sur GitHub et le lien dans YouTube.

👉JavaMail - Envoi mail avec images

Nous utiliserons une technique similaire plus quelques modifications afin d’intégrer certaines images directement dans le message.

Les images incorporées sont appelées pièces jointes en ligne que les utilisateurs voient les images directement dans le contenu de l’e-mail. C’est différent avec les pièces jointes régulières que les utilisateurs doivent télécharger et ouvrir manuellement.

Le message doit être au format HTML pour avoir des images en ligne, nous devons donc définir le type de contenu du message comme suit:

1 2	`MimeBodyPart bodyPart =` `new` `MimeBodyPart();` `bodyPart.setContent(htmlMessage,` `"text/html");`

Où htmlMessage est une chaîne Représentant le contenu du message avec des balises HTML

1

2

3

String htmlMessage = "<html>Hi there,<br>";
htmlMessage += "See this cool pic: <img src=\"cid:kiloAbcXyz123\" />";
htmlMessage += "</html>";

Comme vous le remarquez dans le code HTML ci-dessus, nous utilisons la <img> balise pour inclure une image, mais son attribut src ne pointe pas vers le nom de l’image. Au lieu de cela, l’attribut src doit faire référence à la valeur de l’en-tête Content-ID d’une partie MIME qui contient l’image réelle, sous la forme suivante :

src="cid:<content_id> »

Ensuite, la partie image doit être créée comme suit:

1

2

3

4

5

MimeBodyPart imagePart = new MimeBodyPart();
imagePart.setHeader("Content-ID", "kiloAbcXyz123");
imagePart.setDisposition(MimeBodyPart.INLINE);
// attach the image file
imagePart.attachFile(imageFilePath);