上手 Velocity：让 Java 代码自动生成，告别重复劳动的实战指南🔥Java 开发还在被重复编码拖后腿？页面渲

在我们使用若依的时候，你是否有没有好奇过，他这个代码到底是怎么生成的？

再比如在生成动态网页时，我们可能需要在 Java 代码中拼接大量的 HTML 字符串，这不仅使得代码变得冗长和难以阅读，而且也不利于前端和后端的分离开发。假设我们要生成一个简单的用户列表页面，使用传统的字符串拼接方式，代码可能如下：

public class UserController {
    public String generateUserListPage(List<User> users) {
        StringBuilder html = new StringBuilder();
        html.append("<html><body><h1>User List</h1><ul>");
        for (User user : users) {
            html.append("<li>ID: ").append(user.getId()).append(", Name: ").append(user.getName()).append(", Age: ").append(user.getAge()).append("</li>");
        }
        html.append("</ul></body></html>");
        return html.toString();
    }
}

这段代码虽然能够实现基本的功能，但它的可读性和可维护性都非常差。如果页面的样式或者结构发生变化，我们就需要在 Java 代码中进行大量的修改，这对于前端开发人员来说是非常不友好的。而且，这种方式也不利于代码的复用和扩展，一旦需要生成其他类型的页面，我们就需要重新编写大量的代码。
Velocity 模板引擎的出现，为我们解决这些问题提供了一种有效的方案。它遵循 Model - View - Controller（MVC）设计模式，将数据模型与模板分离，使得我们可以专注于业务逻辑的实现，而将页面的展示逻辑交给模板来处理。使用 Velocity，我们可以将上述的 CRUD 操作和动态网页生成代码进行优化，提高开发效率和代码的可维护性。接下来，让我们深入了解 Velocity 的核心原理和使用方法，看看它是如何帮助我们提升开发效率的。

二、Velocity 核心概念与 MVC 架构实践

（一）什么是模板引擎？从 MVC 模式说起

在软件开发的世界里，MVC（Model - View - Controller）架构就像是一座大厦的蓝图，它将整个应用程序清晰地划分为三个主要部分：模型（Model）、视图（View）和控制器（Controller）。这种架构模式的出现，极大地提高了软件的可维护性、可扩展性和可复用性，成为了现代软件开发的基石之一。
模型（Model），它就像是大厦的根基，负责管理和维护应用程序的数据。它包含了业务逻辑和数据访问层，用于处理数据的存储、读取和更新等操作。在一个电商系统中，模型可能包含用户信息、商品信息、订单信息等，以及对这些数据进行增删改查的方法。
视图（View），则是大厦展现在人们眼前的外观，它负责将数据以一种直观的方式呈现给用户。视图通常是用户界面，如网页、桌面应用程序的窗口等。在电商系统中，视图可以是商品列表页面、购物车页面、订单详情页面等，用户通过这些视图与应用程序进行交互。
控制器（Controller），是连接模型和视图的桥梁，它负责接收用户的请求，并根据请求的类型和内容，调用相应的模型方法来处理数据，然后将处理结果传递给合适的视图进行展示。在电商系统中，当用户点击商品列表页面上的某个商品时，控制器会接收到这个请求，调用模型中获取商品详情的方法，然后将商品详情传递给商品详情视图进行展示。
然而，在传统的 JSP（JavaServer Pages）开发中，虽然也遵循 MVC 架构，但常常会出现 Java 代码与 HTML 混杂的情况。在一个 JSP 页面中，我们可能会看到如下代码：

<%@ page contentType="text/html; charset=UTF-8" %>
<html>
<head>
    <title>用户列表</title>
</head>
<body>
    <h1>用户列表</h1>
    <ul>
        <%
            List<User> users = (List<User>) request.getAttribute("users");
            for (User user : users) {
        %>
                <li>ID: <%= user.getId() %>, Name: <%= user.getName() %>, Age: <%= user.getAge() %></li>
        <%
            }
        %>
    </ul>
</body>
</html>

这段代码中，Java 代码和 HTML 代码交织在一起，使得代码的可读性和可维护性大大降低。当页面的样式或者结构发生变化时，我们需要在 Java 代码中进行修改，这对于前端开发人员来说是非常不友好的。而且，这种方式也不利于代码的复用和扩展，一旦需要生成其他类型的页面，我们就需要重新编写大量的代码。
模板引擎的出现，为解决这些问题提供了一种有效的方案。它作为 MVC 架构中视图层的重要组成部分，能够将数据展示与业务逻辑彻底分离。通过模板引擎，我们可以将页面的展示逻辑封装在模板文件中，而将业务逻辑放在控制器和模型中处理。这样，前端开发人员可以专注于模板的设计和优化，而后端开发人员则可以专注于业务逻辑的实现，两者互不干扰，提高了开发效率。
Velocity 就是这样一款优秀的模板引擎，它以其简洁的语法和强大的功能，在 Java 开发领域得到了广泛的应用。接下来，让我们深入了解 Velocity 的核心组件和工作流程，看看它是如何实现数据展示与业务逻辑分离的。

（二）Velocity 核心组件与工作流程

VelocityEngine：引擎核心，负责加载模板文件、解析配置（如类路径加载器）。在使用 Velocity 时，我们首先需要创建一个 VelocityEngine 对象，并对其进行初始化配置。例如，我们可以通过以下代码创建一个 VelocityEngine 对象，并设置其资源加载器为类路径加载器：

import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;
import java.util.Properties;
public class VelocityExample {
    public static void main(String[] args) {
        // 创建Velocity引擎
        VelocityEngine velocityEngine = new VelocityEngine();
        // 设置资源加载器为类路径加载器
        Properties props = new Properties();
        props.setProperty("resource.loader", "class");
        props.setProperty("class.resource.loader.class", ClasspathResourceLoader.class.getName());
        velocityEngine.init(props);
    }
}

通过上述配置，VelocityEngine 就能够从类路径中加载模板文件。

VelocityContext：数据上下文，通过 put (key, value) 方法存储待渲染的变量（支持 Map 或直接赋值）。VelocityContext 就像是一个数据容器，我们可以将需要在模板中使用的数据存储在其中。例如，我们可以通过以下代码创建一个 VelocityContext 对象，并向其中添加一个名为 “name” 的变量：

import org.apache.velocity.VelocityContext;
public class VelocityExample {
    public static void main(String[] args) {
        // 创建Velocity上下文
        VelocityContext context = new VelocityContext();
        // 向上下文中添加变量
        context.put("name", "张三");
    }
}

在模板中，我们可以通过 “$name” 来引用这个变量。

Template：编译后的模板对象，通过 merge (context, writer) 方法将数据注入模板生成最终输出。当我们加载模板文件并创建好 VelocityContext 对象后，就可以通过 Template 对象的 merge 方法将数据注入模板，生成最终的输出。例如，我们可以通过以下代码加载一个模板文件，并将数据注入模板生成输出：

import org.apache.velocity.Template;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.context.Context;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;
import java.io.StringWriter;
import java.util.Properties;
public class VelocityExample {
    public static void main(String[] args) throws Exception {
        // 创建Velocity引擎
        VelocityEngine velocityEngine = new VelocityEngine();
        // 设置资源加载器为类路径加载器
        Properties props = new Properties();
        props.setProperty("resource.loader", "class");
        props.setProperty("class.resource.loader.class", ClasspathResourceLoader.class.getName());
        velocityEngine.init(props);
        // 创建Velocity上下文
        Context context = new org.apache.velocity.VelocityContext();
        context.put("name", "张三");
        // 加载模板
        Template template = velocityEngine.getTemplate("example.vm");
        // 生成输出
        StringWriter writer = new StringWriter();
        template.merge(context, writer);
        System.out.println(writer.toString());
    }
}

在上述代码中，我们首先创建了一个 VelocityEngine 对象，并设置了其资源加载器。然后创建了一个 VelocityContext 对象，并向其中添加了一个名为 “name” 的变量。接着，我们通过 VelocityEngine 的 getTemplate 方法加载了一个名为 “example.vm” 的模板文件。最后，通过 Template 的 merge 方法将 VelocityContext 中的数据注入模板，并将生成的输出通过 StringWriter 输出到控制台。

典型流程如下：

初始化 VelocityEngine：创建 VelocityEngine 对象，并配置其资源加载器等参数。

创建 VelocityContext：创建 VelocityContext 对象，并向其中添加需要在模板中使用的数据。

加载模板：通过 VelocityEngine 的 getTemplate 方法加载模板文件，得到 Template 对象。

合并数据与模板：使用 Template 的 merge 方法，将 VelocityContext 中的数据注入模板，生成最终的输出。

输出结果：将生成的输出通过指定的 Writer 输出到目标位置，如控制台、文件或网络流等。

通过以上步骤，我们就可以使用 Velocity 模板引擎实现数据的动态渲染，将数据展示与业务逻辑有效地分离，提高开发效率和代码的可维护性。

三、三大核心应用场景：不止于代码生成

（一）代码生成神器：告别重复 CRUD

在后端开发的日常工作中，重复编写 CRUD（Create, Read, Update, Delete）代码是一项既繁琐又容易出错的任务。以一个简单的用户管理模块为例，在传统的开发模式下，我们可能需要手动编写大量的 SQL 语句和 Java 代码来实现用户数据的增删改查操作。这些代码不仅冗长，而且容易出现拼写错误、参数绑定错误等问题。
在 MyBatis Plus、Spring Boot 等流行框架中，Velocity 则可以成为我们的救星。通过配置模板文件和相关参数，Velocity 能够根据数据库表结构自动生成 Controller、Service、DAO 层的代码。在生成 Controller 层代码时，Velocity 可以根据模板定义，自动生成处理用户请求的方法，包括请求映射、参数解析等。在生成 Service 层代码时，Velocity 可以根据业务需求，自动生成调用 DAO 层方法的业务逻辑。在生成 DAO 层代码时，Velocity 可以根据数据库表结构，自动生成 SQL 语句和参数绑定的代码。
假设我们有一个名为 “user” 的数据库表，包含 “id”、“name”、“age” 等字段，使用 Velocity 结合 MyBatis Plus 和 Spring Boot，我们可以通过定义如下模板文件来生成 Controller 层代码：

package ${package.controller};
import org.springframework.web.bind.annotation.*;
import ${package.entity}.User;
import ${package.service}.UserService;
@RestController
@RequestMapping("/user")
public class UserController {
    private final UserService userService;
    public UserController(UserService userService) {
        this.userService = userService;
    }
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }
    @PostMapping
    public void addUser(@RequestBody User user) {
        userService.addUser(user);
    }
    @PutMapping
    public void updateUser(@RequestBody User user) {
        userService.updateUser(user);
    }
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

在上述模板中，通过 “({package.controller}”、“){package.entity}”、“${package.service}” 等变量来动态生成包名，通过 “@RequestMapping”、“@GetMapping”、“@PostMapping” 等注解来定义请求映射，通过 “userService” 来调用 Service 层的方法。在实际生成代码时，只需要提供相应的包名和数据库表结构信息，Velocity 就能够根据模板自动生成完整的 Controller 层代码。
这样，我们只需要关注业务逻辑的实现，而不需要花费大量时间在这些重复的代码编写上，大大提高了开发效率，减少了人为错误的发生。

（二）Web 开发：替代 JSP 的轻量化选择

在 Web 开发领域，JSP（JavaServer Pages）曾经是动态网页开发的主流技术之一。然而，随着时间的推移，JSP 的一些弊端逐渐显现出来。JSP 允许在 HTML 页面中嵌入 Java 代码，这使得代码的可读性和维护性较差，尤其是在大型项目中，Java 代码与 HTML 代码的混杂会导致代码结构混乱，难以理解和修改。而且，JSP 的部署和运行依赖于 Servlet 容器，这增加了项目的部署复杂性和资源消耗。
Velocity 作为一种轻量级的模板引擎，为 Web 开发提供了一种更优的选择。它支持动态生成 HTML 页面，通过 “#if”、“#foreach” 等指令，我们可以轻松实现条件判断与循环渲染，同时避免了 Java 代码侵入视图层。在一个商品列表页面中，我们可以使用 Velocity 模板来动态生成 HTML 代码，展示商品信息：

<html>
<head>
    <title>商品列表</title>
</head>
<body>
    <h1>商品列表</h1>
    <ul>
        #foreach( $product in $productList )
            <li>
                商品名称：$product.name <br>
                商品价格：$product.price <br>
                商品描述：$product.description
            </li>
        #end
    </ul>
</body>
</html>

在上述模板中，通过 “#foreach” 指令遍历 “(productList”集合，动态生成每个商品的HTML代码。通过“)product.name”、“$product.price” 等变量来获取商品的属性值。
配合 Spring MVC，我们可以将模板文件存放于 “src/main/resources/templates” 目录下，通过视图解析器统一管理。在 Spring MVC 的配置文件中，我们可以配置 Velocity 视图解析器，指定模板文件的后缀名、前缀路径等信息：

<bean id="viewResolver" class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
    <property name="suffix" value=".vm"/>
    <property name="prefix" value="/templates/"/>
    <property name="contentType" value="text/html;charset=UTF-8"/>
</bean>

这样，当用户请求某个页面时，Spring MVC 会根据请求的 URL 找到对应的控制器方法，控制器方法处理完业务逻辑后，将数据传递给 Velocity 模板，Velocity 模板根据数据生成最终的 HTML 页面返回给用户。通过这种方式，我们实现了前端页面与后端业务逻辑的分离，提高了代码的可维护性和可扩展性。

（三）多样化文本生成：邮件、配置文件、XML

邮件模板：在现代应用程序中，邮件通知是一种常见的交互方式。无论是用户注册通知、密码重置邮件还是订单状态更新通知，都需要根据不同的业务场景生成个性化的邮件内容。使用 Velocity，我们可以定义邮件模板，通过变量替换的方式动态生成邮件内容，支持 HTML 格式的邮件。

假设我们有一个用户注册通知邮件的模板，内容如下：

<html>
<head>
    <title>用户注册通知</title>
</head>
<body>
    <h1>欢迎注册，$user.name！</h1>
    <p>您的注册账号为：$user.username</p>
    <p>请点击以下链接激活您的账号：<a href="$activationLink">$activationLink</a></p>
</body>
</html>

在发送邮件时，我们只需要创建一个 VelocityContext 对象，将用户信息和激活链接等数据放入其中，然后使用 Velocity 引擎将模板和数据合并，生成最终的邮件内容，再通过邮件发送工具将邮件发送给用户。

配置文件：在不同的运行环境中，应用程序可能需要不同的配置信息，如数据库连接信息、日志级别、服务器地址等。使用 Velocity，我们可以根据环境参数生成差异化的配置文件。假设我们有一个数据库连接配置文件的模板，内容如下：

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://${db.host}:${db.port}/${db.database}?useUnicode=true&characterEncoding=utf-8
jdbc.username=${db.username}
jdbc.password=${db.password}

在应用程序启动时，我们可以读取环境变量或配置中心的配置信息，创建一个 VelocityContext 对象，将数据库连接相关的参数放入其中，然后使用 Velocity 引擎将模板和数据合并，生成最终的配置文件，应用程序再读取这个配置文件来获取数据库连接信息。

XML/JSON 生成：在前后端数据交互中，XML 和 JSON 是两种常见的数据格式。使用 Velocity，我们可以通过模板定义 XML 或 JSON 的结构，动态填充接口返回的数据。假设我们有一个获取用户列表的接口，需要将用户数据以 JSON 格式返回，我们可以定义如下 Velocity 模板：

{
    "users": [
        #foreach( $user in $userList )
            {
                "id": $user.id,
                "name": "$user.name",
                "age": $user.age
            }#if( $velocityCount < $userList.size() ),#end
        #end
    ]
}

在接口实现中，我们将用户列表数据放入 VelocityContext 对象中，然后使用 Velocity 引擎将模板和数据合并，生成最终的 JSON 字符串返回给前端。通过这种方式，我们可以方便地生成符合特定格式要求的 XML 或 JSON 数据，提高数据交互的效率和准确性。

四、VTL 语法详解：从基础到进阶

（一）变量与表达式

基础引用：在 Velocity 模板语言（VTL）中，变量引用是最基本的操作之一。我们可以使用 “({variable}”（严格模式）或“)variable”（简化模式）来引用变量。在一个用户信息展示的模板中，我们可能有如下代码：

<html>
<head>
    <title>用户信息</title>
</head>
<body>
    <p>用户名：${user.username}</p>
    <p>年龄：${user.age}</p>
</body>
</html>

在上述代码中，“({user.username}”和“){user.age}” 分别引用了 “user” 对象的 “username” 和 “age” 属性。这里使用大括号可以避免解析歧义，特别是当变量名与周围的文本容易混淆时。如果我们使用简化模式 “$user.username”，当周围文本复杂时，可能会导致解析错误。因此，推荐在大多数情况下使用大括号模式，以确保代码的准确性和可读性。

安静引用：当我们不确定一个变量是否存在时，可以使用安静引用 “$!variable”。这种引用方式在变量不存在时，不会输出原始的变量名，而是输出一个空字符串。在一个表单输入框中，我们可能希望在没有默认值时，输入框为空：

<input type="text" name="email" value="$!user.email">

在上述代码中，如果 “user.email” 不存在，输入框的 “value” 属性将为空字符串，而不是显示 “$user.email”。这在前端页面展示中非常有用，可以避免因变量缺失而导致的页面显示异常。

对象属性：VTL 支持通过点号（.）来访问对象的属性，这使得我们可以方便地获取对象的各种信息。“({user.name}”实际上等价于在Java代码中调用“user.getName()”方法。而且，VTL还支持链式访问，例如“){user.address.city}”，它会先获取 “user” 对象的 “address” 属性，然后再获取 “address” 对象的 “city” 属性。在一个电商系统中，我们可能有如下代码来展示商品的详细信息：

<html>
<head>
    <title>商品详情</title>
</head>
<body>
    <h1>${product.name}</h1>
    <p>价格：${product.price}</p>
    <p>描述：${product.description}</p>
    <p>商家：${product.seller.name}</p>
    <p>商家地址：${product.seller.address.city}</p>
</body>
</html>

在上述代码中，通过链式访问，我们可以轻松地展示商品的名称、价格、描述，以及商家的名称和地址等信息。这种简洁的语法大大提高了代码的编写效率和可读性。

（二）控制结构

条件判断：在 VTL 中，条件判断是通过 “#if”、“#elseif” 和 “#else” 指令来实现的。这些指令允许我们根据不同的条件来决定模板的输出内容。在一个用户权限验证的场景中，我们可能有如下代码：

#set( $isAdmin = $user.isAdmin )
#if( $isAdmin )
    <p>欢迎管理员，$user.username！您拥有所有权限。</p>
#elseif( $user.isVIP )
    <p>欢迎VIP用户，$user.username！您拥有部分高级权限。</p>
#else
    <p>欢迎普通用户，$user.username！请享受基本服务。</p>
#end

在上述代码中，首先通过 “#set” 指令定义了一个变量 “(isAdmin”，用于表示用户是否为管理员。然后，通过“#if”指令判断“)isAdmin” 的值，如果为真，则输出管理员欢迎信息；如果为假，则通过 “#elseif” 指令判断用户是否为 VIP 用户，如果是，则输出 VIP 用户欢迎信息；如果都不是，则通过 “#else” 指令输出普通用户欢迎信息。

循环遍历：循环遍历是 VTL 中另一个重要的控制结构，主要通过 “#foreach” 指令来实现。该指令允许我们遍历集合、数组等数据结构，并对每个元素执行相同的操作。在一个商品列表展示的场景中，我们可能有如下代码：

<ul>
    #foreach( $product in $productList )
        <li>
            <h2>${product.name}</h2>
            <p>价格：${product.price}</p>
            <p>描述：${product.description}</p>
        </li>
    #end
</ul>

在上述代码中，“#foreach ( (product in )productList )” 表示对 “(productList”集合中的每个元素进行遍历，每次遍历将当前元素赋值给“)product” 变量。然后，在循环体中，我们可以通过 “$product” 变量来访问每个商品的名称、价格和描述等信息，并将其展示在 HTML 页面中。

此外，“(velocityCount”是一个内置变量，它记录了当前循环的次数（从1开始）。在一个分页展示的场景中，我们可能需要显示当前页码，此时就可以使用“)velocityCount” 变量：

<ul>
    #foreach( $page in $pageList )
        <li><a href="?page=$velocityCount">$velocityCount</a></li>
    #end
</ul>

在上述代码中，通过 “$velocityCount” 变量，我们可以生成带有页码的链接，方便用户进行分页浏览。

（三）模板复用与宏定义

文件包含：在大型项目中，模板的复用是提高开发效率的关键。VTL 提供了 “#include” 和 “#parse” 指令来实现文件包含和模板复用。“#include ("common/header.vm")” 指令用于引入静态内容，它会将指定的模板文件内容直接插入到当前位置，但不会对插入的内容进行 Velocity 解析。在一个网站的页面模板中，我们可能有如下代码：

#!html
#set( $title = "首页" )
#include("common/header.vm")
    <h1>欢迎来到我的网站</h1>
    <p>这是首页的内容。</p>
#include("common/footer.vm")

在上述代码中，“#include ("common/header.vm")” 和 “#include ("common/footer.vm")” 分别引入了网站的头部和底部模板，这样可以避免在每个页面中重复编写头部和底部的代码。

而 “#parse ("macro.vm")” 指令则会解析并执行子模板逻辑，它可以用于复用复杂的模板逻辑。在一个商品展示的场景中，我们可能有一个专门的模板文件 “product_display.vm” 用于展示单个商品的详细信息，在商品列表页面中，我们可以通过 “#parse” 指令来复用这个模板：

<ul>
    #foreach( $product in $productList )
        #parse("product_display.vm")
    #end
</ul>

在上述代码中，每次循环都会解析并执行 “product_display.vm” 模板，将当前商品的信息展示出来。

宏定义：宏定义是 VTL 中另一个强大的功能，它允许我们封装重复的逻辑，并通过参数传递来实现灵活的复用。通过 “#macro” 指令，我们可以定义一个宏，然后在模板中多次调用。在一个生成链接的场景中，我们可能有如下宏定义：

#macro( generateLink $text $url )
    <a href="$url">$text</a>
#end

在上述代码中，我们定义了一个名为 “generateLink” 的宏，它接受两个参数 “(text”和“)url”，用于生成一个链接。在模板中，我们可以通过以下方式调用这个宏：

#generateLink("点击这里", "https://www.example.com")

这样就会生成一个链接：点击这里。通过宏定义，我们可以将一些常用的逻辑封装起来，提高代码的复用性和可维护性。

五、与主流模板引擎的对比与选型建议

在 Java 后端开发的广袤天地中，Velocity 并非孤身奋战，FreeMarker、Thymeleaf 等都是其有力的竞争者，它们各有千秋，适用于不同的场景。为了更清晰地了解 Velocity 在众多模板引擎中的地位，我们来进行一番全面的对比。

特性	Velocity	FreeMarker	JSP	Thymeleaf
学习曲线	低（语法简洁）	中（功能复杂）	中（混合 Java 代码）	中（HTML 方言）
代码分离性	严格分离	严格分离	部分混合	分离（HTML 友好）
表达式语言	简单直观	丰富强大	EL 表达式	类似 EL 表达式
动态内容生成	高（轻量级解析）	中（复杂逻辑）	高（编译为 Class）	中（动态解析）
适用场景	代码生成、简单文本模板	复杂 Web 页面、国际化需求	传统 Java Web 项目	HTML 原型开发、Spring Boot 项目
性能表现	高效，轻量级解析	中，复杂逻辑处理	高，编译后执行	中，动态解析性能一般

从上述对比中，我们可以看出：

代码生成、简单文本模板：首选 Velocity（语法简单，Java 集成度高）。在代码生成方面，Velocity 简洁的语法能够让开发人员快速定义模板结构，与 Java 代码的高度集成性使得它能够方便地获取和处理 Java 对象，从而高效地生成各种代码文件。在生成 Java 实体类代码时，Velocity 可以根据数据库表结构信息，快速生成对应的 Java 类文件，包括类的属性、构造方法和 Getter/Setter 方法等。

复杂 Web 页面、国际化需求：FreeMarker（内置更多数据处理函数）。FreeMarker 提供了丰富的数据处理函数和强大的表达式语言，能够方便地对数据进行格式化、转换等操作，非常适合处理复杂的 Web 页面逻辑和国际化需求。在一个需要展示多种语言的电商网站中，FreeMarker 可以根据用户的语言偏好，动态加载相应的语言资源文件，实现页面内容的国际化展示。

HTML 原型开发、Spring Boot 项目：Thymeleaf（原生支持 HTML，与 Spring 生态集成度高）。Thymeleaf 以其对 HTML 的原生支持和与 Spring Boot 的完美融合而备受青睐。在 HTML 原型开发阶段，Thymeleaf 可以直接在 HTML 文件中嵌入模板表达式，方便前端开发人员进行页面设计和预览。在 Spring Boot 项目中，Thymeleaf 可以与 Spring MVC 无缝集成，实现高效的 Web 开发。

六、最佳实践：避坑指南与性能优化

（一）常见问题解决方案

变量解析异常：在使用 Velocity 模板时，变量解析异常是一个常见的问题。如果变量名与文本混淆，可能会导致解析错误。在模板中，如果我们想使用 “(userName”变量，但写成了“)userName”，Velocity 可能会将其解析为 “(user”和“Name”两个部分，从而导致错误。为了避免这种情况，我们应该使用“){variable}” 的形式来明确变量范围，将 “(userName”写为“){user} Name”，这样 Velocity 就能正确解析变量。

资源加载路径：正确配置资源加载路径是确保 Velocity 能够找到模板文件的关键。如果模板文件的路径配置不正确，Velocity 将无法加载模板，从而导致错误。通过 “classpath.resource.loader.class” 配置类路径加载器，可以让 Velocity 从类路径中加载模板文件。在 Maven 项目中，我们通常将模板文件放在 “src/main/resources/” 目录下，这样 Velocity 就能通过类路径加载器找到模板文件。如果我们将模板文件放在其他目录下，就需要相应地修改资源加载路径的配置。

空指针处理：在模板中使用变量时，如果变量可能不存在，就需要进行空指针处理，以避免控制台报错。如果我们在模板中使用 “(variable”，而“variable”在VelocityContext中不存在，就会在控制台输出“)variable”，这可能会影响页面的展示效果。为了避免这种情况，我们应该始终使用 “$!variable” 的形式来处理可能不存在的变量，这样即使变量不存在，也不会在控制台报错，而是输出一个空字符串。

（二）性能优化技巧

缓存模板：在高并发场景下，模板的重复初始化会带来较大的性能开销。通过使用 VelocityEngine 单例模式，我们可以复用引擎实例，避免重复初始化。在一个 Web 应用中，我们可以将 VelocityEngine 实例定义为一个单例对象，在应用启动时初始化，然后在整个应用生命周期中复用这个实例。这样，每次渲染模板时，就不需要重新初始化 VelocityEngine，从而提高了性能。

预编译模板：在生产环境中，启用模板预编译可以显著提升渲染速度。通过设置 “ve.setProperty ("runtime.references.strict", "true")”，我们可以开启严格模式，在模板加载时进行预编译。这样，在实际渲染时，就不需要再次解析和编译模板，直接使用预编译后的结果，大大提高了渲染效率。在一个电商网站中，商品详情页面的模板可能会被频繁访问，通过预编译模板，可以减少页面加载时间，提升用户体验。

简化模板逻辑：模板的主要职责是展示数据，因此应该尽量简化模板逻辑，将复杂的数据处理移至 Java 层。遵循 “模板无逻辑” 原则，不仅可以提高模板的可读性和可维护性，还能提升性能。在一个订单列表页面中，如果需要对订单数据进行复杂的计算和处理，我们应该在 Java 层完成这些操作，然后将处理后的结果传递给模板进行展示。这样，模板只需要负责展示数据，而不需要进行复杂的逻辑处理，从而提高了渲染效率。

七、总结：开启高效开发新范式

Velocity 凭借轻量级设计、Java 深度集成和灵活的模板语法，成为代码生成与动态内容生成的首选工具。通过本文的系统解析，你已掌握从基础语法到实战应用的核心知识，接下来建议通过实际项目练习（如自定义 MyBatis 代码生成器）巩固所学。记住，高效开发的关键在于合理利用工具解放生产力 ——Velocity 正是这样一把助力你跳出重复劳动的「瑞士军刀」。你在开发中遇到过哪些重复代码问题？尝试用 Velocity 解决后有什么体会？欢迎在评论区分享你的经验！