使用 Tio-Boot 整合 tdlight

• 简介
• 环境准备
• 添加依赖
  • 依赖说明
• 配置文件设置
  • 配置项说明
• 核心代码实现
  • TelegramCan 类
  • MyBotApp 类
  • TelegramConfig 类
  • 代码详解
• 测试与验证
  • 发送数据示例
  • 回复内容
• 同步使用示例
  • 代码解释
• 总结
  • 关键步骤回顾

本文将详细介绍如何使用 Tio-Boot 框架整合 Telegram Bots。通过本文，您将学习如何配置项目依赖、设置必要的配置文件、编写核心代码以及进行测试。

简介

Tio-Boot 是一个基于 Java 的高性能网络框架，适用于快速构建各种网络应用。本文将指导您如何将 Telegram Bot 集成到 Tio-Boot 应用中，利用 TDLight 库与 Telegram API 进行交互，实现基本的消息处理和命令响应功能。

环境准备

在开始之前，请确保您已经具备以下环境：

• Java Development Kit (JDK): 建议使用 JDK 1.8 或更高版本。
• Maven: 用于项目管理和依赖管理。
• Telegram Bot Token: 您需要在 Telegram BotFather 创建一个 Bot 并获取其 Token。

添加依赖

首先，您需要在 pom.xml 文件中添加必要的依赖和配置。这些依赖包括 Tio-Boot 框架、TDLight 库、Lombok 以及其他辅助库。

  <properties>
    <!-- 项目属性 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <maven.compiler.target>${java.version}</maven.compiler.target>

    <!-- 版本属性 -->
    <lombok-version>1.18.30</lombok-version>
    <fastjson2.version>2.0.52</fastjson2.version>

    <!-- 应用程序属性 -->
    <final.name>telegram-tio-boot</final.name>
    <main.class>com.example.telegram.TelegramBotApp</main.class>
  </properties>

  <repositories>
    <!-- 添加 MCHV Maven 仓库 -->
    <repository>
      <id>mchv</id>
      <name>MCHV Apache Maven Packages</name>
      <url>https://mvn.mchv.eu/repository/mchv/</url>
    </repository>
  </repositories>

  <dependencyManagement>
    <dependencies>
      <!-- TDLight BOM 管理 -->
      <dependency>
        <groupId>it.tdlight</groupId>
        <artifactId>tdlight-java-bom</artifactId>
        <version>3.4.0+td.1.8.26</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <!-- 日志框架 -->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.2.3</version>
    </dependency>

    <!-- Tio-Boot 框架 -->
    <dependency>
      <groupId>com.litongjava</groupId>
      <artifactId>tio-boot-admin</artifactId>
      <version>1.0.0</version>
    </dependency>

    <!-- TDLight Java 客户端 -->
    <dependency>
      <groupId>it.tdlight</groupId>
      <artifactId>tdlight-java</artifactId>
      <classifier>jdk8</classifier>
      <!-- 版本由 BOM 管理 -->
    </dependency>
    <!-- TDLight 本地库（Linux AMD64 示例） -->
    <dependency>
      <groupId>it.tdlight</groupId>
      <artifactId>tdlight-natives</artifactId>
      <classifier>linux_amd64_gnu_ssl3</classifier>
    </dependency>
    <!-- TDLight 本地库（Windows AMD64 示例） -->
    <dependency>
      <groupId>it.tdlight</groupId>
      <artifactId>tdlight-natives</artifactId>
      <classifier>windows_amd64</classifier>
    </dependency>

    <!-- Lombok 用于简化代码 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok-version}</version>
      <optional>true</optional>
      <scope>provided</scope>
    </dependency>

    <!-- MySQL 连接器 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.46</version>
    </dependency>

    <!-- JUnit 用于测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

依赖说明

• tdlight-java-bom: 管理 TDLight 库的版本，确保各个模块版本一致。
• tdlight-java: TDLight 的 Java 客户端，用于与 Telegram API 交互。
• tdlight-natives: TDLight 的本地库，根据运行环境选择合适的 classifier。
• tio-boot-admin: Tio-Boot 的管理模块，提供基础的服务功能。
• Lombok: 简化 Java 代码的编写，如自动生成 getter/setter 等。
• logback-classic: 强大的日志框架，常用于 Java 应用中记录日志。

配置文件设置

在项目的 src/main/resources 目录下创建 app.properties 文件，用于存储 Telegram API 的相关配置。

telegram.api.id=
telegram.api.hash=
bot.authToken=

配置项说明

• telegram.api.id: 您从 Telegram 获取的 API ID。
• telegram.api.hash: 您从 Telegram 获取的 API Hash。
• bot.authToken: 您的 Telegram Bot Token，由 BotFather 提供。

核心代码实现

接下来，我们将编写关键的 Java 类，实现 Telegram Bot 的核心功能。

TelegramCan 类

此类用于保存 SimpleTelegramClient 的实例，方便在不同类中访问。

package it.tdlight.example.can;

import it.tdlight.client.SimpleTelegramClient;

public class TelegramCan {
  public static SimpleTelegramClient client;
}

MyBotApp 类

MyBotApp 类包含处理 Telegram 更新的逻辑，包括授权状态更新、新消息处理以及命令响应。

package it.tdlight.example.bots;

import java.util.concurrent.CompletableFuture;

import it.tdlight.example.can.TelegramCan;
import it.tdlight.jni.TdApi;
import it.tdlight.jni.TdApi.AuthorizationState;
import it.tdlight.jni.TdApi.FormattedText;
import it.tdlight.jni.TdApi.InputMessageText;
import it.tdlight.jni.TdApi.Message;
import it.tdlight.jni.TdApi.MessageContent;
import it.tdlight.jni.TdApi.SendMessage;
import it.tdlight.jni.TdApi.TextEntity;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyBotApp {

  public void onUpdateAuthorizationState(TdApi.UpdateAuthorizationState update) {
    AuthorizationState authorizationState = update.authorizationState;
    if (authorizationState instanceof TdApi.AuthorizationStateReady) {
      log.info("Logged in");
    } else if (authorizationState instanceof TdApi.AuthorizationStateClosing) {
      log.info("Closing...");
    } else if (authorizationState instanceof TdApi.AuthorizationStateClosed) {
      log.info("Closed");
    } else if (authorizationState instanceof TdApi.AuthorizationStateLoggingOut) {
      log.info("Logging out...");
    }
  }

  public void onUpdateNewMessage(TdApi.UpdateNewMessage update) {
    log.info("update:{}", update);
    MessageContent messageContent = update.message.content;
    String text;
    if (messageContent instanceof TdApi.MessageText) {
      text = ((TdApi.MessageText) messageContent).text.text;
    } else {
      text = String.format("(%s)", messageContent.getClass().getSimpleName());
    }

    if (text.startsWith("/get_chat_id")) {
      long chatId = update.message.chatId;
      // Send a test message to the admin
      InputMessageText txt = new InputMessageText();
      txt.text = new FormattedText(chatId + " from maxkb", new TextEntity[0]);

      SendMessage req = new SendMessage();
      req.chatId = chatId;
      req.inputMessageContent = txt;

      // 异步发送消息
      CompletableFuture<Message> future = TelegramCan.client.sendMessage(req, false);
      future.thenAccept(result -> {
        log.info("已发送消息: {}", result);
      }).exceptionally(e -> {
        log.error("发送消息失败", e);
        return null;
      });

    }
  }

  public void onStopCommand(TdApi.Chat chat, TdApi.MessageSender commandSender, String arguments) {
    if (isAdmin(commandSender)) {
      log.info("Received stop command. Closing Telegram client...");
      if (TelegramCan.client != null) {
        TelegramCan.client.sendClose();
      }
    }
  }

  public boolean isAdmin(TdApi.MessageSender sender) {
    return sender instanceof TdApi.MessageSenderUser && ((TdApi.MessageSenderUser) sender).userId == 6276672963L;
  }
}

TelegramConfig 类

TelegramConfig 类负责初始化 TDLight 客户端、配置认证信息、添加更新处理器以及管理客户端的生命周期。

package it.tdlight.example.config;

import java.nio.file.Path;
import java.nio.file.Paths;

import com.litongjava.annotation.AConfiguration;
import com.litongjava.annotation.Initialization;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.thread.TioThreadUtils;

import it.tdlight.Init;
import it.tdlight.Log;
import it.tdlight.Slf4JLogMessageHandler;
import it.tdlight.client.APIToken;
import it.tdlight.client.AuthenticationSupplier;
import it.tdlight.client.SimpleAuthenticationSupplier;
import it.tdlight.client.SimpleTelegramClientBuilder;
import it.tdlight.client.SimpleTelegramClientFactory;
import it.tdlight.client.TDLibSettings;
import it.tdlight.example.bots.MyBotApp;
import it.tdlight.example.can.TelegramCan;
import it.tdlight.jni.TdApi;
import it.tdlight.util.UnsupportedNativeLibraryException;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@AConfiguration
public class TelegramConfig {

  // 管理 SimpleTelegramClientFactory 的生命周期
  private SimpleTelegramClientFactory clientFactory;

  @Initialization
  public void config() {
    // 从配置文件中读取 Telegram API 信息
    int apiId = EnvUtils.getInt("telegram.api.id");
    String apiHash = EnvUtils.getStr("telegram.api.hash");
    String botToken = EnvUtils.getStr("bot.authToken");

    // 初始化 TDLight 本地库
    try {
      Init.init();
    } catch (UnsupportedNativeLibraryException e) {
      log.error("初始化 TDLight 本地库失败", e);
      return;
    }

    // 设置日志级别
    Log.setLogMessageHandler(1, new Slf4JLogMessageHandler());

    // 初始化客户端工厂
    clientFactory = new SimpleTelegramClientFactory();

    // 配置 API Token
    APIToken apiToken = new APIToken(apiId, apiHash);

    // 配置 TDLib 设置
    TDLibSettings settings = TDLibSettings.create(apiToken);

    // 设置会话目录
    String botIdString = botToken.split(":")[1];
    Path sessionPath = Paths.get(botIdString);
    settings.setDatabaseDirectoryPath(sessionPath.resolve("data"));
    settings.setDownloadedFilesDirectoryPath(sessionPath.resolve("downloads"));

    // 准备客户端构建器
    SimpleTelegramClientBuilder clientBuilder = clientFactory.builder(settings);

    // 配置认证信息（使用 Bot Token）
    SimpleAuthenticationSupplier<?> authenticationData = AuthenticationSupplier.bot(botToken);

    // 获取 MyBotApp 实例
    MyBotApp botApp = Aop.get(MyBotApp.class);

    // 添加更新处理器
    clientBuilder.addUpdateHandler(TdApi.UpdateAuthorizationState.class, botApp::onUpdateAuthorizationState);
    clientBuilder.addCommandHandler("stop", botApp::onStopCommand);
    clientBuilder.addUpdateHandler(TdApi.UpdateNewMessage.class, botApp::onUpdateNewMessage);

    // 在单独线程中构建客户端，防止阻塞主线程
    TioThreadUtils.submit(() -> {
      try {
        log.info("开始构建 Telegram 客户端");
        TelegramCan.client = clientBuilder.build(authenticationData);
        log.info("Telegram 客户端构建成功: {}", TelegramCan.client);
      } catch (Exception e) {
        log.error("构建 Telegram 客户端失败", e);
      }
    });

    log.info("客户端构建任务已提交到单独线程");

    // 注册销毁方法，在应用关闭时执行
    HookCan.me().addDestroyMethod(this::shutdown);
  }

  /**
   * 关闭客户端工厂和 Telegram 客户端
   */
  public void shutdown() {
    if (clientFactory != null) {
      try {
        clientFactory.close();
        log.info("Telegram 客户端工厂已成功关闭");
      } catch (Exception e) {
        log.error("关闭 Telegram 客户端工厂失败", e);
      }
      try {
        TelegramCan.client.close();
        log.info("Telegram 客户端已成功关闭");
      } catch (Exception e) {
        log.error("关闭 Telegram 客户端失败", e);
      }
    }
  }
}

代码详解

• TelegramCan 类: 作为一个共享类，用于存储 SimpleTelegramClient 实例，便于在不同模块中访问和操作 Telegram 客户端。

• MyBotApp 类:

  • onUpdateAuthorizationState: 处理 Telegram 客户端的授权状态变化，如登录、关闭等。
  • onUpdateNewMessage: 处理新消息的到达。如果消息内容以 /get_chat_id 开头，则回复发送者的 chatId。
  • onStopCommand: 处理 /stop 命令，仅限管理员使用，执行关闭 Telegram 客户端的操作。
  • isAdmin: 判断消息发送者是否为管理员，通过用户 ID 进行验证。

• TelegramConfig 类:

  • config 方法:
    • 读取配置文件中的 Telegram API 信息。
    • 初始化 TDLight 本地库。
    • 配置日志处理器。
    • 设置 TDLib 的会话目录和下载目录。
    • 配置认证信息（使用 Bot Token）。
    • 添加更新处理器，包括授权状态更新、新消息处理和命令处理。
    • 在单独的线程中构建 Telegram 客户端，防止阻塞主线程。
    • 注册销毁方法，在应用关闭时正确关闭客户端和工厂。

测试与验证

在完成上述配置和代码编写后，您可以进行测试，确保 Telegram Bot 能够正常响应命令。

发送数据示例

以下是 Telegram 发送的一条消息示例，内容为 /get_chat_id 命令：

UpdateNewMessage {
  message = Message {
    id = 537919488
    senderId = MessageSenderChat {
      chatId = -1002446428074
    }
    chatId = -1002446428074
    ...
    content = MessageText {
      text = FormattedText {
        text = "/get_chat_id"
        entities = vector[1] {
          TextEntity {
            offset = 0
            length = 12
            type = TextEntityTypeBotCommand {
            }
          }
        }
      }
      ...
    }
    ...
  }
}

回复内容

当 Bot 接收到上述消息时，会回复以下内容：

-1002446428074 from maxkb

这表明 Bot 成功获取了发送者的 chatId 并进行了回复。

同步使用示例

除了处理新消息，您可能还希望在处理过程中同步获取一些信息。以下是一个示例，展示如何同步获取聊天标题：

TelegramCan.client.send(new TdApi.GetChat(chatId)).whenCompleteAsync((chatResult, error) -> {
  if (error != null) {
    log.error("无法获取聊天标题，聊天 ID: {}", chatId, error);
  } else {
    String title = chatResult.title;
    log.info("收到来自聊天 {}（ID: {}）的新消息: {}", title, chatId, text);
  }
});

代码解释

• send: 发送一个 GetChat 请求，以获取指定 chatId 的聊天信息。
• whenCompleteAsync: 异步处理结果，如果成功获取聊天信息，则记录聊天标题和消息内容；如果出错，则记录错误信息。

总结

本文详细介绍了如何使用 Tio-Boot 框架整合 Telegram Bots，包括项目依赖的配置、必要的配置文件设置、核心代码的实现以及测试方法。通过整合 TDLight 库，您可以轻松地与 Telegram API 进行交互，实现丰富的 Bot 功能。

关键步骤回顾

1. 添加依赖: 配置 pom.xml，引入 Tio-Boot、TDLight 及其他必要的库。
2. 配置文件: 设置 app.properties，存储 Telegram API 的相关信息。
3. 编写核心代码: 实现 TelegramCan、MyBotApp 和 TelegramConfig 类，完成客户端初始化、消息处理和命令响应。
4. 测试与验证: 通过发送命令消息，验证 Bot 的响应是否符合预期。

通过本文的指导，您应该能够成功地将 Telegram Bot 集成到 Tio-Boot 应用中，并根据需求扩展更多功能。如果在集成过程中遇到问题，请参考相关库的官方文档或寻求社区支持。