הוספת בוט טלגרם לפרויקט - "פרויקט ג'אווה מא' עד ת'"

שלום חברים יקרים שלי. כן, כן, בדיוק חברים. כבר כל כך הכרתי את סדרת המאמרים הזו, שאותם אנשים שכותבים באופן קבוע את הכרת התודה שלהם בתגובות ו/או מראים שהם קראו והבינו את החומר כבר התקרבו. אתה ואני נעים משני כיוונים לעבר אותה מטרה. אתה רוצה להבין, אבל אני רוצה להסביר. ולנו אותה מטרה סופית - בקשה כתובה שמובנת לך מתחילתה ועד סופה. אולי כבר שמעתם על הרבה ממה שאתאר במאמר זה. אני לא חושב שאספר לכם משהו חדש ויוצא דופן (אבל במסגרת הפרויקט יש צורך לדעת/לחזור על כך). באביב כתבתי לעצמי בוט, אז נסתמך על ה"דפוסים" שלו.

אנו כותבים JRTB-2

נעשה את אותו הדבר כפי שעשינו במאמר עם המשימה JRTB-0 :

1. אנו מעדכנים את הסניף הראשי בפרויקט המקומי באמצעות השילוב ctrl + t .
2. בהתבסס על הסניף הראשי, אנו יוצרים:
3. הוסף בוט.
4. אנו יוצרים commit חדש עם תיאור של מה שנעשה ודוחפים אותו ל-GitHub.
5. צור בקשת משיכה עבור הסניף הראשי ובדוק אותה שוב. אנחנו מחכים שהבנייה תעבור (פעולות github), תמזג אותו לסניף הראשי.
6. סגור את המשימה המתאימה.

מהו בוט טלגרם

אנחנו, מפתחים, יכולים לדמיין עבודה עם בוט טלגרם כמו זה: אנחנו משתמשים בלקוח שלהם כדי לעבוד איתם. יש לנו ספרייה מוכנה לעבודה. יש קבוצה של פעולות שלאחריהן בוט הטלגרם יידע שהוא משויך לתוכנית שלנו. וכבר בתוך התוכנית נלמד איך לקבל מכתבים, פקודות ואיכשהו לעבד אותם. יש דבר כזה פקודה בבוטים של טלגרם : היא מתחילה עם קו נטוי "/". אחריו נכתוב מיד את המילה ביחד, וזה ייחשב לפקודה. לדוגמה, ישנן שתי פקודות שכולם צריכים לדעת:

• /start — התחל לעבוד עם הבוט;
• /stop - סיום עבודה עם הבוט.

את השאר נעשה בעצמנו. הרשו לי להזמין מקום מיד: נעשה בדיוק מה ובדרך שלמדתי. וכשעובדים עם בוט, אני בטוח שאפשר יהיה לעשות יותר טוב. ואם מישהו רוצה לעשות את זה, אני רק אשמח ואתמוך בעשייה הזו בכל דרך אפשרית. אגב, הדבר הראשון שיהיה מגניב זה אם מישהו יסביר לי איך לתכנת את תיאור הפקודות דרך קוד, ולא דרך הגדרות הבוט בטלגרם. לא למדתי את זה. יש לנו כמה מאמרים על המשאב שלנו שמתארים איך ליצור בוט בסיסי: היום נעשה משהו דומה. אם יש לך שאלות נוספות, אני ממליץ לדפדף במאמר זה .

צור בוט עם BotFather

כדי לחבר בוט, תחילה עליך ליצור אותו. לטלגרם יש גישה - יצירת בוט עם שם ייחודי משלו. זה ילווה גם באסימון (מחרוזת גדולה שעובדת כמו סיסמה). כבר יצרתי בוט עבור JavaRush - @javarush_community_bot . הבוט הזה עדיין ריק ואינו יכול לעשות דבר. העיקר שיהיה _bot בסוף השם . כדי להראות איך עושים זאת, אצור בוט שעליו נבדוק את הפונקציונליות שלנו. במונחים של פרויקטים אמיתיים, זו תהיה סביבת מבחן. והעיקרית שלנו תהיה סביבת הפרוד (פרוד - ייצור, כלומר הסביבה האמיתית עליה יבוצע הפרויקט). כמובן שניתן יהיה להוסיף סביבה נוספת - סביבת ארגז חול: ארגז חול משותף, משתנה ונגיש יותר לכל משתתפי הפיתוח. אבל זה רק יסבך את המצב בשלב יצירת הפרויקט. לעת עתה, בואו ניצור שני בוטים נוספים לבדיקה ולסביבת ארגז חול. הצעד הראשון הוא ליצור (לרשום) בוט בטלגרם עצמו. עלינו למצוא את הבוט: @BotFather ולכתוב לו את הפקודה: /newbot לאחר מכן, אנו מתבקשים לתת שם לבוט הזה. מכיוון שמדובר בבוט למשימות בדיקה, השם שלו יתאים: [TEST] JavarushBot עכשיו הגיע הזמן לתת שם ייחודי שלפיו תמיד ניתן למצוא אותו - שם המשתמש שלו: test_javarush_community כפי שאמרתי למעלה, אתה צריך להוסיף את ה-_bot סיומת לשם משתמש, אז נכתוב שוב: test_javarush_community_bot וזהו! הבוט נוצר. כעת, באמצעות שם המשתמש והאסימון, ניתן לחבר אותו לפרויקט שלנו. כמובן שלמען תפעול חלק של שרת הבדיקה, לא אציג את האסימון (בעצם סיסמה לגישה לבוט) של הבוט הזה לצפייה ציבורית.

אנחנו מחברים את הבוט לפרויקט

לא נכלול את הספרייה כרגיל, אלא מיד ננצל את השלד שלנו - SpringBoot. יש לו דבר כזה סטרטר. על ידי הכללת הספרייה, נוכל להשתמש בה כדי ליידע את SpringBoot שאנו רוצים להגדיר את הפרויקט בצורה נכונה. אם היינו הולכים בדרך הרגילה, המתוארת במקומות רבים, היינו צריכים ליצור תצורה איפשהו שתהיה לה משהו כזה:

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

כאן נוצר אובייקט שאיתו ניתן ליצור קשר עם הבוט. במקרה שלנו, המתנע שאנו רוצים לחבר יעשה עבורנו הכל איפשהו "מתחת למכסה המנוע" (זהו גם תרגום של ביטוי בשימוש תכוף ב-IT - מתחת למכסה המנוע). הנה קישור למתחיל הזה . אתה יכול לראות מיד מהקובץ README.md מה זה, למה ואיך להשתמש בו. כדי לחבר אותו, אתה רק צריך להוסיף את התלות הזו לזיכרון. זה הכל :) הנה התלות הנדרשת:

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

אנחנו מוסיפים את זה לזיכרון שלנו. אנו מתקינים את הגרסה כצפוי ומעדכנים את פרויקט Maven. בהתבסס על התיאור, אנחנו רק צריכים ליצור מחלקה חדשה, לרשת מ- TelegramLongPollingBot ולהוסיף את המחלקה הזו להקשר היישום של SpringBoot שלנו. יישום הקשר הוא המקום שבו מאוחסנים האובייקטים שנוצרו להפעלת הפרויקט. כדי להוסיף מחלקה, עליך להשתמש באחת ההערות: @Component, @Service, @Repository, @Controller. או הערת @Bean אם נוצרה באמצעות מתודה במחלקת תצורה (כלומר, במחלקה שמסומנת עם הערת Configuration). אני מבין שכל זה אולי עדיין נראה בלתי מובן. אבל כשתתחיל להבין את זה, תראה שאין שם שום דבר מסובך. כדי להבין במהירות את Spring Boot, אני ממליץ על ספר מגניב - Spring In Action 5th Edition. אם יש רצון, אוכל לכתוב סדרת מאמרים המבוססים על הספר הזה. בוא נחזור. בחבילה המכילה JavarushTelegramBotApplication, אנו יוצרים את חבילת הבוט , שתכיל את בוט הטלגרם שלנו. השם שלו יהיה 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;
   }
}

מחלקה זו הייתה מופשטת והיו צריכים ליישם שלוש שיטות. בואו נדבר עליהם ביתר פירוט:

• onUpdateReceived(עדכון עדכון) - זוהי נקודת הכניסה אליה יגיעו הודעות ממשתמשים. כל היגיון חדש יבוא מכאן;
• getBotUsername() - כאן צריך להוסיף את שם המשתמש של הבוט שלנו אליו נתחבר;
• getBotToken() - וזה, בהתאם, הוא אסימון הבוט.

בעיקרו של דבר זה כמו כניסה וסיסמה לאתר. לא נכתוב את הערך הזה במפורש לעת עתה. זה נקרא "קוד קשיח" (כלומר, כריכת ערך מסוים - כרגיל, נייר מעקב מקוד קשיח אנגלי). אתה לא צריך לעשות את זה. נלך בדרך אחרת - נכתוב את הנתונים האלה למחלקה application.properties ונקרא אותם מכאן. למה זה נחוץ? לאחר מכן, כדי שכאשר האפליקציה מתחילה, נוכל להגדיר את הערכים הללו חיצונית. זה גמיש, זה נכון. עבור אל הקובץ src/main/resources/application.properties. שם נמציא שמות למשתנים הללו. קבצים עם סיומת .properties נקראים כמבנה מפתח-ערך מופרד על ידי "=", כל זוג הוא שורה נפרדת. אז הגעתי למשתנים האלה:

• bot.username ;
• bot.token .

כך זה ייראה: ל-SpringBoot יש הערה נהדרת - @Value. אם נעשה בו שימוש נכון, הוא ימשוך את הערכים מקובץ application.properties. אנו מעדכנים את הפרויקט בכך:

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

ניתן לראות שהעברנו את ערך המשתנה לביאור. וכאשר SpringBoot יוצר את אובייקט הבוט שלנו, הערכים יילקחו מהמאפיינים (שוב, נייר מעקב מאנגלית - מאפיינים). אנחנו כמעט שם. אתה צריך לגרום לבוט לענות על משהו. לכן, בואו נעדכן את השיטה onUpdateReceived . עלינו לאחזר את ההודעה שהגיעה לבוט ולהעביר אותה בחזרה. כך נדע שהבוט עובד. לשם כך, נכתוב בערך ובמהירות את מה שצריך:

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

הכל כאן פשוט ביותר: אנחנו בודקים שההודעה באמת קיימת, אז אנחנו מחלצים את ההודעה עצמה ( הודעה ) ואת מזהה הצ'אט ( chatId ) שבו מתבצעת ההתכתבות. לאחר מכן, אנו יוצרים אובייקט לשליחת הודעה SendMessage , מעבירים אליה את ההודעה עצמה ואת מזהה הצ'אט - כלומר מה לשלוח לבוט ולאן. יש לנו כבר מספיק מזה. לאחר מכן, אנו מריצים את השיטה הראשית במחלקה JavarushTelegramBotApplication ומחפשים את הבוט שלנו בטלגרם: מהלוגים אנו רואים שהבוט התחיל. אז, זה הזמן ללכת לטלגרם ולכתוב לבוט: אנחנו לוחצים על התחל ומיד מקבלים תשובה: בואו נכתוב עוד שטויות לבדוק: וזהו, בשלב זה אנחנו יכולים לומר שמשימת ה-JRTB-2 שלנו הושלמה . אתה לא באמת יכול לכתוב כאן מבחנים עדיין, אז נשאיר הכל כמו שהוא. בשלב הבא אתה צריך ליצור commit חדש: שימו לב לשם ה-commit: שוב אני מפנה את תשומת לבכם לכך. התחייבות מכילה תחילה את שם המשימה, ולאחר מכן תיאור מפורט יותר של מה שנעשה. לחץ על Commit and Push... ואשר על ידי לחיצה נוספת על Push : עבור לפרויקט שלנו . כמו בעבר, GitHub כבר ראתה את הסניף החדש ומציעה ליצור בקשת משיכה ל-main. אנחנו לא מתנגדים ויוצרים אותו: כרגיל, כבר בחרנו תווית, פרויקט והקצנו לי אותו. לבסוף, לחץ על צור בקשת משיכה. בוא נחכה קצת בזמן שהבנייה תעבור - וזהו, בקשת המשיכה מוכנה למיזוג:

גירסאות

איכשהו פספסתי את הנקודה שאנחנו צריכים לעשות גרסאות. לשם כך נבצע מספר שינויים נוספים בסניף שלנו. אנו חוזרים ל-IDEA ומסתכלים על גרסת הפרויקט בזיכרון: הגרסה היא 0.0.1-SNAPSHOT . זוהי גרסת החובה. ונתחיל בעדכון גרסת הפרויקט עם כל בעיה חדשה שנפתרה. עד שנגיע ל-MVP, הגרסה תגיע עם הסיומת -SNAPSHOT. מה תהיה ערכת ניהול הגרסאות? XYZ-SNAPSHOT איפה:

• X - עדכון גרסה מרכזי, מכיל לעתים קרובות בעיות עם תאימות לאחור עם הגרסה הקודמת;
• Y - שינויים לא גדולים במיוחד, תואם באופן מלא לגרסה הקודמת;
• Z הוא מונה של ליקויים שמצאנו ותיקנו.

על סמך זה, תהיה לנו את הגרסה הראשונה - 0.1.0-SNAPSHOT - כלומר, עדיין לא היו לנו עדכונים גדולים, רק קצת מהכל, ועדיין לא הגענו ל-MVP, אז יש סיומת -SNAPSHOT . נשנה זאת בזיכרון: עבור לקובץ RELEASE_NOTES, שם נתאר את השינויים בפרויקט עם כל גרסה חדשה: הערך הראשון שלנו. כעת, עם כל עדכון גרסה עוקב, נתאר כאן מה בדיוק קרה. אנו מבצעים את המקרה הזה, כותבים תיאור: JRTB-2: גרסת פרויקט מעודכנת ונוספה ל-RELEASE_NOTES הכל בדיוק כמו קודם. אנחנו מחכים שהבנייה תעבור ונוכל למזג את השינויים שלנו. רק כאן זה יהיה קצת אחרת. אני רוצה לוודא שכל משימה בסניף הראשי היא התחייבות נפרדת, כך שפשוט דחיפה של בקשת משיכה של מיזוג לא תעבוד עבורנו. ל-Git יש את אפשרות ה-git squash, שאוסף את כל ההתחייבויות לאחד וממזג אותם. אנו בוחרים באפשרות זו: לוחצים על Squash and Merge, ומוצע לנו לערוך את ההודעה שתהיה בסופו של דבר: נוחה מאוד והכי חשוב מה מבוקש. דרך אגב, לא ראיתי תכונה כזו ב-bitbucket =/ אשר את המיזוג. הדבר היחיד שנותר הוא לשנות את סטטוס המשימה לסיום בלוח שלנו, לכתוב תגובה עם קישור לבקשת המשיכה ולסגור אותה: הלוח שלנו נראה כעת כך:

סיכום

היום יצרנו בוט טלגרם צעד אחר צעד ויישמנו אותו בפרויקט SpringBoot שלנו. הבוט עובד ונותן תשובות. עשינו גישה מיידית לנתוני הבוט דרך מאפיינים. עוד יבואו: נעשה יצירה גדולה - נבצע JRTB-3 - נוסיף תבנית פקודה לפרויקט שלנו. אה, עוד משהו... אמרתי לך שלא אפרסם את האסימון כדי שלא ייעשה בו שימוש. אבל מאז שכתבתי את המאמר קרוב יותר לחצות ואחרי העבודה, התברר שפרסמתי אסימון תקף במאגר, ו-GitGuardian סיפר לי על כך במכתב: תודה להם על זה! מה לעשות עכשיו? לא ניתן יהיה יותר למחוק אותו מה-git, שכן גם אם אני מעלה commit חדש ללא האסימון הזה, הוא עדיין יישאר בקוד הישן. אבל אני לא רוצה למחוק ולהחזיר את ה-commit לאחור. אז הלכתי והשבתתי את האסימון מה-BotFather שכבר הוזכר. עכשיו האסימון שם, אבל הוא כבר לא תקף. הירשם לחשבון GitHub שלי כדי לראות את כל הקוד שלו לפני פרסום המאמר. תודה לכולכם שקראתם, נתראה בקרוב.

רשימה של כל החומרים בסדרה נמצאת בתחילת מאמר זה.