Skapa en telegrambot i Java: från idé till implementering

Så vad är bots? Du kan läsa mer om detta här . För att börja måste du granska den officiella dokumentationen för biblioteket som används för att utveckla Telegram-bots (hädanefter "API"). Den finns här . Allt där är väldigt lättillgängligt och tydligt. Det verkar som att vi bara kan skriva kod och glädjas! Men det är inte så enkelt. Efter att ha spenderat mycket tid på att leta har jag hittat kunskapsbitar om botutveckling, till exempel hur man gör ett tangentbord, hanterar enCallbackQuery, och så vidare. Men jag hittade inte en komplett, uttömmande guide för utveckling av Java-bot. Det fick mig att skriva den här artikeln. Det finns många webbplatser där du kan skapa din egen lättanvända bot. Men faktum är att de flesta av de skapade botarna ger referensinformation och liknande. Vår bot är en fullfjädrad webbapplikation. Du kan binda en databas, utföra olika API-förfrågningar, analysera webbplatser, utföra komplexa beräkningar och mer. Möjligheterna begränsas endast av din fantasi. Jag hoppas att ovanstående har bidragit till att förtydliga vad jag ska skriva om. Det är väldigt enkelt att registrera en bot på Telegram. Denna process beskrivs i detalj i dokumentationen som länkas till ovan. För vår ansökan behöver du bara känna till botens namn och den token du får när du registrerar boten. I grund och botten, en bot är bara en konsolbaserad webbapplikation. Det finns inget gränssnitt, bara ren kommandobearbetning. Om du vill bemästraGå i viloläge eller lär dig att analysera JSON , då är det här projektet för dig. Låt oss börja med att lägga till ett beroende till pom.xml(jag antar att du använder Maven). Du kan göra så här:

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

Skapa sedan en Botklass som ärver TelegramLongPollingBotklassen och åsidosätt dess metoder:

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

Och nu innehållet i mainmetoden:

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

Efter att ha fyllt i metoderna getBotUsername()och getBotToken()startar du boten. För närvarande omdirigerar den bara alla meddelanden vi skickar till oss, ungefär som en " spegel ". Det fungerar så här: när du startar programmet börjar det skicka förfrågningar till Telegram-servern, en gång var n:e sekund, på följande URL: https://api.telegram.org/BotToken/getMe , där BotToken är din bots token . Som svar får den JSON som innehåller alla meddelanden. Vart och ett av dessa meddelanden bearbetas av biblioteket och skickas till OnUpdateReceived(Update update)metoden som enUpdateobjekt. Och det är det vi jobbar med. Häri ligger skönheten med Telegram-bots: de kan köras på vilken dator som helst, testning av den kräver bara att applikationen startas, och du behöver inte distribuera den till värden efter varje ändring. Detta är väldigt bekvämt. Naturligtvis kan du konfigurera en bot att fungera med hjälp av webhooks. Du kan hitta anvisningar för det på Internet. För enkelhetens skull använder vi LongPolling. Hur meddelanden behandlas och vad du skickar som svar begränsas endast av språkets och bibliotekets möjligheter. Allt annat är upp till dig. Du kan skapa en bot som söker efter YouTube-videor åt dig. Du kan skapa en bot som skickar det du skickar till dig varje dag, som en tidskapsel från ett år sedan. Eller så kan du lära dig att integrera med CRM-system och skapa bots för småföretag – du är bara begränsad av din fantasi. Gå vidare. De som har använt bots vet att det är bekvämt att interagera med dem med kommandon som börjar med tecknet " ", /till exempel /start. Men det finns ett bekvämare sätt: knappar. Det finns två typer av knappar: de som visas under ett inmatningsfält ( ReplyKeyboardMarkup) och knappar som är direkt under meddelandet de är länkade till (InlineKeyboardMarkup). Du kan få en grundläggande förståelse för dem från deras beskrivningar i dokumentationen.

ReplyKeyboardMarkup

I verkligheten är detta en uppsättning knapparrayer: List<KeyboardRow <KeyboardButton>>. Här är exempelkoden som skapar ett tangentbord:

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

Vi kallar denna metod i sendMsg()metoden, efter att ha skickat den ett meddelande. Så här ställer vi in ​​ett tangentbord för det meddelandet. När vi skickar detta meddelande till användaren kommer han att se texten i vårt meddelande och 2 knappar som säger " Hej" och "Hjälp" , den ena under den andra. När en av dessa knappar klickas, skickas boten ett meddelande som innehåller knapptexten. Så om klienten klickar på "Hjälp" kommer boten att få ett meddelande med "Hjälp". För boten kommer det att verka som att klienten själv skrev "Hjälp" och skickade texten till boten. Och sedan bearbetar du meddelandena.

InlineKeyboardMarkup

Detta är också en array av arrayer. Det liknar den tidigare Markup, men logiken fungerar lite annorlunda här. Den här typen av tangentbord är kopplad till ett specifikt meddelande och finns bara för det. Här är en metod för att ställa in ett inlinetangentbord:

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

Skapa en Listinom List, och lägg till inline-knappen på den första raden. Den här knappen kan innehålla en URL, en länk till en kanal eller en , CallbackQuerysom jag kommer att skriva om lite senare. Det är här vi ställer in vår knapps text, vilket är vad användaren kommer att se, och sedan ställer vi in ​​data som ska skickas till boten. I vårt exempel ser användaren "Hej", och när knappen trycks kommer siffran 17 att skickas till boten. Det här är vår CallbackQuery. Några ord angående CallbackQuery. För att få dessa data från objektet Updatemåste du köra update.getCallbackQuery(). Denna metod returnerar en CallbackQuery, från vilken du kan komma åt data som skickas till boten. Försök inte få tag på dessa data genom update.getMessage().getText()metoden – du får en 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());
        }
    }

Om det finns ett meddelande skickar vi det till en ny tråd för bearbetning; om det finns en CallbackQueryskickar vi till lämplig tråd för bearbetning. Du kan skicka ett svar till en CallbackQuery. Varje objekt i Telegram har sitt eget id. För att skicka ett svar till ett specifikt CallbackQuery, behöver du bara känna till dess id, som vi får från motsvarande objekt. För att skicka ett svar kallar vi denna metod:

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

VIKTIG:Texten i ett svar på a CallbackQueryfår inte vara längre än 200 tecken! Efter att ha skickat ett sådant svar kommer klienten att se ett popup-fönster som innehåller meddelandet. Det här fönstret kan försvinna några sekunder efter att det har dykt upp, eller så kan det finnas kvar tills användaren trycker på OK. För att byta läge kallar vi answer.setShowAlert(true)metoden. Om du går över truetill metoden kvarstår fönstret tills du trycker på OK. Om du passerar falskt försvinner det efter 5 sekunder. Dessa är alla Telegram Bot-bibliotekets grundläggande funktioner. Om du vill kan du lära dig saker som hur du skickar multimedia, geolokalisering, etc. Låt oss gå vidare till att distribuera vår bot till en värdplattform. För mitt projekt valde jag Heroku. Jag tycker att det är en ganska bekväm värdplattform med en egen CLI. Det är gratis, men med denna plan kommer din bot att gå i viloläge efter 30 minuter utan att ha mottagit några förfrågningar. Den kommer att vakna när en förfrågan tas emot. Detta händer så snabbt att du inte ens märker det (såvida inte databasanslutningen naturligtvis inte startar om). Den kostnadsfria planen är begränsad av en 5MB databas, 100MB diskutrymme, 2TB data per månad och 1 dyno. En dyno är din applikation som körs. Jag ska genast säga att det var implementeringen som orsakade mig svårigheter, eftersom jag aldrig hade distribuerat mina applikationer tidigare. Under distributionen kräver Heroku en fil med namnet Procfile (utan tillägg). Vi skapar det i projektroten. Inuti skriver vi worker: sh target/bin/workerBot, där workerBot är namnet som anges i pom.xml. En shskriptet, genererat av Maven Application Assembler Plugin (appassembler-maven-plugin), kommer att starta. Skriptet beskriver hur man startar en kompilerad jar-fil. Namnet på klassen som ska lanseras anges mellan <mainClass>och </mainClass>, medan namnet på skriptet ges mellan <name>och </name>i 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>

Innan du startar denna process bör du registrera dig på Heroku och installera både Git och Heroku CLI . Om din applikation behöver en databas, glöm inte att lägga till den nödvändiga databasen när du skapar en ny applikation. Vidare måste du bestämma värd, användarnamn, lösenord och port för din databas och sedan ange dem i din ansökan. Därefter, innan du distribuerar, bygg ditt projekt med Maven .

mvn clean install

Först går vi till vår projektkatalog och initierar förvaret med kommandot git init. Sedan lägger vi till vårt projekt i detta förråd.

git add .

Sedan åtar vi förändringarna

git commit -m "First commit in the project"

Därefter måste du logga in på heroku. Skriv följande på kommandoraden

heroku login

Ange inloggningsuppgifterna du skapade under registreringen. Efter det bestämmer du ditt förvars URL på heroku. Detta gör du i inställningarna. Sen skriver vi

git remote add heroku [url]

Ett fjärrstyrt heroku-förråd läggs till för ditt förråd. Därefter skriver vi

git push heroku master

Sedan väntar vi... om applikationen distribueras framgångsrikt, kör följande kommando

heroku ps:scale worker=1

Och det är allt, din applikation är igång. Om det inte är det, titta noga på loggarna. Troligtvis har ett fel i din applikation orsakat att den misslyckats. Tack för att du läser en så lång artikel. Jag hoppas att någon kommer att ha nytta av det och att det kommer att spara dig mycket tid inom de områden som gav mig problem under utvecklingen.