Praca z wiadomościami z serwera IMAP

Wyświetlanie ID wiadomości MIME z serwera

ImapMessageInfo udostępnia MIME MessageId do identyfikacji wiadomości bez wyciągania całej wiadomości. Poniższy fragment kodu pokazuje, jak wyświetlić 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());
}

Listowanie wiadomości z serwera

Aspose.Email udostępnia dwuelementową przeciążoną wersję listMessages() aby pobrać określoną liczbę wiadomości na podstawie zapytania. Poniższy fragment kodu pokazuje, jak listować wiadomości.

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

Rekurencyjne listowanie wiadomości z serwera

Protokół IMAP obsługuje rekurencyjne listowanie wiadomości z folderu skrzynki. Dzięki temu można również wyświetlać wiadomości z podfolderów. Poniższy fragment kodu pokazuje, jak listować wiadomości rekurencyjnie.

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

Listowanie wiadomości z wieloma połączeniami

ImapClient zapewnia UseMultiConnection właściwość, której można używać do tworzenia wielu połączeń przy intensywnych operacjach. Możesz także ustawić liczbę połączeń używanych w trybie wielokrotnego połączenia, używając ImapClient.ConnectionsQuantity. Poniższy fragment kodu demonstruje użycie trybu wielokrotnego połączenia do listowania wiadomości i porównuje jego wydajność z trybem jednego połączenia.

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

Należy zauważyć, że użycie trybu wielokonekowego nie gwarantuje zwiększenia wydajności.

Pobierz wiadomości w kolejności malejącej

Aspose.Email udostępnia ImapClient.listMessagesByPage metoda, która wymienia wiadomości z obsługą stronicowania. Niektóre przeciążenia ImapClient.listMessagesByPage przyjmuje PageSettings jako parametr. PageSettings zapewnia AscendingSorting właściwość, która po ustawieniu na false, zwraca e-maile w kolejności malejącej.

Poniższy kod przykładu demonstruje użycie AscendingSorting właściwość PageSettings klasa do zmiany kolejności e-maili.

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

Pobierz wiadomości z serwera i zapisz na dysku

Ten ImapClient klasa może pobierać wiadomości z serwera IMAP i zapisywać je w formacie EML na lokalnym dysku. Następujące kroki są wymagane, aby zapisać wiadomości na dysku:

Utwórz instancję ImapClient klasa.
Określ nazwę hosta, port, nazwę użytkownika i hasło w ImapClient constructor.
Wybierz folder używając selectFolder() metoda.
Wywołaj listMessages metodę, aby uzyskać ImapMessageInfoCollection obiekt.
Iteruj przez ImapMessageInfoCollection kolekcję, wywołaj saveMessage() metodę i podać ścieżkę wyjściową oraz nazwę pliku.

Poniższy fragment kodu pokazuje, jak pobrać wiadomości e-mail z serwera i je zapisać.

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

Zapisywanie wiadomości w formacie MSG

W powyższym przykładzie, e-maile są zapisywane w formacie EML. Aby zapisać e-maile w formacie MSG, ImapClient.fetchMessage() metodę należy wywołać. Zwraca wiadomość jako instancję MailMessage klasa. Ta MailMessage.save() metodę można następnie wywołać, aby zapisać wiadomość w formacie MSG. Poniższy fragment kodu pokazuje, jak zapisać wiadomości w formacie 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());
}

Grupowe pobieranie wiadomości

ImapClient zapewnia fetchMessages metoda, która przyjmuje iterowalny zestaw numerów sekwencyjnych lub unikalnych ID i zwraca listę MailMessage. Poniższy fragment kodu demonstruje użycie fetchMessages metoda pobierająca wiadomości według numerów sekwencyjnych i unikalnego 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());
}

Wątkowanie e-maili / organizowanie e-maili w konwersacje

Aspose.Email umożliwia grupowanie wszystkich wiadomości typu forward, reply oraz reply-all związanych z tą samą konwersacją w sposób hierarchiczny. Zasadniczo protokół IMAP może obsługiwać możliwość THREAD określoną w RFC-5256. Ponadto istnieje inne rozszerzenie IMAP udostępniane przez Gmail, opisane jako X-GM-EXT-1.

Poniższe funkcje wątkowania e-maili są dostępne do użycia:

getMessageThreads metoda – otrzymuje wątki wiadomości przez ImapClient.
boolean getGmExt1Supported - Pobiera informację, czy rozszerzenie Gmail X-GM-EXT-1 jest wspierane.
boolean getThreadSupported - Pobiera informację, czy rozszerzenie THREAD jest wspierane.
String[] getThreadAlgorithms - Pobiera obsługiwane algorytmy THREAD.

Poniższe przykłady kodu pokazują użycie tych funkcji do pobierania wątków e-mailowych z Gmaila:

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

       }

   }

}

Kod nieco się zmienia, jeśli serwer IMAP obsługuje możliwość THREAD:

Sprawdź, czy serwer IMAP obsługuje rozszerzenie THREAD:

 if (client.getThreadSupported())

Utwórz odpowiednie warunki wyszukiwania dla wątku:

 ThreadSearchConditions conditions = new ThreadSearchConditions();

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

conditions.setUseUId(true);

Wyświetlanie wiadomości z obsługą stronicowania

W sytuacjach, gdy serwer poczty zawiera dużą liczbę wiadomości w skrzynce, często pożądane jest wyświetlanie lub pobieranie wiadomości z obsługą stronicowania. API Aspose.Email ImapClient pozwala pobrać wiadomości z serwera z obsługą stronicowania.

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

Pobieranie folderów i czytanie wiadomości rekurencyjnie

W tym artykule, większość ImapClient funkcje są wykorzystywane do stworzenia aplikacji, która rekurencyjnie wymienia wszystkie foldery i podfoldery z serwera IMAP. Zapisuje również wiadomości w każdym folderze i podfolderze w formacie MSG na lokalnym dysku. Na dysku foldery i wiadomości są tworzone i zapisywane w tej samej strukturze hierarchicznej co na serwerze IMAP. Poniższy fragment kodu pokazuje, jak pobrać wiadomości i informacje o podfolderach rekurencyjnie.

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

Pobierz UID wiadomości lub numer sekwencji

Publiczne API Aspose.Email udostępnia następujące funkcje umożliwiające uzyskanie informacji identyfikacyjnych wiadomości, takich jak UID lub numer sekwencji, które mogą być wymagane przy przetwarzaniu wiadomości otrzymanych z serwera:

MailboxInfo klasa - Reprezentuje informacje identyfikacyjne o wiadomości w skrzynce pocztowej.

getSequenceNumber() metoda – pobiera numer sekwencji wiadomości.
getUniqueId() metoda – pobiera unikalny identyfikator wiadomości.

MailMessage klasa – reprezentuje wiadomość e-mail i umożliwia dostęp do właściwości wiadomości, np. tematu, treści, nadawcy oraz adresów odbiorców itp.

getItemId metoda – reprezentuje informacje identyfikacyjne o wiadomości w skrzynce pocztowej.

Poniższy przykład kodu pokazuje, jak pobrać i wyświetlić szczegóły wiadomości z folderu "INBOX" na serwerze IMAP za pomocą ImapClient klasa:

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

Pobieranie dodatkowych parametrów jako informacji podsumowującej

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

Uzyskiwanie informacji o nagłówku List-Unsubscribe

Nagłówek List-Unsubscribe zawiera adres URL umożliwiający wypisanie się z list mailingowych, np. reklam, biuletynów itp. Aby uzyskać nagłówek List-Unsubscribe, użyj listUnsubscribe właściwość ImapMessageInfo klasa. Poniższy przykład pokazuje użycie listUnsubscribe właściwość umożliwiająca pobranie nagłówka 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());
}

Łączenie się z serwerem IMAP Praca z flagami wiadomości na serwerze