前言
搭建项目
- Thymeleaf默认配置
Thymeleaf基础语法
算术运算符
关系运算符
逻辑运算符
三目运算符
对空值做处理
th:href
th:onclick
内置对象API

SpringBoot整合Thymeleaf模板框架 - 图1

前言

Thymeleaf的主要目标是将优雅的自然模板带到开发工作流程中，并将HTML在浏览器中正确显示，并且可以作为静态原型，让开发团队能更容易地协作。Thymeleaf能够处理HTML，XML，JavaScript，CSS甚至纯文本。
长期以来,jsp在视图领域有非常重要的地位,随着时间的变迁,出现了一位新的挑战者:Thymeleaf,Thymeleaf是原生的,不依赖于标签库.它能够在接受原始HTML的地方进行编辑和渲染.因为它没有与Servelet规范耦合,因此Thymeleaf模板能进入jsp所无法涉足的领域。
Thymeleaf在Spring Boot项目中放入到resources/templates中。这个文件夹中的内容是无法通过浏览器URL直接访问的（和WEB-INF效果一样），所有Thymeleaf页面必须先走控制器。

搭建项目

创建一个新的项目，在pom.xml中添加一组 spring-boot-starter-thymeleaf 依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
            <version>2.4.5</version>
        </dependency>
    </dependencies>

Thymeleaf默认配置

在springBoot的官方文档指出Thymeleaf的配置地址在 src/resources/temlates/目录下，支持xxxx.html文件进行框架识别

Thymeleaf基础语法

Thymeleaf通过标准变量表达式完成数据的展示和处理
1 标准变量表达式必须依赖标签,不能独立使用
2 标准变量表达式一般在开始标签中,以 th开头
3 语法为:
4 表达式中可以通过${}取出域中的值并放入标签的指定位置
5 ${}在这里不能单独使用,必须在 th:后面的双引号里使用

th:text属性

向HTML标签内部输出信息。
处理器 Controller

    @RequestMapping("showIndex")
    public String  showIndex(Map<String,Object> map){
        map.put("msg", "testMessage");
        return "index";
    }

    <!--向span双标签内部添加文本-->
    <span th:text="pageMessage"></span> <br/>
    <!--从域中根据参数名取出参数值放在双标签中-->
    <span th:text="${msg}"></span>      <br/>

th:value

表单元素，设置HTML标签中表单元素value属性时使用。

    <!--向input标签中的value属性赋值-->
    <input type="text"  th:value="pageMessage"/>
    <!--从域中根据参数名取出参数值 向input标签中的value属性赋值-->
    <input type="text"  th:value="${msg}"/>

th:if

常用来值判断是否显示
<span th:if="${name}!='张三'">会显示</span>

循环遍历.th:each

示例中u为迭代遍历。
th:each=”u,i :${list}” 其中i表示迭代状态。

index:当前迭代器的索引从0开始
count:当前迭代对象的计数从1开始
size:被迭代对象的长度
even/odd:布尔值，当前循环是否是偶数/奇数从0开始
first:布尔值，当前循环的是否是第一条，如果是返回true否则返回false
last:布尔值，当前循环的是否是最后一条，如果是则返回true否则返回false

controller代码

@Controller
public class ThymeleafController {
    @Autowired
    private EmpService empService;
    @RequestMapping("/showEmp")
    public String showEmp(Map<String, Object> map) {
        List<Emp> empList = empService.findAll();
        map.put("empList", empList);
        map.put("emp", empList.get(0));
        return "showEmp";
    }

页面模板代码

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style type="text/css">
        #empTable{
            width: 80%;
            border: 1px solid blue;
            margin: 0px auto;
        }
        #empTable th,td{
            border: 1px solid green;
            text-align: center;
        }
    </style>
</head>
<body>
<span  th:if="${empList}!=null">
    <span  th:if="${empList.size()} ne 0">
        工号:<span th:text="${empList[0].empno}"></span><br/>
        姓名:<span th:text="${empList[0].ename}"></span><br/>
        职务:<span th:text="${empList[0].job}"></span><br/>
        上级:<span th:text="${empList[0].mgr}"></span><br/>
        入职日期:<span th:text="${empList[0].hiredate}"></span><br/>
        工资:<span th:text="${empList[0].sal}"></span><br/>
        补助:<span th:text="${empList[0].comm}"></span><br/>
        部门号:<span th:text="${empList[0].deptno}"></span><br/>
    </span>
</span>
<table  id="empTable" cellpadding="0px" cellspacing="0px">
    <tr>
        <th>索引</th>
        <th>序号</th>
        <th>总人数</th>
        <th>偶数索引?</th>
        <th>奇数索引?</th>
        <th>第一?</th>
        <th>最后?</th>
        <th>工号</th>
        <th>姓名</th>
        <th>职务</th>
        <th>上级</th>
        <th>入职日期</th>
        <th>工资</th>
        <th>补助</th>
        <th>部门号</th>
    </tr>
    <tr th:each="emp,i:${empList}">
        <td th:text="${i.index}"></td>
        <td th:text="${i.count}"></td>
        <td th:text="${i.size}"></td>
        <td th:text="${i.odd}"></td>
        <td th:text="${i.even}"></td>
        <td th:text="${i.first}"></td>
        <td th:text="${i.last}"></td>
        <td th:text="${emp.empno}"></td>
        <td th:text="${emp.ename}"></td>
        <td th:text="${emp.job}"></td>
        <td th:text="${emp.mgr}"></td>
        <td th:text="${emp.hiredate}"></td>
        <td th:text="${emp.sal}"></td>
        <td th:text="${emp.comm}"></td>
        <td th:text="${emp.deptno}"></td>
    </tr>
</table>
</body>
</html>

算术运算符

算术运算：+，-，*，/，%

<span th:text="1+1"></span>
<span th:text="'1'+1"></span>
<span th:text="${emp.empno}+1"></span>
<span th:text="${emp.empno+1}"></span>

关系运算符

1 gt: great than（大于）>
2 ge： great equal（大于等于）>=
3 eq： equal（等于）==
4 lt： less than（小于）<
5 le： less equal（小于等于）<=
6 ne： not equal（不等于）!=

逻辑运算符

&& 或 and: 表示并且
|| 或 or : 表示或者

<div th:text="1>0 and 2<3"></div>
<div th:text="1>0 and 2>3"></div>
<div th:text="1>0 or 2<3"></div>
<div th:text="1>0 or 2>3"></div>
<hr/>
<div th:text="${emp.sal ge 800}"></div>
<div th:text="${emp.sal } ge 800"></div>
<div th:text="${emp.sal ge 800} and ${emp.deptno eq 20}"></div>
<div th:text="(${emp.sal }ge 800) or (${emp.deptno } ne 20)"></div>
<div th:text="${emp.sal ge 800 or emp.deptno ne 20 }"></div>

在早期的thymeleaf模板引擎框架中逻辑运算符要写在${}的外边,目前我们2.4.5版本中,可以写在${}里面

三目运算符

和常用的java中的三目运算符是一样的，但在html中使用 th:class=””的方式去取值并进行值比较。

例：<tr th:each="emp,i:${empList}" th:class="${i.odd}?a:b">

对空值做处理

使用三目运算符和关系运算符来组合做空空值判断

例：<td th:text="${emp.mgr} eq null ?老板:${emp.mgr}"></td>

th:href

设置a标签中的href属性,取值使用@{}取值

<a th:href="@{/getParam(id=1,name='msb')}" >跳转</a>
<!-- 获取作用域值-->
<a th:href="@{/getParam(name=${stu.name},age=${stu.age})}">跳转二</a>

页面代码：

<tr th:each="emp,i:${empList}" th:class="${i.odd}?a:b">
        <td th:text="${i.index}"></td>
        <td th:text="${i.count}"></td>
        <td th:text="${i.size}"></td>
        <td th:text="${i.odd}"></td>
        <td th:text="${i.even}"></td>
        <td th:text="${i.first}"></td>
        <td th:text="${i.last}"></td>
        <td th:text="${emp.empno}"></td>
        <td th:text="${emp.ename}"></td>
        <td th:text="${emp.job}"></td>
        <td th:text="${emp.mgr} eq null ?老板:${emp.mgr}"></td>
        <td th:text="${emp.hiredate}"></td>
        <td th:text="${emp.sal}"></td>
        <td th:text="${emp.comm} eq null ?0:${emp.comm}"></td>
        <td th:text="${emp.deptno}"></td>
        <td>
            <a th:href="@{/removeEmp(empno=${emp.empno},ename=${emp.ename})}">删除</a>
        </td>
 </tr>

后台controller处理器

@Controller
public class ThymeleafController {
    @Autowired
    private EmpService empService;
    @RequestMapping("/showAllEmp")
    public String showEmp(Map<String, Object> map) {
        List<Emp> empList = empService.findAll();
        map.put("empList", empList);
        map.put("emp", empList.get(0));
        return "showEmp";
    }
    @RequestMapping("/removeEmp")
    public String removeEmp(Integer empno,String ename){
        boolean success =empService.removeEmp(empno,ename);
        return "redirect:showAllEmp";
    }
}

th:onclick

给元素绑定事件,单击事件并传递参数
写法1:仅仅支持数字和布尔类型参数的传递,字符串不支持（语法复杂且限制条件多，不推荐）

<a href="javascript:viod(0)"  th:onclick="'del('+${emp.empno}+')'">删除</a>

写法2:支持数字和文本类型的参数传递（推荐）

<a href="javascript:void(0)" th:onclick="delEmp([[${emp.empno}]],[[${emp.ename}]])">删除</a>

前端代码

<table  id="empTable" cellpadding="0px" cellspacing="0px">
    <tr>
        <th>索引</th>
        <th>序号</th>
        <th>总人数</th>
        <th>偶数索引?</th>
        <th>奇数索引?</th>
        <th>第一?</th>
        <th>最后?</th>
        <th>工号</th>
        <th>姓名</th>
        <th>职务</th>
        <th>上级</th>
        <th>入职日期</th>
        <th>工资</th>
        <th>补助</th>
        <th>部门号</th>
        <th>操作</th>
    </tr>
    <tr th:each="emp,i:${empList}" th:class="${i.odd}?a:b">
        <td th:text="${i.index}"></td>
        <td th:text="${i.count}"></td>
        <td th:text="${i.size}"></td>
        <td th:text="${i.odd}"></td>
        <td th:text="${i.even}"></td>
        <td th:text="${i.first}"></td>
        <td th:text="${i.last}"></td>
        <td th:text="${emp.empno}"></td>
        <td th:text="${emp.ename}"></td>
        <td th:text="${emp.job}"></td>
        <td th:text="${emp.mgr} eq null ?老板:${emp.mgr}"></td>
        <td th:text="${emp.hiredate}"></td>
        <td th:text="${emp.sal}"></td>
        <td th:text="${emp.comm} eq null ?0:${emp.comm}"></td>
        <td th:text="${emp.deptno}"></td>
        <td>
            <a href="javascript:void(0)" th:onclick="removeEmp([[${emp.empno}]],[[${emp.ename}]])">删除</a>
        </td>
    </tr>
</table>
<script>
    function removeEmp(empno,ename){
        var resulet =confirm("确定要删除编号为"+empno+"的"+ename);
        if(resulet){
            window.location.href="removeEmp?empno="+empno+"&ename="+ename;
        }
    }
</script>

内置对象API

Thymeleaf提供了一些内置对象，内置对象可直接在模板中使用。这些对象是以#引用的。
使用内置对象的语法
1引用内置对象需要使用#
2大部分内置对象的名称都以s结尾。如：strings、numbers、dates
3常见内置对象如下
#arrays：数组操作的工具；
#aggregates：操作数组或集合的工具；
#bools：判断boolean类型的工具；
#calendars：类似于#dates，但是是java.util.Calendar类的方法；
#ctx：上下文对象，可以从中获取所有的thymeleaf内置对象；
#dates：日期格式化内置对象，具体方法可以参照java.util.Date；
#numbers：数字格式化；#strings：字符串格式化，具体方法可以参照String，如startsWith、contains等；
#objects：参照java.lang.Object；
#lists：列表操作的工具，参照java.util.List；
#sets：Set操作工具，参照java.util.Set；#maps：Map操作工具，参照java.util.Map；
#messages：操作消息的工具。
更多

官方文档：https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html

参考链接：https://blog.csdn.net/lianghecai52171314/article/details/106394943/?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.opensearchhbase&spm=1001.2101.3001.4242.1

实例

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>IT Thymeleaf 内置方法</title>
    </head>
    <body>
        <h3>#strings </h3>
        <div th:if="${not #strings.isEmpty(itStr)}" >
            <p>Old Str : <span th:text="${itStr}"/></p>
            <p>toUpperCase : <span th:text="${#strings.toUpperCase(itStr)}"/></p>
            <p>toLowerCase : <span th:text="${#strings.toLowerCase(itStr)}"/></p>
            <p>equals : <span th:text="${#strings.equals(itStr, 'helloworld')}"/></p>
            <p>equalsIgnoreCase : <span th:text="${#strings.equalsIgnoreCase(itStr, 'helloworld')}"/></p>
            <p>indexOf : <span th:text="${#strings.indexOf(itStr, 'r')}"/></p>
            <p>substring : <span th:text="${#strings.substring(itStr, 2, 8)}"/></p>
            <p>replace : <span th:text="${#strings.replace(itStr, 'or', 'IT')}"/></p>
            <p>startsWith : <span th:text="${#strings.startsWith(itStr, 'he')}"/></p>
            <p>contains : <span th:text="${#strings.contains(itStr, 'ow')}"/></p>
        </div>
        <h3>#numbers </h3>
        <div>
            <p>formatDecimal 整数部分随意，小数点后保留两位，四舍五入: <span th:text="${#numbers.formatDecimal(itNum, 0, 2)}"/></p>
            <p>formatDecimal 整数部分保留五位数，小数点后保留两位，四舍五入: <span th:text="${#numbers.formatDecimal(itNum, 5, 2)}"/></p>
        </div>
        <h3>#bools </h3>
        <div th:if="${#bools.isTrue(itBool)}">
            <p th:text="${itBool}"></p>
        </div>
        <h3>#arrays </h3>
        <div th:if="${not #arrays.isEmpty(itArray)}">
            <p>length : <span th:text="${#arrays.length(itArray)}"/></p>
            <p>contains : <span th:text="${#arrays.contains(itArray, 5)}"/></p>
            <p>containsAll : <span th:text="${#arrays.containsAll(itArray, itArray)}"/></p>
        </div>
        <h3>#lists </h3>
        <div th:if="${not #lists.isEmpty(itList)}">
            <p>size : <span th:text="${#lists.size(itList)}"/></p>
            <p>contains : <span th:text="${#lists.contains(itList, 0)}"/></p>
            <p>sort : <span th:text="${#lists.sort(itList)}"/></p>
        </div>
        <h3>#maps </h3>
        <div th:if="${not #maps.isEmpty(itMap)}">
            <p>size : <span th:text="${#maps.size(itMap)}"/></p>
            <p>containsKey : <span th:text="${#maps.containsKey(itMap, 'thName')}"/></p>
            <p>containsValue : <span th:text="${#maps.containsValue(itMap, '#maps')}"/></p>
        </div>
        <h3>#dates </h3>
        <div>
            <p>format : <span th:text="${#dates.format(itDate)}"/></p>
            <p>custom format : <span th:text="${#dates.format(itDate, 'yyyy-MM-dd HH:mm:ss')}"/></p>
            <p>day : <span th:text="${#dates.day(itDate)}"/></p>
            <p>month : <span th:text="${#dates.month(itDate)}"/></p>
            <p>monthName : <span th:text="${#dates.monthName(itDate)}"/></p>
            <p>year : <span th:text="${#dates.year(itDate)}"/></p>
            <p>dayOfWeekName : <span th:text="${#dates.dayOfWeekName(itDate)}"/></p>
            <p>hour : <span th:text="${#dates.hour(itDate)}"/></p>
            <p>minute : <span th:text="${#dates.minute(itDate)}"/></p>
            <p>second : <span th:text="${#dates.second(itDate)}"/></p>
            <p>createNow : <span th:text="${#dates.createNow()}"/></p>
        </div>
    </body>
</html>

第二步：对应的Controller
@RequestMapping("demo3")
public String demo3(ModelMap modelMap) {
    modelMap.put("itStr", "HelloWorld");
    modelMap.put("itNum", 888.888D);
    modelMap.put("itBool", true);
    modelMap.put("itArray", new Integer[]{1,2,3,4});
    modelMap.put("itList", Arrays.asList(1,3,2,4,0));
    Map itMap = new HashMap();
    itMap.put("thName", "${#...}");
    itMap.put("desc", "变量表达式内置方法");
    modelMap.put("itMap", itMap);
    modelMap.put("itDate", new Date());
    return "demo3";
}

strings对象

/*
* Null-safe toString()
*/
${#strings.toString(obj)} // 也可以是 array*、list* 或 set*
/*
* 检查String是否为空(或null)。在检查之前执行trim()操作也同样适用于数组、列表或集合
*/
${#strings.isEmpty(name)}
${#strings.arrayIsEmpty(nameArr)}
${#strings.listIsEmpty(nameList)}
${#strings.setIsEmpty(nameSet)}
/*
* 对字符串执行“isEmpty()”检查, 如果为false则返回它, 如果为true则默认为另一个指定的字符串。
* 也同样适用于数组、列表或集合
*/
${#strings.defaultString(text,default)}
${#strings.arrayDefaultString(textArr,default)}
${#strings.listDefaultString(textList,default)}
${#strings.setDefaultString(textSet,default)}
/*
* 检查字符串中是否包含片段，比如 ${#strings.containsIgnoreCase(user.name,'kang')}
* 也同样适用于数组、列表或集合
*/
${#strings.contains(name,'ez')} // 也可以是 array*、list* 或 set*
${#strings.containsIgnoreCase(name,'ez')} // 也可以是 array*、list* 或 set*
/*
* 检查字符串是否以片段开始或结束
* 也同样适用于数组、列表或集合
*/
${#strings.startsWith(name,'Don')} // 也可以是 array*、list* 或 set*
${#strings.endsWith(name,endingFragment)} // 也可以是 array*、list* 或 set*
/*
* 子串相关操作
* 也同样适用于数组、列表或集合
*/
${#strings.indexOf(name,frag)} // 也可以是 array*、list* 或 set*
${#strings.substring(name,3,5)} // 也可以是 array*、list* 或 set*
${#strings.substringAfter(name,prefix)} // 也可以是 array*、list* 或 set*
${#strings.substringBefore(name,suffix)} // 也可以是 array*、list* 或 set*
${#strings.replace(name,'las','ler')} // 也可以是 array*、list* 或 set*
/*
* 附加和前置
* 也同样适用于数组、列表或集合
*/
${#strings.prepend(str,prefix)} // 也可以是 array*、list* 或 set*
${#strings.append(str,suffix)} // 也可以是 array*、list* 或 set*
/*
* 大小写转换
* 也同样适用于数组、列表或集合
*/
${#strings.toUpperCase(name)} // 也可以是 array*、list* 或 set*
${#strings.toLowerCase(name)} // 也可以是 array*、list* 或 set*
/*
* 拆分和拼接
*/
${#strings.arrayJoin(namesArray,',')}
${#strings.listJoin(namesList,',')}
${#strings.setJoin(namesSet,',')}
${#strings.arraySplit(namesStr,',')} // 返回String []
${#strings.listSplit(namesStr,',')} // 返回List<String>
${#strings.setSplit(namesStr,',')} // 返回Set<String>
/*
* Trim
* 也同样适用于数组、列表或集合
*/
${#strings.trim(str)} // 也可以是 array*、list* 或 set*
/*
* 计算长度
* 也同样适用于数组、列表或集合
*/
${#strings.length(str)} // 也可以是 array*、list* 或 set*
/*
* 缩写文本, 使其最大大小为n。如果文本较大, 它将被剪辑并在末尾附加“...”
* 也同样适用于数组、列表或集合
*/
${#strings.abbreviate(str,10)} // 也可以是 array*、list* 或 set*
/*
* 将第一个字符转换为大写(反之亦然)
*/
${#strings.capitalize(str)} // 也可以是 array*、list* 或 set*
${#strings.unCapitalize(str)} // 也可以是 array*、list* 或 set*
/*
* 将每个单词的第一个字符转换为大写
*/
${#strings.capitalizeWords(str)} // 也可以是 array*、list* 或 set*
${#strings.capitalizeWords(str,delimiters)} // 也可以是 array*、list* 或 set*
/*
* 转义字符串
*/
${#strings.escapeXml(str)} // 也可以是 array*、list* 或 set*
${#strings.escapeJava(str)} // 也可以是 array*、list* 或 set*
${#strings.escapeJavaScript(str)} // 也可以是 array*、list* 或 set*
${#strings.unescapeJava(str)} // 也可以是 array*、list* 或 set*
${#strings.unescapeJavaScript(str)} // 也可以是 array*、list* 或 set*
/*
* 空安全比较和连接
*/
${#strings.equals(first, second)}
${#strings.equalsIgnoreCase(first, second)}
${#strings.concat(values...)}
${#strings.concatReplaceNulls(nullValue, values...)}
/*
* 随机数
*/
${#strings.randomAlphanumeric(count)}

dates对象

/*
* 使用标准区域设置格式格式化日期
* 也同样适用于数组、列表或集合
*/
${#dates.format(date)}
${#dates.arrayFormat(datesArray)}
${#dates.listFormat(datesList)}
${#dates.setFormat(datesSet)}

/*
* 使用ISO8601格式格式化日期
* 也同样适用于数组、列表或集合
*/
${#dates.formatISO(date)}
${#dates.arrayFormatISO(datesArray)}
${#dates.listFormatISO(datesList)}
${#dates.setFormatISO(datesSet)}

/*
* 使用指定的格式格式化日期，比如 ${#dates.format(date,'yyyy-MM-dd HH:mm:ss')}
* 也同样适用于数组、列表或集合
*/
${#dates.format(date, 'dd/MMM/yyyy HH:mm')}
${#dates.arrayFormat(datesArray, 'dd/MMM/yyyy HH:mm')}
${#dates.listFormat(datesList, 'dd/MMM/yyyy HH:mm')}
${#dates.setFormat(datesSet, 'dd/MMM/yyyy HH:mm')}

/*
* 获取日期属性
* 也同样适用于数组、列表或集合
*/
${#dates.day(date)} // 也可以是 arrayDay(...), listDay(...)之类的
${#dates.month(date)} // 也可以是 arrayMonth(...), listMonth(...)之类的
${#dates.monthName(date)} // 也可以是 arrayMonthName(...), listMonthName(...)之类的
${#dates.monthNameShort(date)} // 也可以是 arrayMonthNameShort(...), listMonthNameShort(...)之类的
${#dates.year(date)} // 也可以是 arrayYear(...), listYear(...)之类的
${#dates.dayOfWeek(date)} // 也可以是 arrayDayOfWeek(...), listDayOfWeek(...)之类的
${#dates.dayOfWeekName(date)} // 也可以是 arrayDayOfWeekName(...), listDayOfWeekName(...)之类的
${#dates.dayOfWeekNameShort(date)} // 也可以是 arrayDayOfWeekNameShort(...), listDayOfWeekNameShort(...)之类的
${#dates.hour(date)} // 也可以是 arrayHour(...), listHour(...)之类的
${#dates.minute(date)} // 也可以是 arrayMinute(...), listMinute(...)之类的
${#dates.second(date)} // 也可以是 arraySecond(...), listSecond(...)之类的
${#dates.millisecond(date)} // 也可以是 arrayMillisecond(...), listMillisecond(...)之类的

/*
* 根据year,month,day创建日期(java.util.Date)对象，比如 ${#dates.create('2008','08','08')}
*/
${#dates.create(year,month,day)}
${#dates.create(year,month,day,hour,minute)}
${#dates.create(year,month,day,hour,minute,second)}
${#dates.create(year,month,day,hour,minute,second,millisecond)}

/*
* 创建当前日期和时间创建日期(java.util.Date)对象，比如 ${#dates.format(#dates.createNow(),'yyyy-MM-dd HH:mm:ss')}
*/
${#dates.createNow()}

${#dates.createNowForTimeZone()}

/*
* 创建当前日期创建一个日期(java.util.Date)对象(时间设置为00:00)
*/
${#dates.createToday()}

${#dates.createTodayForTimeZone()}

Calendars对象

/*
* 使用标准区域设置格式格式化日历
* 也同样适用于数组、列表或集合
*/
${#calendars.format(cal)}
${#calendars.arrayFormat(calArray)}
${#calendars.listFormat(calList)}
${#calendars.setFormat(calSet)}

/*
* 使用ISO8601格式格式化日历
* 也同样适用于数组、列表或集合
*/
${#calendars.formatISO(cal)}
${#calendars.arrayFormatISO(calArray)}
${#calendars.listFormatISO(calList)}
${#calendars.setFormatISO(calSet)}

/*
* 使用指定的格式格式化日历
* 也同样适用于数组、列表或集合
*/
${#calendars.format(cal, 'dd/MMM/yyyy HH:mm')}
${#calendars.arrayFormat(calArray, 'dd/MMM/yyyy HH:mm')}
${#calendars.listFormat(calList, 'dd/MMM/yyyy HH:mm')}
${#calendars.setFormat(calSet, 'dd/MMM/yyyy HH:mm')}

/*
* 获取日历属性
* 也同样适用于数组、列表或集合
*/
${#calendars.day(date)} // 也可以是 arrayDay(...), listDay(...)之类的
${#calendars.month(date)} // 也可以是 arrayMonth(...), listMonth(...)之类的
${#calendars.monthName(date)} // 也可以是 arrayMonthName(...), listMonthName(...)之类的
${#calendars.monthNameShort(date)} // 也可以是 arrayMonthNameShort(...), listMonthNameShort(...)之类的
${#calendars.year(date)} // 也可以是 arrayYear(...), listYear(...)之类的
${#calendars.dayOfWeek(date)} // 也可以是 arrayDayOfWeek(...), listDayOfWeek(...)之类的
${#calendars.dayOfWeekName(date)} // 也可以是 arrayDayOfWeekName(...), listDayOfWeekName(...)之类的
${#calendars.dayOfWeekNameShort(date)} // 也可以是 arrayDayOfWeekNameShort(...), listDayOfWeekNameShort(...)之类的
${#calendars.hour(date)} // 也可以是 arrayHour(...), listHour(...)之类的
${#calendars.minute(date)} // 也可以是 arrayMinute(...), listMinute(...)之类的
${#calendars.second(date)} // 也可以是 arraySecond(...), listSecond(...)之类的
${#calendars.millisecond(date)} // 也可以是 arrayMillisecond(...), listMillisecond(...)之类的

/*
* 从其组件创建日历(java.util.Calendar)对象
*/
${#calendars.create(year,month,day)}
${#calendars.create(year,month,day,hour,minute)}
${#calendars.create(year,month,day,hour,minute,second)}
${#calendars.create(year,month,day,hour,minute,second,millisecond)}

${#calendars.createForTimeZone(year,month,day,timeZone)}
${#calendars.createForTimeZone(year,month,day,hour,minute,timeZone)}
${#calendars.createForTimeZone(year,month,day,hour,minute,second,timeZone)}
${#calendars.createForTimeZone(year,month,day,hour,minute,second,millisecond,timeZone)}

/*
* 为当前日期和时间创建一个日历(java.util.Calendar)对象
*/
${#calendars.createNow()}

${#calendars.createNowForTimeZone()}

/*
* 为当前日期创建日历(java.util.Calendar)对象(时间设置为00:00)
*/
${#calendars.createToday()}

${#calendars.createTodayForTimeZone()}

numbers对象

/*
* ==========================
* 格式化整数
* ==========================
*/

/*
* 设置最小整数位数。
* 也同样适用于数组、列表或集合
*/
${#numbers.formatInteger(num,3)}
${#numbers.arrayFormatInteger(numArray,3)}
${#numbers.listFormatInteger(numList,3)}
${#numbers.setFormatInteger(numSet,3)}


/*
* 设置最小整数位数和千位分隔符：
* 'POINT'、'COMMA'、'WHITESPACE'、'NONE' 或 'DEFAULT'(根据本地化)。
* 也同样适用于数组、列表或集合
*/
${#numbers.formatInteger(num,3,'POINT')}
${#numbers.arrayFormatInteger(numArray,3,'POINT')}
${#numbers.listFormatInteger(numList,3,'POINT')}
${#numbers.setFormatInteger(numSet,3,'POINT')}


/*
* ==========================
* 格式化十进制数
* ==========================
*/

/*
* 设置最小整数数字和(精确的)十进制数字。
* 也同样适用于数组、列表或集合
*/
${#numbers.formatDecimal(num,3,2)}
${#numbers.arrayFormatDecimal(numArray,3,2)}
${#numbers.listFormatDecimal(numList,3,2)}
${#numbers.setFormatDecimal(numSet,3,2)}

/*
* 设置最小整数数字和(精确的)小数位数, 以及小数分隔符。
* 也同样适用于数组、列表或集合
*/
${#numbers.formatDecimal(num,3,2,'COMMA')}
${#numbers.arrayFormatDecimal(numArray,3,2,'COMMA')}
${#numbers.listFormatDecimal(numList,3,2,'COMMA')}
${#numbers.setFormatDecimal(numSet,3,2,'COMMA')}

/*
* 设置最小整数数字和(精确的)十进制数字, 以及千位和十进制分隔符。
* 也同样适用于数组、列表或集合
*/
${#numbers.formatDecimal(num,3,'POINT',2,'COMMA')}
${#numbers.arrayFormatDecimal(numArray,3,'POINT',2,'COMMA')}
${#numbers.listFormatDecimal(numList,3,'POINT',2,'COMMA')}
${#numbers.setFormatDecimal(numSet,3,'POINT',2,'COMMA')}

/*
* ==========================
* 实用方法
* ==========================
*/

/*
* 创建一个从x到y的整数序列(数组)
*/
${#numbers.sequence(from,to)}
${#numbers.sequence(from,to,step)}

实例：

<p th:utext="${#numbers.formatInteger(0.1024,3)}"></p>
<p th:utext="${#numbers.formatInteger(1.024,3)}"></p>
<p th:utext="${#numbers.formatInteger(10.24,3)}"></p>
<p th:utext="${#numbers.formatInteger(102.4,3)}"></p>

<br><br>

<p th:utext="${#numbers.formatInteger(1.024,2,'POINT')}"></p>
<p th:utext="${#numbers.formatInteger(1024,3,'POINT')}"></p>
<p th:utext="${#numbers.formatInteger(1024,10,'POINT')}"></p>

<p th:utext="${#numbers.formatInteger(1.024,2,'COMMA')}"></p>
<p th:utext="${#numbers.formatInteger(1024,3,'COMMA')}"></p>
<p th:utext="${#numbers.formatInteger(1024,10,'COMMA')}"></p>

<p th:utext="${#numbers.formatInteger(1.024,2,'WHITESPACE')}"></p>
<p th:utext="${#numbers.formatInteger(1024,3,'WHITESPACE')}"></p>
<p th:utext="${#numbers.formatInteger(1024,10,'WHITESPACE')}"></p>

objects对象

/*
* 当obj不为空时，返回obj，否则返回default默认值
* 其同样适用于数组、列表或集合
*/
${#objects.nullSafe(obj,default)}
${#objects.arrayNullSafe(objArray,default)}
${#objects.listNullSafe(objList,default)}
${#objects.setNullSafe(objSet,default)}

bools对象

/*
* 评估条件, 类似于 th:if 标签
* 也同样适用于数组、列表或集合
*/
${#bools.isTrue(obj)}
${#bools.arrayIsTrue(objArray)}
${#bools.listIsTrue(objList)}
${#bools.setIsTrue(objSet)}

/*
* 用否定来评估条件
* 也同样适用于数组、列表或集合
*/
${#bools.isFalse(cond)}
${#bools.arrayIsFalse(condArray)}
${#bools.listIsFalse(condList)}
${#bools.setIsFalse(condSet)}

/*
* 评估条件并执行与操作
* 接收数组、列表或集合作为参数
*/
${#bools.arrayAnd(condArray)}
${#bools.listAnd(condList)}
${#bools.setAnd(condSet)}

/*
* 评估条件并执行或操作
* 接收数组、列表或集合作为参数
*/
${#bools.arrayOr(condArray)}
${#bools.listOr(condList)}
${#bools.setOr(condSet)}

arrays对象

/*
* 转换为数组, 试图推断数组组件类。注意, 如果结果数组为空, 或者目标对象的元素不是全部相同的类, 则
* 此方法将返回Object []。
*/
${#arrays.toArray(object)}

/*
* 转换为指定组件类的数组。
*/
${#arrays.toStringArray(object)}
${#arrays.toIntegerArray(object)}
${#arrays.toLongArray(object)}
${#arrays.toDoubleArray(object)}
${#arrays.toFloatArray(object)}
${#arrays.toBooleanArray(object)}

/*
* 计算数组长度
*/
${#arrays.length(array)}

/*
* 检查数组是否为空
*/
${#arrays.isEmpty(array)}

/*
* 检查数组中是否包含元素或元素集合
*/
${#arrays.contains(array, element)}
${#arrays.containsAll(array, elements)}

lists对象

/*
* 转化为 list
*/
${#lists.toList(object)}

/*
* 计算大小
*/
${#lists.size(list)}

/*
*/
${#lists.isEmpty(list)}

/*
* 检查list中是否包含元素或元素集合
*/
${#lists.contains(list, element)}
${#lists.containsAll(list, elements)}

/*
* 排序给定列表的副本。列表的成员必须
* 实现comparable, 或者必须定义comparator。
*/
${#lists.sort(list)}
${#lists.sort(list, comparator)}

sets对象

/*
* 转化为 to set
*/
${#sets.toSet(object)}

/*
* 计算大小
*/
${#sets.size(set)}

/*
* 检查set是否为empty
*/
${#sets.isEmpty(set)}

/*
* 检查set中是否包含元素或元素集合
*/
${#sets.contains(set, element)}
${#sets.containsAll(set, elements)}

maps对象

/*
* 计算大小
*/
${#maps.size(map)}

/*
* 检查map是否为空
*/
${#maps.isEmpty(map)}

/*
* 检查map中是否包含key/s或value/s
*/
${#maps.containsKey(map, key)}
${#maps.containsAllKeys(map, keys)}
${#maps.containsValue(map, value)}
${#maps.containsAllValues(map, value)}

aggregates对象

/*
* 计算总和。如果数组或集合为空，则返回null
*/
${#aggregates.sum(array)}
${#aggregates.sum(collection)}
/*
* 计算平均值。如果数组或集合为空，则返回null
*/
${#aggregates.avg(array)}
${#aggregates.avg(collection)}

messages对象

/*
* 获取外部化消息。可以接收单个键，一个键加上参数，
* 或者一个数组/列表/密钥集（在这种情况下，它将返回一个数组/列表/外部化消息集）。
* 如果未找到消息，则返回默认消息（如“？？msgKey？？”）。
*/
${#messages.msg('msgKey')}
${#messages.msg('msgKey', param1)}
${#messages.msg('msgKey', param1, param2)}
${#messages.msg('msgKey', param1, param2, param3)}
${#messages.msgWithParams('msgKey', new Object[] {param1, param2, param3, param4})}
${#messages.arrayMsg(messageKeyArray)}
${#messages.listMsg(messageKeyList)}
${#messages.setMsg(messageKeySet)}
/*
* 获取外部化消息或null。如果找不到指定密钥的消息，则返回Null而不是默认消息。
*/
${#messages.msgOrNull('msgKey')}
${#messages.msgOrNull('msgKey', param1)}
${#messages.msgOrNull('msgKey', param1, param2)}
${#messages.msgOrNull('msgKey', param1, param2, param3)}
${#messages.msgOrNullWithParams('msgKey', new Object[] {param1, param2, param3, param4})}
${#messages.arrayMsgOrNull(messageKeyArray)}
${#messages.listMsgOrNull(messageKeyList)}
${#messages.setMsgOrNull(messageKeySet)}

ids对象

/*
* 通常在th:id属性中使用，用于将计数器附加到id属性值，以便它即使在迭代过程中也保持唯一。
*/
${#ids.seq('someId')}
/*
* 通常用于th:for<label>标记中的属性，因此这些标签可以引用通过#id生成的id。序号（…）作用
*
* 取决于<label>是在带有#id的元素之前还是之后。序号（…）函数，
* 则应调用“next”（标签位于“seq”之前）或“prev”函数（标签位于“seq”之后）。
*/
${#ids.next('someId')}
${#ids.prev('someId')}