Java构建静态html片段工具类

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量275 收藏
点赞数
文章标签： java html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50723472/article/details/127606540
版权 
package cn.wangjiahang.record.util.html;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.text.StrPool;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.StrUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;

/**
 * Created on 2022/10/23.
 *
 * @author jh.wang
 */
public class HtmlUtil implements StrPool {
    private static final String startTag = "startTag";
    private static final String aloneTagContent = "aloneTagContent";
    private static final String style = "style";
    private static final String clazz = "class";
    private static final String content = "content";
    private static final String extra = "extra";

    //---------------------------------
    public static HtmlStyle style() {
        return new HtmlStyle(MapUtil.newHashMap());
    }
    //---------------------------------


    public static class HtmlTag {
        private final String tag;
        private String template;

        public HtmlTag(boolean nonStyle, String htmlOrTag) {
            this.tag = htmlOrTag;
            this.template = nonStyle ? htmlOrTag : tagTemplate(htmlOrTag, null, false);
        }

        public HtmlTag(String tag) {
            this.tag = tag;
            this.template = tagTemplate(tag, null, false);
        }

        public HtmlTag(String tag, String extra) {
            this.tag = tag;
            this.template = tagTemplate(tag, extra, false);
        }

        public HtmlTag(String tag, boolean aloneTag) {
            this.tag = tag;
            this.template = tagTemplate(tag, null, aloneTag);
        }

        public HtmlTag(String tag, String extra, boolean aloneTag) {
            this.tag = tag;
            this.template = tagTemplate(tag, extra, aloneTag);
        }

        private static String tagTemplate(String tag, String extra, boolean aloneTag) {
            // <{startTag} style='{style}' class='{class}' {extra}{aloneTagContent}
            return StrUtil.format("<{startTag} style='{style}' class='{class}' {extra}{aloneTagContent}",
                    MapUtil.builder(HtmlUtil.startTag, tag)
                            .put(HtmlUtil.extra, extra)
                            .put(HtmlUtil.aloneTagContent, aloneTag ? "/>" : String.format(">{content}</%s>", tag))
                            .build(),
                    false);
        }

        public HtmlTag appendContent(HtmlTag htmlTag) {
            return appendContent(htmlTag.build());
        }

        public HtmlTag appendContent(String customTag, Consumer<HtmlTag> htmlTag) {
            final HtmlTag custom = HtmlUtil.custom(customTag);
            htmlTag.accept(custom);
            return appendContent(custom);
        }

        public HtmlTag appendContent(String customTag, String customExtra, Consumer<HtmlTag> htmlTag) {
            final HtmlTag custom = HtmlUtil.custom(customTag, customExtra);
            htmlTag.accept(custom);
            return appendContent(custom);
        }

        public HtmlTag appendContent(String content) {
            this.template = StrUtil.format(this.template, MapUtil.builder(HtmlUtil.content, content + String.format("{%s}", HtmlUtil.content)).build());
            return this;
        }

        public String content(HtmlTag htmlTag) {
            return content(htmlTag.ignore());
        }

        public String content(String customTag, Consumer<HtmlTag> htmlTag) {
            final HtmlTag custom = HtmlUtil.custom(customTag);
            htmlTag.accept(custom);
            return content(custom);
        }

        public String content(String customTag, String customExtra, Consumer<HtmlTag> htmlTag) {
            final HtmlTag custom = HtmlUtil.custom(customTag, customExtra);
            htmlTag.accept(custom);
            return content(custom);
        }


        public String content(String content) {
            this.template = StrUtil.format(this.template, MapUtil.builder(HtmlUtil.content, content).build());
            return build();
        }

        public HtmlTag style(String style) {
            this.template = StrUtil.format(this.template, MapUtil.builder(HtmlUtil.style, style).build());
            return this;
        }

        public HtmlTag style(HtmlStyle htmlStyle) {
            return style(htmlStyle.build());
        }

        public HtmlTag style(Consumer<HtmlStyle> htmlTag) {
            final HtmlStyle htmlStyle = HtmlUtil.style();
            htmlTag.accept(htmlStyle);
            return style(htmlStyle);
        }

        public HtmlTag style(String name, String value) {
            return style(MapUtil.builder(name, value).build());
        }

        public HtmlTag style(Map<String, String> mapStyle) {
            return style(MapUtil.joinIgnoreNull(mapStyle, ";", ": "));
        }

        public HtmlTag clazz(String... clazz) {
            this.template = StrUtil.format(this.template, MapUtil.builder(HtmlUtil.clazz, CollUtil.join(Convert.toList(String.class, clazz), " ")).build());
            return this;
        }

        public HtmlTag clazz(List<String> clazzs) {
            return clazz(CollUtil.join(clazzs, " "));
        }

        public HtmlTag extraTag(String extraTag, String value) {
            return this.extraTag(MapUtil.builder(extraTag, value).build());
        }

        public HtmlTag extraTag(Map<String, String> value) {
            for (Map.Entry<String, String> entry : value.entrySet()) {
                entry.setValue(String.format("%s=\"%s\"", entry.getKey(), entry.getValue()));
            }
            this.template = StrUtil.format(this.template, value);
            return this;
        }

        public HtmlTag extraTag(Consumer<Map<String, String>> htmlTag) {
            final HashMap<String, String> map = MapUtil.newHashMap();
            htmlTag.accept(map);
            return extraTag(map);
        }

        private String ignore() {
            String temp = this.template.replaceAll(" style='\\{style}'", "").replaceAll(" class='\\{class}'", "");
            return ReUtil.replaceAll(temp, String.format("<%s.*?>", this.tag), str -> ReUtil.replaceAll(str.group(0), "(\\{[^\\}]+\\})", ""));
        }

        public String build() {
            return ignore().replaceAll("\\{content}", "");
        }
    }


    public static class HtmlStyle {
        private final Map<String, String> styles;

        private HtmlStyle(Map<String, String> styles) {
            this.styles = styles;
        }

        public HtmlStyle append(String name, String value) {
            styles.put(name, value);
            return this;
        }

        public String build() {
            return MapUtil.joinIgnoreNull(styles, ";", ": ");
        }
    }


    //---------------------------------

    public static HtmlTag custom(String tag) {
        return new HtmlTag(tag);
    }

    public static HtmlTag custom(String tag, String extra) {
        return new HtmlTag(tag, extra);
    }

    public static HtmlTag custom(String tag, boolean aloneTag) {
        return new HtmlTag(tag, aloneTag);
    }

    public static HtmlTag custom(String tag, String extra, boolean aloneTag) {
        return new HtmlTag(tag, extra, aloneTag);
    }

    public static HtmlTag custom(boolean nonStyle, String html, int repeatCount) {
        return new HtmlTag(nonStyle, StrUtil.repeat(html, repeatCount));
    }

    public static HtmlTag div() {
        return custom("div");
    }

    public static HtmlTag span() {
        return custom("span");
    }

    public static HtmlTag p() {
        return custom("p");
    }

    public static HtmlTag img() {
        return custom("img", "{src} {alt} {width}", true);
    }

    public static HtmlTag H(int level) {
        return custom(String.format("h%s", level));
    }

    public static HtmlTag br() {
        return br(0);
    }

    public static HtmlTag br(int count) {
        return custom(true, "<br>", count);
    }

    public static HtmlTag hr() {
        return br(0);
    }

    public static HtmlTag hr(int count) {
        return custom(true, "<hr>", count);
    }

    public static HtmlTag i() {
        return custom("i");
    }

    public static HtmlTag a() {
        return custom("a", "{href}");
    }

    public static HtmlTag table() {
        return custom("table", "{width} {align} {height} {border}", false);
    }

    public static HtmlTag thead() {
        return custom("thead");
    }

    public static HtmlTag tfoot() {
        return custom("tfoot");
    }

    public static HtmlTag tbody() {
        return custom("tbody");
    }

    public static HtmlTag tr() {
        return custom("tr");
    }

    public static HtmlTag th() {
        return custom("th");
    }

    public static HtmlTag td() {
        return custom("td");
    }

    public static HtmlTag ul() {
        return custom("ul");
    }

    public static HtmlTag ol() {
        return custom("ol");
    }

    public static HtmlTag dl() {
        return custom("dl");
    }

    public static HtmlTag li() {
        return custom("li");
    }
}

测试类

package cn.wangjiahang.record.util.html;

import cn.hutool.core.date.StopWatch;
import cn.hutool.core.lang.Console;
import org.junit.Test;

/**
 * @author jh.wang
 * @since 2022/10/30
 */
public class HtmlTest {
    @Test
    public void htmlBuildTest() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("测试1");

        final String build1 = HtmlUtil.custom("div").clazz("container", "kkk").style(HtmlUtil.style().append("color", "red")).build();
        stopWatch.stop();
        Console.log("{} 耗时:{} 内容:{}", stopWatch.getLastTaskName(), stopWatch.getTotalTimeMillis(), build1);


        stopWatch.start("测试2");
        final String build2 = HtmlUtil.div().style("position", "relative").appendContent(HtmlUtil.div().style("position: absolute; top: 0;right: 20;")).build();
        stopWatch.stop();
        Console.log("{} 耗时:{} 内容:{}", stopWatch.getLastTaskName(), stopWatch.getTotalTimeMillis(), build2);


        stopWatch.start("测试3");
        final String build3 = HtmlUtil.custom("div","{uu} {uu3}")
                .style(htmlStyle -> {
                    htmlStyle.append("yy", "90").append("ll", "99");
                }).extraTag(val -> {
                    val.put("uu", "88");
                    val.put("uu3", "88");
                }).appendContent("div", "{src}", tag -> {
                    tag.extraTag("src", "http:xxx/de/de12").content("p", inner1 -> {
                        inner1.clazz("aaaa").appendContent("a", "{alt} {src}", inner2 -> {
                            inner2.extraTag("src", "111")
                                    .extraTag("alt", "点击跳转")
                                    .style(style -> style.append("color", "#666"));
                        });
                    });
                })
                .content("来来来来来绿绿绿绿绿绿绿绿绿绿绿绿绿");
        stopWatch.stop();
        Console.log("{} 耗时:{} 内容:{}", stopWatch.getLastTaskName(), stopWatch.getTotalTimeMillis(), build3);


        stopWatch.start("测试4");
        for (int i = 0; i < 100; i++) {
            HtmlUtil.custom("div","{uu} {uu3}")
                    .style(htmlStyle -> {
                        htmlStyle.append("yy", "90").append("ll", "99");
                    }).extraTag(val -> {
                        val.put("uu", "88");
                        val.put("uu3", "88");
                    }).appendContent("div", "{src}", tag -> {
                        tag.extraTag("src", "http:xxx/de/de12").content("p", inner1 -> {
                            inner1.clazz("aaaa").appendContent("a", "{alt} {src}", inner2 -> {
                                inner2.extraTag("src", "111")
                                        .extraTag("alt", "点击跳转")
                                        .style(style -> style.append("color", "#666"));
                            });
                        });
                    })
                    .content("来来来来来绿绿绿绿绿绿绿绿绿绿绿绿绿");
        }
        stopWatch.stop();
        Console.log("{} 耗时:{}", stopWatch.getLastTaskName(), stopWatch.getTotalTimeMillis());
    }
}

// 测试1 耗时:68 内容:<div style='color: red' class='container kkk' ></div>
// 测试2 耗时:94 内容:<div style='position: relative' ><div style='position: absolute; top: 0;right: 20;' ></div></div>
// 测试3 耗时:98 内容:<div style='yy: 90;ll: 99' uu="88" uu3="88"><div src="http:xxx/de/de12"><p class='aaaa' ><a style='color: #666' alt="点击跳转" src="111"></a></p></div>来来来来来绿绿绿绿绿绿绿绿绿绿绿绿绿</div>
// 测试4 耗时:212
啊啦嗦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java代码生成html文件
06-19
java生成静态html代码 一个简单的实例 自己去扩展
JavaWeb --- HTML
乌云的博客
02-28 1851
HTMLHTML通过标签来标记要显示的网页中的各个部分。网页文件本身是一种文本文件，通过在文本文件中添加标记符，可以告诉浏览器如何显示其中的内容（如：文字如何处理，画面如何安排，图片如何显示等） 跨行跨列
Java工具库——Hutool的50个常用方法
IT小辉同学
10-26 2218
爱一辈子也好，恨一辈子也罢，终究是要让你记我一辈子......
挺好玩的java工具类HuTool(常用案例和方法）
qq_51390404的博客
08-11 863
Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。它帮助我们简化每一行代码，避免重复造轮子。如果你有需要用到某些工具方法的时候，可以在Hutool里面找找，可能就有你需要的工具方法。Hutool参考文档模块介绍hutool-aopJDK动态代理封装，提供非IOC下的切面支持布隆过滤，提供一些Hash算法的布隆过滤简单缓存实现核心，包括Bean操作、日期、各种Util等。
Java读取word内容带格式，输出HTML格式富文本
SQF2404的博客
05-18 1999
word中的中文，在生成HTML之后，并非以中文显示，但不影响在浏览器中显示。代码如上，pom文件引包如下，经自测该版本可用。
【JavaWeb习笔记】DAY01——HTML页面
m0_62106729的博客
06-29 665
仅供个人学习总结，侵权必删！
利用Java生成静态HMTL页面的方法收集
weixin_33758863的博客
03-12 308
利用Java生成静态HMTL页面的方法收集 生成静态页面技术解决方案之一 转载者前言：这是一个全面的jsp动态页面静态化方案，本站的帖子静态化方案将借鉴这篇帖子中方法。向[url]http://www.agilejava.org[/url]的single的共享精神致敬。 转帖正文： 相信很多人都...
Java快速生成html接口文档和CHM文件详细过程
weixin_46801673的博客
08-29 1517
java快速生成接口文档和CHM文件详细过程
java解析html_java中几种解析html的工具
weixin_31437717的博客
02-12 6415
Jsoup还支持白名单过滤机制，对于网站防止XSS攻击也是很好的。2.HtmlParserHtmlParser的功能比较完备，也挺灵活，但谈不上方便。这个项目很久没有维护了，最新版本是2.1。HtmlParser的核心元素是Node，对应一个HTML标签，支持getChildren()等树状遍历方式。HtmlParser另外一个核心元素是NodeFilter，通过实现NodeFilter接口，可以...
Jsoup，一款超好用的HTML文本解析Java工具
Dream it Possible
11-23 5479
jsoup是一款Java的HTML解析器，可以直接解析某个URL地址或HTML内容。它提供了一套非常简单好用的API，可通过DOM，CSS以及类似于jQuery的操作方法来读取和操作数据。
html java处理工具类
01-04
提供从html中提取纯文本，从HTML中提取图片链接集合；使用于富文本编辑器存在数据库里面的网页处理
可能是方法最全Redis静态工具类（RedisUtils.java）
06-28
可能是最全的Redis静态工具类，拿来即用，随时随地RedisUtils.方法名()存取数据，每个方法都有对应的注释，快速上手！
Java Web分页工具类
最新发布
04-29
PageUtils是一个Java工具类，用于简化分页逻辑的处理。它包含以下两个主要部分： 1. PageInfo 内部类：这是一个泛型类，封装了分页所需的信息，包括当前页码、页面大小、总页数、总记录数和当前页的记录列表。 2. ...
腾讯云对象存储静态工具类（CosUtils.java），快速上手！！！
06-28
腾讯云对象存储静态工具类，满足日常工作使用，每个方法都有注释，快速上手！记得先引入Maven依赖，在配置文件中配置对象存储所属参数！
Java静态检测工具的简单介绍
03-23
静态检查:静态测试包括代码检查、静态结构分析、代码质量度量等。它可以由人工进行，充分发挥人...看了一系列的静态代码扫描或者叫静态代码分析工具后，总结对工具的看法：静态代码扫描工具，和编译器的某些功能其实是
阿里云对象存储静态工具类（AliOSSUtils.java）快速上手！！！
01-26
根据官网和网上分享的代码自己整理了一个阿里云OSS工具类，自动创建标准公开权限的存储空间，支持上传图片，音频，视频，PDF各种文件，批量上传，上传后支持在线预览，文件路径处理，浏览器文件下载（支持源文件中文...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 796
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 868
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1806
c++中string的模拟实现，面试必会知识点
静态代码扫描工具java_静态代码扫描工具
05-13
Java的静态代码扫描工具很多，以下是一些常用的： 1. FindBugs：是一个开源的静态代码分析器，可以检查Java代码中的错误、缺陷和潜在的性能问题。 2. PMD：也是一个开源的静态代码分析器，可以检查Java代码中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值