Werken met Berichten van IMAP‑server

Lijst van MIME-bericht-ID’s van server

ImapMessageInfo biedt de MIME MessageId voor berichtidentificatie zonder het volledige bericht te extraheren. Het onderstaande codefragment toont hoe u MIME‑messageId kunt vermelden.

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

Berichten Van Server Lijsten

Aspose.Email biedt een 2‑parameter overladen variant van listMessages() om een opgegeven aantal berichten op te halen op basis van een query. Het onderstaande codefragment toont hoe u berichten kunt vermelden.

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

Berichten Recursief Van Server Lijsten

Het IMAP‑protocol ondersteunt het recursief vermelden van berichten uit een mailboxmap. Dit helpt ook om berichten uit submappen van een map te vermelden. Het onderstaande codefragment toont hoe u berichten recursief kunt vermelden.

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

Berichten weergeven met MultiConnection

ImapClient biedt een UseMultiConnection eigenschap die kan worden gebruikt om meerdere verbindingen voor zware bewerkingen te maken. U kunt ook het aantal verbindingen dat tijdens de multiverbindingsmodus wordt gebruikt instellen door gebruik te maken van ImapClient.ConnectionsQuantity. Het onderstaande codefragment toont het gebruik van de multiverbindings‑modus voor het vermelden van berichten en vergelijkt de prestaties met de enkele‑verbinding‑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);

Let op dat het gebruik van multiconnectiemodus geen prestatieverbetering garandeert.

Berichten in aflopende volgorde ophalen

Aspose.Email biedt ImapClient.listMessagesByPage methode die berichten lijst met pagineringondersteuning. Sommige overloads van ImapClient.listMessagesByPage accepteert PageSettings als parameter. PageSettings biedt een AscendingSorting eigenschap die, wanneer ingesteld op false, e‑mails in aflopende volgorde retourneert.

De volgende voorbeeldcode demonstreert het gebruik van AscendingSorting eigenschap van de PageSettings klasse om de volgorde van e‑mails te wijzigen.

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

Berichten van server ophalen en opslaan op schijf

De ImapClient klasse kan berichten van een IMAP‑server ophalen en de berichten in EML‑indeling opslaan op een lokale schijf. De volgende stappen zijn vereist om de berichten op te slaan op schijf:

Maak een instantie van de ImapClient klasse.
Specificeer een hostnaam, poort, gebruikersnaam en wachtwoord in de ImapClient constructor.
Selecteer de map met behulp van selectFolder() methode.
Roep de listMessages methode om de ImapMessageInfoCollection object.
Itereer door de ImapMessageInfoCollection collectie, roep de saveMessage() methode en geef het uitvoerpad en de bestandsnaam op.

Het onderstaande codefragment laat zien hoe je e‑mailberichten van een server ophaalt en opslaat.

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

Berichten opslaan in MSG-formaat

In het bovenstaande voorbeeld, worden de e‑mails opgeslagen in EML‑indeling. Om e‑mails in MSG‑indeling op te slaan, de ImapClient.fetchMessage() methode moet worden aangeroepen. Het retourneert het bericht in een instantie van de MailMessage klasse. De MailMessage.save() methode kan vervolgens worden aangeroepen om het bericht op te slaan als MSG. Het onderstaande codefragment laat zien hoe je berichten in MSG‑indeling opslaat.

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

Groepsophalen van berichten

ImapClient biedt een fetchMessages methode die een iterable van Volgnummer of Unieke ID accepteert en een lijst retourneert van MailMessage. Het volgende codefragment demonstreert het gebruik van de fetchMessages methode om berichten op te halen via Volgnummer en Unieke 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‑mailthreading/E‑mails organiseren in conversaties

Aspose.Email maakt het mogelijk om alle doorgestuurde berichten, antwoorden en antwoorden‑aan‑allen die gerelateerd zijn aan dezelfde conversatie, samen te groeperen in een hiërarchische manier. In principe kan het IMAP‑protocol de THREAD‑mogelijkheid ondersteunen die gedefinieerd is in RFC‑5256. Daarnaast bestaat er een andere IMAP‑extensie geleverd door Gmail en beschreven als X‑GM‑EXT‑1.

De volgende e‑mailthreading‑functies zijn beschikbaar voor gebruik:

getMessageThreads methode - Ontvangt berichtthreads via ImapClient.
boolean getGmExt1Supported - Haalt informatie op of de Gmail X‑GM‑EXT‑1-extensie wordt ondersteund.
boolean getThreadSupported - Haalt informatie op of de THREAD-extensie wordt ondersteund.
String[] getThreadAlgorithms - Haalt ondersteunde THREAD-algoritmen op.

De volgende codevoorbeelden tonen het gebruik van deze functionaliteiten om e‑mailthreads van Gmail op te halen:

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

       }

   }

}

De code wijzigt enigszins als de IMAP-server THREAD-ondersteuning biedt:

Controleer of de IMAP-server de THREAD-extensie ondersteunt:

 if (client.getThreadSupported())

Creëer de geschikte zoekcriteria voor een thread:

 ThreadSearchConditions conditions = new ThreadSearchConditions();

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

conditions.setUseUId(true);

Berichten weergeven met pagineringsondersteuning

In scenario’s waarin de e‑mailserver een groot aantal berichten in de mailbox bevat, is het vaak wenselijk om de berichten te lijst of op te halen met pagineringondersteuning. Aspose.Email API ImapClient stelt je in staat om de berichten van de server op te halen met pagineringondersteuning.

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

Mappen ophalen en berichten recursief lezen

In dit artikel, de meeste van de ImapClient functies worden gebruikt om een toepassing te maken die alle mappen en submappen recursief van een IMAP‑server lijst. Het slaat ook de berichten in elke map en submap op in MSG‑indeling op een lokale schijf. Op de schijf worden mappen en berichten in dezelfde hiërarchische structuur als op de IMAP‑server aangemaakt en opgeslagen. Het volgende codefragment laat zien hoe je recursief de berichten‑ en submapinformatie kunt ophalen.

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

Bericht‑UID of volgnummer ophalen

De openbare API van Aspose.Email biedt de volgende functionaliteiten om berichtidentificatie‑informatie zoals UID of volgnummer op te halen, wat nodig kan zijn bij het verwerken van berichten die van de server zijn ontvangen:

MailboxInfo klasse - Vertegenwoordigt identificatie‑informatie over een bericht in een postvak.

getSequenceNumber() methode - Haalt het volgnummer van een bericht op.
getUniqueId() methode - Haalt de unieke ID van een bericht op.

MailMessage klasse - Vertegenwoordigt een e‑mailbericht en maakt toegang tot berichteigenschappen mogelijk, bijv. onderwerp, inhoud, afzender en ontvangers, enz.

getItemId methode - Vertegenwoordigt identificatie‑informatie over een bericht in een mailbox.

Het onderstaande codevoorbeeld toont hoe je de details van berichten uit de "INBOX"-map op een IMAP-server kunt ophalen en weergeven met behulp van de 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());
    }
}

Extra parameters ophalen als samenvattingsinformatie

// 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-headerinformatie ophalen

De List-Unsubscribe-header bevat de URL om je af te melden voor e‑maillijsten, bijv. advertenties, nieuwsbrieven, enz. Om de List-Unsubscribe-header op te halen, gebruik de listUnsubscribe eigenschap van de ImapMessageInfo klasse. Het volgende voorbeeld toont het gebruik van de listUnsubscribe eigenschap om de List-Unsubscribe-header op te halen.

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

Verbinden met IMAP‑server Werken met berichtbijlagen via IMAP