Geekly articles weekly

Ein Beispiel für die Verwendung einer Java-Bibliothek zum Erstellen eines Telegramm-Bots

Jeder Entwickler (und nicht nur), der Telegramm im Alltag verwendet, hat mindestens einmal darüber nachgedacht, wie es sich anfühlt, einen eigenen Bot zu erstellen, wie schwierig es ist und welche Programmiersprache am besten zu verwenden ist.


Ich kann all diese Fragen am einfachsten (und wahrscheinlich am richtigsten) beantworten: Alles hängt von Ihnen selbst, Ihrem Wissen und Ihren Absichten ab.


... Aber in diesem kurzen Artikel werde ich zeigen, wie Sie Ihren eigenen Bot in der Java-Sprache erstellen können und dass er sehr interessant und unkompliziert ist.


Wir werden die Bibliothek für die Arbeit mit der Telegram Bots-API und ihrer Erweiterung verwenden , mit der wir unsere eigenen Befehle (' /custom_cmd ') erstellen und auf einfache Weise verarbeiten können.


Die Aufgabe des Bots besteht darin, den Benutzer zu registrieren und eine Nachricht mit dem angegebenen Namen an andere Bot-Benutzer zu senden.


Erstellung eines neuen Projekts und Vorbereitung


1. Fügen Sie dem Projekt Abhängigkeiten hinzu


Erstellen Sie ein neues Maven-Projekt, bearbeiten Sie die Datei pom.xml und fügen Sie die erforderlichen Abhängigkeiten hinzu:


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>

Telegramm-API - Eine Bibliothek für die Arbeit mit der Telegramm-Bots-API , die Klassen und Methoden für die Interaktion mit Telegrammdiensten und einige Erweiterungen dieser Klassen enthält.


2. Erstellen Sie ein Konto für den Bot


Dazu müssen wir den BotFather-Bot um Hilfe bitten:


  • finde den Bot in der Suche;
  • Führen Sie den Befehl "/ start" aus.
  • Führen Sie den Befehl "/ newbot" aus.
  • Lassen Sie uns einen Namen für unseren Bot setzen (er sollte mit "Bot" enden). Ich nannte es "ExampleOfAnonymizerBot".

Nach dem Ausführen dieser Befehle erhalten wir das Token, das wir zur Verwendung der Bot-API benötigen. (7xxxxxxx2: Axxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)






Implementierung


1. Modell des anonymen Absenders von Nachrichten


Die Daten, die wir von jedem Benutzer benötigen:


  • User mUser - Informationen über den Telegrammbenutzer;
  • Chat mChat - Benutzer- und Bot-Chat-Informationen;
  • String mDisplayedName - Der Name, von dem aus der Benutzer Nachrichten an andere Benutzer des Bots sendet.

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

Fügen Sie einen Dienst hinzu, der häufig verwendete Methoden zum Bearbeiten vieler anonymer Benutzer enthält.


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. Bot-Schnittstelle


Jeder benutzerdefinierte Befehl sollte von BotCommand erben und eine Methode implementieren
execute(AbsSender sender, User user, Chat chat, String[] strings) , mit dem Benutzerbefehle verarbeitet werden.


Nachdem wir den Befehl des Benutzers verarbeitet haben, können wir ihm eine Antwort mit der execute der AbsSender Klasse AbsSender , die die oben erwähnte execute(AbsSender sender, User user, Chat chat, String[] strings) .


Im Folgenden erstellen wir die AnonymizerCommand Klasse, um nicht jedes Mal die AbsSender.execute Methode zu AbsSender.execute , die eine TelegramApiException in try-catch AbsSender.execute kann, und um nicht in jedem Befehl monotone Protokolle zu schreiben, und erben unsere benutzerdefinierten Befehle davon (In diesem Beispiel wird die Ausnahmebehandlung beibehalten.):


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

Definieren Sie die Befehle, auf die unser Bot reagiert:


  • /start - Erstelle einen neuen Anonymous ohne Namen und füge ihn der Anonymouses Sammlung hinzu.

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 - ICommandRegistry dem Benutzer Informationen zu allen verfügbaren Befehlen an (der Konstruktor unterscheidet sich von anderen darin, dass Sie ICommandRegistry übergeben ICommandRegistry , das alle benutzerdefinierten Befehle enthält).

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 Benutzer einen Namen fest, von dem anonyme Nachrichten gesendet werden.

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 - zeigt den aktuellen Benutzernamen an;

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 - Entfernt den Benutzer aus der anonymen Sammlung.

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. Initialisierung und Start des Bots


Eine Bot-Klasse, in der alle benutzerdefinierten Befehle, ein Nachrichtenhandler für Nichtbefehle und unbekannte Befehle registriert sind.


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

Starten Sie zum Schluss den 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); } } }

Das ist alles! Der Bot ist bereit für die ersten Tests.


Anwendungsbeispiel


Stellen Sie sich als Beispiel das folgende Szenario vor:


  1. 'A' beginnt mit dem Bot zu arbeiten ( /start );
  2. 'A' versucht eine Nachricht zu senden;
  3. 'A' versucht einen Namen zu setzen ( /set_name );
  4. 'A' setzt den Namen ( /set_name Pendalf );
  5. 'A' sendet eine Nachricht an andere Benutzer (die es nicht sind);
  6. 'B' beginnt mit dem Bot zu arbeiten ( /start );
  7. 'B' setzt den Namen ( /set_name Chuck Norris );
  8. 'B' sendet eine Nachricht an andere Benutzer;
  9. 'A' sieht die Nachricht von 'B' und sendet eine Nachricht als Antwort;
  10. 'B' sieht die Antwort von 'A' und schreibt nicht mehr an ihn ...



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

More articles:


All Articles