SpringBoot Apache Tika 轻松实现各种文档内容解析

javpower

发布于 2025-05-30 11:34:37

12200

代码可运行

运行总次数：0

代码可运行

在当今的数字时代，各种类型的文档在企业和个人中广泛使用。从PDF和Word文档到Excel电子表格和PowerPoint演示文稿，管理这些文档并从它们中提取有价值的信息变得越来越重要。文档内容解析是指从这些文档中提取和分析文本和元数据的过程，这对于信息检索、搜索和分类等任务非常有用。 Apache Tika是一个强大的开源工具，可以检测和提取超过一千种不同文件类型的元数据和文本。它设计精巧，提供了一个单一的接口，使用户能够轻松地从各种文件中提取内容。将Tika与SpringBoot结合使用，可以创建一个高效且可扩展的文档解析解决方案。在本文中，我们将逐步介绍如何使用SpringBoot和Apache Tika创建一个应用程序，该应用程序可以解析各种类型的文档并提取其内容。

Apache Tika简介

Apache Tika是一个内容分析工具包，可以检测和提取超过一千种不同文件类型的元数据和文本。它设计精巧，提供了一个单一的接口，使它易于使用。 Tika的主要功能包括：

文件类型检测：自动检测文件的类型
内容提取：从文件中提取文本内容
元数据提取：从文件中提取元数据信息，如作者、创建日期等
支持多种文件格式：支持超过一千种文件格式，包括PDF、Word、Excel、PPT等 Tika的核心组件包括：
Parser：解析器，用于解析特定类型的文件
Detector：检测器，用于检测文件的类型
Content：内容，表示文件的内容
Metadata：元数据，表示文件的元数据信息

SpringBoot项目配置

创建SpringBoot项目

首先，我们需要创建一个SpringBoot项目。可以使用Spring Initializer来创建一个基本的SpringBoot项目，选择适当的依赖项，如Web、Thymeleaf等。

添加Tika依赖

在项目的pom.xml文件中添加Tika的依赖：

<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-core</artifactId>
    <version>2.6.0</version>
</dependency>
<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-parsers</artifactId>
    <version>2.6.0</version>
</dependency>

配置Tika解析器

为了提高性能，我们可以配置Tika解析器以仅解析所需的文件类型。以下是一个配置示例：

import org.apache.tika.config.TikaConfig;
import org.apache.tika.detect.Detector;
import org.apache.tika.parser.Parser;
import org.apache.tika.parser.pdf.PDFParser;
import org.apache.tika.parser.microsoft.OfficeParser;
import org.apache.tika.parser.txt.TXTParser;
import org.apache.tika.parser.html.HtmlParser;
import org.apache.tika.parser.xml.XMLParser;
import java.util.HashMap;
import java.util.Map;
publicclass TikaConfigurator {
    public static TikaConfig configureTika() {
        // 创建自定义的解析器映射
        Map<String, Parser> parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
        // 创建自定义的检测器
        Detector detector = new DefaultDetector();
        // 创建Tika配置
        TikaConfig tikaConfig = new TikaConfig();
        tikaConfig.setParsers(parserMap);
        tikaConfig.setDetector(detector);
        return tikaConfig;
    }
}

创建文档解析服务

创建一个服务类来处理文档解析：

import org.apache.tika.Tika;
import org.apache.tika.config.TikaConfig;
import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;
import org.xml.sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
publicclass DocumentParserService {
    private Tika tika;
    private Map<String, Parser> parserMap;
    public DocumentParserService() {
        this.tika = new Tika();
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
    }
    public String parseDocument(File file) throws IOException, TikaException, SAXException {
        // 获取文件扩展名
        String extension = getFileExtension(file.getName());
        // 选择合适的解析器
        Parser parser = parserMap.get(extension);
        if (parser == null) {
            thrownew IllegalArgumentException("Unsupported file type: " + extension);
        }
        // 创建内容处理器
        BodyContentHandler contentHandler = new BodyContentHandler();
        // 创建元数据对象
        Metadata metadata = new Metadata();
        // 解析文档
        ParseContext parseContext = new ParseContext();
        parser.parse(file, contentHandler, metadata, parseContext);
        // 获取解析后的内容
        String content = contentHandler.toString();
        return content;
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

创建控制器

创建一个SpringBoot控制器来处理文件上传和解析请求：

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.StandardCopyOption;
@RestController
@RequestMapping("/api")
publicclass DocumentController {
    private DocumentParserService documentParserService;
    public DocumentController() {
        this.documentParserService = new DocumentParserService();
    }
    @PostMapping("/parse")
    public String parseDocument(@RequestParam("file") MultipartFile file) throws IOException {
        // 保存上传的文件
        File tempFile = new File("temp/" + file.getOriginalFilename());
        Files.copy(file.getInputStream(), tempFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        try {
            // 解析文档
            String content = documentParserService.parseDocument(tempFile);
            return content;
        } finally {
            // 删除临时文件
            tempFile.delete();
        }
    }
}

配置文件上传路径

在application.properties文件中配置文件上传路径：

upload.path=temp

创建视图页面

创建一个简单的HTML页面，用于文件上传：

<!DOCTYPE html>
<html>
<head>
    <title>Document Parser</title>
</head>
<body>
    <h1>Document Parser</h1>
    <form action="/api/parse" method="post" enctype="multipart/form-data">
        <input type="file" name="file" accept=".pdf,.docx,.xlsx,.pptx,.txt,.html,.xml">
        <button type="submit">Parse Document</button>
    </form>
</body>
</html>

运行应用程序

运行SpringBoot应用程序，访问视图页面，上传需要解析的文档，点击“Parse Document”按钮即可获取解析后的内容。

Apache Tika的高级功能

分页解析

对于大型文档，可以实现分页解析以提高效率。以下是一个分页解析的示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
publicclass PaginatedDocumentParserService {
    private Map<String, Parser> parserMap;
    public PaginatedDocumentParserService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
    }
    public String parseDocument(File file, int pageNumber) throws IOException, SAXException {
        // 获取文件扩展名
        String extension = getFileExtension(file.getName());
        // 选择合适的解析器
        Parser parser = parserMap.get(extension);
        if (parser == null) {
            thrownew IllegalArgumentException("Unsupported file type: " + extension);
        }
        // 创建内容处理器
        BodyContentHandler contentHandler = new BodyContentHandler();
        // 创建元数据对象
        Metadata metadata = new Metadata();
        // 设置分页参数
        ParseContext parseContext = new ParseContext();
        parseContext.set(Metadata.EMBEDDED_PAGE_NUMBER, pageNumber);
        // 解析文档
        parser.parse(file, contentHandler, metadata, parseContext);
        // 获取解析后的内容
        String content = contentHandler.toString();
        return content;
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

元数据提取

除了内容提取，Tika还可以提取文件的元数据。以下是一个提取元数据的示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
publicclass MetadataExtractorService {
    private Map<String, Parser> parserMap;
    public MetadataExtractorService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
    }
    public Map<String, String> extractMetadata(File file) throws IOException, SAXException {
        // 获取文件扩展名
        String extension = getFileExtension(file.getName());
        // 选择合适的解析器
        Parser parser = parserMap.get(extension);
        if (parser == null) {
            thrownew IllegalArgumentException("Unsupported file type: " + extension);
        }
        // 创建内容处理器
        BodyContentHandler contentHandler = new BodyContentHandler();
        // 创建元数据对象
        Metadata metadata = new Metadata();
        // 解析文档
        ParseContext parseContext = new ParseContext();
        parser.parse(file, contentHandler, metadata, parseContext);
        // 提取元数据
        Map<String, String> metadataMap = new HashMap<>();
        for (String name : metadata.names()) {
            metadataMap.put(name, metadata.get(name));
        }
        return metadataMap;
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

批量解析

对于多个文档，可以实现批量解析以提高效率。以下是一个批量解析的示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika parser.Parser;
import org.apache.tika sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
publicclass BatchDocumentParserService {
    private Map<String, Parser> parserMap;
    public BatchDocumentParserService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
    }
    public Map<File, String> parseDocuments(List<File> files) throws IOException, SAXException {
        Map<File, String> contentMap = new HashMap<>();
        for (File file : files) {
            // 获取文件扩展名
            String extension = getFileExtension(file.getName());
            // 选择合适的解析器
            Parser parser = parserMap.get(extension);
            if (parser == null) {
                thrownew IllegalArgumentException("Unsupported file type: " + extension);
            }
            // 创建内容处理器
            BodyContentHandler contentHandler = new BodyContentHandler();
            // 创建元数据对象
            Metadata metadata = new Metadata();
            // 解析文档
            ParseContext parseContext = new ParseContext();
            parser.parse(file, contentHandler, metadata, parseContext);
            // 获取解析后的内容
            String content = contentHandler.toString();
            // 存储内容
            contentMap.put(file, content);
        }
        return contentMap;
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

异步解析

对于大型文档或高并发场景，可以实现异步解析以提高性能。以下是一个异步解析的示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika parser.ParseContext;
import org.apache.tika parser.Parser;
import org.apache.tika sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
publicclass AsyncDocumentParserService {
    private Map<String, Parser> parserMap;
    private ExecutorService executorService;
    public AsyncDocumentParserService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
        this.executorService = Executors.newFixedThreadPool(4);
    }
    public CompletableFuture<String> parseDocument(File file) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                // 获取文件扩展名
                String extension = getFileExtension(file.getName());
                // 选择合适的解析器
                Parser parser = parserMap.get(extension);
                if (parser == null) {
                    thrownew IllegalArgumentException("Unsupported file type: " + extension);
                }
                // 创建内容处理器
                BodyContentHandler contentHandler = new BodyContentHandler();
                // 创建元数据对象
                Metadata metadata = new Metadata();
                // 解析文档
                ParseContext parseContext = new ParseContext();
                parser.parse(file, contentHandler, metadata, parseContext);
                // 获取解析后的内容
                String content = contentHandler.toString();
                return content;
            } catch (IOException | SAXException e) {
                thrownew RuntimeException(e);
            }
        }, executorService);
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

错误处理和日志记录

为了确保应用程序的健壮性，可以实现错误处理和日志记录。以下是一个包含错误处理和日志记录的文档解析服务示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika parser.ParseContext;
import org.apache.tika parser.Parser;
import org.apache.tika sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
publicclass RobustDocumentParserService {
    privatestaticfinal Logger logger = Logger.getLogger(RobustDocumentParserService.class.getName());
    private Map<String, Parser> parserMap;
    public RobustDocumentParserService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
    }
    public String parseDocument(File file) {
        try {
            // 获取文件扩展名
            String extension = getFileExtension(file.getName());
            // 选择合适的解析器
            Parser parser = parserMap.get(extension);
            if (parser == null) {
                logger.warning("Unsupported file type: " + extension);
                thrownew IllegalArgumentException("Unsupported file type: " + extension);
            }
            // 创建内容处理器
            BodyContentHandler contentHandler = new BodyContentHandler();
            // 创建元数据对象
            Metadata metadata = new Metadata();
            // 解析文档
            ParseContext parseContext = new ParseContext();
            parser.parse(file, contentHandler, metadata, parseContext);
            // 获取解析后的内容
            String content = contentHandler.toString();
            return content;
        } catch (IOException | SAXException e) {
            logger.severe("Error parsing document: " + e.getMessage());
            thrownew RuntimeException("Error parsing document", e);
        }
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

性能优化

为了提高解析性能，可以考虑以下优化措施：

缓存：缓存频繁访问的文档或元数据
并行处理：使用多线程并行解析多个文档
增量解析：对于大型文档，实现增量解析，只解析需要的部分以下是一个使用缓存的文档解析服务示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika parser.ParseContext;
import org.apache.tika parser.Parser;
import org.apache.tika sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
publicclass CachedDocumentParserService {
    private Map<String, Parser> parserMap;
    private Map<String, String> contentCache;
    public CachedDocumentParserService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
        this.contentCache = new ConcurrentHashMap<>();
    }
    public String parseDocument(File file) throws IOException, SAXException {
        // 获取文件路径作为缓存键
        String filePath = file.getAbsolutePath();
        // 检查缓存
        if (contentCache.containsKey(filePath)) {
            return contentCache.get(filePath);
        }
        // 解析文档
        String content = doParseDocument(file);
        // 存入缓存
        contentCache.put(filePath, content);
        return content;
    }
    private String doParseDocument(File file) throws IOException, SAXException {
        // 获取文件扩展名
        String extension = getFileExtension(file.getName());
        // 选择合适的解析器
        Parser parser = parserMap.get(extension);
        if (parser == null) {
            thrownew IllegalArgumentException("Unsupported file type: " + extension);
        }
        // 创建内容处理器
        BodyContentHandler contentHandler = new BodyContentHandler();
        // 创建元数据对象
        Metadata metadata = new Metadata();
        // 解析文档
        ParseContext parseContext = new ParseContext();
        parser.parse(file, contentHandler, metadata, parseContext);
        // 获取解析后的内容
        String content = contentHandler.toString();
        return content;
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}

集成搜索功能

可以将解析后的内容集成到搜索功能中，方便用户快速查找所需信息。以下是一个简单的搜索功能示例：

import org.apache.tika.metadata.Metadata;
import org.apache.tika parser.ParseContext;
import org.apache.tika parser.Parser;
import org.apache.tika sax.BodyContentHandler;
import org.xml sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
publicclass SearchService {
    private Map<String, Parser> parserMap;
    private Map<String, String> documentCache;
    public SearchService() {
        this.parserMap = new HashMap<>();
        parserMap.put("pdf", new PDFParser());
        parserMap.put("docx", new OfficeParser());
        parserMap.put("xlsx", new OfficeParser());
        parserMap.put("pptx", new OfficeParser());
        parserMap.put("txt", new TXTParser());
        parserMap.put("html", new HtmlParser());
        parserMap.put("xml", new XMLParser());
        this.documentCache = new HashMap<>();
    }
    public void addDocument(File file) throws IOException, SAXException {
        // 获取文件路径作为缓存键
        String filePath = file.getAbsolutePath();
        // 解析文档
        String content = parseDocument(file);
        // 存入缓存
        documentCache.put(filePath, content);
    }
    public List<String> search(String query) {
        return documentCache.entrySet().stream()
                .filter(entry -> entry.getValue().contains(query))
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }
    private String parseDocument(File file) throws IOException, SAXException {
        // 获取文件扩展名
        String extension = getFileExtension(file.getName());
        // 选择合适的解析器
        Parser parser = parserMap.get(extension);
        if (parser == null) {
            thrownew IllegalArgumentException("Unsupported file type: " + extension);
        }
        // 创建内容处理器
        BodyContentHandler contentHandler = new BodyContentHandler();
        // 创建元数据对象
        Metadata metadata = new Metadata();
        // 解析文档
        ParseContext parseContext = new ParseContext();
        parser.parse(file, contentHandler, metadata, parseContext);
        // 获取解析后的内容
        String content = contentHandler.toString();
        return content;
    }
    private String getFileExtension(String fileName) {
        int lastDotIndex = fileName.lastIndexOf('.');
        if (lastDotIndex == -1) {
            return"";
        }
        return fileName.substring(lastDotIndex + 1).toLowerCase();
    }
}