Geekly articles weekly

Um exemplo de uso de uma biblioteca Java para criar um bot de Telegram

Todo desenvolvedor (e não apenas) que usa o Telegram na vida cotidiana, pelo menos uma vez pensou em como é criar seu próprio bot, quão difícil é e qual linguagem de programação é melhor usar.


Posso dar a resposta mais simples (e provavelmente a mais correta) a todas essas perguntas: tudo depende de você, seu conhecimento e intenções.


... Mas neste pequeno artigo, mostrarei como você pode criar seu próprio bot em Java e que ele é bastante interessante e descomplicado.


Usaremos a biblioteca para trabalhar com a API do Telegram Bots e sua extensão , o que nos permite criar nossos próprios comandos (' /custom_cmd ') e processá-los de maneira simples.


A tarefa do bot será registrar o usuário e enviar uma mensagem do nome especificado para outros usuários do bot.


Criação de um novo projeto e preparação


1. Adicione dependências ao projeto


Crie um novo projeto maven e edite o pom.xml , adicionando as dependências necessárias a ele:


pom.xml
  <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>io.example</groupId> <artifactId>anonymizerbot</artifactId> <version>1.0-SNAPSHOT</version> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> ```8</source> <target>8</target> </configuration> </plugin> </plugins> </build> <dependencies> <!-- Telegram API --> <dependency> <groupId>org.telegram</groupId> <artifactId>telegrambots</artifactId> <version>LATEST</version> </dependency> <dependency> <groupId>org.telegram</groupId> <artifactId>telegrambotsextensions</artifactId> <version>LATEST</version> </dependency> ... </dependencies> </project>

API do Telegram - uma biblioteca para trabalhar com a API do Telegram Bots , contém classes e métodos para interagir com os serviços do Telegram e algumas extensões dessas classes.


2. Criando uma conta para o bot


Para fazer isso, precisamos entrar em contato com o bot do BotFather para obter ajuda:


  • encontre o bot na busca;
  • execute o comando "/ start";
  • execute o comando "/ newbot";
  • vamos definir um nome para o nosso bot (ele deve terminar com "Bot"). Eu chamei de "ExampleOfAnonymizerBot".

Depois de executar esses comandos, obtemos o token necessário para usar a API Bot. (7xxxxxxx2: Axxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx0)






Implementação


1. Modelo de remetente anônimo de mensagens


Os dados que precisamos de cada usuário:


  • Usuário mUser - informações sobre o usuário do Telegram;
  • Chat mChat - informações de bate-papo de usuários e bot;
  • String mDisplayedName - o nome do qual o usuário enviará mensagens para outros usuários do bot.

Anonymous.java
 package io.example.anonymizerbot.model; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.telegram.telegrambots.meta.api.objects.Chat; import org.telegram.telegrambots.meta.api.objects.User; public final class Anonymous { private static final Logger LOG = LogManager.getLogger(Anonymous.class); private static final String USER_CHAT_CANNOT_BE_NULL = "User or chat cannot be null!"; private final User mUser; private final Chat mChat; private String mDisplayedName; public Anonymous(User user, Chat chat) { if (user == null || chat == null) { LOG.error(USER_CHAT_CANNOT_BE_NULL); throw new IllegalStateException(USER_CHAT_CANNOT_BE_NULL); } mUser = user; mChat = chat; } @Override public int hashCode() { return mUser.hashCode(); } @Override public boolean equals(Object obj) { return obj instanceof Anonymous && ((Anonymous) obj).getUser().equals(mUser); } public User getUser() { return mUser; } public Chat getChat() { return mChat; } public String getDisplayedName() { return mDisplayedName; } public void setDisplayedName(String displayedName) { mDisplayedName = displayedName; } }

Adicione um serviço que contenha métodos comumente usados ​​para manipular muitos usuários anônimos.


AnonymousService.java
 package io.example.anonymizerbot.service; import io.example.anonymizerbot.model.Anonymous; import org.telegram.telegrambots.meta.api.objects.User; import java.util.HashSet; import java.util.Objects; import java.util.Set; import java.util.stream.Stream; public final class AnonymousService { private final Set<Anonymous> mAnonymouses; public AnonymousService() { mAnonymouses = new HashSet<>(); } public boolean setUserDisplayedName(User user, String name) { if (!isDisplayedNameTaken(name)) { mAnonymouses.stream().filter(a -> a.getUser().equals(user)).forEach(a -> a.setDisplayedName(name)); return true; } return false; } public boolean removeAnonymous(User user) { return mAnonymouses.removeIf(a -> a.getUser().equals(user)); } public boolean addAnonymous(Anonymous anonymous) { return mAnonymouses.add(anonymous); } public boolean hasAnonymous(User user) { return mAnonymouses.stream().anyMatch(a -> a.getUser().equals(user)); } public String getDisplayedName(User user) { Anonymous anonymous = mAnonymouses.stream().filter(a -> a.getUser().equals(user)).findFirst().orElse(null); if (anonymous == null) { return null; } return anonymous.getDisplayedName(); } public Stream<Anonymous> anonymouses() { return mAnonymouses.stream(); } private boolean isDisplayedNameTaken(String name) { return mAnonymouses.stream().anyMatch(a -> Objects.equals(a.getDisplayedName(), name)); } }

2. interface Bot


Qualquer comando personalizado deve herdar do BotCommand e implementar um método
execute(AbsSender sender, User user, Chat chat, String[] strings) , usado para processar comandos do usuário.


Após processarmos o comando do usuário, podemos enviar uma resposta a ele usando o método execute da classe AbsSender , que execute(AbsSender sender, User user, Chat chat, String[] strings) mencionada acima execute(AbsSender sender, User user, Chat chat, String[] strings) .


A seguir, a fim de não AbsSender.execute sempre o método AbsSender.execute , que pode lançar uma TelegramApiException , em try-catch , e para não gravar logs monótonos em cada comando, criaremos a classe AnonymizerCommand e herdaremos nossos comandos personalizados. (deixaremos o tratamento de exceções neste exemplo):


AnonymizerCommand.java
 package io.example.anonymizerbot.command; import io.example.anonymizerbot.logger.LogLevel; import io.example.anonymizerbot.logger.LogTemplate; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; import org.telegram.telegrambots.extensions.bots.commandbot.commands.BotCommand; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.bots.AbsSender; import org.telegram.telegrambots.meta.exceptions.TelegramApiException; abstract class AnonymizerCommand extends BotCommand { final Logger log = LogManager.getLogger(getClass()); AnonymizerCommand(String commandIdentifier, String description) { super(commandIdentifier, description); } void execute(AbsSender sender, SendMessage message, User user) { try { sender.execute(message); log.log(Level.getLevel(LogLevel.SUCCESS.getValue()), LogTemplate.COMMAND_SUCCESS.getTemplate(), user.getId(), getCommandIdentifier()); } catch (TelegramApiException e) { log.error(LogTemplate.COMMAND_EXCEPTION.getTemplate(), user.getId(), getCommandIdentifier(), e); } } }

Defina os comandos aos quais nosso bot responderá:


  • /start - cria um novo Anonymous sem nome e adiciona-o à coleção Anonymouses ;

StartCommand.java
 package io.example.anonymizerbot.command; import io.example.anonymizerbot.logger.LogLevel; import io.example.anonymizerbot.logger.LogTemplate; import io.example.anonymizerbot.model.Anonymous; import io.example.anonymizerbot.service.AnonymousService; import org.apache.logging.log4j.Level; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.Chat; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.bots.AbsSender; public final class StartCommand extends AnonymizerCommand { private final AnonymousService mAnonymouses; //     , //        public StartCommand(AnonymousService anonymouses) { super("start", "start using bot\n"); mAnonymouses = anonymouses; } /** *    BotCommand,    ,   * @param absSender -    * @param user - ,    * @param chat -     * @param strings - ,    */ @Override public void execute(AbsSender absSender, User user, Chat chat, String[] strings) { log.info(LogTemplate.COMMAND_PROCESSING.getTemplate(), user.getId(), getCommandIdentifier()); StringBuilder sb = new StringBuilder(); SendMessage message = new SendMessage(); message.setChatId(chat.getId().toString()); if (mAnonymouses.addAnonymous(new Anonymous(user, chat))) { log.info("User {} is trying to execute '{}' the first time. Added to users' list.", user.getId(), getCommandIdentifier()); sb.append("Hi, ").append(user.getUserName()).append("! You've been added to bot users' list!\n") .append("Please execute command:\n'/set_name <displayed_name>'\nwhere &lt;displayed_name&gt; is the name you want to use to hide your real name."); } else { log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} has already executed '{}'. Is he trying to do it one more time?", user.getId(), getCommandIdentifier()); sb.append("You've already started bot! You can send messages if you set your name (/set_name)."); } message.setText(sb.toString()); execute(absSender, message, user); } }

  • /help - exibe informações sobre todos os comandos disponíveis para o usuário (o construtor difere dos outros porque precisa passar ICommandRegistry , que contém todos os comandos personalizados);

HelpCommand.java
 package io.example.anonymizerbot.command; import io.example.anonymizerbot.logger.LogTemplate; import org.telegram.telegrambots.extensions.bots.commandbot.commands.ICommandRegistry; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.Chat; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.bots.AbsSender; public final class HelpCommand extends AnonymizerCommand { private final ICommandRegistry mCommandRegistry; public HelpCommand(ICommandRegistry commandRegistry) { super("help", "list all known commands\n"); mCommandRegistry = commandRegistry; } @Override public void execute(AbsSender absSender, User user, Chat chat, String[] strings) { log.info(LogTemplate.COMMAND_PROCESSING.getTemplate(), user.getId(), getCommandIdentifier()); StringBuilder helpMessageBuilder = new StringBuilder("<b>Available commands:</b>"); mCommandRegistry.getRegisteredCommands().forEach(cmd -> helpMessageBuilder.append(cmd.toString()).append("\n")); SendMessage helpMessage = new SendMessage(); helpMessage.setChatId(chat.getId().toString()); helpMessage.enableHtml(true); helpMessage.setText(helpMessageBuilder.toString()); execute(absSender, helpMessage, user); } }

  • /set_name - /set_name usuário um nome a partir do qual as mensagens anônimas serão enviadas;

SetNameCommand.java
 package io.example.anonymizerbot.command; import io.example.anonymizerbot.logger.LogLevel; import io.example.anonymizerbot.logger.LogTemplate; import io.example.anonymizerbot.service.AnonymousService; import org.apache.logging.log4j.Level; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.Chat; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.bots.AbsSender; public final class SetNameCommand extends AnonymizerCommand { private final AnonymousService mAnonymouses; public SetNameCommand(AnonymousService anonymouses) { super("set_name", "set or change name that will be displayed with your messages\n"); mAnonymouses = anonymouses; } @Override public void execute(AbsSender absSender, User user, Chat chat, String[] strings) { log.info(LogTemplate.COMMAND_PROCESSING.getTemplate(), user.getId(), getCommandIdentifier()); SendMessage message = new SendMessage(); message.setChatId(chat.getId().toString()); if (!mAnonymouses.hasAnonymous(user)) { log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to execute '{}' without starting the bot!", user.getId(), getCommandIdentifier()); message.setText("Firstly you should start the bot! Execute '/start' command!"); execute(absSender, message, user); return; } String displayedName = getName(strings); if (displayedName == null) { log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to set empty name.", user.getId()); message.setText("You should use non-empty name!"); execute(absSender, message, user); return; } StringBuilder sb = new StringBuilder(); if (mAnonymouses.setUserDisplayedName(user, displayedName)) { if (mAnonymouses.getDisplayedName(user) == null) { log.info("User {} set a name '{}'", user.getId(), displayedName); sb.append("Your displayed name: '").append(displayedName) .append("'. Now you can send messages to bot!"); } else { log.info("User {} has changed name to '{}'", user.getId(), displayedName); sb.append("Your new displayed name: '").append(displayedName).append("'."); } } else { log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to set taken name '{}'", user.getId(), displayedName); sb.append("Name ").append(displayedName).append(" is already in use! Choose another name!"); } message.setText(sb.toString()); execute(absSender, message, user); } private String getName(String[] strings) { if (strings == null || strings.length == 0) { return null; } String name = String.join(" ", strings); return name.replaceAll(" ", "").isEmpty() ? null : name; } }

  • /my_name - exibe o nome de usuário atual;

MyNameCommand.java
 package io.example.anonymizerbot.command; import io.example.anonymizerbot.logger.LogLevel; import io.example.anonymizerbot.logger.LogTemplate; import io.example.anonymizerbot.service.AnonymousService; import org.apache.logging.log4j.Level; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.Chat; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.bots.AbsSender; public final class MyNameCommand extends AnonymizerCommand { private final AnonymousService mAnonymouses; public MyNameCommand(AnonymousService anonymouses) { super("my_name", "show your current name that will be displayed with your messages\n"); mAnonymouses = anonymouses; } @Override public void execute(AbsSender absSender, User user, Chat chat, String[] strings) { log.info(LogTemplate.COMMAND_PROCESSING.getTemplate(), user.getId(), getCommandIdentifier()); StringBuilder sb = new StringBuilder(); SendMessage message = new SendMessage(); message.setChatId(chat.getId().toString()); if (!mAnonymouses.hasAnonymous(user)) { sb.append("You are not in bot users' list! Send /start command!"); log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to execute '{}' without starting the bot.", user.getId(), getCommandIdentifier()); } else if(mAnonymouses.getDisplayedName(user) == null) { sb.append("Currently you don't have a name.\nSet it using command:\n'/set_name &lt;displayed_name&gt;'"); log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to execute '{}' without having a name.", user.getId(), getCommandIdentifier()); } else { log.info("User {} is executing '{}'. Name is '{}'.", user.getId(), getCommandIdentifier(), mAnonymouses.getDisplayedName(user)); sb.append("Your current name: ").append(mAnonymouses.getDisplayedName(user)); } message.setText(sb.toString()); execute(absSender, message, user); } }

  • /stop - remove o usuário da coleção anônima.

StopCommand.java
 package io.example.anonymizerbot.command; import io.example.anonymizerbot.logger.LogLevel; import io.example.anonymizerbot.logger.LogTemplate; import io.example.anonymizerbot.service.AnonymousService; import org.apache.logging.log4j.Level; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.Chat; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.bots.AbsSender; public final class StopCommand extends AnonymizerCommand { private final AnonymousService mAnonymouses; public StopCommand(AnonymousService anonymouses) { super("stop", "remove yourself from bot users' list\n"); mAnonymouses = anonymouses; } @Override public void execute(AbsSender absSender, User user, Chat chat, String[] strings) { log.info(LogTemplate.COMMAND_PROCESSING.getTemplate(), user.getId(), getCommandIdentifier()); StringBuilder sb = new StringBuilder(); SendMessage message = new SendMessage(); message.setChatId(chat.getId().toString()); if (mAnonymouses.removeAnonymous(user)) { log.info("User {} has been removed from users list!", user.getId()); sb.append("You've been removed from bot's users list! Bye!"); } else { log.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to execute '{}' without having executed 'start' before!", user.getId(), getCommandIdentifier()); sb.append("You were not in bot users' list. Bye!"); } message.setText(sb.toString()); execute(absSender, message, user); } }

3. Inicialização e lançamento do bot


Uma classe bot na qual todos os comandos personalizados, um manipulador de mensagens de não comandos e comandos desconhecidos são registrados.


AnonymizerBot.java
 package io.example.anonymizerbot.bot; import io.example.anonymizerbot.command.*; import io.example.anonymizerbot.logger.LogLevel; import io.example.anonymizerbot.logger.LogTemplate; import io.example.anonymizerbot.model.Anonymous; import io.example.anonymizerbot.service.AnonymousService; import org.apache.logging.log4j.Level; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.telegram.telegrambots.bots.DefaultBotOptions; import org.telegram.telegrambots.extensions.bots.commandbot.TelegramLongPollingCommandBot; import org.telegram.telegrambots.meta.api.methods.send.SendMessage; import org.telegram.telegrambots.meta.api.objects.Message; import org.telegram.telegrambots.meta.api.objects.Update; import org.telegram.telegrambots.meta.api.objects.User; import org.telegram.telegrambots.meta.exceptions.TelegramApiException; import java.util.stream.Stream; public final class AnonymizerBot extends TelegramLongPollingCommandBot { private static final Logger LOG = LogManager.getLogger(AnonymizerBot.class); //  ,        BotFather //  ,     private static final String BOT_NAME = "AnonymizerBotExample"; private static final String BOT_TOKEN = "7xxxxxxx2:Axxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx0"; private final AnonymousService mAnonymouses; public AnonymizerBot(DefaultBotOptions botOptions) { super(botOptions, BOT_NAME); LOG.info("Initializing Anonymizer Bot..."); LOG.info("Initializing anonymouses list..."); mAnonymouses = new AnonymousService(); //     LOG.info("Registering commands..."); LOG.info("Registering '/start'..."); register(new StartCommand( mAnonymouses)); LOG.info("Registering '/set_name'..."); register(new SetNameCommand(mAnonymouses)); LOG.info("Registering '/stop'..."); register(new StopCommand(mAnonymouses)); LOG.info("Registering '/my_name'..."); register(new MyNameCommand(mAnonymouses)); HelpCommand helpCommand = new HelpCommand(this); LOG.info("Registering '/help'..."); register(helpCommand); //    LOG.info("Registering default action'..."); registerDefaultAction(((absSender, message) -> { LOG.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to execute unknown command '{}'.", message.getFrom().getId(), message.getText()); SendMessage text = new SendMessage(); text.setChatId(message.getChatId()); text.setText(message.getText() + " command not found!"); try { absSender.execute(text); } catch (TelegramApiException e) { LOG.error("Error while replying unknown command to user {}.", message.getFrom(), e); } helpCommand.execute(absSender, message.getFrom(), message.getChat(), new String[] {}); })); } @Override public String getBotToken() { return BOT_TOKEN; } //      '/' @Override public void processNonCommandUpdate(Update update) { LOG.info("Processing non-command update..."); if (!update.hasMessage()) { LOG.error("Update doesn't have a body!"); throw new IllegalStateException("Update doesn't have a body!"); } Message msg = update.getMessage(); User user = msg.getFrom(); LOG.info(LogTemplate.MESSAGE_PROCESSING.getTemplate(), user.getId()); if (!canSendMessage(user, msg)) { return; } String clearMessage = msg.getText(); String messageForUsers = String.format("%s:\n%s", mAnonymouses.getDisplayedName(user), msg.getText()); SendMessage answer = new SendMessage(); //     ,     answer.setText(clearMessage); answer.setChatId(msg.getChatId()); replyToUser(answer, user, clearMessage); //       answer.setText(messageForUsers); Stream<Anonymous> anonymouses = mAnonymouses.anonymouses(); anonymouses.filter(a -> !a.getUser().equals(user)) .forEach(a -> { answer.setChatId(a.getChat().getId()); sendMessageToUser(answer, a.getUser(), user); }); } //  ,        private boolean canSendMessage(User user, Message msg) { SendMessage answer = new SendMessage(); answer.setChatId(msg.getChatId()); if (!msg.hasText() || msg.getText().trim().length() == 0) { LOG.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to send empty message!", user.getId()); answer.setText("You shouldn't send empty messages!"); replyToUser(answer, user, msg.getText()); return false; } if(!mAnonymouses.hasAnonymous(user)) { LOG.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to send message without starting the bot!", user.getId()); answer.setText("Firstly you should start bot! Use /start command!"); replyToUser(answer, user, msg.getText()); return false; } if (mAnonymouses.getDisplayedName(user) == null) { LOG.log(Level.getLevel(LogLevel.STRANGE.getValue()), "User {} is trying to send message without setting a name!", user.getId()); answer.setText("You must set a name before sending messages.\nUse '/set_name <displayed_name>' command."); replyToUser(answer, user, msg.getText()); return false; } return true; } private void sendMessageToUser(SendMessage message, User receiver, User sender) { try { execute(message); LOG.log(Level.getLevel(LogLevel.SUCCESS.getValue()), LogTemplate.MESSAGE_RECEIVED.getTemplate(), receiver.getId(), sender.getId()); } catch (TelegramApiException e) { LOG.error(LogTemplate.MESSAGE_LOST.getTemplate(), receiver.getId(), sender.getId(), e); } } private void replyToUser(SendMessage message, User user, String messageText) { try { execute(message); LOG.log(Level.getLevel(LogLevel.SUCCESS.getValue()), LogTemplate.MESSAGE_SENT.getTemplate(), user.getId(), messageText); } catch (TelegramApiException e) { LOG.error(LogTemplate.MESSAGE_EXCEPTION.getTemplate(), user.getId(), e); } } }

Por fim, inicie o bot:


BotInitializer.java
 package io.example.anonymizerbot; import io.example.anonymizerbot.bot.AnonymizerBot; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.telegram.telegrambots.ApiContextInitializer; import org.telegram.telegrambots.bots.DefaultBotOptions; import org.telegram.telegrambots.meta.ApiContext; import org.telegram.telegrambots.meta.TelegramBotsApi; import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException; public final class BotInitializer { private static final Logger LOG = LogManager.getLogger(BotInitializer.class); private static final String PROXY_HOST = "xx.xx.xxx.xxx"; private static final int PROXY_PORT = 9999; public static void main(String[] args) { try { LOG.info("Initializing API context..."); ApiContextInitializer.init(); TelegramBotsApi botsApi = new TelegramBotsApi(); LOG.info("Configuring bot options..."); DefaultBotOptions botOptions = ApiContext.getInstance(DefaultBotOptions.class); botOptions.setProxyHost(PROXY_HOST); botOptions.setProxyPort(PROXY_PORT); botOptions.setProxyType(DefaultBotOptions.ProxyType.SOCKS4); LOG.info("Registering Anonymizer..."); botsApi.registerBot(new AnonymizerBot(botOptions)); LOG.info("Anonymizer bot is ready for work!"); } catch (TelegramApiRequestException e) { LOG.error("Error while initializing bot!", e); } } }

Isso é tudo! O bot está pronto para os primeiros testes.


Exemplo de uso


Como exemplo, considere o seguinte cenário:


  1. 'A' começa a trabalhar com o bot ( /start );
  2. 'A' está tentando enviar uma mensagem;
  3. 'A' está tentando definir um nome ( /set_name );
  4. 'A' define o nome ( /set_name Pendalf );
  5. 'A' envia uma mensagem para outros usuários (que não são);
  6. 'B' começa a trabalhar com o bot ( /start );
  7. 'B' define o nome ( /set_name Chuck Norris );
  8. 'B' envia uma mensagem para outros usuários;
  9. 'A' vê a mensagem de 'B' e envia uma mensagem em resposta;
  10. 'B' vê a resposta de 'A' e não escreve mais para ele ...



Source: https://habr.com/ru/post/pt432548/

More articles:


All Articles