Adicionando um bot de telegrama ao projeto - "Projeto Java de A a Z"

Saudações, meus queridos amigos. Sim, sim, exatamente amigos. Já me familiarizei tanto com esta série de artigos que já se tornaram próximas aquelas pessoas que regularmente escrevem seus agradecimentos nos comentários e/ou mostram que leram e compreenderam o material. Você e eu estamos nos movendo em duas direções em direção ao mesmo objetivo. Você quer entender, mas eu quero explicar. E temos o mesmo objetivo final - uma aplicação escrita que seja compreensível para você do início ao fim. Você já deve ter ouvido falar muito do que descreverei neste artigo. Não creio que lhe direi nada de novo e extraordinário (mas no âmbito do projeto é necessário saber/repetir isto). Na primavera eu escrevi um bot para mim, então vamos contar com seus “padrões”.

Nós escrevemos JRTB-2

Faremos o mesmo que fizemos no artigo com a tarefa JRTB-0 :

1. Atualizamos o branch principal no projeto local usando a combinação ctrl + t .
2. Com base no branch principal, criamos:
3. Adicione um bot.
4. Criamos um novo commit com uma descrição do que foi feito e enviamos para o GitHub.
5. Crie uma solicitação pull para o branch principal e verifique novamente. Estamos aguardando a conclusão da compilação (ações do github), mesclando-a no branch principal.
6. Feche a tarefa correspondente.

O que é um bot de telegrama

Nós, desenvolvedores, podemos imaginar trabalhar com um bot de telegrama assim: usamos o cliente deles para trabalhar com eles. Temos uma biblioteca pronta para trabalhar. Existe um conjunto de ações após as quais o bot do telegrama saberá que está associado ao nosso programa. E já dentro do programa aprenderemos como receber cartas, comandos e de alguma forma processá-los. Existe um comando em bots de telegrama : ele começa com uma barra “/”. Depois disso, escrevemos imediatamente a palavra juntos, e isso será considerado um comando. Por exemplo, existem dois comandos que todos deveriam saber:

• /start — comece a trabalhar com o bot;
• /stop - finaliza o trabalho com o bot.

Nós mesmos faremos o resto. Deixe-me fazer uma reserva desde já: faremos exatamente o que e da maneira que aprendi. E ao trabalhar com um bot, tenho certeza que será possível fazer melhor. E se alguém quiser fazer isso, ficarei muito feliz e apoiarei essa empreitada de todas as formas possíveis. Aliás, a primeira coisa que seria legal é se alguém me explicasse como programar a descrição dos comandos por meio de código, e não por meio das configurações do bot no telegrama. Eu não aprendi isso. Temos vários artigos em nosso recurso que descrevem como fazer um bot básico: hoje faremos algo semelhante. Se você tiver mais dúvidas, recomendo dar uma olhada neste artigo.

Crie um bot com BotFather

Para conectar um bot, primeiro você precisa criá-lo. O Telegram tem uma abordagem: criar um bot com seu próprio nome exclusivo. Também será acompanhado por um token (uma string grande que funciona como uma senha). Já criei um bot para JavaRush - @javarush_community_bot . Este bot ainda está vazio e não pode fazer nada. O principal é que deve haver _bot no final do nome . Para mostrar como fazer isso, criarei um bot no qual testaremos nossa funcionalidade. Em termos de projetos reais, este seria um ambiente de teste. E o nosso principal será o ambiente prod (prod - produção, ou seja, o ambiente real no qual o projeto será executado). Claro, seria possível adicionar outro ambiente - um ambiente sandbox: um sandbox comum, mais mutável e acessível a todos os participantes do desenvolvimento. Mas isso só complicará a situação na fase de criação do projeto. Por enquanto, vamos criar mais dois bots para teste e para ambiente sandbox. O primeiro passo é criar (cadastrar) um bot no próprio Telegram. Precisamos encontrar o bot: @BotFather e escrever o comando nele: /newbot Em seguida, somos solicitados a dar um nome a esse bot. Como este é um bot para tarefas de teste, seu nome será apropriado: [TEST] JavarushBot Agora é hora de fornecer um nome exclusivo pelo qual ele sempre possa ser encontrado - seu nome de usuário: test_javarush_community Como eu disse acima, você precisa adicionar o _bot sufixo para nome de usuário, então escrevemos novamente: test_javarush_community_bot E é isso! O bot foi criado. Agora, usando nome de usuário e token, ele pode ser conectado ao nosso projeto. Obviamente, para o bom funcionamento do servidor de teste, não exibirei o token (essencialmente uma senha para acessar o bot) deste bot para visualização pública.

Conectamos o bot ao projeto

Não incluiremos a biblioteca como de costume, mas aproveitaremos imediatamente nosso esqueleto - SpringBoot. Ele tem algo como Starter. Ao incluir a biblioteca, podemos usá-la para informar ao SpringBoot que queremos configurar o projeto corretamente. Se seguíssemos o caminho usual, descrito em muitos lugares, precisaríamos criar uma configuração em algum lugar que teria algo assim:

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

Aqui é criado um objeto com o qual você pode estabelecer uma conexão com o bot. No nosso caso, o starter que queremos conectar fará tudo por nós em algum lugar “nos bastidores” (esta também é a tradução de uma frase frequentemente usada em TI - nos bastidores). Aqui está um link para este iniciador . Você pode ver imediatamente no arquivo README.md o que é, por que e como usá-lo. Para conectá-lo, basta adicionar esta dependência à memória. Isso é tudo :) Aqui está a dependência necessária:

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

Nós o adicionamos à nossa memória. Instalamos a versão conforme esperado e atualizamos o projeto Maven. Com base na descrição, precisamos apenas criar uma nova classe, herdar de TelegramLongPollingBot e adicionar esta classe ao Application Context do nosso SpringBoot. Contexto do Aplicativo é o local onde são armazenados os objetos criados para execução do projeto. Para adicionar uma classe, você precisa usar uma das anotações: @Component, @Service, @Repository, @Controller. Ou a anotação @Bean se criada através de um método em uma classe de configuração (ou seja, em uma classe marcada com a anotação Configuration). Entendo que tudo isso ainda pode parecer incompreensível. Mas quando você começar a descobrir, verá que não há nada complicado nisso. Para entender rapidamente o Spring Boot, recomendo um livro legal - Spring In Action 5ª edição. Se desejar, posso escrever uma série de artigos baseados neste livro. Vamos voltar. No pacote que contém JavarushTelegramBotApplication, criamos o pacote bot , que conterá nosso bot de telegrama. Seu nome 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 classe era abstrata e três métodos tiveram que ser implementados. Vamos falar sobre eles com mais detalhes:

• onUpdateReceived(Update update) - este é o ponto de entrada por onde chegarão as mensagens dos usuários. Toda nova lógica virá daqui;
• getBotUsername() - aqui você precisa adicionar o nome de usuário do nosso bot ao qual nos conectaremos;
• getBotToken() - e este, portanto, é o token do bot.

Essencialmente, é como um login e uma senha para um site. Não escreveremos explicitamente esse valor por enquanto. Isso é chamado de “hardcoding” (isto é, vincular algum valor específico - como de costume, papel vegetal do código rígido em inglês). Você não deveria fazer isso. Iremos por outro caminho - gravaremos esses dados na classe application.properties e os leremos daqui. Por que isso é necessário? Então, para que quando a aplicação for iniciada, possamos definir esses valores externamente. É flexível, está certo. Vá para o arquivo src/main/resources/application.properties. Lá iremos encontrar nomes para essas variáveis. Arquivos com extensão .properties são lidos como uma estrutura de valores-chave separados por “=”, sendo cada par uma linha separada. Então eu criei essas variáveis:

• bot.nomedeusuário ;
• bot.token .

Será assim: SpringBoot tem uma ótima anotação - @Value. Se usado corretamente, ele extrairá os valores do arquivo application.properties. Atualizamos o projeto com isto:

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;
   }
}

Pode-se observar que passamos o valor da variável para a anotação. E quando o SpringBoot criar nosso objeto bot, os valores serão retirados das propriedades (novamente, papel vegetal do inglês - propriedades). Estamos quase lá. Você precisa fazer o bot responder alguma coisa. Portanto, vamos atualizar o método onUpdateReceived . Precisamos recuperar a mensagem que chegou ao bot e devolvê-la. Assim saberemos que o bot está funcionando. Para fazer isso, escreveremos de maneira aproximada e rápida o que é necessário:

@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();
       }
   }
}

Tudo aqui é extremamente simples: verificamos se a mensagem realmente existe, então extraímos a própria mensagem ( message ) e o ID do chat ( chatId ) no qual a correspondência está ocorrendo. A seguir, criamos um objeto para enviar uma mensagem SendMessage , passamos a própria mensagem e o ID do chat para ele - ou seja, o que enviar ao bot e para onde. Já temos o suficiente disso. A seguir, executamos o método principal na classe JavarushTelegramBotApplication e procuramos nosso bot no Telegram: A partir dos logs vemos que o bot foi iniciado. Então, é hora de ir ao Telegram e escrever para o bot: Clicamos em iniciar e imediatamente recebemos uma resposta: Vamos escrever mais algumas porcarias para verificar: E é isso, neste ponto podemos dizer que nossa tarefa JRTB-2 está concluída . Você ainda não pode escrever nenhum teste aqui, então deixaremos tudo como está. Em seguida você precisa criar um novo commit: Preste atenção no nome do commit: mais uma vez chamo sua atenção para isso. Um commit contém primeiro o nome da tarefa e depois uma descrição mais detalhada do que foi feito. Clique em Commit and Push... e confirme clicando em Push novamente : Vá para nosso projeto . Como antes, o GitHub já viu o novo branch e se oferece para criar uma solicitação pull para main. Não resistimos e criamos: Como sempre, já escolhemos um rótulo, um projeto e atribuímos para mim. Por fim, clique em Criar solicitação pull. Vamos esperar um pouco enquanto a compilação é concluída - e pronto, a solicitação pull está pronta para mesclar:

Versionamento

De alguma forma, não entendi que precisamos fazer o versionamento. Para fazer isso, faremos mais algumas alterações em nosso branch. Voltamos ao IDEA e olhamos a versão do projeto na memória: A versão é 0.0.1-SNAPSHOT . Esta é a versão de serviço. E começaremos atualizando a versão do projeto a cada novo problema resolvido. Até chegarmos ao MVP, a versão virá com o sufixo -SNAPSHOT. Qual será o esquema de versionamento? INSTANTÂNEO XYZ Onde:

• X - atualização de versão principal, geralmente contém problemas de compatibilidade com versões anteriores;
• Y - mudanças não muito grandes, totalmente compatível com a versão anterior;
• Z é um contador de defeitos que encontramos e reparamos.

Com base nisso teremos a primeira versão - 0.1.0-SNAPSHOT - ou seja, ainda não tivemos grandes atualizações, só um pouco de tudo, e ainda não atingimos o MVP, então existe um sufixo -SNAPSHOT . Vamos mudar isso na memória: Vá para o arquivo RELEASE_NOTES, onde descreveremos as alterações no projeto a cada nova versão: Nossa primeira entrada. Agora, com cada atualização de versão subsequente, descreveremos aqui o que exatamente aconteceu. Comprometemos este caso, escrevemos uma descrição: JRTB-2: versão atualizada do projeto e adicionada a RELEASE_NOTES Tudo está exatamente como antes. Estamos aguardando a conclusão da construção e podemos mesclar nossas alterações. Só aqui será um pouco diferente. Quero ter certeza de que cada tarefa no branch principal seja um commit separado, portanto, simplesmente enviar uma solicitação pull Merge não funcionará para nós. O Git tem a opção git squash, que reúne todos os commits em um e os mescla. Selecionamos esta opção: Clique em Squash and Merge, e nos é oferecido editar a mensagem, que no final ficará: Muito conveniente e o mais importante, o que está em demanda. A propósito, não vi tal recurso no bitbucket =/ Confirme a mesclagem. A única coisa que resta é alterar a tarefa para o status Concluído em nosso quadro, escrever um comentário com um link para o pull request e fechá-lo: Nosso quadro agora está assim:

Conclusão

Hoje criamos passo a passo um bot de telegrama e o implementamos em nosso projeto SpringBoot. O bot funciona e dá respostas. Imediatamente acessamos os dados do bot por meio de propriedades. Mais por vir: faremos uma grande peça - executar JRTB-3 - adicionando um Command Pattern para nosso projeto. Ah, mais uma coisa... Eu lhe disse que não publicaria o token para que não fosse usado. Mas como eu estava escrevendo o artigo perto da meia-noite e depois do trabalho, descobri que havia postado um token válido no repositório, e o GitGuardian me contou sobre isso em uma carta: Obrigado a eles por isso! O que fazer agora? Não será mais possível excluí-lo do git, pois mesmo que eu carregue um novo commit sem esse token, ele ainda permanecerá no antigo. Mas não quero excluir e reverter o commit. Então desativei o token do já mencionado BotFather. Agora o token está aí, mas não é mais válido. Assine minha conta GitHub para ver todo o código antes de publicar o artigo. Obrigado a todos pela leitura, até breve.

Uma lista de todos os materiais da série está no início deste artigo.