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 :- Ina-update namin ang pangunahing sangay sa lokal na proyekto gamit ang kumbinasyon ng ctrl + t .
- Batay sa pangunahing sangay, lumikha kami ng:
- Magdagdag ng bot.
- Gumagawa kami ng bagong commit na may isang paglalarawan ng kung ano ang nagawa at itulak ito sa GitHub.
- 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.
- 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.
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.
- bot.username ;
- bot.token .
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.
GO TO FULL VERSION