Hinzufügen eines Telegram-Bots zum Projekt – „Java-Projekt von A bis Z“

Grüße, meine lieben Freunde. Ja, ja, genau Freunde. Ich habe mich mit dieser Artikelreihe bereits so gut vertraut gemacht, dass sich die Menschen, die sich regelmäßig in den Kommentaren bedanken und/oder zeigen, dass sie den Stoff gelesen und verstanden haben, schon näher gekommen sind. Sie und ich bewegen uns von beiden Seiten auf das gleiche Ziel zu. Du willst es verstehen, aber ich möchte es erklären. Und wir haben das gleiche Endziel – eine schriftliche Bewerbung, die für Sie von Anfang bis Ende verständlich ist. Vieles von dem, was ich in diesem Artikel beschreibe, haben Sie vielleicht schon gehört. Ich glaube nicht, dass ich Ihnen etwas Neues und Außergewöhnliches erzählen werde (aber im Rahmen des Projekts ist es notwendig, dies zu wissen/zu wiederholen). Im Frühjahr habe ich einen Bot für mich selbst geschrieben, daher werden wir uns auf seine „Muster“ verlassen.

Wir schreiben JRTB-2

Wir werden das Gleiche tun wie im Artikel mit der Aufgabe JRTB-0 :

1. Wir aktualisieren den Hauptzweig im lokalen Projekt mit der Kombination Strg + T.
2. Basierend auf dem Hauptzweig erstellen wir:
3. Fügen Sie einen Bot hinzu.
4. Wir erstellen einen neuen Commit mit einer Beschreibung dessen, was getan wurde, und pushen ihn an GitHub.
5. Erstellen Sie eine Pull-Anfrage für den Hauptzweig und prüfen Sie diese erneut. Wir warten darauf, dass der Build durchlaufen wird (Github-Aktionen) und ihn in den Hauptzweig einbinden.
6. Schließen Sie die entsprechende Aufgabe.

Was ist ein Telegram-Bot?

Wir Entwickler können uns die Zusammenarbeit mit einem Telegram-Bot so vorstellen: Wir nutzen ihren Client, um mit ihnen zu arbeiten. Wir haben eine fertige Bibliothek für die Arbeit. Es gibt eine Reihe von Aktionen, nach denen der Telegram-Bot erkennt, dass er mit unserem Programm verknüpft ist. Und schon im Programm lernen wir, wie man Briefe und Befehle empfängt und irgendwie verarbeitet. In Telegram-Bots gibt es so etwas wie einen Befehl : Er beginnt mit einem Schrägstrich „/“. Danach schreiben wir sofort das Wort zusammen, und dies wird als Befehl betrachtet. Es gibt zum Beispiel zwei Befehle, die jeder kennen sollte:

• /start – Beginnen Sie mit der Arbeit mit dem Bot;
• /stop – Arbeit mit dem Bot beenden.

Den Rest erledigen wir selbst. Lassen Sie mich gleich eine Reservierung vornehmen: Wir werden genau das tun und auf die Art und Weise, wie ich es gelernt habe. Und wenn man mit einem Bot arbeitet, bin ich mir sicher, dass man es noch besser machen kann. Und wenn jemand dies tun möchte, freue ich mich sehr und werde dieses Unterfangen auf jede erdenkliche Weise unterstützen. Das allererste, was cool wäre, wäre übrigens, wenn mir jemand erklären würde, wie man die Beschreibung von Befehlen durch Code programmiert und nicht durch die Bot-Einstellungen im Telegramm. Das habe ich nicht gelernt. Wir haben mehrere Artikel auf unserer Ressource, die beschreiben, wie man einen einfachen Bot erstellt: Heute werden wir etwas Ähnliches tun. Wenn Sie weitere Fragen haben, empfehle ich Ihnen, diesen Artikel zu überfliegen.

Erstellen Sie einen Bot mit BotFather

Um einen Bot zu verbinden, müssen Sie ihn zunächst erstellen. Telegram hat einen Ansatz – die Erstellung eines Bots mit einem eigenen, eindeutigen Namen. Außerdem wird es von einem Token begleitet (einer langen Zeichenfolge, die wie ein Passwort funktioniert). Ich habe bereits einen Bot für JavaRush erstellt – @javarush_community_bot . Dieser Bot ist noch leer und kann nichts tun. Die Hauptsache ist, dass am Ende des Namens _bot stehen sollte . Um zu zeigen, wie das geht, werde ich einen Bot erstellen, an dem wir unsere Funktionalität testen. Bezogen auf reale Projekte wäre dies eine Testumgebung. Und unser wichtigstes wird die Produktionsumgebung sein (Prod – Produktion, also die reale Umgebung, in der das Projekt ausgeführt wird). Natürlich wäre es möglich, eine weitere Umgebung hinzuzufügen – eine Sandbox-Umgebung: eine gemeinsame Sandbox, veränderbarer und für alle Entwicklungsteilnehmer zugänglich. Dies wird jedoch die Situation in der Phase der Projekterstellung nur verkomplizieren. Lassen Sie uns zunächst zwei weitere Bots für den Test und für die Sandbox-Umgebung erstellen. Der erste Schritt besteht darin, einen Bot in Telegram selbst zu erstellen (registrieren). Wir müssen den Bot finden: @BotFather und den Befehl hineinschreiben: /newbot Als nächstes werden wir gebeten, diesem Bot einen Namen zu geben. Da es sich um einen Bot für Testaufgaben handelt, ist sein Name angemessen: [TEST] JavarushBot Jetzt ist es an der Zeit, einen eindeutigen Namen zu vergeben, unter dem er immer gefunden werden kann – seinen Benutzernamen: test_javarush_community Wie ich oben sagte, müssen Sie den _bot hinzufügen Suffix für Benutzernamen, also schreiben wir noch einmal: test_javarush_community_bot Und das war's! Der Bot wurde erstellt. Jetzt kann es mit Benutzername und Token mit unserem Projekt verbunden werden. Um den reibungslosen Betrieb des Testservers zu gewährleisten, werde ich das Token (im Wesentlichen ein Passwort für den Zugriff auf den Bot) dieses Bots natürlich nicht öffentlich anzeigen.

Wir verbinden den Bot mit dem Projekt

Wir werden die Bibliothek nicht wie üblich einbinden, sondern sofort auf unser Grundgerüst – SpringBoot – zurückgreifen. Er hat so etwas wie Starter. Indem wir die Bibliothek einbinden, können wir SpringBoot darüber informieren, dass wir das Projekt korrekt konfigurieren möchten. Wenn wir den üblichen Weg gehen würden, der an vielen Stellen beschrieben wird, müssten wir irgendwo eine Konfiguration erstellen, die etwa so aussehen würde:

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

Hier wird ein Objekt erstellt, mit dem Sie eine Verbindung mit dem Bot herstellen können. In unserem Fall erledigt der Starter, den wir anschließen möchten, alles für uns irgendwo „unter der Haube“ (dies ist auch eine Übersetzung eines in der IT häufig verwendeten Ausdrucks – unter der Haube). Hier ist ein Link zu diesem Starter . Aus der Datei README.md können Sie sofort erkennen, was es ist, warum und wie man es verwendet. Um es zu verbinden, müssen Sie nur diese Abhängigkeit zum Speicher hinzufügen. Das ist alles :) Hier ist die erforderliche Abhängigkeit:

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

Wir fügen es unserem Gedächtnis hinzu. Wir installieren die Version wie erwartet und aktualisieren das Maven-Projekt. Basierend auf der Beschreibung müssen wir lediglich eine neue Klasse erstellen, von TelegramLongPollingBot erben und diese Klasse zum Anwendungskontext unseres SpringBoot hinzufügen. Der Anwendungskontext ist der Ort, an dem die erstellten Objekte zum Ausführen des Projekts gespeichert werden. Um eine Klasse hinzuzufügen, müssen Sie eine der Annotationen verwenden: @Component, @Service, @Repository, @Controller. Oder die @Bean-Annotation, wenn sie über eine Methode in einer Konfigurationsklasse erstellt wird (d. h. in einer Klasse, die mit der Configuration-Annotation markiert ist). Ich verstehe, dass das alles immer noch unverständlich erscheinen mag. Aber wenn Sie anfangen, es herauszufinden, werden Sie feststellen, dass es da nichts Kompliziertes gibt. Um Spring Boot schnell zu verstehen, empfehle ich ein cooles Buch – Spring In Action 5. Auflage. Wenn der Wunsch besteht, kann ich eine Artikelserie basierend auf diesem Buch schreiben. Lass uns zurück gehen. In dem Paket, das JavarushTelegramBotApplication enthält, erstellen wir das Bot- Paket , das unseren Telegram-Bot enthalten wird. Sein Name wird JavaRushTelegramBot sein :

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

Diese Klasse war abstrakt und es mussten drei Methoden implementiert werden. Lassen Sie uns genauer darüber sprechen:

• onUpdateReceived(Update update) – Dies ist der Einstiegspunkt, an dem Nachrichten von Benutzern eingehen. Alle neue Logik wird von hier kommen;
• getBotUsername() – hier müssen Sie den Benutzernamen unseres Bots hinzufügen, mit dem wir uns verbinden;
• getBotToken() – und dies ist dementsprechend das Bot-Token.

Im Grunde ist es wie ein Login und ein Passwort für eine Website. Wir werden diesen Wert vorerst nicht explizit schreiben. Dies nennt man „Hardcoding“ (d. h. das Binden eines bestimmten Wertes – wie üblich Pauspapier aus englischem Hardcode). Das solltest du nicht tun. Wir gehen den anderen Weg – wir schreiben diese Daten in die Klasse application.properties und lesen sie von hier aus. Warum ist das notwendig? Damit wir beim Start der Anwendung diese Werte dann extern festlegen können. Es ist flexibel, es ist richtig. Gehen Sie zur Datei src/main/resources/application.properties. Dort werden wir Namen für diese Variablen finden. Dateien mit der Erweiterung .properties werden als durch „=“ getrennte Schlüsselwertstruktur gelesen, wobei jedes Paar eine separate Zeile darstellt. Also habe ich mir diese Variablen ausgedacht:

• bot.Benutzername ;
• bot.token .

So wird es aussehen: SpringBoot hat eine tolle Annotation – @Value. Bei korrekter Verwendung werden die Werte aus der Datei application.properties abgerufen. Wir aktualisieren das Projekt wie folgt:

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

Es ist ersichtlich, dass wir den Wert der Variablen an die Annotation übergeben haben. Und wenn SpringBoot unser Bot-Objekt erstellt, werden die Werte aus den Eigenschaften übernommen (wiederum Pauspapier aus dem Englischen – Eigenschaften). Wir sind fast da. Sie müssen den Bot dazu bringen, etwas zu beantworten. Aktualisieren wir daher die onUpdateReceived -Methode . Wir müssen die Nachricht, die an den Bot gelangt ist, abrufen und zurückgeben. Auf diese Weise wissen wir, dass der Bot funktioniert. Dazu schreiben wir grob und schnell auf, was benötigt wird:

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

Hier ist alles ganz einfach: Wir überprüfen, ob die Nachricht wirklich existiert, extrahieren also die Nachricht selbst ( message ) und die Chat-ID ( chatId ), in der die Korrespondenz stattfindet. Als nächstes erstellen wir ein Objekt zum Senden einer Nachricht SendMessage , übergeben ihm die Nachricht selbst und die Chat-ID – das heißt, was und wohin an den Bot gesendet werden soll. Davon haben wir schon genug. Als nächstes führen wir die Hauptmethode in der Klasse JavarushTelegramBotApplication aus und suchen in Telegram nach unserem Bot: Aus den Protokollen sehen wir, dass der Bot gestartet ist. Also ist es an der Zeit, zu Telegram zu gehen und dem Bot zu schreiben: Wir klicken auf Start und erhalten sofort eine Antwort: Schreiben wir noch etwas Mist zur Überprüfung: Und das war’s, an diesem Punkt können wir sagen, dass unsere JRTB-2-Aufgabe abgeschlossen ist . Da man hier noch keine wirklichen Tests schreiben kann, lassen wir alles so wie es ist. Als nächstes müssen Sie einen neuen Commit erstellen: Achten Sie auf den Namen des Commits: Ich mache Sie noch einmal darauf aufmerksam. Ein Commit enthält zunächst den Namen der Aufgabe und dann eine detailliertere Beschreibung dessen, was getan wurde. Klicken Sie auf „Commit and Push...“ und bestätigen Sie, indem Sie erneut auf „Push“ klicken : Gehen Sie zu unserem Projekt . Nach wie vor hat GitHub den neuen Branch bereits gesehen und bietet an, einen Pull-Request für main zu erstellen. Wir wehren uns nicht und schaffen es: Wie immer haben wir uns bereits für ein Label, ein Projekt entschieden und es mir zugewiesen. Klicken Sie abschließend auf Pull-Anfrage erstellen. Warten wir noch ein wenig, während der Build durchläuft – und fertig, der Pull-Request ist bereit zum Zusammenführen:

Versionierung

Irgendwie habe ich den Punkt übersehen, dass wir eine Versionierung durchführen müssen. Dazu werden wir in unserer Filiale noch ein paar Änderungen vornehmen. Wir gehen zurück zu IDEA und schauen uns die Projektversion im Speicher an: Die Version ist 0.0.1-SNAPSHOT . Dies ist die Pflichtversion. Und wir beginnen damit, die Version des Projekts mit jedem neuen gelösten Problem zu aktualisieren. Bis wir MVP erreichen, wird die Version mit dem Suffix -SNAPSHOT geliefert. Was wird das Versionierungsschema sein? XYZ-SNAPSHOT Wo:

• X – Hauptversionsaktualisierung, enthält häufig Probleme mit der Abwärtskompatibilität mit der vorherigen Version;
• Y – keine sehr großen Änderungen, vollständig kompatibel mit der Vorgängerversion;
• Z ist ein Zähler für Mängel, die wir gefunden und behoben haben.

Auf dieser Grundlage werden wir die erste Version haben – 0.1.0-SNAPSHOT – das heißt, wir hatten noch keine größeren Updates, nur ein bisschen von allem, und wir haben MVP noch nicht erreicht, daher gibt es ein Suffix –SNAPSHOT . Lassen Sie uns dies im Speicher ändern: Gehen Sie zur Datei RELEASE_NOTES, in der wir die Änderungen am Projekt mit jeder neuen Version beschreiben: Unser erster Eintrag. Nun werden wir bei jedem weiteren Versionsupdate hier beschreiben, was genau passiert ist. Wir begehen diesen Fall, schreiben eine Beschreibung: JRTB-2: Projektversion aktualisiert und zu RELEASE_NOTES hinzugefügt. Alles ist genau wie zuvor. Wir warten darauf, dass der Build abgeschlossen ist und wir unsere Änderungen zusammenführen können. Nur hier wird es etwas anders sein. Ich möchte sicherstellen, dass jede Aufgabe im Hauptzweig ein separater Commit ist, sodass das einfache Pushen einer Merge-Pull-Anfrage für uns nicht funktioniert. Git verfügt über die Git-Squash-Option, die alle Commits in einem sammelt und zusammenführt. Wir wählen diese Option: Klicken Sie auf „Squash and Merge“, und uns wird angeboten, die Nachricht zu bearbeiten, die am Ende lautet: Sehr praktisch und vor allem gefragt. Übrigens habe ich eine solche Funktion bei bitbucket noch nicht gesehen =/ Zusammenführung bestätigen. Jetzt müssen Sie nur noch den Aufgabenstatus in unserem Board auf „Fertig“ ändern, einen Kommentar mit einem Link zum Pull-Request schreiben und diesen schließen: Unser Board sieht nun so aus:

Abschluss

Heute haben wir Schritt für Schritt einen Telegram-Bot erstellt und ihn in unserem SpringBoot-Projekt implementiert. Der Bot funktioniert und gibt Antworten. Wir haben über Eigenschaften sofort Zugriff auf die Bot-Daten erhalten. Es folgt noch mehr: Wir werden ein großes Stück machen – JRTB-3 durchführen – und ein Befehlsmuster für unser Projekt hinzufügen. Oh, noch etwas... Ich habe Ihnen gesagt, dass ich den Token nicht veröffentlichen werde, damit er nicht verwendet wird. Aber da ich den Artikel näher an Mitternacht und nach der Arbeit schrieb, stellte sich heraus, dass ich einen gültigen Token im Repository gepostet hatte, und GitGuardian teilte mir dies in einem Brief mit: Vielen Dank dafür! Was nun? Es wird nicht mehr möglich sein, es aus dem Git zu löschen, denn selbst wenn ich ein neues Commit ohne dieses Token hochlade, bleibt es immer noch im alten. Aber ich möchte das Commit nicht löschen und zurücksetzen. Also habe ich den Token vom bereits erwähnten BotFather deaktiviert. Jetzt ist der Token da, aber er ist nicht mehr gültig. Abonnieren Sie mein GitHub-Konto , um den gesamten Code dafür zu sehen, bevor Sie den Artikel veröffentlichen. Vielen Dank fürs Lesen, bis bald.

Eine Liste aller Materialien der Serie finden Sie am Anfang dieses Artikels.