Documentation – ביצוע עבודה עם לקוח IMAP

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

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

ה ImapClient המחלקה מאפשרת ליישומים לנהל תיבות דואר IMAP באמצעות פרוטוקול IMAP. ה- ImapClient המחלקה משמשת להתחברות לשרתי דואר IMAP ולניהול אימיילים בתיקיות הדואר של IMAP. כדי להתחבר לשרת IMAP

צור מופע של ImapClient מחלקה.
ציין את שם המארח, שם המשתמש והסיסמה ב- ImapClient constructor.

לאחר שה ImapClient המותח מתחילה, הקריאה הבאה לכל פעולה באמצעות המותח תתחבר לשרת. הקטע הקוד הבא מראה כיצד להתחבר לשרת IMAP באמצעות השלבים שלמעלה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create an imapclient with host, user and password
ImapClient client = new ImapClient("localhost", "user", "password");

התחברות עם שרת IMAP עם SSL מופעל

התחברות עם שרת IMAP מתואר כיצד להתחבר לשרת IMAP בארבעה שלבים פשוטים:

צור מופע של ImapClient מחלקה.
ציין את שם המארח, שם המשתמש והסיסמה.
ציין את הפורט.
ציין את אפשרויות אבטחה.

תהליך ההתחברות לשרת IMAP עם SSL דומה אך דורש להגדיר כמה מאפיינים נוספים:

הגדר אפשרויות אבטחה ל‑SSLImplicit.

הקטע הקוד הבא מראה כיצד

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create an instance of the ImapClient class
ImapClient client = new ImapClient("imap.domain.com", 993, "user@domain.com", "pwd");

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

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

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

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP and set SecurityOptions
ImapClient client = new ImapClient("imap.domain.com", "username", "password");
client.setSecurityOptions(SecurityOptions.Auto);

String proxyAddress = "192.168.203.142"; // proxy address
int proxyPort = 1080; // proxy port
SocksProxy proxy = new SocksProxy(proxyAddress, proxyPort, SocksVersion.SocksV5);

// Set the proxy
client.setProxy(proxy);

try {
    client.selectFolder("Inbox");
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

התחברות לשרת דרך פרוקסי 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);
final ImapClient client = new ImapClient("imap.domain.com", "username", "password");
try {
    client.setProxy(proxy);
    client.selectFolder("Inbox");
} finally {
    if (client != null)
        client.dispose();
}

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

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

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

imapClient.setAllowedAuthentication(ImapKnownAuthenticationType.Plain);

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

ה ImapClient מחלקה מספקת ReadOnly מאפיין שכאשר מוגדר ל‑true, מצביע שאין לבצע שינויים במצב הקבוע של תיבת הדואר. דוגמת הקוד הבאה מדגימה את השימוש ב- ImapClient.ReadOnly מאפיין. הוא מקבל את ספירת ההודעות שלא נקראו, משיג הודעה אחת ולאחר מכן מקבל שוב את ספירת ההודעות שלא נקראו במצב קריאה בלבד. ספירת ההודעות שלא נקראו נשארת אחת, מה שמעיד שהמצב הקבוע של תיבת הדואר לא השתנה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

ImapQueryBuilder imapQueryBuilder = new ImapQueryBuilder();
imapQueryBuilder.hasNoFlags(ImapMessageFlags.isRead()); /* get unread messages. */
MailQuery query = imapQueryBuilder.getQuery();

imapClient.setReadOnly(true);
imapClient.selectFolder("Inbox");
ImapMessageInfoCollection messageInfoCol = imapClient.listMessages(query);
System.out.println("Initial Unread Count: " + messageInfoCol.size());
if (messageInfoCol.size() > 0) {
    imapClient.fetchMessage(messageInfoCol.get_Item(0).getSequenceNumber());

    messageInfoCol = imapClient.listMessages(query);
    // This count will be equal to the initial count
    System.out.println("Updated Unread Count: " + messageInfoCol.size());
} else {
    System.out.println("No unread messages found");
}

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

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

imapClient.setAllowedAuthentication(ImapKnownAuthenticationType.CramMD5);

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

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

try (ImapClient imapClient = new ImapClient(
        server.ImapUrl, server.ImapPort, "username", "password", SecurityOptions.Auto)) {
    imapClient.setTimeout(4000);

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

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

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

try (ImapClient imapClient = new ImapClient("host", 993, "username", "password", SecurityOptions.SSLImplicit))
{
    imapClient.setTimeout(60000); // 60 seconds

    // some code...
}

כיצד להגביל את ה‑Greeting Timeout

לקוח ה‑IMAP עשוי להשתמש במצב האוטומטי כדי להקמת חיבור. במצב זה, לקוח ה‑IMAP עובר על כל פרמטרי החיבור האפשריים עד שמתקבל חיבור. שרת IMAP במקרה של חיבור תקין שולח מחרוזת ברכה ללקוח. שרתים יכולים להשתמש בחיבור SSL/TLS עקיף או מפורש (START TLS). אם מצב החיבור אינו תואם (למשל, השרת מחכה לחיבור SSL עקיף אך הלקוח מנסה להקים חיבור SSL לא מאובטח או מפורש), השרת לא ישלח מחרוזת ברכה והמשתמש יחכה זמן רב עד שה‑timeout יגרום לקבלת מחרוזת ברכה, והלקוח יעבור לאופציית חיבור הבאה. כדי למנוע בעיה זו, ה‑GreetingTimeout הוצג. מאפיין זה מאפשר להגדיר את משך הזמן עבור מחרוזת הברכה, ולהקטין את זמן הקמת החיבור האוטומטי.

ImapClient imapClient = new ImapClient();
imapClient.setGreetingTimeout(4000);

Java: עבודה עם הודעות משרת IMAP

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

רשימת מזהי הודעות MIME מהשרת

מידע הודעה Imap מספק את ה-MIME MessageId לזיהוי הודעה מבלי לחלץ את ההודעה המלאה. הקטע הקוד הבא מראה כיצד לרשום MIME messageId.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient client = new ImapClient();
client.setHost("domain.com");
client.setUsername("username");
client.setPassword("password");

try {
    ImapMessageInfoCollection messageInfoCol = client.listMessages("Inbox");
    for (ImapMessageInfo info : messageInfoCol) {
        // Display MIME Message ID
        System.out.println("Message Id = " + info.getMessageId());
    }
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

רשימת הודעות מהשרת

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create an imapclient with host, user and password
ImapClient client = new ImapClient("localhost", "user", "password");

// Select the inbox folder and Get the message info collection
ImapQueryBuilder builder = new ImapQueryBuilder();
MailQuery query = builder
        .or(builder.or(builder.or(builder.or(builder.getSubject().contains(" (1) "), builder.getSubject().contains(" (2) ")), builder.getSubject().contains(" (3) ")),
                builder.getSubject().contains(" (4) ")), builder.getSubject().contains(" (5) "));
ImapMessageInfoCollection messageInfoCol4 = client.listMessages(query, 4);
System.out.println((messageInfoCol4.size() == 4) ? "Success" : "Failure");

רשימת הודעות מהשרת בצורה רקורסיבית

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// 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 msgsColl = client.listMessages(true);
System.out.println("Total Messages: " + msgsColl.size());

רישום הודעות עם חיבור מרובה

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

imapClient.selectFolder("Inbox");
imapClient.setConnectionsQuantity(5);
imapClient.setUseMultiConnection(MultiConnectionMode.Enable);
long multiConnectionModeStartTime = System.currentTimeMillis();
ImapMessageInfoCollection messageInfoCol1 = imapClient.listMessages(true);
long multiConnectionModeTimeSpan = System.currentTimeMillis() - multiConnectionModeStartTime;

imapClient.setUseMultiConnection(MultiConnectionMode.Disable);
long singleConnectionModeStartTime = System.currentTimeMillis();
ImapMessageInfoCollection messageInfoCol2 = imapClient.listMessages(true);
long singleConnectionModeTimeSpan = System.currentTimeMillis() - singleConnectionModeStartTime;

double performanceRelation = singleConnectionModeTimeSpan / multiConnectionModeTimeSpan;
System.out.println("Performance Relation: " + performanceRelation);

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

קבל הודעות בסדר יורד

Aspose.Email מספקת ImapClient.listMessagesByPage מתודה שמציגה הודעות עם תמיכת דפדוף. כמה עומסים של ImapClient.listMessagesByPage מקבל PageSettings כפרמטר. PageSettings מספק AscendingSorting מאפיין שכאשר מוגדר ל‑false, מחזיר אימיילים בסדר יורד.

קוד הדוגמה הבא מדגים את השימוש ב- AscendingSorting מאפיין של PageSettings מחלקה לשינוי סדר האימיילים.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

PageSettings pageSettings = new PageSettings();
pageSettings.setAscendingSorting(false);
ImapPageInfo pageInfo = imapClient.listMessagesByPage(5, pageSettings);
ImapMessageInfoCollection messages = pageInfo.getItems();

for (ImapMessageInfo message : messages) {
    System.out.println(message.getSubject() + " -> " + message.getDate().toString());
}

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

ה ImapClient מחלקה יכולה לאחזר הודעות משרת IMAP ולשמור את ההודעות בפורמט EML על דיסק מקומי. השלבים הבאים נדרשים לשמירת ההודעות לדיסק:

צור מופע של ImapClient מחלקה.
ציין שם מארח, יציאה, שם משתמש וסיסמה ב‑ImapClient constructor.
בחר את התיקייה באמצעות selectFolder() שיטה.
הפעל את listMessages מתודה לקבלת ה- אוסף מידע הודעה Imap אובייקט.
איטרציה דרך ה- אוסף מידע הודעה Imap אוסף, קרא ל- saveMessage() מתודה והספק את נתיב הפלט ואת שם הקובץ.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Select the inbox folder and Get the message info collection
client.selectFolder(ImapFolderInfo.IN_BOX);
ImapMessageInfoCollection list = client.listMessages();

// Download each message
for (int i = 0; i < list.size(); i++) {
    // Save the EML file locally
    client.saveMessage(list.get_Item(i).getUniqueId(), dataDir + list.get_Item(i).getUniqueId() + ".eml");
}

שמירת הודעות בפורמט MSG

בדוגמה למעלה, האימיילים נשמרים בפורמט EML. כדי לשמור אימיילים בפורמט MSG, ה- ImapClient.fetchMessage() יש לקרוא למתודה. היא מחזירה את ההודעה כמופע של MailMessage מחלקה. ה- MailMessage.save() מתודה יכולה לאחר מכן להיקרא לשמירת ההודעה כ‑MSG. קטע הקוד הבא מראה כיצד לשמור הודעות בפורמט MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the file directory.
String dataDir = "data/";

// Create an imapclient with host, user and password
ImapClient client = new ImapClient("localhost", "user", "password");

// Select the inbox folder and Get the message info collection
client.selectFolder(ImapFolderInfo.IN_BOX);
ImapMessageInfoCollection list = client.listMessages();

// Download each message
for (int i = 0; i < list.size(); i++) {
    // Save the message in MSG format
    MailMessage message = client.fetchMessage(list.get_Item(i).getUniqueId());
    message.save(dataDir + list.get_Item(i).getUniqueId() + "_out.msg", SaveOptions.getDefaultMsgUnicode());
}

הבאת הודעות בקבוצות

ImapClient מספק fetchMessages מתודה המקבלת איטרביל של מספרי סדר או ID ייחודי ומחזירה רשימה של MailMessage. קוד הדוגמה הבא מדגים את השימוש ב- fetchMessages מתודה להבאת הודעות לפי מספרי סדר ו-ID ייחודי.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

ImapMessageInfoCollection messageInfoCol = imapClient.listMessages();
System.out.println("ListMessages Count: " + messageInfoCol.size());

List<Integer> sequenceNumberAr = new ArrayList<Integer>();
List<String> uniqueIdAr = new ArrayList<String>();
for (ImapMessageInfo mi : messageInfoCol) {
    sequenceNumberAr.add(mi.getSequenceNumber());
    uniqueIdAr.add(mi.getUniqueId());
}

for (MailMessage m : imapClient.fetchMessagesBySequences(sequenceNumberAr)) {
    System.out.println("FetchMessages-sequenceNumberAr : " + m.getSubject());
}

for (MailMessage m : imapClient.fetchMessagesByUids(uniqueIdAr)) {
    System.out.println("FetchMessages-uniqueIdAr : " + m.getSubject());
}

תיוג שיחות אימייל/ארגון אימיילים לשיחות

Aspose.Email מאפשר לקבץ את כל ההעברות, התגובות, ותשובות-לכולם הקשורים לאותה שיחה באופן היררכי. באופן בסיסי, פרוטוקול IMAP עשוי לתמוך ביכולת THREAD המוגדרת ב‑RFC‑5256. בנוסף, קיימת הרחבת IMAP נוספת שמסופקת על‑ידי Gmail ומתוארכת כ‑X-GM-EXT-1.

התכונות הבאות של תיוג שיחות אימייל זמינות לשימוש:

getMessageThreads מתודה - מקבלת שיחות הודעה באמצעות ImapClient.
boolean getGmExt1Supported - מקבל מידע האם הרחבת Gmail X-GM-EXT-1 נתמכת.
boolean getThreadSupported - מקבל מידע האם הרחבת THREAD נתמכת.
String[] getThreadAlgorithms - מקבל אלגוריתמי THREAD נתמכים.

קודד הקוד הבא מציג את השימוש בתכונות אלה לקבלת שיחות אימייל מ‑Gmail:

  ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password", SecurityOptions.SSLImplicit);

try {

    client.selectFolder(ImapFolderInfo.IN_BOX);

   // get a list of messages that we'll group by conversation

   ImapMessageInfoCollection messages = client.listMessages();

   // make sure the IMAP server supports X-GM-EXT-1 extension

   if (client.getGmExt1Supported()) {

       // gets unique conversationId for our example

       Set<String> conversationIds = new HashSet<String>();

       for (ImapMessageInfo messageInfo : messages) {

           if (messageInfo.getConversationId() != null)

                conversationIds.add(messageInfo.getConversationId());

       }

       for (String conversationId : conversationIds) {

           // create the necessary search conditions for a thread

           XGMThreadSearchConditions conditions = new XGMThreadSearchConditions();

            conditions.setConversationId(conversationId);

            conditions.setUseUId(true);

           // get results

           List<MessageThreadResult> conversation = client.getMessageThreads(conditions);

           // print the email conversation in hierarchically manner

           printConversaton("", conversation, messages);

            System.out.println("--------------------");

       }

   }

} finally {

    client.dispose();

}

/**

 * <p>

 * Prints the email conversation in hierarchically manner

 * </p>

 */

public static void printConversaton(String indent, Iterable<MessageThreadResult> conversation,

    Iterable<ImapMessageInfo> messages) {

   for (MessageThreadResult thread : conversation) {

       for (ImapMessageInfo messageInfo : messages) {

           if (thread.getUniqueId().equals(messageInfo.getUniqueId())) {

                System.out.println(indent + " (" + thread.getUniqueId() + ") " + messageInfo.getSubject());

               break;

           }

       }

       if (thread.getChildMessages().size() != 0) {

            printConversaton(indent += "-", thread.getChildMessages(), messages);

       }

   }

}

הקוד משתנה במקצת אם שרת IMAP תומך ביכולת THREAD:

בדוק אם שרת IMAP תומך בהרחבה THREAD:

 if (client.getThreadSupported())

צור תנאי חיפוש מתאימים לשיחה:

 ThreadSearchConditions conditions = new ThreadSearchConditions();

conditions.setAlgorithm(client.getThreadAlgorithms()[0]);

conditions.setUseUId(true);

רשימת הודעות עם תמיכת עימוד

בתרחישים שבהם שרת הדואר מכיל מספר גדול של הודעות בתיבת הדואר, לעיתים רוצים לרשום או לאחזר את ההודעות עם תמיכה בדפדוף. Aspose.Email API ImapClient מאפשר לך לאחזר את ההודעות מהשרת עם תמיכה בדפדוף.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// This example shows the paging support of ImapClient for listing messages from the server
// Available in Aspose.Email for Java and onwards
final ImapClient client = new ImapClient("host.domain.com", 993, "username", "password");
try {
    try {
        int messagesNum = 12;
        int itemsPerPage = 5;
        MailMessage message = null;
        // Create some test messages and append these to server's inbox
        for (int i = 0; i < messagesNum; i++) {
            message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-35157 - " + UUID.randomUUID(),
                    "EMAILNET-35157 Move paging parameters to separate class");
            client.appendMessage(ImapFolderInfo.IN_BOX, message);
        }

        // List messages from inbox
        client.selectFolder(ImapFolderInfo.IN_BOX);
        ImapMessageInfoCollection totalMessageInfoCol = client.listMessages();
        // Verify the number of messages added
        System.out.println(totalMessageInfoCol.size());

        ////////////////// RETREIVE THE MESSAGES USING PAGING SUPPORT////////////////////////////////////

        List<ImapPageInfo> pages = new ArrayList<ImapPageInfo>();
        PageSettings pageSettings = new PageSettings();
        ImapPageInfo pageInfo = client.listMessagesByPage(itemsPerPage, 0, pageSettings);
        System.out.println(pageInfo.getTotalCount());
        pages.add(pageInfo);
        while (!pageInfo.getLastPage()) {
            pageInfo = client.listMessagesByPage(itemsPerPage, pageInfo.getNextPage().getPageOffset(), pageSettings);
            pages.add(pageInfo);
        }
        int retrievedItems = 0;

        // foreach to while statements conversion
        for (ImapPageInfo folderCol : pages) {
            retrievedItems += folderCol.getItems().size();
        }
        System.out.println(retrievedItems);
    } finally {
    }
} finally {
    if (client != null)
        client.dispose();
}

קבלת תיקיות וקריאת הודעות באופן רקורסיבי

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() throws Exception {
    // Create an instance of the ImapClient class
    ImapClient client = new ImapClient();

    // Specify host, username, password, Port and SecurityOptions for your client
    client.setHost("imap.gmail.com");
    client.setUsername("your.username@gmail.com");
    client.setPassword("your.password");
    client.setPort(993);
    client.setSecurityOptions(SecurityOptions.Auto);
    try {
        // The root folder (which will be created on disk) consists of host and username
        String rootFolder = client.getHost() + "-" + client.getUsername();

        // Create the root folder and List all the folders from IMAP server
        new File(rootFolder).mkdirs();
        ImapFolderInfoCollection folderInfoCollection = client.listFolders();
        for (ImapFolderInfo folderInfo : folderInfoCollection) {
            // Call the recursive method to read messages and get sub-folders
            listMessagesInFolder(folderInfo, rootFolder, client);
        }
        // Disconnect to the remote IMAP server
        client.dispose();
    } catch (java.lang.RuntimeException ex) {
        System.out.println(ex);
    }

    System.out.println("Downloaded messages recursively from IMAP server.");
}

/// Recursive method to get messages from folders and sub-folders
private static void listMessagesInFolder(ImapFolderInfo folderInfo, String rootFolder, ImapClient client) {
    // Create the folder in disk (same name as on IMAP server)
    String currentFolder = "data/";
    new File(currentFolder).mkdirs();

    // Read the messages from the current folder, if it is selectable
    if (folderInfo.getSelectable()) {
        // Send status command to get folder info
        ImapFolderInfo folderInfoStatus = client.getFolderInfo(folderInfo.getName());
        System.out.println(folderInfoStatus.getName() + " folder selected. New messages: " + folderInfoStatus.getNewMessageCount() + ", Total messages: "
                + folderInfoStatus.getTotalMessageCount());

        // Select the current folder and List messages
        client.selectFolder(folderInfo.getName());
        ImapMessageInfoCollection msgInfoColl = client.listMessages();
        System.out.println("Listing messages....");
        for (ImapMessageInfo msgInfo : msgInfoColl) {
            // Get subject and other properties of the message
            System.out.println("Subject: " + msgInfo.getSubject());
            System.out.println("Read: " + msgInfo.isRead() + ", Recent: " + msgInfo.getRecent() + ", Answered: " + msgInfo.getAnswered());

            // Get rid of characters like ? and :, which should not be included in a file name and Save the message in MSG format
            String fileName = msgInfo.getSubject().replace(":", " ").replace("?", " ");
            MailMessage msg = client.fetchMessage(msgInfo.getSequenceNumber());
            msg.save(currentFolder + "\\" + fileName + "-" + msgInfo.getSequenceNumber() + ".msg", SaveOptions.getDefaultMsgUnicode());
        }
        System.out.println("============================\n");
    } else {
        System.out.println(folderInfo.getName() + " is not selectable.");
    }

    try {
        // If this folder has sub-folders, call this method recursively to get messages
        ImapFolderInfoCollection folderInfoCollection = client.listFolders(folderInfo.getName());
        for (ImapFolderInfo subfolderInfo : folderInfoCollection) {
            listMessagesInFolder(subfolderInfo, rootFolder, client);
        }
    } catch (java.lang.RuntimeException e) {
    }
}

קבלת UID או מספר רצף של הודעה

ה-API הציבורי של Aspose.Email מספק את התכונות הבאות לקבלת מידע זיהוי של הודעה כגון UID או מספר רצף, שעשוי להידרש בעת עיבוד הודעות שהתקבלו מהשרת:

MailboxInfo מחלקה - מייצגת מידע זיהוי לגבי הודעה בתיבת דואר.

getSequenceNumber() מתודה - מקבלת את מספר הרצף של הודעה.
getUniqueId() מתודה - מקבלת את המזהה הייחודי של הודעה.

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

getItemId מתודה - מייצגת מידע זיהוי על הודעה בתיבת דואר.

דוגמת הקוד למטה מדגימה כיצד לאחזר ולהציג את פרטי ההודעות מתיקיית "INBOX" בשרת IMAP באמצעות ImapClient מחלקה:

try (ImapClient client = new ImapClient(imapHost, port, emailAddress, password, securityOption)) {
    ImapMessageInfoCollection msgs = client.listMessages("INBOX");
    List<Integer> seqIds = new ArrayList<>();
    for (ImapMessageInfo msg : msgs) {
        seqIds.add(msg.getSequenceNumber());
    }
    Iterable<MailMessage> msgsViaFetch = client.fetchMessagesBySequences(seqIds);
    for (MailMessage thisMsg : msgsViaFetch) {
        System.out.println("Message ID: " + thisMsg.getItemId().getUniqueId()
                + " SequenceNumber: " + thisMsg.getItemId().getSequenceNumber()
                + " Subject: " + thisMsg.getSubject());
    }
}

שחזור פרמטרים נוספים כמידע סיכום

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
final ImapClient client = new ImapClient("host.domain.com", "username", "password");
try {
    MailMessage message = new MailMessage("from@domain.com", "to@doman.com", "EMAILNET-38466 - " + UUID.randomUUID().toString(),
            "EMAILNET-38466 Add extra parameters for UID FETCH command");

    // append the message to the server
    String uid = client.appendMessage(message);

    // wait for the message to be appended
    Thread.sleep(5000);

    // Define properties to be fetched from server along with the message
    List<String> messageExtraFields = Arrays.asList("X-GM-MSGID", "X-GM-THRID");

    // retreive the message summary information using it's UID
    ImapMessageInfo messageInfoUID = client.listMessage(uid, messageExtraFields);

    // retreive the message summary information using it's sequence number
    ImapMessageInfo messageInfoSeqNum = client.listMessage(1, messageExtraFields);

    // List messages in general from the server based on the defined properties
    ImapMessageInfoCollection messageInfoCol = client.listMessages(messageExtraFields);

    ImapMessageInfo messageInfoFromList = messageInfoCol.get_Item(0);

    // verify that the parameters are fetched in the summary information
    for (String paramName : messageExtraFields) {
        System.out.println(messageInfoFromList.getExtraParameters().containsKey(paramName));
        System.out.println(messageInfoUID.getExtraParameters().containsKey(paramName));
        System.out.println(messageInfoSeqNum.getExtraParameters().containsKey(paramName));
    }
} finally {
    if (client != null)
        client.dispose();
}

קבלת מידע על כותרת List-Unsubscribe

כותרת List-Unsubscribe מכילה את כתובת ה-URL לביטול מנוי מרשימות דואר אלקטרוני כגון פרסומות, ניוזלטרים וכו’. כדי לקבל את כותרת List-Unsubscribe, השתמש ב- listUnsubscribe מאפיין של מידע הודעה Imap מחלקה. הדוגמה הבאה מציגה את השימוש ב- listUnsubscribe מאפיין לקבלת הכותרת List-Unsubscribe.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

ImapMessageInfoCollection messageInfoCol = imapClient.listMessages();
for (ImapMessageInfo imapMessageInfo : messageInfoCol) {
    System.out.println("ListUnsubscribe Header: " + imapMessageInfo.getListUnsubscribe());
}

Java: עבודה עם דגלי הודעה על השרת

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

שינוי דגלי ההודעה

ניתן לשנות דגלי הודעה על‑ידי שימוש ב- changeMessageFlags() מתודה. מתודה זו מקבלת שני פרמטרים.

מספר סדר ההודעה או מזהה ייחודי.
MessageFlag.

הדגלים הבאים ניתנים להגדרה:

הגדרת דגלי הודעה

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Mark the message as read
client.changeMessageFlags(1, ImapMessageFlags.isRead());

הסרת דגלי הודעה

דגלי הודעה ניתן גם להסיר באמצעות ה removeMessageFlags() מתודה. השימוש דומה לזה של changeMessageFlags() מתודה. היא מקבלת מספר סדר או מזהה הודעה ייחודי ו‑ MessageFlag. הקטע הקוד הבא מציג כיצד להסיר דגלי הודעה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Remove the message flag
client.removeMessageFlags(1, ImapMessageFlags.isRead());

הגדרת דגלים מותאמים

ניתן גם להגדיר דגלים מותאמים אישית להודעה באמצעות ה ImapClient של ה‑API. ה‑ImapClient AddMessageFlags מספקת אפשרות להגדיר דגלים מותאמים אישית על הודעות.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create a message
MailMessage message = new MailMessage("user@domain1.com", "user@domain2.com", "subject", "message");

// Append the message to mailbox
String uid = client.appendMessage(ImapFolderInfo.IN_BOX, message);

// Add custom flags to the added messge
client.addMessageFlags(uid, com.aspose.email.ImapMessageFlags.op_BitwiseOr(ImapMessageFlags.keyword("custom1"), ImapMessageFlags.keyword("custom1_0")));

// Retreive the messages for checking the presence of custom flag
client.selectFolder(ImapFolderInfo.IN_BOX);

ImapMessageInfoCollection messageInfos = client.listMessages();
for (ImapMessageInfo inf : messageInfos) {
    ImapMessageFlags[] flags = inf.getFlags().split();

    if (inf.containsKeyword("custom1"))
        System.out.println("Keyword found");
}

Java: עבודה עם קבצים מצורפים של הודעות באמצעות IMAP

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

רשימת קבצים מצורפים של הודעה באמצעות לקוח IMAP

כדי לקבל מידע על קבצים מצורפים כגון שם, גודל מבלי להוריד את נתוני הקובץ המצורף, השתמש בתכונות ה‑API הבאות:

ImapAttachmentInfo - מייצג מידע קובץ מצורף.
ImapAttachmentInfoCollection - מייצג אוסף של ImapAttachmentInfo.
listAttachments(int sequenceNumber) - מקבל מידע עבור כל קובץ מצורף בהודעה.

הקטע הקוד הבא מציג כיצד להשתמש ב‑IMAP client כדי לקבל מידע על הודעות אימייל והקבצים המצורפים שלהן מהשרת ולאחר מכן להציג את פרטי הקובץ המצורף לכל הודעה. זה מאפשר גישה ועיבוד של קבצים מצורפים מהודעות אימייל באמצעות פרוטוקול IMAP.

ImapMessageInfoCollection messageInfoCollection = imapClient.listMessages();

for (ImapMessageInfo message : messageInfoCollection) {
    ImapAttachmentInfoCollection attachmentInfoCollection =
            imapClient.listAttachments(message.getSequenceNumber());

    for (ImapAttachmentInfo attachmentInfo : attachmentInfoCollection) {
        System.out.println(
                "Attachment: " + attachmentInfo.getName() + " (size: " + attachmentInfo.getSize() + ")");
    }
}

Java: סינון הודעות מהשרת באמצעות לקוח IMAP

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

ה ImapClient class מספקת את listMessages() מתודה אשר מקבלת את כל ההודעות מתיבת דואר. כדי לקבל רק הודעות שתואמות תנאי מסוים, השתמש ב- listMessages() מתודה אשר מקבלת MailQuery כארגומנט. ה- MailQuery המחלקה מספקת מגוון מאפיינים לציון תנאים, לדוגמה תאריך, נושא, שולח, נמען וכד’. הדוגמה הראשונה מדגימה כיצד לסנן הודעות בהתבסס על תאריך ונושא. אנו גם מציגים כיצד לסנן לפי קריטריונים נוספים וכאיך לבנות שאילתות מורכבות יותר. ה-API גם מספק את היכולת להחיל קריטריונים של חיפוש רגיש לרישיות כדי להתאים לקריטריוני סינון מדויקים. בנוסף, ה-API מאפשר לציין את קידוד מחרוזת החיפוש עבור סינון הודעות מתיבת הדואר.

סינון הודעות מתיבת דואר

התחבר והתחבר לשרת IMAP
צור מופע של MailQuery ולקבוע את המאפיינים
הפעל את ImapClient.listMessages(MailQuery query) method והעבר את MailQuery עם הפרמטרים כדי לקבל רק הודעות מסוננות.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP
final String host = "host";
final int port = 143;
final String username = "user@host.com";
final String password = "password";
ImapClient client = new ImapClient(host, port, username, password);
client.selectFolder("Inbox");
// Set conditions, Subject contains "Newsletter", Emails that arrived today
ImapQueryBuilder builder = new ImapQueryBuilder();
builder.getSubject().contains("Newsletter");
builder.getInternalDate().on(new Date());
// Build the query and Get list of messages
MailQuery query = builder.getQuery();
ImapMessageInfoCollection messages = client.listMessages(query);
System.out.println("Imap: " + messages.size() + " message(s) found.");
// Disconnect from IMAP
client.dispose();

קבל הודעות העומדות בקריטריונים ספציפיים

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

תאריך היום.
טווח תאריכים.
משולח ספציפי.
מדומיין ספציפי.
ממען ספציפי.

תאריך היום

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Emails that arrived today
MailQueryBuilder builder = new MailQueryBuilder();
builder.getInternalDate().on(new Date());
~~
### **Date Range*
The following code snippet shows you how to filter emails on the date range.

~~~Java
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Emails that arrived in last 7 days
Calendar cal = Calendar.getInstance();
builder.getInternalDate().before(cal.getTime());
cal.add(Calendar.DATE, -7);
builder.getInternalDate().since(cal.getTime());

שולח ספציפי

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Get emails from specific sender
builder.getFrom().contains("saqib.razzaq@127.0.0.1");

דומיין ספציפי

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Get emails from specific domain
builder.getFrom().contains("SpecificHost.com");

מקבל ספציפי

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Get emails sent to specific recipient
builder.getTo().contains("recipient");

בניית שאילתות מורכבות

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

שילוב שאילתות עם AND

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Emails from specific host, get all emails that arrived before today and all emails that arrived since 7 days ago
builder.getFrom().contains("SpecificHost.com");

Calendar cal = Calendar.getInstance();
builder.getInternalDate().before(cal.getTime());
cal.add(Calendar.DATE, -7);
builder.getInternalDate().since(cal.getTime());

שילוב שאילתות עם OR

MailQueryBuilder מספקת את or() מתודה שלוקחת שני MailQuery מופעים כפרמטרים. הוא מקבל את ההודעות שתואמות לאחד משני התנאים שהוגדרו. הקטע הקוד הבא מראה כיצד לסנן הודעות שהנושא שלהן מכיל "test" או שהן נשלחות מ-"noreply@host.com". הקטע הקוד הבא מראה איך לשלב שאילתות בעזרת OR.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Specify OR condition
builder.or(builder.getSubject().contains("test"), builder.getFrom().contains("noreply@host.com"));

סינון לפי InternalDate

ניתן לחלץ הודעות מהשרת בהתבסס על InternalDate, אך לפעמים השרת אינו מחזיר את כל ההודעות כפי שהן נראות בתיבת הדואר נכנסה. הסיבה יכולה להיות אזור זמן של השרת מכיוון שלא תמיד הוא UTC לכל השרתים כגון Gmail. Aspose שולחת פקודות כגון 008 SEARCH ON 4-May-2014 בהתאם ל- פרוטוקול IMAP עם זאת התוצאה יכולה להשתנות עקב הגדרות אזור זמן של השרת. חבר חדש נוסף ב- מידע הודעה Imap כ־ InternalDate שמסייעת יותר בסינון ההודעות. הקטע הקוד הבא מראה את השימוש ב- InternalDate לסינון הודעות.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP
final String host = "host";
final int port = 143;
final String username = "user@host.com";
final String password = "password";
ImapClient client = new ImapClient(host, port, username, password);
client.selectFolder("Inbox");

// Set conditions, Subject contains "Newsletter", Emails that arrived today
ImapQueryBuilder builder = new ImapQueryBuilder();
builder.getSubject().contains("Newsletter");
builder.getInternalDate().on(new Date());

// Build the query and Get list of messages
MailQuery query = builder.getQuery();
ImapMessageInfoCollection messages = client.listMessages(query);
for (ImapMessageInfo info : messages) {
    System.out.println("Internal Date: " + info.getInternalDate());
}

// Disconnect from IMAP
client.dispose();

סינון אימיילים רגיש לרישיות

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set conditions, Subject contains "Newsletter", Emails that arrived today
ImapQueryBuilder builder = new ImapQueryBuilder();
builder.getSubject().contains("Newsletter", true);
builder.getInternalDate().on(new Date());
MailQuery query = builder.getQuery();

ציין קידוד עבור בניית השאילתא

של ה-API בונה שאילתות Imap הבנאי יכול לשמש לציון הקידוד עבור מחרוזת החיפוש. ניתן גם להגדיר זאת באמצעות ה- DefaultEncoding מאפיין של MailQueryBuilder. הקטע הקוד הבא מראה כיצד לציין קידוד עבור בניית השאילתא.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set conditions
ImapQueryBuilder builder = new ImapQueryBuilder(Charset.forName("utf-8"));
builder.getSubject().contains("ğüşıöç", true);
MailQuery query = builder.getQuery();

סינון הודעות עם תמיכת דפדוף

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
/// <summary>
/// This example shows how to search for messages using ImapClient of the API with paging support
/// Introduced in Aspose.Email for .NET 6.4.0
/// </summary>
final ImapClient client = new ImapClient("host.domain.com", 84, "username", "password");
try {
    try {
        // Append some test messages
        int messagesNum = 12;
        int itemsPerPage = 5;
        MailMessage message = null;
        for (int i = 0; i < messagesNum; i++) {
            message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-35128 - " + UUID.randomUUID(), "111111111111111");
            client.appendMessage(ImapFolderInfo.IN_BOX, message);
        }
        String body = "2222222222222";
        for (int i = 0; i < messagesNum; i++) {
            message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-35128 - " + UUID.randomUUID(), body);
            client.appendMessage(ImapFolderInfo.IN_BOX, message);
        }

        client.selectFolder("Inbox");
        ImapQueryBuilder iqb = new ImapQueryBuilder();
        iqb.getBody().contains(body);
        MailQuery query = iqb.getQuery();

        client.selectFolder(ImapFolderInfo.IN_BOX);
        ImapMessageInfoCollection totalMessageInfoCol = client.listMessages(query);
        System.out.println(totalMessageInfoCol.size());

        //////////////////////////////////////////////////////

        List<ImapPageInfo> pages = new ArrayList<ImapPageInfo>();

        PageSettings ps = new PageSettings();
        ps.setFolderName(ImapFolderInfo.IN_BOX);
        PageInfo pi = new PageInfo(itemsPerPage);
        ImapPageInfo pageInfo = client.listMessagesByPage(query, pi, ps);

        pages.add(pageInfo);
        while (!pageInfo.getLastPage()) {
            pageInfo = client.listMessagesByPage(query, pageInfo.getNextPage(), ps);
            pages.add(pageInfo);
        }
        int retrievedItems = 0;
        // foreach to while statements conversion
        for (ImapPageInfo folderCol : pages) {
            retrievedItems += folderCol.getItems().size();
        }
    } finally {
    }
} finally {
    if (client != null)
        client.dispose();
}

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapQueryBuilder queryBuilder = new ImapQueryBuilder();

queryBuilder.hasFlags(ImapMessageFlags.keyword("custom1"));

queryBuilder.hasNoFlags(ImapMessageFlags.keyword("custom2"));

סינון הודעות באמצעות חיפוש מותאם

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

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

ImapQueryBuilder builder = new ImapQueryBuilder();
builder.customSearch("X-GM-RAW \"has:attachment\"");
MailQuery query = builder.getQuery();
messageInfoCol = client.listMessages(query);

Java: מחיקת הודעות מהשרת

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

מחיקת הודעות

ה ImapClient המחלקה יכולה למחוק הודעות משרת IMAP. ה ImapClient מחלקה deleteMessage() פונקציה משמשת למחיקת הודעות. היא מקבלת את מספר סדר ההודעה או מזהה ייחודי כפרמטר. ה ImapClient מספקת deleteMessage ו deleteMessages שיטות למחיקת הודעות אחת אחת או מרובות. הקטע הקוד הבא מציג כיצד למחוק הודעת אימייל עם מזהה הודעה 1 משרת IMAP.

try (ImapClient client = new ImapClient("host", "username", "password")) {
    client.setSecurityOptions(SecurityOptions.SSLImplicit);

    // Append test message
    client.selectFolder(ImapFolderInfo.IN_BOX);

    MailMessage eml = new MailMessage("from@from.com", "to@to.com");
    eml.setSubject("Message to delete");
    eml.setBody("Hey! This Message will be deleted!");
    String emlId = client.appendMessage(eml);

    // Delete appended message
    client.deleteMessage(emlId);
    client.commitDeletes();
}

מחיקת הודעות מרובות

ניתן למחוק מספר הודעות אימייל מתיבת הדואר באמצעות ה ImapClient מ‑API של Aspose.Email. ה deleteMessages המתודה מספקת מספר אפשרויות למחיקת הודעות מרובות מהשרת באמצעות מזהים ייחודיים, מספרי סדר או אוסף מידע הודעה Imap אלמנטים. הקטע הקוד הבא מראה כיצד למחוק הודעות מרובות.

try (ImapClient client = new ImapClient("host", "username", "password")) {
    client.selectFolder(ImapFolderInfo.IN_BOX);

    // Append test messages
    List<MailMessage> emlList = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        MailMessage eml = new MailMessage("from@from.com", "to@to.com");
        eml.setSubject("Message to delete " + i);
        eml.setBody("Hey! This Message will be deleted!");

        emlList.add(eml);
    }

    AppendMessagesResult appendMessagesResult = client.appendMessages(emlList);
    List<String> uidList = new ArrayList<>();
    for (String uid : appendMessagesResult.getSucceeded().getValues()) {
        uidList.add(uid);
    }

    // Bulk Delete appended Messages
    client.deleteMessagesByUids(uidList, true);
    client.commitDeletes();
}

Java: עבודה עם תיקיות בשרת IMAP

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

קבלת מידע על תיקיות

קבלת מידע על תיקיות משרת IMAP היא קלה מאוד עם Aspose.Email. קרא ל- listFolders() שיטה של ImapClient מחלקה. היא מחזירה אובייקט של אוסף מידע תיקייה Imap סוג. חזור על האוסף הזה וקבל מידע על תיקיות בודדות בלולאה. המתודה מוטעמת. אתה יכול להעביר שם תיקייה כפרמטר כדי לקבל רשימת תת‑תיקיות. קטע הקוד הבא מראה כיצד לקבל מידע על תיקייה משרת IMAP באמצעות המתודה המתוארת של Aspose.Email.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Get all folders in the currently subscribed folder
ImapFolderInfoCollection folderInfoColl = client.listFolders();

// Iterate through the collection to get folder info one by one
for (ImapFolderInfo folderInfo : (Iterable<ImapFolderInfo>) folderInfoColl) {
    // Folder name and get New messages in the folder
    System.out.println("Folder name is " + folderInfo.getName());
    ImapFolderInfo folderExtInfo = client.getFolderInfo(folderInfo.getName());
    System.out.println("New message count: " + folderExtInfo.getNewMessageCount());
    System.out.println("Is it readonly? " + folderExtInfo.getReadOnly());
    System.out.println("Total number of messages " + folderExtInfo.getTotalMessageCount());
}

מחיקה ושינוי שם של תיקיות

תיקייה בשרת IMAP יכולה להימחק או לשנות שם בשורה אחת עם Aspose.Email:

ה deleteFolder() מתודה מקבלת את שם התיקייה כפרמטר.
ל- renameFolder() מתודה, עליך להעביר את שם התיקייה הנוכחית ואת שם התיקייה החדשה. קטע הקוד הבא מראה כיצד להסיר תיקייה משרת IMAP וכיצד לשנות שם תיקייה. כל פעולה מבוצעת בשורה אחת של קוד.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Delete a folder and Rename a folder
client.deleteFolder("foldername");
client.renameFolder("foldername", "newfoldername");

הוספת הודעה חדשה בתיקייה

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create a message
MailMessage msg = new MailMessage("user@domain1.com", "user@domain2.com", "subject", "message");

// Subscribe to the Inbox folder and Append the newly created message
client.selectFolder(ImapFolderInfo.IN_BOX);
client.subscribeFolder(client.getCurrentFolder().getName());
client.appendMessage(client.getCurrentFolder().getName(), msg);

הוספת הודעות מרובות עם תמיכת MultiConnection

אתה יכול להוסיף הודעות מרובות באמצעות appendMessages מתודה המסופקת על‑ידי ה- ImapClient מחלקה. ה- appendMessages מתודה מקבלת רשימה של MailMessage ומוסיף אותה לתיקייה הנוכחית אם התיקייה לא ניתנת כפרמטר. ImapClient תומך גם במצב MultiConnection לפעולות בעומס גבוה. קטע הקוד הבא מראה כיצד להוסיף הודעות מרובות באמצעות מצב MultiConnection.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

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(), "IMAP Group Append with MultiConnection");
    messages.add(message);
}

imapClient.setConnectionsQuantity(5);
imapClient.setUseMultiConnection(MultiConnectionMode.Enable);
imapClient.appendMessages(messages);

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

העבר הודעות לתיקיית דואר אחרת

Aspose.Email for Java מאפשר להעביר הודעה מתיקיית דואר אחת לאחרת באמצעות ImapClient API. ה moveMessage המתודה משתמשת במזהה הייחודי של ההודעה ובשם תיקיית היעד להעברת הודעה לתיקיית היעד. הקטע הקוד הבא מראה כיצד להעביר הודעות לתיקיית דואר אחרת.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// This example shows how to move a message from one folder of a mailbox to another one using the ImapClient API of Aspose.Email for Java
// Available from Aspose.Email for Java onwards
// -------------- Available API Overload Members --------------
// void ImapClient.moveMessage(IConnection iConnection, int sequenceNumber, String folderName, boolean commitDeletions)
// void ImapClient.moveMessage(IConnection iConnection, String uniqueId, String folderName, boolean commitDeletions)
// void ImapClient.moveMessage(int sequenceNumber, String folderName, boolean commitDeletions)
// void ImapClient.moveMessage(String uniqueId, String folderName, boolean commitDeletions)
// void ImapClient.moveMessage(IConnection iConnection, int sequenceNumber, String folderName)
// void ImapClient.moveMessage(IConnection iConnection, String uniqueId, String folderName)
// void ImapClient.moveMessage(int sequenceNumber, String folderName)
// void ImapClient.moveMessage(String uniqueId, String folderName)

final ImapClient client = new ImapClient("host.domain.com", 993, "username", "password");
try {
    String folderName = "EMAILNET-35151";
    if (!client.existFolder(folderName))
        client.createFolder(folderName);
    try {
        MailMessage message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-35151 - " + UUID.randomUUID(),
                "EMAILNET-35151 ImapClient: Provide option to Move Message");
        client.selectFolder(ImapFolderInfo.IN_BOX);
        // Append the new message to Inbox folder
        String uniqueId = client.appendMessage(ImapFolderInfo.IN_BOX, message);
        ImapMessageInfoCollection messageInfoCol1 = client.listMessages();
        System.out.println(messageInfoCol1.size());
        // Now move the message to the folder EMAILNET-35151
        client.moveMessage(uniqueId, folderName);
        client.commitDeletes();
        // Verify that the message was moved to the new folder
        client.selectFolder(folderName);
        messageInfoCol1 = client.listMessages();
        System.out.println(messageInfoCol1.size());
        // Verify that the message was moved from the Inbox
        client.selectFolder(ImapFolderInfo.IN_BOX);
        messageInfoCol1 = client.listMessages();
        System.out.println(messageInfoCol1.size());
    } finally {
        try {
            client.deleteFolder(folderName);
        } catch (java.lang.RuntimeException e) {
        }
    }
} finally {
    if (client != null)
        client.dispose();
}

העתק הודעות לתיקיית דואר אחרת

ה‑API של Aspose.Email מספק את היכולת להעתיק הודעה מתיקיית דואר אחת לאחרת. הוא מאפשר העתקה של הודעה יחידה וכן של הודעות מרובות באמצעות copyMessage ו copyMessages מתודות. ה- copyMessages מתודה מספקת את היכולת להעתיק הודעות מרובות מתיקיית המקור של תיבת דואר אל תיקיית היעד. קטע הקוד הבא מראה כיצד להעתיק הודעות לתיקיית דואר אחרת.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
final ImapClient client = new ImapClient("exchange.aspose.com", "username", "password");
try {
    // Create the destination folder
    String folderName = "EMAILNET-35242";
    if (!client.existFolder(folderName))
        client.createFolder(folderName);
    try {
        // Append a couple of messages to the server
        MailMessage message1 = new MailMessage("asposeemail.test3@aspose.com", "asposeemail.test3@aspose.com", "EMAILNET-35242 - " + UUID.randomUUID(),
                "EMAILNET-35242 Improvement of copy method.Add ability to 'copy' multiple messages per invocation.");
        String uniqueId1 = client.appendMessage(message1);

        MailMessage message2 = new MailMessage("asposeemail.test3@aspose.com", "asposeemail.test3@aspose.com", "EMAILNET-35242 - " + UUID.randomUUID(),
                "EMAILNET-35242 Improvement of copy method.Add ability to 'copy' multiple messages per invocation.");
        String uniqueId2 = client.appendMessage(message2);

        // Verify that the messages have been added to the mailbox
        client.selectFolder(ImapFolderInfo.IN_BOX);
        ImapMessageInfoCollection msgsColl = client.listMessages();
        for (ImapMessageInfo msgInfo : msgsColl)
            System.out.println(msgInfo.getSubject());

        // Copy multiple messages using the CopyMessages command and Verify that messages are copied to the destination folder
        client.copyMessagesByUids(Arrays.asList(uniqueId1, uniqueId2), folderName);

        client.selectFolder(folderName);
        msgsColl = client.listMessages();
        for (ImapMessageInfo msgInfo : msgsColl)
            System.out.println(msgInfo.getSubject());
    } finally {
        try {
            client.deleteFolder(folderName);
        } catch (java.lang.RuntimeException e) {
        }
    }
} finally {
    if (client != null)
        client.dispose();
}

עבודה עם תיקיות תיבת דואר בשימוש מיוחד

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapClient imapClient = new ImapClient();
imapClient.setHost("<HOST>");
imapClient.setPort(993);
imapClient.setUsername("<USERNAME>");
imapClient.setPassword("<PASSWORD>");
imapClient.setSupportedEncryption(EncryptionProtocols.Tls);
imapClient.setSecurityOptions(SecurityOptions.SSLImplicit);

ImapMailboxInfo mailboxInfo = imapClient.getMailboxInfo();
System.out.println(mailboxInfo.getInbox());
System.out.println(mailboxInfo.getDraftMessages());
System.out.println(mailboxInfo.getJunkMessages());
System.out.println(mailboxInfo.getSentMessages());
System.out.println(mailboxInfo.getTrash());

Java: עבודה עם ImapClient באופן אסינכרוני

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

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

איחזור הודעות באופן אסינכרוני

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP
try (ImapClient client = new ImapClient("host", "username", "password")) {
    client.selectFolder("Issues/SubFolder");
    ImapMessageInfoCollection messages = client.listMessages();
    IAsyncResult ar = client.beginFetchMessage(messages.get_Item(0).getSequenceNumber());
    MailMessage message = client.endFetchMessage(ar);
}

רשימת הודעות בצורה אסינכרונית עם MailQuery

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
ImapQueryBuilder builder = new ImapQueryBuilder();
builder.getSubject().contains("Subject");
MailQuery query = builder.getQuery();
IAsyncResult asyncResult = client.beginListMessages(query);
ImapMessageInfoCollection messages = client.endListMessages(asyncResult);

Java: רישום הרחבות שרת IMAP

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP
ImapClient client = new ImapClient("imap.gmail.com", "username", "password");
String[] getCapabilities = client.getCapabilities();
for (String getCap : getCapabilities) {
    System.out.println(getCap);
}

Java: תמיכה בפקודת IMAP IDLE

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

Aspoe.Email API ImapClient מספקת את היכולת לפתוח חיבור לשרת ולהמתין להגעת הודעת אימייל. זה מאפשר להימנע משאלת השרת שוב ושוב עבור כל אימייל נכנס. הקטע הקוד הבא מראה כיצד לתמוך בפקודת IMAP Idle.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP
ImapClient client = new ImapClient("imap.domain.com", "username", "password");

client.startMonitoring(new ImapMonitoringEventHandler() {
    public void invoke(Object sender, ImapMonitoringEventArgs e) {
        System.out.println(e.getNewMessages().length);
        System.out.println(e.getDeletedMessages().length);
    }
});
client.stopMonitoring("Inbox");

Java: תמיכה בפקודת IMAP IDLE והרחבות

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

תמיכה בפקודת IMAP Idle

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Connect and log in to IMAP
ImapClient client = new ImapClient("imap.domain.com", "username", "password");

client.startMonitoring(new ImapMonitoringEventHandler() {
    public void invoke(Object sender, ImapMonitoringEventArgs e) {
        System.out.println(e.getNewMessages().length);
        System.out.println(e.getDeletedMessages().length);
    }
});
client.stopMonitoring("Inbox");

תמיכה בהרחבות IMAP

Aspose.Email API מספק תמיכה בהרחבות IMAP. ההרחבות הבאות של IMAP נתמכות על‑ידי ה‑API כעת. הרחבות אלו אינן נתמכות על‑ידי כל השרתים.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
final ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password");
try {
    // Set SecurityOptions
    client.setSecurityOptions(SecurityOptions.Auto);
    System.out.println(client.getIdSupported());

    ImapIdentificationInfo serverIdentificationInfo1 = client.introduceClient();
    ImapIdentificationInfo serverIdentificationInfo2 = client.introduceClient(ImapIdentificationInfo.getDefaultValue());

    // Display ImapIdentificationInfo properties
    System.out.println(serverIdentificationInfo1.toString() + serverIdentificationInfo2.toString());
    System.out.println(serverIdentificationInfo1.getName());
    System.out.println(serverIdentificationInfo1.getVendor());
    System.out.println(serverIdentificationInfo1.getSupportUrl());
    System.out.println(serverIdentificationInfo1.getVersion());
} finally {
    if (client != null)
        client.dispose();
}

פקודת רשימה מורחבת של IMAP4

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
final ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password");
try {
    ImapFolderInfoCollection folderInfoCol = client.listFolders("*");
    System.out.println("Extended List Supported: " + client.getExtendedListSupported());
    for (ImapFolderInfo folderInfo : (Iterable<ImapFolderInfo>) folderInfoCol) {
        if (folderInfo.getName().equals("[Gmail]/All Mail"))
            System.out.println("Has Children: " + folderInfo.hasChildren());
        if (folderInfo.getName().equals("[Gmail]/Bin"))
            System.out.println("Bin has children? " + folderInfo.hasChildren());
        if (folderInfo.getName().equals("[Gmail]/Drafts"))
            System.out.println("Drafts has children? " + folderInfo.hasChildren());
        if (folderInfo.getName().equals("[Gmail]/Important"))
            System.out.println("Important has Children? " + folderInfo.hasChildren());
        if (folderInfo.getName().equals("[Gmail]/Sent Mail"))
            System.out.println("Sent Mail has Children? " + folderInfo.hasChildren());
        if (folderInfo.getName().equals("[Gmail]/Spam"))
            System.out.println("Spam has Children? " + folderInfo.hasChildren());
        if (folderInfo.getName().equals("[Gmail]/Starred"))
            System.out.println("Starred has Children? " + folderInfo.hasChildren());
    }
} finally {
    if (client != null)
        client.dispose();
}

Java: פעולת גיבוי ושחזור IMAP

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

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

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

גיבוי הודעות

כדי לגבות הודעות, השתמש ב‑ ImapClient.backup מתודה כפי שמודגם בקטע הקוד הבא.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";
// Create an instance of the ImapClient class
ImapClient imapClient = new ImapClient();

// Specify host, username and password, and set port for your client
imapClient.setHost("imap.gmail.com");
imapClient.setUsername("your.username@gmail.com");
imapClient.setPassword("your.password");
imapClient.setPort(993);
imapClient.setSecurityOptions(SecurityOptions.Auto);

ImapMailboxInfo mailboxInfo = imapClient.getMailboxInfo();

ImapFolderInfo info = imapClient.getFolderInfo(mailboxInfo.getInbox().getName());
ImapFolderInfoCollection infos = new ImapFolderInfoCollection();
infos.addItem(info);

imapClient.backup(infos, dataDir + "\\ImapBackup.pst", com.aspose.email.BackupSettings.to_BackupSettings(BackupOptions.Recursive));

שחזור הודעות

כדי לגבות הודעות, השתמש ב‑ ImapClient.restore מתודה כפי שמודגם בקטע הקוד הבא.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";
// Create an instance of the ImapClient class
ImapClient imapClient = new ImapClient();

// Specify host, username and password, and set port for your client
imapClient.setHost("imap.gmail.com");
imapClient.setUsername("your.username@gmail.com");
imapClient.setPassword("your.password");
imapClient.setPort(993);
imapClient.setSecurityOptions(SecurityOptions.Auto);

ImapRestoreSettings settings = new ImapRestoreSettings();
settings.setRecursive(true);
PersonalStorage pst = PersonalStorage.fromFile(dataDir + "\\ImapBackup.pst");
imapClient.restore(pst, settings);

פעולת גיבוי ושחזור IMAP עם MultiConnection

כאשר עובדים עם מספר גדול של הודעות, פעולת הגיבוי/שחזור יכולה לקחת זמן רב. לשם כך, ה‑API מספק תמיכה בריבוי חיבורים במהלך פעולת הגיבוי והשחזור. כדי להפעיל את מצב MultiConnection, הגדר ImapClient.UseMultiConnection מאפיין ל MultiConnectionMode.Enable. קטעי הקוד הבאים מדגימים פעולות גיבוי ושחזור עם מצב MultiConnection מופעל.

גיבוי הודעות עם MultiConnection

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";
// Create an instance of the ImapClient class
ImapClient imapClient = new ImapClient();

// Specify host, username and password, and set port for your client
imapClient.setHost("imap.gmail.com");
imapClient.setUsername("your.username@gmail.com");
imapClient.setPassword("your.password");
imapClient.setPort(993);
imapClient.setSecurityOptions(SecurityOptions.Auto);

imapClient.setUseMultiConnection(MultiConnectionMode.Enable);

ImapMailboxInfo mailboxInfo = imapClient.getMailboxInfo();

ImapFolderInfo info = imapClient.getFolderInfo(mailboxInfo.getInbox().getName());
ImapFolderInfoCollection infos = new ImapFolderInfoCollection();
infos.addItem(info);

imapClient.backup(infos, dataDir + "\\ImapBackup.pst", com.aspose.email.BackupSettings.to_BackupSettings(BackupOptions.Recursive));

שחזור הודעות עם MultiConnection

קטעי הקוד הבאים מדגמים פעולה של שחזור עם מצב MultiConnection מופעל.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";
// Create an instance of the ImapClient class
ImapClient imapClient = new ImapClient();

// Specify host, username and password, and set port for your client
imapClient.setHost("imap.gmail.com");
imapClient.setUsername("your.username@gmail.com");
imapClient.setPassword("your.password");
imapClient.setPort(993);
imapClient.setSecurityOptions(SecurityOptions.Auto);

imapClient.setUseMultiConnection(MultiConnectionMode.Enable);

ImapRestoreSettings settings = new ImapRestoreSettings();
settings.setRecursive(true);
PersonalStorage pst = PersonalStorage.fromFile(dataDir + "\\Outlook.pst");
imapClient.restore(pst, settings);