Creare un bot Telegram in Java: dall'idea alla distribuzione

Cosa sono comunque i bot? Puoi leggere questo in dettaglio qui . Per prima cosa devi leggere la documentazione ufficiale della libreria per lo sviluppo di bot su Telegram (di seguito denominata API). Lei giace qui . Tutto è molto accessibile e comprensibile. Sembrerebbe che scrivi e rallegrati! Ma non è così semplice. Dopo aver trascorso molto tempo sui motori di ricerca, ho trovato frammenti di conoscenze sullo sviluppo dei bot, ad esempio su come realizzare una tastiera, elaborare CallbackQuery e simili. Non ho mai trovato una guida completa ed esaustiva per lo sviluppo di bot in Java. Ciò mi ha spinto a scrivere questo articolo. Esistono molti siti su Internet in cui puoi creare il tuo bot con una distribuzione già pronta. Ma il punto è. che per la maggior parte vengono creati bot in grado di fornire informazioni di base e così via. Il nostro bot è un'applicazione web a tutti gli effetti alla quale puoi associare un database, effettuare richieste a varie API, analizzare siti, eseguire calcoli complessi, ecc. La questione è limitata solo dalla tua immaginazione. Spero di avervi spiegato un po' in queste righe di cosa andrò a scrivere. Registrare un bot su Telegram è molto semplice; questo processo è descritto in dettaglio nella documentazione al link sopra. Per la nostra applicazione ti basterà conoscere il nome del bot e il token che riceverai al momento della registrazione. Essenzialmente, un bot è solo un'applicazione web della console. Nessun frontend, pura elaborazione dei comandi. Se vuoi padroneggiare bene Hibernate o imparare come analizzare JSON, allora questo progetto fa per te. Iniziamo includendo la dipendenza in pom.xml (supponiamo che tu stia utilizzando Maven). Puoi farlo in questo modo:

<dependency>
            <groupId>org.telegram</groupId>
            <artifactId>telegrambots</artifactId>
            <version>3.5</version>
</dependency>

Quindi creiamo una classe Bot, la ereditiamo dalla classe TelegramLongPollingBot, sovrascrivendone i metodi:

public class Bot extends TelegramLongPollingBot {

    /**
     * Method for receiving messages.
     * @param update Contains a message from the user.
     */
    @Override
    public void onUpdateReceived(Update update) {
	String message = update.getMessage().getText();
	sendMsg(update.getMessage().getChatId().toString(), message);
    }

    /**
     * Method for setting up a message and sending it.
     * @param chatId chat id
     * @param s The string to send as a message.
     */
    public synchronized void sendMsg(String chatId, String s) {
        SendMessage sendMessage = new SendMessage();
        sendMessage.enableMarkdown(true);
        sendMessage.setChatId(chatId);
        sendMessage.setText(s);
        try {
            sendMessage(sendMessage);
        } catch (TelegramApiException e) {
            log.log(Level.SEVERE, "Exception: ", e.toString());
        }
    }

    /**
     * The method returns the name of the bot specified during registration.
     * @return bot name
     */
    @Override
    public String getBotUsername() {
        return ”BotName”;
    }

    /**
     * The method returns the bot's token to communicate with the Telegram server
     * @return token for the bot
     */
    @Override
    public String getBotToken() {
        return ”BotToken”;
    }
}

Bene, il contenuto del metodo main:

public static void main(String[] args) {
        ApiContextInitializer.init();
        TelegramBotsApi telegramBotsApi = new TelegramBotsApi();
        try {
            telegramBotsApi.registerBot(Bot.getBot());
        } catch (TelegramApiRequestException e) {
            e.printStackTrace();
        }
}

Inserendolo nei metodi getBotUsername()lanciamo getBotToken()il bot. Per ora si limita a reindirizzarci i messaggi che gli inviamo, una sorta di “specchio”. Funziona tutto così: quando avvii l'applicazione, inizia a inviare una richiesta GET al server Telegram una volta ogni n secondi al seguente URL: https://api.telegram.org/BotToken/getMe, dove BotToken è il token del tuo bot, ricevendo in una risposta JSON contenente tutti i messaggi. Ciascuno di questi messaggi viene elaborato dalla libreria e arriva al metodo OnUpdateReceived(Update update)come oggetto Update. Questo è ciò con cui lavoriamo. Questo è il bello dei bot di Telegram, possono funzionare su qualsiasi computer, per testarli basta avviare l'applicazione, non è necessario distribuirla sull'hosting dopo ogni modifica. È molto comodo Naturalmente il bot può essere configurato per funzionare tramite webhook; il manuale è reperibile su Internet; per semplicità lavoreremo utilizzando LongPolling. Come elaborare i messaggi e cosa inviare in risposta è limitato solo dagli strumenti linguistici e dalla libreria, tutto il resto è a tua discrezione. Puoi creare un bot che cercherà video su YouTube per te, puoi creare un bot che ogni giorno ti invierà ciò che invii a te stesso, ad esempio, in un anno, una sorta di capsula del tempo. Oppure puoi imparare come integrarti nei sistemi CRM e creare bot per le piccole imprese, tutto è limitato dalla tua immaginazione. Andare avanti. Chi ha utilizzato i bot sa che è conveniente interagire con essi utilizzando i comandi che iniziano con il segno «/», ad esempio /start. Ma esiste un modo più conveniente: i pulsanti. Esistono due tipi di pulsanti: quelli che appaiono sotto il campo di input ReplyKeyboardMarkupe i pulsanti che appaiono direttamente sotto il messaggio a cui sono collegati InlineKeyboardMarkup. Nella documentazione puoi familiarizzare brevemente con la loro descrizione. RispondiKeyboardMarkup. Essenzialmente si tratta di una serie di matrici di pulsanti, List<KeyboardRow<KeyboardButton>>. Ecco un codice di esempio che crea la tastiera

public synchronized void setButtons(SendMessage sendMessage) {
        // Create a keyboard
        ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
        sendMessage.setReplyMarkup(replyKeyboardMarkup);
        replyKeyboardMarkup.setSelective(true);
        replyKeyboardMarkup.setResizeKeyboard(true);
        replyKeyboardMarkup.setOneTimeKeyboard(false);

        // Create a list of keyboard strings
        List<KeyboardRow> keyboard = new ArrayList<>();

        // First line of the keyboard
        KeyboardRow keyboardFirstRow = new KeyboardRow();
        // Add buttons to the first line of the keyboard
        keyboardFirstRow.add(new KeyboardButton(“Привет”));

        // Second line of the keyboard
        KeyboardRow keyboardSecondRow = new KeyboardRow();
        // Add buttons to the second line of the keyboard
        keyboardSecondRow.add(new KeyboardButton(“Помощь”);

        // Add all keyboard strings to the list
        keyboard.add(keyboardFirstRow);
        keyboard.add(keyboardSecondRow);
        // and set this list to our keyboard
        replyKeyboardMarkup.setKeyboard(keyboard);
    }

In un metodo sendMsg()chiamiamo questo metodo passandogli un messaggio, impostando così la tastiera per quel messaggio. Quando inviamo questo messaggio all'utente, vedrà il testo del messaggio che abbiamo impostato, così come 2 pulsanti che dicono Ciao e Aiuto, uno accanto all'altro. Cliccando su questi pulsanti verrà inviato al bot un messaggio il cui testo è quello scritto sul pulsante. Cioè, se il client fa clic su "Aiuto", il bot riceverà un messaggio con il testo "Aiuto". Per lui è come se il cliente stesso avesse scritto il testo "Aiuto" e glielo avesse inviato. Bene, allora elabori tali messaggi. InlineKeyboardMarkup Anche questo è un array di array, è simile al Markup precedente, ma la logica di funzionamento qui è leggermente diversa. Tale tastiera è legata a un messaggio specifico ed esiste solo per esso. Ecco il metodo per installare la tastiera in linea

private void setInline() {
        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
        List<InlineKeyboardButton> buttons1 = new ArrayList<>();
        buttons1.add(new InlineKeyboardButton().setText(“Кнопка“).setCallbackData(17));
        buttons.add(buttons1);

        InlineKeyboardMarkup markupKeyboard = new InlineKeyboardMarkup();
        markupKeyboard.setKeyboard(buttons);
    }

Crea Listin List, aggiungi un pulsante Inline alla prima riga. Tale pulsante può contenere un URL, un collegamento a un canale o CallbackQuery, di cui parlerò più avanti. Qui impostiamo il testo per il nostro pulsante che l'utente vedrà e poi impostiamo i dati che verranno inviati al bot. Nel nostro esempio, l'utente vede "Ciao" e, quando viene cliccato, al bot verrà inviato il numero 17, questo è il nostro file CallbackQuery. Qualche parola su CallbackQuery. Per ottenere tali dati da un oggetto Updateè necessario eseguire update.getCallbackQuery(), questo metodo restituisce CallbackQuery, da cui è già possibile ottenere i dati trasferiti al bot. Non è necessario provare a ottenere questi dati tramite il metodo update.getMessage().getText()get NullPointerException.

@Override
    public void onUpdateReceived(Update update) {
        if(update.hasMessage()) {
            ThreadClass thread = new ThreadClass(update.getMessage());
        } else  if(update.hasCallbackQuery()) {
            AnswerCallbackThread answerThread = new AnswerCallbackThread(update.getCallbackQuery());
        }
    }

Se c'è un messaggio, inviamo il messaggio per l'elaborazione a un nuovo thread; se c'è un messaggio CallbackQuery, lo inviamo per l'elaborazione al thread appropriato. Puoi CallbackQueryinviare una risposta. Ogni oggetto in Telegram ha il proprio ID. Per inviare una risposta a uno specifico, CallbackQuerydobbiamo solo conoscere il suo ID, che riceveremo dall'oggetto corrispondente. Per inviare una risposta, chiama questo metodo:

public synchronized void answerCallbackQuery(String callbackId, String message) {
        AnswerCallbackQuery answer = new AnswerCallbackQuery();
        answer.setCallbackQueryId(callbackId);
        answer.setText(message);
        answer.setShowAlert(true);
        try {
            answerCallbackQuery(answer);
        } catch (TelegramApiException e) {
            e.printStackTrace();
        }
    }

IMPORTANTE:Il testo nella risposta CallbackQuerynon deve essere più lungo di 200 caratteri! Quando si invia tale risposta, il client riceverà una finestra pop-up in cui verrà scritto il messaggio. Tale finestra potrebbe scomparire alcuni secondi dopo la sua visualizzazione oppure potrebbe rimanere bloccata finché l'utente non preme OK. Per cambiare queste modalità, chiamiamo answer.setShowAlert(true). Quando truela finestra si blocca finché non si preme OK, quindi falsescompare dopo 5 secondi. In linea di principio, queste sono tutte le funzionalità di base della libreria bot di Telegram. Se lo desideri, puoi imparare dalla documentazione cose come l'invio di contenuti multimediali, la geolocalizzazione, ecc. Passiamo alla distribuzione del nostro bot sull'hosting. Per il mio progetto ho scelto Heroku, perché secondo me è un hosting abbastanza conveniente che dispone di una propria CLI. È gratuito, ma a questa velocità il tuo bot andrà in ibernazione dopo 30 minuti se non ci sono richieste. Quando gli viene inviata una richiesta, si sveglia. Ciò accade abbastanza rapidamente, non te ne accorgerai nemmeno (a meno che, ovviamente, la connessione al database non venga ristabilita). Il limite del piano gratuito è di 5 MB di database, 100 MB di spazio su disco, 2 TB di traffico al mese, 1 dinosauro. Dino è la tua applicazione in esecuzione. Dirò subito che è stata la fase di distribuzione a crearmi difficoltà, poiché non avevo mai distribuito le mie applicazioni prima. Durante la distribuzione, Heroku richiede un file denominato Procfile (senza estensione). Lo creiamo nella radice del progetto, scriviamo lì worker: sh target/bin/workerBot workBot : il nome che specifichiamo in pom.xml Verrà avviato lo script sh generato utilizzando il plugin Maven appassembler-maven-plugin. Lo script descrive l'esecuzione del jar compilato. Il nome della classe da lanciare è indicato tra <mainClass></mainClass>, il nome dello script tra <name></name> pom.xml:

...
<build>
    <plugins>
        ...
       <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>appassembler-maven-plugin</artifactId>
            <version>1.1.1</version>
            <configuration>
                <assembleDirectory>target</assembleDirectory>
                <programs>
                    <program>
                        <mainClass>com.home.server.TelegramBot</mainClass>
                        <name>workerBot</name>
                    </program>
                </programs>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>assemble</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Prima di iniziare questo processo, dovresti registrarti su Heroku, installare Git e la CLI di Heroku. Se la tua applicazione richiede un database, quando registri una nuova applicazione, non dimenticare di aggiungere il database di cui hai bisogno. Successivamente, devi scoprire l'host, il nome utente, la password e la porta del tuo database, quindi specificarlo nella tua applicazione. Successivamente, prima della distribuzione, crea il tuo progetto utilizzando Maven.

mvn clean install

Per cominciare, andiamo nella directory del nostro progetto, inizializziamo il repository con il comandogit init Quindi aggiungiamo il nostro progetto a questo repository

git add .

Dopo aver confermato le modifiche

git commit -m “First commit in project”

Successivamente devi accedere a heroku, scrivere nella riga di comando

heroku login

Inserisci i dati specificati in fase di registrazione. Quindi devi scoprire l'URL del tuo repository su Heroku, questo viene fatto nelle impostazioni. Allora scriviamo

git remote add heroku [url]

Il repository remoto heroku verrà aggiunto al tuo repository. Successivamente scriviamo

git push heroku master

Stiamo aspettando... Se la distribuzione dell'applicazione ha esito positivo, eseguiamo il comando

heroku ps:scale worker=1

E questo è tutto, la tua applicazione è in esecuzione. Se ciò non accade, guarda attentamente i log: molto probabilmente c'è un errore nella tua applicazione che ne ha causato il crash. Grazie per aver letto un articolo così lungo, spero che qualcuno lo trovi utile e mi faccia risparmiare molto tempo nei punti in cui sono incappato durante lo sviluppo.