Agregar un bot de Telegram al proyecto: "Proyecto Java de la A a la Z"

Saludos, mis queridos amigos. Sí, sí, exactamente amigos. Ya me he familiarizado tanto con esta serie de artículos que aquellas personas que regularmente escriben su agradecimiento en los comentarios y/o demuestran que han leído y comprendido el material ya se han vuelto cercanas. Tú y yo avanzamos desde ambos lados hacia el mismo objetivo. Quieres entender, pero yo quiero explicar. Y tenemos el mismo objetivo final: una solicitud escrita que sea comprensible para usted de principio a fin. Es posible que ya hayas oído hablar de gran parte de lo que describiré en este artículo. No creo que les diga nada nuevo y extraordinario (pero en el marco del proyecto es necesario saber/repetir esto). En la primavera escribí un bot para mí, así que confiaremos en sus "patrones".

Escribimos JRTB-2

Haremos lo mismo que hicimos en el artículo con la tarea JRTB-0 :

1. Actualizamos la rama principal en el proyecto local usando la combinación ctrl + t .
2. Basado en la rama principal, creamos:
3. Agrega un robot.
4. Creamos una nueva confirmación con una descripción de lo que se ha hecho y la enviamos a GitHub.
5. Cree una solicitud de extracción para la rama principal y verifíquela nuevamente. Estamos esperando que se complete la compilación (acciones de github), fusionarla con la rama principal.
6. Cierra la tarea correspondiente.

¿Qué es un robot de Telegram?

Nosotros, los desarrolladores, podemos imaginarnos trabajando con un bot de Telegram como este: utilizamos su cliente para trabajar con ellos. Disponemos de una biblioteca preparada para trabajar. Hay un conjunto de acciones tras las cuales el bot de Telegram sabrá que está asociado a nuestro programa. Y ya dentro del programa aprenderemos a recibir cartas, comandos y de alguna manera procesarlos. Existe un comando en los robots de Telegram : comienza con una barra diagonal "/". Después de eso, inmediatamente escribimos la palabra juntos, y esto se considerará un comando. Por ejemplo, hay dos comandos que todo el mundo debería conocer:

• /start — empieza a trabajar con el bot;
• /stop - finaliza el trabajo con el bot.

El resto lo haremos nosotros mismos. Permítanme hacer una reserva de inmediato: haremos exactamente lo que aprendí y de la manera que aprendí. Y cuando trabaje con un bot, estoy seguro de que será posible hacerlo mejor. Y si alguien quiere hacer esto, estaré feliz y apoyaré este esfuerzo en todas las formas posibles. Por cierto, lo primero que sería genial si alguien me explicara cómo programar la descripción de los comandos a través del código, y no a través de la configuración del bot en Telegram. No aprendí esto. Tenemos varios artículos en nuestro recurso que describen cómo hacer un bot básico: hoy haremos algo similar. Si tienes más preguntas, te recomiendo que leas este artículo.

Crea un bot con BotFather

Para conectar un bot, primero debes crearlo. Telegram tiene un enfoque: crear un bot con su propio nombre único. También irá acompañado de un token (una cadena grande que funciona como una contraseña). Ya creé un bot para JavaRush: @javarush_community_bot . Este bot todavía está vacío y no puede hacer nada. Lo principal es que al final del nombre debe aparecer _bot . Para mostrar cómo hacer esto, crearé un bot en el que probaremos nuestra funcionalidad. En términos de proyectos reales, este sería un entorno de prueba. Y nuestro principal será el entorno de producción (prod - producción, es decir, el entorno real en el que se ejecutará el proyecto). Por supuesto, sería posible agregar otro entorno: un entorno sandbox: un entorno sandbox común, más modificable y accesible para todos los participantes en el desarrollo. Pero esto sólo complicará la situación en la etapa de creación del proyecto. Por ahora, creemos dos bots más para prueba y para entorno sandbox. El primer paso es crear (registrar) un bot en Telegram. Necesitamos encontrar el bot: @BotFather y escribirle el comando: /newbot. A continuación, se nos pide que le demos un nombre a este bot. Dado que se trata de un bot para tareas de prueba, su nombre será apropiado: [PRUEBA] JavarushBot Ahora es el momento de darle un nombre único por el cual siempre se pueda encontrar: su nombre de usuario: test_javarush_community Como dije anteriormente, debes agregar el _bot sufijo para nombre de usuario, así que escribimos nuevamente: test_javarush_community_bot ¡Y listo! El bot ha sido creado. Ahora, usando nombre de usuario y token, se puede conectar a nuestro proyecto. Por supuesto, para el buen funcionamiento del servidor de prueba, no mostraré el token (esencialmente una contraseña para acceder al bot) de este bot para que lo vea el público.

Conectamos el bot al proyecto.

No incluiremos la biblioteca como de costumbre, pero aprovecharemos inmediatamente nuestro esqueleto: SpringBoot. Tiene algo llamado Starter. Al incluir la biblioteca, podemos usarla para hacerle saber a SpringBoot que queremos configurar el proyecto correctamente. Si siguiéramos la ruta habitual, que se describe en muchos lugares, necesitaríamos crear una configuración en algún lugar que tuviera algo como esto:

ApiContextInitializer.init();
TelegramBotsApi telegramBotsApi = new TelegramBotsApi();
try {
  telegramBotsApi.registerBot(Bot.getBot());
} catch (TelegramApiRequestException e) {
  e.printStackTrace();
}

Aquí se crea un objeto con el que puedes establecer una conexión con el bot. En nuestro caso, el motor de arranque que queremos conectar hará todo por nosotros en algún lugar "debajo del capó" (esta es también una traducción de una frase de uso frecuente en TI: debajo del capó). Aquí hay un enlace a este iniciador . Puede ver inmediatamente en el archivo README.md qué es, por qué y cómo usarlo. Para conectarlo, sólo necesitas agregar esta dependencia a la memoria. Eso es todo :) Aquí está la dependencia requerida:

<dependency>
        <groupId>org.telegram</groupId>
        <artifactId>telegrambots-spring-boot-starter</artifactId>
        <version>5.0.1</version>
    </dependency>

Lo agregamos a nuestra memoria. Instalamos la versión como se esperaba y actualizamos el proyecto Maven. Según la descripción, solo necesitamos crear una nueva clase, heredar de TelegramLongPollingBot y agregar esta clase al contexto de aplicación de nuestro SpringBoot. El contexto de la aplicación es el lugar donde se almacenan los objetos creados para ejecutar el proyecto. Para agregar una clase, debe usar una de las anotaciones: @Component, @Service, @Repository, @Controller. O la anotación @Bean si se crea a través de un método en una clase de configuración (es decir, en una clase marcada con la anotación Configuración). Entiendo que todo esto todavía pueda parecer incomprensible. Pero cuando empieces a entenderlo, verás que no hay nada complicado allí. Para comprender rápidamente Spring Boot, recomiendo un libro interesante: Spring In Action, quinta edición. Si lo deseo, puedo escribir una serie de artículos basados ​​en este libro. Volvamos. En el paquete que contiene JavarushTelegramBotApplication, creamos el paquete bot , que contendrá nuestro bot de Telegram. Su nombre será JavaRushTelegramBot :

package com.github.javarushcommunity.jrtb.bot;

import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Telegrambot for Javarush Community from Javarush community.
*/
@Component
public class JavarushTelegramBot extends TelegramLongPollingBot {

   @Override
   public void onUpdateReceived(Update update) {

   }

   @Override
   public String getBotUsername() {
       return null;
   }

   @Override
   public String getBotToken() {
       return null;
   }
}

Esta clase era abstracta y se debían implementar tres métodos. Hablemos de ellos con más detalle:

• onUpdateReceived(Actualización de actualización) : este es el punto de entrada al que llegarán los mensajes de los usuarios. Toda nueva lógica vendrá de aquí;
• getBotUsername() : aquí debe agregar el nombre de usuario de nuestro bot al que nos conectaremos;
• getBotToken() - y este, en consecuencia, es el token del bot.

Básicamente, es como un nombre de usuario y una contraseña para un sitio. No escribiremos explícitamente este valor por ahora. Esto se llama "codificación" (es decir, vincular algún valor particular; como de costumbre, papel de calco a partir del código rígido en inglés). No deberías hacer eso. Iremos al revés: escribiremos estos datos en la clase application.properties y los leeremos desde aquí. ¿Por qué es esto necesario? Luego, para que cuando se inicie la aplicación, podamos establecer estos valores de forma externa. Es flexible, es correcto. Vaya al archivo src/main/resources/application.properties. Allí encontraremos nombres para estas variables. Los archivos con la extensión .properties se leen como una estructura clave-valor separada por "=", siendo cada par una línea separada. Entonces se me ocurrieron estas variables:

• bot.nombre de usuario ;
• token.bot .

Así es como se verá: SpringBoot tiene una excelente anotación: @Value. Si se usa correctamente, extraerá los valores del archivo application.properties. Actualizamos el proyecto con esto:

package com.github.javarushcommunity.jrtb.bot;

import org.springframework.beans.factory.annotation.Value;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Telegram bot for Javarush Community from Javarush community.
*/
@Component
public class JavarushTelegramBot extends TelegramLongPollingBot {

   @Value("${bot.username}")
   private String username;

   @Value("${bot.token}")
   private String token;

   @Override
   public void onUpdateReceived(Update update) {

   }

   @Override
   public String getBotUsername() {
       return username;
   }

   @Override
   public String getBotToken() {
       return token;
   }
}

Se puede ver que pasamos el valor de la variable a la anotación. Y cuando SpringBoot crea nuestro objeto bot, los valores se tomarán de las propiedades (nuevamente, papel de calco del inglés - propiedades). Casi estámos allí. Necesitas hacer que el bot responda algo. Por lo tanto, actualicemos el método onUpdateReceived . Necesitamos recuperar el mensaje que llegó al bot y devolverlo. De esta forma sabremos que el bot está funcionando. Para ello, escribiremos de forma aproximada y rápida lo que se necesita:

@Override
public void onUpdateReceived(Update update) {
   if(update.hasMessage() && update.getMessage().hasText()) {
       String message = update.getMessage().getText().trim();
       String chatId = update.getMessage().getChatId().toString();

       SendMessage sm = new SendMessage();
       sm.setChatId(chatId);
       sm.setText(message);

       try {
           execute(sm);
       } catch (TelegramApiException e) {
           //todo add logging to the project.
           e.printStackTrace();
       }
   }
}

Aquí todo es extremadamente simple: comprobamos que el mensaje realmente existe, por lo que extraemos el mensaje en sí ( mensaje ) y el ID del chat ( chatId ) en el que se produce la correspondencia. A continuación, creamos un objeto para enviar un mensaje SendMessage , le pasamos el mensaje en sí y la ID del chat, es decir, qué enviar al bot y dónde. Ya tenemos suficiente de esto. A continuación, ejecutamos el método principal en la clase JavarushTelegramBotApplication y buscamos nuestro bot en Telegram: En los registros vemos que el bot se ha iniciado. Entonces, es hora de ir a Telegram y escribirle al bot: Hacemos clic en iniciar e inmediatamente recibimos una respuesta: Escribamos más basura para verificar: Y listo, en este punto podemos decir que nuestra tarea JRTB-2 está completa . Realmente no puedes escribir ninguna prueba aquí todavía, así que dejaremos todo como está. A continuación necesitas crear un nuevo compromiso: presta atención al nombre del compromiso: nuevamente llamo tu atención sobre esto. Una confirmación primero contiene el nombre de la tarea y luego una descripción más detallada de lo que se ha hecho. Haga clic en Confirmar y enviar... y confirme haciendo clic en Enviar nuevamente : Vaya a nuestro proyecto . Como antes, GitHub ya vio la nueva rama y ofrece crear una solicitud de extracción para main. No nos resistimos y lo creamos: como siempre, ya hemos elegido un sello, un proyecto y me lo hemos asignado. Finalmente, haga clic en Crear solicitud de extracción. Esperemos un poco mientras se completa la compilación, y eso es todo, la solicitud de extracción está lista para fusionarse:

Versionado

De alguna manera no entendí el punto de que necesitamos hacer versiones. Para hacer esto, haremos algunos cambios más en nuestra rama. Volvemos a IDEA y miramos la versión del proyecto en la memoria: La versión es 0.0.1-SNAPSHOT . Esta es la versión de servicio. Y comenzaremos actualizando la versión del proyecto con cada nuevo problema resuelto. Hasta que lleguemos a MVP, la versión vendrá con el sufijo -SNAPSHOT. ¿Cuál será el esquema de versiones? XYZ-INSTANTÁNEA Donde:

• X: actualización de la versión principal, a menudo contiene problemas de compatibilidad con la versión anterior;
• Y - cambios no muy grandes, totalmente compatible con la versión anterior;
• Z es un contador de defectos que encontramos y reparamos.

En base a esto tendremos la primera versión - 0.1.0-SNAPSHOT - es decir, aún no hemos tenido actualizaciones importantes, solo un poco de todo, y aún no llegamos a MVP, por lo que hay un sufijo -SNAPSHOT . Cambiemos esto en la memoria: Vaya al archivo RELEASE_NOTES, donde describiremos los cambios en el proyecto con cada nueva versión: Nuestra primera entrada. Ahora, con cada actualización de versión posterior, describiremos aquí qué sucedió exactamente. Comprometemos este caso, escribimos una descripción: JRTB-2: versión del proyecto actualizada y agregada a RELEASE_NOTES Todo es exactamente igual que antes. Estamos esperando que se apruebe la compilación y podamos fusionar nuestros cambios. Sólo que aquí será un poco diferente. Quiero asegurarme de que cada tarea en la rama principal sea una confirmación separada, por lo que simplemente enviar una solicitud de extracción de combinación no funcionará para nosotros. Git tiene la opción git squash, que reúne todas las confirmaciones en una y las fusiona. Seleccionamos esta opción: Hacemos clic en Squash and Merge, y se nos ofrece editar el mensaje, que al final será: Muy conveniente y lo más importante, lo que hay en demanda. Por cierto, no he visto esa característica en bitbucket =/ Confirmar la fusión. Lo único que queda es cambiar el estado de la tarea a Listo en nuestro tablero, escribir un comentario con un enlace a la solicitud de extracción y cerrarlo: Nuestro tablero ahora se ve así:

Conclusión

Hoy creamos un bot de Telegram paso a paso y lo implementamos en nuestro proyecto SpringBoot. El bot funciona y da respuestas. Inmediatamente accedimos a los datos del bot a través de propiedades. Más por venir: haremos una gran pieza, realizaremos JRTB-3 , y agregaremos un patrón de comando para nuestro proyecto. Ah, una cosa más... Les dije que no publicaría el token para que no fuera utilizado. Pero como estaba escribiendo el artículo cerca de la medianoche y después del trabajo, resultó que había publicado un token válido en el repositorio, y GitGuardian me lo contó en una carta: ¡ Gracias a ellos por esto! ¿Qué hacer ahora? Ya no será posible borrarlo del git, ya que incluso si subo un nuevo commit sin este token, seguirá estando en el antiguo. Pero no quiero eliminar ni revertir la confirmación. Así que fui y desactivé el token del ya mencionado BotFather. Ahora el token está ahí, pero ya no es válido. Suscríbase a mi cuenta de GitHub para ver todo el código antes de publicar el artículo. Gracias a todos por leer, nos vemos pronto.

Al principio de este artículo encontrará una lista de todos los materiales de la serie.