Aggiunta di un bot di Telegram al progetto - "Progetto Java dalla A alla Z"

Saluti, miei cari amici. Sì, sì, esattamente amici. Ho già acquisito così tanta familiarità con questa serie di articoli che quelle persone che scrivono regolarmente la loro gratitudine nei commenti e/o dimostrano di aver letto e compreso il materiale si sono già avvicinate. Tu ed io ci stiamo muovendo da entrambe le parti verso lo stesso obiettivo. Tu vuoi capire, ma io voglio spiegare. E abbiamo lo stesso obiettivo finale: una domanda scritta che ti sia comprensibile dall'inizio alla fine. Potresti aver già sentito parlare di molto di ciò che descriverò in questo articolo. Non credo che vi dirò nulla di nuovo e straordinario (ma nell’ambito del progetto è necessario saperlo/ripetere). In primavera ho scritto un bot per me, quindi faremo affidamento sui suoi "schemi".

Scriviamo JRTB-2

Faremo la stessa cosa che abbiamo fatto nell'articolo con l'attività JRTB-0 :

1. Aggiorniamo il ramo principale nel progetto locale utilizzando la combinazione ctrl+t .
2. In base al ramo principale creiamo:
3. Aggiungi un bot.
4. Creiamo un nuovo commit con una descrizione di ciò che è stato fatto e lo inviamo su GitHub.
5. Crea una richiesta pull per il ramo principale e ricontrollala. Stiamo aspettando che la build venga completata (azioni github), uniamola nel ramo principale.
6. Chiudi l'attività corrispondente.

Cos'è un bot di Telegram

Noi sviluppatori possiamo immaginare di lavorare con un bot di Telegram in questo modo: utilizziamo il loro client per lavorare con loro. Abbiamo una biblioteca già pronta per il lavoro. Esiste una serie di azioni dopo le quali il bot di Telegram saprà di essere associato al nostro programma. E già all'interno del programma impareremo come ricevere lettere, comandi e in qualche modo elaborarli. Nei bot di Telegram esiste un comando : inizia con una barra “/”. Dopodiché, scriviamo immediatamente insieme la parola e questo sarà considerato un comando. Ad esempio, ci sono due comandi che tutti dovrebbero conoscere:

• /start: inizia a lavorare con il bot;
• /stop: termina il lavoro con il bot.

Faremo il resto da soli. Faccio subito la prenotazione: faremo esattamente cosa e come ho imparato. E quando si lavora con un bot, sono sicuro che sarà possibile fare di meglio. E se qualcuno vuole farlo, sarò solo felice e sosterrò questo sforzo in ogni modo possibile. A proposito, la prima cosa che sarebbe interessante sarebbe se qualcuno mi spiegasse come programmare la descrizione dei comandi tramite codice e non tramite le impostazioni del bot nel telegramma. Non l'ho imparato. Abbiamo diversi articoli sulla nostra risorsa che descrivono come realizzare un bot di base: oggi faremo qualcosa di simile. Se hai altre domande, ti consiglio di sfogliare questo articolo.

Crea un bot con BotFather

Per connettere un bot, devi prima crearlo. Telegram ha un approccio: creare un bot con il proprio nome univoco. Sarà inoltre accompagnato da un token (una stringa di grandi dimensioni che funziona come una password). Ho già creato un bot per JavaRush - @javarush_community_bot . Questo bot è ancora vuoto e non può fare nulla. La cosa principale è che alla fine del nome ci sia _bot . Per mostrare come farlo, creerò un bot su cui testeremo la nostra funzionalità. In termini di progetti reali, questo sarebbe un ambiente di prova. E il nostro principale sarà l'ambiente prod (prod - produzione, cioè l'ambiente reale su cui verrà eseguito il progetto). Naturalmente, sarebbe possibile aggiungere un altro ambiente: un ambiente sandbox: un sandbox comune, più modificabile e accessibile a tutti i partecipanti allo sviluppo. Ma ciò non farà altro che complicare la situazione nella fase di creazione del progetto. Per ora creiamo altri due bot per il test e per l'ambiente sandbox. Il primo passo è creare (registrare) un bot nello stesso Telegram. Dobbiamo trovare il bot: @BotFather e scrivergli il comando: /newbot Successivamente, ci viene chiesto di dare un nome a questo bot. Poiché si tratta di un bot per attività di test, il suo nome sarà appropriato: [TEST] JavarushBot Ora è il momento di dare un nome univoco con cui possa essere sempre trovato: il suo nome utente: test_javarush_community Come ho detto sopra, devi aggiungere _bot suffisso per il nome utente, quindi scriviamo di nuovo: test_javarush_community_bot E il gioco è fatto! Il bot è stato creato. Ora, utilizzando nome utente e token, può essere collegato al nostro progetto. Naturalmente, per il corretto funzionamento del server di test, non mostrerò il token (essenzialmente una password per accedere al bot) di questo bot per la visualizzazione pubblica.

Colleghiamo il bot al progetto

Non includeremo la libreria come al solito, ma sfrutteremo immediatamente il nostro scheletro: SpringBoot. Ha una cosa come Starter. Includendo la libreria, possiamo usarla per far sapere a SpringBoot che vogliamo configurare correttamente il progetto. Se dovessimo seguire il solito percorso, descritto in molti posti, dovremmo creare da qualche parte una configurazione che dovrebbe essere simile a questa:

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

Qui viene creato un oggetto con il quale è possibile stabilire una connessione con il bot. Nel nostro caso, l'antipasto che vogliamo connettere farà tutto per noi da qualche parte "sotto il cofano" (questa è anche una traduzione della frase usata di frequente nell'IT - sotto il cofano). Ecco un collegamento a questo antipasto . Puoi vedere subito dal file README.md di cosa si tratta, perché e come usarlo. Per collegarlo, devi solo aggiungere questa dipendenza alla memoria. Questo è tutto :) Ecco la dipendenza richiesta:

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

Lo aggiungiamo alla nostra memoria. Installiamo la versione come previsto e aggiorniamo il progetto Maven. In base alla descrizione, dobbiamo solo creare una nuova classe, ereditare da TelegramLongPollingBot e aggiungere questa classe al contesto applicativo del nostro SpringBoot. Il contesto dell'applicazione è il luogo in cui vengono archiviati gli oggetti creati per l'esecuzione del progetto. Per aggiungere una classe, è necessario utilizzare una delle annotazioni: @Component, @Service, @Repository, @Controller. Oppure l'annotazione @Bean se creata tramite un metodo in una classe di configurazione (ovvero in una classe contrassegnata con l'annotazione Configurazione). Capisco che tutto questo possa sembrare ancora incomprensibile. Ma quando inizi a capirlo, vedrai che non c'è nulla di complicato lì. Per comprendere rapidamente Spring Boot, consiglio un libro interessante: Spring In Action 5a edizione. Se c'è un desiderio, posso scrivere una serie di articoli basati su questo libro. Torniamo indietro. Nel pacchetto che contiene JavarushTelegramBotApplication, creiamo il pacchetto bot , che conterrà il nostro bot di telegram. Il suo nome sarà 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;
   }
}

Questa classe era astratta e dovevano essere implementati tre metodi. Parliamo di loro più nel dettaglio:

• onUpdateReceived(Aggiornamento aggiornamento) : questo è il punto di ingresso in cui arriveranno i messaggi degli utenti. Tutta la nuova logica verrà da qui;
• getBotUsername() - qui dobbiamo aggiungere il nome utente del nostro bot a cui ci collegheremo;
• getBotToken() - e questo, di conseguenza, è il token del bot.

Essenzialmente è come un login e una password per un sito. Non scriveremo esplicitamente questo valore per ora. Questo è chiamato "hardcoding" (ovvero, vincolare un valore particolare - come al solito, carta da lucido dall'hard code inglese). Non dovresti farlo. Andremo dall'altra parte: scriveremo questi dati nella classe application.properties e li leggeremo da qui. Perché è necessario? Quindi, in modo che all'avvio dell'applicazione possiamo impostare questi valori esternamente. È flessibile, è giusto. Vai al file src/main/resources/application.properties. Lì troveremo i nomi per queste variabili. I file con estensione .properties vengono letti come una struttura chiave-valore separata da "="", ciascuna coppia essendo una riga separata. Quindi ho pensato a queste variabili:

• bot.nomeutente ;
• bot.token .

Ecco come apparirà: SpringBoot ha un'ottima annotazione: @Value. Se utilizzato correttamente, recupererà i valori dal file application.properties. Aggiorniamo il progetto con questo:

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

Si può vedere che abbiamo passato il valore della variabile all'annotazione. E quando SpringBoot crea il nostro oggetto bot, i valori verranno presi dalle proprietà (di nuovo, carta da lucido dall'inglese - proprietà). Ci siamo quasi. Devi fare in modo che il bot risponda a qualcosa. Pertanto, aggiorniamo il metodo onUpdateReceived . Dobbiamo recuperare il messaggio arrivato al bot e restituirlo. In questo modo sapremo che il bot funziona. Per fare ciò, scriveremo in modo approssimativo e veloce ciò che è necessario:

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

Qui tutto è estremamente semplice: controlliamo che il messaggio esista realmente, quindi estraiamo il messaggio stesso ( message ) e l'ID della chat ( chatId ) in cui si svolge la corrispondenza. Successivamente, creiamo un oggetto per l'invio di un messaggio SendMessage , gli passiamo il messaggio stesso e l'ID della chat, ovvero cosa inviare al bot e dove. Ne abbiamo già abbastanza. Successivamente, eseguiamo il metodo main nella classe JavarushTelegramBotApplication e cerchiamo il nostro bot in Telegram: Dai log vediamo che il bot è stato avviato. Allora è il momento di andare su Telegram e scrivere al bot: Facciamo clic su Start e riceviamo immediatamente una risposta: Scriviamo ancora qualche schifezza per verificare: E questo è tutto, a questo punto possiamo dire che il nostro compito JRTB-2 è completato . Non puoi ancora scrivere alcun test qui, quindi lasceremo tutto così com'è. Successivamente devi creare un nuovo commit: presta attenzione al nome del commit: attiro ancora la tua attenzione su questo. Un commit contiene prima il nome dell'attività e poi una descrizione più dettagliata di ciò che è stato fatto. Fare clic su Commit and Push... e confermare facendo nuovamente clic su Push : Vai al nostro progetto . Come prima, GitHub ha già visto il nuovo ramo e si offre di creare una richiesta pull per main. Noi non resistiamo e lo creiamo: come al solito abbiamo già scelto un’etichetta, un progetto e me lo abbiamo assegnato. Infine, fai clic su Crea richiesta pull. Aspettiamo un po' mentre la compilazione viene completata - e il gioco è fatto, la richiesta pull è pronta per la fusione:

Controllo delle versioni

In qualche modo non ho capito il punto in cui dobbiamo eseguire il controllo delle versioni. Per fare ciò, apporteremo qualche altra modifica nel nostro ramo. Torniamo a IDEA e guardiamo la versione del progetto in memoria: La versione è 0.0.1-SNAPSHOT . Questa è la versione di servizio. E inizieremo aggiornando la versione del progetto con ogni nuovo problema risolto. Fino a quando non raggiungeremo MVP, la versione avrà il suffisso -SNAPSHOT. Quale sarà lo schema di controllo delle versioni? XYZ-SNAPSHOT Dove:

• X - aggiornamento principale della versione, spesso contiene problemi di retrocompatibilità con la versione precedente;
• Y - cambiamenti non molto grandi, pienamente compatibile con la versione precedente;
• Z è un contatore di difetti che abbiamo riscontrato e riparato.

Sulla base di questo, avremo la prima versione - 0.1.0-SNAPSHOT - cioè non abbiamo ancora avuto aggiornamenti importanti, solo un po' di tutto, e non abbiamo ancora raggiunto MVP, quindi c'è un suffisso -SNAPSHOT . Cambiamo questo nella memoria: andiamo al file RELEASE_NOTES, dove descriveremo le modifiche al progetto con ogni nuova versione: la nostra prima voce. Ora, con ogni successivo aggiornamento della versione, descriveremo qui cosa è successo esattamente. Commettiamo questo caso, scriviamo una descrizione: JRTB-2: versione del progetto aggiornata e aggiunta a RELEASE_NOTES Tutto è esattamente come prima. Stiamo aspettando che la build passi e possiamo unire le nostre modifiche. Solo che qui sarà un po' diverso. Voglio assicurarmi che ogni attività nel ramo principale sia un commit separato, quindi semplicemente inviare una richiesta pull di unione non funzionerà per noi. Git ha l'opzione git squash, che raccoglie tutti i commit in uno solo e li unisce. Selezioniamo questa opzione: fai clic su Squash and Merge e ci viene offerto di modificare il messaggio, che alla fine sarà: Molto conveniente e, soprattutto, ciò che è richiesto. A proposito, non ho visto una funzionalità del genere su bitbucket =/ Conferma l'unione. L'unica cosa rimasta è cambiare lo stato dell'attività in Fatto nella nostra bacheca, scrivere un commento con un collegamento alla richiesta pull e chiuderla: La nostra bacheca ora appare così:

Conclusione

Oggi abbiamo creato passo dopo passo un bot di Telegram e lo abbiamo implementato nel nostro progetto SpringBoot. Il bot funziona e dà risposte. Abbiamo immediatamente effettuato l'accesso ai dati del bot tramite le proprietà. Altro in arrivo: faremo un pezzo importante - eseguiremo JRTB-3 - aggiungendo un modello di comando per il nostro progetto. Ah, ancora una cosa... Ti avevo detto che non avrei pubblicato il token in modo che non venisse utilizzato. Ma poiché stavo scrivendo l'articolo più vicino a mezzanotte e dopo il lavoro, si è scoperto che avevo pubblicato un token valido nel repository e GitGuardian me ne ha parlato in una lettera: Grazie a loro per questo! Cosa fare adesso? Non sarà più possibile eliminarlo da git, poiché anche se carico un nuovo commit senza questo token, rimarrà comunque in quello vecchio. Ma non voglio eliminare e ripristinare il commit. Quindi sono andato a disattivare il token del già citato BotFather. Ora il token c'è, ma non è più valido. Iscriviti al mio account GitHub per vedere tutto il codice prima di pubblicare l'articolo. Grazie a tutti per aver letto, a presto.

Un elenco di tutti i materiali della serie si trova all'inizio di questo articolo.