Telegram Bot létrehozása Java nyelven: a koncepciótól a telepítésig

Tehát mik azok a botok? Erről bővebben itt olvashat . A kezdéshez át kell tekintenie a Telegram robotok (a továbbiakban: API) fejlesztéséhez használt könyvtár hivatalos dokumentációját. Itt található . Ott minden nagyon hozzáférhető és világos. Úgy tűnik, csak írhatunk kódot és örülhetünk! De ez nem ilyen egyszerű. Miután sok időt eltöltöttem a kereséssel, botfejlesztéssel kapcsolatos ismereteket találtam, például hogyan kell billentyűzetet készíteni,CallbackQuery, és így tovább. De nem találtam teljes, kimerítő útmutatót a Java bot fejlesztéshez. Ez késztetett arra, hogy megírjam ezt a cikket. Nagyon sok webhely van, ahol létrehozhatja saját, könnyen telepíthető botját. A tény azonban az, hogy a létrehozott robotok többsége referencia információkat és hasonlókat nyújt. A robotunk egy teljes értékű webes alkalmazás. Összeköthet egy adatbázist, végrehajthat különféle API-kéréseket, elemezhet webhelyeket, végezhet összetett számításokat stb. A lehetőségeknek csak a képzelet szab határt. Remélem, hogy a fentiek segítettek tisztázni, hogy miről fogok írni. Nagyon egyszerű egy bot regisztrálása a Telegramon. Ezt a folyamatot részletesen leírja a fent hivatkozott dokumentáció. Alkalmazásunkhoz csak a bot nevét és a bot regisztrálásakor kapott tokent kell ismernie. Alapvetően, a bot csak egy konzol alapú webalkalmazás. Nincs frontend, csak tiszta parancsfeldolgozás. Ha el akarod sajátítaniHibernáljon , vagy tanulja meg a JSON elemzését , akkor ez a projekt az Ön számára. Kezdjük azzal, hogy adjunk hozzá egy függőséget pom.xml(feltételezem, hogy Maven-t használsz). Ezt így teheti meg:

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

Ezután hozzon létre egy Botosztályt, amely örökli az TelegramLongPollingBotosztályt, és írja felül a metódusait:

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

És most a módszer tartalma main:

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

getBotUsername()A és metódusok kitöltése után getBotToken()indítsa el a botot. Egyelőre csak átirányít hozzánk minden üzenetet, amit küldünk neki, olyan, mint egy " tükör ". Ez a következőképpen működik: az alkalmazás elindításakor n másodpercenként elkezd kéréseket küldeni a Telegram szervernek a következő URL-címen: https://api.telegram.org/BotToken/getMe , ahol a BotToken a robotod tokenje . Válaszul megkapja az összes üzenetet tartalmazó JSON-t. Ezen üzenetek mindegyikét a könyvtár feldolgozza, és OnUpdateReceived(Update update)mint an továbbítja a metódusnakUpdatetárgy. És ezzel dolgozunk. Ebben rejlik a Telegram botok szépsége: bármilyen számítógépen futhatnak, a teszteléshez elég az alkalmazás elindítása, és nem kell minden változtatás után telepíteni a gazdagépre. Ez nagyon kényelmes. Természetesen beállíthat egy botot úgy, hogy webhook segítségével működjön. Az interneten találsz ehhez útmutatást. Az egyszerűség kedvéért a LongPolling-ot használjuk. Az üzenetek feldolgozása és a válaszként küldött üzenetek csak a nyelv és a könyvtár képességei által korlátozódnak. Minden más rajtad múlik. Készíthet egy robotot, amely megkeresi Ön helyett a YouTube-videókat. Készíthetsz egy botot, amely elküldi neked azt, amit naponta küldesz magadnak, mint egy egy évvel ezelőtti időkapszulát. Vagy megtanulhat integrálni a CRM rendszerekkel, és robotokat készíthet kisvállalkozások számára – csak a képzelet szab határt. Továbblépni. Azok, akik használtak botokat, tudják, hogy kényelmes a velük való interakció a " /" karakterrel kezdődő parancsokkal, például /start. De van egy kényelmesebb módszer: a gombok. Kétféle gomb létezik: azok, amelyek egy beviteli mező alatt jelennek meg ( ReplyKeyboardMarkup), és azok a gombok, amelyek közvetlenül az üzenet alatt találhatók, amelyhez kapcsolódnak (InlineKeyboardMarkup). Alapvető megértést kaphat ezekről a dokumentációban található leírásukból.

ReplyKeyboardMarkup

A valóságban ez egy gombtömb tömbje: List<KeyboardRow <KeyboardButton>>. Íme egy példakód a billentyűzet létrehozásához:

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

Ezt a metódust a metódusban hívjuk sendMsg(), miután üzenetet küldtünk neki. Így állítjuk be a billentyűzetet az üzenethez. Amikor elküldjük ezt az üzenetet a felhasználónak, látni fogja az üzenetünk szövegét és a 2 gombot, amelyeken egymás alatt a "Szia" és a "Súgó" felirat áll. Ha ezen gombok valamelyikére kattintanak, a bot üzenetet küld, amely tartalmazza a gomb szövegét. Tehát, ha a kliens a "Súgó" gombra kattint , a bot "Súgó" üzenetet kap . A bot számára úgy tűnik, hogy maga az ügyfél írta a "Súgó"-t , és elküldte a szöveget a botnak. És akkor feldolgozza az üzeneteket.

InlineKeyboardMarkup

Ez is egy tömbök tömbje. Hasonló az előző Markuphoz, de a logika itt egy kicsit másképp működik. Ez a típusú billentyűzet egy adott üzenethez van csatolva, és csak ehhez létezik. Íme egy módszer a beépített billentyűzet beállítására:

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

Hozzon létre egy-t Lista -n belül List, és adja hozzá a soron belüli gombot az első sorhoz. Ez a gomb tartalmazhat egy URL-t, egy csatornára mutató hivatkozást vagy egy CallbackQuery, amiről kicsit később írok. Itt állítjuk be a gombunk szövegét, amit a felhasználó látni fog, majd beállítjuk a botnak küldendő adatokat. Példánkban a felhasználó a "Szia" üzenetet látja, és a gomb megnyomásakor a 17-es szám kerül elküldésre a botnak. Ez a miénk CallbackQuery. Néhány szó ezzel kapcsolatban CallbackQuery. Ahhoz, hogy ezeket az adatokat lekérje az objektumról Update, a következőt kell végrehajtania update.getCallbackQuery(): . Ez a metódus egy -et ad vissza CallbackQuery, amelyből hozzáférhet a botnak átadott adatokhoz. Ne próbálja meg ezeket az adatokat a update.getMessage().getText()metóduson keresztül megszerezni – kap egy 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());
        }
    }

Ha van üzenet, elküldjük egy új szálra feldolgozásra; ha van CallbackQuery, akkor a megfelelő szálra küldjük feldolgozásra. Választ küldhet egy CallbackQuery. A Telegram minden objektumának megvan a maga azonosítója. Ha választ szeretne küldeni egy adott objektumra CallbackQuery, csak ismernie kell az azonosítóját, amelyet a megfelelő objektumtól kapunk. Válasz küldéséhez ezt a módszert hívjuk:

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

FONTOS:A válasz szövege CallbackQuerynem lehet hosszabb 200 karakternél! Az ilyen válasz elküldése után az ügyfél egy felugró ablakot fog látni, amely az üzenetet tartalmazza. Ez az ablak néhány másodperccel a megjelenése után eltűnhet, vagy mindaddig fennmaradhat, amíg a felhasználó meg nem nyomja az OK gombot. Az üzemmódváltáshoz a answer.setShowAlert(true)metódust nevezzük. Ha átlép truea metódusra, az ablak az OK gomb megnyomásáig fennmarad. Ha hamis értéket ad meg, akkor 5 másodperc múlva eltűnik. Ezek mind a Telegram Bot könyvtár alapvető funkciói. Ha szeretné, megtanulhat olyan dolgokat, mint például a multimédia küldése, a földrajzi helymeghatározás stb. Térjünk át a robotunk tárhelyplatformra történő telepítésére. A projektemhez a Herokut választottam. Szerintem ez egy meglehetősen kényelmes hosting platform saját CLI-vel. Ingyenes, de ennél a tervnél a robot 30 perccel hibernált állapotba kerül, ha nem kap semmilyen kérést. Felébred, amikor egy kérés érkezik. Ez olyan gyorsan történik, hogy észre sem veszi (persze, ha nem indul újra az adatbázis-kapcsolat). Az ingyenes csomagot egy 5 MB adatbázis, 100 MB lemezterület, havi 2 TB adat és 1 dyno korlátozza. A dyno a futó alkalmazás. Rögtön leszögezem, hogy a telepítés okozta a nehézségeket, mivel még soha nem telepítettem az alkalmazásaimat. A telepítés során a Herokunak szüksége van egy Procfile nevű fájlra (kiterjesztés nélkül). A projektgyökérben hozzuk létre. Belül írjuk worker: sh target/bin/workerBot, ahol a workerBot a -ban megadott név pom.xml. Egy shA Maven Application Assembler Plugin (appassembler-maven-plugin) által generált szkript elindul. A szkript leírja, hogyan kell elindítani egy lefordított jar fájlt. Az indítandó osztály neve <mainClass>és között van megadva </mainClass>, míg a szkript neve <name>és </name>között van megadva 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>

A folyamat megkezdése előtt regisztrálnia kell a Heroku-n , és telepítenie kell a Git-et és a Heroku CLI-t is . Ha az alkalmazásnak adatbázisra van szüksége, ne felejtse el hozzáadni a szükséges adatbázist új alkalmazás létrehozásakor. Ezenkívül meg kell határoznia az adatbázis gazdagépét, felhasználónevét, jelszavát és portját, majd jeleznie kell ezeket az alkalmazásban. Ezután a telepítés előtt építse fel projektjét a Maven segítségével .

mvn clean install

Először a projektkönyvtárba lépünk, és inicializáljuk a tárat a paranccsal git init. Ezután hozzáadjuk a projektünket ehhez a tárolóhoz.

git add .

Ezután végrehajtjuk a változtatásokat

git commit -m "First commit in the project"

Ezután be kell jelentkeznie a herokuba. Írja be a következőt a parancssorba

heroku login

Adja meg a regisztráció során létrehozott hitelesítő adatokat. Ezt követően határozza meg a tárhely URL-jét a heroku-n. Ezt a beállításokban teheted meg. Aztán írunk

git remote add heroku [url]

Egy távoli heroku-tárat adunk hozzá a tárhoz. Ezután írunk

git push heroku master

Ezután várunk… ha az alkalmazás sikeresen üzembe helyeződik, hajtsa végre a következő parancsot

heroku ps:scale worker=1

És ennyi, az alkalmazás elindult és fut. Ha nem, nézze meg alaposan a naplókat. Valószínűleg az alkalmazás hibája okozta a sikertelenséget. Köszönöm, hogy ilyen hosszú cikket olvastál. Remélem valaki hasznosnak találja, és sok időt megspórol azokon a területeken, amelyek a fejlesztés során gondot okoztak.