اچو ته bot سان ڪم ڪرڻ لاءِ ڪمانڊ جو نمونو لاڳو ڪريون. (حصو 1) - "جاوا پروجيڪٽ A کان Z تائين"

سڀني کي سلام، پيارا دوست. اڄ اسان پنهنجي ضرورتن لاءِ ڪمانڊ ڊيزائن جو هڪ ٽيمپليٽ (ٽيمپليٽ هڪ نمونو آهي، اسان جي حوالي سان اهو ساڳيو آهي) لاڳو ڪنداسين. هن ٽيمپليٽ کي استعمال ڪندي، اسان آساني سان ۽ صحيح طريقي سان ڪم ڪنداسين اسان جي بوٽن جي حڪمن جي پروسيسنگ سان. شروع ڪرڻ سان، اهو سٺو ٿيندو ته اهو ڪهڙي قسم جو نمونو آهي - حڪم. پر جيڪڏهن مان ائين ڪندس ته مضمون تمام وڏو ۽ منجهيل هوندو. تنهن ڪري، مون خود مطالعي لاء مواد چونڊيو:

1. هي منهنجو آرٽيڪل 4 سال اڳ آهي. مون اهو لکيو هو جڏهن مان هڪ جونيئر هو، تنهنڪري ان کي تمام سختيء سان فيصلو نه ڪريو.
2. يوٽيوب تي هڪ تمام جذباتي ۽ انٽرويو سويڊن جي وڊيو. مان ان جي ڏاڍي سفارش ڪريان ٿو. هو خوبصورت ڳالهائيندو آهي، هن جي انگريزي صاف ۽ سمجھڻ واري آهي. ۽ عام طور تي، هن وٽ ٻين ڊزائن جي نمونن بابت هڪ وڊيو آهي.
3. منهنجي مضمون جي تبصرن ۾، ڪو ماڻهو Nullptr35 هن وڊيو جي سفارش ڪئي .

اهو ڪافي هجڻ گهرجي پاڻ کي موضوع ۾ وسارڻ ۽ مون وانگر ساڳئي صفحي تي. يقينن، جيڪي هن ڊزائن جي نموني سان واقف آهن محفوظ طور تي ڇڏي سگهن ٿا ۽ اڳتي وڌو.

اسان لکون ٿا JRTB-3

سڀ ڪجهه اڳ وانگر آهي:

1. اسان مکيه شاخ کي اپڊيٽ ڪيو.
2. تازه ڪاري مکيه شاخ جي بنياد تي، اسان هڪ نئون JRTB-3 ٺاهيندا آهيون .
3. اچو ته نموني تي عمل ڪريو.
4. اسان هڪ نئون ڪم ٺاهيو جيڪو ڪم ڪيو ويو بيان ڪري ٿو.
5. اسان هڪ پل جي درخواست ٺاهي، ان کي چيڪ ڪريو، ۽ جيڪڏھن سڀ ڪجھ ٺيڪ آھي، اسان پنھنجي ڪم کي ملائي سگھون ٿا.

مان پوائنٽس 1-2 نه ڏيکاريندس: مون انهن کي اڳئين مضمونن ۾ تمام احتياط سان بيان ڪيو آهي، تنهنڪري اچو ته سڌو سنئون ٽيمپليٽ کي لاڳو ڪرڻ لاءِ اڳتي وڌون. هي ٽيمپليٽ اسان لاءِ موزون ڇو آهي؟ ها، ڇاڪاڻ ته هر دفعي اسان هڪ حڪم تي عمل ڪندا آهيون، اسان تي وڃون ٿا onUpdateReceived(Update update) طريقي سان ، ۽ حڪم جي بنياد تي اسين مختلف منطق تي عمل ڪنداسين. هن نموني کان سواء، اسان وٽ هڪ مڪمل ميزبان هوندو if-else if بيان. ڪجهه هن طرح:

if (message.startsWith("/start")) {
   doStartCommand();
} else if(message.startsWith("/stop")) {
   doStopCommand();
} else if(message.startsWith("/addUser")) {
   doAddUserCommand();
}
...
else if(message.startsWith("/makeMeHappy")) {
   doMakeMeHappyCommand();
}

ان کان سواء، جتي هڪ ellipsis آهي، اتي ڪيترن ئي درجن وڌيڪ ٽيمون ٿي سگهي ٿي. ۽ ان کي عام طور تي ڪيئن سنڀالجي؟ سپورٽ ڪيئن ڪجي؟ مشڪل ۽ مشڪل. هن جو مطلب آهي ته هي اختيار اسان کي مناسب نه آهي. اهو ڪجهه هن طرح ڏسڻ گهرجي:

if (message.startsWith(COMMAND_PREFIX)) {
   String commandIdentifier = message.split(" ")[0].toLowerCase();
   commandContainer.getCommand(commandIdentifier, userName).execute(update);
} else {
   commandContainer.getCommand(NO.getCommand(), userName).execute(update);
}

اهو ئي سڀ ڪجهه آهي! ۽ ڪو مسئلو ناهي ته اسان ڪيترا حڪم شامل ڪندا آهيون، ڪوڊ جو هي حصو اڻڄاتل رهندو. هي ڇا ڪري رهيو آهي؟ پهرين جيڪڏهن پڪ ڪري ٿي ته پيغام شروع ٿئي ٿو ڪمانڊ پريفڪس "/" سان. جيڪڏهن اهو معاملو آهي، ته پوء اسان پهرين اسپيس تائين لڪير کي چونڊيو ۽ ڪمانڊ ڪنٽينر ۾ لاڳاپيل ڪمان کي ڳولي؛ جيئن ئي اسان ان کي ڳوليندا آهيون، اسان ڪمانڊ هلائيندا آهيون. ۽ اهو سڀ ڪجهه آهي...) جيڪڏهن توهان وٽ خواهش ۽ وقت آهي، ته توهان ٽيمن سان ڪم ڪري سگهو ٿا، پهرين هڪ طبقي ۾ هڪ ئي وقت، شرطن جي هڪ گروپ سان ۽ انهن سڀني سان، ۽ پوءِ ٽيمپليٽ استعمال ڪندي. تون فرق ڏسندين. اها ڪهڙي خوبصورتي هوندي! پهرين، اچو ته بوٽ پيڪيج جي اڳيان هڪ پيڪيج ٺاهي، جنهن کي سڏيو ويندو حڪم . ۽ اڳ ۾ ئي هن پيڪيج ۾ موجود سڀئي طبقا هوندا جيڪي ڪمانڊ جي نفاذ سان لاڳاپيل آهن. ڪمانڊز سان ڪم ڪرڻ لاءِ اسان کي ھڪڙي انٽرفيس جي ضرورت آھي. هن معاملي لاء، اچو ته ان کي ٺاهيو:

package com.github.javarushcommunity.jrtb.command;

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

/**
* Command interface for handling telegram-bot commands.
*/
public interface Command {

   /**
    * Main method, which is executing command logic.
    *
    * @param update provided {@link Update} object with all the needed data for command.
    */
   void execute(Update update);
}

هن نقطي تي، اسان کي حڪم جي ريورس آپريشن کي لاڳو ڪرڻ جي ضرورت ناهي، تنهنڪري اسان هن طريقي کي ڇڏي ڏينداسين (unexecute). عمل جي طريقي ۾، اپڊيٽ اعتراض هڪ دليل طور اچي ٿو - بلڪل اهو جيڪو اسان جي بنيادي طريقي سان اچي ٿو بوٽ ۾. هي اعتراض هر شيء تي مشتمل هوندو جيڪو ڪمانڊ کي پروسيس ڪرڻ جي ضرورت آهي. اڳيون، اسان هڪ اينم شامل ڪنداسين جيڪو ذخيرو ڪندو حڪم جي قيمتن (شروع، اسٽاپ، وغيره). اسان کي هن جي ضرورت ڇو آهي؟ انهي ڪري ته اسان وٽ ٽيم جي نالن لاءِ سچائي جو صرف هڪ ذريعو آهي. اسان ان کي اسان جي ڪمانڊ پيڪيج ۾ پڻ ٺاهيو . اچو ته ان کي سڏين CommandName :

package com.github.javarushcommunity.jrtb.command;

/**
* Enumeration for {@link Command}'s.
*/
public enum CommandName {

   START("/start"),
   STOP("/stop");

   private final String commandName;

   CommandName(String commandName) {
       this.commandName = commandName;
   }

   public String getCommandName() {
       return commandName;
   }

}

اسان کي پڻ هڪ خدمت جي ضرورت آهي جيڪا بوٽ ذريعي پيغام موڪليندي. هن کي ڪرڻ لاءِ، اسان ڪمانڊ پيڪيج جي اڳيان هڪ سروس پيڪيج ٺاهينداسين ، جنهن ۾ اسين سڀ ضروري خدمتون شامل ڪنداسين. هتي اهو ڌيان ڏيڻ جي قابل آهي ته هن معاملي ۾ خدمت لفظ مان منهنجو مطلب ڇا آهي. جيڪڏهن اسان هڪ ايپليڪيشن تي غور ڪريون ٿا، اهو اڪثر ڪري ڪيترن ئي تہن ۾ ورهايل آهي: آخري پوائنٽ سان ڪم ڪرڻ لاء هڪ پرت - ڪنٽرولرز، ڪاروباري منطق جي هڪ پرت - خدمتون، ۽ ڊيٽابيس سان ڪم ڪرڻ لاء هڪ پرت - هڪ مخزن. تنهن ڪري، اسان جي صورت ۾، هڪ خدمت هڪ طبقي آهي جيڪو ڪنهن قسم جي ڪاروباري منطق کي لاڳو ڪري ٿو. هڪ خدمت صحيح طريقي سان ڪيئن ٺاهي؟ پهرين، ان لاء هڪ انٽرفيس ٺاهيو ۽ هڪ عمل درآمد. اسان جي SpringBoot ايپليڪيشن جي ايپليڪيشن جي حوالي سان `@Service` تشريح استعمال ڪندي عمل درآمد شامل ڪريو، ۽، جيڪڏھن ضروري ھجي، ته ان کي `@Autowired` تشريح استعمال ڪندي سخت ڪريو. تنهن ڪري، اسان SendBotMessageService انٽرفيس ٺاهيندا آهيون (نام ڏيڻ جي خدمتن ۾ اهي عام طور تي نالي جي آخر ۾ سروس شامل ڪندا آهن):

package com.github.javarushcommunity.jrtb.service;

/**
* Service for sending messages via telegram-bot.
*/
public interface SendBotMessageService {

   /**
    * Send message via telegram bot.
    *
    * @param chatId provided chatId in which messages would be sent.
    * @param message provided message to be sent.
    */
   void sendMessage(String chatId, String message);
}

اڳيون، اسان ان جي عمل کي ٺاهيندا آهيون:

package com.github.javarushcommunity.jrtb.service;

import com.github.javarushcommunity.jrtb.bot.JavarushTelegramBot;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;

/**
* Implementation of {@link SendBotMessageService} interface.
*/
@Service
public class SendBotMessageServiceImpl implements SendBotMessageService {

   private final JavarushTelegramBot javarushBot;

   @Autowired
   public SendBotMessageServiceImpl(JavarushTelegramBot javarushBot) {
       this.javarushBot = javarushBot;
   }

   @Override
   public void sendMessage(String chatId, String message) {
       SendMessage sendMessage = new SendMessage();
       sendMessage.setChatId(chatId);
       sendMessage.enableHtml(true);
       sendMessage.setText(message);

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

اهو آهي جيڪو عمل درآمد وانگر نظر اچي ٿو. سڀ کان اهم جادو آهي جتي ڊزائنر ٺاهي وئي آهي. تعمير ڪندڙ تي @Autowired تشريح استعمال ڪندي، SpringBoot هن طبقي جي هڪ اعتراض کي پنهنجي ايپليڪيشن جي حوالي سان ڳوليندو. ۽ هو اڳ ۾ ئي آهي. اهو هن طرح ڪم ڪري ٿو: اسان جي ايپليڪيشن ۾، ڪٿي به اسان بوٽ تائين رسائي ڪري سگهون ٿا ۽ ڪجهه ڪري سگهون ٿا. ۽ هي خدمت پيغام موڪلڻ جي ذميوار آهي. ته جيئن اسين هر وقت هر هنڌ هن طرح ڪجهه نه لکون:

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

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

اسان هن منطق کي الڳ طبقي ۾ منتقل ڪيو آهي ۽ جيڪڏهن ضروري هجي ته ان کي استعمال ڪنداسين. هاڻي اسان کي ٽن حڪمن تي عمل ڪرڻ جي ضرورت آهي: StartCommand، StopCommand ۽ UnknownCommand. اسان کي انهن جي ضرورت آهي ته اسان وٽ ڪجهه آهي اسان جي ڪنٽينر کي ڀرڻ لاءِ حڪمن لاءِ. في الحال، نصوص سڪل ۽ غير معلوماتي هوندا؛ هن ڪم جي مقصدن لاء، اهو تمام ضروري ناهي. تنهن ڪري، StartCommand:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Start {@link Command}.
*/
public class StartCommand implements Command {

   private final SendBotMessageService sendBotMessageService;

   public final static String START_MESSAGE = "Привет. Я Javarush Telegram Bot. Я помогу тебе быть в курсе последних " +
           "статей тех авторов, котрые тебе интересны. Я еще маленький и только учусь.";

   // Здесь не добавляем сервис через получение из Application Context.
   // Потому что если это сделать так, то будет циклическая зависимость, которая
   // ломает работу applications.
   public StartCommand(SendBotMessageService sendBotMessageService) {
       this.sendBotMessageService = sendBotMessageService;
   }

   @Override
   public void execute(Update update) {
       sendBotMessageService.sendMessage(update.getMessage().getChatId().toString(), START_MESSAGE);
   }
}

مھرباني ڪري تبصرو پڙھو احتياط سان ٺاھيندڙ کان اڳ. سرڪيولر انحصار ( سرکلر انحصار ) ٿي سگهي ٿو هڪ فن تعمير جي ڪري جيڪو بلڪل صحيح ناهي. اسان جي صورت ۾، اسان کي يقيني بڻائي ته سڀڪنھن شيء کي ڪم ۽ صحيح آهي. ايپليڪيشن جي حوالي سان حقيقي اعتراض شامل ڪيو ويندو جڏهن ڪمانڊ ٺاهيندي اڳ ۾ ئي CommandContainer ۾. اسٽاپ ڪمانڊ:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Stop {@link Command}.
*/
public class StopCommand implements Command {

   private final SendBotMessageService sendBotMessageService;

   public static final String STOP_MESSAGE = "Деактивировал все ваши подписки \uD83D\uDE1F.";

   public StopCommand(SendBotMessageService sendBotMessageService) {
       this.sendBotMessageService = sendBotMessageService;
   }

   @Override
   public void execute(Update update) {
       sendBotMessageService.sendMessage(update.getMessage().getChatId().toString(), STOP_MESSAGE);
   }
}

۽ Unknown Command. اسان کي ان جي ضرورت ڇو آهي؟ اسان لاء، هي هڪ اهم حڪم آهي جيڪو جواب ڏيندو جيڪڏهن اسان اهو حڪم نه ڳولي سگهون ٿا جيڪو اسان کي ڏنو ويو آهي. اسان کي به ضرورت پوندي NoCommand ۽ HelpCommand.

• NoCommand - صورتحال جو ذميوار هوندو جڏهن پيغام ڪنهن حڪم سان شروع نٿو ٿئي؛
• HelpCommand صارف لاءِ ھدايت وارو ھوندو، ھڪ قسم جو دستاويز.

اچو ته شامل ڪريون HelpCommand:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

import static com.github.javarushcommunity.jrtb.command.CommandName.*;

/**
* Help {@link Command}.
*/
public class HelpCommand implements Command {

   private final SendBotMessageService sendBotMessageService;

   public static final String HELP_MESSAGE = String.format("✨<b>Дотупные команды</b>✨\n\n"

                   + "<b>Начать\\закончить работу с ботом</b>\n"
                   + "%s - начать работу со мной\n"
                   + "%s - приостановить работу со мной\n\n"
                   + "%s - получить помощь в работе со мной\n",
           START.getCommandName(), STOP.getCommandName(), HELP.getCommandName());

   public HelpCommand(SendBotMessageService sendBotMessageService) {
       this.sendBotMessageService = sendBotMessageService;
   }

   @Override
   public void execute(Update update) {
       sendBotMessageService.sendMessage(update.getMessage().getChatId().toString(), HELP_MESSAGE);
   }
}

No Command:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* No {@link Command}.
*/
public class NoCommand implements Command {

   private final SendBotMessageService sendBotMessageService;

   public static final String NO_MESSAGE = "Я поддерживаю команды, начинающиеся со слеша(/).\n"
           + "Whatбы посмотреть список команд введите /help";

   public NoCommand(SendBotMessageService sendBotMessageService) {
       this.sendBotMessageService = sendBotMessageService;
   }

   @Override
   public void execute(Update update) {
       sendBotMessageService.sendMessage(update.getMessage().getChatId().toString(), NO_MESSAGE);
   }
}

۽ هن ڪم لاء اڃا تائين اڻڄاتل حڪم آهي:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

/**
* Unknown {@link Command}.
*/
public class UnknownCommand implements Command {

   public static final String UNKNOWN_MESSAGE = "Не понимаю вас \uD83D\uDE1F, напишите /help чтобы узнать что я понимаю.";

   private final SendBotMessageService sendBotMessageService;

   public UnknownCommand(SendBotMessageService sendBotMessageService) {
       this.sendBotMessageService = sendBotMessageService;
   }

   @Override
   public void execute(Update update) {
       sendBotMessageService.sendMessage(update.getMessage().getChatId().toString(), UNKNOWN_MESSAGE);
   }
}

اڳيون، اچو ته اسان جي حڪمن لاء هڪ ڪنٽينر شامل ڪريو. اهو اسان جي حڪم جي شين کي ذخيرو ڪندو ۽ درخواست تي اسان کي گهربل حڪم حاصل ڪرڻ جي اميد آهي. اچو ته ان کي سڏين CommandContainer :

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import com.google.common.collect.ImmutableMap;

import static com.github.javarushcommunity.jrtb.command.CommandName.*;

/**
* Container of the {@link Command}s, which are using for handling telegram commands.
*/
public class CommandContainer {

   private final ImmutableMap<String, Command> commandMap;
   private final Command unknownCommand;

   public CommandContainer(SendBotMessageService sendBotMessageService) {

       commandMap = ImmutableMap.<string, command="">builder()
               .put(START.getCommandName(), new StartCommand(sendBotMessageService))
               .put(STOP.getCommandName(), new StopCommand(sendBotMessageService))
               .put(HELP.getCommandName(), new HelpCommand(sendBotMessageService))
               .put(NO.getCommandName(), new NoCommand(sendBotMessageService))
               .build();

       unknownCommand = new UnknownCommand(sendBotMessageService);
   }

   public Command retrieveCommand(String commandIdentifier) {
       return commandMap.getOrDefault(commandIdentifier, unknownCommand);
   }

}

جئين توهان ڏسي سگهو ٿا، هر شيء آسان ٿي وئي. اسان وٽ هڪ ناقابل بدلي نقشو آهي جنهن ۾ هڪ ڪنجي سان ڪمانڊ ويليو جي صورت ۾ ۽ قيمت ڪمانڊ قسم جي ڪمانڊ شئي جي صورت ۾ آهي. تعمير ڪندڙ ۾، اسان هڪ ڀيرو ناقابل قابل نقشو ڀريو ۽ ان تائين رسائي سڄي ايپليڪيشن جي آپريشن دوران. ڪنٽينر سان ڪم ڪرڻ جو مکيه ۽ واحد طريقو آهي retrieveCommand(String commandIdentifier) ​​. اتي ھڪڙو حڪم آھي UnknownCommand، جيڪو ڪيسن لاء ذميوار آھي جڏھن اسان لاڳاپيل حڪم نه ڳولي سگھون ٿا. ھاڻي اسان ڪنٽينر کي پنھنجي بوٽ ڪلاس ۾ لاڳو ڪرڻ لاءِ تيار آھيون - JavaRushTelegramBot ۾: ھي اھو آھي جيڪو اسان جو بوٽ ڪلاس ھاڻي ڏسڻ ۾ اچي ٿو:

package com.github.javarushcommunity.jrtb.bot;

import com.github.javarushcommunity.jrtb.command.CommandContainer;
import com.github.javarushcommunity.jrtb.service.SendBotMessageServiceImpl;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

import static com.github.javarushcommunity.jrtb.command.CommandName.NO;

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

   public static String COMMAND_PREFIX = "/";

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

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

   private final CommandContainer commandContainer;

   public JavarushTelegramBot() {
       this.commandContainer = new CommandContainer(new SendBotMessageServiceImpl(this));
   }

   @Override
   public void onUpdateReceived(Update update) {
       if (update.hasMessage() && update.getMessage().hasText()) {
           String message = update.getMessage().getText().trim();
           if (message.startsWith(COMMAND_PREFIX)) {
               String commandIdentifier = message.split(" ")[0].toLowerCase();

               commandContainer.retrieveCommand(commandIdentifier).execute(update);
           } else {
               commandContainer.retrieveCommand(NO.getCommandName()).execute(update);
           }
       }
   }

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

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

۽ اھو اھو آھي، ڪوڊ ۾ تبديليون مڪمل ڪيون ويون آھن. مان هن کي ڪيئن چيڪ ڪري سگهان ٿو؟ توهان کي بوٽ لانچ ڪرڻ جي ضرورت آهي ۽ چيڪ ڪريو ته هر شي ڪم ڪري ٿي. ائين ڪرڻ لاءِ، مان Application.properties ۾ ٽوڪن کي اپڊيٽ ڪريان ٿو، صحيح سيٽ ڪريو، ۽ ايپليڪيشن کي JavarushTelegramBotApplication ڪلاس ۾ لانچ ڪريان ٿو: ھاڻي اسان کي جانچڻ جي ضرورت آھي ته ڪمانڊ توقع مطابق ڪم ڪن ٿا. مان ان کي قدم قدم جي جانچ ڪريان ٿو:

• اسٽاپ ڪمانڊ؛
• StartCommand؛
• مدد حڪم؛
• No Command؛
• اڻڄاتل حڪم.

هتي ڇا ٿيو آهي: بوٽ بلڪل ڪم ڪيو جيئن اسان توقع ڪئي. لنڪ ذريعي جاري .

سيريز ۾ سڀني مواد جي هڪ فهرست هن مضمون جي شروعات ۾ آهي.