Tutoriel pour apprendre à envoyer et recevoir des emails avec Javamail

L'envoi du message se fait en trois étapes :

• création d'une Session ;
• création d'un objet Message, auquel nous ajoutons les destinataires ;
• envoi du message, grâce à un objet Transport.

Voyons ces étapes une à une :

public static void sendMessage(String subject, String text, String destinataire, String copyDest) {
    // 1 -> Création de la session
    Properties properties = new Properties();
    properties.setProperty("mail.transport.protocol", "smtp");
    properties.setProperty("mail.smtp.host", SMTP_HOST1);
    properties.setProperty("mail.smtp.user", LOGIN_SMTP1);
    properties.setProperty("mail.from", IMAP_ACCOUNT1);
    Session session = Session.getInstance(properties);

    ...

}

Pour construire une Session, nous avons besoin de quelques propriétés, comme le protocole (SMTP dans notre cas), le serveur, ainsi que des informations d'identification, mais sans le mot de passe. Ce dernier nous sera demandé lors de la connexion par l'objet Transport. Pour connaître l'ensemble des propriétés, je vous renvoie à la documentation officielle de Javamail.

Maintenant que nous avons notre session, créons notre message :

public static void sendMessage(String subject, String text, String destinataire, String copyDest) {
    ...

    // 2 -> Création du message
    MimeMessage message = new MimeMessage(session);
    try {
        message.setText(text);
        message.setSubject(subject);
        message.addRecipients(Message.RecipientType.TO, destinataire);
        message.addRecipients(Message.RecipientType.CC, copyDest);
    } catch (MessagingException e) {
        e.printStackTrace();
    }

    ...
}

Rien de compliqué : on instancie notre message en lui passant en paramètre la session, puis on ajoute le texte, le sujet et les destinataires. Reste à l'envoyer :

public static void sendMessage(String subject, String text, String destinataire, String copyDest) {
    ...

    // 3 -> Envoi du message
    Transport transport;
    try {
        transport = session.getTransport("smtp");
        transport.connect(LOGIN_SMTP1, PASSWORD_SMTP1);
        transport.sendMessage(message, new Address[] { new InternetAddress(destinataire),
                                                        new InternetAddress(copyDest) });
    } catch (MessagingException e) {
        e.printStackTrace();
    } finally {
        try {
            if (transport != null) {
                transport.close();
            }
        } catch (MessagingException e) {
            e.printStackTrace();
        }
    }
}

C'est tout aussi simple : notre session nous donne un objet Transport, qui nous permet de nous connecter au serveur SMTP et d'envoyer le message à nos destinataires. Attention, pour créer l'objet Transport à partir de la session, pensez à mettre le protocole en minuscules ! Et bien entendu, on ferme notre connexion.

Rien de bien compliqué, mais nous avons cependant affaire à quelques subtilités. En premier lieu, il est possible, mais pas toujours, d'envoyer des messages sans indiquer les propriétés. Tout dépend du serveur SMTP et de sa configuration. J'ai réussi avec l'un, pas avec l'autre (smtp.laposte.net). Le mieux est donc de les mettre systématiquement. Ensuite, la propriété mail.host doit impérativement correspondre au nom du serveur SMTP. En général, c'est celui utilisé pour l'envoi, mais pas toujours. Si on se trompe, tout ce qu'on obtient est une exception :

com.sun.mail.smtp.SMTPAddressFailedException: 554 5.7.1 <yy@y.com>: Relay access denied

Votre message est simplement considéré comme du SPAM.

Une autre exception possible est celle-ci :

com.sun.mail.smtp.SMTPSendFailedException: 530 5.7.0 Must issue a STARTTLS command first. ed6sm6117146wib.9 - gsmtp

Elle est due au fait que votre serveur SMTP utilise une connexion sécurisée. C'est notamment le cas de smtp.gmail.com. Le problème se résout très simplement en ajoutant cette propriété :

properties.setProperty("mail.smtp.starttls.enable", "true");

Quant aux destinataires du message, notre message n'a nul besoin de les connaître pour être acheminé. Seul notre objet Transport en a besoin. Enlevez les deux lignes message.addRecipients(), et essayez, vous verrez que votre message arrive à bon port malgré tout. Seulement, le destinataire ne saura jamais à qui d'autre que lui il était destiné.

Faites quelques essais avec votre client de mail favori, et voyez les résultats.

Maintenant que nous savons envoyer un message, il ne nous reste plus qu'à le recevoir.

Pour ces essais, fermez votre client de courriel utilisé jusqu'ici, et faites attention à ce que vous faites : nous allons lire des mails, mais pas seulement ceux de notre exemple. Le code fourni ne supprime pas les messages du serveur, mais si vous faites d'autres essais, pensez-y !

Comme pour l'envoi, la réception des messages a besoin d'un objet Session :

private static void receiveMessage() {
    // 1 -> La session
    Properties properties = new Properties();
    properties.setProperty("mail.store.protocol", "pop3");
    properties.setProperty("mail.pop3.host", POP_SERVER3);
    properties.setProperty("mail.pop3.user", POP_ACCOUNT3);
    Session session = Session.getInstance(properties);
    ...
}

C'est pareil que pour l'envoi, avec de nouvelles propriétés. La session que nous obtenons nous permet d'obtenir un objet Store, grâce auquel nous accéderons aux différents Folder contenant nos messages :

private static void receiveMessage() {
    ...

    // 2 -> Les dossiers
    Store store = null;
    Folder defaultFolder = null;
    Folder inbox = null;
    try {
        store = session.getStore(new URLName("pop3://" + POP_SERVER3));
        store.connect(POP_ACCOUNT3, POP_PASSWORD3);
        defaultFolder = store.getDefaultFolder();
        System.out.println("defaultFolder : " + defaultFolder.getName());

        for (Folder folder : defaultFolder.list()) {
            System.out.println(folder.getName());
        }
        inbox = defaultFolder.getFolder("INBOX");
        printMessages(inbox);
    } catch (Exception e) {
        e.printStackTrace();
    } finally { // Ne pas oublier de fermer tout ça !
        close(inbox);
        close(defaultFolder);
        try {
            if (store != null && store.isConnected()) {
                store.close();
            }
        } catch (MessagingException e) {
            e.printStackTrace();
        }
    }
}

Notez à ligne 9 la manière de récupérer un Store depuis une session par une URL. Pour une boite IMAP, on remplace pop3 par imap ou imaps selon les cas.

Un Store peut contenir plusieurs Folder. Nous partons donc du Folder racine (defaultFolder), puis nous imprimons ses enfants, qui pourraient à leur tour en contenir d'autres comme toute arborescence qui se respecte. Ici, celui qui nous intéresse est INBOX, la boite de réception tout simplement. Une fois que nous avons notre Folder, récupérer les messages et les imprimer est un jeu d'enfant :

private static void printMessages(Folder folder) {
    try {
        folder.open(Folder.READ_ONLY);
        int count = folder.getMessageCount();
        int unread = folder.getUnreadMessageCount();
        System.out.println("Il y a " + count + " messages, dont " + unread + " non lus.");
        for (int i = 1; i <= count; i++ ) {

            Message message = folder.getMessage(i);
            System.out.println("Message n° " + i);
            System.out.println("Sujet : " + message.getSubject());

            System.out.println("Expéditeur : ");
            Address[] addresses = message.getFrom();
            for (Address address : addresses) {
                System.out.println("\t" + address);
            }

            System.out.println("Destinataires : ");
            addresses = message.getRecipients(RecipientType.TO);
            if (addresses != null) {
                for (Address address : addresses) {
                    System.out.println("\tTo : " + address);
                }
            }
            addresses = message.getRecipients(RecipientType.CC);
            if (addresses != null) {
                for (Address address : addresses) {
                    System.out.println("\tCopie : " + address);
                }
            }

            System.out.println("Content : ");
            for (String line : inputStreamToStrings(message.getInputStream())) {
                System.out.println(line);
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
}

Nous les comptons, et nous affichons leurs attributs : expéditeur, destinataires, ... Le contenu lui est un peu plus embêtant, puisque nous le récupérons sous forme d'InputStream. Sa transformation en String n'est cependant pas très complexe, surtout si vous avez lu l'excellent article d'Olivier Croisier sur java.io.

Remarquons que les messages sont numérotés à partir de 1, et non à partir de 0 comme on en a l'habitude en informatique.

Il ne nous reste plus qu'à fermer nos Folder, en prenant bien soin de lui dire de ne pas effacer les messages :

private static void close(Folder folder) {
    if (folder != null && folder.isOpen()) {
        try {
            folder.close(false); // false -> On n'efface pas les messages marqués DELETED
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Et maintenant que nous savons envoyer et recevoir des messages textes, voyons ce qu'il en est des pièces jointes.

Un message avec pièces jointes est composé de plusieurs parties : le texte du message, plus les pièces jointes. Pour transporter tout cela, nous utilisons les types MIME. Le type du texte sera text/plain, quant à celui de nos pièces jointes, ça dépend. Le message contiendra donc un objet MimeMultiPart, auquel nous allons adjoindre un MimeBodyPart par partie du message.

Commençons par une belle image d'autruche :

Les étapes pour obtenir le MimeBodyPart de l'autruche sont les suivantes :

1. créer un objet File. C'est notre pièce jointe ;
2. grâce à lui, nous pouvons instancier une FileDataSource ;
3. cette FileDataSource nous permettra d'obtenir un DataHandler ;
4. nous créons ensuite notre MimeBodyPart, auquel nous ajouterons notre DataHandler ;
5. nous indiquons finalement à notre MimeBodyPart le nom du fichier. Nous verrons les conséquences de l'oubli de cette étape.

Voici le code, à répéter pour chaque pièce jointe :

File file = new File(PATH_TO_FILE + "/autruche.jpg");
FileDataSource datasource1 = new FileDataSource(file);
DataHandler handler1 = new DataHandler(datasource1);
MimeBodyPart autruche = new MimeBodyPart();
try {
    autruche.setDataHandler(handler1);
    autruche.setFileName(datasource1.getName());
} catch (MessagingException e) {
    e.printStackTrace();
}

Ajouter un fichier mp3 se fait exactement de la même manière. Pour notre texte, c'est plus simple :

MimeBodyPart content = new MimeBodyPart();
try {
    content.setContent("Texte du message", "text/plain");
} catch (MessagingException e) {
    e.printStackTrace();
}

Maintenant, plaçons nos MimeBodyPart dans un MimeMultiPart :

MimeMultipart mimeMultipart = new MimeMultipart();
try {
    mimeMultipart.addBodyPart(content);
    mimeMultipart.addBodyPart(autruche);
    mimeMultipart.addBodyPart(musique);
} catch (MessagingException e) {
    e.printStackTrace();
}

Il ne nous reste plus qu'à créer notre message, y placer notre MimeMultiPart et à l'envoyer :

try {
    message.setContent(mimeMultipart);
    message.setSubject("sujet");
    // envoi du message
    ...
} catch (MessagingException e) {
    e.printStackTrace();
}

Nous obtenons notre objet message exactement comme précédemment à l'aide d'une Session, et nous l'envoyons de la même manière. Voilà, notre message est parti. Regardons un peu ce qu'il advient des pièces jointes lors de sa réception si on oublie d'indiquer le nom du fichier.

Cela n'empêche nullement ceux-ci d'être transmis. Seulement, le destinataire du message ne saura jamais quel type de fichier il a reçu. Pour l'image, ça va encore, le message contient le type mime :

------=_Part_0_1167368365.1361654391542
Content-Type: image/jpeg
Content-Transfer-Encoding: base64

/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAHgAA/+4ADkFkb2JlAGTAAAAAAf/b
AIQAEAsLCwwLEAwMEBcPDQ8XGxQQEBQbHxcXFxcXHx4XGhoaGhceHiMlJyUjHi8vMzMvL0BAQEBA
...

Pour notre musique, ça ne va pas du tout, le type mime est inconnu :

------=_Part_0_1167368365.1361654391542
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64

SUQzAwAAAAVbdlRSQ0sAAAADAAAAMTFUQUxCAAAAEQAAAE1hZGFtZSBsYSBHaXJhZmVUQ09OAAAA
EQAAAENoaWxkcmVuknMgTXVzaWNBUElDAAFdGgAAAGltYWdlL3BuZwAAAIlQTkcNChoKAAAADUlI
...

Le fichier est devenu un simple flux d'octets. En passant, remarquons que nos pièces jointes sont encodées en Base64, ça nous sera utile quand il s'agira de lire nos messages.

En ajoutant le nom au MimeBodyPart, cette fois tout va bien. On retrouve le nom du fichier et son extension qui permet de savoir comment l'ouvrir.

------=_Part_0_1461157241.1361655021999
Content-Type: image/jpeg; name=autruche.jpg
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename=autruche.jpg

/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAHgAA/+4ADkFkb2JlAGTAAAAAAf/b
AIQAEAsLCwwLEAwMEBcPDQ8XGxQQEBQbHxcXFxcXHx4XGhoaGhceHiMlJyUjHi8vMzMvL0BAQEBA
...

------=_Part_0_1461157241.1361655021999
Content-Type: application/octet-stream; name="musique.mp3"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="musique.mp3"

SUQzAwAAAAVbdlRSQ0sAAAADAAAAMTFUQUxCAAAAEQAAAE1hZGFtZSBsYSBHaXJhZmVUQ09OAAAA
EQAAAENoaWxkcmVuknMgTXVzaWNBUElDAAFdGgAAAGltYWdlL3BuZwAAAIlQTkcNChoKAAAADUlI
...

Quant à notre texte, on le retrouve également comme part du message :

------=_Part_0_2141998910.1375532871953
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit

Texte du message

Si on ajoute quelques caractères accentués, nous obtenons :

------=_Part_0_1167368365.1361657672775
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

Quelques caract=C3=A8res sp=C3=A9ciaux : =C3=A9 =C3=89 =C3=A0 =C3=80 =E2=82=
=AC =C5=93 =C5=92=20
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectu=

...

Le texte, à cause des caractères accentués, n'est plus codé en us-ascii, mais en quoted-printable.

Maintenant que nous savons un peu à quoi ressemble notre message envoyé, passons à sa réception.

Comme pour l'envoi, la réception du message ne change pas, il est simplement un petit peu plus complexe à lire. Nous n'allons donc nous consacrer qu'à sa lecture et son interprétation. On peut aussi reprendre notre méthode printMessage() telle quelle, ça marchera. Le problème, comme nous l'avons vu, est que le texte est en quoted-printable, et nos pièces jointes en Base64. Pas vraiment exploitable dans la console. Nous allons donc devoir séparer chaque partie du message, et les interpréter correctement.

Voyons donc comment récupérer les différentes parties de notre message :

public void printMessage(Message message) {

    try {
        DataSource dataSource = message.getDataHandler().getDataSource();
        MimeMultipart mimeMultipart = new MimeMultipart(dataSource);
        int multiPartCount = mimeMultipart.getCount();
        System.out.println("Il y a " + multiPartCount + " partie(s) dans ce message.");

        for (int i = 0; i < multiPartCount; i++ ) {
            BodyPart bp = mimeMultipart.getBodyPart(i);
            processBodyPart(bp);
        }
    } catch (MessagingException e) {
        e.printStackTrace();
    }
}

On instancie un objet MimeMultiPart à partir de la DataSource du message. À partir de là, il ne nous reste plus qu'à parcourir les BodyPart pour les traiter :

private void processBodyPart(BodyPart bp) {
    try {
        System.out.println("Type : " + bp.getContentType());
        String fileName = bp.getFileName();
        System.out.println("FileName : " + fileName);

        if (bp.isMimeType("text/plain")) {
            System.out.println("Texte du message :");
            List<String> strings = inputStreamToStrings(bp.getInputStream());
            for (String string : strings) {
                System.out.println(string);
            }
        } else {
            File file = new File(PATH_TO_FILE + "/received_" + fileName);
            FileOutputStream fos = new FileOutputStream(file);
            bp.writeTo(fos);
        }
    } catch (MessagingException | IOException e) {
        e.printStackTrace();
    }
}

Il n'y a rien de compliqué, il nous suffit de prévoir deux traitements différents : le premier pour le texte du message, qu'on transforme en liste de String puis qu'on imprime, et le second pour les pièces jointes qu'on enregistre en tant que fichiers.

Tout cela semble très bien, mais si on ouvre notre fichier received_autruche.jpg, nous obtenons une erreur. Pour la comprendre, ouvrons-le avec un simple éditeur de texte :

Content-Type: image/jpeg; name=autruche.jpg
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename=autruche.jpg

/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAHgAA/+4ADkFkb2JlAGTAAAAAAf/b
AIQAEAsLCwwLEAwMEBcPDQ8XGxQQEBQbHxcXFxcXHx4XGhoaGhceHiMlJyUjHi8vMzMvL0BAQEBA

Du simple texte, du Base64… Nous avons tout simplement oublié de le convertir. Bien entendu, Java nous met à disposition tout ce dont nous avons besoin. Il s'agit d'un DataHandler, obligeamment fourni par notre BodyPart. Notre code définitif est donc :

DataHandler dh = bp.getDataHandler();
File file = new File(PATH_TO_DATA + "/received_" + fileName);
FileOutputStream fos = new FileOutputStream(file);
dh.writeTo(fos);

Et voilà, nous récupérons notre image et notre musique intactes. Il y a cependant une question qui doit vous tarauder. Nous savions que notre message comportait des pièces jointes. Mais comment savoir si notre message n'est pas un simple texte, sans fioritures, ni images, ni rien ? Eh bien essayons d'envoyer un message comme précédemment. Et voici ce que nous obtenons :

javax.mail.MessagingException: Missing start boundary

Une belle exception. Comment faire alors ? La première idée sera de ne plus composer de message avec message.setText(text). Composons nos messages à partir de MimeMultiPart ne contenant qu'une partie, notre texte, et tout rentre dans l'ordre. Malheureusement, nous ne savons rien à propos du message qui nous a été envoyé. Nous devons agir côté réception.

Utilisons la méthode getContentType() de MimeMultiPart pour observer la différence entre les deux types de messages. Dans le cas d'un message de texte simple, le type est text/plain. Dans le cas d'un message avec pièces jointes (ou un simple texte dans MimeBodyPart à l'intérieur de MimeMultiPart), le type est multipart/mixed.  Ce simple test fera donc l'affaire :

if (message.isMimeType("multipart/mixed")) {
    printMixedMessage(message);
} else {
    printTextMessage(message);
}

Et voilà, nous sommes capables de lire toutes sortes de messages. Ou presque, il nous reste encore à voir les messages HTML.