Pagdaragdag ng telegram bot sa proyekto - "Java project from A to Z"

Pagbati, mahal kong mga kaibigan. Oo, oo, eksakto mga kaibigan. Naging pamilyar na ako sa serye ng mga artikulong ito na ang mga taong regular na nagsusulat ng kanilang pasasalamat sa mga komento at/o nagpapakita na nabasa at naunawaan nila ang materyal ay naging malapit na. Ikaw at ako ay gumagalaw mula sa dalawang direksyon patungo sa iisang layunin. Gusto mong intindihin, pero gusto kong ipaliwanag. At mayroon kaming parehong panghuling layunin - isang nakasulat na aplikasyon na naiintindihan mo mula simula hanggang matapos. Maaaring narinig mo na ang tungkol sa marami sa kung ano ang ilalarawan ko sa artikulong ito. Sa palagay ko ay hindi ako magsasabi sa iyo ng anumang bago at hindi pangkaraniwang bagay (ngunit sa loob ng balangkas ng proyekto ay kailangang malaman/ulitin ito). Sa tagsibol nagsulat ako ng isang bot para sa aking sarili, kaya aasa kami sa "mga pattern" nito.

Nagsusulat kami ng JRTB-2

Gagawin namin ang parehong tulad ng ginawa namin sa artikulo na may gawain JRTB-0 :

1. Ina-update namin ang pangunahing sangay sa lokal na proyekto gamit ang kumbinasyon ng ctrl + t .
2. Batay sa pangunahing sangay, lumikha kami ng:
3. Magdagdag ng bot.
4. Gumagawa kami ng bagong commit na may isang paglalarawan ng kung ano ang nagawa at itulak ito sa GitHub.
5. Gumawa ng pull request para sa pangunahing sangay at suriin itong muli. Hinihintay namin na dumaan ang build (mga pagkilos ng github), pagsamahin ito sa pangunahing sangay.
6. Isara ang kaukulang gawain.

Ano ang isang telegram bot

Kami, mga developer, ay maiisip na nagtatrabaho sa isang telegram bot na tulad nito: ginagamit namin ang kanilang kliyente upang makipagtulungan sa kanila. Mayroon kaming handa na library para sa trabaho. Mayroong isang hanay ng mga aksyon pagkatapos kung saan malalaman ng telegram bot na nauugnay ito sa aming programa. At nasa loob na ng programa ay matututunan natin kung paano tumanggap ng mga liham, utos at kahit papaano ay iproseso ang mga ito. Mayroong isang bagay bilang isang utos sa mga bot ng telegrama : nagsisimula ito sa isang slash na "/". Pagkatapos nito, agad naming isinusulat ang salita nang magkasama, at ito ay maituturing na isang utos. Halimbawa, mayroong dalawang utos na dapat malaman ng lahat:

• /start — magsimulang magtrabaho kasama ang bot;
• /stop - tapusin ang trabaho sa bot.

Kami na mismo ang gagawa ng iba. Hayaan akong magpareserba kaagad: gagawin namin kung ano talaga at sa paraang natutunan ko. At kapag nagtatrabaho sa isang bot, sigurado ako na magiging posible na gumawa ng mas mahusay. At kung may gustong gawin ito, magiging masaya lang ako at susuportahan ko ang pagsisikap na ito sa lahat ng posibleng paraan. Sa pamamagitan ng paraan, ang pinakaunang bagay na magiging cool ay kung may nagpaliwanag sa akin kung paano i-program ang paglalarawan ng mga utos sa pamamagitan ng code, at hindi sa pamamagitan ng mga setting ng bot sa telegrama. Hindi ko ito natutunan. Mayroon kaming ilang artikulo sa aming mapagkukunan na naglalarawan kung paano gumawa ng pangunahing bot: ngayon ay gagawa kami ng katulad na bagay. Kung mayroon ka pang mga katanungan, inirerekumenda kong suriin ang artikulong ito .

Gumawa ng bot gamit ang BotFather

Upang ikonekta ang isang bot, kailangan mo munang gawin ito. May diskarte ang Telegram - paglikha ng bot na may sariling natatanging pangalan. Sasamahan din ito ng isang token (isang malaking string na gumagana tulad ng isang password). Nakagawa na ako ng bot para sa JavaRush - @javarush_community_bot . Walang laman pa rin ang bot na ito at wala siyang magagawa. Ang pangunahing bagay ay dapat mayroong _bot sa dulo ng pangalan . Para ipakita kung paano ito gagawin, gagawa ako ng bot kung saan susuriin namin ang aming functionality. Sa mga tuntunin ng mga tunay na proyekto, ito ay magiging isang pagsubok na kapaligiran. At ang aming pangunahing isa ay ang kapaligiran ng prod (prod - produksyon, iyon ay, ang tunay na kapaligiran kung saan isasagawa ang proyekto). Siyempre, posibleng magdagdag ng isa pang kapaligiran - isang kapaligiran ng sandbox: isang karaniwang sandbox, mas nababago at naa-access sa lahat ng mga kalahok sa pag-unlad. Ngunit ito ay magpapalubha lamang sa sitwasyon sa yugto ng paglikha ng proyekto. Sa ngayon, gumawa tayo ng dalawa pang bot para sa pagsubok at para sa sandbox environment. Ang unang hakbang ay lumikha (magrehistro) ng isang bot sa Telegram mismo. Kailangan nating hanapin ang bot: @BotFather at isulat ang utos dito: /newbot Susunod, hihilingin sa amin na bigyan ng pangalan ang bot na ito. Dahil ito ay isang bot para sa mga gawain sa pagsubok, magiging angkop ang pangalan nito: [TEST] JavarushBot Ngayon ay oras na para magbigay ng isang natatanging pangalan kung saan palagi itong mahahanap - ang username nito: test_javarush_community Gaya ng sinabi ko sa itaas, kailangan mong idagdag ang _bot suffix para sa username, kaya sumulat kami muli: test_javarush_community_bot At iyon na! Nagawa na ang bot. Ngayon, gamit ang username at token, maaari itong ikonekta sa aming proyekto. Siyempre, para sa maayos na pagpapatakbo ng test server, hindi ko ipapakita ang token (talagang password para ma-access ang bot) ng bot na ito para sa pampublikong pagtingin.

Ikinonekta namin ang bot sa proyekto

Hindi namin isasama ang library gaya ng dati, ngunit agad naming sasamantalahin ang aming skeleton - SpringBoot. Mayroon siyang isang bagay bilang Starter. Sa pamamagitan ng pagsasama ng library, magagamit namin ito upang ipaalam sa SpringBoot na gusto naming i-configure nang tama ang proyekto. Kung pupunta tayo sa karaniwang ruta, na inilalarawan sa maraming lugar, kakailanganin nating gumawa ng configuration sa isang lugar na magkakaroon ng ganito:

ApiContextInitializer.init();
TelegramBotsApi telegramBotsApi = new TelegramBotsApi();
try {
  telegramBotsApi.registerBot(Bot.getBot());
} catch (TelegramApiRequestException e) {
  e.printStackTrace();
}

Dito nilikha ang isang bagay kung saan maaari kang magtatag ng isang koneksyon sa bot. Sa aming kaso, gagawin ng starter na gusto naming ikonekta ang lahat para sa amin sa isang lugar "sa ilalim ng hood" (ito ay pagsasalin din ng isang madalas na ginagamit na parirala sa IT - sa ilalim ng hood). Narito ang isang link sa starter na ito . Makikita mo kaagad mula sa README.md file kung ano ito, bakit at paano ito gamitin. Upang ikonekta ito, kailangan mo lamang idagdag ang dependency na ito sa memorya. Iyon lang :) Narito ang kinakailangang dependency:

<dependency>
        <groupId>org.telegram</groupId>
        <artifactId>telegrambots-spring-boot-starter</artifactId>
        <version>5.0.1</version>
    </dependency>

Idinaragdag natin ito sa ating alaala. Ini-install namin ang bersyon tulad ng inaasahan at ina-update ang proyekto ng Maven. Batay sa paglalarawan, kailangan lang naming lumikha ng bagong klase, magmana mula sa TelegramLongPollingBot at idagdag ang klase na ito sa Konteksto ng Application ng aming SpringBoot. Ang Konteksto ng Application ay ang lugar kung saan iniimbak ang mga nilikhang bagay para sa pagpapatakbo ng proyekto. Upang magdagdag ng klase, kailangan mong gumamit ng isa sa mga anotasyon: @Component, @Service, @Repository, @Controller. O ang @Bean annotation kung ginawa sa pamamagitan ng isang method sa isang configuration class (iyon ay, sa isang class na minarkahan ng Configuration annotation). Naiintindihan ko na ang lahat ng ito ay maaaring mukhang hindi pa rin maintindihan. Ngunit kapag sinimulan mong malaman ito, makikita mo na walang kumplikado doon. Upang mabilis na maunawaan ang Spring Boot, inirerekomenda ko ang isang cool na libro - Spring In Action 5th edition. Kung may pagnanais, maaari akong magsulat ng isang serye ng mga artikulo batay sa aklat na ito. Balik tayo. Sa package na naglalaman ng JavarushTelegramBotApplication, ginagawa namin ang bot package , na maglalaman ng aming telegram bot. Ang pangalan nito ay JavaRushTelegramBot :

package com.github.javarushcommunity.jrtb.bot;

import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Telegrambot for Javarush Community from Javarush community.
*/
@Component
public class JavarushTelegramBot extends TelegramLongPollingBot {

   @Override
   public void onUpdateReceived(Update update) {

   }

   @Override
   public String getBotUsername() {
       return null;
   }

   @Override
   public String getBotToken() {
       return null;
   }
}

Ang klase na ito ay abstract at tatlong pamamaraan ang kailangang ipatupad. Pag-usapan natin ang mga ito nang mas detalyado:

• onUpdateReceived(Update update) - ito ang entry point kung saan darating ang mga mensahe mula sa mga user. Lahat ng bagong lohika ay magmumula rito;
• getBotUsername() - dito kailangan mong idagdag ang username ng aming bot kung saan kami ikokonekta;
• getBotToken() - at ito, nang naaayon, ay ang bot token.

Sa pangkalahatan, ito ay tulad ng isang pag-login at password para sa isang site. Hindi namin tahasang isusulat ang halagang ito sa ngayon. Ito ay tinatawag na "hardcoding" (iyon ay, nagbubuklod ng ilang partikular na halaga - gaya ng dati, ang pagsubaybay sa papel mula sa English hard code). Hindi mo dapat ginawa iyon. Pupunta tayo sa kabilang paraan - isusulat natin ang data na ito sa klase ng application.properties at babasahin ito mula rito. Bakit kailangan ito? Pagkatapos, upang kapag nagsimula ang application, maaari naming itakda ang mga halagang ito sa labas. Ito ay nababaluktot, ito ay tama. Pumunta sa file na src/main/resources/application.properties. Doon ay makakabuo tayo ng mga pangalan para sa mga variable na ito. Ang mga file na may extension na .properties ay binabasa bilang isang istraktura ng key-value na pinaghihiwalay ng "="", ang bawat pares ay isang hiwalay na linya. Kaya naisip ko ang mga variable na ito:

• bot.username ;
• bot.token .

Ito ang magiging hitsura nito: May magandang anotasyon ang SpringBoot - @Value. Kung ginamit nang tama, kukunin nito ang mga halaga mula sa application.properties file. Ina-update namin ang proyekto gamit ito:

package com.github.javarushcommunity.jrtb.bot;

import org.springframework.beans.factory.annotation.Value;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Telegram bot for Javarush Community from Javarush community.
*/
@Component
public class JavarushTelegramBot extends TelegramLongPollingBot {

   @Value("${bot.username}")
   private String username;

   @Value("${bot.token}")
   private String token;

   @Override
   public void onUpdateReceived(Update update) {

   }

   @Override
   public String getBotUsername() {
       return username;
   }

   @Override
   public String getBotToken() {
       return token;
   }
}

Makikita na ipinasa namin ang halaga ng variable sa anotasyon. At kapag ginawa ng SpringBoot ang aming bot object, kukunin ang mga value mula sa mga property (muli, tracing paper mula sa English - properties). Malapit na tayo. Kailangan mong gawin ang bot na sumagot ng isang bagay. Samakatuwid, i-update natin ang onUpdateReceived method . Kailangan nating kunin ang mensaheng dumating sa bot at ipasa ito pabalik. Sa ganitong paraan malalaman natin na gumagana ang bot. Upang gawin ito, halos at mabilis naming isusulat kung ano ang kailangan:

@Override
public void onUpdateReceived(Update update) {
   if(update.hasMessage() && update.getMessage().hasText()) {
       String message = update.getMessage().getText().trim();
       String chatId = update.getMessage().getChatId().toString();

       SendMessage sm = new SendMessage();
       sm.setChatId(chatId);
       sm.setText(message);

       try {
           execute(sm);
       } catch (TelegramApiException e) {
           //todo add logging to the project.
           e.printStackTrace();
       }
   }
}

Ang lahat dito ay napakasimple: sinusuri namin kung talagang umiiral ang mensahe, kaya kinuha namin ang mismong mensahe ( mensahe ) at ang chat ID ( chatId ) kung saan nagaganap ang pagsusulatan. Susunod, lumikha kami ng isang bagay para sa pagpapadala ng isang mensahe SendMessage , ipasa ang mensahe mismo at ang chat ID dito - iyon ay, kung ano ang ipapadala sa bot at kung saan. Mayroon na tayong sapat na ganito. Susunod, pinapatakbo namin ang pangunahing pamamaraan sa klase ng JavarushTelegramBotApplication at hanapin ang aming bot sa Telegram: Mula sa mga log nakita namin na nagsimula na ang bot. Kaya, oras na para pumunta sa Telegram at sumulat sa bot: Nag-click kami sa simula at agad naming natatanggap ang sagot: Sumulat pa tayo ng iba pang crap para suriin: At iyon lang, sa puntong ito masasabi nating natapos na ang ating JRTB-2 na gawain . Hindi ka pa talaga makakasulat ng anumang mga pagsubok dito, kaya iiwan namin ang lahat ng ganito. Susunod na kailangan mong gumawa ng bagong commit: Bigyang-pansin ang pangalan ng commit: muli kong iginuhit ang iyong pansin dito. Ang isang commit ay unang naglalaman ng pangalan ng gawain, at pagkatapos ay isang mas detalyadong paglalarawan ng kung ano ang nagawa. I-click ang Commit at Push... at kumpirmahin sa pamamagitan ng pag-click muli sa Push : Pumunta sa aming proyekto . Tulad ng dati, nakita na ng GitHub ang bagong sangay at nag-aalok na gumawa ng pull request para sa main. Hindi namin nilalabanan at nilikha ito: Gaya ng dati, nakapili na kami ng label, isang proyekto at itinalaga ito sa akin. Panghuli, i-click ang Lumikha ng Pull Request. Maghintay tayo ng kaunti habang nagpapatuloy ang build - at iyon lang, handa na ang pull request para sa pagsasama:

Pag-bersyon

Kahit papaano ay napalampas ko ang punto na kailangan nating gumawa ng bersyon. Para magawa ito, gagawa kami ng ilan pang pagbabago sa aming sangay. Bumalik kami sa IDEA at tingnan ang bersyon ng proyekto sa memorya: Ang bersyon ay 0.0.1-SNAPSHOT . Ito ang bersyon ng tungkulin. At magsisimula kami sa pamamagitan ng pag-update ng bersyon ng proyekto sa bawat bagong nalutas na problema. Hanggang sa maabot natin ang MVP, ang bersyon ay darating na may suffix -SNAPSHOT. Ano ang magiging scheme ng bersyon? XYZ-SNAPSHOT Saan:

• X - pangunahing pag-update ng bersyon, kadalasang naglalaman ng mga problema sa pabalik na pagkakatugma sa nakaraang bersyon;
• Y - hindi masyadong malaking pagbabago, ganap na katugma sa nakaraang bersyon;
• Ang Z ay isang counter ng mga depekto na aming nakita at naayos.

Batay dito, magkakaroon tayo ng unang bersyon - 0.1.0-SNAPSHOT - ibig sabihin, wala pa tayong major updates, kaunti lang sa lahat, at hindi pa tayo nakakaabot ng MVP, kaya may suffix -SNAPSHOT . Baguhin natin ito sa memorya: Pumunta sa RELEASE_NOTES file, kung saan ilalarawan namin ang mga pagbabago sa proyekto sa bawat bagong bersyon: Ang aming unang entry. Ngayon, sa bawat kasunod na pag-update ng bersyon, ilalarawan namin dito kung ano ang eksaktong nangyari. Ginagawa namin ang kasong ito, sumulat ng paglalarawan: JRTB-2: na-update na bersyon ng proyekto at idinagdag sa RELEASE_NOTES Lahat ay eksaktong kapareho ng dati. Naghihintay kami na pumasa ang build at maaari naming pagsamahin ang aming mga pagbabago. Dito lamang ito ay magiging isang maliit na pagkakaiba. Gusto kong tiyakin na ang bawat gawain sa pangunahing sangay ay isang hiwalay na commit, kaya hindi gagana para sa amin ang simpleng pag-push ng isang hiling na pull ng Merge . Ang Git ay may opsyon na git squash, na kinokolekta ang lahat ng mga commit sa isa at pinagsasama ang mga ito. Pinipili namin ang opsyong ito: I-click ang Squash at Merge, at inaalok kami na i-edit ang mensahe, na magiging sa huli: Napaka-maginhawa at pinakamahalaga, kung ano ang hinihiling. Siyanga pala, wala pa akong nakikitang ganoong feature sa bitbucket =/ Kumpirmahin ang pagsasanib. Ang natitira na lang ay baguhin ang gawain sa katayuang Tapos na sa aming board, magsulat ng komento na may link sa pull request at isara ito: Ganito na ngayon ang hitsura ng aming board:

Konklusyon

Ngayon gumawa kami ng isang telegram bot nang sunud-sunod at ipinatupad ito sa aming proyekto sa SpringBoot. Gumagana ang bot at nagbibigay ng mga sagot. Agad kaming nag-access sa data ng bot sa pamamagitan ng mga property. Marami pang darating: gagawa kami ng isang malaking piraso - gumanap ng JRTB-3 - pagdaragdag ng Command Pattern para sa aming proyekto. Oh, isa pang bagay... Sinabi ko sa iyo na hindi ko i-publish ang token para hindi ito magamit. Ngunit dahil isinusulat ko ang artikulo nang mas malapit sa hatinggabi at pagkatapos ng trabaho, lumabas na nag-post ako ng wastong token sa repositoryo, at sinabi sa akin ng GitGuardian ang tungkol dito sa isang liham: Salamat sa kanila para dito! Ano ang dapat gawin ngayon? Hindi na posibleng tanggalin ito sa git, dahil kahit na mag-upload ako ng bagong commit nang walang token na ito, mananatili pa rin ito sa luma. Ngunit ayaw kong tanggalin at i-roll back ang commit. Kaya pumunta ako at na-deactivate ang token mula sa nabanggit na BotFather. Ngayon nandoon na ang token, ngunit hindi na ito wasto. Mag-subscribe sa aking GitHub account upang makita ang lahat ng code para dito bago i-publish ang artikulo. Salamat sa lahat ng nagbabasa, see you soon.

Ang isang listahan ng lahat ng mga materyales sa serye ay nasa simula ng artikulong ito.