10 0 obj
<<
  /Type /Catalog
  /Pages 20 0 obj
  /ViewerPreferences <<
    /DisplayDocTitle true
  >>
  /OpenAction [30 0 R /Fit]
>>
endobj

PDF存储结构详解

PDF文件采用线性结构存储，包含四个主要部分：

1. 文件头（File Header）

位于文件开头，用于标识PDF文件版本。标准格式：

%PDF-2.0
%âãÏÓ

其中：

• %PDF-2.0 - 版本标识（可选含次版本号如%PDF-2.0.1）
• %âãÏÓ - 二进制注释，确保文件以二进制模式处理
• 文件头建议包含注释以提高兼容性

2. 文档主体（Document Body）

包含所有PDF对象，每个对象都有唯一的对象编号和生成号：

1 0 obj
<<
  /Type /Page
  /Parent 2 0 R
  /MediaBox [0 0 612 792]
  /Contents 3 0 R
  /Resources 4 0 R
>>
endobj

• 对象编号 - 文档内的唯一标识符（从1开始）
• 生成号 - 用于跟踪对象的修订版本（0表示原始版本）
• obj/endobj - 标记对象的开始和结束
• 间接引用 - 格式为"N 0 R"，用于跨对象引用

3. 交叉引用表（Cross-Reference Table）

记录所有对象的字节偏移量，实现快速随机访问：

xref
0 5
0000000000 65535 f 
0000000009 00000 n 
0000000074 00000 n 
0000000179 00000 n 
0000000306 00000 n 
trailer

• xref - 交叉引用表开始标记
• 起始对象号 - 表中第一个对象的编号
• 对象数量 - 表中包含的对象总数
• 每行格式 - "偏移量 生成号 状态"（n=活动，f=空闲）
• 支持增量更新，无需重写整个文件
• PDF 1.5+支持压缩的交叉引用流，减少文件大小

4. 文件尾（File Trailer）

包含定位交叉引用表和根对象的信息：

<<
  /Size 5
  /Root 1 0 R
  /Info 2 0 R
  /ID [<8f8a4d...> <8f8a4d...>]
>>
startxref
383
%%EOF

• /Size - 文档中对象总数（包括第0号对象）
• /Root - 指向文档目录（Catalog）对象的引用
• /Info - 可选，指向文档信息字典
• /ID - 文件标识符数组，用于增量更新验证
• startxref - 交叉引用表起始位置的字节偏移
• %%EOF - 文件结束标记

对象引用机制

PDF使用间接引用实现对象间的链接：

/Parent 2 0 R      % 引用对象编号2
/Pages [3 0 R 4 0 R] % 引用对象数组

• 格式为"N 0 R"，N是目标对象编号
• 通过交叉引用表快速定位对象位置
• 支持跨文档引用（通过/Names字典）
• 允许对象复用，减少文件大小

增量更新机制

PDF支持增量更新，修改文档时只需追加内容：

• 新的修改作为新对象追加到文件末尾
• 创建新的交叉引用表和文件尾
• 旧内容保持不变，确保可恢复性
• /Prev字段指向前一个文件尾位置
• 可实现文档的线性化和优化

压缩和优化

• 对象流 - PDF 1.5+特性，将多个对象压缩到一个流中
• 线性化 - 支持快速Web视图，渐进式加载
• 对象压缩 - 使用FlateDecode等算法压缩对象内容
• 共享资源 - 通过/Resources字典复用字体、图像等资源

from pypdf import PdfReader

def extract_text_from_pdf(pdf_path):
    """
    从PDF中提取所有文本内容
    """
    reader = PdfReader(pdf_path)
    full_text = ""

    for page in reader.pages:
        page_text = page.extract_text()
        full_text += f"--- Page {page.page_number + 1} ---\n"
        full_text += page_text + "\n\n"

    return full_text

# 使用示例
text = extract_text_from_pdf("document.pdf")
print(text)

from pypdf import PdfReader

def get_pdf_metadata(pdf_path):
    """
    获取PDF文档的元数据信息
    """
    reader = PdfReader(pdf_path)
    metadata = reader.metadata

    print(f"标题: {metadata.get('/Title', 'N/A')}")
    print(f"作者: {metadata.get('/Author', 'N/A')}")
    print(f"创建者: {metadata.get('/Creator', 'N/A')}")
    print(f"创建日期: {metadata.get('/CreationDate', 'N/A')}")
    print(f"修改日期: {metadata.get('/ModDate', 'N/A')}")
    print(f"主题: {metadata.get('/Subject', 'N/A')}")
    print(f"关键词: {metadata.get('/Keywords', 'N/A')}")

    return metadata

# 使用示例
metadata = get_pdf_metadata("document.pdf")

from pypdf import PdfReader, PdfWriter

def split_pdf_by_pages(pdf_path, output_prefix):
    """
    将PDF的每一页保存为单独的文件
    """
    reader = PdfReader(pdf_path)

    for page_num in range(len(reader.pages)):
        writer = PdfWriter()
        writer.add_page(reader.pages[page_num])

        output_filename = f"{output_prefix}_page_{page_num + 1}.pdf"
        with open(output_filename, "wb") as output_file:
            writer.write(output_file)

        print(f"已保存: {output_filename}")

# 使用示例
split_pdf_by_pages("document.pdf", "output")

from pypdf import PdfMerger

def merge_pdfs(input_files, output_file):
    """
    合并多个PDF文件为一个
    """
    merger = PdfMerger()

    for pdf_file in input_files:
        merger.append(pdf_file)
        print(f"已添加: {pdf_file}")

    merger.write(output_file)
    merger.close()

    print(f"合并完成，输出文件: {output_file}")

# 使用示例
input_pdfs = ["file1.pdf", "file2.pdf", "file3.pdf"]
merge_pdfs(input_pdfs, "merged_output.pdf")

from pypdf import PdfReader
from PIL import Image
import io

def extract_images_from_pdf(pdf_path, output_dir="extracted_images"):
    """
    从PDF中提取所有图像
    """
    import os
    os.makedirs(output_dir, exist_ok=True)

    reader = PdfReader(pdf_path)
    image_count = 0

    for page_num, page in enumerate(reader.pages):
        if '/Resources' in page and '/XObject' in page['/Resources']:
            xObject = page['/Resources']['/XObject'].get_object()

            for obj in xObject:
                if xObject[obj]['/Subtype'] == '/Image':
                    image = xObject[obj]._data

                    try:
                        # 尝试使用PIL打开图像
                        pil_image = Image.open(io.BytesIO(image))
                        image_format = pil_image.format or 'png'

                        output_path = f"{output_dir}/page_{page_num + 1}_image_{image_count}.{image_format.lower()}"
                        pil_image.save(output_path)

                        print(f"已保存图像: {output_path}")
                        image_count += 1
                    except Exception as e:
                        print(f"无法保存图像: {e}")

    print(f"总共提取了 {image_count} 张图像")
    return image_count

# 使用示例
extract_images_from_pdf("document.pdf", "images")

from pypdf import PdfReader, PdfWriter
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import letter
import io

def add_text_to_pdf(input_pdf, output_pdf, text, x, y, font_size=12):
    """
    在PDF指定位置添加文本
    """
    # 读取原始PDF
    reader = PdfReader(input_pdf)
    writer = PdfWriter()

    # 复制所有页面
    for page in reader.pages:
        writer.add_page(page)

    # 创建新的PDF页面用于添加文本
    packet = io.BytesIO()
    c = canvas.Canvas(packet, pagesize=letter)
    c.setFont("Helvetica", font_size)
    c.drawString(x, y, text)
    c.save()

    # 将新页面合并到原始PDF
    overlay = PdfReader(packet).pages[0]
    writer.pages[0].merge_page(overlay)

    # 保存结果
    with open(output_pdf, "wb") as output_file:
        writer.write(output_file)

    print(f"已添加文本，输出文件: {output_pdf}")

# 使用示例
add_text_to_pdf("document.pdf", "annotated.pdf", "已审核", 450, 750, 14)

# 基础PDF解析库
go get github.com/unidoc/unipdf/v3

# 文本提取
go get github.com/ledongthuc/pdf

# PDF生成
go get github.com/jung-kurt/gofpdf

package main

import (
    "fmt"
    "log"

    "github.com/unidoc/unipdf/v3/common/license"
    "github.com/unidoc/unipdf/v3/extractor"
    "github.com/unidoc/unipdf/v3/model"
)

func init() {
    // 设置UniDoc许可证（社区版免费但有限制）
    // 获取免费许可证: https://unidoc.io
    err := license.SetMeteredKey("your-license-key")
    if err != nil {
        log.Fatal("Failed to set license: ", err)
    }
}

func extractText(pdfPath string) error {
    // 打开PDF文件
    f, err := model.NewPdfReaderFromFile(pdfPath, nil)
    if err != nil {
        return fmt.Errorf("无法打开PDF: %v", err)
    }

    // 获取页数
    numPages, err := f.GetNumPages()
    if err != nil {
        return fmt.Errorf("获取页数失败: %v", err)
    }

    fmt.Printf("PDF共 %d 页\n", numPages)

    // 逐页提取文本
    for i := 1; i <= numPages; i++ {
        page, err := f.GetPage(i)
        if err != nil {
            return fmt.Errorf("获取第%d页失败: %v", i, err)
        }

        ex, err := extractor.New(page)
        if err != nil {
            return fmt.Errorf("创建提取器失败: %v", err)
        }

        text, err := ex.ExtractText()
        if err != nil {
            return fmt.Errorf("提取文本失败: %v", err)
        }

        fmt.Printf("\n--- 第 %d 页 ---\n", i)
        fmt.Println(text)
    }

    return nil
}

func main() {
    err := extractText("document.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/unidoc/unipdf/v3/common/license"
    "github.com/unidoc/unipdf/v3/model"
)

func getMetadata(pdfPath string) error {
    // 打开PDF文件
    f, err := model.NewPdfReaderFromFile(pdfPath, nil)
    if err != nil {
        return fmt.Errorf("无法打开PDF: %v", err)
    }

    // 获取PDF信息
    pdfInfo, err := f.GetPdfInfo()
    if err != nil {
        return fmt.Errorf("获取PDF信息失败: %v", err)
    }

    // 获取元数据
    metadata := pdfInfo.PdfInfo

    fmt.Println("=== PDF元数据 ===")
    if metadata.Title != "" {
        fmt.Printf("标题: %s\n", metadata.Title)
    }
    if metadata.Author != "" {
        fmt.Printf("作者: %s\n", metadata.Author)
    }
    if metadata.Subject != "" {
        fmt.Printf("主题: %s\n", metadata.Subject)
    }
    if metadata.Keywords != "" {
        fmt.Printf("关键词: %s\n", metadata.Keywords)
    }
    if metadata.Creator != "" {
        fmt.Printf("创建者: %s\n", metadata.Creator)
    }
    if metadata.Producer != "" {
        fmt.Printf("生产者: %s\n", metadata.Producer)
    }

    // 解析日期
    if metadata.CreationDate != nil {
        creationTime := metadata.CreationDate.Time
        fmt.Printf("创建日期: %s\n", creationTime.Format(time.RFC3339))
    }

    if metadata.ModDate != nil {
        modTime := metadata.ModDate.Time
        fmt.Printf("修改日期: %s\n", modTime.Format(time.RFC3339))
    }

    return nil
}

func main() {
    err := getMetadata("document.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "fmt"
    "log"
    "os"
    "strconv"

    "github.com/unidoc/unipdf/v3/common/license"
    "github.com/unidoc/unipdf/v3/creator"
    "github.com/unidoc/unipdf/v3/model"
)

func splitPDF(inputPath, outputPrefix string) error {
    // 打开PDF文件
    f, err := model.NewPdfReaderFromFile(inputPath, nil)
    if err != nil {
        return fmt.Errorf("无法打开PDF: %v", err)
    }

    numPages, err := f.GetNumPages()
    if err != nil {
        return fmt.Errorf("获取页数失败: %v", err)
    }

    // 逐页分割
    for i := 1; i <= numPages; i++ {
        // 创建新的PDF
        c := creator.New()

        // 获取页面
        page, err := f.GetPage(i)
        if err != nil {
            return fmt.Errorf("获取第%d页失败: %v", i, err)
        }

        // 添加页面到新PDF
        err = c.AddPage(page)
        if err != nil {
            return fmt.Errorf("添加页面失败: %v", err)
        }

        // 生成输出文件名
        outputPath := outputPrefix + "_page_" + strconv.Itoa(i) + ".pdf"

        // 保存文件
        err = c.WriteToFile(outputPath)
        if err != nil {
            return fmt.Errorf("保存文件失败: %v", err)
        }

        fmt.Printf("已保存: %s\n", outputPath)
    }

    return nil
}

func main() {
    err := splitPDF("document.pdf", "output")
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "fmt"
    "log"

    "github.com/unidoc/unipdf/v3/common/license"
    "github.com/unidoc/unipdf/v3/model"
)

func mergePDFs(inputPaths []string, outputPath string) error {
    // 创建新的PDF写入器
    writer := model.NewPdfWriter()

    // 遍历所有输入PDF
    for _, inputPath := range inputPaths {
        // 打开PDF文件
        reader, err := model.NewPdfReaderFromFile(inputPath, nil)
        if err != nil {
            return fmt.Errorf("无法打开PDF %s: %v", inputPath, err)
        }

        // 获取页数
        numPages, err := reader.GetNumPages()
        if err != nil {
            return fmt.Errorf("获取页数失败: %v", err)
        }

        // 将所有页面添加到写入器
        for i := 1; i <= numPages; i++ {
            page, err := reader.GetPage(i)
            if err != nil {
                return fmt.Errorf("获取第%d页失败: %v", i, err)
            }

            err = writer.AddPage(page)
            if err != nil {
                return fmt.Errorf("添加页面失败: %v", err)
            }
        }

        fmt.Printf("已添加: %s (%d页)\n", inputPath, numPages)
    }

    // 写入合并后的PDF
    f, err := os.Create(outputPath)
    if err != nil {
        return fmt.Errorf("创建输出文件失败: %v", err)
    }
    defer f.Close()

    err = writer.Write(f)
    if err != nil {
        return fmt.Errorf("写入PDF失败: %v", err)
    }

    fmt.Printf("合并完成，输出文件: %s\n", outputPath)
    return nil
}

func main() {
    inputPDFs := []string{"file1.pdf", "file2.pdf", "file3.pdf"}
    err := mergePDFs(inputPDFs, "merged_output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "log"

    "github.com/jung-kurt/gofpdf"
)

func createPDF(outputPath string) error {
    // 创建新的PDF
    pdf := gofpdf.New("P", "mm", "A4", "")
    pdf.AddPage()

    // 设置字体
    pdf.SetFont("Arial", "B", 16)

    // 添加标题
    pdf.Cell(40, 10, "Hello, PDF!")
    pdf.Ln(12)

    // 添加普通文本
    pdf.SetFont("Arial", "", 12)
    pdf.MultiCell(0, 10, "这是一个使用Golang创建的PDF文件。\n"+
        "你可以添加文本、图像、表格等各种内容。",
        "", "", false)

    pdf.Ln(10)

    // 添加列表
    pdf.SetFont("Arial", "B", 12)
    pdf.Cell(0, 10, "功能列表:")
    pdf.Ln(6)

    pdf.SetFont("Arial", "", 12)
    items := []string{
        "文本绘制",
        "图像插入",
        "表格创建",
        "多页支持",
        "字体自定义",
    }

    for _, item := range items {
        pdf.Cell(10, 6, "")
        pdf.Cell(0, 6, item)
        pdf.Ln(6)
    }

    // 保存文件
    err := pdf.OutputFileAndClose(outputPath)
    if err != nil {
        return err
    }

    log.Printf("PDF创建成功: %s\n", outputPath)
    return nil
}

func main() {
    err := createPDF("created.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "fmt"
    "log"

    "github.com/unidoc/unipdf/v3/common/license"
    "github.com/unidoc/unipdf/v3/extractor"
    "github.com/unidoc/unipdf/v3/model"
)

type TableData struct {
    Rows [][]string
}

func extractTable(pdfPath, pageNum int) (*TableData, error) {
    // 打开PDF文件
    f, err := model.NewPdfReaderFromFile(pdfPath, nil)
    if err != nil {
        return nil, fmt.Errorf("无法打开PDF: %v", err)
    }

    // 获取指定页面
    page, err := f.GetPage(pageNum)
    if err != nil {
        return nil, fmt.Errorf("获取第%d页失败: %v", pageNum, err)
    }

    // 创建文本提取器
    ex, err := extractor.New(page)
    if err != nil {
        return nil, fmt.Errorf("创建提取器失败: %v", err)
    }

    // 提取页面布局
    pageLayout, err := ex.ExtractPageLayout()
    if err != nil {
        return nil, fmt.Errorf("提取页面布局失败: %v", err)
    }

    // 分析文本位置，识别表格
    table := &TableData{
        Rows: make([][]string, 0),
    }

    // 遍历文本块，按行分组
    currentRow := make([]string, 0)
    lastY := 0.0

    for _, block := range pageLayout.Text {
        // 简单的行分组逻辑（实际应用中需要更复杂的算法）
        if lastY != 0 && block.Position.Y != lastY {
            table.Rows = append(table.Rows, currentRow)
            currentRow = make([]string, 0)
        }
        currentRow = append(currentRow, block.Text)
        lastY = block.Position.Y
    }

    if len(currentRow) > 0 {
        table.Rows = append(table.Rows, currentRow)
    }

    return table, nil
}

func main() {
    table, err := extractTable("document.pdf", 1)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("提取的表格数据:")
    for i, row := range table.Rows {
        fmt.Printf("第%d行: %v\n", i+1, row)
    }
}

选择合适的库

需求	Python推荐	Golang推荐
简单文本提取	pypdf	ledongthuc/pdf
完整读写操作	pypdf, PyMuPDF	unipdf
表格提取	pdfplumber, camelot	unipdf (需自定义)
从零创建PDF	reportlab	gofpdf, unipdf
PDF渲染到图像	pdf2image, PyMuPDF	unipdf, skia-pdf

快速开始建议

1. 阅读PDF 2.0规范，了解基本概念
2. 选择一门编程语言（Python/Java/JavaScript）
3. 学习使用相应的PDF库进行基本操作
4. 实践创建、修改、合并、分割PDF文档
5. 探索AI集成和自动化工作流
6. 了解PDF安全和签名机制