tio-boot 整合 Groovy

在现代 Java 开发中，为了提高开发效率和代码灵活性，Groovy 作为一种运行在 Java 平台上的动态语言，被广泛应用于快速开发、脚本编写、自动化测试以及构建工具中。本文介绍了 Groovy 的主要特点、在 tio-boot 中整合 Groovy 脚本的实现方式，以及详细的代码示例和说明。

---

1. 什么是 Groovy

Groovy 是一种与 Java 完全兼容的动态语言，它不仅具备简洁的语法，还集成了现代化的编程特性。Groovy 的设计初衷就是为了提高开发人员的生产力，使得开发者能够更加专注于业务逻辑，而不必被冗长的 Java 语法所束缚。

主要特点

1. 简化的语法
   Groovy 的语法比 Java 更加精简。比如，分号可以省略，方法定义可以省略返回类型（如果不需要显式指定的话），这都大大减少了代码冗余。

2. 动态特性
   作为动态语言，Groovy 支持运行时元编程、动态类型和闭包等特性，使得代码在编写脚本、快速开发和原型设计时非常灵活。

3. 强大的集合处理能力
   Groovy 为集合操作提供了丰富的内建方法，如 each, collect, find, groupBy 等，这些 API 能够简化对集合数据的遍历和处理。

4. 内建对 XML 与 JSON 的支持
   Groovy 内置对 XML 与 JSON 数据的处理能力，使得解析和生成这类数据格式变得非常便捷。

5. 闭包支持
   Groovy 的闭包机制是一种轻量级的代码块，能够简化 Java 中匿名内部类的写法，同时也使得函数式编程更加直观。

6. 编译与脚本双模式
   Groovy 代码既可以编译成 Java 字节码，也可以作为脚本直接运行，这为开发人员提供了极大的灵活性。

7. 与 Java 无缝集成
   Groovy 可以直接调用所有 Java 类库，Java 代码也能轻松调用 Groovy 编写的代码。这使得 Groovy 能够在现有的 Java 项目中作为辅助语言使用，增强了项目的扩展性和可维护性。

应用场景

• 快速开发：利用 Groovy 的动态特性和简洁语法，可以迅速开发原型或小型应用。
• 测试脚本：Groovy 常用于编写自动化测试脚本，例如借助 Spock 框架进行单元测试和集成测试。
• 构建脚本：Groovy 是 Gradle 构建工具的基础语言，使得项目构建和部署脚本的编写更为简单和灵活。
• Web 应用开发：通过与 Grails 框架结合，Groovy 可用于构建全栈 Web 应用，提供类似 Ruby on Rails 的开发体验。

---

2. 在 tio-boot 中整合 Groovy 脚本

tio-boot 作为一个基于 Java 的高性能网络通信框架，通过整合 Groovy 脚本，可以让开发者在处理 HTTP 请求、动态执行业务逻辑时拥有更高的灵活性。下面详细介绍如何在 tio-boot 中调用 Groovy 脚本处理 Web 请求。

2.1 添加 Groovy 依赖

在使用 Groovy 脚本前，首先需要在项目中添加 Groovy 的依赖。以 Maven 项目为例，在 pom.xml 中加入如下依赖：

<dependency>
  <groupId>org.codehaus.groovy</groupId>
  <artifactId>groovy</artifactId>
  <version>3.0.9</version> <!-- 根据实际需求选择合适的版本 -->
</dependency>

此依赖确保项目可以编译并运行 Groovy 脚本。

2.2 编写 Groovy 脚本处理器

为了能够在 Java 代码中动态执行 Groovy 脚本，我们需要创建一个脚本管理器。该管理器负责加载脚本文件、读取脚本内容，并调用 GroovyShell 执行脚本代码。下面是一个示例实现：

package com.litongjava.grovvy;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.stream.Collectors;

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.tio.utils.hutool.ResourceUtil;

import groovy.lang.GroovyShell;

public class GroovyScriptManager {

  /**
   * 直接执行传入的脚本字符串，并返回执行结果。
   */
  public static Object executeScript(String script) {
    // 从 AOP 框架中获取 GroovyShell 实例（可保证单例或配置统一）
    GroovyShell shell = Aop.get(GroovyShell.class);
    return shell.evaluate(script);
  }

  /**
   * 执行位于 classpath 中的脚本文件。
   *
   * @param filename 脚本文件在 classpath 中的路径
   * @param <T>      返回结果的泛型类型
   * @return 脚本执行结果
   * @throws IllegalArgumentException 如果脚本文件未找到
   */
  @SuppressWarnings("unchecked")
  public static <T> T executeClasspathScript(String filename) {
    try (InputStream inputStream = ResourceUtil.getResourceAsStream(filename)) {
      if (inputStream != null) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
          String script = reader.lines().collect(Collectors.joining("\n"));
          return (T) executeScript(script);
        }
      } else {
        throw new IllegalArgumentException("Script file not found: " + filename);
      }
    } catch (Exception e) {
      throw new RuntimeException("Error executing Groovy script", e);
    }
  }
}

说明
上述代码通过 GroovyShell 对象动态执行传入的 Groovy 脚本，同时提供了从 classpath 加载脚本的功能。通过 AOP 框架获取 GroovyShell 实例，可确保配置和依赖注入的一致性。

2.3 创建 Groovy 脚本示例

在项目的 src/main/resources/groovy 目录下，新建一个脚本文件 web_hello.groovy，用于处理 HTTP 请求。示例如下：

// web_hello.groovy

import com.litongjava.tio.http.common.HttpRequest
import com.litongjava.tio.http.common.HttpResponse
import com.litongjava.tio.boot.http.TioControllerContext
import com.litongjava.tio.utils.resp.RespBodyVo

// 获取请求和响应对象
def request = TioControllerContext.getRequest()
def response = TioControllerContext.getResponse()

// 模拟执行数据库查询（这里只是打印 SQL 语句）
def sql = "select * from test_data where name=?"
println(sql)

// 设置响应内容，将 SQL 语句返回给客户端
response.setJson(RespBodyVo.ok(sql))
return response

说明
脚本中首先获取了 HTTP 请求和响应对象，然后模拟执行了一个数据库查询（打印 SQL），最后将查询结果封装在 JSON 响应中返回给客户端。实际开发中，可根据业务需求替换为具体的业务逻辑。

2.4 配置 HTTP 请求处理

为了让 tio-boot 能够在接收到 HTTP 请求时调用上述 Groovy 脚本，需要在项目中添加 HTTP 请求处理的配置类。如下示例展示了如何将 /hi 路由与 Groovy 脚本绑定：

package com.litongjava.tio.web.hello.config;

import com.litongjava.jfinal.aop.annotation.AInitialization;
import com.litongjava.jfinal.aop.annotation.BeforeStartConfiguration;
import com.litongjava.tio.web.hello.GroovyScriptManager;
import com.litongjava.tio.http.server.handler.SimpleHttpRoutes;

@BeforeStartConfiguration
public class HttpServerRequestHandlerConfig {

    @AInitialization
    public void httpRoutes() {
        SimpleHttpRoutes simpleHttpRoutes = new SimpleHttpRoutes();
        // 绑定 /hi 路由，执行位于 classpath 下的 groovy/web_hello.groovy 脚本
        simpleHttpRoutes.add("/hi", (request) -> {
            String filename = "groovy/web_hello.groovy";
            return GroovyScriptManager.executeClasspathScript(filename);
        });

        // 将路由配置应用到 tio-boot 服务器中
        TioBootServer.me().setHttpRoutes(simpleHttpRoutes);
    }
}

说明
通过配置 SimpleHttpRoutes，将 /hi 路由与脚本执行逻辑进行绑定。当 HTTP 请求到达 /hi 时，系统会加载并执行 web_hello.groovy 脚本，并将脚本返回的结果作为 HTTP 响应发送回客户端。

2.5 测试示例

启动服务器后，当客户端发送请求至 /hi 路由时，将获得如下响应数据：

{
  "data": "select * from test_data where name=?",
  "ok": true,
  "code": 1,
  "msg": null
}

这表明 Groovy 脚本成功执行，并返回了预期的 SQL 语句。此机制同样适用于更多的业务场景，比如动态执行业务逻辑、调用外部服务、或与数据库进行交互等。

---

3. 通过 HTTP 请求执行 Groovy 代码

除了通过固定脚本文件处理请求外，还可以通过 HTTP 请求直接传递 Groovy 代码并执行。下面提供一个示例：

3.1 编写 HTTP 请求处理类

在项目中创建一个专门用于处理 Groovy 脚本执行的 HTTP 请求处理器，如下所示：

package com.litongjava.open.chat.httphandler;

import com.litongjava.annotation.Post;
import com.litongjava.annotation.RequestPath;
import com.litongjava.tio.boot.grovvy.GroovyScriptManager;
import com.litongjava.tio.boot.http.TioRequestContext;
import com.litongjava.tio.http.common.HttpRequest;

@RequestPath("/groovy")
public class GroovyHandler {

    @Post
    public com.litongjava.tio.http.common.HttpResponse index(HttpRequest request) {
        // 获取响应对象
        com.litongjava.tio.http.common.HttpResponse response = TioRequestContext.getResponse();
        // 从请求体中获取要执行的 Groovy 代码
        String bodyString = request.getBodyString();
        Object result = GroovyScriptManager.executeScript(bodyString);
        if (result != null) {
            response.setString(result.toString());
        }
        return response;
    }
}

3.2 示例请求与返回

请求体：

import com.litongjava.tio.utils.environment.EnvUtils

def baseUrl = EnvUtils.getStr("SEARXNG_API_BASE")
def endpoint = "${baseUrl}/search"

return endpoint

返回数据：

https://searx-ng.fly.dev/search

说明
该处理器通过 POST 请求接收任意的 Groovy 脚本代码，并立即执行。执行结果会作为字符串返回。此特性为动态需求（例如运行时代码更新、脚本调试等）提供了极大便利，但在实际使用中需要注意安全问题，防止代码注入和未经授权的执行。

---

4. 总结

通过本文的介绍，我们详细了解了：

• Groovy 的优势与应用场景：简化语法、动态特性、强大的集合处理能力以及与 Java 的无缝集成使得 Groovy 成为现代开发中不可或缺的语言工具。
• 如何在 tio-boot 中整合 Groovy 脚本：通过添加依赖、编写脚本管理器、创建示例脚本以及配置 HTTP 请求处理器，可以方便地将 Groovy 脚本嵌入到 tio-boot 应用中。
• 动态执行 Groovy 代码的实现：不仅可以加载 classpath 下的脚本文件，还能通过 HTTP 请求动态执行传递的 Groovy 脚本，极大提升了应用的灵活性和扩展性。

这种整合方式不仅提高了代码的灵活性，也为开发者提供了一种高效、简洁的处理复杂业务逻辑的手段。无论是快速开发原型还是构建稳定的生产环境，tio-boot 与 Groovy 的结合都能满足多样化的需求。

---

以上便是关于 tio-boot 整合 Groovy 脚本的完整文档，希望能为您在开发中提供有价值的指导和参考。