Paglikha ng Telegram Bot sa Java: mula sa paglilihi hanggang sa pag-deploy

Kaya ano ang mga bot? Maaari mong basahin ang higit pa tungkol dito . Upang magsimula, kailangan mong suriin ang opisyal na dokumentasyon para sa library na ginamit upang bumuo ng mga Telegram bots (pagkatapos nito ay ang "API"). Ito ay matatagpuan dito . Lahat doon ay napaka-accessible at malinaw. Tila maaari lamang tayong magsulat ng code at magalak! Ngunit ito ay hindi gaanong simple. Pagkatapos gumugol ng maraming oras sa paghahanap, nakahanap ako ng mga kaalaman sa pagbuo ng bot, halimbawa, kung paano gumawa ng keyboard, humawak ng isangCallbackQuery, at iba pa. Ngunit, wala akong nakitang kumpletong, kumpletong gabay para sa pagbuo ng Java bot. Iyan ang nagtulak sa akin na isulat ang artikulong ito. Mayroong maraming mga website kung saan maaari kang lumikha ng iyong sariling madaling ma-deploy na bot. Ngunit ang katotohanan ay, karamihan sa mga bot na nilikha ay nagbibigay ng impormasyon ng sanggunian at iba pa. Ang aming bot ay isang ganap na web application. Maaari kang mag-bind ng database, magsagawa ng iba't ibang mga kahilingan sa API, mag-parse ng mga website, magsagawa ng mga kumplikadong kalkulasyon, at higit pa. Ang mga posibilidad ay limitado lamang sa pamamagitan ng iyong imahinasyon. Umaasa ako na ang nasa itaas ay nakatulong na linawin kung ano ang aking isusulat. Napakadaling magrehistro ng bot sa Telegram. Ang prosesong ito ay inilarawan nang detalyado sa dokumentasyong naka-link sa itaas. Para sa aming aplikasyon, kailangan mo lamang malaman ang pangalan ng bot at ang token na natatanggap mo kapag nirerehistro ang bot. Talaga, ang bot ay isang console-based na web application lamang. Walang front end, puro command processing lang. Kung gusto mong makabisadoHibernate o alamin kung paano i-parse ang JSON , kung gayon ito ang proyekto para sa iyo. Magsimula tayo sa pamamagitan ng pagdaragdag ng dependency sa pom.xml(Ipagpalagay ko na gumagamit ka ng Maven). Maaari mong gawin iyon tulad nito:

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

Pagkatapos ay lumikha ng isang Botklase na nagmamana ng TelegramLongPollingBotklase, at i-override ang mga pamamaraan nito:

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

At ngayon ang mga nilalaman ng mainpamamaraan:

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

Pagkatapos punan ang getBotUsername()at getBotToken()mga pamamaraan, simulan ang bot. Sa ngayon, nire-redirect lang nito sa amin ang anumang mga mensaheng ipinapadala namin dito, parang " salamin ". Ito ay gumagana tulad nito: kapag sinimulan mo ang application, magsisimula itong magpadala ng mga kahilingan sa Telegram server, isang beses bawat n segundo, sa sumusunod na URL: https://api.telegram.org/BotToken/getMe , kung saan ang BotToken ang token ng iyong bot . Bilang tugon, natatanggap nito ang JSON na naglalaman ng lahat ng mga mensahe. Ang bawat isa sa mga mensaheng ito ay pinoproseso ng library at ipinapasa sa OnUpdateReceived(Update update)pamamaraan bilang isangUpdatebagay. At iyon ang pinagtatrabahuhan namin. Dito nakasalalay ang kagandahan ng Telegram bots: maaari silang tumakbo sa anumang computer, kailangan lang ng pagsubok na simulan ang application, at hindi mo na kailangang i-deploy ito sa host pagkatapos ng bawat pagbabago. Ito ay napaka-maginhawa. Siyempre, maaari mong i-configure ang isang bot upang gumana gamit ang mga webhook. Makakahanap ka ng mga direksyon para doon sa Internet. Para sa pagiging simple, gagamitin namin ang LongPolling. Kung paano pinoproseso ang mga mensahe at kung ano ang ipapadala mo bilang tugon ay limitado lamang ng mga kakayahan ng wika at library. Ang lahat ng iba ay nasa iyo. Maaari kang gumawa ng bot na maghahanap ng mga video sa YouTube para sa iyo. Maaari kang gumawa ng bot na magpapadala sa iyo ng kung ano ang ipinapadala mo sa iyong sarili araw-araw, tulad ng isang time capsule mula noong isang taon. O maaari kang matutong magsama sa mga CRM system at gumawa ng mga bot para sa maliliit na negosyo—nalilimitahan ka lamang ng iyong imahinasyon. Moving on. Alam ng mga gumamit ng bot na maginhawang makipag-ugnayan sa kanila gamit ang mga command na nagsisimula sa /karakter na " ", halimbawa, /start. Ngunit mayroong isang mas maginhawang paraan: mga pindutan. Mayroong dalawang uri ng mga button: ang mga lumalabas sa ilalim ng input field ( ReplyKeyboardMarkup) at mga button na direktang nasa ibaba ng mensahe kung saan sila naka-link (InlineKeyboardMarkup). Maaari kang makakuha ng pangunahing pag-unawa sa kanila mula sa kanilang mga paglalarawan sa dokumentasyon.

ReplyKeyboardMarkup

Sa katotohanan, ito ay isang hanay ng mga array ng button: List<KeyboardRow <KeyboardButton>>. Narito ang sample na code na lumilikha ng keyboard:

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

Tinatawag namin ang pamamaraang ito sa sendMsg()pamamaraan, pagkatapos ipasa ito ng isang mensahe. Ganito kami mag-set up ng keyboard para sa mensaheng iyon. Kapag ipinadala namin ang mensaheng ito sa user, makikita niya ang text ng aming mensahe at 2 button na nagsasabing "Hi" at "Help" , isa sa ilalim ng isa. Kapag na-click ang isa sa mga button na ito, padadalhan ang bot ng mensahe na naglalaman ng text ng button. Kaya, kung iki-click ng kliyente ang "Tulong" , makakatanggap ang bot ng mensahe na may "Tulong". Sa bot, mukhang ang kliyente mismo ang sumulat ng "Tulong" at nagpadala ng text sa bot. At pagkatapos ay iproseso mo ang mga mensahe.

InlineKeyboardMarkup

Isa rin itong hanay ng mga arrays. Ito ay katulad ng nakaraang Markup, ngunit ang lohika ay gumagana ng kaunti naiiba dito. Ang ganitong uri ng keyboard ay naka-attach sa isang partikular na mensahe at umiiral lamang para dito. Narito ang isang paraan para sa pag-set up ng isang inline na keyboard:

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

Lumikha ng isang Listsa loob ng List, at idagdag ang inline na button sa unang hilera. Ang button na ito ay maaaring maglaman ng isang URL, isang link sa isang channel, o isang CallbackQuery, na isusulat ko sa ibang pagkakataon. Dito namin itinatakda ang text ng aming button, na kung ano ang makikita ng user, at pagkatapos ay itinakda namin ang data na ipapadala sa bot. Sa aming halimbawa, nakikita ng user ang "Hi", at kapag pinindot ang button ang numero 17 ay ipapadala sa bot. Ito ang ating CallbackQuery. Ilang salita patungkol sa CallbackQuery. Upang makuha ang data na ito mula sa Updateobject, kailangan mong isagawa ang update.getCallbackQuery(). Ang pamamaraang ito ay nagbabalik ng isang CallbackQuery, kung saan maaari mong ma-access ang data na ipinasa sa bot. Huwag subukang kunin ang data na ito sa pamamagitan ng update.getMessage().getText()pamamaraan—makakakuha ka ng 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());
        }
    }

Kung mayroong mensahe, ipinapadala namin ito sa isang bagong thread para sa pagproseso; kung mayroong CallbackQuery, ipinapadala namin sa naaangkop na thread para sa pagproseso. Maaari kang magpadala ng tugon sa isang CallbackQuery. Ang bawat bagay sa Telegram ay may sariling id. Upang magpadala ng tugon sa isang partikular na CallbackQuery, kailangan mo lang malaman ang id nito, na nakukuha namin mula sa kaukulang bagay. Upang magpadala ng tugon, tinatawag namin ang paraang ito:

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

MAHALAGA:Ang teksto sa isang tugon sa isang CallbackQueryay dapat na hindi hihigit sa 200 mga character! Pagkatapos magpadala ng ganoong tugon, makakakita ang kliyente ng pop-up window na naglalaman ng mensahe. Maaaring mawala ang window na ito ilang segundo pagkatapos itong lumitaw, o maaari itong magpatuloy hanggang sa pinindot ng user ang OK. Upang lumipat ng mga mode, tinatawag namin ang answer.setShowAlert(true)pamamaraan. Kung pumasa ka truesa pamamaraan, magpapatuloy ang window hanggang sa pinindot ang OK. Kung pumasa ka ng false, mawawala ito pagkatapos ng 5 segundo. Ito ang lahat ng mga pangunahing tampok ng Telegram Bot library . Kung gusto mo, maaari kang matuto ng mga bagay tulad ng kung paano magpadala ng multimedia, geolocation, atbp. Magpatuloy tayo sa pag-deploy ng aming bot sa isang hosting platform. Para sa aking proyekto, pinili ko si Heroku. Sa tingin ko ito ay isang medyo maginhawang platform sa pagho-host na may sarili nitong CLI. Ito ay libre, ngunit sa planong ito ang iyong bot ay hibernate pagkatapos ng 30 minuto ng walang natanggap na mga kahilingan. Magigising ito kapag may natanggap na kahilingan. Nangyayari ito nang napakabilis, hindi mo mapapansin (maliban kung, siyempre, ang koneksyon sa database ay hindi nag-restart). Ang libreng plano ay limitado ng 5MB database, 100MB disk space, 2TB data bawat buwan, at 1 dyno. Ang dyno ay ang iyong tumatakbong application. Sasabihin ko kaagad na ang pag-deploy ang nagdulot sa akin ng mga paghihirap, dahil hindi ko pa na-deploy ang aking mga aplikasyon noon. Sa panahon ng deployment, nangangailangan si Heroku ng file na pinangalanang Procfile (nang walang extension). Ginagawa namin ito sa root ng proyekto. Sa loob, isinusulat namin ang worker: sh target/bin/workerBot, kung saan ang workerBot ay ang pangalan na tinukoy sa pom.xml. Isang shilulunsad ang script, na nabuo ng Maven Application Assembler Plugin (appassembler-maven-plugin). Inilalarawan ng script kung paano maglunsad ng pinagsama-samang jar file. Ang pangalan ng klase na ilulunsad ay tinukoy sa pagitan <mainClass>ng at </mainClass>, habang ang pangalan ng script ay ibinibigay sa pagitan ng <name>at </name>sa 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>

Bago simulan ang prosesong ito, dapat kang magparehistro sa Heroku , at i-install ang parehong Git at ang Heroku CLI . Kung ang iyong application ay nangangailangan ng isang database, pagkatapos ay huwag kalimutang idagdag ang kinakailangang database kapag lumikha ka ng isang bagong application. Dagdag pa, kailangan mong tukuyin ang host, username, password at port para sa iyong database, at pagkatapos ay ipahiwatig ang mga ito sa iyong aplikasyon. Susunod, bago i-deploy, buuin ang iyong proyekto gamit ang Maven .

mvn clean install

Una, pumunta kami sa aming direktoryo ng proyekto at simulan ang repositoryo gamit ang command git init. Pagkatapos ay idinagdag namin ang aming proyekto sa repositoryong ito.

git add .

Pagkatapos ay ginagawa namin ang mga pagbabago

git commit -m "First commit in the project"

Susunod, kailangan mong mag-sign in sa heroku. Isulat ang sumusunod sa command line

heroku login

Ilagay ang mga kredensyal na iyong ginawa sa panahon ng pagpaparehistro. Pagkatapos nito, tukuyin ang URL ng iyong repository sa heroku. Ginagawa mo ito sa mga setting. Tapos nagsusulat kami

git remote add heroku [url]

Ang isang malayong heroku repository ay idinagdag para sa iyong repository. Sunod naming isusulat

git push heroku master

Pagkatapos ay maghihintay kami... kung matagumpay na na-deploy ang application, isagawa ang sumusunod na command

heroku ps:scale worker=1

At iyon lang, gumagana na ang iyong aplikasyon. Kung hindi, tingnang mabuti ang mga log. Malamang, isang error sa iyong application ang naging dahilan upang mabigo ito. Salamat sa pagbabasa ng napakahabang artikulo. Umaasa ako na ang isang tao ay makahanap ng kapaki-pakinabang at na ito ay makatipid sa iyo ng maraming oras sa mga lugar na nagbigay sa akin ng problema sa panahon ng pag-unlad.