שליחת והעברת הודעות - שליחת הודעות Outlook באמצעות תוכנית Java

ה SmtpClient class מאפשרת ליישומים לשלוח אימייל באמצעות פרוטוקול Simple Mail Transfer Protocol (SMTP).

  • ה SmtpClient class היא רקודת הכניסה המרכזית היחידה שמשתמשים מפתחים משתמשים כדי לשלוח הודעות דוא"ל.
  • ה SmtpClient class גם מספקת שיטות משלוח אימייל נפוצות אחרות, כולל כתיבת הודעות אימייל למערכת הקבצים, תור הודעות וכו׳.
  • ה SmtpClient class תומכת במלואה בשתי מודלים תכנותיים אלו:
  • ה SmtpClient class גם תומכת ב שליחת הודעות בתור TNEF

כדי לשלוח את הודעת האימייל ולחסום בזמן ההמתנה להעברת האימייל לשרת SMTP, השתמש באחת משיטות Send הסינכרוניות. כדי לאפשר לתיל הראשי של התוכנית שלך להמשיך לרוץ בזמן שהאימייל נשלח, השתמש ב beginSend שיטה.

שליחת דוא"לים באופן סינכרוני

הודעת אימייל יכולה להישלח באופן סינכרוני באמצעות SmtpClient מחלקה send method. הוא שולח את הודעת האימייל המצוינת דרך שרת SMTP למטרת משלוח. שולח ההודעה, הנמענים, הנושא וגוף ההודעה מצוינים באמצעות אובייקטים מסוג String. כדי לשלוח הודעת אימייל באופן סינכרוני, פעל לפי הצעדים שלהלן:

  1. צור מופע של MailMessage class והגדר את תכונותיו.
  2. צור מופע של SmtpClient class וציין את המארח, הפורט, שם המשתמש והסיסמה.
  3. שלח את ההודעה באמצעות SmtpClient מחלקה send method והעבר את MailMessage מופע.

הקטע הקוד הבא ב‑Java מראה לך כיצד לשלוח דוא"לי Outlook באופן סינכרוני.

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

שליחת דוא"לים באופן אסינכרוני

לפעמים, אתה עשוי לרצות לשלוח דוא"ל באופן אסינכרוני. למשל, אם אתה שולח הרבה דוא"לים דרך האפליקציה שלך, הגישה הסינכרונית עשויה לא לעבוד. במצב כזה, ניתן להשתמש ב beginSend. ה beginSend שיטה של SmtpClient class שולחת הודעת דוא"ל לשרת SMTP למשלוח. מתודה זו אינה חוסמת את תיל הקריאה ומאפשרת למזמין להעביר אובייקט למתודה אשר יינקט כאשר הפעולה מסתיימת. כדי לשלוח הודעת Outlook באופן אסינכרוני ב‑Java, פעל לפי הצעדים הבאים:

  1. צור מופע של MailMessage class והשתמש בתכונות השונות שלו.
  2. צור מופע של SmtpClient class וציין את המארח, הפורט, שם המשתמש והסיסמה.
  3. צור מופע שהוגדר על‑ידי המשתמש אשר יועבר למתודה ויינצל כאשר הפעולה האסינכרונית מסתיימת.
  4. שלח את ההודעה באמצעות beginSend מתודה של SmtpClient class והעבר את MailMessage מופע (instance) ומופע שהוגדר על‑ידי המשתמש בו יחד עם פונקציית callback שתיקרא כאשר הפעולה הושלמה.

כדי לקבל התראה כאשר הדוא"ל נשלח או שהפעולה בוטלה, פונקציית המשוב (callback) שהועברה אל beginSend method נקראת. לאחר קריאת SmtpClient מחלקה beginSend method אינו צורך לחכות שהודעת דוא"ל תישלח במלואה. אנו יכולים לקרוא לשיטה אחרת beginSend במקביל. כאשר אימייל נשלח באמצעות ה- beginSend מתודה, קטע הקוד מדפיס הודעה ("Message Sent"). תוכנית Java הבאה או קטע קוד מראה כיצד לשלוח אימיילים באופן אסינכרוני.

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

שליחת הודעות שמורות מהדיסק

קבצי EML (קבצי דואר אלקטרוני של Outlook Express) כוללים כותרת אימייל, גוף הודעה וכל קבצים מצורפים. Aspose.Email מאפשר למפתחים לעבוד עם קבצי EML בדרכים שונות. מאמר זה מראה כיצד לטעון קבצי EML מהדיסק ולשלוח אותם כאימיילים באמצעות SMTP. ניתן לטעון קבצי .eml מהדיסק או זרם אל ה- MailMessage מחלקה ולשלוח את הודעת האימייל באמצעות ה- SmtpClient מחלקה. ה- MailMessage המחלקה היא המחלקה הראשית ליצירת הודעות אימייל חדשות, טעינת קבצי הודעות אימייל מדיסק או זרם ושמירת ההודעות. קטע קוד Java הבא מראה כיצד לשלוח הודעות שמורות מהדיסק.

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

שליחת אימייל טקסט פשוט

דוגמאות קוד למטה מראות כיצד לשלוח הודעת אימייל טקסט פשוט. ה- גוף מאפיין, מאפיין של ה- MailMessage מחלקה, משמשת לציון תוכן הטקסט הפשוט של גוף ההודעה. כדי לשלוח הודעת אימייל טקסט פשוט, פעל לפי הצעדים הבאים:

  • צור מופע של MailMessage מחלקה.
  • ציין את כתובות האימייל של השולח והמקבל ב- MailMessage מופע.
  • ציין את גוף תוכן, משמש להודעת טקסט פשוט.
  • צור מופע של SmtpClient מחלקה ולשלוח את האימייל.

הקטע קוד הבא מראה כיצד לשלוח אימייל טקסט פשוט.

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

שליחת אימייל עם גוף HTML

דוגמאות קוד למטה מראות כיצד ניתן לשלוח הודעת אימייל HTML פשוטה. ה- HtmlBody, מאפיין של ה- MailMessage מחלקה, משמשת לציון תוכן ה-HTML של גוף ההודעה. כדי לשלוח אימייל HTML פשוט, פעל לפי הצעדים הבאים:

  • צור מופע של MailMessage מחלקה.
  • ציין כתובת אימייל של השולח והמקבל ב- MailMessage מופע.
  • ציין את HtmlBody תוכן.
  • צור מופע של SmtpClient מחלקה ולשלוח את האימייל באמצעות ה- send שיטה.

לצורכי מאמר זה, תוכן ה-HTML של האימייל הוא בסיסי: This is the HTML body רוב האימיילים ב-HTML יהיו יותר מורכבים. קטע קוד Java הבא מראה כיצד לשלוח אימייל עם גוף 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;
}

שליחת אימייל עם טקסט הודעה חלופי

דוגמאות קוד למטה מראות כיצד לשלוח הודעת אימייל HTML פשוטה עם תוכן חלופי. השתמש ב- AlternateView מחלקה לציון עותקים של הודעת אימייל בפורמטים שונים. לדוגמה, אם אתה שולח הודעה ב-HTML, ייתכן שתרצה לספק גרסת טקסט רגיל למקבלים שמשתמשים בתוכנות קריאת אימייל שאינן מציגות תוכן HTML. או, אם אתה שולח ניוזלטר, ייתכן שתרצה לספק עותק טקסט רגיל למקבלים שבחרו לקבל גרסת טקסט רגיל. כדי לשלוח אימייל עם טקסט חלופי, עקוב אחרי הצעדים הבאים:

  1. צור מופע של MailMessage מחלקה.
  2. ציין כתובות אימייל של השולח והמקבל ב- MailMessage מופע.
  3. צור מופע של AlternateView מחלקה.

זה יוצר תצוגה חלופית להודעת אימייל באמצעות התוכן שמוגדר במחרוזת.

  1. הוסף את המופע של ה- AlternateView מחלקה ל- MailMessage אובייקט.
  2. צור מופע של SmtpClient מחלקה ולשלוח את האימייל באמצעות ה- send שיטה.

הקטע קוד הבא מראה כיצד לשלוח אימייל עם טקסט חלופי.

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

שליחת אימיילים בכמות גדולה

שליחת אימיילים בכמות גדולה משמעותה שליחת קבוצה של אימיילים בהודעה אחת. אנו יכולים לשלוח קבוצה של אימיילים באמצעות ה- SmtpClient מחלקה send העמסת מתודה שמקבלת MailMessageCollection מחלקה:

  1. צור מופע של SmtpClient מחלקה.
  2. ציין את SmtpClient מאפייני המחלקה.
  3. צור מופע של MailMessage מחלקה.
  4. ציין שולח, מקבל, נושא האימייל וההודעה במופע של ה- MailMessage מחלקה.
  5. חזור על שני הצעדים שלמעלה שוב, אם ברצונך לשלוח אימייל לאדם אחר.
  6. צור מופע של MailMessageCollection מחלקה.
  7. הוסף מופע של MailMessage מחלקה במופע של ה- MailMessageCollection מחלקה.
  8. כעת שלח את האימייל שלך באמצעות ה- SmtpClient מחלקה send מתודה על ידי העברת המופע של MailMessageCollection מחלקה בתוכה.

הקטע קוד הבא מראה כיצד לשלוח אימיילים בכמות גדולה.

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

קבלת מידע על הודעות בכמות שנשלחו

כאשר אתה שולח הודעות בכמות גדולה, ניתן לקבל מידע על מספר ההודעות שנשלחו בהצלחה ורשימת ההודעות. ה- SucceededSending אירוע משמש למטרה זו.

דוגמת הקוד שלהלן מראה כיצד לקבל מידע על מספר ההודעות שנשלחו בהצלחה:

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

שליחת אימיילים עם MultiConnection

SmtpClient מספק UseMultiConnection מאפיין שניתן להשתמש בו ליצירת חיבורים מרובים לפעולות כבדות. ניתן גם להגדיר את מספר החיבורים שישמשו במצב מרובה חיבורים באמצעות SmtpClient.ConnectionsQuantity. הקטע קוד הבא מדגים את השימוש במצב מרובה חיבורים לשליחת מספר הודעות.

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

שליחת הודעה בתור TNEF

הודעות TNEF כוללות פורמט מיוחד שעשוי להיות אבוד אם נשלחות באמצעות ה‑API הסטנדרטי. Aspose.Email מספקת את האפשרות לשלוח אימיילים בתור TNEF, ובכך משמרת את הפורמט. ה SmtpClient מחלקה UseTnef ניתן להגדיר את המאפיין כדי לשלוח את האימייל בתור TNEF. קטע הקוד הבא מראה כיצד לשלוח הודעה בתור 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);

שליחת בקשות פגישה

Microsoft Outlook מציע פונקציות יומן וגם ניהול אימייל. כאשר משתמש פותח אימייל עם הזמנה לאירוע, Outlook מציג לו אפשרות לקבל או לדחות את ההזמנה. Aspose.Email מאפשרת למפתחים להוסיף פונקציות יומן לאימיילים שלך.

שליחת בקשות דרך אימייל

כדי לשלוח בקשות פגישה דרך אימייל, פעל לפי הצעדים הבאים:

  • צור מופע של MailMessage מחלקה.
  • ציין כתובות שולח ונמען באמצעות מופע של MailMessage מחלקה.
  • אתחל מופע של Appointment class והעבר את ערכיו.
  • ציין תקציר ותיאור ב Calendar מופע.
  • הוסף את ה- Calendar) ל MailMessage מופע והעבר לו את Appointment מופע.

|בקשת פגישה iCalendar שנשלחת באימייל| | :- | |todo:image_alt_text| קטע הקוד הבא מראה כיצד לשלוח בקשות דרך אימייל.

// 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 עבור IBM Lotus Notes

תכונת היומן של Aspose.Email מבוססת על תקן iCalendar, תקן לחילופי נתוני לוח שנה (RFC 2445 או RFC2445 Syntax Reference). לכן, היא תומכת לא רק ב‑Microsoft Outlook אלא גם ב‑IBM Lotus Notes. כדי לשלוח בקשת פגישה ב‑Lotus Notes, פעל לפי אותם הצעדים שהוזכרו למעלה.

העבר אימייל באמצעות לקוח SMTP

העברת אימייל עם לקוח SMTP

העברת אימייל היא נוהל נפוץ בתקשורת דיגיטלית יומיומית. אימייל שהתקבל ניתן להעברה למקבלים ספציפיים מבלי לשתף עם השולחים המקוריים. Aspose.Email API SmtpClient מספקת את האפשרות להעביר אימייל למקבלים ספציפיים. ה העברה method יכולה לשמש להעברת אימייל שהתקבל או נשמר למקבלים רצויים כפי שמוצג במאמר זה. קטע הקוד הבא מראה כיצד להעביר אימייל באמצעות לקוח 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);

העברת אימייל ללא שימוש ב‑MailMessage

ה‑API גם תומך בהעברת הודעות EML מבלי לטעון אותן קודם ל MailMessage. זה שימושי במקרים שבהם משאבי הזיכרון של המערכת מוגבלים.

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

ביצוע מיזוג דואר

מיזוגי דואר מאפשרים ליצור ולשלוח קבוצת הודעות אימייל דומות. הליבה של ההודעות זהה, אך התוכן ניתן להתאמה אישית. בדרך כלל, פרטי הקשר של הנמען (שם פרטי, שם שני, חברה וכד’) משמשים להתאמת ההודעה.

|הדגמה של איך מיזוג דואר עובד:| | :- | |todo:image_alt_text| Aspose.Email מאפשרת למפתחים להגדיר מיזוגי דואר הכוללים נתונים ממגוון מקורות נתונים.

כדי לבצע מיזוג דואר עם Aspose.Email, פעלו לפי הצעדים הבאים:

  1. צור פונקציה עם חתימת שם
  2. צור מופע של MailMessage מחלקה.
  3. ציין את השולח, המקבל, הנושא והגוף.
  4. צור חתימה לסיום המייל.
  5. צור מופע של TemplateEngine מחלקה והעביר לה את MailMessage מופע.
  6. קח חתימה ב‑ TemplateEngine מופע.
  7. צור מופע של DataTable מחלקה.
  8. הוסף את העמודות Receipt, FirstName ו‑LastName כמקורות נתונים ב DataTable מחלקה.
  9. צור מופע של DataRow מחלקה.
  10. ציין את כתובת הקבלה, שם פרטי ושם משפחה ב DataRow אובייקט.
  11. צור מופע של MailMessageCollection מחלקה
  12. ציין את TemplateEngine  ו DataTable מופעים ב MailMessageCollection מופע.
  13. צור מופע של SmtpClient class וציין את השרת, הפורט, שם המשתמש והסיסמה.
  14. שלח אימיילים באמצעות SmtpClient מחלקה send שיטה.

בדוגמה שלמטה, #FirstName# מציין DataTable עמודה, שערכה נקבעת על ידי המשתמש. קטע הקוד הבא מראה כיצד לבצע מיזוג דואר.

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

ביצוע מיזוג דואר לפי שורה

המשתמש יכול למזג שורת נתונים בודדת גם כן כדי לקבל תוצאה שלמה ומוכנה MailMessage אובייקט. ה TemplateEngine.merge method יכולה לשמש לביצוע מיזוג דואר לפי שורה.

// Create message from the data in current row.
MailMessage message = engine.merge(currentRow);
התחברות לשרת SMTP תכונות שירות - לקוח SMTP