Een Telegram Bot maken in Java: van ontwerp tot implementatie

Dus wat zijn bots? U kunt hier meer over lezen . Om te beginnen moet u de officiële documentatie bekijken voor de bibliotheek die wordt gebruikt om Telegram-bots te ontwikkelen (hierna de "API"). Het is hier te vinden .

Alles is daar heel toegankelijk en duidelijk. Het lijkt erop dat we gewoon code kunnen schrijven en ons kunnen verheugen! Maar zo eenvoudig is het niet. Na veel tijd te hebben besteed aan zoeken, heb ik weetjes gevonden over botontwikkeling, bijvoorbeeld hoe je een toetsenbord maakt, eenCallbackQuery, enzovoorts. Maar ik vond geen complete, uitputtende gids voor de ontwikkeling van Java-bots. Dat bracht me ertoe dit artikel te schrijven. Er zijn veel websites waar u uw eigen gemakkelijk inzetbare bot kunt maken. Maar het feit is dat de meeste van de gemaakte bots referentie-informatie en dergelijke verstrekken. Onze bot is een volwaardige webapplicatie. U kunt een database binden, verschillende API-verzoeken uitvoeren, websites ontleden, complexe berekeningen uitvoeren en meer. De mogelijkheden worden alleen beperkt door uw verbeelding. Ik hoop dat het bovenstaande heeft geholpen om duidelijk te maken waarover ik ga schrijven. Het is heel eenvoudig om een bot op Telegram te registreren. Dit proces wordt in detail beschreven in de documentatie waarnaar hierboven is gelinkt. Voor onze toepassing hoeft u alleen de naam van de bot te weten en het token dat u ontvangt bij het registreren van de bot. In principe, een bot is slechts een op een console gebaseerde webtoepassing. Er is geen front-end, alleen pure opdrachtverwerking. Als je het onder de knie wilt krijgenOverwinteren of leren hoe JSON te ontleden , dan is dit het project voor jou. Laten we beginnen met het toevoegen van een afhankelijkheid aan pom.xml(ik neem aan dat u Maven gebruikt). U kunt dat als volgt doen:

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

Maak vervolgens een Botklasse die de TelegramLongPollingBotklasse erft en de methoden overschrijft:

public class Bot extends TelegramLongPollingBot {

    /**
     * Method for receiving messages.
     * @param update Contains a message from the user.
     */
    @Override
    public void onUpdateReceived(Update update) {
    String message = update.getMessage().getText();
    sendMsg(update.getMessage().getChatId().toString(), message);
    }

    /**
     * Method for creating a message and sending it.
     * @param chatId chat id
     * @param s The String that you want to send as a message.
     */
    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());
        }
    }

    /**
     * This method returns the bot's name, which was specified during registration.
     * @return bot name
     */
    @Override
    public String getBotUsername() {
        return "BotName";
    }

    /**
     * This method returns the bot's token for communicating with the Telegram server
     * @return the bot's token
     */
    @Override
    public String getBotToken() {
        return "BotToken";
    }
}

En nu de inhoud van de mainmethode:

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

Start de bot na het invullen van de methoden getBotUsername()en . getBotToken()Voor nu stuurt het alleen alle berichten die we ernaar sturen naar ons door, een soort " spiegel ". Het werkt als volgt: wanneer u de toepassing start, begint deze om de n seconden verzoeken naar de Telegram-server te verzenden op de volgende URL: https://api.telegram.org/BotToken/getMe , waarbij BotToken het token van uw bot is . Als reactie ontvangt het JSON met alle berichten. Elk van deze berichten wordt door de bibliotheek verwerkt en OnUpdateReceived(Update update)als eenUpdatevoorwerp. En daar werken wij mee. Hierin ligt het mooie van Telegram-bots: ze kunnen op elke computer worden uitgevoerd. Voor het testen hoeft u alleen de applicatie te starten en hoeft u deze niet na elke wijziging op de host in te zetten. Dit is erg handig. Natuurlijk kunt u een bot configureren om met webhooks te werken. Een routebeschrijving daarvoor vind je op internet. Voor de eenvoud gebruiken we LongPolling. Hoe berichten worden verwerkt en wat u als reactie verzendt, wordt alleen beperkt door de mogelijkheden van de taal en bibliotheek. Al het andere is aan jou. Je kunt een bot maken die YouTube-video's voor je doorzoekt. Je kunt een bot maken die je elke dag stuurt wat je jezelf stuurt, zoals een tijdcapsule van een jaar geleden. Of u kunt leren integreren met CRM-systemen en bots maken voor kleine bedrijven - u wordt alleen beperkt door uw verbeeldingskracht. Verder gaan. Degenen die bots hebben gebruikt, weten dat het handig is om ermee te communiceren met behulp van opdrachten die beginnen met het /teken " ", bijvoorbeeld /start. Maar er is een handigere manier: knoppen. Er zijn twee soorten knoppen: knoppen die verschijnen onder een invoerveld ( ReplyKeyboardMarkup) en knoppen die direct onder het bericht staan waaraan ze zijn gekoppeld (InlineKeyboardMarkup). U kunt een basiskennis van hen krijgen uit hun beschrijvingen in de documentatie.

ReplyKeyboardMarkup

In werkelijkheid is dit een reeks knoparrays: List<KeyboardRow <KeyboardButton>>. Hier is voorbeeldcode die een toetsenbord maakt:

public synchronized void setButtons(SendMessage sendMessage) {
        // Create a keyboard
        ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
        sendMessage.setReplyMarkup(replyKeyboardMarkup);
        replyKeyboardMarkup.setSelective(true);
        replyKeyboardMarkup.setResizeKeyboard(true);
        replyKeyboardMarkup.setOneTimeKeyboard(false);

        // Create a list of keyboard rows
        List<KeyboardRow> keyboard = new ArrayList<>();

        // First keyboard row
        KeyboardRow keyboardFirstRow = new KeyboardRow();
        // Add buttons to the first keyboard row
        keyboardFirstRow.add(new KeyboardButton("Hi"));

        // Second keyboard row
        KeyboardRow keyboardSecondRow = new KeyboardRow();
        // Add the buttons to the second keyboard row
        keyboardSecondRow.add(new KeyboardButton("Help");

        // Add all of the keyboard rows to the list
        keyboard.add(keyboardFirstRow);
        keyboard.add(keyboardSecondRow);
        // and assign this list to our keyboard
        replyKeyboardMarkup.setKeyboard(keyboard);
    }

We noemen deze methode in de sendMsg()methode, nadat we er een bericht aan hebben doorgegeven. Zo hebben we een toetsenbord voor dat bericht ingesteld. Wanneer we dit bericht naar de gebruiker sturen, ziet hij de tekst van ons bericht en 2 knoppen met de tekst "Hallo" en "Help" onder elkaar. Wanneer op een van deze knoppen wordt geklikt, krijgt de bot een bericht met de knoptekst. Dus als de client op "Help" klikt , ontvangt de bot een bericht met "Help". Voor de bot lijkt het erop dat de klant zelf "Help" heeft geschreven en de tekst naar de bot heeft gestuurd. En dan verwerk je de berichten.

InlineKeyboardMarkering

Dit is ook een array van arrays. Het is vergelijkbaar met de vorige Markup, maar de logica werkt hier iets anders. Dit type toetsenbord is gekoppeld aan een specifiek bericht en bestaat alleen daarvoor. Hier is een methode voor het opzetten van een inline toetsenbord:

private void setInline() {
        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
        List<InlineKeyboardButton> buttons1 = new ArrayList<>();
        buttons1.add(new InlineKeyboardButton().setText("Button").setCallbackData(17));
        buttons.add(buttons1);

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

Maak een Listbinnen de List, en voeg de inline-knop toe aan de eerste rij. Deze knop kan een URL bevatten, een link naar een kanaal of een CallbackQuery, waarover ik later zal schrijven. Hier stellen we de tekst van onze knop in, wat de gebruiker zal zien, en vervolgens stellen we de gegevens in die naar de bot worden verzonden. In ons voorbeeld ziet de gebruiker "Hallo", en wanneer de knop wordt ingedrukt, wordt het nummer 17 naar de bot gestuurd. Dit is onze CallbackQuery. Een paar woorden over CallbackQuery. Om deze gegevens van het Updateobject te verkrijgen, moet u uitvoeren update.getCallbackQuery(). Deze methode retourneert een CallbackQuery, van waaruit u toegang hebt tot de gegevens die aan de bot zijn doorgegeven. Probeer deze gegevens niet via de update.getMessage().getText()methode te krijgen - u krijgt een 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());
        }
    }

Als er een bericht is, sturen we het naar een nieuwe thread voor verwerking; als er een is CallbackQuery, sturen we naar de juiste thread voor verwerking. U kunt een reactie sturen naar een CallbackQuery. Elk object in Telegram heeft zijn eigen id. Om een antwoord te sturen naar een specifiek CallbackQuery, hoeft u alleen maar de id te weten, die we krijgen van het corresponderende object. Om een antwoord te sturen, noemen we deze methode:

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

BELANGRIJK:De tekst in een reactie op een CallbackQuerymag niet langer zijn dan 200 karakters! Na het verzenden van een dergelijk antwoord, ziet de klant een pop-upvenster met het bericht. Dit venster kan enkele seconden nadat het is verschenen verdwijnen, of het kan blijven bestaan totdat de gebruiker op OK drukt. Om van modus te wisselen, noemen we de answer.setShowAlert(true)methode. Als u truenaar de methode gaat, blijft het venster bestaan totdat op OK wordt gedrukt. Als u false passeert, verdwijnt deze na 5 seconden. Dit zijn alle basisfuncties van de Telegram Bot-bibliotheek . Als je wilt, kun je dingen leren zoals het verzenden van multimedia, geolocatie, enz. Laten we verder gaan met het implementeren van onze bot op een hostingplatform. Voor mijn project heb ik voor Heroku gekozen. Ik denk dat het een redelijk handig hostingplatform is met een eigen CLI. Het is gratis, maar bij dit abonnement gaat uw bot in slaapstand nadat er 30 minuten geen verzoeken zijn ontvangen. Het wordt wakker wanneer een verzoek wordt ontvangen. Dit gebeurt zo snel dat u het niet eens merkt (tenzij de databaseverbinding natuurlijk niet opnieuw wordt opgestart). Het gratis abonnement wordt beperkt door een database van 5 MB, 100 MB schijfruimte, 2 TB data per maand en 1 dyno. Een dyno is uw lopende applicatie. Ik zal meteen zeggen dat het de implementatie was die me problemen bezorgde, aangezien ik mijn applicaties nog nooit eerder had geïmplementeerd. Tijdens de implementatie heeft Heroku een bestand met de naam Procfile nodig (zonder extensie). We maken het in de projectroot. Binnenin schrijven we worker: sh target/bin/workerBot, waarbij workerBot de naam is die is gespecificeerd in pom.xml. Een schscript, gegenereerd door de Maven Application Assembler-plug-in (appassimbler-maven-plug-in), wordt gestart. Het script beschrijft hoe je een gecompileerd jar-bestand start. De naam van de te starten klasse wordt opgegeven tussen <mainClass>en </mainClass>, terwijl de naam van het script wordt gegeven tussen <name>en </name>in 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>

Voordat u dit proces start, moet u zich registreren op Heroku en zowel Git als de Heroku CLI installeren . Als uw applicatie een database nodig heeft, vergeet dan niet de vereiste database toe te voegen wanneer u een nieuwe applicatie maakt. Verder moet u de host, gebruikersnaam, wachtwoord en poort voor uw database bepalen en deze vervolgens aangeven in uw toepassing. Bouw vervolgens, voordat u het implementeert, uw project met Maven .

mvn clean install

Eerst gaan we naar onze projectdirectory en initialiseren we de repository met het commando git init. Vervolgens voegen we ons project toe aan deze repository.

git add .

Vervolgens voeren we de wijzigingen door

git commit -m "First commit in the project"

Vervolgens moet u zich aanmelden bij heroku. Schrijf het volgende op de opdrachtregel

heroku login

Voer de inloggegevens in die u tijdens de registratie hebt gemaakt. Bepaal daarna de URL van uw repository op heroku. Dit doe je in de instellingen. Dan schrijven wij

git remote add heroku [url]

Er is een externe heroku-repository toegevoegd voor uw repository. Vervolgens schrijven we

git push heroku master

Daarna wachten we ... als de applicatie met succes is geïmplementeerd, voert u de volgende opdracht uit

heroku ps:scale worker=1

En dat is alles, uw applicatie is actief. Als dit niet het geval is, bekijk dan zorgvuldig de logboeken. Hoogstwaarschijnlijk heeft een fout in uw toepassing ervoor gezorgd dat deze is mislukt.

Bedankt voor het lezen van zo'n lang artikel. Ik hoop dat iemand het nuttig zal vinden en dat het je veel tijd zal besparen op de gebieden die me problemen gaven tijdens de ontwikkeling.