การเพิ่มบอตโทรเลขให้กับโปรเจ็กต์ - "โปรเจ็กต์ Java จาก A ถึง Z"

สวัสดีเพื่อนรักของฉัน ใช่ ใช่ เพื่อนจริงๆ ฉันคุ้นเคยกับบทความชุดนี้มากจนคนที่เขียนแสดงความขอบคุณเป็นประจำในความคิดเห็นและ/หรือแสดงให้เห็นว่าพวกเขาได้อ่านและเข้าใจเนื้อหานั้นได้สนิทสนมกันแล้ว คุณและฉันกำลังเคลื่อนจากทั้งสองฝ่ายไปสู่เป้าหมายเดียวกัน คุณต้องการที่จะเข้าใจ แต่ฉันต้องการที่จะอธิบาย และเรามีเป้าหมายสุดท้ายเดียวกัน - แอปพลิเคชันที่เป็นลายลักษณ์อักษรที่เข้าใจได้ตั้งแต่ต้นจนจบ คุณอาจเคยได้ยินเกี่ยวกับสิ่งที่ฉันจะอธิบายในบทความนี้มาบ้างแล้ว ฉันไม่คิดว่าฉันจะบอกคุณถึงสิ่งแปลกใหม่และพิเศษ (แต่ภายในกรอบของโครงการจำเป็นต้องรู้ / ทำซ้ำ) ในฤดูใบไม้ผลิ ฉันเขียนบอทให้ตัวเอง ดังนั้นเราจะอาศัย "รูปแบบ" ของมัน

เราเขียน JRTB-2

เราจะทำแบบเดียวกับที่เราทำในบทความด้วยงานJRTB-0 :

1. เราอัปเดตสาขาหลักในโครงการท้องถิ่นโดยใช้ ชุดค่าผสม Ctrl + t
2. เราสร้างตามสาขาหลัก:
3. เพิ่มบอท
4. เราสร้างการคอมมิตใหม่พร้อมคำอธิบายถึงสิ่งที่ทำไปแล้วและพุชไปที่ GitHub
5. สร้างคำขอดึงสำหรับสาขาหลักและตรวจสอบอีกครั้ง เรากำลังรอให้บิลด์ดำเนินการ (การดำเนินการ github) รวมเข้ากับสาขาหลัก
6. ปิดงานที่เกี่ยวข้อง

บอทโทรเลขคืออะไร

เราซึ่งเป็นนักพัฒนาสามารถจินตนาการถึงการทำงานกับบอตโทรเลขเช่นนี้: เราใช้ไคลเอนต์ของพวกเขาเพื่อทำงานกับพวกเขา เรามีห้องสมุดสำเร็จรูปสำหรับทำงาน มีชุดของการดำเนินการหลังจากนั้นบอทโทรเลขจะรู้ว่าเกี่ยวข้องกับโปรแกรมของเรา และภายในโปรแกรมแล้วเราจะได้เรียนรู้วิธีรับจดหมายคำสั่งและประมวลผลพวกมัน มีสิ่งที่เรียกว่าคำสั่งในบอตโทรเลข : มันขึ้นต้นด้วยเครื่องหมายทับ “/” หลังจากนั้นเราก็เขียนคำนี้พร้อมกันทันทีซึ่งจะถือเป็นคำสั่ง ตัวอย่างเช่น มีสองคำสั่งที่ทุกคนควรรู้:

• /start — เริ่มทำงานกับบอท;
• /stop - จบการทำงานกับบอท

ที่เหลือเราจะจัดการเอง ให้ฉันจองทันที: เราจะทำอะไรอย่างแน่นอนและในวิธีที่ฉันเรียนรู้ และเมื่อทำงานกับบอท ฉันมั่นใจว่าจะสามารถทำงานได้ดีขึ้น และถ้าใครอยากทำสิ่งนี้ฉันก็จะมีความสุขและจะสนับสนุนความพยายามนี้ทุกวิถีทาง อย่างไรก็ตามสิ่งแรกสุดที่จะเจ๋งคือถ้ามีคนอธิบายให้ฉันฟังถึงวิธีตั้งโปรแกรมคำอธิบายคำสั่งผ่านโค้ดไม่ใช่ผ่านการตั้งค่าบอทในโทรเลข ฉันไม่ได้เรียนรู้สิ่งนี้ เรามีบทความหลายบทความเกี่ยวกับแหล่งข้อมูลของเราที่อธิบายวิธีสร้างบอทพื้นฐาน: วันนี้เราจะทำสิ่งที่คล้ายกัน หากคุณมีคำถามเพิ่มเติม ฉันขอแนะนำให้อ่านบทความนี้

สร้างบอทด้วย BotFather

หากต้องการเชื่อมต่อบอท คุณต้องสร้างบอทก่อน Telegram มีแนวทางในการสร้างบอทด้วยชื่อเฉพาะของตัวเอง นอกจากนี้ยังจะมาพร้อมกับโทเค็น (สตริงขนาดใหญ่ที่ทำงานเหมือนรหัสผ่าน) ฉันได้สร้างบอทสำหรับ JavaRush - @javarush_community_botแล้ว บอทนี้ยังว่างเปล่าและไม่สามารถทำอะไรได้ สิ่งสำคัญคือควรมี_bot ต่อ ท้ายชื่อ เพื่อแสดงวิธีการทำเช่นนี้ ฉันจะสร้างบอทที่เราจะทดสอบฟังก์ชันการทำงานของเรา ในแง่ของโปรเจ็กต์จริง นี่จะเป็นสภาพแวดล้อมการทดสอบ และสิ่งสำคัญของเราคือสภาพแวดล้อมการผลิต (การผลิต - การผลิตนั่นคือสภาพแวดล้อมจริงที่โครงการจะดำเนินการ) แน่นอนว่าเป็นไปได้ที่จะเพิ่มสภาพแวดล้อมอื่น - สภาพแวดล้อมแซนด์บ็อกซ์: แซนด์บ็อกซ์ทั่วไป ผู้เข้าร่วมการพัฒนาทุกคนสามารถเปลี่ยนแปลงได้และเข้าถึงได้มากขึ้น แต่สิ่งนี้จะทำให้สถานการณ์ในขั้นตอนการสร้างโครงการซับซ้อนขึ้นเท่านั้น ในตอนนี้ เรามาสร้างบอทอีกสองตัวสำหรับการทดสอบและสำหรับสภาพแวดล้อม Sandbox กันดีกว่า ขั้นตอนแรกคือการสร้าง (ลงทะเบียน) บอทใน Telegram เอง เราจำเป็นต้องค้นหาบอท: @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();
}

ที่นี่ออบเจ็กต์จะถูกสร้างขึ้นซึ่งคุณสามารถสร้างการเชื่อมต่อกับบอทได้ ในกรณีของเรา สตาร์ทเตอร์ที่เราต้องการเชื่อมต่อจะทำทุกอย่างให้เรา "ภายใต้ประทุน" (นี่คือคำแปลของวลีที่ใช้บ่อยในไอที - ภายใต้ประทุน) นี่คือลิงค์ไปยังผู้เริ่มต้นนี้ คุณสามารถดูได้ทันทีจากไฟล์ README.md ว่าคืออะไร ทำไม และใช้งานอย่างไร หากต้องการเชื่อมต่อ คุณเพียงแค่ต้องเพิ่มการพึ่งพานี้ลงในหน่วยความจำ นั่นคือทั้งหมด :) นี่คือการพึ่งพาที่จำเป็น:

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

เราเพิ่มมันเข้าไปในความทรงจำของเรา เราติดตั้งเวอร์ชันตามที่คาดไว้และอัปเดตโปรเจ็กต์ Maven ตามคำอธิบาย เราเพียงแค่ต้องสร้างคลาสใหม่ สืบทอดจาก TelegramLongPollingBot และเพิ่มคลาสนี้ใน Application Context ของ SpringBoot ของเรา บริบทของแอปพลิเคชันเป็นสถานที่จัดเก็บออบเจ็กต์ที่สร้างขึ้นสำหรับการรันโปรเจ็กต์ หากต้องการเพิ่มคลาส คุณต้องใช้คำอธิบายประกอบอย่างใดอย่างหนึ่ง: @Component, @Service, @Repository, @Controller หรือคำอธิบายประกอบ @Bean หากสร้างขึ้นผ่านวิธีการในคลาสการกำหนดค่า (นั่นคือในคลาสที่ทำเครื่องหมายด้วยคำอธิบายประกอบการกำหนดค่า) ฉันเข้าใจว่าทั้งหมดนี้อาจดูเหมือนเข้าใจยาก แต่เมื่อคุณเริ่มคิดออก คุณจะเห็นว่าไม่มีอะไรซับซ้อนที่นั่น เพื่อให้เข้าใจ Spring Boot ได้อย่างรวดเร็ว ฉันขอแนะนำหนังสือดีๆ - Spring In Action ฉบับที่ 5 หากมีความปรารถนาฉันสามารถเขียนบทความชุดจากหนังสือเล่มนี้ได้ กลับกันเถอะ. ในแพ็คเกจที่มี 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.โทเค็น

หน้าตาจะเป็นดังนี้: 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ส่งข้อความเองและ ID แชทไป - นั่นคือสิ่งที่จะส่งไปยังบอทและที่ไหน เรามีสิ่งนี้เพียงพอแล้ว ต่อไป เราจะรันเมธอดหลักใน คลาส JavarushTelegramBotApplicationและมองหาบอทของเราใน Telegram: จากบันทึก เราจะเห็นว่าบอทได้เริ่มทำงานแล้ว ถึงเวลาไปที่ Telegram แล้วเขียนถึงบอท: เราคลิกเริ่มแล้วเราได้รับคำตอบทันที: มาเขียนเรื่องไร้สาระเพื่อตรวจสอบกันดีกว่า: เท่านั้นเอง ณ จุดนี้เราสามารถพูดได้ว่างาน JRTB-2 ของเราเสร็จสมบูรณ์แล้ว . คุณยังเขียนการทดสอบใดๆ ที่นี่ไม่ได้จริงๆ ดังนั้นเราจะปล่อยให้ทุกอย่างเหมือนเดิม ถัดไป คุณต้องสร้างการคอมมิตใหม่: ให้ความสนใจกับชื่อของการคอมมิต: ฉันจะดึงความสนใจของคุณมาที่สิ่งนี้อีกครั้ง คอมมิตประกอบด้วยชื่อของงานก่อน จากนั้นจึงอธิบายรายละเอียดเพิ่มเติมเกี่ยวกับสิ่งที่ทำไปแล้ว คลิกCommit and Push... และยืนยันโดยคลิก Pushอีกครั้ง: ไปที่โครงการของเรา เช่นเคย GitHub ได้เห็นสาขาใหม่แล้วและเสนอให้สร้าง pull request สำหรับ main เราไม่ต่อต้านและสร้างมันขึ้นมา: เหมือนเช่นเคย เราได้เลือกป้ายกำกับ โปรเจ็กต์ และมอบหมายให้ฉันแล้ว สุดท้าย คลิกสร้างคำขอดึง รอสักครู่ในขณะที่บิลด์ดำเนินไป - เพียงเท่านี้ คำขอดึงก็พร้อมสำหรับการรวมแล้ว:

การกำหนดเวอร์ชัน

ฉันพลาดจุดที่เราต้องทำเวอร์ชัน เพื่อทำเช่นนี้ เราจะทำการเปลี่ยนแปลงเพิ่มเติมเล็กน้อยในสาขาของเรา เรากลับไปที่ IDEA และดูเวอร์ชันของโครงการในหน่วยความจำ: เวอร์ชันคือ0.0.1- SNAPSHOT นี่คือรุ่นหน้าที่ และเราจะเริ่มต้นด้วยการอัปเดตเวอร์ชันของโครงการพร้อมกับปัญหาใหม่ที่ได้รับการแก้ไขแล้ว เวอร์ชันนี้จะมาพร้อมกับคำต่อท้าย -SNAPSHOT จนกว่าเราจะไปถึง MVP รูปแบบการกำหนดเวอร์ชันจะเป็นอย่างไร? XYZ-SNAPSHOT โดยที่:

• X - การอัปเดตเวอร์ชันหลัก มักมีปัญหาเกี่ยวกับความเข้ากันได้แบบย้อนหลังกับเวอร์ชันก่อนหน้า
• Y - ไม่ใช่การเปลี่ยนแปลงครั้งใหญ่มาก เข้ากันได้กับเวอร์ชันก่อนหน้าอย่างสมบูรณ์
• Z คือตัวนับข้อบกพร่องที่เราพบและแก้ไข

จากนี้ เราจะมีเวอร์ชันแรก - 0.1.0-SNAPSHOT - นั่นคือเรายังไม่มีการอัปเดตที่สำคัญ เพียงเล็กน้อยของทุกสิ่ง และเรายังไม่ถึง MVP ดังนั้นจึงมีคำต่อท้าย -SNAPSHOT . มาเปลี่ยนแปลงสิ่งนี้ในหน่วยความจำ: ไปที่ไฟล์ RELEASE_NOTES ซึ่งเราจะอธิบายการเปลี่ยนแปลงของโครงการในแต่ละเวอร์ชันใหม่: รายการแรกของเรา ในตอนนี้ ด้วยการอัปเดตเวอร์ชันต่อๆ ไป เราจะอธิบายสิ่งที่เกิดขึ้นที่นี่ เรายอมรับกรณีนี้ เขียนคำอธิบาย: JRTB-2: เวอร์ชันโปรเจ็กต์ที่อัปเดตและเพิ่มใน RELEASE_NOTES ทุกอย่างเหมือนเดิมทุกประการ เรากำลังรอให้บิลด์ผ่าน และเราสามารถรวมการเปลี่ยนแปลงของเราได้ เฉพาะที่นี่จะแตกต่างออกไปเล็กน้อย ฉันต้องการให้แน่ใจว่าแต่ละงานในสาขาหลักเป็นการกระทำที่แยกจากกัน ดังนั้นการพุชMerge pull requestจะไม่ได้ผลสำหรับเรา Git มีตัวเลือก git squash ซึ่งรวบรวมคอมมิตทั้งหมดเป็นอันเดียวและรวมเข้าด้วยกัน เราเลือกตัวเลือกนี้: คลิก Squash and Merge และเราได้รับการเสนอให้แก้ไขข้อความซึ่งจะอยู่ในท้ายที่สุด: สะดวกมากและที่สำคัญที่สุดคือสิ่งที่อยู่ในความต้องการ อย่างไรก็ตาม ฉันไม่เห็นฟีเจอร์ดังกล่าวใน bitbucket =/ ยืนยันการรวม สิ่งเดียวที่เหลือคือเปลี่ยนงานเป็นสถานะเสร็จสิ้นในบอร์ดของเรา เขียนความคิดเห็นพร้อมลิงก์ไปยังคำขอดึงและปิด: ตอนนี้บอร์ดของเรามีลักษณะดังนี้:

บทสรุป

วันนี้เราสร้างบอตโทรเลขทีละขั้นตอนและนำไปใช้ในโปรเจ็กต์ SpringBoot ของเรา บอททำงานและให้คำตอบ เราเข้าถึงข้อมูลบอทได้ทันทีผ่านคุณสมบัติ อื่นๆ ที่จะตามมา: เราจะทำงานชิ้นใหญ่ - ดำเนินการJRTB-3 - เพิ่มรูปแบบคำสั่งสำหรับโครงการของเรา อ้อ อีกเรื่องหนึ่ง... ฉันบอกคุณแล้วว่าฉันจะไม่เผยแพร่โทเค็นเพื่อที่จะไม่ถูกนำไปใช้ แต่เนื่องจากฉันเขียนบทความตอนใกล้เที่ยงคืนและหลังเลิกงาน ปรากฎว่าฉันได้โพสต์โทเค็นที่ถูกต้องในพื้นที่เก็บข้อมูล และ GitGuardian บอกฉันเกี่ยวกับสิ่งนี้ในจดหมาย: ขอบคุณพวกเขาสำหรับสิ่งนี้! จะทำอย่างไรตอนนี้? จะไม่สามารถลบออกจากคอมไพล์ได้อีกต่อไป เนื่องจากแม้ว่าฉันจะอัปโหลดคอมมิตใหม่โดยไม่มีโทเค็นนี้ แต่โทเค็นก็จะยังคงอยู่ในอันเก่า แต่ฉันไม่ต้องการลบและย้อนกลับการคอมมิต ดังนั้นฉันจึงไปและปิดการใช้งานโทเค็นจาก BotFather ที่กล่าวถึงแล้ว ตอนนี้โทเค็นอยู่ที่นั่นแล้ว แต่ใช้ไม่ได้อีกต่อไป สมัครสมาชิกบัญชี GitHub ของฉันเพื่อดูโค้ดทั้งหมดก่อนที่จะเผยแพร่บทความ ขอบคุณทุกท่านที่เข้ามาอ่าน แล้วพบกันใหม่ครับ

รายการเนื้อหาทั้งหมดในซีรีส์นี้อยู่ที่ตอนต้นของบทความนี้