JavaMail IMAP przez SSL dość wolno-zbiorcze pobieranie wielu wiadomości

Po wielu pracach i pomocy ze strony ludzi w JavaMail, źródłem tej "powolności" jest zachowanie pobierania w API. Rzeczywiście, jak powiedział pjaol, wracamy do serwera za każdym razem, gdy potrzebujemy informacji (nagłówka lub treści wiadomości) dla wiadomości.

Jeśli fetchprofile pozwala na zbiorcze pobieranie informacji nagłówkowych lub FLAG dla wielu wiadomości, pobieranie zawartości wielu wiadomości nie jest bezpośrednio możliwe.

Na szczęście możemy napisać własne polecenie IMAP, aby tego uniknąć "ograniczenie" (zostało to zrobione w ten sposób, aby uniknąć błędów z pamięci: pobieranie każdej poczty w pamięci jednym poleceniem może być dość ciężkie).

Oto Mój kod:

import com.sun.mail.iap.Argument;
import com.sun.mail.iap.ProtocolException;
import com.sun.mail.iap.Response;
import com.sun.mail.imap.IMAPFolder;
import com.sun.mail.imap.protocol.BODY;
import com.sun.mail.imap.protocol.FetchResponse;
import com.sun.mail.imap.protocol.IMAPProtocol;
import com.sun.mail.imap.protocol.UID;

public class CustomProtocolCommand implements IMAPFolder.ProtocolCommand {
    /** Index on server of first mail to fetch **/
    int start;

    /** Index on server of last mail to fetch **/
    int end;

    public CustomProtocolCommand(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public Object doCommand(IMAPProtocol protocol) throws ProtocolException {
        Argument args = new Argument();
        args.writeString(Integer.toString(start) + ":" + Integer.toString(end));
        args.writeString("BODY[]");
        Response[] r = protocol.command("FETCH", args);
        Response response = r[r.length - 1];
        if (response.isOK()) {
            Properties props = new Properties();
            props.setProperty("mail.store.protocol", "imap");
            props.setProperty("mail.mime.base64.ignoreerrors", "true");
            props.setProperty("mail.imap.partialfetch", "false");
            props.setProperty("mail.imaps.partialfetch", "false");
            Session session = Session.getInstance(props, null);

            FetchResponse fetch;
            BODY body;
            MimeMessage mm;
            ByteArrayInputStream is = null;

            // last response is only result summary: not contents
            for (int i = 0; i < r.length - 1; i++) {
                if (r[i] instanceof IMAPResponse) {
                    fetch = (FetchResponse) r[i];
                    body = (BODY) fetch.getItem(0);
                    is = body.getByteArrayInputStream();
                    try {
                        mm = new MimeMessage(session, is);
                        Contents.getContents(mm, i);
                    } catch (MessagingException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        // dispatch remaining untagged responses
        protocol.notifyResponseHandlers(r);
        protocol.handleResult(response);

        return "" + (r.length - 1);
    }
}

Funkcja getContents (mimemessage mm, int i) jest klasyczną funkcją, która rekurencyjnie drukuje zawartość wiadomości do pliku(wiele przykładów dostępnych w sieci).

Aby uniknąć błędów z pamięci, po prostu ustawiłem limit maxDocs i maxSize (zostało to zrobione arbitralnie i prawdopodobnie można je poprawić!) używane w następujący sposób:

public int efficientGetContents(IMAPFolder inbox, Message[] messages)
        throws MessagingException {
    FetchProfile fp = new FetchProfile();
    fp.add(FetchProfile.Item.FLAGS);
    fp.add(FetchProfile.Item.ENVELOPE);
    inbox.fetch(messages, fp);
    int index = 0;
    int nbMessages = messages.length;
    final int maxDoc = 5000;
    final long maxSize = 100000000; // 100Mo

    // Message numbers limit to fetch
    int start;
    int end;

    while (index < nbMessages) {
        start = messages[index].getMessageNumber();
        int docs = 0;
        int totalSize = 0;
        boolean noskip = true; // There are no jumps in the message numbers
                                           // list
        boolean notend = true;
        // Until we reach one of the limits
        while (docs < maxDoc && totalSize < maxSize && noskip && notend) {
            docs++;
            totalSize += messages[index].getSize();
            index++;
            if (notend = (index < nbMessages)) {
                noskip = (messages[index - 1].getMessageNumber() + 1 == messages[index]
                        .getMessageNumber());
            }
        }

        end = messages[index - 1].getMessageNumber();
        inbox.doCommand(new CustomProtocolCommand(start, end));

        System.out.println("Fetching contents for " + start + ":" + end);
        System.out.println("Size fetched = " + (totalSize / 1000000)
                + " Mo");

    }

    return nbMessages;
}

Nie, że tutaj używam numerów wiadomości, co jest niestabilne (te zmiany, jeśli wiadomości są usuwane z serwera). Lepszą metodą byłoby użycie UIDs! Następnie zmienisz polecenie z FETCH na UID FETCH.