Creazione di un Telegram Bot in Java: dall'ideazione alla distribuzione

Quindi cosa sono i bot? Puoi leggere di più su questo qui . Per iniziare, è necessario esaminare la documentazione ufficiale della libreria utilizzata per sviluppare i bot di Telegram (di seguito "API"). Può essere trovato qui . Tutto è molto accessibile e chiaro. Sembra che possiamo semplicemente scrivere codice e gioire! Ma non è così semplice. Dopo aver dedicato molto tempo alla ricerca, ho trovato bocconcini di conoscenza sullo sviluppo di bot, ad esempio come creare una tastiera, gestire unCallbackQuery, e così via. Ma non ho trovato una guida completa ed esaustiva per lo sviluppo di bot Java. Questo mi ha spinto a scrivere questo articolo. Esistono molti siti Web in cui è possibile creare il proprio bot facilmente distribuibile. Ma il fatto è che la maggior parte dei robot creati fornisce informazioni di riferimento e simili. Il nostro bot è un'applicazione web a tutti gli effetti. Puoi associare un database, eseguire varie richieste API, analizzare siti Web, eseguire calcoli complessi e altro ancora. Le possibilità sono limitate solo dalla tua immaginazione. Spero che quanto sopra abbia contribuito a chiarire ciò che sto per scrivere. È molto facile registrare un bot su Telegram. Questo processo è descritto in dettaglio nella documentazione collegata sopra. Per la nostra applicazione, devi solo conoscere il nome del bot e il token che ricevi al momento della registrazione del bot. Fondamentalmente, un bot è solo un'applicazione web basata su console. Non esiste un front-end, solo pura elaborazione dei comandi. Se vuoi padroneggiareHibernate o impara ad analizzare JSON , allora questo è il progetto che fa per te. Iniziamo aggiungendo una dipendenza a pom.xml(presumo che tu stia usando Maven). Puoi farlo in questo modo:

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

Quindi crea una Botclasse che erediti la TelegramLongPollingBotclasse e sovrascrivi i suoi 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 creating a message and sending it.
     * @param chatId chat id
     * @param s The String that you want 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());
        }
    }

    /**
     * This method returns the bot's name, which was specified during registration.
     * @return bot name
     */
    @Override
    public String getBotUsername() {
        return "BotName";
    }

    /**
     * This method returns the bot's token for communicating with the Telegram server
     * @return the bot's token
     */
    @Override
    public String getBotToken() {
        return "BotToken";
    }
}

E ora il contenuto del mainmetodo:

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

Dopo aver compilato i metodi getBotUsername()e getBotToken(), avviare il bot. Per ora, si limita a reindirizzare a noi tutti i messaggi che gli inviamo, una specie di " specchio ". Funziona così: quando avvii l'applicazione, inizia a inviare richieste al server Telegram, una volta ogni n secondi, al seguente URL: https://api.telegram.org/BotToken/getMe , dove BotToken è il token del tuo bot . In risposta, riceve JSON contenente tutti i messaggi. Ciascuno di questi messaggi viene elaborato dalla libreria e passato al OnUpdateReceived(Update update)metodo come messaggioUpdateoggetto. Ed è quello con cui lavoriamo. Qui sta la bellezza dei bot di Telegram: possono essere eseguiti su qualsiasi computer, testarlo richiede solo l'avvio dell'applicazione e non è necessario distribuirlo all'host dopo ogni modifica. Questo è molto conveniente. Naturalmente, puoi configurare un bot in modo che funzioni utilizzando i webhook. Puoi trovare indicazioni per questo su Internet. Per semplicità, useremo LongPolling. Il modo in cui i messaggi vengono elaborati e ciò che invii in risposta sono limitati solo dalle capacità della lingua e della libreria. Tutto il resto dipende da te. Puoi creare un bot che cercherà i video di YouTube per te. Puoi creare un bot che ti mandi ciò che ti invii ogni giorno, come una capsula del tempo di un anno fa. Oppure puoi imparare a integrarti con i sistemi CRM e creare bot per le piccole imprese: sei limitato solo dalla tua immaginazione. Andare avanti. Chi ha utilizzato i bot sa che conviene interagire con essi utilizzando comandi che iniziano con il /carattere " ", ad esempio /start. Ma c'è un modo più conveniente: i pulsanti. Esistono due tipi di pulsanti: quelli che appaiono sotto un campo di input ( ReplyKeyboardMarkup) e i pulsanti che si trovano direttamente sotto il messaggio a cui sono collegati (InlineKeyboardMarkup). Puoi ottenere una comprensione di base di loro dalle loro descrizioni nella documentazione.

RispondiKeyboardMarkup

In realtà, questo è un array di array di pulsanti: List<KeyboardRow <KeyboardButton>>. Ecco un esempio di codice che crea una 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 rows
        List<KeyboardRow> keyboard = new ArrayList<>();

        // First keyboard row
        KeyboardRow keyboardFirstRow = new KeyboardRow();
        // Add buttons to the first keyboard row
        keyboardFirstRow.add(new KeyboardButton("Hi"));

        // Second keyboard row
        KeyboardRow keyboardSecondRow = new KeyboardRow();
        // Add the buttons to the second keyboard row
        keyboardSecondRow.add(new KeyboardButton("Help");

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

Chiamiamo questo metodo nel sendMsg()metodo, dopo avergli passato un messaggio. Ecco come abbiamo impostato una tastiera per quel messaggio. Quando inviamo questo messaggio all'utente, vedrà il testo del nostro messaggio e 2 pulsanti che dicono "Ciao" e "Aiuto" , uno sotto l'altro. Quando si fa clic su uno di questi pulsanti, al bot viene inviato un messaggio contenente il testo del pulsante. Quindi, se il client fa clic su "Aiuto" , il bot riceverà un messaggio con "Aiuto". Al bot sembrerà che il client stesso abbia scritto "Aiuto" e inviato il testo al bot. E poi elabori i messaggi.

InlineKeyboardMarkup

Anche questo è un array di array. È simile al Markup precedente, ma qui la logica funziona in modo leggermente diverso. Questo tipo di tastiera è collegato a un messaggio specifico ed esiste solo per esso. Ecco un metodo per configurare una tastiera in linea:

private void setInline() {
        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
        List<InlineKeyboardButton> buttons1 = new ArrayList<>();
        buttons1.add(new InlineKeyboardButton().setText("Button").setCallbackData(17));
        buttons.add(buttons1);

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

Crea un Listall'interno di Liste aggiungi il pulsante in linea alla prima riga. Questo pulsante può contenere un URL, un collegamento a un canale o un CallbackQuery, di cui parlerò tra poco. Qui è dove impostiamo il testo del nostro pulsante, che è ciò che l'utente vedrà, e poi impostiamo i dati che verranno inviati al bot. Nel nostro esempio, l'utente vede "Ciao", e quando il pulsante viene premuto il numero 17 verrà inviato al bot. Questo è il nostro CallbackQuery. Qualche parola in merito CallbackQuery. Per ottenere questi dati dall'oggetto Update, è necessario eseguire update.getCallbackQuery(). Questo metodo restituisce un CallbackQuery, da cui è possibile accedere ai dati passati al bot. Non cercare di ottenere questi dati attraverso il update.getMessage().getText()metodo: otterrai un file 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, lo inviamo a un nuovo thread per l'elaborazione; se c'è un CallbackQuery, lo inviamo al thread appropriato per l'elaborazione. Puoi inviare una risposta a un CallbackQuery. Ogni oggetto in Telegram ha il proprio ID. Per inviare una risposta a uno specifico CallbackQuery, è sufficiente conoscerne l'id, che otteniamo dall'oggetto corrispondente. Per inviare una risposta, chiamiamo 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 in una risposta a CallbackQuerynon deve superare i 200 caratteri! Dopo aver inviato tale risposta, il client vedrà una finestra pop-up contenente il messaggio. Questa finestra può scomparire pochi secondi dopo essere apparsa oppure può persistere finché l'utente non preme OK. Per cambiare modalità, chiamiamo il answer.setShowAlert(true)metodo. Se si passa trueal metodo, la finestra persiste fino a quando non si preme OK. Se passi falso, scompare dopo 5 secondi. Queste sono tutte le funzionalità di base della libreria Telegram Bot . Se vuoi, puoi imparare cose come come inviare contenuti multimediali, geolocalizzazione, ecc. Passiamo alla distribuzione del nostro bot su una piattaforma di hosting. Per il mio progetto ho scelto Heroku. Penso che sia una piattaforma di hosting piuttosto conveniente con la propria CLI. È gratuito, ma con questo piano il tuo bot andrà in letargo dopo 30 minuti senza ricevere richieste. Si sveglierà quando viene ricevuta una richiesta. Questo accade così rapidamente che non te ne accorgerai nemmeno (a meno che, ovviamente, la connessione al database non si riavvii). Il piano gratuito è limitato da un database da 5 MB, 100 MB di spazio su disco, 2 TB di dati al mese e 1 dyno. Un banco prova è la tua applicazione in esecuzione. Dirò subito che è stata la distribuzione a causarmi difficoltà, poiché non avevo mai distribuito le mie applicazioni prima. Durante la distribuzione, Heroku richiede un file denominato Procfile (senza estensione). Lo creiamo nella root del progetto. All'interno scriviamo worker: sh target/bin/workerBot, dove workerBot è il nome specificato in pom.xml. Una merdascript, generato dal plug-in Maven Application Assembler (appassembler-maven-plugin), verrà avviato. Lo script descrive come avviare un file jar compilato. Il nome della classe da lanciare è specificato tra <mainClass>e </mainClass>, mentre il nome dello script è specificato tra <name>e </name>in 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, devi registrarti su Heroku e installare sia Git che Heroku CLI . Se la tua applicazione necessita di un database, non dimenticare di aggiungere il database richiesto quando crei una nuova applicazione. Inoltre, è necessario determinare l'host, il nome utente, la password e la porta del database e quindi indicarli nell'applicazione. Successivamente, prima della distribuzione, crea il tuo progetto utilizzando Maven .

mvn clean install

Per prima cosa, andiamo nella directory del nostro progetto e inizializziamo il repository con il comando git init. Quindi aggiungiamo il nostro progetto a questo repository.

git add .

Quindi applichiamo le modifiche

git commit -m "First commit in the project"

Successivamente, devi accedere a heroku. Scrivi quanto segue sulla riga di comando

heroku login

Inserisci le credenziali che hai creato durante la registrazione. Successivamente, determina l'URL del tuo repository su heroku. Puoi farlo nelle impostazioni. Poi scriviamo

git remote add heroku [url]

Viene aggiunto un repository heroku remoto per il tuo repository. Quindi scriviamo

git push heroku master

Quindi aspettiamo... se l'applicazione viene distribuita correttamente, esegui il seguente comando

heroku ps:scale worker=1

E questo è tutto, la tua applicazione è attiva e funzionante. In caso contrario, esaminare attentamente i registri. Molto probabilmente, un errore nell'applicazione ne ha causato il fallimento. Grazie per aver letto un articolo così lungo. Spero che qualcuno lo trovi utile e che ti faccia risparmiare molto tempo nelle aree che mi hanno dato problemi durante lo sviluppo.