Zarządzanie BLOB-ami prezentacji w Java w celu efektywnego wykorzystania pamięci

Przegląd

Aspose.Slides zapewnia obsługę BLOB‑ów dla dużych danych binarnych w prezentacjach, pomagając zmniejszyć zużycie pamięci przy pracy z dużymi obrazami, dźwiękiem, wideo i plikami prezentacji.

Ten artykuł pokazuje, jak używać przetwarzania opartego na BLOB, aby dodać duże multimedia do prezentacji, wyeksportować duże multimedia z prezentacji oraz wczytać duże prezentacje bardziej efektywnie. Wyjaśnia również, jak można używać plików tymczasowych podczas przetwarzania oraz jak zmienić folder używany do ich przechowywania.

O BLOB

BLOB (Binary Large Object) to zazwyczaj duży element (zdjęcie, prezentacja, dokument lub multimedia) zapisywany w formacie binarnym.

Aspose.Slides for Java umożliwia użycie BLOB‑ów dla obiektów w sposób, który zmniejsza zużycie pamięci, gdy zaangażowane są duże pliki.

Użyj BLOB, aby zmniejszyć zużycie pamięci

Dodaj duży plik przez BLOB do prezentacji

Aspose.Slides for Java umożliwia dodanie dużych plików (w tym przypadku dużego pliku wideo) przy użyciu procesu opartego na BLOB, aby zmniejszyć zużycie pamięci.

Ten przykład w Javie pokazuje, jak dodać duży plik wideo przez proces BLOB do prezentacji:

String pathToVeryLargeVideo = "veryLargeVideo.avi";

// Tworzy nową prezentację, do której zostanie dodane wideo
Presentation pres = new Presentation();
try {
    FileInputStream fileStream = new FileInputStream(pathToVeryLargeVideo);
    try {
        // Dodajmy wideo do prezentacji – wybraliśmy zachowanie KeepLocked, ponieważ
        // nie zamierzamy uzyskiwać dostępu do pliku "veryLargeVideo.avi" file.
        IVideo video = pres.getVideos().addVideo(fileStream, LoadingStreamBehavior.KeepLocked);
        pres.getSlides().get_Item(0).getShapes().addVideoFrame(0, 0, 480, 270, video);

        // Zapisuje prezentację. Podczas generowania dużej prezentacji zużycie pamięci
        // pozostaje niskie przez cały cykl życia obiektu pres 
        pres.save("presentationWithLargeVideo.pptx", SaveFormat.Pptx);
    } finally {
        if (fileStream != null) fileStream.close();
    }
} catch(IOException e) {
} finally {
    if (pres != null) pres.dispose();
}

Eksportuj duży plik przez BLOB z prezentacji

Aspose.Slides for Java umożliwia eksportowanie dużych plików (np. pliku audio lub wideo) przy użyciu procesu opartego na BLOB z prezentacji. Na przykład możesz potrzebować wyodrębnić duży plik multimedialny z prezentacji, ale nie chcesz, aby plik był ładowany do pamięci komputera. Eksportując plik przez proces BLOB, utrzymujesz niskie zużycie pamięci.

Ten kod w Javie demonstruje opisaną operację:

String hugePresentationWithAudiosAndVideosFile = "LargeVideoFileTest.pptx";

LoadOptions loadOptions = new LoadOptions();
// Blokuje plik źródłowy i nie ładuje go do pamięci
loadOptions.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked);

// Utwórz instancję klasy Presentation i zablokuj plik "hugePresentationWithAudiosAndVideos.pptx".
Presentation pres = new Presentation(hugePresentationWithAudiosAndVideosFile, loadOptions);
try {
    // Zapiszmy każde wideo do pliku. Aby zapobiec dużemu zużyciu pamięci, potrzebny jest bufor, który będzie używany
    // do przeniesienia danych ze strumienia wideo prezentacji do strumienia nowo utworzonego pliku wideo.
    byte[] buffer = new byte[8 * 1024];

    // Iteruje przez wszystkie wideo
    for (int index = 0; index < pres.getVideos().size(); index++) {
        IVideo video = pres.getVideos().get_Item(index);

        // Otwiera strumień wideo prezentacji. Należy zauważyć, że celowo unikaliśmy dostępu do właściwości
        // takich jak video.BinaryData – ponieważ ta właściwość zwraca tablicę bajtów zawierającą pełne wideo, co
        // powoduje załadowanie bajtów do pamięci. Używamy video.GetStream, który zwraca Stream – i nie
        //  nie wymaga od nas załadowania całego wideo do pamięci.
        InputStream presVideoStream = video.getStream();
        try {
            OutputStream outputFileStream = new FileOutputStream("video" + index + ".avi");
            try {
                int bytesRead;
                while ((bytesRead = presVideoStream.read(buffer, 0, buffer.length)) > 0) {
                    outputFileStream.write(buffer, 0, bytesRead);
                }
            } finally {
                outputFileStream.close();
            }
        } finally {
            presVideoStream.close();
        }
        // Zużycie pamięci pozostanie niskie niezależnie od rozmiaru wideo lub prezentacji.
    }
    // W razie potrzeby możesz zastosować te same kroki dla plików audio. 
} catch (IOException e) {
} finally {
    pres.dispose();
}

Dodaj obraz jako BLOB do prezentacji

Za pomocą metod z interfejsu IImageCollection oraz klasy ImageCollection możesz dodać duży obraz jako strumień, aby był traktowany jako BLOB.

Ten kod w Javie pokazuje, jak dodać duży obraz przez proces BLOB:

String pathToLargeImage = "large_image.jpg";

// tworzy nową prezentację, do której zostanie dodany obraz.
Presentation pres = new Presentation();
try {
	FileInputStream fileStream = new FileInputStream(pathToLargeImage);
	try {
		// Dodajmy obraz do prezentacji – wybieramy zachowanie KeepLocked, ponieważ
		// NIE zamierzamy uzyskiwać dostępu do pliku "largeImage.png" file.
		IPPImage img = pres.getImages().addImage(fileStream, LoadingStreamBehavior.KeepLocked);
		pres.getSlides().get_Item(0).getShapes().addPictureFrame(ShapeType.Rectangle, 0, 0, 300, 200, img);

		// Zapisuje prezentację. Podczas generowania dużej prezentacji zużycie pamięci
		// pozostaje niskie przez cały cykl życia obiektu pres
		pres.save("presentationWithLargeImage.pptx", SaveFormat.Pptx);
	} finally {
		if (fileStream != null) fileStream.close();
	}
} catch(IOException e) {
} finally {
	if (pres != null) pres.dispose();
}

Pamięć i duże prezentacje

Typowo, aby wczytać dużą prezentację, komputery wymagają dużo pamięci tymczasowej. Cała zawartość prezentacji jest ładowana do pamięci, a plik (z którego prezentacja została wczytana) przestaje być używany.

Rozważ dużą prezentację PowerPoint (large.pptx), która zawiera 1,5 GB plik wideo. Standardowa metoda wczytywania prezentacji jest przedstawiona w tym kodzie Java:

Presentation pres = new Presentation("large.pptx");
try {
    pres.save("large.pdf", SaveFormat.Pdf);
} finally {
    if (pres != null) pres.dispose();
}

Jednak metoda ta zużywa około 1,6 GB pamięci tymczasowej.

Wczytaj dużą prezentację jako BLOB

Poprzez proces wykorzystujący BLOB możesz wczytać dużą prezentację używając mało pamięci. Ten kod Java opisuje implementację, w której proces BLOB jest używany do wczytania dużego pliku prezentacji (large.pptx):

LoadOptions loadOptions = new LoadOptions();
loadOptions.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked);
loadOptions.getBlobManagementOptions().setTemporaryFilesAllowed(true);

Presentation pres = new Presentation("large.pptx", loadOptions);
try {
    pres.save("large.pdf", SaveFormat.Pdf);
} finally {
    if (pres != null) pres.dispose();
}

Zmień folder plików tymczasowych

Gdy używany jest proces BLOB, komputer tworzy pliki tymczasowe w domyślnym folderze plików tymczasowych. Jeśli chcesz, aby pliki tymczasowe były przechowywane w innym folderze, możesz zmienić ustawienia przechowywania za pomocą TempFilesRootPath:

LoadOptions loadOptions = new LoadOptions();
loadOptions.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked);
loadOptions.getBlobManagementOptions().setTemporaryFilesAllowed(true);
loadOptions.getBlobManagementOptions().setTempFilesRootPath("temp");

Zwolnij obiekty prezentacji, aby zwolnić pamięć

Podczas przetwarzania dużych prezentacji upewnij się, że instancja Presentation jest prawidłowo zwalniana, aby pamięć, którą zajmowała, została uwolniona. Wywołaj dispose() po zakończeniu pracy z prezentacją, aby zwolnić niezarządzane zasoby.

Presentation presentation = new Presentation("large.pptx");

// ...przetwarzaj prezentację...
presentation.save("large.pdf", SaveFormat.Pdf);

// Jawnie zwolnij zasoby.
presentation.dispose();

FAQ

Jakie dane w prezentacji Aspose.Slides są traktowane jako BLOB i kontrolowane przez opcje BLOB?

Duże obiekty binarne, takie jak obrazy, audio i wideo, są traktowane jako BLOB. Cały plik prezentacji również podlega obsłudze BLOB podczas ładowania lub zapisywania. Obiekty te są zarządzane przez polityki BLOB, które pozwalają kontrolować zużycie pamięci i przechowywanie w plikach tymczasowych w razie potrzeby.

Gdzie konfiguruje się zasady obsługi BLOB podczas ładowania prezentacji?

Użyj LoadOptions wraz z BlobManagementOptions. Tam ustawiasz limit pamięci dla BLOB, zezwalasz lub nie na pliki tymczasowe, wybierasz ścieżkę główną dla plików tymczasowych oraz określasz zachowanie blokowania źródła.

Czy ustawienia BLOB wpływają na wydajność i jak zbalansować szybkość wobec pamięci?

Tak. Trzymanie BLOB w pamięci maksymalizuje szybkość, ale zwiększa zużycie RAM; obniżenie limitu pamięci przenosi więcej pracy do plików tymczasowych, zmniejszając RAM kosztem dodatkowego I/O. Użyj metody setMaxBlobsBytesInMemory aby uzyskać właściwy balans dla swojego obciążenia i środowiska.

Czy opcje BLOB pomagają przy otwieraniu niezwykle dużych prezentacji (np. gigabajty)?

Tak. BlobManagementOptions są zaprojektowane do takich scenariuszy: włączenie plików tymczasowych i użycie blokowania źródła może znacząco zmniejszyć szczytowe zużycie RAM i ustabilizować przetwarzanie bardzo dużych zestawów slajdów.

Czy mogę stosować zasady BLOB przy ładowaniu ze strumieni zamiast plików dyskowych?

Tak. Te same zasady obowiązują dla strumieni: instancja prezentacji może posiadać i blokować strumień wejściowy (w zależności od wybranego trybu blokowania), a pliki tymczasowe są używane, gdy jest to dozwolone, utrzymując przewidywalne zużycie pamięci podczas przetwarzania.

Zarządzanie odnośnikami w prezentacji w Javie