Documentation – מאמרים טכניים

Java: הבחנה בין קבצים מצורפים משולבים (Inline) לרגילים

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

הודעות דוא"ל עשויות להכיל תמונות משולבות (inline) וכן קבצים מצורפים. באמצעות MailMessage, הקבצים המצורפים המשולבים ניתנים לחילוץ מתוך ה‑ LinkedResourceCollection אוסף, בעוד שהקבצים המצורפים הרגילים נגישים וניתנים לחילוץ עם ה‑ AttachmentCollection אוסף. עם זאת, זה שונה כאשר ההודעה נטענת באמצעות MapiMessage, שכן כל התמונות המשולבות והקבצים המצורפים הרגילים נגישים למשתמש באותו MapiAttachmentCollection. ולכן, שיטה שיכולה להבדיל בין קובץ מצורף משולב (inline) לקובץ רגיל כאשר MapiMessage נעשה שימוש נדרש.

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

גוף טקסט פשוט: הודעות דוא"ל עם גוף טקסט פשוט אינן דורשות בדיקה, מאחר שכל הקבצים המצורפים באותן הודעות הם תמיד קבצים רגילים.
גוף HTML: עבור הודעות עם גוף HTML, הקובץ המצורף צריך להכיל לא רק את המאפיין PR_ATTACH_FLAGS (0x37140003), אלא ערכו צריך להיות שווה ל‑0x00000004 עבור קבצים מצורפים משולבים. אם תנאי זה מתקיים, הוא תלוי בנוסף בתגים PR_ATTACH_CONTENT_LOCATION ו‑PR_ATTACH_CONTENT_ID כדי לקבוע את טבע הקובץ המצורף. עם זאת, בהעדר תג MAPI PR_ATTACH_FLAGS, הקובץ נבדק עבור המאפיין PR_ATTACH_DISPOSITION (0x3716001F או 0x3716001E) כדי לקבוע את סוג הקובץ המצורף.
גוף RTF: אם הגוף הוא RTF, אז כל קבצי ה‑OLE הם קבצים מצורפים משולבים. ערך PR_ATTACH_METHOD לכל קבצי ה‑OLE שווה ל‑0x00000006.

דוגמת הקוד הבאה מציגה כיצד להבדיל באופן תכנותי בין קבצים מצורפים משולבים וקבצים רגילים. הפונקציה isInlineAttachment מקבלת קובץ מצורף ו‑MapiMessage כפרמטרי קלט ומחזירה true אם הקובץ המצורף הוא משולב.

public static boolean isInlineAttachment(MapiAttachment att, MapiMessage msg) {
    if (msg.getBodyType() == BodyContentType.PlainText)
        // ignore indications for plain text messages
        return false;
    else if (msg.getBodyType() == BodyContentType.Html) {
        // check the PidTagAttachFlags property
        Long attachFlagsValue = att.getPropertyLong(MapiPropertyTag.PR_ATTACH_FLAGS);
        if (attachFlagsValue != null && (attachFlagsValue > 3 || attachFlagsValue < 1)) {
            // check PidTagAttachContentId property
            String contentId = att.getProperties().containsKey(MapiPropertyTag.PR_ATTACH_CONTENT_ID)
                    ? att.getPropertyString(MapiPropertyTag.PR_ATTACH_CONTENT_ID)
                    : att.getPropertyString(MapiPropertyTag.PR_ATTACH_CONTENT_ID_W);
            if (contentId != null && !contentId.isEmpty() && msg.getBodyHtml().contains("cid:" + contentId)) {
                return true;
            }
            // check PidTagAttachContentLocation property
            String contentLocation = att.getProperties().containsKey(MapiPropertyTag.PR_ATTACH_CONTENT_LOCATION)
                    ? att.getPropertyString(MapiPropertyTag.PR_ATTACH_CONTENT_LOCATION)
                    : att.getPropertyString(MapiPropertyTag.PR_ATTACH_CONTENT_LOCATION_W);
            if (contentLocation != null && !contentLocation.isEmpty() && msg.getBodyHtml().contains(contentLocation)) {
                return true;
            }
        }
        return "inline".equals(att.getPropertyString(0x3716001F)) || "inline".equals(att.getPropertyString(0x3716001E));
    } else if (msg.getBodyType() == BodyContentType.Rtf) {
        // If the body is RTF, then all OLE attachments are inline attachments.
        // OLE attachments have 0x00000006 for the value of the PidTagAttachMethod property
        Long attachMethod = att.getPropertyLong(MapiPropertyTag.PR_ATTACH_METHOD);
        return attachMethod != null && attachMethod == 0x00000006;
    } else {
        throw new ArgumentOutOfRangeException();
    }
}

קטע קוד זה משתמש בפונקציה isInlineAttachment() להערכת קבצים מצורפים.

Java

String fileName = ("Sample.msg");
MapiMessage message = MapiMessage.fromFile(fileName);
MapiAttachmentCollection attachments = message.getAttachments();
for (int i = 0; i < attachments.size(); i++) {
    MapiAttachment attachment = (MapiAttachment) attachments.get(i);
    if (isInlineAttachment(attachment, message)) {
        System.out.println(attachment.getLongFileName() + " is inline attachment");
    } else {
        System.out.println(attachment.getLongFileName() + " is regular attachment");
    }
}

Java: זיהוי והוצאת קובץ מצורף משובץ מקובץ MSG בפורמט RTF

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

הודעות דוא"ל עם גוף בפורמט RTF עשויות להכיל קבצים מצורפים משולבים שיכולים להיות משובצים כאובייקט שלם או כסמל. כדי להבדיל בין שני סוגי הקבצים המצורפים, יש לבדוק תחילה כמה מאפיינים של הקובץ המצורף. לאחר עמידה בקריטריונים מסוימים בהתבסס על מאפייני הקובץ, ניתן לשמור את הקובץ על‑ידי חילוצו מ‑ObjectData שלו.

מאמר זה מזהה ומוציא קובץ מצורף משובץ מקובץ MSG בפורמט RTF.

Java


   static void ExtractInlineAttachments()

  {

        MapiMessage message = MapiMessage.fromFile("Test.msg");

    MapiAttachmentCollection attachments = message.getAttachments();

    for (Object untypedAttachment : attachments)

    {

          MapiAttachment attachment = (MapiAttachment) untypedAttachment;

          if(IsAttachmentInline(attachment))

          {

                try

                {

                      SaveAttachment(attachment, UUID.randomUUID().toString());

                }

                catch (IOException | FileNotFoundException e)

                {

                      // TODO Auto-generated catch block

                          e.printStackTrace();

                    }

              }

        }

  }

  static boolean IsAttachmentInline(MapiAttachment attachment)

  {

        MapiObjectProperty objectData = attachment.getObjectData();

        if (objectData == null)

              return false;

        for (Object prop : attachment.getObjectData().getProperties().getValues())

        {

              MapiProperty property = (MapiProperty)prop;

              if ("\u0003ObjInfo".equals(property.getName()))

              {

                    byte[] data = property.getData();

                    int odtPersist1 = data[1] << 8 | data[0];

                    return (odtPersist1 & 0x40) == 0;

              }

        }

        return false;

  }

  static void SaveAttachment(MapiAttachment attachment, String fileName) throws IOException, FileNotFoundException

  {

        for (Object prop : attachment.getObjectData().getProperties().getValues())

        {

              MapiProperty property = (MapiProperty)prop;

              if ("Package".equals(property.getName()))

          {

                FileOutputStream fs;

                try

                {

                      fs = new FileOutputStream(fileName);

                      fs.write(property.getData(), 0, property.getData().length);

                }

                catch (java.io.IOException e)

                {

                      // TODO Auto-generated catch block

                          e.printStackTrace();

                    }

              }

        }

  }

Java: שמירת קובץ MSG כ‑PDF

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

מאמר זה מציג כיצד להמיר הודעת דוא"ל ל‑PDF באמצעות Aspose.Email. Aspose.Email for Java מטפל בתכונות של Microsoft Outlook, ולא יכול לבצע המרה ישירה ל‑PDF. כדי להתגבר על זאת, הדוגמאות במאמר משתמשות ב‑Aspose.Email כדי להמיר את הודעת הדוא"ל ל‑זרם MHTML ולאחר מכן משתמשים ב‑Aspose.Words for Java כדי לטעון את זרם ה‑MHTML ולשמור אותו כ‑PDF.

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

המרת הודעת דוא"ל ל‑PDF

הקוד הבא מציג המרה של הודעת דוא"ל ל‑PDF באמצעות Aspose.Email בשילוב עם Aspose.Words for Java. פעולה זו כוללת את השלבים הבאים:

טען את הודעת הדוא"ל באמצעות MailMessage
שמור את הודעת הדוא"ל ל‑MemoryStream כ‑MHTML
טען את הזרם באמצעות Aspose.Words
שמור את ההודעה כ‑PDF

הודעת הדוא"ל המקורית נראית כך:

|| | :- | |דמות: קובץ MSG מקור |

|| | :- | |דמות: קובץ PDF מומר | Java


 static void EmailToPdf(String emailPath) throws Exception

{

       FileInputStream fstream=new FileInputStream(emailPath);

       MailMessage eml = MailMessage.load(fstream);

       //Save the Message to output stream in MHTML format

       ByteArrayOutputStream emlStream = new ByteArrayOutputStream();

       eml.save(emlStream, SaveOptions.getDefaultMhtml());

       //Load the stream in Word document

       LoadOptions lo = new LoadOptions();

       lo.setLoadFormat(LoadFormat.MHTML);

       Document doc = new Document(new ByteArrayInputStream(emlStream.toByteArray()), lo);

       //Save to disc

       doc.save("About Aspose.Pdf", SaveFormat.PDF);

       //or Save to stream

       ByteArrayOutputStream foStream = new ByteArrayOutputStream();

       doc.save(foStream, SaveFormat.PDF);

}

Java: מאגר חיבורים שוחזר

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

עם השחרור של Aspose.Email 19.3, מאגר החיבורים שוחזר. חדש EmailClient מחלקה הוצגה שתחליף בסופו את CredentialsByHostClient מחלקה. ה- EmailClient מחלקה מספקת ConnectionAsgmtMode מאפיין שמגדיר את מצב הקצאת החיבורים בסביבה מרובת תהליכים. EmailClient.ConnectionAsgmtMode מתוגדר באמצעות ConnectionAsgmtType enumerable.

סוגי חיבורים

הקיימים שלושה סוגי חיבורים הבאים:

החיבור הראשי: זהו החיבור שנוצר ונפטר יחד עם לקוח הדואר. לא ניתן ליצור או לפטר אותו ידנית.
חיבור ברירת מחדל: המשתמש יכול ליצור חיבורים ברירת מחדל לתילים עם CreateConnection מתודה. אם חיבור ברירת מחדל קיים, כל המתודות של לקוח הדוא"ל המבוצעות בתיל ישתמשו במרומז בחיבור זה. רק חיבור ברירת מחדל אחד יכול להתקיים לכל תיל. הוא יכול להיווצר ידנית או אוטומטית. זה תלוי במאפיין EmailClient.ConnectionAsgmtMode. חיבורים אלו ניתן ליצור ידנית באמצעות EmailClient.CreateConnection(createAsDefaultConnection = true) מתודה. אם חיבור ברירת המחדל אינו משמש (תלוי במצב הקצאת חיבור), החיבור הראשי משמש במרומז במקום זאת.
חיבורים עצמאיים: אלו חיבורים שאינם מקושרים לתילים. ניתן ליצור אותם ידנית וחייבים להשתמש בהם במפורש כפרמטר למתודה. חיבורים אלו ניתן ליצור ידנית באמצעות EmailClient.CreateConnection() מתודה או EmailClient.CreateConnection(createAsDefaultConnection = false) שיטה.

סוגי הקצאת חיבור

כדי להגדיר את ה‑ EmailClient.ConnectionAsgmtMode מאפיין, ConnectionAsgmtType ה‑enumerable משמש. סוגי ההקצאה שמסופקים על ידי ConnectionAsgmtType מופיעים למטה.

ConnectionAsgmtType.UseMainOrDefault מצב זה משמש כברירת מחדל בלקוחות דוא"ל. לקוח הדוא"ל משתמש בחיבור הראשי לכל הפעולות מכמה תילים אם חיבור ברירת מחדל לא נוצר, או אם חיבור לא נמסר במפורש כפרמטר למתודה. החיבור הראשי הוא חיבור שנוצר יחד עם לקוח הדוא"ל. המשתמש יכול ליצור חיבורי ברירת מחדל לתילים עם CreateConnection מתודה. אם חיבור ברירת מחדל לתיל נוצר, הוא משמש במרומז לכל המתודות של לקוח הדוא"ל שמוזמנות בתיל זה. אם חיבור ברירת מחדל לתיל אינו נוצר, החיבור הראשי משמש לכל המתודות של לקוח הדוא"ל שמוזמנות בתיל זה. המשתמש גם יכול ליצור חיבורים שאינם מקושרים לתילים (לא חיבורי ברירת מחדל) באמצעות CreateConnection מתודה. אם המשתמש רוצה להשתמש בחיבורים אחרים (לא הראשי ולא ברירת המחדל) עליו להעביר חיבור זה במפורש כפרמטר של מתודה שהוא רוצה להשתמש בו. המשתמש יכול בנוסף ליצור כל מספר של חיבורים. חיבור ברירת מחדל יכול להיות רק אחד לכל תיל. יש לשים לב שחיבורי ברירת מחדל פועלים כראוי אם המשתמש משתמש באובייקטי Thread לתכנות מרובה משימות. אם המשתמש משתמש ב‑ConnectionPool או באובייקטי Task לתכנות מרובה משימות, מצב זה עלול להוביל להתנהגות שגויה של האפליקציה. כדי למנוע בעיה זו, על המשתמש לפרק ידנית את חיבור ברירת המחדל (אם הוא משתמש בו) בסיום ביצוע הקוד.
ConnectionAsgmtType.UseMain לקוח הדוא"ל משתמש בחיבור הראשי לכל הפעולות מכמה תילים. החיבור הראשי הוא חיבור שנוצר יחד עם לקוח הדוא"ל. המשתמש לא יכול ליצור חיבורי ברירת מחדל. המשתמש יכול ליצור חיבורים שאינם מקושרים לתילים (לא חיבורי ברירת מחדל) באמצעות CreateConnection מתודה. אם המשתמש רוצה להשתמש בחיבורים אחרים (לא הראשי ולא ברירת המחדל) עליו להעביר חיבור זה במפורש כפרמטר של מתודה שהוא מעוניין להשתמש בו.
ConnectionAsgmtType.UseDefault לקוח הדוא"ל משתמש במרומז רק בחיבורי ברירת מחדל לכל הפעולות מכמה תילים. חיבור ראשי אינו משמש במצב זה. אם חיבור ברירת מחדל לא נוצר עבור תיל מסוים (קריאה ראשונה למתודת לקוח הדוא"ל), לקוח הדוא"ל יוצר חיבור ברירת מחדל באופן מרומז עבור התיל לפני שהפעולה הראשונה מתבצעת. המשתמש אינו יכול ליצור חיבורי ברירת מחדל לתילים עם CreateConnectionמתודה מכיוון שהם נוצרים אוטומטית. כאשר חיבור ברירת מחדל לתיל נוצר, הוא משמש במרומז לכל המתודות של לקוח הדואר שמוזמנות בתיל זה. המשתמש יכול גם ליצור חיבורים שאינם מקושרים לתילים (לא חיבורי ברירת מחדל) באמצעות CreateConnectionמתודה. אם המשתמש רוצה להשתמש בחיבורים אחרים (לא הראשי ולא ברירת המחדל) עליו להעביר חיבור זה בפורמט מפורש כפרמטר של המתודה שהוא רוצה להשתמש בה. למשתמש ניתן additionally ליצור כל מספר של חיבורים. רק חיבור ברירת מחדל אחד יכול לשמש לכל תרחיש. יש לשים לב שחיבורי ברירת מחדל פועלים כראוי אם המשתמש משתמש באובייקטי Thread לתכנות מרובה משימות. אם המשתמש משתמש ב‑ConnectionPool או באובייקטי Task לתכנות מרובה משימות, מצב זה עלול להוביל להתנהגות שגויה של האפליקציה. כדי למנוע בעיה זו, על המשתמש לפרק ידנית את חיבור ברירת המחדל בסיום ביצוע הקוד.

Java: תמיכה בקביעת Locale לתהליך הנוכחי

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

Aspose.Email מספקת אפשרות לקבוע את ה‑Locale עבור התהליך הנוכחי. Aspose.Email מספקת מחלקה CurrentThreadSettings שמספקת את setLocale מתודה למטרה זו. קטע הקוד הבא מדגים את השימוש ב‑ CurrentThreadSettings מחלקה לקביעת ה‑Locale הנוכחי. הקטע מציב תחילה את ה‑Locale לערך בלתי חוקי ולאחר מכן משתמש ב‑ CurrentThreadSettings.setLocale מתודה לקביעת ה‑Locale לתהליך הנוכחי.

Locale defaultLocale = Locale.getDefault();
try {
    // set incorrect default Locale
    Locale.setDefault(new Locale("en", "RU"));
    // set Current Thread Locale
    CurrentThreadSettings.setLocale("en-US");
    // or
    // CurrentThreadSettings.setLocale(new Locale("en", "US"));

    PersonalStorage.create(dataDir + "test.pst", FileFormatVersion.Unicode);
} finally {
    Locale.setDefault(defaultLocale);
}

Java: פרטים חשובים של iCalendar RFC 2445

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

על מודל האובייקטים iCalendar של Aspose

ה‑Aspose.Email מכילה את כל המחלקות שסופקו על‑ידי Aspose iCalendar רכיב RecurrencePattern ו RecurrenceRule הן המחלקות המרכזיות של Aspose iCalendar, ולספק מימושים קונקרטיים של אלמנטים מתאימים מ‑RFC 2445.

ה RecurrencePattern המחלקה מייצגת את כל תבנית החזרתיות. ניתן ליצור תבנית חזרתיות חדשה מאפס באמצעות בנאי ברירת המחדל או לטעון תבנית קיימת ב‑ CalendarRecurrence. ה RecurrenceRule המחלקה מייצגת את חלק ה‑RRULE או EXRULE של תבנית חזרתיות. RecurrenceRule חשוף מספר מאפיינים המתאימים במדויק למקבילים שלהם בתקן iCalendar. לדוגמה, ByMonth ממופה ל‑BYMONTH ב‑iCalendar וכן הלאה. על ידי בחינת או קביעת ערכים של ה‑ RecurrenceRule מאפיינים שבהם ניתן לנתח או לשנות כלל חזרתיות. למידע נוסף ודוגמאות קוד, ראה RecurrencePattern ו RecurrenceRule בהפניות ה‑API.

פרטים חשובים של iCalendar RFC 2445

מקטע זה כולל את הנושאים הבאים:

תבניות תאריך וזמן.
DATE.
DATE‑TIME עם זמן מקומי.
DATE‑TIME עם זמן UTC.
DATE‑TIME עם זמן מקומי ואזור זמן.
BYWEEKNO מספק התאמה ל‑ISO 8601

תבניות תאריך וזמן

תאריכים, או תאריכים עם זמנים משוייכים, ניתן להשתמש בהם ברכיבי DTSTART, UNTIL, EXDATE ו‑RDATE בעת הצגת תבנית חזרתיות. iCalendar מגדיר את סוג הערך DATE לזיהוי ערכים המורכבים מתאריך לוח שנה וכן מגדיר את סוג הערך DATE‑TIME לזיהוי ערכים המצביעים על תאריך לוח שנה מדויק וזמן ביום. ערכי DATE‑TIME יכולים להיות מפורטים בשלוש צורות, עם:

זמן מקומי.
זמן UTC.
זמן מקומי ואזור זמן.

DATE

לפי תקן iCalendar, ערכי DATE חייבים להיות בפורמט yyyyMMdd. הדוגמה הבאה מייצגת 14 ביולי 1997: 19970714

DATE‑TIME עם זמן מקומי

התאריך בצורת זמן מקומי הוא פשוט ערך תאריך‑זמן שאינו מכיל את מעצב ה‑UTC, ואינו מתייחס לאזור זמן. לדוגמה, הבא מייצג 18 בינואר 1998, בשעה 23:00: DTSTART:19980118T230000. ערכי תאריך‑זמן מסוג זה נקראים "צפים" ולא קשורים לאזור זמן מסוים. הם משמשים לייצוג אותו שעה, דקות ושניות ללא תלות באיזור הזמן שנצפה כרגע.

DATE‑TIME עם זמן UTC

התאריך עם זמן UTC, או זמן מוחלט, מזוהה באמצעות תו האות הגדולה הלטינית Z כסיומת, המעיד על UTC, המצורף לערך הזמן. לדוגמה, הבא מייצג 19 בינואר 1998, בשעה 07:00 UTC: DTSTART:19980119T070000Z. שים לב ש‑Aspose iCalendar מתעלם מהסיומת Z של פורמט UTC ומתנהג כאילו הזמן הוא זמן מקומי. תקן RFC2445 קובע שהחלק זמן המצויין בכלל UNTIL של תבנית חזרתיות חייב להיות בפורמט UTC. זוהי הצהרה מוזרה מאוד, ובפועל קיימים בדוגמאות בתקן חישובים שגויים. Aspose iCalendar מקבל זמן בכל פורמט בכלל UNTIL.

DATE‑TIME עם זמן מקומי ואזור זמן

להתייחס לאזור הזמן, משנים את DATE‑TIME בעזרת הפרמטר TZID. לדוגמה, הבא מייצג 2 לפנה״צ בניו יורק ב‑19 בינואר 1998: DTSTART;TZID=US-Eastern:19980119T020000. שים לב ש‑Aspose iCalendar בזמן זה מתעלם מפרמטר TZID ומתנהג כאילו הזמן הוא זמן מקומי.

BYWEEKNO מספק התאמה ל‑ISO 8601

השתמש ב‑BYWEEKNO רק כאשר יש צורך בהתאמה ל‑ ISO 8601 נדרש. מספרי שבוע כפי שמוגדרים ב‑ISO 8601 שונים מאוד ממספרי שבוע במשמעות הרגילה. לפי ISO 8601, מספר שבוע ראשון של שנת הלוח הוא השבוע הראשון של השנה שמכיל לפחות ארבעה ימים. כלל זה עושה את האלגוריתם ספציפי ליישומים הדורשים התאמה ל‑ISO 8601 ומקשה מאוד על שימושים אחרים. ISO 8601 נתמך על‑ידי כמה אפליקציות בנקאיות ופיננסיות באירופה. הוא משמש גם בטלוויזיה לתזמון פרסומות. כלל BYWEEKNO מציין רשימה מופרדת בפסיקים של מספרים המזהים שבועות של השנה. ערכים תקינים הם 1 עד 53 ו‑1 עד 53. זה תואם לשבועות לפי מספור שבוע כפי שמוגדר ב‑ISO 8601. BYWEEKNO תקף רק לכללים שנתיים.

Java: ניתוח קבצי הודעות של Microsoft Outlook

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

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

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

קטע הקוד הבא מראה איך לנתח קבצי הודעות של Microsoft Outlook.

// The path to the File directory and Load Microsoft Outlook email message file
String dataDir = "data/";
MapiMessage msg = MapiMessage.fromFile(dataDir + "message3.msg");

// Obtain subject of the email message, sender, body and Attachment count
System.out.println("Subject:" + msg.getSubject());
System.out.println("From:" + msg.getSenderName());
System.out.println("Body:" + msg.getBody());
System.out.println("Attachment Count:" + msg.getAttachments().size());

// Iterate through the attachments
for (MapiAttachment attachment : msg.getAttachments()) {
    // Access the attachment's file name and Save attachment
    System.out.println("Attachment:" + attachment.getFileName());
    attachment.save(dataDir + attachment.getLongFileName());
}

Java: קבלת הודעות על הודעות שנשלחו בהצלחה וכאלו שנכשלו

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

כאשר ברצונך לקבל את הודעת האספקה הן עבור הודעות שנשלחו בהצלחה והן עבור אלו שנכשלו, ניתן להשתמש באופרטור הפייפ (|) עבור ה‑ DeliveryNotificationOptions מאפיין של MailMessage המחלקה. קטע הקוד הבא מראה כיצד לקבל הודעות על הודעות שנשלחו בהצלחה וכאלו שנכשלו.

// Create the message
MailMessage msg = new MailMessage();
msg.setFrom(MailAddress.to_MailAddress("sender@sender.com"));
msg.setTo(MailAddressCollection.to_MailAddressCollection("receiver@receiver.com"));
msg.setSubject("the subject of the message");

// Set delivery notifications for success and failed messages and Add the MIME headers
msg.setDeliveryNotificationOptions(DeliveryNotificationOptions.OnSuccess | DeliveryNotificationOptions.OnFailure);
msg.getHeaders().add("Read-Receipt-To", "sender@sender.com");
msg.getHeaders().add("Disposition-Notification-To", "sender@sender.com");

// Send the message
SmtpClient client = new SmtpClient("host", "username", "password");
client.send(msg);

Java: זיהוי הודעות דוא"ל חדשות בשרת POP3

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

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

קרא את כל ההודעות משרת הדוא"ל POP3 באמצעות Aspose.Email.
הורד את ההודעות למסד הנתונים המקומי שלך.

ההודעות אינן נמחקות אלא נשארות בשרת. בפעם הראשונה שהפעולה רצה, התהליך עובד תקין. כל ההודעות הדרושות מורדות למסד הנתונים. אך בפעם השנייה שהפעולה רצה, אותן הודעות מורדות שוב מכיוון שהן עדיין על שרת הדוא"ל. זה גורם לרשומות משוכפלות. כדי לפתור בעיה זו, השתמש ב‑ Pop3MessageInfo.UniqueID מאפיין לבדיקת האם הודעה כבר הורדה. יש לאחסן את המזהה הייחודי של ההודעה במסד הנתונים: הוא המפתח לחיפוש לצורך זיהוי הודעות חדשות.

זיהוי הודעות חדשות

כדי לזהות הודעות דוא"ל חדשות מרשימת הודעות בשרת POP3:

התחבר לשרת.
קבל רשימת הודעות.
התחבר למסד הנתונים.
קבל רשימת הודעות.
השווה את הרשימות.
שמור הודעות חדשות למסד הנתונים.

התהליך מהיר יותר כאשר אתה:

הורד את כל המזהים הייחודיים של ההודעות לטבלת האש.
חפש בטבלת האש במקום בבסיס הנתונים עבור כל הודעת דוא"ל בלולאת for(…).

במקום לבצע שאילתת מסד נתונים עבור כל הודעה, הדורשת קריאות מרובות, מתודה זו דורשת קריאה אחת בלבד. קטע הקוד הבא מראה כיצד לזהות הודעות דוא"ל חדשות על שרת POP3.

public static void run() {
    try {
        // Connect to the POP3 mail server and check messages.
        Pop3Client pop3Client = new Pop3Client("pop.domain.com", 993, "username", "password");

        // List all the messages
        Pop3MessageInfoCollection msgList = pop3Client.listMessages();
        for (Pop3MessageInfo msgInfo : msgList) {
            // Get the POP3 message's unique ID
            String strUniqueID = msgInfo.getUniqueId();

            // Search your local database or data store on the unique ID. If a match is found, that means it's already downloaded. Otherwise download and save it.
            if (searchPop3MsgInLocalDB(strUniqueID) == true) {
                // The message is already in the database. Nothing to do with this message. Go to next message.
            } else {
                // Save the message
                savePop3MsgInLocalDB(msgInfo);
            }
        }
    } catch (Exception ex) {
        System.err.println(ex);
    }

}

private static void savePop3MsgInLocalDB(Pop3MessageInfo msgInfo) {
    // Open the database connection according to your database. Use public properties (for example msgInfo.Subject) and store in database,
    // for example, " INSERT INTO POP3Mails (UniqueID, Subject) VALUES ('" + msgInfo.UniqueID + "' , '" + msgInfo.Subject + "') and Run the query to store in database.
}

private static boolean searchPop3MsgInLocalDB(String strUniqueID) {
    // Open the database connection according to your database. Use strUniqueID in the search query to find existing records,
    // for example, " SELECT COUNT(*) FROM POP3Mails WHERE UniqueID = '" + strUniqueID + "' Run the query, return true if count == 1. Return false if count == 0.
    return false;
}

Java: קביעת קידוד טקסט ברירת מחדל בהודעת דוא"ל

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

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

מאת: שם תצוגה
אל: שם תצוגה
נושא
גוף

קביעת קידוד טקסט ברירת מחדל

בגרסאות קודמות של Aspose.Email, קידוד הטקסט עבור תכונות from, to, subject ו‑body קבוע בנפרד. כדי לשפר את השימושיות, הוספנו את PreferredTextEncoding מאפיין שמגדיר הכל בבת אחת. כעת קל יותר להבטיח שכל הטקסט בתכונות שלמעלה מקודד כראוי בהודעת הדוא"ל. קטע הקוד הבא מראה כיצד להשתמש במילה בצרפתית כשם תצוגה עבור כתובות הדוא"ל, הנושא והגוף.

// Create an instance of MailMessage
String fileName = "data/";
MailMessage msg = new MailMessage();

// Set the default or preferred encoding. This encoding will be used as the default for the from/to email addresses, subject and body of message.
msg.setPreferredTextEncoding(Charset.forName("cp1252"));

// Set email addresses, subject and body
msg.setFrom(new MailAddress("dmo@domain.com", "démo"));
msg.getTo().addItem(new MailAddress("dmo@domain.com", "démo"));
msg.setSubject("démo");
msg.setHtmlBody("démo");
msg.save(fileName + "SetDefaultTextEncoding_out.msg", SaveOptions.getDefaultMsg());

Java: המרת קובץ הודעת Outlook (MSG) לתמונת TIFF

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

המרת קובץ MSG של Outlook לתמונת TIFF אינה נתמכת ב‑Aspose.Email for Java.

Java: שימוש במסמך Microsoft Word כגוף ההודעה ושליחת אימייל

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

מאמר זה מציג כיצד להשתמש במסמך Microsoft Word כגוף ההודעה ולאפשר שליחה למקבלים. המסמך לדוגמה הוא חשבונית מכירה ממסד הנתונים Northwind, מיוצא לפורמט Microsoft Word. Aspose.Email for Java מתמודד עם פרוטוקולי רשת ותכונות של Microsoft Outlook ולא יכול לטפל במסמכי Microsoft Word. כדי להתגבר על כך, הדוגמאות במאמר זה משתמשות Aspose.Words for Java כדי לטעון את מסמך ה‑Word ולהמירו לפורמט MHTML. Aspose.Email for Java משתמש במסמך MHTML בגוף האימייל.

שימוש במסמכי Microsoft Word כגוף אימייל

דוגמאות הקוד שלהלן ממחישות כיצד לשלוח מסמך Word כגוף אימייל באמצעות Aspose.Words for Java ו‑Aspose.Email for Java:

טען מסמך Microsoft Word באמצעות Aspose.Word for Java של Document מחלקה.
שמור אותו בפורמט MHTML.
טען את מסמך ה‑MHTML באמצעות Aspose.Email for Java של MailMessage מחלקה להגדרת גוף האימייל.
הגדר תכונות הודעה נוספות באמצעות שונות MailMessage תכונות ושיטות של המחלקה.
שלח את האימייל באמצעות Aspose.Email for Java של SMTPClient מחלקה.

מסמך המקור, חשבונית מכירות שיוצאה ל‑Microsoft Word מדוגמת Microsoft Northwind, ניתן לראות למטה.

כאשר ההודעה נשלחה ומתקבלת ב‑Microsoft Outlook, היא נראית כפי שמופיעה למטה.

עיצוב ה‑HTML והתמונות נשמרים כפי שהם במסמך המקור כאשר מציגים את ההודעה ב‑Outlook או בלקוח דוא״ל ברשת כמו Gmail או Hotmail. למטה מצורפת תצלום מסך של ההודעה כשפתוחה ב‑Gmail בדפדפן Chrome.

קוד הדוגמה הבא מראה כיצד להשתמש במסמך Microsoft Word כגוף הודעה ולשלוח אימייל באמצעות SmtpClient מופע של מחלקה.

// The path to the File directory
String dataDir = "data/";

// Load a Word document from disk and save it to stream as MHTML
Document wordDocument = new Document(dataDir + "Test.doc");
ByteArrayOutputStream mhtmlStream = new ByteArrayOutputStream();
wordDocument.save(mhtmlStream, SaveFormat.MHTML);

// Load the MHTML in a MailMessage object
MailMessage message = MailMessage.load(new ByteArrayInputStream(mhtmlStream.toByteArray()), new MhtmlLoadOptions());
message.setSubject("Sending Invoice in Email");
message.setFrom(new MailAddress("sender@gmail.com"));
message.setTo(MailAddressCollection.to_MailAddressCollection("recipient@gmail.com"));

// Save the message in MSG format to disk
message.save(dataDir + "WordDocAsEmailBody_out.msg", SaveOptions.getDefaultMsgUnicode());

    // Send the email message
try (SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "sender@gmail.com", "pwd")) {
    client.setSecurityOptions(SecurityOptions.SSLExplicit);
    client.send(message);
}

Java: תכונות הדפסה של Aspose.Email

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

תכונות הדפסה

ה‑תכונות ההדפסה אינן נתמכות ב‑Aspose.Email עבור Java.

Java: יצירת אירועים מתבנית חזרה

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

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

חשב את המופע הבא או n מופעים הבאים

כדי לקבל את המופע "הזה" הבא, השתמשו במתודה GenerateOccurrences עם הפרמטר nNextOccurrences = 1. הקטע הקוד הבא מראה כיצד ליצור 20 מופעים באמצעות nNextOccurrences = 20. הפלט של הקוד למטה הוא כדלקמן:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

CalendarRecurrence recurrencePattern = new CalendarRecurrence();

recurrencePattern.setStartDate(sdf.parse("1997-09-10 09:00:00"));
RecurrenceRule rule = recurrencePattern.getRRules().add();
rule.setFrequency(Frequency.Monthly);
rule.setCount(20);
rule.setInterval(18);
rule.getByMonthDay().add(new int[] { 10, 11, 12, 13, 14, 15 });
DateCollection expectedDates = recurrencePattern.generateOccurrences(20);
System.out.println("expectedDates.Count = " + expectedDates.size());
for (int i = 0; i < expectedDates.size(); i++) {
    System.out.println("DateTime = " + sdf.format(expectedDates.getItem(i)));
}

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

ניתן לקבל טקסט ידידותי למשתמש עבור כלל באמצעות המאפיין FriendlyText כפי שמוצג למטה. פלט הקוד יהיה: "מתרחש בכל חודש ביום הראשון והאחרון של היום(ים) של החודש למקסימום של 2 אירועים.". קטע הקוד הבא מראה כיצד לקבל טקסט ידידותי למשתמש עבור חזרה.

RecurrenceRule rule = recurrencePattern.getRRules().add();
rule.setFrequency(Frequency.Monthly);
rule.setCount(2);
rule.getByMonthDay().add(1);
rule.getByMonthDay().add(-1);
System.out.println(rule.getFriendlyText());

Java: גישה לשירותי דואר באמצעות OAuth

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

תמיכת OAuth 2.0 נוספה ל‑Aspose.Email וניתן להשתמש בה לגישה לשרתים SMTP, POP3, IMAP ו‑EWS. באופן כללי, ניתן להשתמש בכל השרתים התומכים באסימוני נושא OAuth 2.0 עם Aspose.Email, אך לקוחות הדוא"ל שלנו נבדקו עם שרתי הדוא"ל של Google ושרתי Microsoft Office 365. גישה לשרת מ‑ SmtpClient, Pop3Client, ImapClient ו EWSClient עם OAuth ניתן לממש ב-2 דרכים.

ספק אסימון גישה ישירות למבנה הבנאי של לקוח הדוא"ל. במקרה זה, המשתמש צריך להבין כי חיי האסימונים מוגבלים. כאשר האסימון פג, לקוח הדוא"ל אינו יכול לשמש לגישה לשרת.
ספק מימוש מותאם אישית של ספק אסימונים המבוסס על ITokenProvider ממשק למבנה הבנאי של לקוח הדוא"ל. במקרה זה, הלקוח בודק את זמן תפוגת האסימונים ומבקש ITokenProvider לקבלת אסימון גישה חדש כאשר הקודם פג תוקף. בצורה זו, הלקוח מרענן אסימונים באופן מחזורי ויכול לעבוד עם השרת לזמן בלתי מוגבל. בדרך כלל שירותים תומכים בדרך פשוטה לחדש אסימוני גישה. לדוגמה, שימוש באסימוני רענון בשירותי Google או זרימת אימות ROPC בפלטפורמת הזהות של Microsoft עשויים לשמש למימוש ספק אסימונים.

הגדרת חשבון על השרת המתאים

המאמרים הבאים עוזרים לכם להגדיר חשבונות לגישה לשירותי דואר.

ל Office 365
ל Gmail

גישה לשירותי דואר עם אסימוני גישה

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

// Connecting to SMTP server
try (SmtpClient client = new SmtpClient(
        "smtp.gmail.com",
        587,
        "user1@gmail.com",
        "accessToken",
        true,
        SecurityOptions.SSLExplicit)) {

}

// Connecting to IMAP server
try (ImapClient client = new ImapClient(
        "imap.gmail.com",
        993,
        "user1@gmail.com",
        "accessToken",
        true,
        SecurityOptions.SSLImplicit)) {

}

// Connecting to POP3 server
try (Pop3Client client = new Pop3Client(
        "pop.gmail.com",
        995,
        "user1@gmail.com",
        "accessToken",
        true,
        SecurityOptions.Auto)) {

}

גישה לשירותי דואר עם ספקי אסימונים

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

ITokenProvider tokenProvider = TokenProvider.Google.getInstance(
        "ClientId",
        "ClientSecret",
        "RefreshToken");

// Connecting to SMTP server
try (SmtpClient client = new SmtpClient(
        "smtp.gmail.com",
        587,
        "user1@gmail.com",
        tokenProvider,
        SecurityOptions.SSLExplicit)) {

}

// Connecting to IMAP server
try (ImapClient client = new ImapClient(
        "imap.gmail.com",
        993,
        "user1@gmail.com",
        tokenProvider,
        SecurityOptions.SSLImplicit)) {

}

// Connecting to POP3 server
try (Pop3Client client = new Pop3Client(
        "pop.gmail.com",
        995,
        "user1@gmail.com",
        tokenProvider,
        SecurityOptions.Auto)) {

}

מימוש של ITokenProvider מותאם אישית עבור Office 365

ניתן להשתמש במימוש ספק האסימונים למטה לגישה לשירותי הדואר של Office 365.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * Azure resource owner password credential (ROPC) token provider
 * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth-ropc
 * https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-authenticate-an-ews-application-by-using-oauth
 * https://portal.azure.com
 * https://developer.microsoft.com/en-us/graph/graph-explorer/#
 * token parser https://jwt.io
 * </p>
 */
class AzureROPCTokenProvider implements ITokenProvider {

    private static final String GRANT_TYPE = "password";

    private final String clientId;
    private final String clientSecret;
    private final String userName;
    private final String password;
    private final String tenant;
    private final String scope;

    private OAuthToken token;

    public AzureROPCTokenProvider(String tenant, String clientId, String clientSecret,
                                  String userName, String password, String[] scopeAr) {
        this.tenant = tenant;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.userName = userName;
        this.password = password;
        this.scope = joinToStr(scopeAr, " ");
    }

    public synchronized OAuthToken getAccessToken(boolean ignoreExistingToken) {
        if (this.token != null && !this.token.getExpired() && !ignoreExistingToken)
            return this.token;
        token = null;

        Map<String, String> tokenArgs = geToken();

        java.util.Calendar c = java.util.Calendar.getInstance();
        c.add(java.util.Calendar.SECOND, Integer.parseInt(tokenArgs.get("expires_in")));
        token = new OAuthToken(tokenArgs.get("access_token"), TokenType.AccessToken, c.getTime());
        return token;
    }

    public final OAuthToken getAccessToken() {
        return getAccessToken(false);
    }

    public void dispose() {
    }

    private String getEncodedParameters() {
        return "client_id=" + urlEncode(clientId) + "&scope=" + urlEncode(scope) + "&username=" + urlEncode(userName)
                + "&password=" + urlEncode(password) + "&grant_type="
                + urlEncode(GRANT_TYPE);
    }

    private String getUri() {
        if (tenant == null || tenant.trim().isEmpty())
            return "https://login.microsoftonline.com/common/oauth2/v2.0/token";
        else
            return "https://login.microsoftonline.com/" + tenant + "/oauth2/v2.0/token";
    }

    private Map<String, String> geToken() {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL(getUri()).openConnection();
            connection.setRequestMethod("POST");

            byte[] requestData = getEncodedParameters().getBytes(StandardCharsets.UTF_8);

            connection.setUseCaches(false);
            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", "" + requestData.length);

            final OutputStream st = connection.getOutputStream();
            try {
                st.write(requestData, 0, requestData.length);
            } finally {
                st.flush();
                st.close();
            }

            connection.connect();

            if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
                throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" +
                        connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
                        + readInputStream(connection.getErrorStream()));
            }

            String responseText = readInputStream(connection.getInputStream());

            Map<String, String> result = new HashMap<>();
            String[] fromJsonToKeyValue = responseText.replace("{", "").replace("}", "")
                    .replace("\"", "").replace("\r", "")
                    .replace("\n", "").split(",");
            for (String keyValue : fromJsonToKeyValue) {
                String[] pair = keyValue.split(":");
                String name = pair[0].trim().toLowerCase();
                String value = urlDecode(pair[1].trim());
                result.put(name, value);
            }

            return result;
        } catch (IOException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlDecode(String value) {
        try {
            return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String readInputStream(InputStream is) {
        if (is == null)
            return "";

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder result = new StringBuilder();
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
        } catch (IOException e) {
            // ignore
        }
        return result.toString();
    }

    static String joinToStr(String[] arr, String sep) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i > 0)
                sb.append(sep);
            sb.append(arr[i]);
        }
        return sb.toString();
    }
}

דוגמאות הקוד הבאות מראות כיצד להתחבר לשירותי Office 365 באמצעות ספק האסימונים המותאם אישית.

ITokenProvider tokenProvider = new AzureROPCTokenProvider(
        "Tenant",
        "ClientId",
        "ClientSecret",
        "EMail",
        "Password",
        scopes);

// Connecting to SMTP server
try (SmtpClient client = new SmtpClient(
        "smtp.office365.com",
        587,
        "Test1@test.onmicrosoft.com",
        tokenProvider,
        SecurityOptions.SSLExplicit)) {

}

// Connecting to IMAP server
try (ImapClient client = new ImapClient(
        "outlook.office365.com",
        993,
        "Test1@test.onmicrosoft.com",
        tokenProvider,
        SecurityOptions.SSLImplicit)) {

}

// Connecting to POP3 server
try (Pop3Client client = new Pop3Client(
        "outlook.office365.com",
        995,
        "Test1@test.onmicrosoft.com",
        tokenProvider,
        SecurityOptions.Auto)) {

}

// Connecting to EWS server
final String mailboxUri = "https://outlook.office365.com/ews/exchange.asmx";
ICredentials credentials = new OAuthNetworkCredential(tokenProvider);
try (IEWSClient ewsClient = EWSClient.getEWSClient(mailboxUri, credentials)) {

}

Java: שימוש ב-OAuth לגישה לשירותי דואר

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

ספק אסימון גישה ישירות למבנה הבנאי של לקוח הדוא"ל. במקרה זה, המשתמש צריך להבין כי חיי האסימונים מוגבלים. כאשר האסימון פג, לקוח הדוא"ל אינו יכול לשמש לגישה לשרת.
ספק מימוש מותאם אישית של ספק אסימונים המבוסס על ITokenProvider ממשק למבנה הבנאי של לקוח הדוא"ל. במקרה זה, הלקוח בודק את זמן תפוגת האסימונים ומבקש ITokenProvider לקבלת אסימון גישה חדש כאשר הקודם פג תוקף. בצורה זו, הלקוח מרענן אסימונים באופן מחזורי ויכול לעבוד עם השרת לזמן בלתי מוגבל. בדרך כלל שירותים תומכים בדרך פשוטה לחדש אסימוני גישה. לדוגמה, שימוש באסימוני רענון בשירותי Google או זרימת אימות ROPC בפלטפורמת הזהות של Microsoft עשויים לשמש למימוש ספק אסימונים.

הגדרת חשבון על השרת המתאים

המאמרים הבאים עוזרים לכם להגדיר חשבונות לגישה לשירותי דואר.

ל Office 365
ל Gmail

גישה לשירותי דואר עם אסימוני גישה

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

// Connecting to SMTP server
try (SmtpClient client = new SmtpClient(
        "smtp.gmail.com",
        587,
        "user1@gmail.com",
        "accessToken",
        true,
        SecurityOptions.SSLExplicit)) {

}

// Connecting to IMAP server
try (ImapClient client = new ImapClient(
        "imap.gmail.com",
        993,
        "user1@gmail.com",
        "accessToken",
        true,
        SecurityOptions.SSLImplicit)) {

}

// Connecting to POP3 server
try (Pop3Client client = new Pop3Client(
        "pop.gmail.com",
        995,
        "user1@gmail.com",
        "accessToken",
        true,
        SecurityOptions.Auto)) {

}

גישה לשירותי דואר עם ספקי אסימונים

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

ITokenProvider tokenProvider = TokenProvider.Google.getInstance(
        "ClientId",
        "ClientSecret",
        "RefreshToken");

// Connecting to SMTP server
try (SmtpClient client = new SmtpClient(
        "smtp.gmail.com",
        587,
        "user1@gmail.com",
        tokenProvider,
        SecurityOptions.SSLExplicit)) {

}

// Connecting to IMAP server
try (ImapClient client = new ImapClient(
        "imap.gmail.com",
        993,
        "user1@gmail.com",
        tokenProvider,
        SecurityOptions.SSLImplicit)) {

}

// Connecting to POP3 server
try (Pop3Client client = new Pop3Client(
        "pop.gmail.com",
        995,
        "user1@gmail.com",
        tokenProvider,
        SecurityOptions.Auto)) {

}

מימוש של ITokenProvider מותאם אישית עבור Office 365

ניתן להשתמש במימוש ספק האסימונים למטה לגישה לשירותי הדואר של Office 365.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * Azure resource owner password credential (ROPC) token provider
 * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth-ropc
 * https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-authenticate-an-ews-application-by-using-oauth
 * https://portal.azure.com
 * https://developer.microsoft.com/en-us/graph/graph-explorer/#
 * token parser https://jwt.io
 * </p>
 */
class AzureROPCTokenProvider implements ITokenProvider {

    private static final String GRANT_TYPE = "password";

    private final String clientId;
    private final String clientSecret;
    private final String userName;
    private final String password;
    private final String tenant;
    private final String scope;

    private OAuthToken token;

    public AzureROPCTokenProvider(String tenant, String clientId, String clientSecret,
                                  String userName, String password, String[] scopeAr) {
        this.tenant = tenant;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.userName = userName;
        this.password = password;
        this.scope = joinToStr(scopeAr, " ");
    }

    public synchronized OAuthToken getAccessToken(boolean ignoreExistingToken) {
        if (this.token != null && !this.token.getExpired() && !ignoreExistingToken)
            return this.token;
        token = null;

        Map<String, String> tokenArgs = geToken();

        java.util.Calendar c = java.util.Calendar.getInstance();
        c.add(java.util.Calendar.SECOND, Integer.parseInt(tokenArgs.get("expires_in")));
        token = new OAuthToken(tokenArgs.get("access_token"), TokenType.AccessToken, c.getTime());
        return token;
    }

    public final OAuthToken getAccessToken() {
        return getAccessToken(false);
    }

    public void dispose() {
    }

    private String getEncodedParameters() {
        return "client_id=" + urlEncode(clientId) + "&scope=" + urlEncode(scope) + "&username=" + urlEncode(userName)
                + "&password=" + urlEncode(password) + "&grant_type="
                + urlEncode(GRANT_TYPE);
    }

    private String getUri() {
        if (tenant == null || tenant.trim().isEmpty())
            return "https://login.microsoftonline.com/common/oauth2/v2.0/token";
        else
            return "https://login.microsoftonline.com/" + tenant + "/oauth2/v2.0/token";
    }

    private Map<String, String> geToken() {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL(getUri()).openConnection();
            connection.setRequestMethod("POST");

            byte[] requestData = getEncodedParameters().getBytes(StandardCharsets.UTF_8);

            connection.setUseCaches(false);
            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", "" + requestData.length);

            final OutputStream st = connection.getOutputStream();
            try {
                st.write(requestData, 0, requestData.length);
            } finally {
                st.flush();
                st.close();
            }

            connection.connect();

            if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
                throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" +
                        connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
                        + readInputStream(connection.getErrorStream()));
            }

            String responseText = readInputStream(connection.getInputStream());

            Map<String, String> result = new HashMap<>();
            String[] fromJsonToKeyValue = responseText.replace("{", "").replace("}", "")
                    .replace("\"", "").replace("\r", "")
                    .replace("\n", "").split(",");
            for (String keyValue : fromJsonToKeyValue) {
                String[] pair = keyValue.split(":");
                String name = pair[0].trim().toLowerCase();
                String value = urlDecode(pair[1].trim());
                result.put(name, value);
            }

            return result;
        } catch (IOException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlDecode(String value) {
        try {
            return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String readInputStream(InputStream is) {
        if (is == null)
            return "";

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder result = new StringBuilder();
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
        } catch (IOException e) {
            // ignore
        }
        return result.toString();
    }

    static String joinToStr(String[] arr, String sep) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i > 0)
                sb.append(sep);
            sb.append(arr[i]);
        }
        return sb.toString();
    }
}

דוגמאות הקוד הבאות מראות כיצד להתחבר לשירותי Office 365 באמצעות ספק האסימונים המותאם אישית.

ITokenProvider tokenProvider = new AzureROPCTokenProvider(
        "Tenant",
        "ClientId",
        "ClientSecret",
        "EMail",
        "Password",
        scopes);

// Connecting to SMTP server
try (SmtpClient client = new SmtpClient(
        "smtp.office365.com",
        587,
        "Test1@test.onmicrosoft.com",
        tokenProvider,
        SecurityOptions.SSLExplicit)) {

}

// Connecting to IMAP server
try (ImapClient client = new ImapClient(
        "outlook.office365.com",
        993,
        "Test1@test.onmicrosoft.com",
        tokenProvider,
        SecurityOptions.SSLImplicit)) {

}

// Connecting to POP3 server
try (Pop3Client client = new Pop3Client(
        "outlook.office365.com",
        995,
        "Test1@test.onmicrosoft.com",
        tokenProvider,
        SecurityOptions.Auto)) {

}

// Connecting to EWS server
final String mailboxUri = "https://outlook.office365.com/ews/exchange.asmx";
ICredentials credentials = new OAuthNetworkCredential(tokenProvider);
try (IEWSClient ewsClient = EWSClient.getEWSClient(mailboxUri, credentials)) {

}

הרשאות לגישה ל-Office 365 דרך IMAP, POP3 או SMTP

אנו צריכים להחיל את הרשאות ה-API הנכונות ולהעניק את הסכמת המנהל לגישה לשירותי הדואר של Office 365:

באשף הרשאות ה-API / הוספת הרשאה, בחרו ב-Microsoft Graph ולאחר מכן בהרשאות המוגבלות כדי למצוא את תחומי ההרשאות הבאים הרשומים:

offline_access
IMAP.AccessAsUser.All
POP.AccessAsUser.All
SMTP.Send

דוגמה לספק אסימון:

ITokenProvider tokenProvider = new AzureROPCTokenProvider(OAuth.Tenant, OAuth.ClientId, OAuth.ClientSecret, User.EMail, User.Password,
        new String[] {
                "offline_access",
                "https://outlook.office.com/IMAP.AccessAsUser.All", // IMAP scope
                "https://outlook.office.com/POP.AccessAsUser.All",  // POP3 scope
                "https://outlook.office.com/SMTP.Send"              // SMTP scope
        });

Java: חילוץ נתוני אובייקטים משולבים

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

לפעמים נתוני OLE משובצים מיוצגים כקובץ מצורף "oleData.mso" על ידי MapiAttachment וצריך לחלץ בצורה ידנית. קבצי oleData.mso אלה הם בפורמט Microsoft Computer Document File (MCDF) והתמיכה בקבצים אלו היא מעבר לתחום של Aspose.Email. עם זאת, ניתן להשתמש ב‑Aspose.Email בשילוב עם ספריות קוד פתוח אחרות, כגון OpenMCDF, לקריאת תוכן הקבצים לצורך שמירה בכונן. Aspose.Email מספקת את InlineAttachmentExtractor מחלקה להצגת חבילות MSO מתוך הנתונים הבינריים של oledata.mso, שניתן להשתמש בהן לחילוץ תכנים על ידי ספריות קריאת קבצים מורכבים.

אם סוג גוף ההודעה הוא HTML (לא RTF), ויש אובייקטים של OLE בהודעה, המאפיין MapiPropertyTag.PR_ATTACH_DATA_OBJ אינו נמצא. במצב זה, המידע על אובייקטי OLE מצוי בקובץ oldedata.mso.

חילוץ אובייקטים משולבים

מאמר זה מראה כיצד לחלץ את התוכן מקובץ כזה באמצעות Aspose.Email:

// The path to the File directory
String dataDir = "/data";

MapiMessage msg = MapiMessage.fromFile(dataDir + "double.msg");
for (MapiAttachment mapiAttachment : msg.getAttachments()) {
    if ("oledata.mso".equals(mapiAttachment.getLongFileName())) {
        IGenericDictionary<String, byte[]> oledata = InlineAttachmentExtractor.enumerateMsoPackage(new ByteArrayInputStream(mapiAttachment.getBinaryData()));

        for (String oleItem : oledata.getKeys()) {
            // Use binary data
            processBynaryData(oledata.get_Item(oleItem));
        }
    }
}

Java: שליחת בקשת פגישה עם חזרתיות

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

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

יצירת בקשת פגישה עם חזרתיות

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

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String szUniqueId;

// Create a mail message
MailMessage msg1 = new MailMessage();
msg1.getTo().add("to@domain.com");
msg1.setFrom(new MailAddress("from@gmail.com"));

// Fill appointment object
Date startDate = sdf.parse("2013-12-01 17:00:00");
Date endDate = sdf.parse("2013-12-31 17:30:00");

// Create appointment object
Appointment agendaAppointment = new Appointment("same place", startDate, endDate, msg1.getFrom(), msg1.getTo());

// Create unique id as it will help to access this appointment later
szUniqueId = UUID.randomUUID().toString();
agendaAppointment.setUniqueId(szUniqueId);
agendaAppointment.setDescription("----------------");

// Create a weekly reccurence pattern object
WeeklyRecurrencePattern pattern1 = new WeeklyRecurrencePattern(14);

// Set weekly pattern properties like days: Mon, Tue and Thu
pattern1.setStartDays(new int[3]);
pattern1.getStartDays()[0] = CalendarDay.Monday;
pattern1.getStartDays()[1] = CalendarDay.Tuesday;
pattern1.getStartDays()[2] = CalendarDay.Thursday;
pattern1.setInterval(1);

// Set recurrence pattern for the appointment
agendaAppointment.setRecurrence(pattern1);

// Attach this appointment with mail
msg1.getAlternateViews().addItem(agendaAppointment.requestApointment());

// Create SmtpCleint
SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
client.setSecurityOptions(SecurityOptions.Auto);

// Send mail with appointment request
client.send(msg1);

// Return unique id for later usage
// return szUniqueId;

שלח בקשת עדכון פגישה

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

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date startDate = sdf.parse("2013-12-12 17:00:00");
Date endDate = sdf.parse("2013-12-12 17:30:00");
Appointment appUpdate = new Appointment("Different Place", startDate, endDate, new MailAddress("newcustomeronnet@gmail.com"),
        MailAddressCollection.to_MailAddressCollection("kashif.iqbal@aspose.com"));
appUpdate.setUniqueId(szUniqueId);
WeeklyRecurrencePattern pattern3 = (WeeklyRecurrencePattern) appUpdate.getRecurrence();
appUpdate.setSummary("update meeting request summary");
appUpdate.setDescription("update");
MailMessage msgUpdate = new MailMessage("newcustomeronnet@gmail.com", "kashif.iqbal@aspose.com", "06 - test email - update meeting request", "test email");
msgUpdate.addAlternateView(appUpdate.updateAppointment());
SmtpClient smtp = new SmtpClient("server.domain.com", 587, "username", "password");
smtp.send(msgUpdate);

Java: תמיכה בריבוי תהליכים בלקוחות הדוא"ל

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

לקוחות דואר כגון ImapClient ו Pop3Client מאפשר למשתמשים להשתמש בהם בסביבת ריבוי תהליכים. לקוחות דואר מאפשרים קיום של חיבור אחד או יותר עם שרת. לניהול קבוצת החיבורים בתוך הלקוחות משתמשים במאגר חיבורים. כמות החיבורים שניתן ליצור ולהשתמש בהם במקביל מוגבלת על ידי המאפיין CredentialsByHostClient.MaxConnectionsPerServer. ניתן להגדיר מאפיין זה ל‑1 או ערך גבוה יותר. ברירת המחדל היא 10. עבור החיבור יושם תור פקודות לתמיכה בפעולות ריבוי‑תהליכים. הפקודות מממשות פעולות פשוטות בפרוטוקול, כגון Noop, Authenticate ועוד. המשתמש יכול להתחיל ביצוע כמות גדולה של פקודות מעבר למספר החיבורים הזמינים, אך הן יתבצעו רק כאשר הלקוח יוכל ליצור חיבור לפעולה.

שיטות שימוש בלקוחות דוא"ל בסביבת ריבוי תהליכים

ללקוחות דוא"ל יש את ההתנהגות הבאה:

1. במקרה שה‑MaxConnectionsPerServer = 1, הלקוח יוצר חיבור אחד, מבצע אימות והauthorization. חיבור זה נשמר במצב פעילות עד שהלקוח יושמד. כל הפעולות מתהליכים שונים מופנות לתור פקודות יחיד הממוקם בחיבור הראשי.

2. במקרה שה‑MaxConnectionsPerServer > 1, הלקוח יוצר את מספר החיבורים הנדרש, מבצע אימות והרשאה לכל חיבור. חיבור אחד שמור כחיבור ראשי. חיבור זה נשמר במצב פעילות עד שהלקוח יתבצע השמדתו. כל שאר החיבורים נוצרים ומשתלמים לפי דרישה. הכמות המרבית של חיבורים כאלה מוגדרת על ידי המאפיין MaxConnectionsPerServer, לדוגמה אם MaxConnectionsPerServer = 2, אז אחד שמור כחיבור ראשי, והחיבור השני משמש כתוספת לפעולות המבוצעות בתהליכים אחרים. באופן דומה, אם MaxConnectionsPerServer = 3, החיבור הראשון שמור כחיבור ראשי, ושניים נוספים משמשים כתוספת לפעולות בתהליכים אחרים. במצב שבו מתבקשת חיבור נוסף מתהליך חדש, וכל החיבורים כבר תפוסים, הלקוח מחכה עד שמספר החיבורים בשימוש יופחת. זהו רגע חשוב שמבהיר מדוע השמדת חיבורים נכונה כה משמעותית.

דוגמאות

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

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

// Create an imapclient with host, user and password
ImapClient client = new ImapClient();
client.setHost("domain.com");
client.setUsername("username");
client.setPassword("password");
client.selectFolder("InBox");

ImapMessageInfoCollection messages = client.listMessages();
IAsyncResult res1 = client.beginFetchMessage(messages.get_Item(0).getUniqueId());
IAsyncResult res2 = client.beginFetchMessage(messages.get_Item(1).getUniqueId());
MailMessage msg1 = client.endFetchMessage(res1);
MailMessage msg2 = client.endFetchMessage(res2);

2. המשתמש יכול ליצור תהליכים באמצעות אובייקטים כגון Thread, ExecutorService או כל אובייקט אחר למטרה זו. בנוסף, המשתמש יכול להשתמש בתהליכים שנוצרו בקוד של צד שלישי. במצב זה הלקוח פועל בשתי מודלים של התנהגות

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

/**
 * Creates an executor service with a fixed pool size, that will time 
 * out after a certain period of inactivity.
 * 
 * @param poolSize The core- and maximum pool size
 * @param keepAliveTime The keep alive time
 * @param timeUnit The time unit
 * @return The executor service
 */
private static ExecutorService createFixedTimeoutExecutorService(
    int poolSize, long keepAliveTime, TimeUnit timeUnit)
{
    ThreadPoolExecutor e = 
        new ThreadPoolExecutor(poolSize, poolSize,
            keepAliveTime, timeUnit, new LinkedBlockingQueue<Runnable>());
    e.allowCoreThreadTimeOut(true);
    return e;
}

final List<MailMessage> list = new ArrayList<MailMessage>();

ExecutorService executor = createFixedTimeoutExecutorService(1, 1000, TimeUnit.MILLISECONDS);

executor.execute(new Runnable() {
    public void run() {
        client.selectFolder("folderName");
        ImapMessageInfoCollection messageInfoCol = client.listMessages();
        for (ImapMessageInfo messageInfo : messageInfoCol) {
            list.add(client.fetchMessage(messageInfo.getUniqueId()));
        }
    }
});

b. כאשר המשתמש מריץ שיטה ליצירת חיבור חדש לתהליל נוסף, תהליך זה חסום עד ששינוי ערך המquota לחיבורים חדשים יאפשר חיבור חדש. לאחר מכן נוצר חיבור חדש. חיבור זה מוגדר כחיבור ברירת המחדל לכל הפעולות בתהליך זה. לאחר שמסיימים את כל הפעולות בתהליך זה, יש לפנות את החיבור. כדי ליצור חיבורים חדשים השתמשו במתודה CredentialsByHostClient.CreateConnection. מתודה זו מחזירה אובייקט שמממש את הממשק IDisposable. לשחרור החיבור יש לקרוא למתודה Dispose. יצירת וחיסול חיבור חייבים להתבצע בתוך התהליך שבו מתבצעות פעולות הדוא"ל. ניסיון ליצור חיבור חדש בתהליך שבו נוצר לקוח הדוא"ל מוביל לשגיאה, מכיוון שתהליך זה במועד זה אינו יכול לשמש ליצירת חיבור חדש. כמו‑כן, יצירת חיבור חדש אינה אפשרית כאשר MaxConnectionsPerServer = 1. דוגמת קוד ליצירת חיבור חדש בתהליך נוסף:

final List<MailMessage> list = new ArrayList<MailMessage>();

ExecutorService executor = createFixedTimeoutExecutorService(1, 1000, TimeUnit.MILLISECONDS);

executor.execute(new Runnable() {
    public void run() {
        IConnection connection = client.createConnection();
        try {
            client.selectFolder(connection, "FolderName");
            ImapMessageInfoCollection messageInfoCol = client.listMessages(connection);
            for (ImapMessageInfo messageInfo : messageInfoCol)
                list.add(client.fetchMessage(connection, messageInfo.getUniqueId()));
        } finally {
            connection.dispose();
        }
    }
});

המלצות

שווה לציין שאם המשתמש שולח את כל הפקודות דרך החיבור הראשי, ייתכנה מצב שבו פקודות משThreads שונים מתערבבות. על המשתמש להבין אילו פקודות תלויות ברצף שלהן ולנקוט אמצעים לסנכרון של פקודות אלו. יש גם לקחת בחשבון אפשרות לביצוע פקודות במפגשים שונים (IMAP/POP3). הפעולות שלוקחות את רוב הזמן, כגון FetchMessage, AppendMessage ו‑Send, ככל הנראה יש לבצע אותן באמצעות תהליך חדש וחיבור חדש. אך פעולות מהירות כגון Delete עדיף לבצען דרך החיבור הראשי. יש להבחין בכך שהאתחול של חיבור חדש הוא פעולה שגוזלת זמן.

Java: מבוא ויישומים לדוגמה

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

תסריטי שימוש ב‑Aspose.Email Mail

מאמר זה מציע מספר שימושים אפשריים עבור Aspose.Email ל‑Java, ומתמקד במיוחד בתכונות תכנות הדוא״ל של הרכיב.

תוכנת ניוזלטר

ניתן להשתמש בממשק ה‑API של Aspose.Email Mail ליצירת יישום ניוזלטר חזק. בעזרת התמיכה של Aspose.Email בהוספת אובייקטים מוטמעים (כמו תמונות, צלילים וכו’), ניתן ליצור ניוזלטרים עשירי HTML עם תמונות (ואובייקטים מוטמעים אחרים). בעזרת תכונת שליחת המיילים בקבוצות של Aspose.Email Mail, אפשר לשלוח כמויות גדולות של הודעות בפרק זמן מוגבל. Aspose.Email Mail מספק גם תכונת מיזוג דואר מבוססת תבנית שניתן להשתמש בה ליצירת תבנית ניוזלטר. תבנית ניוזלטר יכולה לשמש לביצוע מיזוג דואר לצורך שליחת ניוזלטרים בקבוצות. ישנם משימות נוספות רבות שה‑Aspose.Email Mail יכול לבצע ביישום שיווק בדוא״ל.

כלי שיווק אחרים

בדומה ליישומי ניוזלטר, ניתן לבנות סוגים רבים אחרים של תוכנות באמצעות Aspose.Email Mail. השתמש בו לבניית שיווק בדוא״ל, שליחת מיילים בקבוצות וקמפיינים אלקטרוניים בקבוצות, ועוד.

יישומים עסקיים

ניתן להשתמש ב‑Aspose.Email Mail במרבית סוגי היישומים העסקיים לביצוע משימות שירות:

התראות דוא״ל: שלח התראות בדוא״ל כדי לעדכן משתמשים על פעילות.
בקשות פגישה: שלח בקשות פגישות עסקיות באמצעות תמיכת iCalendar של Aspose.Email Mail.
דיווחי דוא״ל מתוזמנים: דוחות הם חלק אינטגרלי ברוב היישומים העסקיים. רבים מהדוחות העסקיים נוצרים בפרקי זמן קבועים. השתמש ב‑Aspose.Email Mail כדי לשלוח דוחות מתוזמנים בדוא״ל.

לקוחות דוא״ל

Aspose.Email Mail יכול לשמש גם בלקוחות דוא״ל לשליחת הודעות רגילות. הוא תומך בקבצים מצורפים, אובייקטים מוטמעים, אירועי iCalendar, מיזוג דואר, שליחת דוא״לים בקבוצות, ועוד, ולכן Aspose.Email Mail הוא האפשרות הטובה ביותר ליצירת יישומי לקוחות דוא״ל.

Aspose.Email Mail יישום לדוגמא

להמחשת השימוש ב‑Aspose.Email Mail, ניצור אפליקציה המראה איך לבנות הודעת דוא״ל עם מחלקת MailMessage ולאחר מכן שלח אותה באמצעות מחלקת SmtpClient.

Mail : שלבי יישום לדוגמא

אנא פעל לפי הצעדים שלמטה כדי ליצור אפליקציה באמצעות Aspose.Email.

עצב את האפליקציה שלך: צור ממשק שלוקח שלושה שדות: From, To ו‑Message.
הקלקה כפולה על כפתור Send בתצוגת העיצוב וכתוב את הקוד בעורך.
צור מופע של המחלקה MailMessage והשתמש במאפייניה לבנות הודעת דוא״ל. (מופעים של מחלקת MailMessage משמשים לבניית הודעות דוא״ל שמועברות לשרת SMTP לצורך משלוח באמצעות מחלקת SmtpClient).
צור מופע של המחלקה SmtpClient והשתמש במאפייניה כדי לשלוח הודעת דוא״ל.
בדוק את האפליקציה שלך.
הקלד כתובות בשדות From ו‑To.
הקלד הודעה בשדה Message Body.
הקלק על Send.

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

// Declare message as MailMessage instance
MailMessage message = new MailMessage();
// Specify From, To, Subject and Body
message.setFrom(new MailAddress("#From"));
message.setTo(MailAddressCollection.to_MailAddressCollection("#To"));
message.setSubject("#Subject");
message.setBody("#Body");

// Send email using SmtpClient, Create an instance of the SmtpClient Class and Specify the mailing host server, Username, Password and Port
SmtpClient client = new SmtpClient();

// Specify the mailing host server, Username, Password and Port
client.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(25);
client.send(message);

// Notify the user that a message has been sent
System.out.println("Message Sent");

כאשר מתחברים לשרת שמפעיל SSL, יש להגדיר את מאפייני האובייקט SMTPClient הבאים

// Set the port to 587. This is the SSL port of Gmail SMTP server, set the security mode to explicit
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);

סיכום

Aspose.Email Mail הוא רכיב חזק מאוד שמאפשר למפתחים לבצע כמעט כל משימה הקשורה לדוא״ל, כגון שליחת דוא״לים בכמויות מרובות בתהליכים מרובי‑חוטים, שימוש במיזוג דואר, הוספת קבצים מצורפים, הטמעת תמונות וקולות בהודעות דוא״ל, הוספת אירועי iCalendar לדוא״לים, קבלת דוא״לים ועוד רבים.

Aspose.Email Pop3

Aspose.Email Pop3 مיישמת את פרוטוקול המשרד הדואר (POP3) ב‑Java. היא מאפשרת למפתחים ב‑Java להוסיף תכונות של שאילתת וקבלת דוא״ל ליישומים שלהם מבלי להיסחף לפרטי הפרוטוקול ולמורכבות של תכנות דוא״ל ורשת. Aspose.Email Pop3 תומכת בכל הפקודות המוגדרות בפרוטוקול POP3 הסטנדרטי, ומספקת ממשקים קלים לשימוש יחד עם מודל אובייקטים קומפקטי ואינטואיטיבי. היא מצמצמת בצורה משמעותית את עקומת הלימוד הרגילה למפתחי Java.

Pop3 : תכונות מרכזיות

כחלק מ‑Aspose.Email, Aspose.Email Pop3 עוצב במיוחד עבור Java ונכתב בקוד Java מנוהל. הוא מאפשר לך:

התחבר והתחבר לשרתים של POP3.
תמיכה ב‑APOP.
שאילתת הודעות.
משיכת הודעות.
תמיכה מלאה בסגנון תכנות אסינכרוני.
תמיכה ב‑SSL.

תסריטי Aspose.Email Pop3

מפתחים יכולים להשתמש ב‑Aspose.Email Pop3 במגוון תרחישים שונים. כאן, אנו חולקים כמה מהם.

אוטומציית דוא״ל עסקית

ניתן להשתמש ב‑Aspose.Email Pop3 כדי לשאול תיבות דוא״ל ולהביא הודעות דוא״ל. הוא עובד באופן חלק עם רכיב שליחת הדוא״ל, Aspose.Email Mail. Aspose.Email תומך באופן מלא באוטומציה של דוא״ל. שלח הודעות דוא״ל עם Aspose.Email Mail והבא הודעות עם Aspose.Email Pop3. הודעות הדוא״ל שהורדו יכולות לאחר מכן להיות מנותחות על‑ידי Aspose.Email Mime.

לקוחות דוא״ל

ניתן להשתמש ב‑Aspose.Email Pop3 ביישומי לקוחות דוא״ל לקבלת הודעות.

Pop3 : יישום לדוגמא

כאן, נציג כיצד להשתמש Aspose.Email Pop3. מחלקה זו כוללת תכונות מרובות אך נתמקד באופן חיבור לשרת POP3 ושליפת הודעות. הדוגמה מציגה כיצד ליצור יישום וכן את דוגמאות הקוד שמפעילות את היישום. עקוב אחרי הצעדים שלמטה כדי ליצור יישום לדוגמא באמצעות Aspose.Email Pop3.

צור מופע של Pop3Client.
הגדר את שם המארח של POP3, שם המשתמש והסיסמה במופע זה.
צור מופע של MailMessage והבא את האימייל הראשון בחשבון שלך אליו על‑ידי קריאה לפונקציה fetchMessage(). פעולה זו מביאה את ההודעה הראשונה מחשבון האימייל שלך למופע MailMessage.
השתמש במאפייני From, Subject ו-HtmlBody של מופע MailMessage כדי לראות את השולח, הנושא וגוף ההודעה.

הצעדים שלמעלה מוצגים בדוגמאות קוד שלהלן.

// Create a POP3 client
Pop3Client client = new Pop3Client();

// Basic settings (required)
client.setHost("pop3.youdomain.com");
client.setUsername("username");
client.setPassword("psw");

try {
    // Retrieve first message in MailMessage format directly
    MailMessage msg;
    msg = client.fetchMessage(1);
    System.out.println(msg.getFrom().toString());
    System.out.println(msg.getSubject());
    System.out.println(msg.getHtmlBody());
} catch (Exception ex) {
    System.err.println(ex);
}

לשרתים עם SSL מופעל, עלינו לשנות את המאפיינים הבאים של האובייקט Pop3Client:

// Set implicit security mode
client.setSecurityOptions(SecurityOptions.SSLImplicit);

Aspose.Email Imap

Aspose.Email Imap מממש את פרוטוקול Internet Message Access Protocol (IMAP) ב‑Java. Aspose.Email Imap מאפשר למפתחים ב‑Java להוסיף יכולות IMAP ליישומים שלהם במהירות, ללא צורך בהבנת פרטי הפרוטוקול. הרכיב תומך באחזור והעלאת הודעות, בבדיקת מצב הודעות חדשות/נקראו/לא נקראו, ועוד.

Imap : תכונות מרכזיות

Aspose.Email Imap מאפשר לך:

הבא הודעות אימייל.
העלאת הודעות אימייל.
רשימת הודעות אימייל בתיקיות שונות.
בדיקת הסטטוס של הודעות אימייל.
עבודה עם MailMessage.
עבודה עם תמיכת SSL.

שימוש ב‑Aspose.Email Imap

Aspose.Email Imap מממש את פרוטוקול Internet Message Access Protocol (IMAP) ב‑Java. באמצעותו, המפתחים יכולים בקלות לשאול ולנהל אימיילים משרת IMAP, וליצור, למחוק או לשנות שם של תיקיות אימייל. עם Aspose.Email Imap, המפתחים מנצלים את פרוטוקול IMAP דרך APIs קלים לשימוש. הם יכולים לגשת לאימיילים מכל מחשב שכן האימיילים נשמרים על השרת. באמצעות Aspose.Email Imap, מפתחים יכולים ליצור יישומי ווב או שולחן עבודה שמקבלים ומשנים אימיילים משרתי IMAP. Aspose מיישם את פרוטוקול IMAP בהתאם לתקני האימות של האינטרנט ו‑RFC. לכן Aspose.Email Imap הוא מימוש מאובטח ומלא של פרוטוקול IMAP עם מודל אובייקטים וממשקים קלים להבנה.

Imap : יישום דוגמה

מאמר זה מסביר כיצד להשתמש ב‑ Aspose.Email Imap. אנו יוצרים יישום קטן שמקבל את מספר הודעות האימייל בחשבון IMAP שלך. עקוב אחרי השלבים שלמטה כדי ליצור יישום דוגמה עם Aspose.Email Imap.

צור מופע של ImapClient על‑ידי העברת שם שרת IMAP, שם משתמש וסיסמה.
קרא לפונקציה selectFolder() של מופע ImapClient כדי לבחור את התיקייה שבה ברצונך לספור את מספר ההודעות.
הפעל כעת את המאפיין CurrentFolder.TotalMessageCount של מופע ImapClient כדי לקבל את ספירת הודעות האימייל.

Imap : דוגמאות קוד

דוגמאות הקוד שלהלן מציגות כיצד לממש את השלבים המתוארים למעלה עם Aspose.Email.

// Creates an instance of the class ImapClient by specified the host, username and password
ImapClient client = new ImapClient("localhost", "username", "password");

try {
    client.selectFolder(ImapFolderInfo.IN_BOX);
    String strTemp;
    strTemp = "You have " + client.getCurrentFolder().getTotalMessageCount() + " messages in your account.";
    // Gets number of messages in the folder, Disconnects to imap server.
    System.out.println(strTemp);
} catch (Exception ex) {
    System.err.println(ex);
}

לשרתים עם SSL מופעל, הגדר את המאפיינים הבאים של האובייקט ImapClient:

// Set security mode
client.setSecurityOptions(SecurityOptions.SSLImplicit);

Aspose.Email Exchange

Aspose.Email Exchange מאפשר למפתחים לנהל אימיילים ב‑Microsoft Exchange Server. באמצעות רכיב זה ניתן להתחבר, לרשום הודעות ולהוריד אימיילים מתיבת דואר של שרת Exchange מבלי להבין את פרטי הפרוטוקול הפנימי. הרכיב תומך ברשימת הודעות, שליחת אימיילים, הורדת הודעות ושמירה לפורמט eml או msg על הדיסק המקומי וכד'.

Exchange : תכונות מרכזיות

Aspose.Email Exchange מאפשר לך:

התחברות ל‑Microsoft Exchange Servers.
רשימת הודעות אימייל בתיבות Exchange.
רשימת הודעות אימייל מתיקיות שונות, לדוגמה תיבת הדואר הנכנס, נשלחו, נמחקו או טיוטות.
מחיקת הודעות בכל תיקייה ב‑Exchange Servers.

שימוש ב‑Aspose.Email Exchange

עם Aspose.Email Exchange, מפתחים יכולים לגשת לתיבות דואר של Exchange Server מתוך יישומי Java שלהם. הוא מספק API ידידותי לניהול הודעות אימייל ב‑Exchange Servers. מפתחים יכולים ליצור יישומי קונסול, שולחן עבודה או ווב שמנהלים הודעות בתיבות Exchange.

יישום דוגמה של Aspose.Email Exchange

מאמר זה מדגים כיצד להשתמש ב‑ Aspose.Email Exchangeאנו יוצרים יישום שולחניים פשוט שמתחבר לתיבת דואר ב‑Exchange Server, משיג את רשימת ההודעות בתיקיית הדואר הנכנס ומציג אותן בטופס ה‑Windows.

Exchange : שלבי יישום לדוגמה

כדי להריץ את היישום בהצלחה, נדרש להשתמש באישורים המתאימים לגישה ל‑Exchange Server. כאן אנו מקבלים את פרטי האישור – כתובת ה‑Exchange Server, שם משתמש, סיסמה ותחום – מהטופס ב‑Windows. זוהי דוגמה בסיסית מאוד ולכן תכונות ההודעה – נושא, ממכיר ואל – מוצגות בפשטות ברשימת התיבות.

Exchange : דוגמאות קוד

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

// Clear the items in the listbox
lstMessages.clear();

// Create instance of IEWSClient class by giving credentials and Call ListMessages method to list messages info from Inbox
IEWSClient client = EWSClient.getEWSClient("mailboxURI", "Username", "Password", "Domain");
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to display the basic information
for (ExchangeMessageInfo msgInfo : msgCollection) {
    String strMsgInfo = "Subject: " + msgInfo.getSubject() + " == From: " + msgInfo.getFrom().toString() + " == To: " + msgInfo.getTo().toString();
    lstMessages.add(strMsgInfo);
}

Exchange : פלט

צילום המסך מציג את ההודעות שהושגו מ‑Exchange Server. המתודה listMessages() מחזירה מידע בסיסי כמו נושא, ממכיר, לנמען ו‑ID ההודעה. כדי לקבל את ההודעה המלאה, קרא למתודה IEWSClient.fetchMessage(). (שימוש ב‑IEWSClient.fetchMessage() מתואר במאמר עבודה עם תיבת דואר Exchange והודעות.)

Aspose.Email Mime

Multipurpose Internet Mail Extensions (MIME) הוא תקן אינטרנט המרחיב את פורמט האימייל לתמיכה בטקסט בקידודים שאינם US‑ASCII, בקבצים מצורפים שאינם טקסט, בגופי הודעות מרובעים ובמידע כותרת בקידודים שאינם ASCII. Aspose.Email Mime מממש את פרוטוקול MIMI ב‑Java. הוא פועל כמתרגם בכך שהוא יכול לקרוא אימייל מקובץ (.eml וכו’) או מזיכרון (מחרוזת). לאחר מכן הוא מפענח את קובץ האימייל או המחרוזת לחלקים משמעותיים. אם ברצונך לעבור על קובץ אימייל מבלי להתעסק בפרטי פרוטוקול MIME, לדוגמה כדי לחלץ קובץ מצורף, השתמש ב‑Aspose.Email Mime.

תכונות מרכזיות

Aspose.Email Mime פועל בצורה מושלמת עם Aspose.Email Pop3 ו‑Aspose.Email Mail.

Aspose.Email Pop3 מאחזר הודעות אימייל מתיבת דואר שצוינה.
Aspose.Email Mail שולח הודעות אימייל לתיבת דואר שצוינה.
Aspose.Email Mime הוא הציר של השניים הנ״ל, ומנתח הודעות אימייל.

Java: ביטול בקשות פגישה עם יומן

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

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

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

לפני שנוכל ביטול בקשות פגישה, עלינו לשלוח כמה:

ראשית, צור מופע מסוג SmtpClient לצורך שליחת ההודעה.
שמור את כל מידע המשתתפים באוסף MailAddressCollection.
צור מופע של מחלקת MailMessage והגדר מאפיינים נדרשים כגון From, To ו‑Subject.
צור מופע מסוג Appointment וספק מידע על המיקום, זמן ההתחלה, זמן הסיום, המארגנים והמשתתפים.
שמור את כל המידע במאגר נתונים. עבודה הקשורה למאגר מתבצעת במתודה SaveIntoDB.

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

class Attendees {
    public String MessageId;
    public String EmailAddress;
    public String DisplayName;
}

class Message {
    public String MessageId;
    public String From;
    public String Subject;
    public String Body;
    public String AppLocation;
    public Date AppStartDate;
    public Date AppEndDate;
    public String AppSummary;
    public String AppDescription;
}

public void send(Attendees[] attendeesArr, String from, String appLocation, Date appStartDate, Date appEndDate) {
    try {
        // Create an instance of SMTPClient
        SmtpClient client = new SmtpClient("MailServer", "Username", "Password");
        // Get the attendees
        MailAddressCollection attendees = new MailAddressCollection();
        for (Attendees a : attendeesArr) {
            attendees.addItem(new MailAddress(a.EmailAddress, a.DisplayName));
        }

        // Create an instance of MailMessage for sending the invitation
        MailMessage msg = new MailMessage();

        // Set from address, attendees
        msg.setFrom(new MailAddress(from));
        msg.setTo(attendees);

        // Create am instance of Appointment
        Appointment app = new Appointment(appLocation, appStartDate, appEndDate, new MailAddress(from), attendees);
        app.setSummary("Monthly Meeting");
        app.setDescription("Please confirm your availability.");
        msg.addAlternateView(app.requestApointment());

        // Save the info to the database
        if (saveIntoDB(msg, app) == true) {
            // Save the message and Send the message with the meeting request
            msg.save(msg.getMessageId() + ".eml", SaveOptions.getDefaultEml());
            client.send(msg);
            System.out.println("message sent");
        }
    } catch (Exception ex) {
        System.err.println(ex);
    }
}

private boolean saveIntoDB(MailMessage msg, Appointment app) {
    // Save Message and Appointment information
    Message messageRow = new Message();
    messageRow.MessageId = msg.getMessageId();
    messageRow.From = msg.getFrom().getAddress();
    messageRow.Subject = msg.getSubject();
    messageRow.Body = msg.getBody();
    messageRow.AppLocation = app.getLocation();
    messageRow.AppStartDate = app.getStartDate();
    messageRow.AppEndDate = app.getEndDate();
    messageRow.AppSummary = app.getSummary();
    messageRow.AppDescription = app.getDescription();
    addToDB(messageRow);

    // Save attendee information
    for (MailAddress address : app.getAttendees()) {
        Attendees attendeesRow = new Attendees();
        attendeesRow.MessageId = msg.getMessageId();
        attendeesRow.EmailAddress = address.getAddress();
        attendeesRow.DisplayName = address.getDisplayName();
        addToDB(attendeesRow);
    }

    return true;
}

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

כדי לבטל בקשת פגישה, ראשית קבל את מזהה ההודעה של המייל. משום ששמרנו מידע זה במאגר לדוגמה זו, ניתן לקבל אותו בקלות שוב.

בחירת ההודעה עבורה יישלח בקשת הביטול.
הקלק על Send Cancel Request כדי לשלוח את הבקשה.
מתשאל את המסד נתונים כדי לקבל מידע על משתתפים, הודעות ונתונים קשורים ליומן.
צור מופעים של מחלקת Calendar ו‑MailMessage באמצעות המידע שהוצא מהמאגר.
השתמש במתודה Appointment.cancelAppointment() כדי לשלוח בקשת ביטול.
שלח את המייל באמצעות ה‑SMTP.

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

public void cancel(String messageId) {
    // Get the message and calendar information from the database get the attendee information

    // Get the attendee information in reader
    Attendees[] attendeesRows = getAttendeesFromDB(messageId);

    // Create a MailAddressCollection from the attendees found in the database
    MailAddressCollection attendees = new MailAddressCollection();
    for (Attendees attendeesRow : attendeesRows) {
        attendees.addItem(new MailAddress(attendeesRow.EmailAddress, attendeesRow.DisplayName));
    }
    // Get message and calendar information
    Message messageRow = getMessageFromDB(messageId);

    // Create the Calendar object from the database information
    Appointment app = new Appointment(messageRow.AppLocation, messageRow.AppSummary, messageRow.AppDescription, messageRow.AppStartDate, messageRow.AppEndDate,
            new MailAddress(messageRow.From), attendees);

    // Create message and Set from and to addresses and Add the cancel meeting request
    MailMessage msg = new MailMessage();
    msg.setFrom(new MailAddress(messageRow.From));
    msg.setTo(attendees);
    msg.setSubject("Cencel meeting");
    msg.addAlternateView(app.cancelAppointment());
    SmtpClient smtp = new SmtpClient("smtp.gmail.com", 587, "user@gmail.com", "password");
    smtp.send(msg);
    System.out.println("cancellation request successfull");
}

Java: היישום הראשון עם Aspose.Email Outlook

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

קטע זה מציג כיצד להשתמש ב‑Aspose.Email Mapi. אנו יוצרים יישום קטן שטוען קובץ הודעת Outlook (TestMessage.msg) ומציג את נושא ההודעה, כתובת השולח, כתובת הנמען ותוכן הגוף. פעלו לפי הצעדים כדי ליצור את היישום הראשון שלכם עם Aspose.Email Outlook.

צור מופע של MapiMessage מחלקה על ידי שצוין נתיב קובץ ההודעה.
השתמש בתכונות הציבוריות להצגת הנושא, השולח, הנמען והגוף.

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

// Load the outlook message file
MapiMessage msg = MapiMessage.fromFile("outlookmessage.msg");

// Use the public properties
//read subject
System.out.print("Subject:" + msg.getSubject());

//sender name
System.out.print("From:" + msg.getSenderName());

//message body
System.out.print("Body:" + msg.getBody());

//Attachments
for(MapiAttachment att : msg.getAttachments())
{
    System.out.print("Attachment Name:"+att.getFileName());
    att.save(att.getFileName());
}

Java: כיצד להתעלם משגיאות

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

תמיכה בהתעלמות משגיאות

ExceptionManager מחלקה המספקת יכולת התעלמות משגיאות:

דוגמאות קוד:

הגדר callback לטיפול בשגיאות:

ExceptionManager.setIgnoreExceptionsHandler(new IgnoreExceptionsCallback() {
    //exception path: {Module}\{Method}\{Action}\{GUID}
    //example: MailMessage\Load\DecodeTnefAttachment\64149867-679e-4645-9af0-d46566cae598
    public boolean invoke(AsposeException ex, String path) {
        //Ignore all exceptions on MailMessage.Load
        return path.equals("MailMessage\\Load");
    }
});

או להשתמש באלטרנטיבה:

//Ignore all exceptions
ExceptionManager.setIgnoreAll(true);

בנוסף, ניתן להגדיר callback עבור יומן שגיאות שהודחת:

ExceptionManager.setIgnoreExceptionsLogHandler(new IgnoreExceptionsLogCallback() {
    public void invoke(String message) {
        System.out.println("=== EXCEPTION IGNORED === " + message);
    }
});

המשתמש יקבל הודעה שהשגיאה ניתנת להתעלמות באמצעות הודעת שגיאה. לדוגמה:

Exceptioin message:

AsposeArgumentException: properties should not be empty.
If you want to ignore an exception and want to proceed further then you can use:
ExceptionManager.getIgnoreList().add("MailMessage\\Load\\DecodeTnefAttachment\\64149867-679e-4645-9af0-d46566cae598")
Invalid TNEF Attachment will be interpreted as regular attachment.