SpringBoot中PDF处理完全指南

1. PDF基础知识

1.1 什么是PDF

PDF(Portable Document Format，便携式文档格式)是由Adobe公司开发的一种电子文件格式，旨在独立于应用软件、硬件和操作系统，呈现文档的固定布局。PDF具有以下特点：

• 跨平台兼容性：可以在任何操作系统上查看，保持相同的外观
• 文档完整性：包含文本、图像、表格、字体等所有文档元素
• 紧凑性：支持多种压缩技术
• 安全性：可以设置密码和权限
• 交互性：支持超链接、表单、多媒体等交互元素

1.2 PDF文件结构

PDF文件包含四个主要部分：

1. 头部(Header)：标识PDF版本
2. 主体(Body)：包含文档内容（文本、图像等）
3. 交叉引用表(Cross-reference Table)：提供文档对象位置的索引
4. 尾部(Trailer)：包含指向交叉引用表的指针和其他对象的引用

了解这些基础概念对于理解PDF操作库的工作原理很有帮助。

2. SpringBoot中的PDF处理库

在SpringBoot应用中处理PDF文件，有几个流行的Java库可供选择：

2.1 iText

iText是一个功能强大的PDF处理库，适用于生成、修改和分析PDF文档。

Maven依赖:

<!-- iText核心库 -->
<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itextpdf</artifactId>
    <version>5.5.13.3</version>
</dependency>

<!-- iText 7 (更新版本) -->
<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext7-core</artifactId>
    <version>7.2.5</version>
    <type>pom</type>
</dependency>

注意：iText有开源版本(AGPL许可)和商业版本。在商业项目中使用前，请确认许可证要求。

2.2 Apache PDFBox

Apache PDFBox是Apache软件基金会的开源PDF库，功能全面，许可证更加开放(Apache License 2.0)。

Maven依赖:

<dependency>
    <groupId>org.apache.pdfbox</groupId>
    <artifactId>pdfbox</artifactId>
    <version>2.0.27</version>
</dependency>

2.3 OpenPDF

OpenPDF是iText 4.2.0的开源继承者，提供了更灵活的许可证(LGPL/MPL)。

Maven依赖:

<dependency>
    <groupId>com.github.librepdf</groupId>
    <artifactId>openpdf</artifactId>
    <version>1.3.30</version>
</dependency>

2.4 JasperReports

JasperReports是一个用于生成PDF报表的高级库，特别适合复杂报表的生成。

Maven依赖:

<dependency>
    <groupId>net.sf.jasperreports</groupId>
    <artifactId>jasperreports</artifactId>
    <version>6.20.0</version>
</dependency>

2.5 选择哪个库？

• iText: 功能最全面，适合需要高度自定义的场景，但许可限制需要注意
• Apache PDFBox: 开源友好，适合基本PDF操作，API相对低级
• OpenPDF: 适合需要iText功能但关注许可问题的项目
• JasperReports: 最适合复杂报表生成，学习曲线较陡

3. 生成PDF文件

3.1 使用iText生成PDF

基本PDF文档生成

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;

import java.io.FileOutputStream;
import java.io.IOException;

@Service
public class PdfGenerationService {

    public void generateSimplePdf(String outputPath) throws DocumentException, IOException {
        // 创建文档
        Document document = new Document();
        
        // 创建PdfWriter实例
        PdfWriter.getInstance(document, new FileOutputStream(outputPath));
        
        // 打开文档
        document.open();
        
        // 添加内容
        document.add(new Paragraph("Hello World! 这是我用iText生成的第一个PDF文档。"));
        document.add(new Paragraph("PDF生成时间: " + new java.util.Date()));
        
        // 关闭文档
        document.close();
        
        System.out.println("PDF已创建: " + outputPath);
    }
}

添加表格

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;

import java.io.FileOutputStream;
import java.io.IOException;

@Service
public class PdfTableService {

    public void generatePdfWithTable(String outputPath) throws DocumentException, IOException {
        Document document = new Document();
        PdfWriter.getInstance(document, new FileOutputStream(outputPath));
        
        document.open();
        
        // 添加一个段落
        document.add(new Paragraph("用户数据表"));
        
        // 创建表格(3列)
        PdfPTable table = new PdfPTable(3);
        // 设置表格宽度百分比
        table.setWidthPercentage(100);
        // 设置列宽比例
        table.setWidths(new float[]{2, 5, 3});
        
        // 添加表头
        addTableHeader(table);
        
        // 添加行数据
        addTableRows(table);
        
        // 将表格添加到文档
        document.add(table);
        
        document.close();
    }
    
    private void addTableHeader(PdfPTable table) {
        PdfPCell header = new PdfPCell();
        header.setBackgroundColor(BaseColor.LIGHT_GRAY);
        header.setBorderWidth(2);
        header.setHorizontalAlignment(Element.ALIGN_CENTER);
        
        header.setPhrase(new Phrase("ID"));
        table.addCell(header);
        
        header.setPhrase(new Phrase("姓名"));
        table.addCell(header);
        
        header.setPhrase(new Phrase("角色"));
        table.addCell(header);
    }
    
    private void addTableRows(PdfPTable table) {
        // 第一行
        table.addCell("1001");
        table.addCell("张三");
        table.addCell("管理员");
        
        // 第二行
        table.addCell("1002");
        table.addCell("李四");
        table.addCell("用户");
        
        // 第三行
        table.addCell("1003");
        table.addCell("王五");
        table.addCell("审核员");
    }
}

添加图片

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Image;
import com.itextpdf.text.pdf.PdfWriter;

import java.io.FileOutputStream;
import java.io.IOException;

@Service
public class PdfImageService {

    public void generatePdfWithImage(String outputPath, String imagePath) 
            throws DocumentException, IOException {
        Document document = new Document();
        PdfWriter.getInstance(document, new FileOutputStream(outputPath));
        
        document.open();
        
        // 添加文本
        document.add(new Paragraph("包含图片的PDF文档"));
        
        // 添加图片
        Image image = Image.getInstance(imagePath);
        // 缩放图片
        image.scaleToFit(400, 300);
        // 设置图片位置(居中)
        image.setAlignment(Image.MIDDLE);
        
        document.add(image);
        
        // 在图片下添加说明
        document.add(new Paragraph("图1: 示例图片"));
        
        document.close();
    }
}

3.2 使用Apache PDFBox生成PDF

基本文档生成

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType0Font;

import java.io.File;
import java.io.IOException;

@Service
public class PdfBoxService {

    public void generateSimplePdf(String outputPath) throws IOException {
        // 创建新文档
        PDDocument document = new PDDocument();
        
        // 添加空白页
        PDPage page = new PDPage();
        document.addPage(page);
        
        // 创建内容流以添加内容
        PDPageContentStream contentStream = new PDPageContentStream(document, page);
        
        // 开始文本操作
        contentStream.beginText();
        
        // 设置字体和大小
        // 使用带有中文支持的字体
        PDType0Font font = PDType0Font.load(document, 
                new File("src/main/resources/fonts/SimSun.ttf"));
        contentStream.setFont(font, 12);
        
        // 设置文本位置(从页面左下角计算,单位是点)
        contentStream.newLineAtOffset(25, 700);
        
        // 添加文本
        contentStream.showText("Hello World! 这是我用PDFBox生成的PDF文档。");
        
        // 移动到下一行
        contentStream.newLineAtOffset(0, -15);
        contentStream.showText("PDF生成时间: " + new java.util.Date());
        
        // 结束文本操作
        contentStream.endText();
        
        // 关闭内容流
        contentStream.close();
        
        // 保存文档
        document.save(outputPath);
        
        // 关闭文档
        document.close();
        
        System.out.println("PDFBox已创建PDF: " + outputPath);
    }
}

添加表格(PDFBox中较为复杂)

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType0Font;

import java.io.File;
import java.io.IOException;

@Service
public class PdfBoxTableService {

    public void generatePdfWithTable(String outputPath) throws IOException {
        // 创建文档
        PDDocument document = new PDDocument();
        PDPage page = new PDPage();
        document.addPage(page);
        
        PDPageContentStream contentStream = new PDPageContentStream(document, page);
        
        // 加载字体
        PDType0Font font = PDType0Font.load(document, 
                new File("src/main/resources/fonts/SimSun.ttf"));
        
        // 表格内容
        String[][] content = {
                {"ID", "姓名", "角色"},
                {"1001", "张三", "管理员"},
                {"1002", "李四", "用户"},
                {"1003", "王五", "审核员"}
        };
        
        // 表格位置和尺寸
        float margin = 50;
        float y = page.getMediaBox().getHeight() - margin;
        float tableWidth = page.getMediaBox().getWidth() - 2 * margin;
        
        // 绘制标题
        contentStream.beginText();
        contentStream.setFont(font, 16);
        contentStream.newLineAtOffset(margin, y);
        contentStream.showText("用户数据表");
        contentStream.endText();
        
        y -= 30;
        
        // 计算每列宽度
        final int rows = content.length;
        final int cols = content[0].length;
        final float rowHeight = 20f;
        final float tableHeight = rowHeight * rows;
        final float colWidth = tableWidth / (float)cols;
        
        // 画表格
        // 表格外框
        contentStream.setLineWidth(1f);
        contentStream.addRect(margin, y - tableHeight, tableWidth, tableHeight);
        contentStream.stroke();
        
        // 画横线
        for(int i = 0; i < rows; i++) {
            contentStream.addLine(margin, y - i * rowHeight, 
                    margin + tableWidth, y - i * rowHeight);
        }
        contentStream.stroke();
        
        // 画竖线
        for(int i = 0; i <= cols; i++) {
            contentStream.addLine(margin + i * colWidth, y, 
                    margin + i * colWidth, y - tableHeight);
        }
        contentStream.stroke();
        
        // 添加文本
        contentStream.setFont(font, 12);
        
        // 表头使用粗体
        float textx = margin + 5;
        float texty = y - 15;
        
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                contentStream.beginText();
                contentStream.newLineAtOffset(textx + j * colWidth, texty - i * rowHeight);
                contentStream.showText(content[i][j]);
                contentStream.endText();
            }
        }
        
        contentStream.close();
        document.save(outputPath);
        document.close();
    }
}

3.3 使用OpenPDF生成PDF

import com.lowagie.text.Document;
import com.lowagie.text.DocumentException;
import com.lowagie.text.Paragraph;
import com.lowagie.text.pdf.PdfWriter;

import java.io.FileOutputStream;
import java.io.IOException;

@Service
public class OpenPdfService {

    public void generateSimplePdf(String outputPath) throws DocumentException, IOException {
        // 创建文档
        Document document = new Document();
        
        // 创建Writer
        PdfWriter.getInstance(document, new FileOutputStream(outputPath));
        
        // 打开文档
        document.open();
        
        // 添加内容
        document.add(new Paragraph("Hello World! 这是我用OpenPDF生成的文档。"));
        document.add(new Paragraph("PDF生成时间: " + new java.util.Date()));
        
        // 关闭文档
        document.close();
        
        System.out.println("OpenPDF已创建PDF: " + outputPath);
    }
}

3.4 在SpringBoot控制器中生成并下载PDF

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.ByteArrayOutputStream;

@RestController
@RequestMapping("/api/pdf")
public class PdfController {

    @Autowired
    private PdfGenerationService pdfService;
    
    @GetMapping("/download")
    public ResponseEntity<byte[]> downloadPdf() {
        try {
            // 使用ByteArrayOutputStream而非文件
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            
            // 生成PDF到内存流
            pdfService.generatePdf(baos);
            
            // 设置HTTP头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_PDF);
            
            // 设置文件下载头
            String filename = "generated_document.pdf";
            headers.setContentDispositionFormData("attachment", filename);
            
            // 返回PDF字节数组
            return new ResponseEntity<>(baos.toByteArray(), headers, HttpStatus.OK);
            
        } catch (Exception e) {
            e.printStackTrace();
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

对应的服务类：

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;

import java.io.IOException;
import java.io.OutputStream;

@Service
public class PdfGenerationService {

    public void generatePdf(OutputStream outputStream) throws DocumentException, IOException {
        // 创建文档
        Document document = new Document();
        
        // 写入输出流
        PdfWriter.getInstance(document, outputStream);
        
        // 打开文档
        document.open();
        
        // 添加内容
        document.add(new Paragraph("动态生成的PDF内容"));
        document.add(new Paragraph("此PDF由SpringBoot应用程序生成"));
        document.add(new Paragraph("生成时间: " + new java.util.Date()));
        
        // 关闭文档
        document.close();
    }
}

4. 读取与解析PDF

4.1 使用PDFBox读取PDF文本

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.text.PDFTextStripper;

import java.io.File;
import java.io.IOException;

@Service
public class PdfReaderService {

    public String extractTextFromPdf(String pdfPath) throws IOException {
        // 加载PDF文档
        File file = new File(pdfPath);
        PDDocument document = PDDocument.load(file);
        
        try {
            // 创建PDF文本提取器
            PDFTextStripper stripper = new PDFTextStripper();
            
            // 获取文本内容
            String text = stripper.getText(document);
            
            return text;
        } finally {
            // 确保文档关闭
            if (document != null) {
                document.close();
            }
        }
    }
    
    // 提取特定页面的文本
    public String extractTextFromPage(String pdfPath, int pageNumber) throws IOException {
        File file = new File(pdfPath);
        PDDocument document = PDDocument.load(file);
        
        try {
            PDFTextStripper stripper = new PDFTextStripper();
            
            // 设置起始页和结束页
            stripper.setStartPage(pageNumber);
            stripper.setEndPage(pageNumber);
            
            return stripper.getText(document);
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
}

4.2 使用iText解析PDF

import com.itextpdf.text.pdf.PdfReader;
import com.itextpdf.text.pdf.parser.PdfTextExtractor;
import com.itextpdf.text.pdf.parser.SimpleTextExtractionStrategy;
import com.itextpdf.text.pdf.parser.TextExtractionStrategy;

import java.io.IOException;

@Service
public class ITextPdfReaderService {

    public String extractTextFromPdf(String pdfPath) throws IOException {
        PdfReader reader = new PdfReader(pdfPath);
        StringBuilder textBuilder = new StringBuilder();
        
        try {
            int pages = reader.getNumberOfPages();
            
            // 遍历所有页面
            for (int i = 1; i <= pages; i++) {
                TextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
                String pageText = PdfTextExtractor.getTextFromPage(reader, i, strategy);
                textBuilder.append(pageText).append("\n");
            }
            
            return textBuilder.toString();
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
    
    // 获取PDF元数据
    public Map<String, String> getPdfMetadata(String pdfPath) throws IOException {
        PdfReader reader = new PdfReader(pdfPath);
        Map<String, String> metadata = new HashMap<>();
        
        try {
            metadata.put("Title", reader.getInfo().get("Title"));
            metadata.put("Author", reader.getInfo().get("Author"));
            metadata.put("Subject", reader.getInfo().get("Subject"));
            metadata.put("Keywords", reader.getInfo().get("Keywords"));
            metadata.put("Creator", reader.getInfo().get("Creator"));
            metadata.put("Producer", reader.getInfo().get("Producer"));
            metadata.put("Creation Date", reader.getInfo().get("CreationDate"));
            metadata.put("Modification Date", reader.getInfo().get("ModDate"));
            metadata.put("Page Count", String.valueOf(reader.getNumberOfPages()));
            
            return metadata;
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
}

4.3 从PDF中提取表格数据

提取PDF中的表格是一个复杂任务，可以使用如Tabula-Java等专门库：

<dependency>
    <groupId>technology.tabula</groupId>
    <artifactId>tabula</artifactId>
    <version>1.0.5</version>
</dependency>

import technology.tabula.ObjectExtractor;
import technology.tabula.Page;
import technology.tabula.PageIterator;
import technology.tabula.Rectangle;
import technology.tabula.Table;
import technology.tabula.extractors.SpreadsheetExtractionAlgorithm;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@Service
public class PdfTableExtractorService {

    public List<String[][]> extractTablesFromPdf(String pdfPath) throws IOException {
        // 打开PDF文件
        PDDocument document = PDDocument.load(new File(pdfPath));
        
        List<String[][]> allTables = new ArrayList<>();
        
        try {
            // 创建ObjectExtractor
            ObjectExtractor extractor = new ObjectExtractor(document);
            
            // 提取所有页面
            PageIterator iterator = extractor.extract();
            
            // 表格提取算法
            SpreadsheetExtractionAlgorithm sea = new SpreadsheetExtractionAlgorithm();
            
            // 处理每一页
            while (iterator.hasNext()) {
                Page page = iterator.next();
                
                // 提取表格
                List<Table> tables = sea.extract(page);
                
                // 处理每个表格
                for (Table table : tables) {
                    int rowCount = table.getRowCount();
                    int colCount = table.getColCount();
                    
                    String[][] tableData = new String[rowCount][colCount];
                    
                    // 提取单元格数据
                    for (int i = 0; i < rowCount; i++) {
                        for (int j = 0; j < colCount; j++) {
                            if (j < table.getRows().get(i).size()) {
                                tableData[i][j] = table.getRows().get(i).get(j).getText();
                            } else {
                                tableData[i][j] = "";
                            }
                        }
                    }
                    
                    allTables.add(tableData);
                }
            }
        } finally {
            if (document != null) {
                document.close();
            }
        }
        
        return allTables;
    }
    
    // 打印表格数据(用于测试)
    public void printTableData(String[][] tableData) {
        for (String[] row : tableData) {
            for (String cell : row) {
                System.out.print(cell + " | ");
            }
            System.out.println();
        }
    }
} 

5. 修改现有PDF文件

修改现有PDF文件是常见需求，包括添加新内容、修改文本、删除页面、合并文档等操作。

5.1 添加水印和页码

使用iText添加水印

import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Document;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfContentByte;
import com.itextpdf.text.pdf.PdfGState;
import com.itextpdf.text.pdf.PdfReader;
import com.itextpdf.text.pdf.PdfStamper;

import java.io.FileOutputStream;
import java.io.IOException;

@Service
public class PdfWatermarkService {

    public void addWatermark(String inputPath, String outputPath, String watermarkText) 
            throws IOException, DocumentException {
        // 打开现有PDF
        PdfReader reader = new PdfReader(inputPath);
        PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(outputPath));
        
        // 创建基本字体
        BaseFont baseFont = BaseFont.createFont("STSong-Light", "UniGB-UCS2-H", BaseFont.NOT_EMBEDDED);
        Font font = new Font(baseFont, 30, Font.BOLD, BaseColor.GRAY);
        
        // 获取PDF页数
        int pageCount = reader.getNumberOfPages();
        
        // 对每页添加水印
        for (int i = 1; i <= pageCount; i++) {
            // 获取页面尺寸
            Rectangle pageRect = reader.getPageSize(i);
            float width = pageRect.getWidth();
            float height = pageRect.getHeight();
            
            // 获取内容字节层(在内容下方)
            PdfContentByte under = stamper.getUnderContent(i);
            
            // 设置透明度
            PdfGState gs = new PdfGState();
            gs.setFillOpacity(0.3f);
            under.setGState(gs);
            
            // 保存图形状态
            under.saveState();
            
            // 设置字体和颜色
            under.setFontAndSize(baseFont, 30);
            under.setColorFill(BaseColor.GRAY);
            
            // 添加水印文本(旋转45度)
            under.beginText();
            // 文本旋转和位置
            under.showTextAligned(Element.ALIGN_CENTER, watermarkText, 
                                 width / 2, height / 2, 45);
            under.endText();
            
            // 恢复图形状态
            under.restoreState();
        }
        
        // 关闭资源
        stamper.close();
        reader.close();
        
        System.out.println("水印已添加: " + outputPath);
    }
}

使用PDFBox添加页码

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.PDPageContentStream.AppendMode;
import org.apache.pdfbox.pdmodel.font.PDType1Font;

import java.io.IOException;

@Service
public class PdfPageNumberService {

    public void addPageNumbers(String inputPath, String outputPath) throws IOException {
        // 打开PDF文档
        PDDocument document = PDDocument.load(new File(inputPath));
        
        try {
            // 获取页数
            int pageCount = document.getNumberOfPages();
            
            // 为每一页添加页码
            for (int i = 0; i < pageCount; i++) {
                PDPage page = document.getPage(i);
                
                // 创建内容流以追加内容(AppendMode.APPEND表示添加到现有内容后)
                PDPageContentStream contentStream = new PDPageContentStream(
                        document, page, AppendMode.APPEND, true, true);
                
                // 获取页面尺寸
                float pageWidth = page.getMediaBox().getWidth();
                float pageHeight = page.getMediaBox().getHeight();
                
                // 设置页码文本
                String pageNumberText = "第 " + (i + 1) + " 页，共 " + pageCount + " 页";
                
                // 使用PDFBox内置字体(注意中文需要使用支持中文的字体)
                contentStream.setFont(PDType1Font.HELVETICA, 10);
                
                // 添加文本(居中于页面底部)
                contentStream.beginText();
                // 计算文本宽度以居中
                float textWidth = PDType1Font.HELVETICA.getStringWidth(pageNumberText) / 1000 * 10;
                float xPosition = (pageWidth - textWidth) / 2;
                
                contentStream.newLineAtOffset(xPosition, 20); // 距底部20点
                contentStream.showText(pageNumberText);
                contentStream.endText();
                
                // 关闭内容流
                contentStream.close();
            }
            
            // 保存修改后的文档
            document.save(outputPath);
            
        } finally {
            if (document != null) {
                document.close();
            }
        }
        
        System.out.println("已添加页码: " + outputPath);
    }
}

5.2 合并多个PDF文件

使用PDFBox合并PDF

import org.apache.pdfbox.multipdf.PDFMergerUtility;
import org.apache.pdfbox.pdmodel.PDDocument;

import java.io.File;
import java.io.IOException;
import java.util.List;

@Service
public class PdfMergeService {

    public void mergePdfFiles(List<String> inputPaths, String outputPath) throws IOException {
        // 创建PDF合并工具
        PDFMergerUtility merger = new PDFMergerUtility();
        
        // 设置目标文件
        merger.setDestinationFileName(outputPath);
        
        // 添加源文件
        for (String path : inputPaths) {
            File file = new File(path);
            merger.addSource(file);
        }
        
        // 执行合并
        merger.mergeDocuments(null);
        
        System.out.println("PDF合并完成: " + outputPath);
    }
    
    // 指定页面范围合并
    public void mergeWithPageRanges(String outputPath) throws IOException {
        // 创建空文档接收合并结果
        PDDocument mergedDocument = new PDDocument();
        
        try {
            // 打开第一个PDF
            PDDocument doc1 = PDDocument.load(new File("pdf1.pdf"));
            // 仅添加第1页和第3页
            mergedDocument.addPage(doc1.getPage(0)); // 0表示第1页
            mergedDocument.addPage(doc1.getPage(2)); // 2表示第3页
            doc1.close();
            
            // 打开第二个PDF
            PDDocument doc2 = PDDocument.load(new File("pdf2.pdf"));
            // 添加所有页面
            for (int i = 0; i < doc2.getNumberOfPages(); i++) {
                mergedDocument.addPage(doc2.getPage(i));
            }
            doc2.close();
            
            // 打开第三个PDF
            PDDocument doc3 = PDDocument.load(new File("pdf3.pdf"));
            // 只添加最后一页
            mergedDocument.addPage(doc3.getPage(doc3.getNumberOfPages() - 1));
            doc3.close();
            
            // 保存合并后的文档
            mergedDocument.save(outputPath);
            
        } finally {
            if (mergedDocument != null) {
                mergedDocument.close();
            }
        }
        
        System.out.println("选择性页面合并完成: " + outputPath);
    }
}

使用iText合并PDF

import com.itextpdf.text.Document;
import com.itextpdf.text.pdf.PdfCopy;
import com.itextpdf.text.pdf.PdfImportedPage;
import com.itextpdf.text.pdf.PdfReader;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;

@Service
public class ITextPdfMergeService {

    public void mergePdfFiles(List<String> inputPaths, String outputPath) 
            throws IOException, DocumentException {
        // 创建一个文档对象
        Document document = new Document();
        
        // 创建PdfCopy实例
        PdfCopy copy = new PdfCopy(document, new FileOutputStream(outputPath));
        
        // 打开文档
        document.open();
        
        try {
            // 遍历每个输入PDF
            for (String path : inputPaths) {
                // 创建PdfReader实例
                PdfReader reader = new PdfReader(path);
                
                // 获取页数
                int pageCount = reader.getNumberOfPages();
                
                // 复制每一页
                for (int i = 1; i <= pageCount; i++) {
                    PdfImportedPage page = copy.getImportedPage(reader, i);
                    copy.addPage(page);
                }
                
                // 关闭reader
                reader.close();
            }
        } finally {
            // 关闭document
            if (document.isOpen()) {
                document.close();
            }
        }
        
        System.out.println("iText PDF合并完成: " + outputPath);
    }
}

5.3 分割PDF文件

import org.apache.pdfbox.multipdf.Splitter;
import org.apache.pdfbox.pdmodel.PDDocument;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

@Service
public class PdfSplitService {

    // 将PDF拆分为单页文件
    public void splitPdfToSinglePages(String inputPath, String outputFolder) throws IOException {
        // 加载PDF
        PDDocument document = PDDocument.load(new File(inputPath));
        
        try {
            // 创建分割器
            Splitter splitter = new Splitter();
            
            // 执行分割(每个文档一页)
            List<PDDocument> pages = splitter.split(document);
            
            // 获取输入文件名(不带扩展名)
            String fileNameWithoutExt = new File(inputPath).getName();
            if (fileNameWithoutExt.contains(".")) {
                fileNameWithoutExt = fileNameWithoutExt.substring(0, 
                                    fileNameWithoutExt.lastIndexOf('.'));
            }
            
            // 创建输出目录(如果不存在)
            File outputDir = new File(outputFolder);
            if (!outputDir.exists()) {
                outputDir.mkdirs();
            }
            
            // 保存每一页为单独文件
            Iterator<PDDocument> iterator = pages.iterator();
            int pageNumber = 1;
            
            while (iterator.hasNext()) {
                PDDocument pd = iterator.next();
                String outputPath = outputFolder + File.separator 
                                   + fileNameWithoutExt + "_page_" + pageNumber + ".pdf";
                pd.save(outputPath);
                pd.close();
                pageNumber++;
            }
            
            System.out.println("PDF分割完成，共 " + (pageNumber - 1) + " 页已保存到: " + outputFolder);
            
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
    
    // 将PDF按页范围拆分
    public void splitPdfByPageRange(String inputPath, String outputPath, int startPage, int endPage) 
            throws IOException {
        // 加载PDF
        PDDocument document = PDDocument.load(new File(inputPath));
        
        try {
            // 验证页面范围
            int totalPages = document.getNumberOfPages();
            if (startPage < 1 || endPage > totalPages || startPage > endPage) {
                throw new IllegalArgumentException("无效的页面范围: " + startPage + "-" + endPage 
                                                  + "，文档共有 " + totalPages + " 页");
            }
            
            // 创建新文档
            PDDocument newDocument = new PDDocument();
            
            // 复制指定页面
            for (int i = startPage; i <= endPage; i++) {
                // 注意PDFBox页码从0开始
                newDocument.addPage(document.getPage(i - 1));
            }
            
            // 保存新文档
            newDocument.save(outputPath);
            newDocument.close();
            
            System.out.println("已提取页面 " + startPage + " 到 " + endPage + " 并保存到: " + outputPath);
            
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
}

5.4 加密与解密PDF

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.encryption.AccessPermission;
import org.apache.pdfbox.pdmodel.encryption.StandardProtectionPolicy;

import java.io.File;
import java.io.IOException;

@Service
public class PdfEncryptionService {

    // 加密PDF文件
    public void encryptPdf(String inputPath, String outputPath, 
                         String userPassword, String ownerPassword) throws IOException {
        // 加载PDF
        PDDocument document = PDDocument.load(new File(inputPath));
        
        try {
            // 设置访问权限
            AccessPermission accessPermission = new AccessPermission();
            
            // 禁止打印
            accessPermission.setCanPrint(false);
            
            // 禁止修改内容
            accessPermission.setCanModify(false);
            
            // 禁止复制内容
            accessPermission.setCanExtractContent(false);
            
            // 禁止添加或修改注释
            accessPermission.setCanModifyAnnotations(false);
            
            // 创建保护策略(用户密码、所有者密码、密钥长度)
            StandardProtectionPolicy policy = new StandardProtectionPolicy(
                    ownerPassword, userPassword, accessPermission);
            
            // 设置加密密钥长度(128位)
            policy.setEncryptionKeyLength(128);
            
            // 应用加密
            document.protect(policy);
            
            // 保存加密后的文档
            document.save(outputPath);
            
            System.out.println("PDF加密完成: " + outputPath);
            
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
    
    // 解密PDF文件(需要提供密码)
    public void decryptPdf(String inputPath, String outputPath, String password) throws IOException {
        // 加载加密的PDF(提供密码)
        PDDocument document = PDDocument.load(new File(inputPath), password);
        
        try {
            // 检查文档是否加密
            if (document.isEncrypted()) {
                // 移除加密
                document.setAllSecurityToBeRemoved(true);
                
                // 保存解密后的文档
                document.save(outputPath);
                
                System.out.println("PDF解密完成: " + outputPath);
            } else {
                System.out.println("PDF未加密，无需解密");
                // 可以选择直接复制文件
                document.save(outputPath);
            }
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
}

5.5 删除和重新排序页面

import org.apache.pdfbox.pdmodel.PDDocument;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

@Service
public class PdfPageManipulationService {

    // 删除指定页面
    public void removePages(String inputPath, String outputPath, List<Integer> pagesToRemove) 
            throws IOException {
        // 加载PDF
        PDDocument document = PDDocument.load(new File(inputPath));
        
        try {
            // 按降序排列要删除的页码(从后往前删除避免索引变化)
            Collections.sort(pagesToRemove, Collections.reverseOrder());
            
            // 删除指定页面
            for (int pageNum : pagesToRemove) {
                // 验证页码是否有效
                if (pageNum >= 1 && pageNum <= document.getNumberOfPages()) {
                    // PDFBox页码从0开始
                    document.removePage(pageNum - 1);
                } else {
                    System.out.println("警告：页码 " + pageNum + " 超出范围，已忽略");
                }
            }
            
            // 保存修改后的文档
            document.save(outputPath);
            
            System.out.println("页面删除完成，保存到: " + outputPath);
            
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
    
    // 重新排序页面
    public void reorderPages(String inputPath, String outputPath, int[] newOrder) throws IOException {
        // 加载PDF
        PDDocument document = PDDocument.load(new File(inputPath));
        
        try {
            // 获取原始页数
            int pageCount = document.getNumberOfPages();
            
            // 验证新顺序数组长度
            if (newOrder.length != pageCount) {
                throw new IllegalArgumentException(
                    "新顺序数组长度(" + newOrder.length + ")与页数(" + pageCount + ")不匹配");
            }
            
            // 创建临时文档
            PDDocument newDocument = new PDDocument();
            
            // 按新顺序添加页面
            for (int i = 0; i < newOrder.length; i++) {
                // 确保索引从1开始转为0开始
                int oldIndex = newOrder[i] - 1;
                
                // 验证索引有效性
                if (oldIndex < 0 || oldIndex >= pageCount) {
                    throw new IllegalArgumentException("新顺序中包含无效页码: " + (oldIndex + 1));
                }
                
                // 导入页面
                newDocument.addPage(document.getPage(oldIndex));
            }
            
            // 保存新文档
            newDocument.save(outputPath);
            newDocument.close();
            
            System.out.println("页面重新排序完成，保存到: " + outputPath);
            
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
}

5.6 填充PDF表单

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
import org.apache.pdfbox.pdmodel.interactive.form.PDField;

import java.io.File;
import java.io.IOException;
import java.util.Map;

@Service
public class PdfFormFillingService {

    // 填充PDF表单
    public void fillPdfForm(String templatePath, String outputPath, 
                           Map<String, String> formData) throws IOException {
        // 加载PDF模板
        PDDocument document = PDDocument.load(new File(templatePath));
        
        try {
            // 获取表单
            PDAcroForm acroForm = document.getDocumentCatalog().getAcroForm();
            
            if (acroForm != null) {
                // 遍历表单字段并填充数据
                for (Map.Entry<String, String> entry : formData.entrySet()) {
                    String fieldName = entry.getKey();
                    String fieldValue = entry.getValue();
                    
                    // 查找表单字段
                    PDField field = acroForm.getField(fieldName);
                    
                    if (field != null) {
                        // 设置字段值
                        field.setValue(fieldValue);
                    } else {
                        System.out.println("警告：找不到表单字段 '" + fieldName + "'");
                    }
                }
                
                // 设置表单为不可编辑(可选)
                acroForm.setNeedAppearances(true);
                
                // 保存填充后的表单
                document.save(outputPath);
                
                System.out.println("PDF表单填充完成，保存到: " + outputPath);
            } else {
                System.out.println("错误：PDF文档不包含表单");
            }
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
    
    // 列出PDF文档中的所有表单字段(用于调试)
    public void listFormFields(String pdfPath) throws IOException {
        // 加载PDF
        PDDocument document = PDDocument.load(new File(pdfPath));
        
        try {
            // 获取表单
            PDAcroForm acroForm = document.getDocumentCatalog().getAcroForm();
            
            if (acroForm != null) {
                // 获取所有字段
                List<PDField> fields = acroForm.getFields();
                
                System.out.println("PDF文档包含 " + fields.size() + " 个表单字段:");
                
                // 打印字段名称和类型
                for (PDField field : fields) {
                    System.out.println("字段名称: " + field.getFullyQualifiedName() + 
                                      ", 类型: " + field.getClass().getSimpleName());
                }
            } else {
                System.out.println("PDF文档不包含表单");
            }
        } finally {
            if (document != null) {
                document.close();
            }
        }
    }
} 

6. Web应用中的PDF处理

在SpringBoot Web应用中，PDF处理是一个常见需求，包括PDF的生成与下载、在线预览、上传与解析等功能。本节将介绍如何在SpringBoot应用中实现这些功能。

6.1 PDF下载功能实现

在Web应用中，通常需要提供PDF下载功能，如报表下载、证书下载等。下面是一个基本的PDF下载控制器实现：

@RestController
@RequestMapping("/api/pdf")
public class PdfDownloadController {

    private final PdfGenerationService pdfService;
    
    @Autowired
    public PdfDownloadController(PdfGenerationService pdfService) {
        this.pdfService = pdfService;
    }
    
    /**
     * 生成并下载简单PDF
     */
    @GetMapping("/download/simple")
    public ResponseEntity<byte[]> downloadSimplePdf() {
        try {
            byte[] pdfBytes = pdfService.generateSimplePdf();
            
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_PDF);
            headers.setContentDispositionFormData("attachment", "document.pdf");
            headers.setCacheControl("must-revalidate, post-check=0, pre-check=0");
            
            return new ResponseEntity<>(pdfBytes, headers, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    /**
     * 根据ID生成并下载报表
     */
    @GetMapping("/download/report/{id}")
    public ResponseEntity<byte[]> downloadReportById(@PathVariable("id") Long id) {
        try {
            byte[] pdfBytes = pdfService.generateReportPdf(id);
            if (pdfBytes == null) {
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            }
            
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_PDF);
            headers.setContentDispositionFormData("attachment", "report-" + id + ".pdf");
            headers.setCacheControl("must-revalidate, post-check=0, pre-check=0");
            
            return new ResponseEntity<>(pdfBytes, headers, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

以下是使用模板生成证书并下载的示例：

@Controller
@RequestMapping("/api/pdf/templates")
public class PdfTemplateController {

    private final PdfTemplateService templateService;
    
    @Autowired
    public PdfTemplateController(PdfTemplateService templateService) {
        this.templateService = templateService;
    }
    
    /**
     * 生成证书并下载
     */
    @GetMapping("/certificate/{userId}")
    public ResponseEntity<byte[]> generateCertificate(@PathVariable Long userId) {
        try {
            // 获取用户信息
            UserDto user = userService.findById(userId);
            if (user == null) {
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            }
            
            // 生成证书
            byte[] certificateBytes = templateService.generateCertificateFromTemplate(user);
            
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_PDF);
            headers.setContentDispositionFormData("attachment", 
                    "certificate-" + user.getUsername() + ".pdf");
            
            return new ResponseEntity<>(certificateBytes, headers, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

6.2 在线PDF预览实现

为了提供更好的用户体验，有时需要在浏览器中直接预览PDF，而不是下载到本地。下面是一个实现在线PDF预览的控制器：

@Controller
@RequestMapping("/pdf/view")
public class PdfViewController {

    private final DocumentService documentService;
    
    @Autowired
    public PdfViewController(DocumentService documentService) {
        this.documentService = documentService;
    }
    
    /**
     * 返回PDF预览页面
     */
    @GetMapping("/{documentId}")
    public String viewPdf(@PathVariable Long documentId, Model model) {
        // 检查文档是否存在
        if (!documentService.exists(documentId)) {
            return "error/404";
        }
        
        model.addAttribute("documentId", documentId);
        model.addAttribute("documentName", documentService.getName(documentId));
        return "pdf/viewer";  // 返回Thymeleaf模板
    }
    
    /**
     * 提供PDF数据的端点
     */
    @GetMapping("/data/{documentId}")
    @ResponseBody
    public ResponseEntity<byte[]> getPdfData(@PathVariable Long documentId) {
        try {
            byte[] pdfData = documentService.getPdfContent(documentId);
            if (pdfData == null) {
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            }
            
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_PDF);
            // 使用inline而不是attachment，这样浏览器会直接显示PDF而不是下载
            headers.add("Content-Disposition", "inline; filename=document-" + documentId + ".pdf");
            
            return new ResponseEntity<>(pdfData, headers, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

Thymeleaf模板（viewer.html）示例：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title th:text="${documentName} + ' - PDF预览'"></title>
    <meta charset="UTF-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.11.338/pdf.min.js"></script>
    <style>
        body { margin: 0; padding: 0; }
        #pdf-container { width: 100%; height: 100vh; overflow: auto; }
        #pdf-viewer { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="pdf-container">
        <iframe id="pdf-viewer" th:src="@{'/pdf/view/data/' + ${documentId}}" frameborder="0"></iframe>
    </div>
</body>
</html>

6.3 PDF文件上传和处理

在许多应用中，需要允许用户上传PDF文件并进行处理。以下是一个处理PDF上传的控制器示例：

@RestController
@RequestMapping("/api/pdf/upload")
public class PdfUploadController {

    private final PdfAnalysisService pdfAnalysisService;
    
    @Autowired
    public PdfUploadController(PdfAnalysisService pdfAnalysisService) {
        this.pdfAnalysisService = pdfAnalysisService;
    }
    
    /**
     * 处理PDF上传并分析内容
     */
    @PostMapping("/analyze")
    public ResponseEntity<?> uploadAndAnalyzePdf(@RequestParam("file") MultipartFile file) {
        // 检查文件是否为空
        if (file.isEmpty()) {
            return ResponseEntity.badRequest().body("请选择要上传的PDF文件");
        }
        
        // 检查文件类型
        if (!file.getContentType().equals("application/pdf")) {
            return ResponseEntity.badRequest().body("只支持PDF文件上传");
        }
        
        try {
            // 读取文件内容
            byte[] pdfBytes = file.getBytes();
            
            // 分析PDF内容
            PdfAnalysisResult result = pdfAnalysisService.analyzePdf(pdfBytes);
            
            return ResponseEntity.ok(result);
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("PDF处理失败: " + e.getMessage());
        }
    }
    
    /**
     * 上传并保存PDF文件
     */
    @PostMapping("/save")
    public ResponseEntity<?> uploadAndSavePdf(
            @RequestParam("file") MultipartFile file,
            @RequestParam("title") String title,
            @RequestParam("description") String description) {
        
        if (file.isEmpty()) {
            return ResponseEntity.badRequest().body("请选择要上传的PDF文件");
        }
        
        try {
            // 保存PDF文件并获取文档ID
            Long documentId = pdfAnalysisService.savePdfDocument(
                    file.getBytes(), 
                    file.getOriginalFilename(), 
                    title, 
                    description);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("documentId", documentId);
            response.put("message", "PDF文件上传成功");
            
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("PDF上传失败: " + e.getMessage());
        }
    }
}

6.4 批量PDF处理

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

@RestController
@RequestMapping("/api/pdf/batch")
public class PdfBatchController {

    @Autowired
    private PdfBatchService pdfBatchService;
    
    // 临时目录用于保存上传的文件
    private final Path tempDir = Paths.get(System.getProperty("java.io.tmpdir"));
    
    @PostMapping("/merge")
    public ResponseEntity<?> mergePdfs(@RequestParam("files") MultipartFile[] files) {
        
        Map<String, Object> response = new HashMap<>();
        List<String> tempFilePaths = new ArrayList<>();
        
        try {
            // 检查文件
            if (files.length < 2) {
                response.put("success", false);
                response.put("message", "请至少提供两个PDF文件进行合并");
                return ResponseEntity.badRequest().body(response);
            }
            
            // 保存上传的文件到临时目录
            for (MultipartFile file : files) {
                // 验证文件类型
                if (!file.getContentType().equals("application/pdf")) {
                    response.put("success", false);
                    response.put("message", "文件 " + file.getOriginalFilename() + " 不是PDF格式");
                    return ResponseEntity.badRequest().body(response);
                }
                
                // 创建唯一文件名
                String tempFileName = UUID.randomUUID().toString() + ".pdf";
                Path tempFile = tempDir.resolve(tempFileName);
                
                // 保存文件
                Files.copy(file.getInputStream(), tempFile);
                tempFilePaths.add(tempFile.toString());
            }
            
            // 生成合并后的PDF文件名
            String outputFileName = "merged_" + UUID.randomUUID().toString() + ".pdf";
            Path outputPath = tempDir.resolve(outputFileName);
            
            // 执行合并
            pdfBatchService.mergePdfFiles(tempFilePaths, outputPath.toString());
            
            // 读取合并后的文件
            byte[] mergedPdfBytes = Files.readAllBytes(outputPath);
            
            // 清理临时文件
            for (String path : tempFilePaths) {
                Files.deleteIfExists(Paths.get(path));
            }
            Files.deleteIfExists(outputPath);
            
            // 设置响应
            response.put("success", true);
            response.put("message", "PDF文件已成功合并");
            response.put("mergedFileSize", mergedPdfBytes.length);
            
            // 可以返回合并后的文件作为Base64字符串(适用于小文件)
            response.put("mergedPdfBase64", 
                    java.util.Base64.getEncoder().encodeToString(mergedPdfBytes));
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            // 清理临时文件
            for (String path : tempFilePaths) {
                try {
                    Files.deleteIfExists(Paths.get(path));
                } catch (IOException ex) {
                    // 忽略清理错误
                }
            }
            
            response.put("success", false);
            response.put("message", "合并PDF时出错: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
}

批量处理服务：

import org.apache.pdfbox.multipdf.PDFMergerUtility;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

@Service
public class PdfBatchService {

    // 用于异步处理的线程池
    private final ExecutorService executor = Executors.newFixedThreadPool(5);
    
    // 合并PDF文件
    public void mergePdfFiles(List<String> inputPaths, String outputPath) throws IOException {
        PDFMergerUtility merger = new PDFMergerUtility();
        merger.setDestinationFileName(outputPath);
        
        for (String path : inputPaths) {
            merger.addSource(new File(path));
        }
        
        merger.mergeDocuments(null);
    }
    
    // 异步处理多个PDF
    public CompletableFuture<List<String>> processMultiplePdfsAsync(
            List<String> inputPaths, String outputDir, String operation) {
        
        // 创建CompletableFuture列表
        List<CompletableFuture<String>> futures = inputPaths.stream()
            .map(path -> CompletableFuture.supplyAsync(() -> {
                try {
                    // 根据操作类型处理PDF
                    String outputPath = outputDir + File.separator 
                                      + new File(path).getName().replace(".pdf", "_processed.pdf");
                    
                    switch (operation) {
                        case "watermark":
                            addWatermark(path, outputPath, "机密文档");
                            break;
                        case "compress":
                            compressPdf(path, outputPath);
                            break;
                        case "encrypt":
                            encryptPdf(path, outputPath, "password123", "owner456");
                            break;
                        // 添加其他操作...
                        default:
                            throw new IllegalArgumentException("不支持的操作: " + operation);
                    }
                    
                    return outputPath;
                } catch (Exception e) {
                    throw new RuntimeException("处理文件失败: " + path, e);
                }
            }, executor))
            .collect(Collectors.toList());
        
        // 组合所有Future
        CompletableFuture<Void> allOf = CompletableFuture.allOf(
                futures.toArray(new CompletableFuture[0]));
        
        // 处理完成后收集结果
        return allOf.thenApply(v ->
            futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList())
        );
    }
    
    // 添加水印方法
    private void addWatermark(String inputPath, String outputPath, String watermarkText) 
            throws IOException {
        // 实现与PdfWatermarkService类似
        // ...
    }
    
    // 压缩PDF方法
    private void compressPdf(String inputPath, String outputPath) throws IOException {
        // 实现PDF压缩
        // ...
    }
    
    // 加密PDF方法
    private void encryptPdf(String inputPath, String outputPath, 
                          String userPassword, String ownerPassword) throws IOException {
        // 实现与PdfEncryptionService类似
        // ...
    }
}

7. PDF安全性与高级功能

在处理PDF文档时，安全性是一个重要的考虑因素，尤其是在处理敏感信息时。同时，高级功能如水印、数字签名等可以为PDF文档添加更多实用功能。

7.1 PDF文档加密与权限控制

使用iText可以很容易地对PDF文档进行加密和设置权限：

@Service
public class PdfSecurityService {

    /**
     * 创建带密码保护的PDF
     */
    public byte[] createEncryptedPdf(String content, String userPassword, String ownerPassword) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
        PdfWriter writer = new PdfWriter(baos);
        PdfDocument pdf = new PdfDocument(writer);
        
        // 设置PDF文档的加密选项
        WriterProperties writerProperties = new WriterProperties();
        
        // 设置用户密码(打开文档需要)和所有者密码(修改权限需要)
        writerProperties.setStandardEncryption(
                userPassword.getBytes(),
                ownerPassword.getBytes(),
                EncryptionConstants.ALLOW_PRINTING, // 允许打印
                EncryptionConstants.ENCRYPTION_AES_128 // 使用AES 128位加密
        );
        
        writer.setWriterProperties(writerProperties);
        
        // 创建文档内容
        Document document = new Document(pdf);
        document.add(new Paragraph(content));
        document.close();
        
        return baos.toByteArray();
    }
    
    /**
     * 创建带权限控制的PDF
     */
    public byte[] createPermissionControlledPdf(String content, String ownerPassword, int permissions) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
        WriterProperties writerProperties = new WriterProperties();
        writerProperties.setStandardEncryption(
                null, // 无用户密码
                ownerPassword.getBytes(),
                permissions, // 自定义权限
                EncryptionConstants.ENCRYPTION_AES_256 // 使用AES 256位加密
        );
        
        PdfWriter writer = new PdfWriter(baos, writerProperties);
        PdfDocument pdf = new PdfDocument(writer);
        Document document = new Document(pdf);
        document.add(new Paragraph(content));
        document.close();
        
        return baos.toByteArray();
    }
    
    /**
     * 检查PDF是否加密
     */
    public boolean isPdfEncrypted(byte[] pdfData) throws IOException {
        PdfReader reader = new PdfReader(new ByteArrayInputStream(pdfData));
        PdfDocument pdf = new PdfDocument(reader);
        boolean isEncrypted = pdf.isEncrypted();
        pdf.close();
        return isEncrypted;
    }
}

7.2 添加水印

水印是一种常见的PDF高级功能，可以用来保护文档版权或标记文档状态：

@Service
public class PdfWatermarkService {

    /**
     * 添加文本水印
     */
    public byte[] addTextWatermark(byte[] originalPdf, String watermarkText) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
        PdfReader reader = new PdfReader(new ByteArrayInputStream(originalPdf));
        PdfWriter writer = new PdfWriter(baos);
        PdfDocument pdf = new PdfDocument(reader, writer);
        
        // 获取页数
        int numberOfPages = pdf.getNumberOfPages();
        
        // 创建透明的水印文本
        PdfFont font = PdfFontFactory.createFont(StandardFonts.HELVETICA);
        Paragraph watermark = new Paragraph(watermarkText)
                .setFont(font)
                .setFontSize(30)
                .setFontColor(new DeviceRgb(0.5f, 0.5f, 0.5f), 0.3f); // 灰色，30%不透明度
        
        // 在每一页添加水印
        for (int i = 1; i <= numberOfPages; i++) {
            PdfPage page = pdf.getPage(i);
            Rectangle pageSize = page.getPageSize();
            float x = (pageSize.getLeft() + pageSize.getRight()) / 2;
            float y = (pageSize.getBottom() + pageSize.getTop()) / 2;
            
            // 创建一个新的Canvas用于绘制水印
            PdfCanvas canvas = new PdfCanvas(page);
            canvas.saveState();
            
            // 应用旋转变换
            canvas.setFillColor(new DeviceRgb(0.5f, 0.5f, 0.5f));
            canvas.setExtGState(new PdfExtGState().setFillOpacity(0.3f));
            
            // 使用Canvas绘制文本
            Canvas watermarkCanvas = new Canvas(canvas, pdf, page.getPageSize());
            watermarkCanvas.showTextAligned(watermark, x, y, i, TextAlignment.CENTER, VerticalAlignment.MIDDLE, (float) Math.PI / 6);
            
            canvas.restoreState();
        }
        
        pdf.close();
        return baos.toByteArray();
    }
    
    /**
     * 添加图片水印
     */
    public byte[] addImageWatermark(byte[] originalPdf, byte[] imageData) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
        PdfReader reader = new PdfReader(new ByteArrayInputStream(originalPdf));
        PdfWriter writer = new PdfWriter(baos);
        PdfDocument pdf = new PdfDocument(reader, writer);
        
        // 转换图片数据为ImageData
        ImageData imageDataObj = ImageDataFactory.create(imageData);
        Image image = new Image(imageDataObj);
        
        // 设置图片大小和不透明度
        image.scaleAbsolute(100, 100);
        image.setOpacity(0.3f);
        
        // 在每一页添加水印
        int numberOfPages = pdf.getNumberOfPages();
        for (int i = 1; i <= numberOfPages; i++) {
            PdfPage page = pdf.getPage(i);
            Rectangle pageSize = page.getPageSize();
            
            // 计算图片位置(居中)
            float x = (pageSize.getLeft() + pageSize.getRight()) / 2 - image.getImageScaledWidth() / 2;
            float y = (pageSize.getBottom() + pageSize.getTop()) / 2 - image.getImageScaledHeight() / 2;
            
            // 创建Canvas并添加图片
            PdfCanvas canvas = new PdfCanvas(page);
            canvas.addImage(imageDataObj, x, y, false);
        }
        
        pdf.close();
        return baos.toByteArray();
    }
}