Poi-tl根据模板导出Word文件（类似于驾驶证，身份证）

Poi-tl官网：Poi-tl Documentation

最近又碰上了导出，真的服了，还是低代码的导出，其中过程的曲折真的是一言难尽..........平台各种适配，依赖冲突，真的是崩溃.......

简单说一下为什么使用Poi-tl，最开始想用的是poi实现，但是结果就是poi不好控制图片的位置，因为图片插入之后是“浮于文字上方”，单纯的插入图片会占行数，为了方便控制格式后续就采用了poi-tl但是他同样也不支持插入图片之后将图片设置为“浮于文字上方”，也是找了一些博客参考，最终实现了想要的效果

参考博客：poi-tl导出word实现图片环绕方式为浮于在文字上方办法_picturerenderpolicy-CSDN博客

老样子上效果图：

实现步骤：

1.准备模板

2.添加依赖

        <dependency>
            <groupId>com.deepoove</groupId>
            <artifactId>poi-tl</artifactId>
            <version>1.10.0-beta</version>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>5.2.3</version>
        </dependency>

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

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>4.1.2</version>
        </dependency>

3.代码实现

package com.example.demo;

import cn.hutool.core.util.URLUtil;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.deepoove.poi.config.ConfigureBuilder;
import com.deepoove.poi.data.PictureRenderData;
import com.deepoove.poi.data.Pictures;
import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;
import com.example.controller.MyPictureRenderPolicy;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class StudentCardExporter001 {

    public static void main(String[] args) {
        // 创建数据映射列表
        List<Map<String, Object>> sectionList = new ArrayList<>();
        HashMap<String, Object> sectionMap = new HashMap<>();
        sectionMap.put("zhenghao", "AS011");
        sectionMap.put("chexing", "C2");
        sectionMap.put("username", "杨无敌");
        sectionMap.put("sex", "男");
        sectionMap.put("birthday", "1983-12-06");
        sectionMap.put("deptname", "北京XXXXXXX");
        sectionMap.put("date", "2025-12-09");
        sectionMap.put("localPicture",  Pictures.ofLocal( "D:\\xiazai\\1212.jpg").size(45, 65).create());


        sectionList.add(sectionMap);

        // 这里可以设置多条数据
        /*sectionMap.put("zhenghao", "AS011");
        sectionMap.put("chexing", "C2");
        sectionMap.put("username", "光头强");
        sectionMap.put("sex", "男");
        sectionMap.put("birthday", "1983-12-06");
        sectionMap.put("deptname", "北京XXXXXXX");
        sectionMap.put("date", "2025-12-09");
        sectionMap.put("localPicture",  Pictures.ofLocal( "D:\\xiazai\\1212.jpg").size(45, 65).create());
        sectionList.add(sectionMap);*/

        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("sectionName", sectionList);
        ArrayList<Object> titleList = new ArrayList<>();
        // 创建最终的数据映射
        for (int i = 0; i < 2; i++) {


            HashMap<String, Object> titleMap = new HashMap<>();
            titleMap.put("oneTitle", "                          1、驾驶车辆必须携带此证，以备检查。");
            titleMap.put("tweTitle", "                          2、持证人必须遵守本公司车辆管理规定及《中华\n" +
                    "                             人民共和国道路交通安全法》。");
            titleMap.put("threeTitle", "                          3、遗失此证必须及时报告发证单位。");
            titleMap.put("fourTitle", "                          4、此证不得伪造、涂改，不得转借他人；一经发\n" +
                    "                             现，立即取消其本人准驾资格并收回其此证。\n");

            titleList.add(titleMap);
        }
        paramMap.put("attention", titleList);
        // 加载模板文件
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            org.springframework.core.io.Resource[] resources = resolver.getResources("classpath:excelTemplate/model1.docx");
            if (resources.length == 0) {
                throw new IOException("Template file not found.");
            }
            InputStream inputStream = resources[0].getInputStream();

            ConfigureBuilder builder = Configure.builder();
            builder.addPlugin('%', new MyPictureRenderPolicy());

            // 编译并渲染模板
            XWPFTemplate template = XWPFTemplate.compile(inputStream, builder.build()).render(paramMap);
//            XWPFTemplate compile = XWPFTemplate.compile(inputStream, builder.build()).render(paramMap);

            // 输出生成的文档
            try (FileOutputStream out = new FileOutputStream("D:\\xiazai\\1209.docx")) {
                template.write(out);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 3.1自定义MyPictureRenderPolicy

package com.example.controller;

import com.deepoove.poi.data.PictureRenderData;
import com.deepoove.poi.data.PictureType;
import com.deepoove.poi.data.Pictures;
import com.deepoove.poi.data.style.PictureStyle;
import com.deepoove.poi.exception.RenderException;
import com.deepoove.poi.policy.AbstractRenderPolicy;
import com.deepoove.poi.render.RenderContext;
import com.deepoove.poi.util.BufferedImageUtils;
import com.deepoove.poi.util.SVGConvertor;
import com.deepoove.poi.util.UnitUtils;
import com.deepoove.poi.xwpf.BodyContainer;
import com.deepoove.poi.xwpf.BodyContainerFactory;
import com.deepoove.poi.xwpf.WidthScalePattern;
import com.deepoove.poi.xwpf.XWPFRunWrapper;
import com.example.demo.ExportUtil;
import org.apache.poi.util.Units;
import org.apache.poi.xwpf.usermodel.IBodyElement;
import org.apache.poi.xwpf.usermodel.ParagraphAlignment;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.openxmlformats.schemas.drawingml.x2006.main.CTGraphicalObject;
import org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.CTAnchor;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDrawing;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.function.Supplier;

public class MyPictureRenderPolicy extends AbstractRenderPolicy<Object> {

    @Override
    protected boolean validate(Object data) {
        if (null == data) {
            return false;
        } else if (data instanceof PictureRenderData) {
            return null != ((PictureRenderData) data).getPictureSupplier();
        } else {
            return true;
        }
    }

    @Override
    public void doRender(RenderContext<Object> context) throws Exception {
        MyPictureRenderPolicy.Helper.renderPicture(context.getRun(), wrapper(context.getData()));
    }

    @Override
    protected void afterRender(RenderContext<Object> context) {
        this.clearPlaceholder(context, false);
    }

    @Override
    protected void reThrowException(RenderContext<Object> context, Exception e) {
        this.logger.info("Render picture " + context.getEleTemplate() + " error: {}", e.getMessage());
        String alt = "";
        if (context.getData() instanceof PictureRenderData) {
            alt = ((PictureRenderData) context.getData()).getAltMeta();
        }

        context.getRun().setText(alt, 0);
    }

    private static PictureRenderData wrapper(Object object) {
        return object instanceof PictureRenderData ? (PictureRenderData) object : Pictures.of(object.toString()).fitSize().create();
    }


    public static class Helper {
        public static void renderPicture(XWPFRun run, PictureRenderData picture) throws Exception {
            Supplier<byte[]> supplier = picture.getPictureSupplier();
            byte[] imageBytes = (byte[]) supplier.get();
            if (null == imageBytes) {
                throw new IllegalStateException("Can't read picture byte arrays!");
            } else {
                PictureType pictureType = picture.getPictureType();
                if (null == pictureType) {
                    pictureType = PictureType.suggestFileType(imageBytes);
                }

                if (null == pictureType) {
                    throw new RenderException("PictureRenderData must set picture type!");
                } else {
                    PictureStyle style = picture.getPictureStyle();
                    if (null == style) {
                        style = new PictureStyle();
                    }

                    int width = style.getWidth();
                    int height = style.getHeight();
                    if (pictureType == PictureType.SVG) {
                        imageBytes = SVGConvertor.toPng(imageBytes, (float) width, (float) height);
                        pictureType = PictureType.PNG;
                    }

                    if (!isSetSize(style)) {
                        BufferedImage original = BufferedImageUtils.readBufferedImage(imageBytes);
                        width = original.getWidth();
                        height = original.getHeight();
                        if (style.getScalePattern() == WidthScalePattern.FIT) {
                            BodyContainer bodyContainer = BodyContainerFactory.getBodyContainer(((IBodyElement) run.getParent()).getBody());
                            int pageWidth = UnitUtils.twips2Pixel(bodyContainer.elementPageWidth((IBodyElement) run.getParent()));
                            if (width > pageWidth) {
                                double ratio = (double) pageWidth / (double) width;
                                width = pageWidth;
                                height = (int) ((double) height * ratio);
                            }
                        }
                    }

                    InputStream stream = new ByteArrayInputStream(imageBytes);
                    Throwable var25 = null;

                    try {
                        PictureStyle.PictureAlign align = style.getAlign();
                        if (null != align && run.getParent() instanceof XWPFParagraph) {
                            ((XWPFParagraph) run.getParent()).setAlignment(ParagraphAlignment.valueOf(align.ordinal() + 1));
                        }

                        XWPFRunWrapper wrapper = new XWPFRunWrapper(run, false);
                        wrapper.addPicture(stream, pictureType.type(), "Generated", Units.pixelToEMU(width), Units.pixelToEMU(height));

                        CTDrawing drawing = run.getCTR().getDrawingArray(0);
                        CTGraphicalObject graphicalobject = drawing.getInlineArray(0).getGraphic();
                        //拿到新插入的图片替换添加CTAnchor 设置浮动属性 删除inline属性
                        CTAnchor anchor = ExportUtil.getAnchorWithGraphic(graphicalobject, "Generated",
                                Units.toEMU(width), Units.toEMU(height),//图片大小
                                Units.toEMU(180), Units.toEMU(-60), false);//相对当前段落位置 需要计算段落已有内容的左偏移

                        drawing.setAnchorArray(new CTAnchor[]{anchor});//添加浮动属性
                        drawing.removeInline(0);//删除行内属性
                    } catch (Throwable var20) {
                        var25 = var20;
                        throw var20;
                    } finally {
                        if (stream != null) {
                            if (var25 != null) {
                                try {
                                    stream.close();
                                } catch (Throwable var19) {
                                    var25.addSuppressed(var19);
                                }
                            } else {
                                stream.close();
                            }
                        }

                    }

                }
            }
        }

    }

    private static boolean isSetSize(PictureStyle style) {
        return (style.getWidth() != 0 || style.getHeight() != 0) && style.getScalePattern() == WidthScalePattern.NONE;
    }

}

3.2图片处理

package com.example.demo;

import org.apache.xmlbeans.XmlException;
import org.openxmlformats.schemas.drawingml.x2006.main.CTGraphicalObject;
import org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.CTAnchor;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDrawing;

import java.math.BigInteger;

public class ExportUtil {


    /**
     * @param ctGraphicalObject 图片数据
     * @param deskFileName      图片描述
     * @param width             宽
     * @param height            高
     * @param leftOffset        水平偏移 left
     * @param topOffset         垂直偏移 top
     * @param behind            文字上方，文字下方
     * @return
     * @throws Exception
     */
    public static CTAnchor getAnchorWithGraphic(CTGraphicalObject ctGraphicalObject,
                                                String deskFileName, int width, int height,
                                                int leftOffset, int topOffset, boolean behind) {
        String anchorXML =
                "<wp:anchor xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" "
                        + "simplePos=\"0\" relativeHeight=\"0\" behindDoc=\"" + ((behind) ? 1 : 0) + "\" locked=\"0\" layoutInCell=\"1\" allowOverlap=\"1\">"
                        + "<wp:simplePos x=\"0\" y=\"0\"/>"
                        + "<wp:positionH relativeFrom=\"character\">"
                        + "<wp:posOffset>" + leftOffset + "</wp:posOffset>"
                        + "</wp:positionH>"
                        + "<wp:positionV relativeFrom=\"paragraph\">"
                        + "<wp:posOffset>" + topOffset + "</wp:posOffset>"
                        + "</wp:positionV>"
                        + "<wp:extent cx=\"" + width + "\" cy=\"" + height + "\"/>"
                        + "<wp:effectExtent l=\"0\" t=\"0\" r=\"0\" b=\"0\"/>"
                        + "<wp:wrapNone/>"
                        + "<wp:docPr id=\"1\" name=\"Drawing 0\" descr=\"" + deskFileName + "\"/><wp:cNvGraphicFramePr/>"
                        + "</wp:anchor>";

        CTDrawing drawing = null;
        try {
            drawing = CTDrawing.Factory.parse(anchorXML);
        } catch (XmlException e) {
            e.printStackTrace();
        }
        CTAnchor anchor = drawing.getAnchorArray(0);
        anchor.setGraphic(ctGraphicalObject);

        // 减少左偏移量以使图片更靠前
        leftOffset = Math.max(0, leftOffset - 500); // 根据需要调整减去的值

        anchor.getPositionH().setPosOffset(leftOffset);
        anchor.getPositionV().setPosOffset(topOffset);

        return anchor;
    }


}