Importing Data from Word

package demo;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import javax.imageio.ImageIO;
import org.apache.poi.openxml4j.opc.PackagePart;
import org.apache.poi.openxml4j.opc.PackagePartName;
import org.apache.poi.openxml4j.opc.PackagingURIHelper;
import org.apache.poi.openxml4j.opc.TargetMode;
import org.apache.poi.util.Units;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xwpf.usermodel.*;
import org.apache.xmlbeans.XmlCursor;
import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlObject;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTStyle;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STStyleType;

/** Test fixture: builds book-request-form.docx with tables, content controls, an image and an attachment. */
public final class BookRequestFormGenerator {

    private static final String W = "xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"";
    private static final String W14 = "xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\"";

    public static void main(String[] args) throws Exception {
        Path target = Path.of(args.length > 0 ? args[0] : "book-request-form.docx");
        try (XWPFDocument doc = new XWPFDocument(); OutputStream out = Files.newOutputStream(target)) {
            addHeadingStyles(doc);
            heading(doc, "Title", "Book request form");

            heading(doc, "Heading1", "Requester");
            XWPFParagraph p = doc.createParagraph();
            p.createRun().setText("Name: ");
            appendXml(p.getCTP(), "<w:sdt " + W + "><w:sdtPr><w:alias w:val=\"Requester name\"/>"
                    + "<w:tag w:val=\"requester.name\"/><w:text/></w:sdtPr>"
                    + "<w:sdtContent><w:r><w:t>Ana Pérez</w:t></w:r></w:sdtContent></w:sdt>");

            p = doc.createParagraph();
            p.createRun().setText("Department: ");
            appendXml(p.getCTP(), "<w:sdt " + W + "><w:sdtPr><w:tag w:val=\"requester.department\"/>"
                    + "<w:dropDownList><w:listItem w:displayText=\"Fiction\" w:value=\"FIC\"/>"
                    + "<w:listItem w:displayText=\"Science\" w:value=\"SCI\"/></w:dropDownList></w:sdtPr>"
                    + "<w:sdtContent><w:r><w:t>Science</w:t></w:r></w:sdtContent></w:sdt>");

            p = doc.createParagraph();
            p.createRun().setText("Needed by: ");
            appendXml(p.getCTP(), "<w:sdt " + W + "><w:sdtPr><w:tag w:val=\"request.neededBy\"/>"
                    + "<w:date w:fullDate=\"2026-11-15T00:00:00Z\"><w:dateFormat w:val=\"dd/MM/yyyy\"/></w:date>"
                    + "</w:sdtPr><w:sdtContent><w:r><w:t>15/11/2026</w:t></w:r></w:sdtContent></w:sdt>");

            p = doc.createParagraph();
            p.createRun().setText("Needs approval: ");
            appendXml(p.getCTP(), "<w:sdt " + W + " " + W14 + "><w:sdtPr><w:tag w:val=\"request.approval\"/>"
                    + "<w14:checkbox><w14:checked w14:val=\"1\"/></w14:checkbox></w:sdtPr>"
                    + "<w:sdtContent><w:r><w:t>☒</w:t></w:r></w:sdtContent></w:sdt>");

            p = doc.createParagraph();
            p.createRun().setText("Priority: ");
            appendXml(p.getCTP(), "<w:sdt " + W + "><w:sdtPr><w:tag w:val=\"request.priority\"/><w:text/>"
                    + "<w:showingPlcHdr/></w:sdtPr><w:sdtContent><w:r><w:t>Click to enter a priority</w:t></w:r>"
                    + "</w:sdtContent></w:sdt>");

            heading(doc, "Heading1", "Justification");
            appendXml(doc.getDocument().getBody(), "<w:sdt " + W + "><w:sdtPr><w:alias w:val=\"Justification\"/>"
                    + "<w:tag w:val=\"request.justification\"/></w:sdtPr><w:sdtContent>"
                    + "<w:p><w:r><w:t>Three students need the course reader.</w:t></w:r></w:p>"
                    + "<w:p><w:r><w:t>The library holds one copy.</w:t></w:r></w:p></w:sdtContent></w:sdt>");

            heading(doc, "Heading1", "Requested books");
            XWPFTable table = doc.createTable(4, 4);
            String[][] rows = {{"Title", "Author", "ISBN", "Quantity"},
                    {"The Dispossessed", "Ursula K. Le Guin", "9780061054884", "2"},
                    {"The Left Hand of Darkness", "", "9780441478125", "1"},
                    {"Cosmos", "Carl Sagan", "9780345539434", "x"}};
            for (int r = 0; r < rows.length; r++) {
                for (int c = 0; c < 4; c++) {
                    table.getRow(r).getCell(c).setText(rows[r][c]);
                }
            }
            // vertical merge: the author cell of row 2 continues the one of row 1
            table.getRow(1).getCell(1).getCTTc().addNewTcPr().addNewVMerge().setVal(
                    org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge.RESTART);
            table.getRow(2).getCell(1).getCTTc().addNewTcPr().addNewVMerge();

            heading(doc, "Heading1", "Attachments");
            byte[] png = cover();
            XWPFRun run = doc.createParagraph().createRun();
            run.addPicture(new ByteArrayInputStream(png), XWPFDocument.PICTURE_TYPE_PNG, "cover.png",
                    Units.toEMU(60), Units.toEMU(80));
            run.getEmbeddedPictures().get(0).getCTPicture().getNvPicPr().getCNvPr().setDescr("Course reader cover");
            embedWorkbook(doc);
            doc.write(out);
        }
    }

    private static void heading(XWPFDocument doc, String styleId, String text) {
        XWPFParagraph p = doc.createParagraph();
        p.setStyle(styleId);
        p.createRun().setText(text);
    }

    private static void addHeadingStyles(XWPFDocument doc) {
        XWPFStyles styles = doc.createStyles();
        String[][] defs = {{"Title", "Title"}, {"Heading1", "heading 1"}, {"Heading2", "heading 2"}};
        for (String[] d : defs) {
            CTStyle ct = CTStyle.Factory.newInstance();
            ct.setStyleId(d[0]);
            ct.addNewName().setVal(d[1]);
            ct.setType(STStyleType.PARAGRAPH);
            styles.addStyle(new XWPFStyle(ct));
        }
    }

    private static byte[] cover() throws IOException {
        BufferedImage img = new BufferedImage(60, 80, BufferedImage.TYPE_INT_RGB);
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            ImageIO.write(img, "png", bos);
            return bos.toByteArray();
        }
    }

    private static void embedWorkbook(XWPFDocument doc) throws Exception {
        byte[] xlsx;
        try (XSSFWorkbook wb = new XSSFWorkbook(); ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            wb.createSheet("Quote").createRow(0).createCell(0).setCellValue("supplier quote");
            wb.write(bos);
            xlsx = bos.toByteArray();
        }
        PackagePartName name = PackagingURIHelper.createPartName("/word/embeddings/Microsoft_Excel_Sheet1.xlsx");
        PackagePart part = doc.getPackage().createPart(name,
                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        try (OutputStream os = part.getOutputStream()) {
            os.write(xlsx);
        }
        doc.getPackagePart().addRelationship(name, TargetMode.INTERNAL,
                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package");
    }

    private static void appendXml(XmlObject target, String xml) throws XmlException {
        try (XmlCursor dst = target.newCursor(); XmlCursor src = XmlObject.Factory.parse(xml).newCursor()) {
            dst.toEndToken();
            src.toFirstChild();
            src.copyXml(dst);
        }
    }
}

<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-ooxml</artifactId>
  <version>5.5.1</version>
</dependency>
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-scratchpad</artifactId>
  <version>5.5.1</version>
</dependency>

dependencies {
    implementation("org.apache.poi:poi-ooxml:5.5.1")
    implementation("org.apache.poi:poi-scratchpad:5.5.1")   // only for legacy .doc
}

package demo;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.poi.xwpf.usermodel.XWPFTable;
import org.apache.poi.xwpf.usermodel.XWPFTableCell;
import org.apache.poi.xwpf.usermodel.XWPFTableRow;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge;

/** Turns a Word table into a list of rows keyed by the header row. */
public final class DocxTables {

    private DocxTables() {
    }

    /** One grid row: merged cells are expanded so that the list has one entry per grid column. */
    static List<String> gridRow(XWPFTableRow row, List<String> rowAbove) {
        List<String> values = new ArrayList<>();
        for (XWPFTableCell cell : row.getTableCells()) {
            CTTcPr pr = cell.getCTTc().getTcPr();
            int span = pr != null && pr.isSetGridSpan() ? pr.getGridSpan().getVal().intValue() : 1;
            String text = cell.getText().strip();
            boolean continuation = pr != null && pr.isSetVMerge()
                    && pr.getVMerge().getVal() != STMerge.RESTART;
            if (continuation && rowAbove != null && values.size() < rowAbove.size()) {
                text = rowAbove.get(values.size());      // vertical merge: repeat the value above
            }
            for (int i = 0; i < span; i++) {
                values.add(text);
            }
        }
        return values;
    }

    /** The first row is the header; every other row becomes a map header -> value. */
    public static List<Map<String, String>> toRows(XWPFTable table) {
        List<XWPFTableRow> rows = table.getRows();
        if (rows.size() < 2) {
            return List.of();
        }
        List<String> header = gridRow(rows.get(0), null).stream()
                .map(h -> h.toLowerCase(java.util.Locale.ROOT)).toList();
        List<Map<String, String>> result = new ArrayList<>();
        List<String> above = header;
        for (XWPFTableRow row : rows.subList(1, rows.size())) {
            List<String> values = gridRow(row, above);
            Map<String, String> record = new LinkedHashMap<>();
            for (int c = 0; c < header.size(); c++) {
                record.put(header.get(c), c < values.size() ? values.get(c) : "");
            }
            result.add(record);
            above = values;
        }
        return result;
    }
}

[{title=The Dispossessed, author=Ursula K. Le Guin, isbn=9780061054884, quantity=2},
 {title=The Left Hand of Darkness, author=Ursula K. Le Guin, isbn=9780441478125, quantity=1},
 {title=Cosmos, author=Carl Sagan, isbn=9780345539434, quantity=x}]

package demo;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.poi.xwpf.usermodel.IBodyElement;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFStyle;
import org.apache.poi.xwpf.usermodel.XWPFStyles;

/** Groups the paragraphs of a document under the heading that precedes them. */
public final class DocxHeadings {

    private static final Pattern HEADING = Pattern.compile("heading ?(\\d)");

    private DocxHeadings() {
    }

    /** 0 for body text, 1..9 for Heading 1..9, regardless of the style id or the UI language. */
    static int headingLevel(XWPFParagraph p, XWPFStyles styles) {
        String styleId = p.getStyle();
        if (styleId == null) {
            return 0;
        }
        String name = styleId;
        XWPFStyle style = styles == null ? null : styles.getStyle(styleId);
        if (style != null && style.getName() != null) {
            name = style.getName();                       // "heading 1" is the built-in name
        }
        Matcher m = HEADING.matcher(name.toLowerCase(Locale.ROOT));
        return m.matches() ? Integer.parseInt(m.group(1)) : 0;
    }

    /** Heading text -> the non-empty paragraphs under it; tables are skipped (see DocxTables). */
    public static Map<String, List<String>> sections(XWPFDocument doc) {
        Map<String, List<String>> sections = new LinkedHashMap<>();
        String current = "(preamble)";
        for (IBodyElement element : doc.getBodyElements()) {
            if (element instanceof XWPFParagraph p) {
                String text = p.getText().strip();
                if (text.isEmpty()) {
                    continue;
                }
                if (headingLevel(p, doc.getStyles()) > 0) {
                    current = text;
                    sections.putIfAbsent(current, new ArrayList<>());
                } else {
                    sections.computeIfAbsent(current, k -> new ArrayList<>()).add(text);
                }
            }
        }
        return sections;
    }
}

{(preamble)=[Book request form],
 Requester=[Name: Ana Pérez, Department: Science, Needed by: 15/11/2026, Needs approval: ☒,
            Priority: Click to enter a priority],
 Justification=[],
 Requested books=[],
 Attachments=[]}

package demo;

import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.xml.namespace.QName;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.xmlbeans.XmlCursor;
import org.apache.xmlbeans.XmlObject;

/** Reads content controls (w:sdt) anywhere in the body: block level, inline and in table cells. */
public final class ContentControls {

    private static final String W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
    private static final String W14 = "http://schemas.microsoft.com/office/word/2010/wordml";
    private static final String NS = "declare namespace w='" + W + "'; ";

    public enum Kind { TEXT, RICH_TEXT, DROP_DOWN, COMBO_BOX, DATE, CHECKBOX, PICTURE, OTHER }

    /** A control with its tag, its display value and, for dropdowns, the stored value. */
    public record Control(String tag, String title, Kind kind, String text, String value, boolean placeholder) {
    }

    private ContentControls() {
    }

    public static List<Control> read(XWPFDocument doc) {
        List<Control> controls = new ArrayList<>();
        XmlObject body = doc.getDocument().getBody();
        for (XmlObject sdt : body.selectPath(NS + ".//w:sdt")) {      // document order, nested controls included
            XmlObject[] props = sdt.selectPath(NS + "./w:sdtPr");
            if (props.length == 0) {
                continue;
            }
            XmlObject pr = props[0];
            String tag = attr(pr, "./w:tag", W, "val");
            String title = attr(pr, "./w:alias", W, "val");
            String text = text(sdt);
            controls.add(new Control(tag, title, kind(pr), text, storedValue(pr, text),
                    pr.selectPath(NS + "./w:showingPlcHdr").length > 0));
        }
        return controls;
    }

    private static Kind kind(XmlObject pr) {
        if (pr.selectPath(NS + "./w:dropDownList").length > 0) return Kind.DROP_DOWN;
        if (pr.selectPath(NS + "./w:comboBox").length > 0) return Kind.COMBO_BOX;
        if (pr.selectPath(NS + "./w:date").length > 0) return Kind.DATE;
        if (pr.selectPath(NS + "./w:picture").length > 0) return Kind.PICTURE;
        if (pr.selectPath("declare namespace w14='" + W14 + "'; ./w14:checkbox").length > 0) return Kind.CHECKBOX;
        if (pr.selectPath(NS + "./w:text").length > 0) return Kind.TEXT;
        return Kind.RICH_TEXT;
    }

    /** The machine value: list item value, checkbox state, ISO date; otherwise the displayed text. */
    private static String storedValue(XmlObject pr, String text) {
        for (XmlObject item : pr.selectPath(NS + "./w:dropDownList/w:listItem | ./w:comboBox/w:listItem")) {
            if (text.equals(attr(item, ".", W, "displayText"))) {
                return attr(item, ".", W, "value");
            }
        }
        for (XmlObject checked : pr.selectPath("declare namespace w14='" + W14 + "'; ./w14:checkbox/w14:checked")) {
            String v = attr(checked, ".", W14, "val");
            return String.valueOf("1".equals(v) || "true".equals(v));
        }
        for (XmlObject date : pr.selectPath(NS + "./w:date")) {
            String full = attr(date, ".", W, "fullDate");
            return full == null ? null : OffsetDateTime.parse(full).toLocalDate().toString();
        }
        return text;
    }

    /** Concatenates the w:t text of the content; paragraphs are separated by a newline. */
    private static String text(XmlObject sdt) {
        StringBuilder sb = new StringBuilder();
        for (XmlObject content : sdt.selectPath(NS + "./w:sdtContent")) {
            for (XmlObject t : content.selectPath(NS + ".//w:p | .//w:r/w:t")) {
                try (XmlCursor c = t.newCursor()) {
                    if ("p".equals(c.getName().getLocalPart())) {
                        if (sb.length() > 0) sb.append('\n');
                    } else {
                        sb.append(c.getTextValue());
                    }
                }
            }
        }
        return sb.toString().strip();
    }

    private static String attr(XmlObject parent, String path, String ns, String local) {
        for (XmlObject o : parent.selectPath(NS + path)) {
            try (XmlCursor c = o.newCursor()) {
                String v = c.getAttributeText(new QName(ns, local));
                if (v != null) {
                    return v;
                }
            }
        }
        return null;
    }

    /** Controls with a tag, as a map tag -> control (the last one wins when a tag is repeated). */
    public static Map<String, Control> byTag(List<Control> controls) {
        Map<String, Control> map = new LinkedHashMap<>();
        for (Control c : controls) {
            if (c.tag() != null) {
                map.put(c.tag(), c);
            }
        }
        return map;
    }
}

Control[tag=requester.name, title=Requester name, kind=TEXT, text=Ana Pérez, value=Ana Pérez, placeholder=false]
Control[tag=requester.department, title=null, kind=DROP_DOWN, text=Science, value=SCI, placeholder=false]
Control[tag=request.neededBy, title=null, kind=DATE, text=15/11/2026, value=2026-11-15, placeholder=false]
Control[tag=request.approval, title=null, kind=CHECKBOX, text=☒, value=true, placeholder=false]
Control[tag=request.priority, title=null, kind=TEXT, text=Click to enter a priority, value=Click to enter a priority, placeholder=true]
Control[tag=request.justification, title=Justification, kind=RICH_TEXT, text=Three students need the course reader.
The library holds one copy., ...]

package demo;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.apache.poi.openxml4j.opc.PackagePart;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFPictureData;

/** Extracts embedded images and attachments without trusting any name stored in the file. */
public final class DocxEmbedded {

    public static final int MAX_PART_BYTES = 10 * 1024 * 1024;

    /** What was found; the bytes are only read when a caller asks for them. */
    public record Attachment(String partName, String contentType, long size) {
    }

    private DocxEmbedded() {
    }

    /** Saves every picture as pictureN.ext in a directory chosen by the server. */
    public static List<Path> savePictures(XWPFDocument doc, Path directory) throws IOException {
        List<Path> saved = new ArrayList<>();
        int n = 1;
        for (XWPFPictureData picture : doc.getAllPackagePictures()) {    // every image part, used or not
            String ext = picture.suggestFileExtension();                // from the content type, not the file name
            if (!List.of("png", "jpeg", "gif", "emf", "wmf", "bmp", "tiff").contains(ext)) {
                continue;                                               // skip unknown or active formats
            }
            byte[] data = picture.getData();
            if (data.length > MAX_PART_BYTES) {
                continue;
            }
            Path target = directory.resolve("picture" + n++ + "." + ext);
            Files.write(target, data);
            saved.add(target);
        }
        return saved;
    }

    /** Lists the parts under /word/embeddings (OLE objects, packaged files such as a .xlsx). */
    public static List<Attachment> listAttachments(XWPFDocument doc) throws Exception {
        List<Attachment> found = new ArrayList<>();
        for (PackagePart part : doc.getPackage().getPartsByName(Pattern.compile("/word/embeddings/.*"))) {
            try (InputStream in = part.getInputStream()) {
                byte[] bytes = readLimited(in); // stops above the limit
                found.add(new Attachment(part.getPartName().getName(), part.getContentType(), bytes.length));
            }
        }
        return found;
    }

    /** Bytes of one attachment; the caller decides whether and how to open them. */
    public static byte[] read(XWPFDocument doc, String partName) throws Exception {
        for (PackagePart part : doc.getPackage().getPartsByName(Pattern.compile("/word/embeddings/.*"))) {
            if (part.getPartName().getName().equals(partName)) {
                try (InputStream in = part.getInputStream()) {
                    return readLimited(in);
                }
            }
        }
        throw new IllegalArgumentException("No such attachment: " + partName);
    }

    private static byte[] readLimited(InputStream in) throws IOException {
        byte[] bytes = in.readNBytes(MAX_PART_BYTES + 1);          // one byte more than allowed
        if (bytes.length > MAX_PART_BYTES) {
            throw new IOException("Embedded part is larger than " + MAX_PART_BYTES + " bytes");
        }
        return bytes;
    }
}

[Attachment[partName=/word/embeddings/Microsoft_Excel_Sheet1.xlsx,
            contentType=application/vnd.openxmlformats-officedocument.spreadsheetml.sheet, size=3290]]
[.../picture1.png]
alt=Course reader cover image1.png
image/png

package demo;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.hwpf.model.StyleDescription;
import org.apache.poi.hwpf.usermodel.Paragraph;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.hwpf.usermodel.Table;
import org.apache.poi.hwpf.usermodel.TableRow;

/** Reads the same structures from a legacy .doc with HWPF. */
public final class LegacyDoc {

    private LegacyDoc() {
    }

    /** Tables of the main text as lists of rows of cell strings (the end-of-cell mark is removed). */
    public static List<List<List<String>>> tables(InputStream in) throws IOException {
        try (HWPFDocument doc = new HWPFDocument(in)) {
            List<List<List<String>>> result = new ArrayList<>();
            Range body = doc.getRange();
            int i = 0;
            while (i < body.numParagraphs()) {
                Paragraph paragraph = body.getParagraph(i);
                if (!paragraph.isInTable()) {
                    i++;
                    continue;
                }
                Table table = body.getTable(paragraph);          // the whole table that contains this paragraph
                List<List<String>> rows = new ArrayList<>();
                for (int r = 0; r < table.numRows(); r++) {
                    TableRow row = table.getRow(r);
                    List<String> cells = new ArrayList<>();
                    for (int c = 0; c < row.numCells(); c++) {
                        cells.add(clean(row.getCell(c).text()));
                    }
                    rows.add(cells);
                }
                result.add(rows);
                i += table.numParagraphs();                       // skip the paragraphs of the table
            }
            return result;
        }
    }

    /** Heading texts (built-in "heading N" styles) in document order. */
    public static List<String> headings(InputStream in) throws IOException {
        try (HWPFDocument doc = new HWPFDocument(in)) {
            List<String> headings = new ArrayList<>();
            Range range = doc.getRange();
            for (int i = 0; i < range.numParagraphs(); i++) {
                Paragraph p = range.getParagraph(i);
                StyleDescription style = doc.getStyleSheet().getStyleDescription(p.getStyleIndex());
                if (style != null && style.getName() != null
                        && style.getName().toLowerCase(Locale.ROOT).startsWith("heading")) {
                    headings.add(clean(p.text()));
                }
            }
            return headings;
        }
    }

    /** All the text, paragraph by paragraph, including headers, footers and footnotes. */
    public static String text(InputStream in) throws IOException {
        try (HWPFDocument doc = new HWPFDocument(in); WordExtractor extractor = new WordExtractor(doc)) {
            return extractor.getText();
        }
    }

    private static String clean(String raw) {
        return raw.replace("\u0007", "").replace("\r", "\n").strip();
    }
}

[[[Title, Author, ISBN, Quantity], [The Dispossessed, Ursula K. Le Guin, 9780061054884, 2],
  [The Left Hand of Darkness, , 9780441478125, 1], [Cosmos, Carl Sagan, 9780345539434, x]]]

package demo;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackageAccess;
import org.apache.poi.poifs.filesystem.FileMagic;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFTable;

/** Imports book-request-form.docx (or the legacy .doc) into a BookRequest, collecting every problem. */
public final class WordImporter {

    public record BookLine(int row, String title, String author, String isbn, int quantity) {
    }

    public record Problem(String location, String message) {
    }

    public record BookRequest(String requester, String department, LocalDate neededBy, boolean needsApproval,
                              String justification, List<BookLine> lines) {
    }

    /** Either a request or the list of everything that is wrong with the file. */
    public record Result(BookRequest request, List<Problem> problems) {
        public boolean ok() {
            return problems.isEmpty();
        }
    }

    private WordImporter() {
    }

    public static Result read(Path upload) throws IOException {
        try (InputStream in = new BufferedInputStream(Files.newInputStream(upload))) {
            FileMagic magic = FileMagic.valueOf(in);
            return switch (magic) {
                case OOXML -> readDocx(upload);
                case OLE2 -> readDoc(upload);
                default -> new Result(null, List.of(new Problem("file", "Not a Word document: " + magic)));
            };
        }
    }

    static Result readDocx(Path file) throws IOException {
        try (OPCPackage pkg = OPCPackage.open(file.toFile(), PackageAccess.READ);
             XWPFDocument doc = new XWPFDocument(pkg)) {   // pkg is closed even when the constructor throws
            List<Problem> problems = new ArrayList<>();
            Map<String, ContentControls.Control> form = ContentControls.byTag(ContentControls.read(doc));

            String requester = required(form, "requester.name", problems);
            String department = required(form, "requester.department", problems);
            LocalDate neededBy = null;
            ContentControls.Control date = form.get("request.neededBy");
            if (date == null || date.placeholder() || date.value() == null) {
                problems.add(new Problem("control request.neededBy", "A date is required"));
            } else {
                neededBy = LocalDate.parse(date.value());
                if (neededBy.isBefore(LocalDate.now())) {
                    problems.add(new Problem("control request.neededBy", "The date is in the past"));
                }
            }
            ContentControls.Control approval = form.get("request.approval");
            boolean needsApproval = approval != null && Boolean.parseBoolean(approval.value());
            String justification = required(form, "request.justification", problems);

            List<BookLine> lines = new ArrayList<>();
            List<XWPFTable> tables = doc.getTables();
            if (tables.isEmpty()) {
                problems.add(new Problem("document", "The table of requested books is missing"));
            } else {
                List<Map<String, String>> rows = DocxTables.toRows(tables.get(0));
                for (int i = 0; i < rows.size(); i++) {
                    mapLine(rows.get(i), i + 2, lines, problems);   // row 1 of the table is the header
                }
            }
            BookRequest request = problems.isEmpty()
                    ? new BookRequest(requester, department, neededBy, needsApproval, justification, lines) : null;
            return new Result(request, problems);
        } catch (org.apache.poi.openxml4j.exceptions.InvalidFormatException e) {
            throw new IOException("Invalid .docx", e);
        }
    }

    static Result readDoc(Path file) throws IOException {
        List<Problem> problems = new ArrayList<>();
        List<BookLine> lines = new ArrayList<>();
        try (InputStream in = Files.newInputStream(file)) {
            List<List<List<String>>> tables = LegacyDoc.tables(in);
            if (tables.isEmpty()) {
                problems.add(new Problem("document", "The table of requested books is missing"));
            } else {
                List<List<String>> grid = tables.get(0);
                List<String> header = grid.get(0).stream().map(String::toLowerCase).toList();
                for (int r = 1; r < grid.size(); r++) {
                    Map<String, String> row = new LinkedHashMap<>();
                    for (int c = 0; c < header.size() && c < grid.get(r).size(); c++) {
                        row.put(header.get(c), grid.get(r).get(c));
                    }
                    mapLine(row, r + 1, lines, problems);
                }
            }
        }
        return new Result(problems.isEmpty() ? new BookRequest(null, null, null, false, null, lines) : null, problems);
    }

    private static void mapLine(Map<String, String> row, int tableRow, List<BookLine> lines, List<Problem> problems) {
        String where = "table row " + tableRow;
        String title = row.getOrDefault("title", "");
        String isbn = row.getOrDefault("isbn", "").replace("-", "");
        int quantity = 0;
        if (title.isBlank()) {
            problems.add(new Problem(where, "Title is required"));
        }
        if (!isbn.matches("\\d{13}")) {
            problems.add(new Problem(where, "ISBN must have 13 digits: '" + isbn + "'"));
        }
        try {
            quantity = Integer.parseInt(row.getOrDefault("quantity", ""));
            if (quantity < 1 || quantity > 20) {
                problems.add(new Problem(where, "Quantity must be between 1 and 20"));
            }
        } catch (NumberFormatException e) {
            problems.add(new Problem(where, "Quantity is not a number: '" + row.get("quantity") + "'"));
        }
        lines.add(new BookLine(tableRow, title, row.get("author"), isbn, quantity));
    }

    private static String required(Map<String, ContentControls.Control> form, String tag, List<Problem> problems) {
        ContentControls.Control control = form.get(tag);
        if (control == null) {
            problems.add(new Problem("control " + tag, "The control is missing"));
            return null;
        }
        if (control.placeholder() || control.text().isBlank()) {
            problems.add(new Problem("control " + tag, "A value is required"));
            return null;
        }
        return control.value();
    }
}

package demo;

import java.nio.file.Path;

public final class ImportDemo {

    public static void main(String[] args) throws Exception {
        WordImporter.Result result = WordImporter.read(Path.of(args[0]));
        if (result.ok()) {
            WordImporter.BookRequest request = result.request();
            System.out.println("Accepted request from " + request.requester() + " with "
                    + request.lines().size() + " books");
            request.lines().forEach(line -> System.out.println("  " + line));
        } else {
            System.out.println("Rejected, " + result.problems().size() + " problem(s):");
            result.problems().forEach(p -> System.out.println("  " + p.location() + ": " + p.message()));
        }
    }
}

Accepted request from Ana Pérez with 3 books
  BookLine[row=2, title=The Dispossessed, author=Ursula K. Le Guin, isbn=9780061054884, quantity=2]
  BookLine[row=3, title=The Left Hand of Darkness, author=Ursula K. Le Guin, isbn=9780441478125, quantity=1]
  BookLine[row=4, title=Cosmos, author=Carl Sagan, isbn=9780345539434, quantity=3]
Rejected, 1 problem(s):
  table row 4: Quantity is not a number: 'x'
Rejected, 1 problem(s):
  file: Not a Word document: UNKNOWN
Rejected, 1 problem(s):
  table row 4: Quantity is not a number: 'x'