超简单HTML转PDF工具封装、包含页眉页码水印

FlySky71

于 2024-12-09 09:04:17 发布

阅读量833

点赞数 9

文章标签： html pdf 前端

本文链接：https://blog.csdn.net/qq_31953841/article/details/144337385

版权

说明

采用html2pdf 和 freemarker 将 html模板转为 pdf
做了一些简单的封装、用起来更方便

maven

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
            <version>2.5.6</version>
        </dependency>
        <!-- html 转 pdf -->
        <dependency>
            <groupId>com.itextpdf</groupId>
            <artifactId>html2pdf</artifactId>
            <version>3.0.2</version>
        </dependency>
        <!-- 中文字体支持 -->
        <dependency>
            <groupId>com.itextpdf</groupId>
            <artifactId>font-asian</artifactId>
            <version>7.1.13</version>
        </dependency>

java 工具类

主工具类

import cn.hutool.core.io.FileUtil;
import com.itextpdf.html2pdf.ConverterProperties;
import com.itextpdf.html2pdf.HtmlConverter;
import com.itextpdf.io.font.PdfEncodings;
import com.itextpdf.io.image.ImageDataFactory;
import com.itextpdf.io.source.ByteArrayOutputStream;
import com.itextpdf.kernel.events.PdfDocumentEvent;
import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.font.PdfFontFactory;
import com.itextpdf.kernel.geom.PageSize;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.layout.element.Image;
import com.itextpdf.layout.font.FontProvider;
import freemarker.template.Configuration;
import freemarker.template.Template;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Slf4j
public class HtmlToPdf {
    /**
     * 自定义水印
     */
    private WaterMarkHandler waterMarkHandler;

    /**
     * 页眉显示
     */
    private HeaderHandler headerHandler;

    /**
     * 页脚页码
     */
    private PageHandler pageHandler;

    /**
     * 字体路径
     */
    private String font_path;

    /**
     * html模版路径
     */
    private String html_path;

    /**
     * 模版数据
     */
    private Object object;

    private Configuration configuration;
    private String path = HtmlToPdf.class.getResource("/").getPath();

    /**
     * 创建一个生成对象
     *
     * @param htmlPath html模版路径
     * @return
     */
    public static HtmlToPdf create(String htmlPath) {
        HtmlToPdf htmlToPdf = new HtmlToPdf();
        htmlToPdf.html_path = htmlPath;
        try {
            Configuration configuration = new Configuration(Configuration.VERSION_2_3_23);
            configuration.setDirectoryForTemplateLoading(new File(htmlToPdf.path));
            configuration.setDefaultEncoding("UTF-8");
            htmlToPdf.configuration = configuration;
        } catch (Exception e) {
            log.error("create error", e);
        }
        return htmlToPdf;
    }

    /**
     * 生成pdf文件
     *
     * @param filePath 路径
     */
    public void buildFile(String filePath) {
        try {
            ByteArrayOutputStream build = build(object);
            if (build != null) {
                FileUtil.writeBytes(build.toByteArray(), filePath);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 生成字节流
     *
     * @return
     */
    public byte[] buildByte() {
        try {
            ByteArrayOutputStream build = build(object);
            if (build != null) {
                return build.toByteArray();
            } else {
                return null;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 生成文件下载
     *
     * @param fileName 文件名
     * @return
     */
    public ResponseEntity buildResponse(String fileName) {
        try {
            ByteArrayOutputStream build = build(object);
            if (build != null) {
                byte[] bytes = build.toByteArray();

                return ResponseEntity.ok()
                        .contentType(MediaType.APPLICATION_OCTET_STREAM)
                        .header("Content-disposition", "attachment; filename=" + fileName)
                        .body(bytes);
            } else {
                return null;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public HtmlToPdf setObject(Object object) {
        this.object = object;
        return this;
    }

    public HtmlToPdf setHeaderHandler(HeaderHandler headerHandler) {
        this.headerHandler = headerHandler;
        return this;
    }

    public HtmlToPdf setPageHandler(PageHandler pageHandler) {
        this.pageHandler = pageHandler;
        return this;
    }

    public HtmlToPdf setWaterMarkHandler(WaterMarkHandler waterMarkHandler) {
        this.waterMarkHandler = waterMarkHandler;
        return this;
    }

    public HtmlToPdf setFontPath(String font_path) {
        this.font_path = this.path + font_path;
        return this;
    }

    public Image getImageUrl(String imgUrl, float width, float height, float left, float top) {
        URL url = null;
        try {
            url = new URL(imgUrl);
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
        Image logo = new Image(ImageDataFactory.create(url));
        logo.scaleAbsolute(width, height);
        logo.setMarginLeft(left);
        logo.setMarginTop(top);
        return logo;
    }


    private ByteArrayOutputStream build(Object obj) throws Exception {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        PdfWriter pdfWriter = new PdfWriter(outputStream);
        PdfDocument pdfDocument = new PdfDocument(pdfWriter);

        // 设置为 A4 大小
        pdfDocument.setDefaultPageSize(PageSize.A4);

        ConverterProperties properties = null;
        // 添加自定义字体, 例如宋体
        if (font_path != null && !font_path.isEmpty()) {
            // 添加中文字体支持
            properties = new ConverterProperties();
            FontProvider fontProvider = new FontProvider();
            String fontPath = font_path + ",0";
            PdfFont microsoft = PdfFontFactory.createFont(fontPath, PdfEncodings.IDENTITY_H, false);
            fontProvider.addFont(microsoft.getFontProgram(), PdfEncodings.IDENTITY_H);
            properties.setFontProvider(fontProvider);

            if (headerHandler != null) {
                if (headerHandler.getHeader_title_font() == null) {
                    headerHandler.setHeader_title_font(microsoft);
                }
                if (headerHandler.getLog_str_font() == null) {
                    headerHandler.setLog_str_font(microsoft);
                }
            }
            if (waterMarkHandler != null && waterMarkHandler.getFont() == null) {
                waterMarkHandler.setFont(microsoft);
            }
            if (pageHandler != null && pageHandler.getFont() == null) {
                pageHandler.setFont(microsoft);
            }
        }

        // 添加页眉
        if (headerHandler != null) {
            pdfDocument.addEventHandler(PdfDocumentEvent.START_PAGE, headerHandler);
        }

        // 添加水印
        if (waterMarkHandler != null) {
            pdfDocument.addEventHandler(PdfDocumentEvent.INSERT_PAGE, waterMarkHandler);
        }

        // 添加页码
        if (pageHandler != null) {
            pdfDocument.addEventHandler(PdfDocumentEvent.END_PAGE, pageHandler);
        }


        InputStream inputStream = analyzeHtml(this.html_path, obj);
        if (inputStream != null) {
            if (properties == null) {
                HtmlConverter.convertToPdf(inputStream, pdfDocument);
            } else {
                HtmlConverter.convertToPdf(inputStream, pdfDocument, properties);
            }
            pdfWriter.close();
            pdfDocument.close();

            return outputStream;
        } else {
            return null;
        }
    }

    /**
     * 读取 HTML 流文件，并查询当中的 &nbsp; 或类似符号，并将其替换为空格
     */
    private InputStream analyzeHtml(String html_path, Object obj) throws Exception {
        Template template = configuration.getTemplate(html_path);
        StringWriter writer = new StringWriter();
        template.process(obj, writer);

        String content = writer.toString();

        // 6. 判断 HTML 内容是否具有 HTML 的特殊字符标记
        Pattern compile = Pattern.compile("&[a-zA-Z]{1,10};", Pattern.CASE_INSENSITIVE);
        Matcher matcher = compile.matcher(content);
        String replaceAll = matcher.replaceAll("");

        if (replaceAll != null && !replaceAll.trim().isEmpty()) {
            return new ByteArrayInputStream(replaceAll.getBytes());
        } else {
            return null;
        }
    }

}

页眉 HeaderHandler

import cn.hutool.core.util.StrUtil;
import com.itextpdf.kernel.events.Event;
import com.itextpdf.kernel.events.IEventHandler;
import com.itextpdf.kernel.events.PdfDocumentEvent;
import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.geom.Rectangle;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfPage;
import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
import com.itextpdf.layout.Canvas;
import com.itextpdf.layout.element.Image;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.layout.property.TextAlignment;
import lombok.Data;

/**
 * 生成 pdf 页眉
 */
@Data
public class HeaderHandler implements IEventHandler {

    /**
     * 页眉显示
     */
    private String header_title;

    private Integer header_title_size = 12;

    private PdfFont header_title_font;

    private TextAlignment header_title_align = TextAlignment.RIGHT;

    /**
     * 页眉logo 图片地址
     */
    private Image logo;

    /**
     * 页眉logo
     */
    private String logo_str;

    private Integer logo_str_size = 12;

    private PdfFont log_str_font;

    private TextAlignment logo_str_align = TextAlignment.LEFT;

    private HeaderHandler() {

    }

    public HeaderHandler(String title) {
        this.header_title = title;
    }

    public HeaderHandler(String title, String logo_str) {
        this.header_title = title;
        this.logo_str = logo_str;
    }

    public HeaderHandler(String title, Image logo) {
        this.header_title = title;
        this.logo = logo;
    }


    @Override
    public void handleEvent(Event event) {
        PdfDocumentEvent docEvent = (PdfDocumentEvent) event;
        PdfDocument pdf = docEvent.getDocument();
        PdfPage page = docEvent.getPage();
        Rectangle pageSize = page.getPageSize();
        PdfCanvas pdfCanvas = new PdfCanvas(page.getLastContentStream(), page.getResources(), pdf);
        Canvas canvas = new Canvas(pdfCanvas, pageSize);
        float x = pageSize.getRight() - 60;
        float y = pageSize.getTop() - 32;

        // header
        Paragraph paragraph = new Paragraph(header_title);
        paragraph.setFontSize(header_title_size);
        if (header_title_font != null) {
            paragraph.setFont(header_title_font);
        }
        canvas.showTextAligned(paragraph, x, y, header_title_align);

        if (logo != null) {
            canvas.add(logo);
        } else if (StrUtil.isNotBlank(logo_str)) {
            // log_str
            Paragraph pLog = new Paragraph(logo_str);
            pLog.setFontSize(logo_str_size);
            if (log_str_font != null) {
                pLog.setFont(log_str_font);
            }
            canvas.showTextAligned(pLog, x, y, logo_str_align);
        }
        canvas.close();
    }
}

页码

import com.itextpdf.kernel.events.Event;
import com.itextpdf.kernel.events.IEventHandler;
import com.itextpdf.kernel.events.PdfDocumentEvent;
import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.geom.Rectangle;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfPage;
import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
import com.itextpdf.layout.Canvas;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.layout.property.TextAlignment;
import lombok.Data;

/**
 * 生成 pdf 页码
 */
@Data
public class PageHandler implements IEventHandler {

    private PdfFont font;

    private final TextAlignment page_align = TextAlignment.CENTER;

    public PageHandler() {
    }

    @Override
    public void handleEvent(Event event) {
        PdfDocumentEvent documentEvent = (PdfDocumentEvent) event;
        PdfDocument document = documentEvent.getDocument();
        PdfPage page = documentEvent.getPage();
        Rectangle pageSize = page.getPageSize();
        PdfCanvas pdfCanvas = new PdfCanvas(page.getLastContentStream(), page.getResources(), document);
        Canvas canvas = new Canvas(pdfCanvas, pageSize);
        float x = (pageSize.getLeft() + pageSize.getRight()) / 2;
        float y = pageSize.getBottom() + 15;

        String pageStr = "第" + document.getPageNumber(page) + "页/共" + document.getNumberOfPages() + "页";

        Paragraph paragraph = new Paragraph(pageStr);
        paragraph.setFontSize(10);
        if (font != null) {
            paragraph.setFont(font);
        }
        canvas.showTextAligned(paragraph, x, y, page_align);

        canvas.close();
    }
}

水印


import com.itextpdf.kernel.colors.Color;
import com.itextpdf.kernel.colors.WebColors;
import com.itextpdf.kernel.events.Event;
import com.itextpdf.kernel.events.IEventHandler;
import com.itextpdf.kernel.events.PdfDocumentEvent;
import com.itextpdf.kernel.font.PdfFont;
import com.itextpdf.kernel.geom.Rectangle;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfPage;
import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
import com.itextpdf.layout.Canvas;
import com.itextpdf.layout.element.Paragraph;
import com.itextpdf.layout.property.TextAlignment;
import com.itextpdf.layout.property.VerticalAlignment;
import lombok.Data;

/**
 * 生成 pdf 水印
 */
@Data
public class WaterMarkHandler implements IEventHandler {

    /**
     * 水印内容
     */
    private String content;

    /**
     * 一页中有几列水印
     */
    private int x = 6;

    /**
     * 一页中每列有多少水印
     */
    private int y = 6;

    /**
     * 字体
     */
    private PdfFont font;

    /**
     * 字体颜色
     */
    private final Color font_color = WebColors.getRGBColor("lightgray");

    /**
     * 字体大小
     */
    private final Integer font_size = 16;

    public WaterMarkHandler() {

    }

    public WaterMarkHandler(String content) {
        this.content = content;
    }

    @Override
    public void handleEvent(Event event) {
        PdfDocumentEvent documentEvent = (PdfDocumentEvent) event;
        PdfDocument document = documentEvent.getDocument();
        PdfPage page = documentEvent.getPage();
        Rectangle pageSize = page.getPageSize();

        PdfCanvas pdfCanvas = new PdfCanvas(page.newContentStreamAfter(), page.getResources(), document);
        Paragraph waterMark = new Paragraph(content).setOpacity(0.5f);
        Canvas canvas = new Canvas(pdfCanvas, pageSize);
        canvas.setFontColor(font_color);
        canvas.setFontSize(font_size);
        if (font != null) {
            canvas.setFont(font);
        }

        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                canvas.showTextAligned(
                        waterMark,
                        (150 + i * 300),
                        (160 + j * 150),
                        document.getNumberOfPages(),
                        TextAlignment.CENTER,
                        VerticalAlignment.BOTTOM,
                        120);
            }
        }
        canvas.close();
    }
}

用法

    @PostMapping("/getPdf")
    public ResponseEntity getPdf(@RequestParam String id) {
        HashMap<String, String> map = new HashMap<>();
        map.put("deviceModel", "张三");
        map.put("deviceName", "张三");

        return HtmlToPdf.create("pdf/test.html.ftl")
                .setFontPath("font/simsun.ttc")
                .setObject(map)
                .buildResponse("test.pdf");
    }

font 和 pdf 放在 resources 目录下

font 所在目录
html 模版使用 freemarker 语法

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试标题</title>
</head>
<body>
<div>
    <h2>设备测试报告</h2>

    <table>
        <tr style="">
            <th style="width: 14%"></th>
            <th style="width: 22%"></th>
            <th style="width: 14%"></th>
            <th style="width: 14%"></th>
            <th style="width: 36%"></th>
        </tr>
        <tr>
            <td>设备名称</td>
            <td colspan="2">${deviceName}</td>
            <td>设备厂家</td>
            <td>${deviceModel}</td>
        </tr>
        <tr>
            <td>设备编码</td>
            <td colspan="2">${deviceName}</td>
            <td>测试时间</td>
            <td>${deviceModel}</td>
        </tr>
        <tr>
            <td>测试人</td>
            <td colspan="2">${deviceName}</td>
            <td>验证人</td>
            <td>${deviceModel}</td>
        </tr>
        <tr>
            <td rowspan="2">功能项</td>
            <td>测试项</td>
            <td>结果</td>
            <td>错误通道数</td>
            <td>备注</td>
        </tr>
        <tr>
            <td>供电</td>
            <td>结果</td>
            <td>错误通道数</td>
            <td>备注</td>
        </tr>
        <tr>
            <td>测试结论</td>
            <td colspan="4"></td>
        </tr>
    </table>
</div>
</body>
<style>
    * {
        margin: 0;
        padding: 0;
    }

    html, body {
        height: 297mm;
        width: 210mm;
    }

    h2 {
        text-align: center;
    }

    table {
        width: 80%;
        margin: auto;
        border-collapse: collapse;
        border-style: solid;
        border-width: 1px;
        font-size: 12px;
    }
    th {
        border: none;
    }
    td {
        border-style: solid;
        border-width: 1px;
        text-align: center;
    }
</style>
</html>

vue3 使用

 return axios({
        url: '/api/' + baseUrl + "/getPdf",
        params: params,
        method: 'post',
        responseType: 'blob',
        headers: {
            'Content-Type': 'application/octet-stream',
            'Authorization': localStorage.getItem('token')
        },
        onDownloadProgress: (ProgressEvent) => {//用来计算下载量（实际项目中可以用来显示下载进度）
            let load = ProgressEvent.loaded;
            console.log(load)
        }
    })

getPdf({id: row.id}).then(res => {
    let header = res.headers['content-disposition'];
    const fileName = decodeURI(header.substring(header.indexOf("=") + 1));
    const downloadElement = document.createElement("a");
    const href = window.URL.createObjectURL(res.data);
    downloadElement.href = href;
    downloadElement.download = decodeURIComponent(fileName);
    document.body.appendChild(downloadElement);
    downloadElement.click();
    document.body.removeChild(downloadElement);
    window.URL.revokeObjectURL(href);

  }).catch(err => {
    ElMessage.error('操作失败！')
  })