Erstellen eines Telegram-Bots in Java: von der Idee bis zur Bereitstellung

Was sind überhaupt Bots? Hier können Sie ausführlich darüber lesen . Zunächst müssen Sie die offizielle Dokumentation der Bibliothek zur Entwicklung von Bots auf Telegram (im Folgenden als API bezeichnet) lesen. Sie liegt hier . Alles dort ist sehr zugänglich und verständlich. Es scheint, als würde man schreiben und sich freuen! Aber so einfach ist es nicht. Nachdem ich viel Zeit in Suchmaschinen verbracht hatte, fand ich Wissensschnipsel zur Bot-Entwicklung, zum Beispiel, wie man eine Tastatur erstellt, CallbackQuery verarbeitet und dergleichen. Ich habe noch nie eine vollständige und umfassende Anleitung zur Entwicklung von Bots in Java gefunden. Dies hat mich dazu veranlasst, diesen Artikel zu schreiben. Es gibt viele Websites im Internet, auf denen Sie Ihren eigenen Bot mit einer vorgefertigten Bereitstellung erstellen können. Aber der Punkt ist. dass zumeist Bots erstellt werden, die Hintergrundinformationen usw. liefern können. Unser Bot ist eine vollwertige Webanwendung, an die Sie eine Datenbank binden, Anfragen an verschiedene APIs stellen, Websites analysieren, komplexe Berechnungen durchführen usw. können. Die Angelegenheit ist nur durch Ihre Vorstellungskraft begrenzt. Ich hoffe, dass ich Ihnen mit diesen Zeilen ein wenig erklärt habe, worüber ich schreiben werde. Die Registrierung eines Bots in Telegram ist sehr einfach; dieser Vorgang wird in der Dokumentation unter dem obigen Link ausführlich beschrieben. Für unsere Bewerbung müssen Sie lediglich den Namen des Bots und den Token kennen, den Sie bei der Registrierung erhalten. Im Wesentlichen ist ein Bot nur eine Konsolen-Webanwendung. Kein Frontend, reine Befehlsverarbeitung. Wenn Sie Hibernate gut beherrschen oder lernen möchten, wie man JSON analysiert, dann ist dieses Projekt genau das Richtige für Sie. Beginnen wir mit der Aufnahme der Abhängigkeit in pom.xml (wir gehen davon aus, dass Sie Maven verwenden). Sie können es so machen:

<dependency>
            <groupId>org.telegram</groupId>
            <artifactId>telegrambots</artifactId>
            <version>3.5</version>
</dependency>

Dann erstellen wir eine Klasse Bot, erben sie von der Klasse TelegramLongPollingBotund überschreiben ihre Methoden:

public class Bot extends TelegramLongPollingBot {

    /**
     * Methode zum Empfangen von Nachrichten.
     * @param update Enthält eine Nachricht des Benutzers.
     */
    @Override
    public void onUpdateReceived(Update update) {
	String message = update.getMessage().getText();
	sendMsg(update.getMessage().getChatId().toString(), message);
    }

    /**
     * Methode zum Einrichten und Senden einer Nachricht.
     * @param chatId chat id
     * @param s Die Zeichenfolge, die als Nachricht gesendet werden soll.
     */
    public synchronized void sendMsg(String chatId, String s) {
        SendMessage sendMessage = new SendMessage();
        sendMessage.enableMarkdown(true);
        sendMessage.setChatId(chatId);
        sendMessage.setText(s);
        try {
            sendMessage(sendMessage);
        } catch (TelegramApiException e) {
            log.log(Level.SEVERE, "Exception: ", e.toString());
        }
    }

    /**
     * Die Methode gibt den Namen des bei der Registrierung angegebenen Bots zurück.
     * @return Bot-Name
     */
    @Override
    public String getBotUsername() {
        return ”BotName”;
    }

    /**
     * Die Methode gibt das Token des Bots zurück, um mit dem Telegram-Server zu kommunizieren
     * @return token for the bot
     */
    @Override
    public String getBotToken() {
        return ”BotToken”;
    }
}

Nun, der Inhalt der Methode main:

public static void main(String[] args) {
        ApiContextInitializer.init();
        TelegramBotsApi telegramBotsApi = new TelegramBotsApi();
        try {
            telegramBotsApi.registerBot(Bot.getBot());
        } catch (TelegramApiRequestException e) {
            e.printStackTrace();
        }
}

Indem wir es in die Methoden eingeben getBotUsername(), getBotToken()starten wir den Bot. Vorerst leitet er lediglich alle Nachrichten, die wir an ihn senden, an uns weiter, eine Art „Spiegel“. Das Ganze funktioniert wie folgt: Wenn Sie die Anwendung starten, sendet sie alle n Sekunden eine GET-Anfrage an den Telegram-Server unter der folgenden URL: https://api.telegram.org/BotToken/getMe, wo sich BotToken befindet das Token Ihres Bots, der eine JSON-Antwort erhält, die alle Nachrichten enthält. Jede dieser Nachrichten wird von der Bibliothek verarbeitet und gelangt OnUpdateReceived(Update update)als Objekt zur Methode Update. Damit arbeiten wir. Das ist das Schöne an Telegram-Bots. Sie können auf jedem Computer funktionieren. Zum Testen müssen Sie nur die Anwendung starten und müssen sie nicht nach jeder Änderung auf dem Hosting bereitstellen. Es ist sehr bequem. Natürlich kann der Bot so konfiguriert werden, dass er mit einem Webhook funktioniert; das Handbuch finden Sie im Internet; der Einfachheit halber arbeiten wir mit LongPolling. Wie Nachrichten verarbeitet werden und was als Antwort gesendet wird, wird nur durch die Sprachtools und die Bibliothek eingeschränkt, alles andere liegt in Ihrem Ermessen. Sie können einen Bot erstellen, der für Sie nach Videos auf YouTube sucht. Sie können einen Bot erstellen, der Ihnen jeden Tag das sendet, was Sie beispielsweise in einem Jahr an sich selbst senden, eine Art Zeitkapsel. Oder Sie können lernen, wie Sie sich in CRM-Systeme integrieren und Bots für kleine Unternehmen erstellen. Ihre Vorstellungskraft setzt hier keine Grenzen. Fortfahren. Diejenigen, die Bots verwendet haben, wissen, dass es bequem ist, mit ihnen zu interagieren, indem sie «/»beispielsweise Befehle verwenden, die mit dem Zeichen beginnen /start. Aber es gibt einen bequemeren Weg – Tasten. Es gibt zwei Arten von Schaltflächen: Schaltflächen, die unter dem Eingabefeld angezeigt werden, ReplyKeyboardMarkupund Schaltflächen, die direkt unter der Nachricht angezeigt werden, mit der sie verknüpft sind InlineKeyboardMarkup. In der Dokumentation können Sie sich kurz mit deren Beschreibung vertraut machen. AntwortenKeyboardMarkup. Im Wesentlichen handelt es sich dabei um ein Array von Schaltflächen-Arrays List<KeyboardRow<KeyboardButton>>. Hier ist ein Beispielcode, der die Tastatur erstellt

public synchronized void setButtons(SendMessage sendMessage) {
        // Eine Tastatur erstellen
        ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
        sendMessage.setReplyMarkup(replyKeyboardMarkup);
        replyKeyboardMarkup.setSelective(true);
        replyKeyboardMarkup.setResizeKeyboard(true);
        replyKeyboardMarkup.setOneTimeKeyboard(false);

        // Eine Liste mit Tastaturzeichenfolgen erstellen
        List<KeyboardRow> keyboard = new ArrayList<>();

        // Erste Zeile der Tastatur
        KeyboardRow keyboardFirstRow = new KeyboardRow();
        // Schaltflächen zur ersten Zeile der Tastatur hinzufügen
        keyboardFirstRow.add(new KeyboardButton(“Привет”));

        // Zweite Zeile der Tastatur
        KeyboardRow keyboardSecondRow = new KeyboardRow();
        // Schaltflächen zur zweiten Zeile der Tastatur hinzufügen
        keyboardSecondRow.add(new KeyboardButton(“Помощь”);

        // Alle Tastaturzeichenfolgen zur Liste hinzufügen
        keyboard.add(keyboardFirstRow);
        keyboard.add(keyboardSecondRow);
        // und setze diese Liste auf unsere Tastatur
        replyKeyboardMarkup.setKeyboard(keyboard);
    }

In einer Methode sendMsg()rufen wir diese Methode auf, indem wir ihr eine Nachricht übergeben und so die Tastatur für diese Nachricht festlegen. Wenn wir diese Nachricht an den Benutzer senden, sieht er den von uns festgelegten Nachrichtentext sowie zwei Schaltflächen mit der Aufschrift „Hallo“ und „Hilfe“ nebeneinander. Durch Klicken auf diese Schaltflächen wird eine Nachricht an den Bot gesendet, deren Text dem entspricht, was auf der Schaltfläche steht. Das heißt, wenn der Client auf „Hilfe“ klickt, erhält der Bot eine Nachricht mit dem Text „Hilfe“. Für ihn ist es so, als ob der Kunde selbst den Text „Hilfe“ geschrieben und ihm geschickt hätte. Dann verarbeiten Sie solche Nachrichten. InlineKeyboardMarkup Dies ist ebenfalls ein Array von Arrays. Es ähnelt dem vorherigen Markup, die Betriebslogik unterscheidet sich jedoch geringfügig. Eine solche Tastatur ist an eine bestimmte Nachricht gebunden und existiert nur für diese. Hier ist die Methode zur Installation der Inline-Tastatur

private void setInline() {
        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
        List<InlineKeyboardButton> buttons1 = new ArrayList<>();
        buttons1.add(new InlineKeyboardButton().setText(“Кнопка“).setCallbackData(17));
        buttons.add(buttons1);

        InlineKeyboardMarkup markupKeyboard = new InlineKeyboardMarkup();
        markupKeyboard.setKeyboard(buttons);
    }

Erstellen Sie Listin Listund fügen Sie der ersten Zeile eine Inline-Schaltfläche hinzu. Eine solche Schaltfläche kann eine URL, einen Link zu einem Kanal oder , CallbackQueryworüber ich etwas später schreiben werde, enthalten. Hier legen wir den Text für unsere Schaltfläche fest, den der Benutzer sehen wird, und legen dann die Daten fest, die an den Bot gesendet werden. In unserem Beispiel sieht der Benutzer „Hallo“, und wenn er darauf klickt, wird dem Bot die Nummer 17 gesendet, das ist unsere CallbackQuery. Ein paar Worte dazu CallbackQuery. Um solche Daten von einem Objekt zu erhalten, Updatemüssen Sie ausführen update.getCallbackQuery(). Diese Methode gibt zurück CallbackQuery, von der Sie bereits die an den Bot übertragenen Daten erhalten können. Sie müssen nicht versuchen, diese Daten über die Methode update.getMessage().getText()get abzurufen NullPointerException.

@Override
    public void onUpdateReceived(Update update) {
        if(update.hasMessage()) {
            ThreadClass thread = new ThreadClass(update.getMessage());
        } else  if(update.hasCallbackQuery()) {
            AnswerCallbackThread answerThread = new AnswerCallbackThread(update.getCallbackQuery());
        }
    }

Wenn eine Nachricht vorhanden ist, senden wir die Nachricht zur Verarbeitung an einen neuen Thread. Wenn eine Nachricht vorhanden ist CallbackQuery, senden wir sie zur Verarbeitung an den entsprechenden Thread. Sie CallbackQuerykönnen eine Antwort senden. Jedes Objekt in Telegram hat seine eigene ID. Um eine Antwort an ein bestimmtes Objekt zu senden, CallbackQuerymüssen wir lediglich dessen ID kennen, die wir vom entsprechenden Objekt erhalten. Um eine Antwort zu senden, rufen Sie diese Methode auf:

public synchronized void answerCallbackQuery(String callbackId, String message) {
        AnswerCallbackQuery answer = new AnswerCallbackQuery();
        answer.setCallbackQueryId(callbackId);
        answer.setText(message);
        answer.setShowAlert(true);
        try {
            answerCallbackQuery(answer);
        } catch (TelegramApiException e) {
            e.printStackTrace();
        }
    }

WICHTIG:Der Antworttext CallbackQuerysollte nicht länger als 200 Zeichen sein! Beim Senden einer solchen Antwort erhält der Client ein Popup-Fenster, in das die Nachricht geschrieben wird. Ein solches Fenster kann einige Sekunden nach dem Erscheinen verschwinden oder hängen bleiben, bis der Benutzer auf „OK“ drückt. Um diese Modi zu wechseln, rufen wir die answer.setShowAlert(true). Wenn truedas Fenster hängen bleibt, bis Sie auf OK drücken, falseverschwindet es nach 5 Sekunden. Im Prinzip sind das alle Grundfunktionen der Telegram-Bot-Bibliothek. Wenn Sie möchten, können Sie aus der Dokumentation Dinge wie das Versenden von Multimedia, Geolokalisierung usw. lernen. Fahren wir mit der Bereitstellung unseres Bots beim Hosting fort. Für mein Projekt habe ich mich für Heroku entschieden, weil es meiner Meinung nach ein recht praktisches Hosting ist, das über eine eigene CLI verfügt. Es ist kostenlos, aber bei dieser Geschwindigkeit geht Ihr Bot nach 30 Minuten in den Ruhezustand, wenn keine Anfragen eingehen. Als eine Anfrage an ihn gesendet wird, wacht er auf. Dies geschieht recht schnell, Sie merken es gar nicht (es sei denn natürlich, die Verbindung zur Datenbank wird wiederhergestellt). Das Limit für den kostenlosen Plan beträgt 5 MB Datenbank, 100 MB Speicherplatz, 2 TB Datenverkehr pro Monat, 1 Dino. Dino ist Ihre laufende Anwendung. Ich möchte gleich sagen, dass es die Bereitstellungsphase war, die mir Schwierigkeiten bereitete, da ich meine Anwendungen noch nie zuvor bereitgestellt hatte. Bei der Bereitstellung benötigt Heroku eine Datei namens Procfile (ohne Erweiterung). Wir erstellen es im Stammverzeichnis des Projekts und schreiben dort worker: sh target/bin/workerBot workerBot – den Namen, den wir in angeben. pom.xml Das mit dem Maven-Plugin appassembler-maven-plugin generierte sh-Skript wird gestartet. Das Skript beschreibt die Ausführung des kompilierten JAR. Der Name der zu startenden Klasse wird zwischen <mainClass></mainClass> angegeben, der Name des Skripts zwischen <name></name> pom.xml:

...
<build>
    <plugins>
        ...
       <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>appassembler-maven-plugin</artifactId>
            <version>1.1.1</version>
            <configuration>
                <assembleDirectory>target</assembleDirectory>
                <programs>
                    <program>
                        <mainClass>com.home.server.TelegramBot</mainClass>
                        <name>workerBot</name>
                    </program>
                </programs>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>assemble</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Bevor Sie diesen Vorgang starten, sollten Sie sich bei Heroku registrieren, Git und die Heroku-CLI installieren. Wenn Ihre Anwendung eine Datenbank erfordert, vergessen Sie bei der Registrierung einer neuen Anwendung nicht, die benötigte Datenbank hinzuzufügen. Als nächstes müssen Sie den Host, den Benutzernamen, das Passwort und den Port Ihrer Datenbank herausfinden und diese dann in Ihrer Anwendung angeben. Erstellen Sie als Nächstes vor der Bereitstellung Ihr Projekt mit Maven.

mvn clean install

Zunächst gehen wir in das Verzeichnis unseres Projekts, initialisieren das Repository mit dem Befehl.git init Anschließend fügen wir unser Projekt zu diesem Repository hinzu

git add .

Nachdem wir die Änderungen übernommen haben

git commit -m “First commit in project”

Als nächstes müssen Sie sich bei Heroku anmelden und in die Befehlszeile schreiben

heroku login

Geben Sie Ihre bei der Registrierung angegebenen Daten ein. Dann müssen Sie die URL Ihres Repositorys auf Heroku herausfinden, dies erfolgt in den Einstellungen. Dann schreiben wir

git remote add heroku [url]

Das Heroku-Remote-Repository wird Ihrem Repository hinzugefügt. Als nächstes schreiben wir

git push heroku master

Wir warten... Wenn die Bereitstellung der Anwendung erfolgreich ist, führen wir den Befehl aus

heroku ps:scale worker=1

Und schon läuft Ihre Anwendung. Wenn dies nicht der Fall ist, sehen Sie sich die Protokolle sorgfältig an. Höchstwahrscheinlich liegt ein Fehler in Ihrer Anwendung vor, der zum Absturz geführt hat. Vielen Dank, dass Sie einen so langen Artikel gelesen haben. Ich hoffe, jemand findet ihn nützlich und spart viel Zeit an Stellen, an denen ich während der Entwicklung gestolpert bin.