Senden und Weiterleiten von Nachrichten – Outlook‑E‑Mails mit Java‑Programm senden

Die SmtpClient Klasse ermöglicht Anwendungen das Senden von E‑Mails über das Simple Mail Transfer Protocol (SMTP).

  • Die SmtpClient Klasse ist der einzige wesentliche Einstiegspunkt, den Entwickler zum Senden von E‑Mails verwenden.
  • Die SmtpClient Klasse bietet außerdem weitere gängige E‑Mail‑Zustellmethoden, einschließlich Schreiben von E‑Mails ins Dateisystem, Message‑Queue usw.
  • Die SmtpClient Klasse unterstützt diese beiden Programmiermodelle vollständig:
  • Die SmtpClient Klasse unterstützt außerdem Nachrichten als TNEF senden

Um die E‑Mail‑Nachricht zu senden und dabei zu blockieren, bis die E‑Mail zum SMTP‑Server übertragen wurde, verwenden Sie eine der synchronen Send‑Methoden. Um dem Haupt‑Thread Ihres Programms zu ermöglichen, weiterzulaufen, während die E‑Mail übertragen wird, verwenden Sie die beginSend Methode.

E‑Mails synchron senden

Eine E‑Mail‑Nachricht kann synchron gesendet werden mit dem SmtpClient Klasse send Methode. Sie sendet die angegebene E‑Mail‑Nachricht über einen SMTP‑Server zur Zustellung. Absender, Empfänger, Betreff und Nachrichtentext werden mittels String‑Objekten angegeben. Um eine E‑Mail‑Nachricht synchron zu senden, folgen Sie den nachstehenden Schritten:

  1. Erstellen Sie eine Instanz von MailMessage Klasse und setzen Sie ihre Eigenschaften.
  2. Erstellen Sie eine Instanz von SmtpClient Klasse und geben Sie Host, Port, Benutzername & Passwort an.
  3. Senden Sie die Nachricht mit dem SmtpClient Klasse send Methode und übergeben Sie die MailMessage Instanz.

Das folgende Java‑Code‑Snippet zeigt, wie man Outlook‑E‑Mails synchron sendet.

// 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);
}

E‑Mails asynchron senden

Manchmal möchten Sie E‑Mails asynchron senden. Zum Beispiel könnte bei einer großen Menge an E‑Mails, die Ihre Anwendung verschickt, der synchrone Ansatz nicht funktionieren. In einem solchen Szenario können Sie verwenden beginSend. Die beginSend Methode des SmtpClient Klasse sendet eine E‑Mail‑Nachricht an einen SMTP‑Server zur Zustellung. Diese Methode blockiert den aufrufenden Thread nicht und ermöglicht dem Aufrufer, ein Objekt an die Methode zu übergeben, das aufgerufen wird, wenn die Operation abgeschlossen ist. Um eine Outlook‑E‑Mail‑Nachricht in Java asynchron zu senden, führen Sie die folgenden Schritte aus:

  1. Erstellen Sie eine Instanz von MailMessage Klasse und nutzen Sie ihre verschiedenen Eigenschaften.
  2. Erstellen Sie eine Instanz von SmtpClient Klasse und geben Sie Host, Port, Benutzername und Passwort an.
  3. Erstellen Sie eine benutzerdefinierte Instanz, die an die Methode übergeben und aufgerufen wird, wenn die asynchrone Operation abgeschlossen ist.
  4. Senden Sie die Nachricht mit beginSend Methode von SmtpClient Klasse und übergeben Sie die MailMessage Instanz und benutzerdefinierte Instanz darin zusammen mit einer Callback‑Funktion, die aufgerufen wird, wenn die Operation abgeschlossen ist.

Um eine Benachrichtigung zu erhalten, wenn die E‑Mail gesendet wurde oder die Operation abgebrochen wurde, wird die Callback‑Funktion übergeben an die beginSend Methode wird aufgerufen. Nach dem Aufruf der SmtpClient Klasse beginSend Methode, es ist nicht notwendig, darauf zu warten, dass eine E‑Mail‑Nachricht vollständig gesendet wird. Wir können eine andere Methode aufrufen beginSend gleichzeitig. Wenn eine E‑Mail gesendet wurde mittels dem beginSend Methode, das Code‑Snippet gibt eine Meldung aus ("Message Sent"). Das folgende Java‑Programm bzw. Code‑Snippet zeigt, wie Sie E‑Mails asynchron senden.

// 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.");
        }
    }
};

Gespeicherte Nachrichten von der Festplatte senden

EML‑Dateien (Outlook‑Express‑Electronic‑Mail‑Dateien) enthalten einen E‑Mail‑Header, Nachrichtenkörper und Anhänge. Aspose.Email ermöglicht Entwicklern die Arbeit mit EML‑Dateien auf verschiedene Weise. Dieser Artikel zeigt, wie EML‑Dateien von der Festplatte geladen und per SMTP als E‑Mails gesendet werden können. Sie können .eml‑Dateien von der Festplatte oder einem Stream in die MailMessage Klasse und senden Sie die E‑Mail‑Nachricht mittels der SmtpClient Klasse. Die MailMessage Klasse ist die Hauptklasse zum Erstellen neuer E‑Mail‑Nachrichten, zum Laden von E‑Mail‑Nachrichtendateien von Festplatte oder Stream und zum Speichern der Nachrichten. Das folgende Java‑Code‑Snippet zeigt, wie gespeicherte Nachrichten von der Festplatte gesendet werden.

// 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());
}

Nur‑Text‑E‑Mail senden

Die untenstehenden Programmbeispiele zeigen, wie man eine Nur‑Text‑E‑Mail sendet. Die Body Eigenschaft, eine Eigenschaft der MailMessage Klasse, die verwendet wird, um den Nur‑Text‑Inhalt des Nachrichtenkörpers festzulegen. Um eine Nur‑Text‑E‑Mail zu senden, gehen Sie wie folgt vor:

  • Erstellen Sie eine Instanz von dem MailMessage Klasse.
  • Geben Sie Absender‑ und Empfänger‑E‑Mail‑Adressen ein in der MailMessage Instanz.
  • Geben Sie das Body Inhalt, verwendet für die Nur‑Text‑Nachricht.
  • Erstellen Sie eine Instanz von dem SmtpClient Klasse und senden Sie die E‑Mail.

Das folgende Code‑Snippet zeigt, wie Sie eine Nur‑Text‑E‑Mail senden.

// 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);
}

E‑Mail mit HTML‑Body senden

Die untenstehenden Programmbeispiele zeigen, wie Sie eine einfache HTML‑E‑Mail‑Nachricht senden können. Die HtmlBody, eine Eigenschaft der MailMessage Klasse, die verwendet wird, um den HTML‑Inhalt des Nachrichtenkörpers festzulegen. Um eine einfache HTML‑E‑Mail zu senden, gehen Sie wie folgt vor:

  • Erstellen Sie eine Instanz von dem MailMessage Klasse.
  • Geben Sie Absender‑ und Empfänger‑E‑Mail‑Adresse ein in der MailMessage Instanz.
  • Geben Sie das HtmlBody Inhalt.
  • Erstellen Sie eine Instanz von dem SmtpClient Klasse und senden Sie die E‑Mail mittels der send Methode.

Für den Zweck dieses Artikels ist der HTML‑Inhalt der E‑Mail einfach gehalten: This is the HTML body Die meisten HTML‑E‑Mails sind komplexer. Das folgende Java‑Programm‑Snippet zeigt, wie Sie eine E‑Mail mit HTML‑Body senden.

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;
}

E‑Mail mit alternativem Nachrichtentext senden

Die untenstehenden Programmbeispiele zeigen, wie man eine einfache HTML‑E‑Mail‑Nachricht mit alternativem Inhalt sendet. Verwenden Sie die AlternateView Klasse, um Kopien einer E‑Mail‑Nachricht in verschiedenen Formaten anzugeben. Zum Beispiel, wenn Sie eine Nachricht in HTML senden, möchten Sie möglicherweise auch eine Nur‑Text‑Version für Empfänger bereitstellen, die keinen HTML‑Inhalt anzeigen können. Oder, wenn Sie einen Newsletter versenden, möchten Sie eine Nur‑Text‑Kopie für Empfänger anbieten, die eine Nur‑Text‑Version bevorzugen. Um eine E‑Mail mit alternativem Text zu senden, gehen Sie wie folgt vor:

  1. Erstellen Sie eine Instanz von dem MailMessage Klasse.
  2. Geben Sie Absender‑ und Empfänger‑E‑Mail‑Adressen ein in der MailMessage Instanz.
  3. Erstellen Sie eine Instanz von dem AlternateView Klasse.

Dies erzeugt eine alternative Ansicht für eine E‑Mail‑Nachricht mit dem im String angegebenen Inhalt.

  1. Fügen Sie die Instanz der AlternateView Klasse zum MailMessage Objekt.
  2. Erstellen Sie eine Instanz von dem SmtpClient Klasse und senden Sie die E‑Mail mittels der send Methode.

Das folgende Code‑Snippet zeigt, wie Sie eine E‑Mail mit alternativem Text senden.

// 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);

Massen‑E‑Mails senden

Massenversand von E‑Mails bedeutet das Senden einer Gruppe von E‑Mails in einer Nachricht. Wir können eine Gruppe von E‑Mails senden mittels der SmtpClient Klasse send Methoden‑Überladung, die einen MailMessageCollection Klasse:

  1. Erstellen Sie eine Instanz von SmtpClient Klasse.
  2. Geben Sie das SmtpClient Klassen‑Eigenschaften an.
  3. Erstellen Sie eine Instanz von dem MailMessage Klasse.
  4. Geben Sie Absender, Empfänger, Betreff und Nachricht in der Instanz der MailMessage Klasse.
  5. Wiederholen Sie die beiden obigen Schritte, wenn Sie eine E‑Mail an eine andere Person senden möchten.
  6. Erstellen Sie eine Instanz von MailMessageCollection Klasse.
  7. Fügen Sie eine Instanz von MailMessage Klasse im Objekt von MailMessageCollection Klasse.
  8. Senden Sie jetzt Ihre E‑Mail mit dem SmtpClient Klasse send Methode durch Übergeben der Instanz von MailMessageCollection Klasse darin.

Das folgende Code‑Snippet zeigt, wie Sie Massen‑E‑Mails senden.

// 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);
}

Informationen über gesendete Massen­nachrichten erhalten

Wenn Sie Nachrichten massenhaft senden, können Sie Informationen über die Anzahl der erfolgreich gesendeten Nachrichten und die Liste dieser Nachrichten erhalten. Die SucceededSending Ereignis wird zu diesem Zweck verwendet.

Das untenstehende Code‑Beispiel zeigt, wie Sie Informationen über die Anzahl erfolgreich gesendeter Nachrichten erhalten:

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.");
}

E‑Mails mit MultiConnection senden

SmtpClient bietet ein UseMultiConnection Eigenschaft, die verwendet werden kann, um mehrere Verbindungen für umfangreiche Vorgänge zu erstellen. Sie können auch die Anzahl der Verbindungen festlegen, die im Multi‑Connection‑Modus verwendet werden sollen, indem Sie SmtpClient.ConnectionsQuantity. Das folgende Code‑Snippet demonstriert die Nutzung des Multi‑Connection‑Modus zum Senden mehrerer Nachrichten.

// 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);

Eine Nachricht als TNEF senden

TNEF‑E‑Mails haben eine spezielle Formatierung, die beim Senden über die Standard‑API verloren gehen kann. Aspose.Email bietet die Möglichkeit, E‑Mails als TNEF zu senden und damit das Format zu erhalten. Die SmtpClient Klasse UseTnef Eigenschaft kann so gesetzt werden, dass die E‑Mail als TNEF gesendet wird. Das folgende Code‑Snippet zeigt, wie man eine Nachricht als TNEF sendet.

// 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);

Versenden von Besprechungsanfragen

Microsoft Outlook bietet Kalenderfunktionen sowie E‑Mail‑Verwaltung. Wenn ein Benutzer eine E‑Mail mit einer Einladung zu einem Ereignis öffnet, fordert Outlook ihn auf, die Einladung anzunehmen oder abzulehnen. Aspose.Email ermöglicht Entwicklern, Kalenderfunktionen zu Ihren E‑Mails hinzuzufügen.

Anfragen per E‑Mail senden

Um Besprechungsanfragen per E‑Mail zu senden, folgen Sie diesen Schritten:

  • Erstellen Sie eine Instanz von dem MailMessage Klasse.
  • Geben Sie Absender‑ und Empfängeradressen mit einer Instanz von der MailMessage Klasse.
  • Initialisieren Sie eine Instanz von der Appointment Klasse und übergeben Sie deren Werte.
  • Geben Sie Zusammenfassung und Beschreibung im Calendar Instanz.
  • Fügen Sie das Calendar) an die MailMessage Instanz und übergeben Sie ihr die Appointment Instanz.

|iCalendar‑Besprechungsanfrage per E‑Mail gesendet| | :- | |todo:image_alt_text| Das folgende Code‑Snippet zeigt, wie man Anfragen per E‑Mail sendet.

// 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);
}

iCalendar‑Unterstützung für IBM Lotus Notes

Die Kalenderfunktion von Aspose.Email basiert auf dem iCalendar‑Standard, einem Standard für den Austausch von Kalenderdaten (RFC 2445 oder RFC2445 Syntax Reference). Daher unterstützt sie nicht nur Microsoft Outlook, sondern auch IBM Lotus Notes. Um eine Besprechungsanfrage in Lotus Notes zu senden, folgen Sie denselben Schritten wie oben beschrieben.

Eine E‑Mail mit dem SMTP‑Client weiterleiten

E‑Mail weiterleiten mit SMTP‑Client

Das Weiterleiten einer E‑Mail ist ein gängiges Verfahren in der täglichen digitalen Kommunikation. Eine empfangene E‑Mail kann an bestimmte Empfänger weitergeleitet werden, ohne sie mit den ursprünglichen Absendern zu teilen. Aspose.Email API SmtpClient bietet die Möglichkeit, eine E‑Mail an bestimmte Empfänger weiterzuleiten. Ihre Weiterleiten Methode kann verwendet werden, um eine empfangene oder gespeicherte E‑Mail an gewünschte Empfänger weiterzuleiten, wie in diesem Artikel gezeigt. Das folgende Code‑Snippet zeigt, wie man eine E‑Mail mit dem SMTP‑Client weiterleitet.

// 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);

E‑Mail weiterleiten ohne MailMessage zu verwenden

Die API unterstützt außerdem das Weiterleiten von EML‑Nachrichten, ohne sie zuerst zu laden in MailMessage. Dies ist nützlich in Fällen, in denen nur begrenzte System‑Speicherressourcen verfügbar sind.

// 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);
    }
}

Durchführen eines Seriendrucks

Seriendrucke helfen Ihnen, eine Charge ähnlicher E‑Mail‑Nachrichten zu erstellen und zu senden. Der Kern der E‑Mails ist gleich, aber der Inhalt kann personalisiert werden. Üblicherweise werden die Kontaktdaten des Empfängers (Vorname, Nachname, Unternehmen usw.) verwendet, um die E‑Mail zu personalisieren.

|Veranschaulichung, wie ein Mail‑Merge funktioniert:| | :- | |todo:image_alt_text| Aspose.Email ermöglicht Entwicklern das Einrichten von Mail‑Merges, die Daten aus verschiedenen Datenquellen einbeziehen.

Um einen Seriendruck mit Aspose.Email durchzuführen, befolgen Sie die folgenden Schritte:

  1. Erstellen Sie eine Funktion mit der Namenssignatur
  2. Erstellen Sie eine Instanz von dem MailMessage Klasse.
  3. Geben Sie Absender, Empfänger, Betreff und Text an.
  4. Erstellen Sie eine Signatur für das Ende der E‑Mail.
  5. Erstellen Sie eine Instanz von dem TemplateEngine Klasse und übergeben Sie ihr die MailMessage Instanz.
  6. Nehmen Sie die Signatur in der TemplateEngine Instanz.
  7. Erstellen Sie eine Instanz von dem DataTable Klasse.
  8. Fügen Sie die Spalten Receipt, FirstName und LastName als Datenquellen im DataTable Klasse.
  9. Erstellen Sie eine Instanz von dem DataRow Klasse.
  10. Geben Sie die Empfangsadresse, Vor‑ und Nachnamen im DataRow Objekt.
  11. Erstellen Sie eine Instanz von dem MailMessageCollection Klasse
  12. Geben Sie das TemplateEngine  und DataTable Instanzen in dem MailMessageCollection Instanz.
  13. Erstellen Sie eine Instanz von dem SmtpClient Klasse und geben Sie Server, Port, Benutzername und Passwort an.
  14. Senden Sie E‑Mails mit der SmtpClient Klasse send Methode.

Im folgenden Beispiel steht #FirstName# für einen DataTable Spalte, deren Wert vom Benutzer festgelegt wird. Das folgende Code‑Snippet zeigt, wie man ein Mail‑Merge durchführt.

// 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();
}

Zeilenweises Mail‑Merge ausführen

Benutzer kann auch einzelne Datenzeilen zusammenführen, um ein komplettes und vorbereitetes MailMessage Objekt. Der TemplateEngine.merge Methode kann verwendet werden, um ein zeilenweises Mail‑Merge durchzuführen.

// Create message from the data in current row.
MailMessage message = engine.merge(currentRow);
Verbindung zum SMTP‑Server herstellen Dienstprogramme – SMTP‑Client