Documentation – עבודה עם לקוח SMTP

Java: התחברות לשרת SMTP

Mon, 01 Jan 0001 00:00:00 +0000

יש להגדיר את המאפיינים הבאים כאשר מתחברים לשרת SMTP עם תמיכת SSL.

SecurityOptions
פורט

בדוגמאות שלהלן אנו מציגים כיצד:

הגדר שם משתמש.
הגדר סיסמה.
הגדר את הפורט.
הגדר אפשרות אבטחה.

הקטע הקוד שלהלן מציג כיצד להתחבר לשרת SMTP שתומך ב‑SSL.

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

SmtpClient client = new SmtpClient("smtp.gmail.com");

// Set username, password, port, and security options
client.setUsername("your.email@gmail.com");
client.setPassword("your.password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);

התחברות לשרת דרך פרוקסי Socks

לפעמים אנו משתמשים בשרתים פרוקסי לצורך תקשורת עם העולם החיצון. במקרים כאלה, לקוחות דואר אינם יכולים לתקשור באינטרנט ללא ציון כתובת הפרוקסי. Aspose.Email תומך בגרסאות 4, 4a ו‑5 של פרוטוקול הפרוקסי SOCKS. מאמר זה מציג דוגמה עובדת של שליחת אימייל באמצעות שרת דואר פרוקסי. כדי לשלוח אימייל דרך פרוקסי:

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

הקטע הקוד שלהלן מציג כיצד להתחבר לשרת דרך פרוקסי.

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

SmtpClient client = new SmtpClient("smtp.domain.com", "username", "password");
client.setSecurityOptions(SecurityOptions.SSLImplicit);
String proxyAddress = "192.168.203.142"; // proxy address
int proxyPort = 1080; // proxy port
SocksProxy proxy = new SocksProxy(proxyAddress, proxyPort, SocksVersion.SocksV5);
client.setProxy(proxy);
client.send(new MailMessage("sender@domain.com", "receiver@domain.com", "Sending Email via proxy",
        "Implement socks proxy protocol for versions 4, 4a, 5 (only Username/Password authentication)"));

התחברות לשרת דרך פרוקסי HTTP

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

HttpProxy proxy = new HttpProxy("18.222.124.59", 8080);
try (SmtpClient client = new SmtpClient("host", 587, "username", "password")) {
    client.setProxy(proxy);
    client.send(new MailMessage("sender@domain.com", "receiver@domain.com", "Sending Email via proxy",
            "Implement socks proxy protocol for versions 4, 4a, 5 (only Username/Password authentication)"));
}

התאמת מנגנון האימות

קבל את רשימת מנגנוני האימות הנתמכים על ידי שרת ה‑SMTP באמצעות ה‑ getSupportedAuthentication שיטה של SmtpClient מחלקה. מתודה זו מאפשרת ללקוח לקבוע אילו שיטות אימות זמינות להקמת חיבור מאובטח עם השרת. לאחר מכן, באמצעות ה‑ setAllowedAuthentication מתודה שמקבלת (או מגדירה) מונה של סוגי האימות המותרים למשתמש, בחרו במנגנון האימות המתאים ביותר לתקשורת לקוח‑שרת. מאפשר להגדיר באופן מפורש את שיטת האימות עבור לקוח הדואר.

דוגמת הקוד שלהלן מציגה כיצד להתאים אישית את אימות לקוח האימייל:

smtpClient.setAllowedAuthentication(SmtpKnownAuthenticationType.Login);

שימוש באימות CRAM‑MD5 לחיבור לשרת

כדי להבטיח אימות ותקשורת בטוחה עם שרת ה‑SMTP, ניתן לציין ולאכוף את השימוש ב‑CRAM‑MD5 כשיטת אימות המותרת ללקוח ה‑SMTP. הקטע הקוד הבא מציג כיצד להגדיר את סוג האימות המותר עבור ה‑ SmtpClient:

smtpClient.setAllowedAuthentication(SmtpKnownAuthenticationType.CramMD5);

קישור לקוח SMTP לכתובת IP ספציפית במארח

יתכן שמארח יכיל מספר פתחות זמינות לשליחת אימיילים, ולכן לא ניתן לשלול אפשרות זאת. במקרים כאלה, ייתכן הצורך לקשר את לקוח שליחת האימייל לפורט ספציפי במארח לצורך שליחת המיילים. ניתן להשיג זאת גם באמצעות Aspose.Email API בעזרת SmtpClient bindIPEndPoint מאפיין. ה‑API SmtpClient ניתן להגדיר להשתמש בכתובת IP ספציפית במארח על ידי ציון נקודת הקצה של ה‑IP הספציפית. הקטע הקוד הבא מציג כיצד לקשר את לקוח ה‑SMTP לכתובת IP ספציפית במארח.

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

SmtpClient client = new SmtpClient("smtp.domain.com", // host
        587, // port
        "username", // username
        "password", // password
        SecurityOptions.Auto // Security Options
);
try {
    client.bindIPEndPoint(new BindIPEndPointHandler() {
        public InetSocketAddress invoke(InetSocketAddress remoteEndPoint) {
            return new InetSocketAddress(0);
        }
    });
    client.noop();
} finally {
    client.dispose();
}

אימות אישורי שרת המייל ללא שליחת אימייל

לפעמים יש צורך לאמת אישורים ללא שליחת אימייל. Aspose.Email מספקת את validateCredentials() method לביצוע פעולה זו. אם האימות מצליח, הקוד בתוך תנאי ה‑if מתבצע, בדרך כלל לשימוש לפעולות נוספות או לאחזור נתונים משרת IMAP. קטע הקוד הבא מדגים אימות של אישורים ללא שליחת אימייל:

try (SmtpClient smtpClient = new SmtpClient(
        server.SmtpUrl, server.SmtpPort, "username", "password", SecurityOptions.Auto)) {
    smtpClient.setTimeout(4000);

    if (smtpClient.validateCredentials()) {
        // to do something
    }
}

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

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

try (SmtpClient smtpClient = new SmtpClient("host", 587, "username", "password", SecurityOptions.SSLExplicit))
{
    smtpClient.setTimeout(60000); // 60 seconds

    // some code...
}

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

Mon, 01 Jan 0001 00:00:00 +0000

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

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

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

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

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

צור מופע של MailMessage class והגדר את תכונותיו.
צור מופע של SmtpClient class וציין את המארח, הפורט, שם המשתמש והסיסמה.
שלח את ההודעה באמצעות 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, פעל לפי הצעדים הבאים:

צור מופע של MailMessage class והשתמש בתכונות השונות שלו.
צור מופע של SmtpClient class וציין את המארח, הפורט, שם המשתמש והסיסמה.
צור מופע שהוגדר על‑ידי המשתמש אשר יועבר למתודה ויינצל כאשר הפעולה האסינכרונית מסתיימת.
שלח את ההודעה באמצעות 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. או, אם אתה שולח ניוזלטר, ייתכן שתרצה לספק עותק טקסט רגיל למקבלים שבחרו לקבל גרסת טקסט רגיל. כדי לשלוח אימייל עם טקסט חלופי, עקוב אחרי הצעדים הבאים:

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

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

הוסף את המופע של ה- AlternateView מחלקה ל- MailMessage אובייקט.
צור מופע של 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 מחלקה:

צור מופע של SmtpClient מחלקה.
ציין את SmtpClient מאפייני המחלקה.
צור מופע של MailMessage מחלקה.
ציין שולח, מקבל, נושא האימייל וההודעה במופע של ה- MailMessage מחלקה.
חזור על שני הצעדים שלמעלה שוב, אם ברצונך לשלוח אימייל לאדם אחר.
צור מופע של MailMessageCollection מחלקה.
הוסף מופע של MailMessage מחלקה במופע של ה- MailMessageCollection מחלקה.
כעת שלח את האימייל שלך באמצעות ה- 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 שנשלחת באימייל| | :- | || קטע הקוד הבא מראה כיצד לשלוח בקשות דרך אימייל.

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

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

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

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

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

צור פונקציה עם חתימת שם
צור מופע של MailMessage מחלקה.
ציין את השולח, המקבל, הנושא והגוף.
צור חתימה לסיום המייל.
צור מופע של TemplateEngine מחלקה והעביר לה את MailMessage מופע.
קח חתימה ב‑ TemplateEngine מופע.
צור מופע של DataTable מחלקה.
הוסף את העמודות Receipt, FirstName ו‑LastName כמקורות נתונים ב DataTable מחלקה.
צור מופע של DataRow מחלקה.
ציין את כתובת הקבלה, שם פרטי ושם משפחה ב DataRow אובייקט.
צור מופע של MailMessageCollection מחלקה
ציין את TemplateEngine ו DataTable מופעים ב MailMessageCollection מופע.
צור מופע של SmtpClient class וציין את השרת, הפורט, שם המשתמש והסיסמה.
שלח אימיילים באמצעות 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);

Java: תכונות שירות - לקוח SMTP

Mon, 01 Jan 0001 00:00:00 +0000

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

Aspose.Email SmtpClient מאפשר לך לאחזר את הרחבות השרת שמשרת תומך בהם כגון IDLE, UNSELECT, QUOTA, וכד’. זה מסייע בזיהוי זמינות ההרחבה לפני שימוש בלקוח עבור תפקוד זה. ה getCapabilities() method מחזירה את סוגי ההרחבות הנתמכות בצורת מערך מחרוזות.

אחזור הרחבות השרת

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

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

SmtpClient client = new SmtpClient("smtp.gmail.com",587,"username","password");
client.setSecurityOptions(SecurityOptions.Auto);
String[] caps = client.getCapabilities();
for (String str:caps)
	System.out.println(str);

עבודה עם הודעה חתומה

Aspose.Email API מספקת את היכולת ליצור הודעות חתומות באמצעות תעודות. ה attachSignature שיטה של MailMessage class יכולה לשמש לחתימה על הודעה לשמירה או אפילו לשליחת ההודעה באמצעות SmtpClient.

שימו לב כי Aspose.Email for Java API תלויה ב‑Bouncy Castle לתכונות קריפטוגרפיה.

תלויות Maven של Bouncy Castle

<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.60</version>
</dependency>

<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.60</version>
</dependency>

הפעלת ספק האבטחה Bouncy Castle

import java.security.Security;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

if (Security.getProvider("BC") == null)
    Security.addProvider(new BouncyCastleProvider());

חתימה על הודעה

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

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

byte[] privateCert = Files.readAllBytes(new File("sample.pfx").toPath());
byte[] publicCert = Files.readAllBytes(new File("sample.cer").toPath());

MailMessage msg = new MailMessage("userfrom@gmail.com", "userto@gmail.com", "Signed message only", "Test Body of signed message");
MailMessage signed = msg.attachSignature(privateCert, "password");
MailMessage encrypted = signed.encrypt(publicCert, "password");
MailMessage decrypted = encrypted.decrypt(privateCert, "password");
MailMessage unsigned = decrypted.removeSignature();// The original message with proper body
MapiMessage mapi = MapiMessage.fromMailMessage(unsigned);

שימוש באופציית תעודה מנותקת

לקוחות אימייל מבוססי רשת עלולים לא להיות מסוגלים להציג את תוכן הגוף של הודעה חתומה. ניתן לטפל בכך על‑ידי ניתוק התעודה לפני שליחתה ללקוחות אימייל מבוססי רשת. דגל הניתוק במתודה העמוסה של attachSignature ניתן להשתמש בזה. אם מוגדר ל‑true, התעודה מנותקת מהאימייל ולהפך. כדי לראות את גוף ההודעה החתומה בלקוחות אינטרנט, צריך ליצור MailMessage עם חתימה מנותקת. קטע הקוד הבא מראה כיצד להשתמש באפשרות תעודה מנותקת.

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

MailMessage msg = new MailMessage("dr38445@gmail.com", "dr38445@gmail.com", "subject:Signed message only by AE", "body:Test Body of signed message by AE");
MailMessage signed = msg.attachSignature(privateCert, "password", true);
SmtpClient smtp = getSmtpClient(); //some test smtp client

smtp.send(signed);