Java填充Word文档空白实现及批量生成Word打印方案咨询

Hey there! Let's tackle your two Java-related Word processing questions one by one—they're both super common scenarios, so I've got some solid solutions for you.

Absolutely, you can fill blank fields in Word documents using Java. The most popular tools for this are Apache POI (great for simple to moderately complex docs) and Docx4j (better for advanced Word structure manipulation like styles, headers/footers, or nested content).

Here’s a quick example using Apache POI for a template-based fill:

Step 1: Set up your template #

Create a Word doc (.docx) with placeholders like ${studentName}, ${topFriend1}, etc., where you need to insert dynamic data.

Step 2: Add Apache POI dependency (Maven) #

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.2.5</version> <!-- Use the latest stable version -->
</dependency>

Step 3: Code to fill the template #

import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Map;

public class WordFiller {
    public static void fillTemplate(String templatePath, String outputPath, Map<String, String> data) throws Exception {
        // Load the template document
        XWPFDocument doc = new XWPFDocument(new FileInputStream(templatePath));
        
        // Replace placeholders in paragraphs
        for (XWPFParagraph paragraph : doc.getParagraphs()) {
            for (XWPFRun run : paragraph.getRuns()) {
                String text = run.getText(0);
                if (text != null) {
                    for (Map.Entry<String, String> entry : data.entrySet()) {
                        if (text.contains(entry.getKey())) {
                            text = text.replace(entry.getKey(), entry.getValue());
                            run.setText(text, 0);
                        }
                    }
                }
            }
        }
        
        // Don't forget to handle tables if your template has them!
        // (Similar logic: iterate over table rows/cells and replace text)
        
        // Save the filled document
        FileOutputStream out = new FileOutputStream(outputPath);
        doc.write(out);
        // Clean up resources
        out.close();
        doc.close();
    }

    public static void main(String[] args) throws Exception {
        Map<String, String> studentData = new HashMap<>();
        studentData.put("${studentName}", "Alice Smith");
        studentData.put("${topFriend1}", "Bob Johnson");
        studentData.put("${topFriend2}", "Charlie Davis");
        
        fillTemplate("friendship-survey-template.docx", "alice-results.docx", studentData);
    }
}

If you need more advanced control (like repeating sections for multiple friends), Docx4j’s content control binding is a better fit—it lets you map data directly to structured Word content controls.

Ditching HTML printing for batch Word generation is a smart move for efficiency, especially with 400+ students. Here’s how to pull this off:

First: Generate Word files efficiently #

Reuse the template-filling logic from the first question! Create a single template, loop through each student’s data, generate a unique Word file per student, and save them to a temporary directory (or generate them in memory if you don’t need to keep the files after printing).

Second: Batch print the Word files #

You have two main options for printing from Java:

Option 1: Use Java’s Desktop class (simple for desktop apps)

This leverages the system’s default Word viewer to handle printing, which is straightforward for desktop applications:

import java.awt.Desktop;
import java.io.File;

public class BatchPrinter {
    public static void printFile(File file) throws Exception {
        if (Desktop.isDesktopSupported() && Desktop.getDesktop().isSupported(Desktop.Action.PRINT)) {
            Desktop.getDesktop().print(file);
        } else {
            throw new UnsupportedOperationException("Printing is not supported on this system");
        }
    }

    public static void main(String[] args) throws Exception {
        // Assume you have a list of generated Word files
        File[] studentFiles = new File("generated-results").listFiles((dir, name) -> name.endsWith(".docx"));
        
        for (File file : studentFiles) {
            printFile(file);
            // Optional: Add a small delay if the printer queue needs time to process
            Thread.sleep(500);
        }
    }
}

Option 2: Use Java Print Service API (more control)

If you need to specify printers, set print settings (like duplex, paper size), or avoid relying on the system’s Word viewer, use the Java Print Service API. Note that this requires parsing the Word content into a printable format—you can use Apache POI to extract text and render it, or use a library like Apache PDFBox to convert Word to PDF first, then print the PDF (often more reliable for consistent formatting):

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.printing.PDFPageable;

import javax.print.PrintService;
import javax.print.PrintServiceLookup;
import java.io.File;

public class PdfBatchPrinter {
    public static void printPdf(File pdfFile) throws Exception {
        // Get the default printer
        PrintService defaultPrinter = PrintServiceLookup.lookupDefaultPrintService();
        
        try (PDDocument doc = PDDocument.load(pdfFile)) {
            doc.print(new PDFPageable(doc), defaultPrinter.createPrintJob());
        }
    }

    // First convert your Word file to PDF (use Apache POI + PDFBox or another converter)
    // Then loop through PDFs and print
}

Key tips for efficiency with 400+ students: #

• Use a template: Don’t build each Word file from scratch—templates cut down on processing time drastically.
• Manage resources: Always close XWPFDocument, FileInputStream, and FileOutputStream after use to avoid memory leaks.
• Consider in-memory generation: If you don’t need to save the Word files, generate them in memory and print directly without writing to disk.
• Parallel processing: If your system has multiple cores, you can generate files in parallel (use ExecutorService) to speed up the process—just make sure printing is handled sequentially to avoid overwhelming the printer queue.

内容的提问来源于stack exchange，提问作者Lillbro55