Arbeiten mit Nachrichten vom IMAP‑Server

Auflisten von MIME-Nachrichten-IDs vom Server

ImapMessageInfo bietet das MIME MessageId zur Nachrichtenidentifikation, ohne die komplette Nachricht zu extrahieren. Das folgende Code‑Snippet zeigt, wie man MIME‑MessageId auflistet.

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

Nachrichten vom Server auflisten

Aspose.Email bietet eine zweifache, überladene Variante von listMessages() um eine bestimmte Anzahl von Nachrichten basierend auf einer Abfrage abzurufen. Das folgende Code‑Snippet zeigt, wie man Nachrichten auflistet.

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

Nachrichten rekursiv vom Server auflisten

Das IMAP‑Protokoll unterstützt das rekursive Auflisten von Nachrichten aus einem Postfachordner. Das hilft, Nachrichten auch aus Unterordnern eines Ordners aufzulisten. Das folgende Code‑Snippet zeigt, wie man Nachrichten rekursiv auflistet.

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

Nachrichten mit MultiConnection auflisten

ImapClient bietet ein UseMultiConnection Eigenschaft, die verwendet werden kann, um mehrere Verbindungen für umfangreiche Vorgänge zu erstellen. Sie können auch die Anzahl der Verbindungen festlegen, die im Multi‑Connection‑Modus verwendet werden sollen, indem Sie ImapClient.ConnectionsQuantity. Das folgende Code‑Snippet demonstriert die Verwendung des Multi‑Verbindungs‑Modus zum Auflisten von Nachrichten und vergleicht dessen Leistung mit dem Einzel‑Verbindungs‑Modus.

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

Bitte beachten Sie, dass die Verwendung des Mehrfachverbindungs‑Modus keine Leistungssteigerung garantiert.

Nachrichten in absteigender Reihenfolge abrufen

Aspose.Email bietet ImapClient.listMessagesByPage Methode, die Nachrichten mit Paging-Unterstützung auflistet. Einige Überladungen von ImapClient.listMessagesByPage akzeptiert PageSettings als Parameter zur Verfügung. PageSettings stellt ein AscendingSorting Eigenschaft, die, wenn auf false gesetzt, E-Mails in absteigender Reihenfolge zurückgibt.

Der folgende Beispielcode demonstriert die Verwendung von AscendingSorting Eigenschaft des PageSettings Klasse zum Ändern der Reihenfolge von E-Mails.

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

Nachrichten vom Server abrufen und auf die Festplatte speichern

Die ImapClient Klasse kann Nachrichten von einem IMAP-Server abrufen und die Nachrichten im EML-Format auf einer lokalen Festplatte speichern. Die folgenden Schritte sind erforderlich, um die Nachrichten zu speichern:

Erstellen Sie eine Instanz von dem ImapClient Klasse.
Geben Sie im ImapClient einen Hostnamen, Port, Benutzernamen und Passwort an constructor.
Wählen Sie den Ordner aus mit selectFolder() Methode.
Rufen Sie die listMessages Methode, um das ImapMessageInfoCollection Objekt.
Iterieren Sie durch die ImapMessageInfoCollection Sammlung, rufen Sie die saveMessage() Methode und geben Sie den Ausgabepfad sowie den Dateinamen an.

Das folgende Codefragment zeigt, wie man E-Mail-Nachrichten von einem Server abruft und speichert.

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

Nachrichten im MSG-Format speichern

Im obigen Beispiel, werden die E-Mails im EML-Format gespeichert. Um E-Mails im MSG-Format zu speichern, die ImapClient.fetchMessage() Methode muss aufgerufen werden. Sie gibt die Nachricht als Instanz von MailMessage Klasse. Die MailMessage.save() Methode kann anschließend aufgerufen werden, um die Nachricht im MSG-Format zu speichern. Das folgende Codefragment zeigt, wie Nachrichten im MSG-Format gespeichert werden.

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

Gruppenabfrage von Nachrichten

ImapClient bietet ein fetchMessages Methode, die ein Iterable von Sequenznummern oder eindeutiger ID akzeptiert und eine Liste von MailMessage. Das folgende Code‑Snippet demonstriert die Verwendung von fetchMessages Methode zum Abrufen von Nachrichten mittels Sequenznummern und eindeutiger 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());
}

E-Mail-Threading/E-Mails in Konversationen organisieren

Aspose.Email ermöglicht es, alle Weiterleitungen, Antworten und Alle-Antworten, die sich auf dieselbe Konversation beziehen, hierarchisch zu gruppieren. Grundsätzlich kann das IMAP-Protokoll die in RFC‑5256 definierte THREAD-Fähigkeit unterstützen. Zusätzlich gibt es eine weitere von Gmail bereitgestellte IMAP-Erweiterung, die als X‑GM‑EXT‑1 beschrieben wird.

Die folgenden E-Mail-Threading-Funktionen stehen zur Verfügung:

getMessageThreads Methode – Empfängt Nachrichten-Threads nach ImapClient.
boolean getGmExt1Supported - Gibt Auskunft darüber, ob die Gmail X-GM-EXT-1-Erweiterung unterstützt wird.
boolean getThreadSupported - Gibt Auskunft darüber, ob die THREAD-Erweiterung unterstützt wird.
String[] getThreadAlgorithms - Holt unterstützte THREAD-Algorithmen.

Die folgenden Codebeispiele zeigen die Verwendung dieser Funktionen, um E-Mail-Threads von Gmail abzurufen:

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

       }

   }

}

Der Code ändert sich geringfügig, wenn der IMAP-Server die THREAD-Fähigkeit unterstützt:

Prüfen Sie, ob der IMAP-Server die THREAD-Erweiterung unterstützt:

 if (client.getThreadSupported())

Erstellen Sie die geeigneten Suchbedingungen für einen Thread:

 ThreadSearchConditions conditions = new ThreadSearchConditions();

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

conditions.setUseUId(true);

Auflisten von Nachrichten mit Paging‑Unterstützung

In Szenarien, in denen der E-Mail-Server eine große Anzahl von Nachrichten im Postfach enthält, ist es häufig gewünscht, die Nachrichten mit Paging-Unterstützung aufzulisten oder abzurufen. Aspose.Email API ImapClient ermöglicht das Abrufen von Nachrichten vom Server mit Paging-Unterstützung.

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

Ordner abrufen und Nachrichten rekursiv lesen

In diesem Artikel sind die meisten ImapClient Funktionen werden verwendet, um eine Anwendung zu erstellen, die alle Ordner und Unterordner rekursiv von einem IMAP-Server auflistet. Sie speichert außerdem die Nachrichten in jedem Ordner und Unterordner im MSG-Format auf einer lokalen Festplatte. Auf der Festplatte werden Ordner und Nachrichten in derselben hierarchischen Struktur wie auf dem IMAP-Server erstellt und gespeichert. Das folgende Codefragment zeigt, wie man Nachrichten und Unterordner-Informationen rekursiv abruft.

// 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 oder Sequenznummer der Nachricht abrufen

Die öffentliche API von Aspose.Email bietet die folgenden Funktionen, um Nachrichten-Identifikationsinformationen wie UID oder Sequenznummer zu erhalten, die bei der Verarbeitung von vom Server empfangenen Nachrichten erforderlich sein können:

MailboxInfo Klasse - Stellt Identifikationsinformationen zu einer Nachricht in einem Postfach dar.

getSequenceNumber() Methode – Holt die Sequenznummer einer Nachricht.
getUniqueId() Methode – Holt die eindeutige ID einer Nachricht.

MailMessage Klasse – Stellt eine E-Mail-Nachricht dar und ermöglicht den Zugriff auf Nachrichten-Eigenschaften, z. B. Betreff, Inhalt, Absender- und Empfängeradressen usw.

getItemId Methode – Stellt Identifizierungsinformationen über eine Nachricht in einem Postfach dar.

Das nachstehende Codebeispiel demonstriert, wie man Details von Nachrichten aus dem "INBOX"-Ordner auf einem IMAP-Server abruft und anzeigt, indem man die ImapClient Klasse:

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

Abrufen zusätzlicher Parameter als Zusammenfassungsinformationen

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

Abrufen von List-Unsubscribe-Header-Informationen

Der List-Unsubscribe-Header enthält die URL zum Abmelden von E-Mail-Listen, z. B. Werbung, Newsletter usw. Um den List-Unsubscribe-Header zu erhalten, verwenden Sie die listUnsubscribe Eigenschaft des ImapMessageInfo Klasse. Das folgende Beispiel zeigt die Verwendung von listUnsubscribe Eigenschaft, um den List-Unsubscribe-Header abzurufen.

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

Verbindung zum IMAP‑Server Arbeiten mit Nachrichten‑Flags auf dem Server