Envoi et transfert de messages - Envoyer des messages Outlook avec un programme Java

Le SmtpClient classe permet aux applications d’envoyer des e-mails en utilisant le Simple Mail Transfer Protocol (SMTP).

  • Le SmtpClient classe est le seul point d’entrée majeur que les développeurs utilisent pour envoyer des messages électroniques.
  • Le SmtpClient classe fournit également d’autres méthodes courantes de livraison d’e-mails, y compris l’écriture de messages e-mail sur le système de fichiers, la file d’attente de messages, etc.
  • Le SmtpClient classe prend pleinement en charge ces deux modèles de programmation :
  • Le SmtpClient classe prend également en charge envoi de messages en tant que TNEF

Pour envoyer le message e-mail et bloquer en attendant que le courriel soit transmis au serveur SMTP, utilisez l’une des méthodes Send synchrones. Pour permettre à votre thread principal de continuer à s’exécuter pendant la transmission du courriel, utilisez le beginSend méthode.

Envoi d’e-mails de façon synchrone

Un message e-mail peut être envoyé de façon synchrone en utilisant le SmtpClient classe send méthode. Elle envoie le message e-mail spécifié via un serveur SMTP pour la livraison. L’expéditeur du message, les destinataires, l’objet et le corps du message sont spécifiés à l’aide d’objets String. Pour envoyer un message e-mail de façon synchrone, suivez les étapes ci-dessous :

  1. Créez une instance de MailMessage classe et définir ses propriétés.
  2. Créez une instance de SmtpClient classe et spécifier l’hôte, le port, le nom d’utilisateur & le mot de passe.
  3. Envoyer le Message en utilisant le SmtpClient classe send méthode et passer le MailMessage instance.

Le fragment de code Java suivant vous montre comment envoyer des e-mails Outlook de façon synchrone.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Declare msg as MailMessage instance
MailMessage msg = new MailMessage();

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port # and Security option
client.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);

try {
    // Client.Send will send this message
    client.send(msg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Envoi d’e-mails de façon asynchrone

Parfois, vous pouvez vouloir envoyer des courriels de façon asynchrone. Par exemple, si vous envoyez beaucoup de courriels via votre application, l’approche synchrone pourrait ne pas fonctionner. Dans un tel scénario, vous pouvez utiliser beginSend. Le beginSend méthode du SmtpClient classe envoie un message électronique à un serveur SMTP pour la livraison. Cette méthode ne bloque pas le thread appelant et permet à l’appelant de passer un objet à la méthode qui est invoqué lorsque l’opération se termine. Pour envoyer un message Outlook de façon asynchrone en Java, suivez ces étapes :

  1. Créez une instance de MailMessage classe et utiliser ses différentes propriétés.
  2. Créez une instance de SmtpClient classe et spécifier l’hôte, le port, le nom d’utilisateur et le mot de passe.
  3. Créer une instance définie par l’utilisateur qui sera transmise à la méthode et invoquée lorsque l’opération asynchrone se termine.
  4. Envoyer le message en utilisant beginSend méthode de SmtpClient classe et passer le MailMessage instance et instance définie par l’utilisateur en elle, ainsi qu’une fonction de rappel à appeler lorsque l’opération est terminée.

Pour recevoir une notification lorsque l’email a été envoyé ou que l’opération a été annulée, la fonction de rappel passée à la beginSend la méthode est appelée. Après avoir appelé la SmtpClient classe beginSend méthode il n’est pas nécessaire d’attendre qu’un message électronique soit envoyé complètement. Nous pouvons appeler une autre méthode beginSend en même temps. Lorsqu’un e‑mail a été envoyé en utilisant le beginSend méthode, l’extrait de code imprime un message ("Message envoyé"). Le programme Java ou l’extrait de code suivant vous montre comment envoyer des e‑mails de façon asynchrone.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

public static void run() {
    sendMail();
}

static SmtpClient getSmtpClient() {
    SmtpClient client = new SmtpClient();
    client.setHost("mail.server.com");
    // Specify your mail Username, Password, Port # and security option
    client.setUsername("username");
    client.setPassword("password");
    client.setPort(587);
    client.setSecurityOptions(SecurityOptions.SSLExplicit);
    return client;
}

static void sendMail() {
    try {

        // Declare msg as MailMessage instance
        MailMessage msg = new MailMessage("sender@gmail.com", "receiver@gmail.com", "Test subject", "Test body");
        SmtpClient client = getSmtpClient();
        Object state = new Object();
        IAsyncResult ar = client.beginSend(msg, callback, state);
        // If the user canceled the send, and mail hasn't been sent yet,
        client.cancelAsyncOperation(ar);

        msg.dispose();
        System.out.println("Goodbye.");
    } catch (Exception ex) {
        System.err.println(ex);
    }
}

static AsyncCallback callback = new AsyncCallback() {
    public void invoke(IAsyncResult ar) {
        IAsyncResultExt task = null;
        if (ar instanceof IAsyncResult)
            task = (IAsyncResultExt) ar;

        if (task != null && task.isCanceled()) {
            System.out.println("Send canceled.");
        }

        if (task != null && task.getErrorInfo() != null) {
            System.out.println(task.getErrorInfo());
        } else {
            System.out.println("Message Sent.");
        }
    }
};

Envoi des messages stockés depuis le disque

Les fichiers EML (fichiers Outlook Express Electronic Mail) contiennent un en‑tête d’e‑mail, le corps du message et les pièces jointes éventuelles. Aspose.Email permet aux développeurs de travailler avec les fichiers EML de différentes manières. Cet article montre comment charger des fichiers EML depuis le disque et les envoyer en tant qu’e‑mails avec SMTP. Vous pouvez charger les fichiers .eml depuis le disque ou un flux dans le MailMessage classe et envoyer le message e‑mail en utilisant le SmtpClient classe. Le MailMessage classe est la classe principale pour créer de nouveaux messages e‑mail, charger des fichiers de messages e‑mail depuis le disque ou un flux et enregistrer les messages. L’extrait de code Java suivant montre comment envoyer des messages stockés depuis le disque.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Load an EML file in MailMessage class
MailMessage message = MailMessage.load(dataDir + "test.eml");

// Send this message using SmtpClient
SmtpClient client = new SmtpClient("host", "username", "password");

try {
    client.send(message);
} catch (Exception ex) {
    System.out.println(ex.getMessage());
}

Envoi d’e‑mail en texte brut

Les exemples de programmation ci‑dessus montrent comment envoyer un message e‑mail en texte brut. Le Corps propriété, une propriété du MailMessage classe, qui est utilisée pour spécifier le contenu texte du corps du message. Pour envoyer un message e‑mail en texte brut, suivez ces étapes :

  • Créez une instance de la MailMessage classe.
  • Spécifiez les adresses e‑mail de l’expéditeur et du destinataire dans le MailMessage instance.
  • Spécifiez le Corps contenu, utilisé pour le message en texte brut.
  • Créez une instance de la SmtpClient classe et envoyer l’e‑mail.

L’extrait de code suivant vous montre comment envoyer un e‑mail en texte brut.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create an instance of the MailMessage class
MailMessage message = new MailMessage();

// Set From field, To field and Plain text body
message.setFrom(MailAddress.to_MailAddress("sender@sender.com"));
message.getTo().add("receiver@receiver.com");
message.setBody("This is Plain Text Body");

// Create an instance of the SmtpClient class
SmtpClient client = new SmtpClient();

// And Specify your mailing host server, Username, Password and Port
client.setHost("smtp.server.com");
client.setUsername("Username");
client.setPassword("Password");
client.setPort(25);

try {
    // Client.Send will send this message
    client.send(message);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Envoi d’e‑mail avec corps HTML

Les exemples de programmation ci‑dessus montrent comment envoyer un simple message e‑mail HTML. Le HtmlBody, une propriété du MailMessage classe, qui est utilisée pour spécifier le contenu HTML du corps du message. Pour envoyer un simple e‑mail HTML, suivez ces étapes :

  • Créez une instance de la MailMessage classe.
  • Spécifiez l’adresse e‑mail de l’expéditeur et du destinataire dans le MailMessage instance.
  • Spécifiez le HtmlBody contenu.
  • Créez une instance de la SmtpClient classe et envoyer l’e‑mail en utilisant le send méthode.

À des fins d’illustration, le contenu HTML de l’e‑mail est rudimentaire : Ceci est le corps HTML La plupart des e‑mails HTML seront plus complexes. L’extrait de programme Java suivant vous montre comment envoyer un e‑mail avec un corps HTML.

public static void run() {
    // Declare msg as MailMessage instance
    MailMessage msg = new MailMessage();

    // Use MailMessage properties like specify sender, recipient, message and HtmlBody
    msg.setFrom(MailAddress.to_MailAddress("newcustomeronnet@gmail.com"));
    msg.setTo(MailAddressCollection.to_MailAddressCollection("asposetest123@gmail.com"));
    msg.setSubject("Test subject");
    msg.setHtmlBody("<html><body>This is the HTML body</body></html>");
    SmtpClient client = getSmtpClient();
    try {
        // Client will send this message
        client.send(msg);
        System.out.println("Message sent");
    } catch (Exception ex) {
        System.err.println(ex);
    }

    System.out.println("Email sent with HTML body.");
}

private static SmtpClient getSmtpClient() {
    SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
    client.setSecurityOptions(SecurityOptions.Auto);
    return client;
}

Envoi d’e‑mail avec texte du message alternatif

Les exemples de programmation ci‑dessus montrent comment envoyer un simple message e‑mail HTML avec du contenu alternatif. Utilisez le AlternateView classe pour spécifier des copies d’un message e‑mail dans différents formats. Par exemple, si vous envoyez un message en HTML, vous pouvez également fournir une version texte brut pour les destinataires qui utilisent des lecteurs d’e‑mail ne pouvant afficher le contenu HTML. Ou, si vous envoyez une newsletter, vous pouvez fournir une copie texte brut du texte pour les destinataires qui ont choisi de recevoir une version texte brut. Pour envoyer un e‑mail avec du texte alternatif, suivez ces étapes :

  1. Créez une instance de la MailMessage classe.
  2. Spécifiez les adresses e‑mail de l’expéditeur et du destinataire dans le MailMessage instance.
  3. Créez une instance de la AlternateView classe.

Cela crée une vue alternative d’un message e‑mail en utilisant le contenu spécifié dans la chaîne.

  1. Ajoutez l’instance du AlternateView classe au MailMessage objet.
  2. Créez une instance de la SmtpClient classe et envoyer l’e‑mail en utilisant le send méthode.

L’extrait de code suivant vous montre comment envoyer un e‑mail avec du texte alternatif.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Declare message as MailMessage instance
MailMessage message = new MailMessage();

// Creates AlternateView to view an email message using the content specified in the //String
AlternateView alternate = AlternateView.createAlternateViewFromString("Alternate Text");

// Adding alternate text
message.getAlternateViews().addItem(alternate);

Envoi d’e‑mails en masse

L’envoi d’e‑mails en masse signifie envoyer un lot d’e‑mails dans un seul message. Nous pouvons envoyer un lot d’e‑mails en utilisant le SmtpClient classe send surcharge de méthode qui accepte un MailMessageCollection classe:

  1. Créez une instance de SmtpClient classe.
  2. Spécifiez le SmtpClient propriétés de la classe.
  3. Créez une instance de la MailMessage classe.
  4. Spécifiez l’expéditeur, le destinataire, l’objet du mail et le message dans l’instance du MailMessage classe.
  5. Répétez les deux étapes ci‑dessus si vous voulez envoyer un e‑mail à une autre personne.
  6. Créez une instance de MailMessageCollection classe.
  7. Ajoutez une instance de MailMessage classe dans l’objet du MailMessageCollection classe.
  8. Envoyez maintenant votre e‑mail en utilisant le SmtpClient classe send méthode en passant l’instance de MailMessageCollection classe dedans.

L’extrait de code suivant vous montre comment envoyer des e‑mails en masse.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create SmtpClient as client and specify server, port, user name and password
SmtpClient client = new SmtpClient("mail.server.com", 25, "Username", "Password");

// Create instances of MailMessage class and Specify To, From, Subject and Message
MailMessage message1 = new MailMessage("msg1@from.com", "msg1@to.com", "Subject1", "message1, how are you?");
MailMessage message2 = new MailMessage("msg1@from.com", "msg2@to.com", "Subject2", "message2, how are you?");
MailMessage message3 = new MailMessage("msg1@from.com", "msg3@to.com", "Subject3", "message3, how are you?");

// Create an instance of MailMessageCollection class
MailMessageCollection manyMsg = new MailMessageCollection();
manyMsg.addItem(message1);
manyMsg.addItem(message2);
manyMsg.addItem(message3);

// Use client.BulkSend function to complete the bulk send task
try {
    // Send Message using BulkSend method
    client.send(manyMsg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Obtenir les informations sur les messages envoyés en masse

Lorsque vous envoyez des messages en masse, vous pouvez obtenir des informations sur le nombre de messages envoyés avec succès et la liste de ces messages. Le SucceededSending l’événement est utilisé à cette fin.

L’exemple de code ci‑dessous montre comment obtenir des informations sur le nombre de messages envoyés avec succès :

try (SmtpClient client = new SmtpClient(host, SecurityOptions.Auto)) {
    final AtomicInteger messageCount = new AtomicInteger(0);

    client.setSucceededSending(new EventHandler<MailMessageEventArgs>() {
        public void invoke(Object sender, MailMessageEventArgs eventArgs) {
            System.out.println("The message " + eventArgs.getMessage().getSubject() + " was successfully sent.");
            messageCount.incrementAndGet();
        }
    });

    client.send(messages);

    System.out.println(messageCount + " messages were successfully sent.");
}

Envoi d’e‑mails avec MultiConnection

SmtpClient fournit un UseMultiConnection propriété qui peut être utilisée pour créer plusieurs connexions pour des opérations intensives. Vous pouvez également définir le nombre de connexions à utiliser pendant le mode multiconnection en utilisant SmtpClient.ConnectionsQuantity. L’extrait de code suivant démontre l’utilisation du mode multiconnection pour l’envoi de plusieurs messages.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

SmtpClient smtpClient = new SmtpClient();
smtpClient.setHost("<HOST>");
smtpClient.setUsername("<USERNAME>");
smtpClient.setPassword("<PASSWORD>");
smtpClient.setPort(587);
smtpClient.setSupportedEncryption(EncryptionProtocols.Tls);
smtpClient.setSecurityOptions(SecurityOptions.SSLExplicit);

List<MailMessage> messages = new ArrayList<MailMessage>();
for (int i = 0; i < 20; i++) {
    MailMessage message = new MailMessage("<EMAIL ADDRESS>", "<EMAIL ADDRESS>", "Test Message - " + UUID.randomUUID().toString(),
            "SMTP Send Messages with MultiConnection");
    messages.add(message);
}

smtpClient.setConnectionsQuantity(5);
smtpClient.setUseMultiConnection(MultiConnectionMode.Enable);
smtpClient.send(messages);

Envoi d’un message en tant que TNEF

Les e‑mails TNEF ont un formatage spécial qui peut être perdu s’ils sont envoyés via l’API standard. Aspose.Email offre la capacité d’envoyer des e‑mails en tant que TNEF, préservant ainsi le format. Le SmtpClient classe UseTnef la propriété peut être définie pour envoyer l’e‑mail en tant que TNEF. Le fragment de code suivant vous montre comment envoyer un message en tant que TNEF.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

String emlFileName = dataDir + "Message.eml"; // A TNEF Email

// Load from eml
MailMessage eml1 = MailMessage.load(emlFileName, new EmlLoadOptions());
eml1.setFrom(MailAddress.to_MailAddress("somename@gmail.com"));
eml1.getTo().clear();
eml1.getTo().addItem(new MailAddress("first.last@test.com"));
eml1.setSubject("With PreserveTnef flag during loading");
eml1.setDate(new Date());
SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "somename", "password");
client.setSecurityOptions(SecurityOptions.Auto);
client.setUseTnef(true); // Use this flag to send as TNEF
client.send(eml1);

Envoi de demandes de réunion

Microsoft Outlook offre des fonctions de calendrier ainsi que la gestion des e‑mails. Lorsqu’un utilisateur ouvre un e‑mail contenant une invitation à un événement, Outlook lui propose d’accepter ou de refuser l’invitation. Aspose.Email permet aux développeurs d’ajouter des fonctions de calendrier à leurs e‑mails.

Envoi de demandes par e‑mail

Pour envoyer des demandes de réunion par e‑mail, suivez ces étapes :

  • Créez une instance de la MailMessage classe.
  • Spécifiez les adresses de l’expéditeur et du destinataire à l’aide d’une instance du MailMessage classe.
  • Initialisez une instance de la Appointment classe et transmettre ses valeurs.
  • Spécifiez le résumé et la description dans le Calendar instance.
  • Ajouter le Calendar) à la MailMessage instance et lui passer le Appointment instance.

|Demande de réunion iCalendar envoyée par e‑mail| | :- | |todo:image_alt_text| Le fragment de code suivant vous montre comment envoyer des demandes par e‑mail.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create an instance of the MailMessage class
MailMessage msg = new MailMessage();

// Set the sender, recipient, who will receive the meeting request. Basically, the recipient is the same as the meeting attendees
msg.setFrom(MailAddress.to_MailAddress("newcustomeronnet@gmail.com"));
msg.setTo(MailAddressCollection.to_MailAddressCollection("person1@domain.com, person2@domain.com, person3@domain.com, asposetest123@gmail.com"));

// Create Appointment instance
Calendar cal = Calendar.getInstance();
cal.set(2015, Calendar.JULY, 17, 13, 0, 0);
Date startDate = cal.getTime();
cal.set(2015, Calendar.JULY, 17, 14, 0, 0);
Date endDate = cal.getTime();
Appointment app = new Appointment("Room 112", startDate, endDate, msg.getFrom(), msg.getTo());
app.setSummary("Release Meetting");
app.setDescription("Discuss for the next release");

// Add appointment to the message and Create an instance of SmtpClient class
msg.addAlternateView(app.requestApointment());
SmtpClient client = getSmtpClient();

try {
    // Client.Send will send this message
    client.send(msg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Prise en charge iCalendar pour IBM Lotus Notes

La fonction calendrier d’Aspose.Email est basée sur la norme iCalendar, une norme d’échange de données de calendrier (RFC 2445 ou Référence de syntaxe RFC2445). Ainsi, elle prend en charge non seulement Microsoft Outlook mais aussi IBM Lotus Notes. Pour envoyer une demande de réunion dans Lotus Notes, suivez les mêmes étapes que ci‑dessus.

Transférer un e-mail en utilisant le client SMTP

Transfert d’e-mail avec le client SMTP

Le transfert d’un e-mail est une pratique courante dans la communication digitale quotidienne. Un e-mail reçu peut être transféré à des destinataires spécifiques sans le partager avec les expéditeurs originaux. L’API Aspose.Email SmtpClient offre la capacité de transférer un e-mail à des destinataires spécifiques. Son Transférer méthode peut être utilisée pour transférer un e-mail reçu ou enregistré aux destinataires souhaités comme indiqué dans cet article. Le fragment de code suivant vous montre comment transférer un e-mail en utilisant le client SMTP.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port and SecurityOptions
client.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);
MailMessage message = MailMessage.load(dataDir + "Message.eml");
client.forward("Recipient1@domain.com", "Recipient2@domain.com", message);

Transfert d’e-mail sans utiliser MailMessage

L’API prend également en charge le transfert de messages EML sans les charger d’abord dans MailMessage. Ceci est utile dans les cas où les ressources système en mémoire sont limitées.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

String host = "mail.server.com";
String username = "username";
String password = "password";
int smtpPort = 587;
String sender = "Sender@domain.com";
MailAddressCollection recipients = new MailAddressCollection();
recipients.add("recepient1@domain.com, recepient2@domain.com");

try (SmtpClient client = new SmtpClient(host, smtpPort, username, password, SecurityOptions.Auto)) {
    String fileName = "test.eml";
    try (FileInputStream fs = new FileInputStream(new File(dataDir + fileName))) {
        client.forward(sender, recipients, fs);
    }
}

Effectuer une fusion de courrier

Les fusions de courrier vous aident à créer et envoyer un lot de messages e‑mail similaires. Le cœur des e‑mails est le même, mais le contenu peut être personnalisé. Typiquement, les coordonnées du destinataire (prénom, nom, entreprise, etc.) sont utilisées pour personnaliser l’e‑mail.

|Illustration du fonctionnement d’une fusion de courrier| | :- | |todo:image_alt_text| Aspose.Email permet aux développeurs de configurer des fusions de courrier incluant des données provenant de diverses sources de données.

Pour effectuer une fusion de courrier avec Aspose.Email, suivez les étapes suivantes :

  1. Créez une fonction avec la signature de nom
  2. Créez une instance de la MailMessage classe.
  3. Spécifiez l’expéditeur, le destinataire, l’objet et le corps.
  4. Créez une signature pour la fin de l’e‑mail.
  5. Créez une instance de la TemplateEngine classe et passez‑lui le MailMessage instance.
  6. Prenez la signature dans le TemplateEngine instance.
  7. Créez une instance de la DataTable classe.
  8. Ajoutez les colonnes Receipt, FirstName et LastName comme sources de données dans le DataTable classe.
  9. Créez une instance de la DataRow classe.
  10. Spécifiez l’adresse de réception, le prénom et le nom de famille dans le DataRow objet.
  11. Créez une instance de la MailMessageCollection classe
  12. Spécifiez le TemplateEngine  et DataTable instances dans le MailMessageCollection instance.
  13. Créez une instance de la SmtpClient classe et spécifier le serveur, le port, le nom d’utilisateur et le mot de passe.
  14. Envoyer des e‑mails en utilisant le SmtpClient classe send méthode.

Dans l’exemple ci-dessous, #FirstName# indique un DataTable colonne, dont la valeur est définie par l’utilisateur. Le fragment de code suivant vous montre comment effectuer une fusion de courrier.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dstEmail = dataDir + "EmbeddedImage.msg";

    // Create a new MailMessage instance
    MailMessage msg = new MailMessage();

    // Add subject and from address
    msg.setSubject("Hello, #FirstName#");
    msg.setFrom(MailAddress.to_MailAddress("sender@sender.com"));

    // Add email address to send email also Add mesage field to HTML body
    msg.getTo().add("your.email@gmail.com");
    String htmlBody = "Your message here/r/n" + "Thank you for your interest in <STRONG>Aspose.Email</STRONG>.";

    // Use GetSignment as the template routine, which will provide the same signature
    htmlBody += "<br><br>Have fun with it.<br><br>#GetSignature()#";

    msg.setHtmlBody(htmlBody);

    // Create a new TemplateEngine with the MSG message, Register GetSignature routine. It will be used in MSG.
    TemplateEngine engine = new TemplateEngine(msg);
    engine.registerRoutine("GetSignature", new TemplateRoutine() {
        public Object invoke(Object[] args) {
            return getSignature(args);
        }
    });

    // Create an instance of DataTable and Fill a DataTable as data source
    DataTable dt = new DataTable();
    dt.getColumns().add("Receipt");
    dt.getColumns().add("FirstName");
    dt.getColumns().add("LastName");

    DataRow dr;
    dr = dt.newRow();
    dr.set("Receipt", "Nancy&lt;Nancy@somedomain.com&gt;");
    dr.set("FirstName", "Nancy");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);
    dr = dt.newRow();
    dr.set("Receipt", "Andrew&lt;Andrew@somedomain.com&gt;");
    dr.set("FirstName", "Andrew");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);
    dr = dt.newRow();
    dr.set("Receipt", "Janet&lt;Janet@somedomain.com&gt;");
    dr.set("FirstName", "Janet");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);

    MailMessageCollection messages;
    try {
        // Create messages from the message and datasource.
        messages = engine.instantiate(dt);

        // Create an instance of SmtpClient and specify server, port, username and password
        SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
        client.setSecurityOptions(SecurityOptions.Auto);

        // Send messages in bulk
        client.send(messages);
    } catch (MailException ex) {
        System.err.println(ex);
    }

    catch (SmtpException ex) {
        System.err.println(ex);
    }

    System.out.println("Message sent after performing mail merge.");
}

// Template routine to provide signature
static Object getSignature(Object[] args) {
    return "Aspose.Email Team<br>Aspose Ltd.<br>" + new Date().toString();
}

Effectuer une fusion de courrier ligne par ligne

L’utilisateur peut également fusionner une ligne de données individuelle pour obtenir un fichier complet et préparé MailMessage objet. Le TemplateEngine.merge méthode peut être utilisée pour effectuer une fusion de courrier ligne par ligne.

// Create message from the data in current row.
MailMessage message = engine.merge(currentRow);
Connexion au serveur SMTP Fonctionnalités utilitaires - client SMTP