Arbeiten mit Nachrichten in einer PST-Datei

Nachrichten zu PST‑Dateien hinzufügen

Neue PST‑Datei erstellen und Unterordner hinzufügen Zeigte, wie man eine PST‑Datei erstellt und einen Unterordner hinzufügt. Mit Aspose.Email können Sie Nachrichten zu Unterordnern einer PST‑Datei hinzufügen, die Sie erstellt oder geladen haben. Dieser Artikel fügt zwei Nachrichten von der Festplatte zum Inbox‑Unterordner einer PST hinzu. Verwenden Sie die PersonalStorage und FolderInfo Klassen zum Hinzufügen von Nachrichten zu PST‑Dateien. Um Nachrichten zum Inbox‑Ordner einer PST‑Datei hinzuzufügen:

  1. Erstellen Sie eine Instanz der FolderInfo‑Klasse und laden Sie sie mit dem Inhalt des Inbox‑Ordners.
  2. Nachrichten von der Festplatte zum Inbox‑Ordner hinzufügen, indem Sie die FolderInfo.addMessage() Methode. Die FolderInfo Klasse stellt das addMessages Methode, die das Hinzufügen einer großen Anzahl von Nachrichten zum Ordner ermöglicht, I/O‑Operationen auf die Festplatte reduziert und die Leistung verbessert. Ein vollständiges Beispiel finden Sie unten in Batch‑Nachrichten hinzufügen.

Die untenstehenden Code‑Snippets zeigen, wie Nachrichten zu einem PST‑Unterordner namens Inbox hinzugefügt werden.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create new PST
PersonalStorage personalStorage = PersonalStorage.create(dataDir, FileFormatVersion.Unicode);

// Add new folder "Inbox"
personalStorage.getRootFolder().addSubFolder("Inbox");

// Select the "Inbox" folder
FolderInfo inboxFolder = personalStorage.getRootFolder().getSubFolder("Inbox");

// Add some messages to "Inbox" folder
inboxFolder.addMessage(MapiMessage.fromFile(dataDir + "MapiMsgWithPoll.msg"));

Batch‑Nachrichten hinzufügen

Das Hinzufügen einzelner Nachrichten zu einer PST führt zu mehr I/O‑Operationen auf die Festplatte und kann daher die Leistung verlangsamen. Für bessere Leistung können Nachrichten im Batch‑Modus zur PST hinzugefügt werden, um I/O‑Operationen zu minimieren. Die addMessages(Iterable messages) Die Methode ermöglicht es, einen Bereich von Nachrichten zu definieren, die zur PST hinzugefügt werden, um die Leistung zu verbessern, und kann in den folgenden Szenarien verwendet werden. Zusätzlich wird das Ereignis MessageAdded ausgelöst, wenn eine Nachricht zum Ordner hinzugefügt wird.

Nachrichten von der Festplatte laden

Das folgende Code‑Snippet zeigt, wie man Nachrichten von der Festplatte lädt.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
private static void addMessagesInBulkMode(String fileName, String msgFolderName) {
    try (PersonalStorage personalStorage = PersonalStorage.fromFile(fileName)) {
        FolderInfo folder = personalStorage.getRootFolder().getSubFolder("myInbox");
        folder.MessageAdded.add(new MessageAddedEventHandler() {
            public void invoke(Object sender, MessageAddedEventArgs e) {
                onMessageAdded(sender, e);
            }
        });
        folder.addMessages(new MapiMessageCollection(msgFolderName));
    }
}

static void onMessageAdded(Object sender, MessageAddedEventArgs e) {
    System.out.println(e.getEntryId());
    System.out.println(e.getMessage().getSubject());
}

Iterable-Implementierung

Das folgende Code‑Snippet zeigt, wie man eine Iterable‑Implementierung erstellt.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public class MapiMessageCollection implements Iterable<MapiMessage> {

    private final File folder;

    public MapiMessageCollection(String folder) {
        this.folder = new File(folder);
    }

    public Iterator<MapiMessage> iterator() {
        return new MapiMessageIterator(folder.listFiles());
    }
}

public class MapiMessageIterator implements Iterator<MapiMessage> {

    private Queue<String> queue = new LinkedList<String>();

    public MapiMessageIterator(File[] listOfFiles) {
        for (File file : listOfFiles) {
            queue.offer(file.getAbsolutePath());
        }
    }

    public boolean hasNext() {
        return !queue.isEmpty();
    }

    public MapiMessage next() {
        return MapiMessage.fromFile(queue.poll());
    }
}

Nachrichten aus einer anderen PST hinzufügen

Um Nachrichten aus einer anderen PST hinzuzufügen, verwenden Sie die FolderInfo.enumerateMapiMessages() Methode, die Iterable zurückgibt. Das folgende Code‑Snippet zeigt, wie Sie Nachrichten aus einer anderen PST hinzufügen.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
private static void bulkAddFromAnotherPst(String source) {
    // The path to the File directory.
    String dataDir = "data/";

    try (PersonalStorage pst = PersonalStorage.fromFile(source, false)) {
        try (PersonalStorage pstDest = PersonalStorage.fromFile(dataDir + "PersonalStorageFile1.pst")) {
            // Get the folder by name
            FolderInfo folderInfo = pst.getRootFolder().getSubFolder("Contacts");
            MessageInfoCollection ms = folderInfo.getContents();

            // Get the folder by name
            FolderInfo f = pstDest.getRootFolder().getSubFolder("myInbox");
            f.MessageAdded.add(new MessageAddedEventHandler() {
                public void invoke(Object sender, MessageAddedEventArgs e) {
                    onMessageAdded(sender, e);
                }
            });
            f.addMessages(folderInfo.enumerateMapiMessages());
            FolderInfo fi = pstDest.getRootFolder().getSubFolder("myInbox");
            MessageInfoCollection msgs = fi.getContents();
        }
    }
}

// Handles the MessageAdded event.
static void onMessageAdded(Object sender, MessageAddedEventArgs e) {
    System.out.println(e.getEntryId());
    System.out.println(e.getMessage().getSubject());
}

Nachrichteninformationen aus einer Outlook‑PST‑Datei abrufen

In Outlook‑PST‑Datei lesen und Informationen zu Ordnern und Unterordnern abrufen, wir haben das Laden einer Outlook‑PST‑Datei und das Durchsuchen ihrer Ordner besprochen, um die Ordnernamen und die Anzahl der Nachrichten darin zu erhalten. Dieser Artikel erklärt, wie man alle Ordner und Unterordner in der PST‑Datei liest und die Informationen zu Nachrichten, z. B. Betreff, Absender und Empfänger, anzeigt. Die FolderInfo.getContents() Methode wird verwendet, um anzuzeigen kurze Nachrichteninformationen wie Betreff, Absender, Empfänger. In Bezug auf die Leistung ist dies die am besten geeignete Option, um primäre Informationen über Nachrichten zu erhalten. Um extrahieren vollständige Nachrichtendaten, die PersonalStorage.extractMessage() Methode wird bereitgestellt. Die Outlook‑PST‑Datei kann verschachtelte Ordner enthalten. Um Nachrichteninformationen aus diesen sowie aus den Oberordnern zu erhalten, verwenden Sie eine rekursive Methode, um alle Ordner zu lesen. Das folgende Code‑Snippet zeigt, wie man eine Outlook‑PST‑Datei liest und den Ordner‑ und Nachrichteninhalt rekursiv anzeigt.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dataDir = "data/";

    // Load the Outlook file
    String path = dataDir + "PersonalStorage.pst";

    try {

        // Load the Outlook PST file
        PersonalStorage personalStorage = PersonalStorage.fromFile(path);

        // Get the Display Format of the PST file
        System.out.println("Display Format: " + personalStorage.getFormat());

        // Get the folders and messages information
        FolderInfo folderInfo = personalStorage.getRootFolder();

        // Call the recursive method to display the folder contents
        displayFolderContents(folderInfo, personalStorage);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
    }
}

// This is a recursive method to display contents of a folder
private static void displayFolderContents(FolderInfo folderInfo, PersonalStorage pst) {
    // Display the folder name
    System.out.println("Folder: " + folderInfo.getDisplayName());
    System.out.println("==================================");
    // Display information about messages inside this folder
    MessageInfoCollection messageInfoCollection = folderInfo.getContents();
    for (MessageInfo messageInfo : messageInfoCollection) {
        System.out.println("Subject: " + messageInfo.getSubject());
        System.out.println("Sender: " + messageInfo.getSenderRepresentativeName());
        System.out.println("Recipients: " + messageInfo.getDisplayTo());
        System.out.println("------------------------------");
    }

    // Call this method recursively for each subfolder
    if (folderInfo.hasSubFolders() == true) {
        for (FolderInfo subfolderInfo : folderInfo.getSubFolders()) {
            displayFolderContents(subfolderInfo, pst);
        }
    }
}

Nachrichten aus PST‑Dateien extrahieren

Dieser Artikel zeigt, wie man Microsoft Outlook PST‑Dateien liest und Nachrichten extrahiert. Die Nachrichten werden dann im MSG‑Format auf die Festplatte gespeichert. Der Artikel zeigt außerdem, wie man eine bestimmte Anzahl von Nachrichten zu extrahieren aus einer PST‑Datei. Verwenden Sie eine rekursive Methode, um alle Ordner (einschließlich verschachtelter Ordner) zu durchlaufen und die PersonalStorage.extractMessage() Methode auf, um Outlook‑Nachrichten in eine Instanz von MapiMessage Klasse. Danach rufen Sie die MapiMessage.save() Methode, um die Nachricht im MSG‑Format entweder auf die Festplatte oder in einen Stream zu speichern. Das folgende Code‑Snippet zeigt, wie Sie Nachrichten aus einer PST‑Datei extrahieren.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dataDir = "data/";

    // Load the Outlook file
    String path = dataDir + "PersonalStorage.pst";

    try {
        // load the Outlook PST file
        PersonalStorage pst = PersonalStorage.fromFile(path);

        // get the Display Format of the PST file
        System.out.println("Display Format: " + pst.getFormat());

        // get the folders and messages information
        FolderInfo folderInfo = pst.getRootFolder();

        // Call the recursive method to extract msg files from each folder
        extractMsgFiles(folderInfo, pst);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
    }
}

// This is a recursive method to display contents of a folder
private static void extractMsgFiles(FolderInfo folderInfo, PersonalStorage pst) {
    // display the folder name
    System.out.println("Folder: " + folderInfo.getDisplayName());
    System.out.println("==================================");
    // loop through all the messages in this folder
    MessageInfoCollection messageInfoCollection = folderInfo.getContents();
    for (MessageInfo messageInfo : messageInfoCollection) {
        System.out.println("Saving message {0} ...." + messageInfo.getSubject());
        // get the message in MapiMessage instance
        MapiMessage message = pst.extractMessage(messageInfo);
        // save this message to disk in msg format
        message.save(message.getSubject().replace(":", " ") + ".msg");
        // save this message to stream in msg format
        ByteArrayOutputStream messageStream = new ByteArrayOutputStream();
        message.save(messageStream);
    }

    // Call this method recursively for each subfolder
    if (folderInfo.hasSubFolders() == true) {
        for (FolderInfo subfolderInfo : folderInfo.getSubFolders()) {
            extractMsgFiles(subfolderInfo, pst);
        }
    }
}

Nachrichten direkt aus PST in einen Stream speichern

Um Nachrichten aus einer PST‑Datei direkt in einen Stream zu speichern, ohne die MsgInfo der Nachrichten zu extrahieren, verwenden Sie die saveMessageToStream() Methode. Das folgende Code‑Snippet zeigt, wie Sie Nachrichten direkt aus einer PST in einen Stream speichern.

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

// Load the Outlook file
String path = dataDir + "PersonalStorage.pst";

// Save message to MemoryStream
try (PersonalStorage personalStorage = PersonalStorage.fromFile(path)) {
    FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");
    for (MessageInfo messageInfo : inbox.enumerateMessages()) {
        try (ByteArrayOutputStream memeorystream = new ByteArrayOutputStream()) {
            personalStorage.saveMessageToStream(messageInfo.getEntryIdString(), memeorystream);
        }
    }
}

// Save message to file
try (PersonalStorage pst = PersonalStorage.fromFile(path)) {
    FolderInfo inbox = pst.getRootFolder().getSubFolder("Inbox");
    for (MessageInfo messageInfo : inbox.enumerateMessages()) {
        try (FileOutputStream fs = new FileOutputStream(new File(dataDir + messageInfo.getSubject() + ".msg"))) {
            pst.saveMessageToStream(messageInfo.getEntryIdString(), fs);
        }
    }
}

try (PersonalStorage pst = PersonalStorage.fromFile(path)) {
    FolderInfo inbox = pst.getRootFolder().getSubFolder("Inbox");

    // To enumerate entryId of messages you may use FolderInfo.EnumerateMessagesEntryId() method:
    for (String entryId : inbox.enumerateMessagesEntryId()) {
        try (ByteArrayOutputStream ms = new ByteArrayOutputStream()) {
            pst.saveMessageToStream(entryId, ms);
        }
    }
}

Extrahieren einer bestimmten Anzahl von Nachrichten aus einer PST‑Datei

Das folgende Code‑Snippet zeigt, wie Sie eine bestimmte Anzahl von Nachrichten aus einer PST extrahieren. Geben Sie einfach den Index der ersten Nachricht und die Gesamtzahl der zu extrahierenden Nachrichten an.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");

// Extracts messages starting from 10th index top and extract total 100 messages
MessageInfoCollection messages = inbox.getContents(10, 100);

Gesamtzahl der Elemente aus einer PST‑Datei abrufen

Aspose.Email provides the GetTotalItemsCount() Methode des PersonalStorage.Store Eigenschaft. Sie gibt die Gesamtzahl der Nachrichtenobjekte zurück, die in der PST enthalten sind.

Das folgende Code‑Beispiel zeigt, wie man die Gesamtanzahl von Elementen (Nachrichten, Terminen, Kontakten usw.) ermittelt, die in der PST‑Datei gespeichert sind:

try (PersonalStorage pst = PersonalStorage.fromFile("my.pst", false)) {
    int count = pst.getStore().getTotalItemsCount();
}

Elemente aus PST‑Dateien löschen

Add Messages to PST Files zeigte, wie man Nachrichten zu PST‑Dateien hinzufügt. Natürlich ist es auch möglich, Elemente (Inhalte) aus einer PST‑Datei zu löschen, und es kann wünschenswert sein, Nachrichten stapelweise zu löschen. Elemente aus einer PST‑Datei können mittels der FolderInfo.deleteChildItem() Methode. Die API bietet außerdem FolderInfo.deleteChildItems() Methode, um Elemente stapelweise aus der PST‑Datei zu löschen.

Nachrichten aus PST‑Dateien löschen

Dieser Artikel zeigt, wie man die FolderInfo Klasse, um auf bestimmte Ordner in einer PST‑Datei zuzugreifen. Um Nachrichten aus dem Gesendet‑Unterordner einer zuvor geladenen oder erstellten PST‑Datei zu löschen:

  1. Erstellen Sie eine Instanz von dem FolderInfo Klasse aufrufen und mit dem Inhalt des Gesendet‑Unterordners laden.
  2. Löschen Sie Nachrichten aus dem Gesendet‑Ordner, indem Sie die FolderInfo.deleteChildItem() Methode und übergeben des MessageInfo.EntryId als Parameter. Das folgende Code‑Snippet zeigt, wie Sie Nachrichten aus dem Gesendet‑Unterordner einer PST‑Datei löschen.
// 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/" + "Sub.pst";

// Load the Outlook PST file
PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir);

// Get the Sent items folder
FolderInfo folderInfo = personalStorage.getPredefinedFolder(StandardIpmFolder.SentItems);

MessageInfoCollection msgInfoColl = folderInfo.getContents();
for (MessageInfo msgInfo : msgInfoColl) {
    System.out.println(msgInfo.getSubject() + ": " + msgInfo.getEntryIdString());
    if (msgInfo.getSubject().equals("some delete condition")) {
        // Delete this item
        folderInfo.deleteChildItem(msgInfo.getEntryId());
        System.out.println("Deleted this message");
    }
}

Ordner aus PST‑Dateien löschen

Sie können einen PST‑Ordner löschen, indem Sie ihn in den Ordner „Gelöschte Elemente“ verschieben.

try (PersonalStorage pst = PersonalStorage.fromFile("test.pst")) {
    FolderInfo deletedItemsFolder = pst.getPredefinedFolder(StandardIpmFolder.DeletedItems);
    FolderInfo emptyFolder = pst.getRootFolder().getSubFolder("Empty folder");
    FolderInfo someFolder = pst.getRootFolder().getSubFolder("Some folder");
    pst.moveItem(emptyFolder, deletedItemsFolder);
    pst.moveItem(someFolder, deletedItemsFolder);
}

Der Vorteil dieser Methode ist, dass der gelöschte Ordner leicht wiederhergestellt werden kann.

FolderInfo someFolder = deletedItemsFolder.getSubFolder("Some folder");
pst.moveItem(someFolder, pst.getRootFolder());

Sie können bei Bedarf auch einen Ordner dauerhaft aus dem Ordner „Gelöschte Elemente“ entfernen.

deletedItemsFolder.deleteChildItem(emptyFolder.getEntryId());

Die deleteChildItem() Methode kann für beliebige Ordner verwendet werden, wenn Sie einen Unterordner sofort und dauerhaft löschen möchten, wobei der Ordner „Gelöschte Elemente“ umgangen wird.

FolderInfo someFolder = pst.getRootFolder().getSubFolder("Some folder");
pst.getRootFolder().deleteChildItem(someFolder.getEntryId());

Elemente stapelweise aus einer PST‑Datei löschen

Die Aspose.Email‑API kann verwendet werden, um Elemente stapelweise aus einer PST‑Datei zu löschen. Dies wird erreicht mittels der deleteChildItems() Methode, die eine Liste von Entry‑ID‑Elementen entgegennimmt, die auf die zu löschenden Elemente verweisen. Das folgende Code‑Snippet zeigt, wie Sie Elemente stapelweise aus einer PST‑Datei löschen.

// 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/" + "Sub.pst";

try (PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir)) {
    // Get Inbox SubFolder from Outlook file
    FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");

    // Create instance of PersonalStorageQueryBuilder
    PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();

    queryBuilder.getFrom().contains("someuser@domain.com");
    MessageInfoCollection messages = inbox.getContents(queryBuilder.getQuery());
    List<String> deleteList = new ArrayList<String>();
    for (MessageInfo messageInfo : messages) {
        deleteList.add(messageInfo.getEntryIdString());
    }

    // delete messages having From = "someuser@domain.com"
    inbox.deleteChildItems(deleteList);
}

Soft‑gelöschte Nachrichten aus PST aufzählen und wiederherstellen

Es ist möglich, dauerhaft gelöschte Nachrichten mit Aspose.Email für Java abzurufen. Die API ermöglicht das Aufzählen soft‑gelöschter Nachrichten in PST‑Dateien. Soft‑gelöschte Elemente sind Nachrichten, die zweimal gelöscht wurden – zuerst in den Ordner „Gelöschte Elemente“ verschoben und dann von dort entfernt. Diese Nachrichten sind weiterhin wiederherstellbar, und Aspose.Email bietet eine bequeme Möglichkeit, auf sie zuzugreifen. Der PersonalStorage.findAndEnumerateSoftDeletedItems() Methode gibt eine Sammlung von zurück RestoredItemEntry Objekte. Jeder Eintrag enthält:

  • MapiMessage item — die wiederhergestellte Nachricht.
  • String FolderId - die Kennung des Ordners, zu dem die Nachricht ursprünglich gehörte.

Das folgende Code‑Beispiel zeigt, wie man soft‑gelöschte (wiederherstellbare) E‑Mail‑Elemente in PST‑Dateien aufzählt:

// Load the PST file
try (PersonalStorage pst = PersonalStorage.fromFile(fileName)) {
    // Enumerate soft-deleted items
    for (RestoredItemEntry entry : pst.findAndEnumerateSoftDeletedItems()) {
        MapiMessage message = entry.getItem();
        String folderId = entry.getFolderId();
        
        System.out.println("Subject: " + message.getSubject());
        System.out.println("Deleted from Folder ID: " + folderId);
        System.out.println("-----------------------------------");
    }
}

Nachrichten und Ordner in einer PST nach Kriterium durchsuchen

Personal Storage (PST)-Dateien können eine enorme Datenmenge enthalten und die Suche nach Daten, die ein bestimmtes Kriterium in solch großen Dateien erfüllen, erfordert mehrere Prüfstellen im Code, um die Informationen zu filtern. Mit dem PersonalStorageQueryBuilder Klasse, Aspose.Email ermöglicht die Suche nach spezifischen Datensätzen in einer PST anhand eines angegebenen Suchkriteriums. Eine PST kann nach Nachrichten durchsucht werden, basierend auf Suchparametern wie Absender, Empfänger, Betreff, Nachrichtenwichtigkeit, Vorhandensein von Anhängen, Nachrichtengröße und sogar Nachrichten‑ID. Der PersonalStorageQueryBuilder kann auch verwendet werden, um Unterordner zu suchen.

Nachrichten und Ordner in PST durchsuchen

Das folgende Code‑Snippet zeigt, wie Sie die PersonalStorageQueryBuilder Klasse, um Inhalte in einer PST anhand verschiedener Suchkriterien zu durchsuchen. Zum Beispiel zeigt sie die Suche in einer PST basierend auf:

  • Nachrichtenwichtigkeit.
  • Nachrichtenklasse.
  • Vorhandensein von Anhängen.
  • Nachrichtengröße.
  • Nachrichtendatum.
  • Ungelesene Nachrichten.
  • Ungelesene Nachrichten mit Anhängen und
  • Ordner mit einem bestimmten Unterordnernamen.
// 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/";

try (PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir + "Outlook.pst")) {
    FolderInfo folder = personalStorage.getRootFolder().getSubFolder("Inbox");
    PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();

    // High importance messages
    builder.getImportance().equals((int) MapiImportance.High);
    MessageInfoCollection messages = folder.getContents(builder.getQuery());
    System.out.println("Messages with High Imp:" + messages.size());

    builder = new PersonalStorageQueryBuilder();
    builder.getMessageClass().equals("IPM.Note");
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages with IPM.Note:" + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Messages with attachments AND high importance
    builder.getImportance().equals((int) MapiImportance.High);
    builder.hasFlags(MapiMessageFlags.MSGFLAG_HASATTACH);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages with atts: " + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Messages with size > 15 KB
    builder.getMessageSize().greater(15000);
    messages = folder.getContents(builder.getQuery());
    System.out.println("messags size > 15Kb:" + messages.size());

    java.util.Calendar c = java.util.Calendar.getInstance();

    builder = new PersonalStorageQueryBuilder();
    // Messages by Current Date
    // (Note that queries by date are not supported for Calendar Items in the Appointments folder)
    builder.getSentDate().on(c.getTime(), DateComparisonType.ByDate);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages by Current Date: " + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Messages between Dates
    // (Note that queries by date are not supported for Calendar Items in the Appointments folder)
    c.set(2020,  0, 1, 0, 0, 0);
    builder.getSentDate().since(c.getTime());
    c.set(2021,  0, 1, 0, 0, 0);
    builder.getSentDate().before(c.getTime());
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages between Dates: " + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Unread messages
    builder.hasNoFlags(MapiMessageFlags.MSGFLAG_READ);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Unread:" + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Unread messages with attachments
    builder.hasNoFlags(MapiMessageFlags.MSGFLAG_READ);
    builder.hasFlags(MapiMessageFlags.MSGFLAG_HASATTACH);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Unread msgs with atts: " + messages.size());

    // Folder with name of 'SubInbox'
    builder = new PersonalStorageQueryBuilder();
    builder.getFolderName().equals("SubInbox");
    FolderInfoCollection folders = folder.getSubFolders(builder.getQuery());
    System.out.println("Folder having subfolder: " + folders.size());

    builder = new PersonalStorageQueryBuilder();
    // Folders with subfolders
    builder.hasSubfolders();
    folders = folder.getSubFolders(builder.getQuery());
    System.out.println(folders.size());
}

Suche nach einer Zeichenkette in PST mit dem Ignore‑Case‑Parameter

Das folgende Code‑Snippet zeigt, wie Sie in einer PST nach einer Zeichenkette mit dem Parameter „ignore case“ suchen.

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

try (PersonalStorage personalStorage = PersonalStorage.create(dataDir + "CaseSensitivity.pst", FileFormatVersion.Unicode)) {
    FolderInfo folderinfo = personalStorage.createPredefinedFolder("Inbox", StandardIpmFolder.Inbox);
    folderinfo.addMessage(MapiMessage.fromMailMessage(MailMessage.load("Sample.eml")));
    PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();
    // IgnoreCase is True
    builder.getFrom().contains("automated", true);
    MailQuery query = builder.getQuery();
    MessageInfoCollection coll = folderinfo.getContents(query);
    System.out.println(coll.size());
}

Nach Betreffszeilen von Nachrichten mit mehreren Schlüsselwörtern in einer PST-Datei suchen

Sie können verwenden MailQueryBuilder.or Methode, um Nachrichten zu finden, deren Betreff mindestens eines der angegebenen Wörter enthält, wie unten gezeigt:

PersonalStorageQueryBuilder builder1 = new PersonalStorageQueryBuilder();
builder1.getSubject().contains("Review"); // 'Review' is key word for the search

PersonalStorageQueryBuilder builder2 = new PersonalStorageQueryBuilder();
builder2.getSubject().contains("Error"); // 'Error' is also key word for the search

PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
queryBuilder.or(builder1.getQuery(), builder2.getQuery()); // message subjects must contain 'Review' or 'Error' words

try (PersonalStorage storage = PersonalStorage.fromFile("example.pst"))
{
    FolderInfo folderInfo = storage.getRootFolder().getSubFolder("Inbox");
    MessageInfoCollection messageInfos = folderInfo.getContents(queryBuilder.getQuery());

    for (MessageInfo messageInfo : messageInfos)
    {
        System.out.println(messageInfo.getSubject());
    }
}

Paginierter Abruf von PST‑Ordnerinhalten

Verbessern Sie die Anwendungsperformance und die Kontrolle beim Durchlaufen großer Ordner. Rufen Sie Ordnerinhalte paginiert ab, indem Sie die Aspose.Email‑Überladung von getContents Methode. Diese Methode – FolderInfo.getContents(MailQuery query, int startIndex, int count) - ruft eine Teilmenge von Nachrichten ab, die der angegebenen Abfrage entsprechen, beginnend bei einem bestimmten Index und begrenzt durch eine Anzahl. Das folgende Code‑Beispiel demonstriert die paginierte Abruf‑ und Verarbeitung gefilterter Nachrichten aus einem PST‑Ordner:

// Load the PST file
try (PersonalStorage pst = PersonalStorage.fromFile(fileName)) {
    // Access a specific subfolder
    FolderInfo folder = pst.getRootFolder().getSubFolder("Inbox");

    // Build a query to filter messages by sender address
    PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
    queryBuilder.getFrom().contains("report-service", true);

    // Define the page size
    int pageSize = 5;

    // Retrieve and process messages in pages
    for (int pageIndex = 0; pageIndex < 6; pageIndex++) {
        int startIndex = pageIndex * pageSize;

        // Get a page of messages
        MessageInfoCollection messages = folder.getContents(queryBuilder.getQuery(), startIndex, pageSize);

        for (MessageInfo messageInfo : messages) {
            // Output basic info about each message
            System.out.println("Subject: " + messageInfo.getSubject() + ", Sender: " + messageInfo.getSenderRepresentativeName());
        }
    }
}

Elemente in andere Ordner einer PST-Datei verschieben

Aspose.Email ermöglicht das Verschieben von Elementen von einem Quellordner zu einem anderen Ordner in derselben Personal Storage (PST)-Datei. Dies beinhaltet:

  • Einen bestimmten Ordner in einen neuen übergeordneten Ordner verschieben.
  • Eine bestimmte Nachricht in einen neuen Ordner verschieben.
  • Den Inhalt in einen neuen Ordner verschieben.
  • Unterordner in einen neuen übergeordneten Ordner verschieben.

Das folgende Code‑Snippet zeigt, wie Sie Elemente wie Nachrichten und Ordner von einem Quellordner in einen anderen Ordner derselben PST‑Datei verschieben.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
try (PersonalStorage personalStorage = PersonalStorage.fromFile("test.pst")) {
    FolderInfo inbox = personalStorage.getPredefinedFolder(StandardIpmFolder.Inbox);
    FolderInfo deleted = personalStorage.getPredefinedFolder(StandardIpmFolder.DeletedItems);
    FolderInfo subfolder = inbox.getSubFolder("Subfolder");

    // Move folder and message to the Deleted Items
    personalStorage.moveItem(subfolder, deleted);
    MessageInfoCollection contents = subfolder.getContents();
    personalStorage.moveItem(contents.get(0), deleted);

    // Move all inbox subfolders and subfolder contents to the Deleted Items
    inbox.moveSubfolders(deleted);
    subfolder.moveContents(deleted);
}

Aktualisieren von Nachrichteneigenschaften in einer PST-Datei

Es ist manchmal erforderlich, bestimmte Eigenschaften von Nachrichten zu aktualisieren, z. B. den Betreff zu ändern, die Wichtigkeit der Nachricht zu markieren und Ähnliches. Das Aktualisieren einer Nachricht in einer PST-Datei mit solchen Änderungen an den Nachrichteneigenschaften kann mit der FolderInfo.changeMessages Methode. Dieser Artikel zeigt, wie Nachrichten in einer PST-Datei stapelweise aktualisiert werden können, um Änderungen an den Eigenschaften vorzunehmen. Das folgende Codebeispiel zeigt, wie Sie die Eigenschaften von Nachrichten im Batch‑Modus für mehrere Nachrichten in einer PST-Datei aktualisieren.

// 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/" + "Sub.pst";

// Load the Outlook PST file
PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir);

// Get Requierd Subfolder
FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");

// find messages having From = "someuser@domain.com"
PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
queryBuilder.getFrom().contains("someuser@domain.com");

// Get Contents from Query
MessageInfoCollection messages = inbox.getContents(queryBuilder.getQuery());

// Save (MessageInfo,EntryIdString) in List
List<String> changeList = new ArrayList<String>();
for (MessageInfo messageInfo : messages) {
    changeList.add(messageInfo.getEntryIdString());
}

// Compose the new properties
MapiPropertyCollection updatedProperties = new MapiPropertyCollection();
updatedProperties.add(MapiPropertyTag.PR_SUBJECT_W, new MapiProperty(MapiPropertyTag.PR_SUBJECT_W, "New Subject".getBytes(Charset.forName("utf-16le"))));
updatedProperties.add(MapiPropertyTag.PR_IMPORTANCE, new MapiProperty(MapiPropertyTag.PR_IMPORTANCE, BitConverter.getBytesInt64(2)));

// update messages having From = "someuser@domain.com" with new properties
inbox.changeMessages(changeList, updatedProperties);

Benutzerdefinierte Eigenschaften in einer PST-Datei aktualisieren

Manchmal ist es erforderlich, Elemente zu markieren, die innerhalb der PST-Datei verarbeitet wurden. Die Aspose.Email‑API ermöglicht dies mithilfe von MapiProperty und MapiNamedProperty. Die folgenden Methoden sind dabei hilfreich.

  • constructor MapiNamedProperty(long propertyTag, String nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • constructor MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • FolderInfo.changeMessages(MapiPropertyCollection updatedProperties) - ändert alle Nachrichten im Ordner
  • PersonalStorage.changeMessage(String entryId, MapiPropertyCollection updatedProperties) - Nachrichteneigenschaften ändern
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dataDir = "data/" + "Sub.pst";

    try (PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir)) {
        FolderInfo testFolder = personalStorage.getRootFolder().getSubFolder("Inbox");

        // Create the collection of message properties for adding or updating
        MapiPropertyCollection newProperties = new MapiPropertyCollection();

        // Normal, Custom and PidLidLogFlags named property
        MapiProperty property = new MapiProperty(MapiPropertyTag.PR_ORG_EMAIL_ADDR_W, "test_address@org.com".getBytes(Charset.forName("utf-16le")));
        MapiProperty namedProperty1 = new MapiNamedProperty(generateNamedPropertyTag(0L, MapiPropertyType.PT_LONG), "ITEM_ID", UUID.randomUUID(),
                BitConverter.getBytesInt64(123));
        MapiProperty namedProperty2 = new MapiNamedProperty(generateNamedPropertyTag(1L, MapiPropertyType.PT_LONG), 0x0000870C,
                UUID.fromString("0006200A-0000-0000-C000-000000000046"), BitConverter.getBytesInt64(0));
        newProperties.add(namedProperty1.getTag(), namedProperty1);
        newProperties.add(namedProperty2.getTag(), namedProperty2);
        newProperties.add(property.getTag(), property);
        testFolder.changeMessages(testFolder.enumerateMessagesEntryId(), newProperties);
    }
}

private static long generateNamedPropertyTag(long index, int dataType) {
    return (((0x8000 | index) << 16) | (long) dataType) & 0x00000000FFFFFFFFL;
}

Anhänge extrahieren, ohne die komplette Nachricht zu extrahieren

Die Aspose.Email‑API kann verwendet werden, um Anhänge aus PST‑Nachrichten zu extrahieren, ohne zuerst die komplette Nachricht zu extrahieren. Die ExtractAttachments Methode von PersonalStorage kann dafür verwendet werden. Das folgende Codebeispiel zeigt, wie Sie Anhänge extrahieren, ohne die komplette Nachricht zu extrahieren.

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

try (PersonalStorage personalstorage = PersonalStorage.fromFile(dataDir + "Outlook.pst")) {
    FolderInfo folder = personalstorage.getRootFolder().getSubFolder("Inbox");

    for (String messageInfo : folder.enumerateMessagesEntryId()) {
        MapiAttachmentCollection attachments = personalstorage.extractAttachments(messageInfo);

        if (attachments.size() != 0) {
            for (MapiAttachment attachment : attachments) {
                if (attachment.getLongFileName() != null && !attachment.getLongFileName().isEmpty()) {
                    if (attachment.getLongFileName().contains(".msg")) {
                        continue;
                    } else {
                        attachment.save(dataDir + "Attachments/" + attachment.getLongFileName());
                    }
                }
            }
        }
    }
}

Dateien zu PST hinzufügen

Die Kernfunktionalität von Microsoft Outlook ist das Verwalten von E‑Mails, Kalendern, Aufgaben, Kontakten und Journaleinträgen. Zusätzlich können Dateien zu einem PST‑Ordner hinzugefügt werden, wobei das resultierende PST die hinzugefügten Dokumente protokolliert. Aspose.Email bietet die Möglichkeit, Dateien genauso zu einem Ordner hinzuzufügen, wie Nachrichten, Kontakte, Aufgaben und Journaleinträge zu PST hinzugefügt werden. Das folgende Codebeispiel zeigt, wie Sie Dokumente zu einem PST‑Ordner mit Aspose.Email hinzufügen.

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

try (PersonalStorage personalStorage = PersonalStorage.create(dataDir + "Ps1_out.pst", FileFormatVersion.Unicode)) {
    FolderInfo folder = personalStorage.getRootFolder().addSubFolder("Files");

    // Add Document.doc file with the "IPM.Document" message class by default.
    folder.addFile(dataDir + "attachment_1.doc", null);
}
Outlook OST-Datei lesen und konvertieren Arbeiten mit Kontakten in PST‑Datei