MACRO NEPAL
PDF to Image Conversion in Java: Complete Guide
awiskar acharya
November 15, 2025
3:53 am

Converting PDF documents to images is a common requirement for document processing, preview generation, and content extraction. Here's a comprehensive guide to various approaches for PDF to image conversion in Java.

Approaches Overview

  1. Apache PDFBox - Most popular and feature-rich
  2. iText - Professional PDF library with conversion capabilities
  3. icepdf - Open source PDF viewer and converter
  4. Ghost4J - Java wrapper for Ghostscript

Approach 1: Apache PDFBox (Recommended)

Dependencies

<dependency>
<groupId>org.apache.pdfbox</groupId>
<artifactId>pdfbox</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.pdfbox</groupId>
<artifactId>pdfbox-tools</artifactId>
<version>3.0.0</version>
</dependency>

Example 1: Basic PDF to Image Conversion

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class PdfBoxBasicConverter {
public static void convertPdfToImages(String pdfPath, String outputDir, String format) 
throws IOException {
File pdfFile = new File(pdfPath);
File outputDirectory = new File(outputDir);
if (!outputDirectory.exists()) {
outputDirectory.mkdirs();
}
try (PDDocument document = PDDocument.load(pdfFile)) {
PDFRenderer pdfRenderer = new PDFRenderer(document);
for (int page = 0; page < document.getNumberOfPages(); page++) {
// Render each page as image
BufferedImage image = pdfRenderer.renderImageWithDPI(page, 300); // 300 DPI
// Create output file
String outputPath = String.format("%s/page_%03d.%s", 
outputDir, page + 1, format.toLowerCase());
File outputFile = new File(outputPath);
// Write image to file
ImageIO.write(image, format, outputFile);
System.out.println("Converted page " + (page + 1) + " to " + outputPath);
}
}
}
public static void main(String[] args) {
try {
String pdfPath = "document.pdf";
String outputDir = "output_images";
String format = "PNG"; // PNG, JPEG, BMP, etc.
convertPdfToImages(pdfPath, outputDir, format);
System.out.println("PDF conversion completed successfully!");
} catch (IOException e) {
System.err.println("Error converting PDF: " + e.getMessage());
e.printStackTrace();
}
}
}

Example 2: Advanced PDFBox with Custom Settings

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;
import org.apache.pdfbox.rendering.ImageType;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class PdfBoxAdvancedConverter {
public static class ConversionConfig {
private int dpi = 300;
private ImageType imageType = ImageType.RGB;
private String outputFormat = "PNG";
private float quality = 0.9f; // For JPEG
private boolean antiAliasing = true;
// Getters and setters
public int getDpi() { return dpi; }
public void setDpi(int dpi) { this.dpi = dpi; }
public ImageType getImageType() { return imageType; }
public void setImageType(ImageType imageType) { this.imageType = imageType; }
public String getOutputFormat() { return outputFormat; }
public void setOutputFormat(String outputFormat) { this.outputFormat = outputFormat; }
public float getQuality() { return quality; }
public void setQuality(float quality) { this.quality = quality; }
public boolean isAntiAliasing() { return antiAliasing; }
public void setAntiAliasing(boolean antiAliasing) { this.antiAliasing = antiAliasing; }
}
public static List<File> convertPdfToImages(String pdfPath, String outputDir, 
ConversionConfig config) throws IOException {
List<File> convertedFiles = new ArrayList<>();
File pdfFile = new File(pdfPath);
File outputDirectory = new File(outputDir);
if (!outputDirectory.exists()) {
outputDirectory.mkdirs();
}
try (PDDocument document = PDDocument.load(pdfFile)) {
PDFRenderer pdfRenderer = new PDFRenderer(document);
for (int page = 0; page < document.getNumberOfPages(); page++) {
System.out.println("Processing page " + (page + 1) + " of " + 
document.getNumberOfPages());
// Render with custom settings
BufferedImage image = pdfRenderer.renderImageWithDPI(
page, config.getDpi(), config.getImageType());
// Apply post-processing if needed
if (config.isAntiAliasing()) {
image = applyAntiAliasing(image);
}
// Create output file
String outputPath = String.format("%s/page_%03d.%s", 
outputDir, page + 1, config.getOutputFormat().toLowerCase());
File outputFile = new File(outputPath);
// Write image with quality settings for JPEG
if ("JPEG".equalsIgnoreCase(config.getOutputFormat())) {
writeJpegWithQuality(image, outputFile, config.getQuality());
} else {
ImageIO.write(image, config.getOutputFormat(), outputFile);
}
convertedFiles.add(outputFile);
System.out.println("Converted: " + outputFile.getName());
}
}
return convertedFiles;
}
private static BufferedImage applyAntiAliasing(BufferedImage original) {
// Simple anti-aliasing by scaling (basic implementation)
int newWidth = original.getWidth();
int newHeight = original.getHeight();
BufferedImage smoothed = new BufferedImage(newWidth, newHeight, original.getType());
java.awt.Graphics2D g2d = smoothed.createGraphics();
// Enable anti-aliasing
g2d.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, 
java.awt.RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setRenderingHint(java.awt.RenderingHints.KEY_INTERPOLATION, 
java.awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.drawImage(original, 0, 0, newWidth, newHeight, null);
g2d.dispose();
return smoothed;
}
private static void writeJpegWithQuality(BufferedImage image, File outputFile, float quality) 
throws IOException {
javax.imageio.plugins.jpeg.JPEGImageWriteParam jpegParams = 
new javax.imageio.plugins.jpeg.JPEGImageWriteParam(null);
jpegParams.setCompressionMode(javax.imageio.ImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(quality);
javax.imageio.ImageWriter writer = ImageIO.getImageWritersByFormatName("JPEG").next();
try (javax.imageio.stream.FileImageOutputStream output = 
new javax.imageio.stream.FileImageOutputStream(outputFile)) {
writer.setOutput(output);
writer.write(null, new javax.imageio.IIOImage(image, null, null), jpegParams);
} finally {
writer.dispose();
}
}
public static void main(String[] args) {
try {
ConversionConfig config = new ConversionConfig();
config.setDpi(200);
config.setImageType(ImageType.RGB);
config.setOutputFormat("JPEG");
config.setQuality(0.8f);
config.setAntiAliasing(true);
List<File> convertedFiles = convertPdfToImages(
"document.pdf", "output_images", config);
System.out.println("Conversion completed! Files created: " + convertedFiles.size());
} catch (IOException e) {
System.err.println("Error converting PDF: " + e.getMessage());
e.printStackTrace();
}
}
}

Approach 2: iText PDF to Image

Dependencies

<dependency>
<groupId>com.itextpdf</groupId>
<artifactId>itext7-core</artifactId>
<version>8.0.0</version>
<type>pom</type>
</dependency>

Example 3: iText PDF Conversion

import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfReader;
import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
import com.itextpdf.kernel.pdf.xobject.PdfFormXObject;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class ITextPdfConverter {
public static void convertPdfToImages(String pdfPath, String outputDir, String format) 
throws IOException {
File pdfFile = new File(pdfPath);
File outputDirectory = new File(outputDir);
if (!outputDirectory.exists()) {
outputDirectory.mkdirs();
}
try (PdfDocument pdfDoc = new PdfDocument(new PdfReader(pdfFile))) {
int totalPages = pdfDoc.getNumberOfPages();
for (int pageNum = 1; pageNum <= totalPages; pageNum++) {
System.out.println("Processing page " + pageNum + " of " + totalPages);
// Create form XObject from page
PdfFormXObject formXObject = pdfDoc.getPage(pageNum).copyAsFormXObject();
// Create buffered image
BufferedImage image = createImageFromFormXObject(formXObject);
// Save image
String outputPath = String.format("%s/page_%03d.%s", 
outputDir, pageNum, format.toLowerCase());
File outputFile = new File(outputPath);
ImageIO.write(image, format, outputFile);
System.out.println("Converted: " + outputFile.getName());
}
}
}
private static BufferedImage createImageFromFormXObject(PdfFormXObject formXObject) {
// Get page dimensions
float width = formXObject.getWidth();
float height = formXObject.getHeight();
// Create buffered image with appropriate dimensions
BufferedImage image = new BufferedImage(
(int) width, (int) height, BufferedImage.TYPE_INT_RGB);
java.awt.Graphics2D g2d = image.createGraphics();
// Set white background
g2d.setColor(java.awt.Color.WHITE);
g2d.fillRect(0, 0, (int) width, (int) height);
// Note: iText 7 doesn't have direct rendering to BufferedImage like PDFBox
// This is a simplified approach - for production, consider using PDFBox or other libraries
g2d.dispose();
return image;
}
public static void main(String[] args) {
try {
convertPdfToImages("document.pdf", "itext_output", "PNG");
System.out.println("iText conversion completed!");
} catch (IOException e) {
System.err.println("Error converting PDF with iText: " + e.getMessage());
e.printStackTrace();
}
}
}

Approach 3: icepdf PDF to Image

Dependencies

<dependency>
<groupId>org.icepdf</groupId>
<artifactId>icepdf-core</artifactId>
<version>7.1.0</version>
</dependency>

Example 4: icepdf Conversion

import org.icepdf.core.pobjects.Document;
import org.icepdf.core.pobjects.Page;
import org.icepdf.core.util.GraphicsRenderingHints;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class IcePdfConverter {
public static void convertPdfToImages(String pdfPath, String outputDir, String format, 
float scale, float rotation) throws IOException {
Document document = new Document();
File outputDirectory = new File(outputDir);
if (!outputDirectory.exists()) {
outputDirectory.mkdirs();
}
try {
document.setFile(pdfPath);
int totalPages = document.getNumberOfPages();
for (int pageNum = 0; pageNum < totalPages; pageNum++) {
System.out.println("Processing page " + (pageNum + 1) + " of " + totalPages);
// Render page to image
BufferedImage image = (BufferedImage) document.getPageImage(
pageNum, GraphicsRenderingHints.SCREEN, 
Page.BOUNDARY_CROPBOX, rotation, scale);
// Save image
String outputPath = String.format("%s/page_%03d.%s", 
outputDir, pageNum + 1, format.toLowerCase());
File outputFile = new File(outputPath);
ImageIO.write(image, format, outputFile);
System.out.println("Converted: " + outputFile.getName());
}
} finally {
document.dispose();
}
}
public static void main(String[] args) {
try {
// Convert with 2x scale and no rotation
convertPdfToImages("document.pdf", "icepdf_output", "PNG", 2.0f, 0f);
System.out.println("icePDF conversion completed!");
} catch (IOException e) {
System.err.println("Error converting PDF with icePDF: " + e.getMessage());
e.printStackTrace();
}
}
}

Approach 4: Ghost4J with Ghostscript

Dependencies

<dependency>
<groupId>org.ghost4j</groupId>
<artifactId>ghost4j</artifactId>
<version>1.0.1</version>
</dependency>

Example 5: Ghost4J Conversion

import org.ghost4j.document.PDFDocument;
import org.ghost4j.renderer.SimpleRenderer;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.List;
import javax.imageio.ImageIO;
public class Ghost4JConverter {
public static void convertPdfToImages(String pdfPath, String outputDir, String format, 
int dpi) throws Exception {
PDFDocument document = new PDFDocument();
document.load(new File(pdfFile));
SimpleRenderer renderer = new SimpleRenderer();
renderer.setResolution(dpi); // Set DPI for output
File outputDirectory = new File(outputDir);
if (!outputDirectory.exists()) {
outputDirectory.mkdirs();
}
try {
List<BufferedImage> images = renderer.render(document);
for (int i = 0; i < images.size(); i++) {
BufferedImage image = images.get(i);
String outputPath = String.format("%s/page_%03d.%s", 
outputDir, i + 1, format.toLowerCase());
File outputFile = new File(outputPath);
ImageIO.write(image, format, outputFile);
System.out.println("Converted: " + outputFile.getName());
}
} catch (Exception e) {
throw new Exception("Ghost4J conversion failed: " + e.getMessage(), e);
}
}
public static void main(String[] args) {
try {
convertPdfToImages("document.pdf", "ghost4j_output", "PNG", 300);
System.out.println("Ghost4J conversion completed!");
} catch (Exception e) {
System.err.println("Error converting PDF with Ghost4J: " + e.getMessage());
e.printStackTrace();
}
}
}

Production-Ready PDF Conversion Service

Example 6: Comprehensive PDF Conversion Service

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;
import org.apache.pdfbox.rendering.ImageType;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.FileImageOutputStream;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
public class ProductionPdfConverter {
public enum OutputFormat {
PNG, JPEG, BMP, GIF
}
public static class ConversionRequest {
private File pdfFile;
private File outputDirectory;
private OutputFormat format = OutputFormat.PNG;
private int dpi = 300;
private ImageType imageType = ImageType.RGB;
private float jpegQuality = 0.9f;
private int timeoutSeconds = 300;
private String filenamePattern = "page_%03d";
// Constructors, getters, and setters
public ConversionRequest(File pdfFile, File outputDirectory) {
this.pdfFile = pdfFile;
this.outputDirectory = outputDirectory;
}
// Getters and setters...
public File getPdfFile() { return pdfFile; }
public void setPdfFile(File pdfFile) { this.pdfFile = pdfFile; }
public File getOutputDirectory() { return outputDirectory; }
public void setOutputDirectory(File outputDirectory) { this.outputDirectory = outputDirectory; }
public OutputFormat getFormat() { return format; }
public void setFormat(OutputFormat format) { this.format = format; }
public int getDpi() { return dpi; }
public void setDpi(int dpi) { this.dpi = dpi; }
public ImageType getImageType() { return imageType; }
public void setImageType(ImageType imageType) { this.imageType = imageType; }
public float getJpegQuality() { return jpegQuality; }
public void setJpegQuality(float jpegQuality) { this.jpegQuality = jpegQuality; }
public int getTimeoutSeconds() { return timeoutSeconds; }
public void setTimeoutSeconds(int timeoutSeconds) { this.timeoutSeconds = timeoutSeconds; }
public String getFilenamePattern() { return filenamePattern; }
public void setFilenamePattern(String filenamePattern) { this.filenamePattern = filenamePattern; }
}
public static class ConversionResult {
private boolean success;
private List<File> convertedFiles;
private String errorMessage;
private long processingTimeMs;
public ConversionResult(boolean success, List<File> convertedFiles, 
String errorMessage, long processingTimeMs) {
this.success = success;
this.convertedFiles = convertedFiles;
this.errorMessage = errorMessage;
this.processingTimeMs = processingTimeMs;
}
// Getters
public boolean isSuccess() { return success; }
public List<File> getConvertedFiles() { return convertedFiles; }
public String getErrorMessage() { return errorMessage; }
public long getProcessingTimeMs() { return processingTimeMs; }
}
private final ExecutorService executorService;
public ProductionPdfConverter(int threadPoolSize) {
this.executorService = Executors.newFixedThreadPool(threadPoolSize);
}
public Future<ConversionResult> convertAsync(ConversionRequest request) {
return executorService.submit(() -> convert(request));
}
public ConversionResult convert(ConversionRequest request) {
long startTime = System.currentTimeMillis();
List<File> convertedFiles = new ArrayList<>();
try {
// Validate inputs
validateRequest(request);
// Ensure output directory exists
if (!request.getOutputDirectory().exists()) {
request.getOutputDirectory().mkdirs();
}
try (PDDocument document = PDDocument.load(request.getPdfFile())) {
PDFRenderer pdfRenderer = new PDFRenderer(document);
int totalPages = document.getNumberOfPages();
System.out.printf("Converting %s (%d pages) to %s with %d DPI%n",
request.getPdfFile().getName(), totalPages, 
request.getFormat(), request.getDpi());
for (int page = 0; page < totalPages; page++) {
// Check for timeout
if (System.currentTimeMillis() - startTime > request.getTimeoutSeconds() * 1000L) {
throw new TimeoutException("Conversion timeout exceeded");
}
// Render page
BufferedImage image = pdfRenderer.renderImageWithDPI(
page, request.getDpi(), request.getImageType());
// Create output file
String filename = String.format(request.getFilenamePattern() + ".%s", 
page + 1, request.getFormat().name().toLowerCase());
File outputFile = new File(request.getOutputDirectory(), filename);
// Write image with appropriate settings
writeImage(image, outputFile, request);
convertedFiles.add(outputFile);
System.out.printf("Converted page %d/%d: %s%n", 
page + 1, totalPages, outputFile.getName());
}
}
long processingTime = System.currentTimeMillis() - startTime;
return new ConversionResult(true, convertedFiles, null, processingTime);
} catch (Exception e) {
long processingTime = System.currentTimeMillis() - startTime;
return new ConversionResult(false, convertedFiles, e.getMessage(), processingTime);
}
}
private void validateRequest(ConversionRequest request) throws IllegalArgumentException {
if (request.getPdfFile() == null || !request.getPdfFile().exists()) {
throw new IllegalArgumentException("PDF file does not exist: " + 
(request.getPdfFile() != null ? request.getPdfFile().getPath() : "null"));
}
if (request.getOutputDirectory() == null) {
throw new IllegalArgumentException("Output directory cannot be null");
}
if (request.getDpi() < 72 || request.getDpi() > 1200) {
throw new IllegalArgumentException("DPI must be between 72 and 1200");
}
if (request.getFormat() == OutputFormat.JPEG && 
(request.getJpegQuality() < 0.1f || request.getJpegQuality() > 1.0f)) {
throw new IllegalArgumentException("JPEG quality must be between 0.1 and 1.0");
}
}
private void writeImage(BufferedImage image, File outputFile, ConversionRequest request) 
throws IOException {
String formatName = request.getFormat().name().toLowerCase();
if (request.getFormat() == OutputFormat.JPEG) {
writeJpegWithQuality(image, outputFile, request.getJpegQuality());
} else {
if (!ImageIO.write(image, formatName, outputFile)) {
throw new IOException("No appropriate writer found for format: " + formatName);
}
}
}
private void writeJpegWithQuality(BufferedImage image, File outputFile, float quality) 
throws IOException {
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("JPEG");
if (!writers.hasNext()) {
throw new IOException("No JPEG writer available");
}
ImageWriter writer = writers.next();
ImageWriteParam params = writer.getDefaultWriteParam();
params.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
params.setCompressionQuality(quality);
try (FileImageOutputStream output = new FileImageOutputStream(outputFile)) {
writer.setOutput(output);
writer.write(null, new javax.imageio.IIOImage(image, null, null), params);
} finally {
writer.dispose();
}
}
public void shutdown() {
executorService.shutdown();
try {
if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
executorService.shutdownNow();
}
} catch (InterruptedException e) {
executorService.shutdownNow();
Thread.currentThread().interrupt();
}
}
public static void main(String[] args) {
ProductionPdfConverter converter = new ProductionPdfConverter(4);
try {
ConversionRequest request = new ConversionRequest(
new File("document.pdf"), 
new File("production_output")
);
request.setFormat(OutputFormat.JPEG);
request.setDpi(200);
request.setJpegQuality(0.85f);
request.setFilenamePattern("document_page_%03d");
ConversionResult result = converter.convert(request);
if (result.isSuccess()) {
System.out.printf("Conversion successful! %d files created in %d ms%n",
result.getConvertedFiles().size(), result.getProcessingTimeMs());
} else {
System.err.printf("Conversion failed: %s%n", result.getErrorMessage());
}
} finally {
converter.shutdown();
}
}
}

Batch Processing and Monitoring

Example 7: Batch PDF Conversion with Progress Tracking

import java.io.File;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class BatchPdfConverter {
private final ProductionPdfConverter converter;
private final int batchSize;
public BatchPdfConverter(int threadPoolSize, int batchSize) {
this.converter = new ProductionPdfConverter(threadPoolSize);
this.batchSize = batchSize;
}
public BatchConversionResult convertBatch(List<File> pdfFiles, File outputBaseDir, 
ProductionPdfConverter.OutputFormat format) {
AtomicInteger completed = new AtomicInteger(0);
AtomicInteger failed = new AtomicInteger(0);
List<Future<ProductionPdfConverter.ConversionResult>> futures = new ArrayList<>();
Map<File, ProductionPdfConverter.ConversionResult> results = new ConcurrentHashMap<>();
// Create conversion tasks
for (File pdfFile : pdfFiles) {
File outputDir = new File(outputBaseDir, getOutputDirName(pdfFile));
ProductionPdfConverter.ConversionRequest request = 
new ProductionPdfConverter.ConversionRequest(pdfFile, outputDir);
request.setFormat(format);
request.setDpi(150); // Lower DPI for faster batch processing
Future<ProductionPdfConverter.ConversionResult> future = 
converter.convertAsync(request);
futures.add(future);
}
// Monitor progress
ExecutorService monitorService = Executors.newSingleThreadExecutor();
Future<?> monitorFuture = monitorService.submit(() -> {
while (completed.get() + failed.get() < pdfFiles.size()) {
try {
Thread.sleep(1000);
System.out.printf("Progress: %d/%d completed, %d failed%n",
completed.get(), pdfFiles.size(), failed.get());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
});
// Collect results
for (int i = 0; i < futures.size(); i++) {
try {
ProductionPdfConverter.ConversionResult result = futures.get(i).get();
results.put(pdfFiles.get(i), result);
if (result.isSuccess()) {
completed.incrementAndGet();
} else {
failed.incrementAndGet();
}
} catch (Exception e) {
failed.incrementAndGet();
System.err.println("Failed to process: " + pdfFiles.get(i).getName());
}
}
monitorFuture.cancel(true);
monitorService.shutdown();
return new BatchConversionResult(results, completed.get(), failed.get());
}
private String getOutputDirName(File pdfFile) {
String name = pdfFile.getName();
int dotIndex = name.lastIndexOf('.');
return dotIndex > 0 ? name.substring(0, dotIndex) : name;
}
public void shutdown() {
converter.shutdown();
}
public static class BatchConversionResult {
private final Map<File, ProductionPdfConverter.ConversionResult> results;
private final int completed;
private final int failed;
public BatchConversionResult(Map<File, ProductionPdfConverter.ConversionResult> results,
int completed, int failed) {
this.results = results;
this.completed = completed;
this.failed = failed;
}
// Getters
public Map<File, ProductionPdfConverter.ConversionResult> getResults() { return results; }
public int getCompleted() { return completed; }
public int getFailed() { return failed; }
public int getTotal() { return completed + failed; }
}
public static void main(String[] args) {
BatchPdfConverter batchConverter = new BatchPdfConverter(4, 10);
try {
// Find all PDF files in a directory
File inputDir = new File("pdf_documents");
File[] pdfFiles = inputDir.listFiles((dir, name) -> 
name.toLowerCase().endsWith(".pdf"));
if (pdfFiles == null || pdfFiles.length == 0) {
System.out.println("No PDF files found in " + inputDir.getPath());
return;
}
File outputBaseDir = new File("batch_output");
BatchConversionResult batchResult = batchConverter.convertBatch(
Arrays.asList(pdfFiles), outputBaseDir, ProductionPdfConverter.OutputFormat.PNG);
System.out.printf("Batch conversion completed: %d successful, %d failed%n",
batchResult.getCompleted(), batchResult.getFailed());
} finally {
batchConverter.shutdown();
}
}
}

Performance Optimization Tips

  1. Memory Management: Use PDDocument.load() with memory usage settings for large PDFs
  2. Thread Pooling: Use fixed thread pools for concurrent conversions
  3. DPI Selection: Choose appropriate DPI (72-150 for screen, 300+ for print)
  4. Image Format: Use JPEG for photos, PNG for text/diagrams
  5. Progressive Rendering: Process large PDFs in chunks

Error Handling and Logging

Example 8: Robust Error Handling

import org.apache.log4j.Logger;
import java.io.File;
import java.io.IOException;
public class ErrorHandlingPdfConverter {
private static final Logger logger = Logger.getLogger(ErrorHandlingPdfConverter.class);
public static class ConversionException extends Exception {
public ConversionException(String message) {
super(message);
}
public ConversionException(String message, Throwable cause) {
super(message, cause);
}
}
public static void convertWithErrorHandling(String pdfPath, String outputDir, String format) 
throws ConversionException {
File pdfFile = new File(pdfPath);
File outputDirectory = new File(outputDir);
// Input validation
if (!pdfFile.exists()) {
throw new ConversionException("PDF file not found: " + pdfPath);
}
if (!pdfFile.canRead()) {
throw new ConversionException("Cannot read PDF file: " + pdfPath);
}
if (outputDirectory.exists() && !outputDirectory.isDirectory()) {
throw new ConversionException("Output path is not a directory: " + outputDir);
}
try (PDDocument document = PDDocument.load(pdfFile)) {
PDFRenderer pdfRenderer = new PDFRenderer(document);
if (!outputDirectory.exists() && !outputDirectory.mkdirs()) {
throw new ConversionException("Failed to create output directory: " + outputDir);
}
// Check disk space
long requiredSpace = document.getNumberOfPages() * 1024L * 1024L; // 1MB per page estimate
if (outputDirectory.getFreeSpace() < requiredSpace) {
throw new ConversionException("Insufficient disk space in output directory");
}
// Perform conversion
for (int page = 0; page < document.getNumberOfPages(); page++) {
try {
BufferedImage image = pdfRenderer.renderImageWithDPI(page, 300);
String outputPath = String.format("%s/page_%03d.%s", 
outputDir, page + 1, format.toLowerCase());
File outputFile = new File(outputPath);
if (!ImageIO.write(image, format, outputFile)) {
logger.warn("Failed to write page " + (page + 1) + " as " + format);
}
} catch (IOException e) {
logger.error("Failed to convert page " + (page + 1), e);
throw new ConversionException("Failed to convert page " + (page + 1), e);
}
}
logger.info("Successfully converted " + document.getNumberOfPages() + 
" pages from " + pdfPath);
} catch (IOException e) {
logger.error("Failed to load PDF document: " + pdfPath, e);
throw new ConversionException("Failed to load PDF document", e);
}
}
}

Conclusion

PDF to image conversion in Java can be achieved through several robust libraries:

  1. Apache PDFBox - Most recommended for general use
  2. iText - Good for PDF manipulation with conversion capabilities
  3. icepdf - Excellent for viewing and basic conversion
  4. Ghost4J - Powerful but requires Ghostscript installation

Recommendations:

  • Use PDFBox for most use cases - it's well-maintained and feature-rich
  • Consider image format and DPI based on your requirements
  • Implement proper error handling and logging for production use
  • Use async processing for better performance with multiple files
  • Monitor memory usage when processing large PDF files

The provided examples give you a solid foundation for implementing PDF to image conversion in various scenarios, from simple conversions to enterprise-grade batch processing systems.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper