Criando um Telegram Bot em Java: da concepção à implantação

Então, o que são bots? Você pode ler mais sobre isso aqui . Para começar, você precisa revisar a documentação oficial da biblioteca usada para desenvolver bots do Telegram (doravante denominada "API"). Pode ser encontrado aqui . Tudo lá é muito acessível e claro. Parece que podemos apenas escrever código e nos alegrar! Mas não é tão simples. Depois de muito pesquisar, encontrei alguns conhecimentos sobre desenvolvimento de bots, por exemplo, como fazer um teclado, manusear umCallbackQuery, e assim por diante. Mas não encontrei um guia completo e exaustivo para o desenvolvimento de bots Java. Isso me levou a escrever este artigo. Existem muitos sites onde você pode criar seu próprio bot facilmente implantável. Mas o fato é que a maioria dos bots criados fornecem informações de referência e afins. Nosso bot é um aplicativo da Web completo. Você pode vincular um banco de dados, executar várias solicitações de API, analisar sites, realizar cálculos complexos e muito mais. As possibilidades são limitadas apenas por sua imaginação. Espero que o que foi dito acima tenha ajudado a esclarecer sobre o que vou escrever. É muito fácil registrar um bot no Telegram. Este processo é descrito em detalhes na documentação vinculada acima. Para nosso aplicativo, você só precisa saber o nome do bot e o token que você recebe ao registrar o bot. Basicamente, um bot é apenas um aplicativo da web baseado em console. Não há front-end, apenas processamento de comando puro. Se você quer dominarHiberne ou aprenda como analisar JSON , então este é o projeto para você. Vamos começar adicionando uma dependência a pom.xml(presumo que você esteja usando o Maven). Você pode fazer isso assim:

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

Em seguida, crie uma Botclasse que herde a TelegramLongPollingBotclasse e substitua seus métodos:

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 agora o conteúdo do mainmétodo:

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

Depois de preencher os métodos getBotUsername()e getBotToken(), inicie o bot. Por enquanto, ele apenas redireciona para nós todas as mensagens que enviamos para ele, como um " espelho ". Funciona assim: ao iniciar o aplicativo, ele começa a enviar requisições para o servidor do Telegram, uma vez a cada n segundos, na seguinte URL: https://api.telegram.org/BotToken/getMe , onde BotToken é o token do seu bot . Em resposta, ele recebe JSON contendo todas as mensagens. Cada uma dessas mensagens é processada pela biblioteca e passada para o OnUpdateReceived(Update update)método como umUpdateobjeto. E é com isso que trabalhamos. Aqui reside a beleza dos bots do Telegram: eles podem ser executados em qualquer computador, testá-lo requer apenas iniciar o aplicativo e você não precisa implantá-lo no host após cada alteração. Isso é muito conveniente. Claro, você pode configurar um bot para funcionar usando webhooks. Você pode encontrar instruções para isso na Internet. Para simplificar, usaremos LongPolling. Como as mensagens são processadas e o que você envia em resposta são limitados apenas pelos recursos do idioma e da biblioteca. O resto é com você. Você pode criar um bot que pesquisará vídeos do YouTube para você. Você pode criar um bot que enviará o que você mesmo envia todos os dias, como uma cápsula do tempo de um ano atrás. Ou você pode aprender a se integrar com sistemas de CRM e criar bots para pequenas empresas - você está limitado apenas pela sua imaginação. Se movendo. Quem já usou bots sabe que é conveniente interagir com eles usando comandos que começam com o /caractere " ", por exemplo, /start. Mas existe uma maneira mais conveniente: botões. Existem dois tipos de botões: os que aparecem em um campo de entrada ( ReplyKeyboardMarkup) e os botões que estão diretamente abaixo da mensagem à qual estão vinculados (InlineKeyboardMarkup). Você pode obter uma compreensão básica deles a partir de suas descrições na documentação.

ResponderMarcação de Teclado

Na realidade, esta é uma matriz de matrizes de botões: List<KeyboardRow <KeyboardButton>>. Aqui está o código de exemplo que cria um teclado:

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

Chamamos esse método no sendMsg()método, após passar uma mensagem para ele. É assim que configuramos um teclado para essa mensagem. Quando enviarmos esta mensagem ao usuário, ele verá o texto da nossa mensagem e 2 botões que dizem "Oi" e "Ajuda" , um embaixo do outro. Quando um desses botões é clicado, o bot recebe uma mensagem contendo o texto do botão. Assim, se o cliente clicar em "Ajuda" , o bot receberá uma mensagem com "Ajuda". Para o bot, parecerá que o próprio cliente escreveu "Ajuda" e enviou o texto para o bot. E então você processa as mensagens.

InlineKeyboardMarkup

Esta também é uma matriz de matrizes. É semelhante à marcação anterior, mas a lógica funciona um pouco diferente aqui. Esse tipo de teclado é anexado a uma mensagem específica e existe apenas para ela. Aqui está um método para configurar um teclado embutido:

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

Crie um Listdentro do Liste adicione o botão embutido à primeira linha. Este botão pode conter um URL, um link para um canal ou um CallbackQuery, sobre o qual escreverei um pouco mais tarde. É aqui que definimos o texto do nosso botão, que é o que o usuário verá, e depois definimos os dados que serão enviados ao bot. No nosso exemplo, o usuário vê "Oi", e quando o botão for pressionado, o número 17 será enviado ao bot. Este é o nosso CallbackQuery. Algumas palavras sobre CallbackQuery. Para obter esses dados do Updateobjeto, você precisa executar update.getCallbackQuery(). Este método retorna um CallbackQuery, a partir do qual você pode acessar os dados passados ​​para o bot. Não tente obter esses dados por meio do update.getMessage().getText()método - você obterá um arquivo 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 houver uma mensagem, nós a enviamos para um novo thread para processamento; se houver um CallbackQuery, enviamos para o thread apropriado para processamento. Você pode enviar uma resposta para um arquivo CallbackQuery. Cada objeto no Telegram tem seu próprio id. Para enviar uma resposta a um determinado CallbackQuery, basta saber seu id, que obtemos do objeto correspondente. Para enviar uma resposta, chamamos este método:

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:O texto em uma resposta a CallbackQuerynão deve ter mais de 200 caracteres! Depois de enviar essa resposta, o cliente verá uma janela pop-up contendo a mensagem. Essa janela pode desaparecer alguns segundos depois de aparecer ou pode persistir até que o usuário pressione OK. Para alternar os modos, chamamos o answer.setShowAlert(true)método. Se você passar truepara o método, a janela persiste até que OK seja pressionado. Se você passar falso, ele desaparece após 5 segundos. Esses são todos os recursos básicos da biblioteca Telegram Bot . Se você quiser, pode aprender coisas como enviar multimídia, geolocalização, etc. Vamos passar a implantar nosso bot em uma plataforma de hospedagem. Para o meu projeto, escolhi o Heroku. Acho que é uma plataforma de hospedagem bastante conveniente com sua própria CLI. É gratuito, mas neste plano seu bot irá hibernar após 30 minutos sem receber solicitações. Ele será ativado quando uma solicitação for recebida. Isso acontece tão rapidamente que você nem notará (a menos, é claro, que a conexão com o banco de dados não reinicie). O plano gratuito é limitado por um banco de dados de 5 MB, 100 MB de espaço em disco, 2 TB de dados por mês e 1 dinamômetro. Um dinamômetro é seu aplicativo em execução. Direi desde já que foi a implantação que me causou dificuldades, pois nunca havia implantado meus aplicativos antes. Durante a implantação, o Heroku requer um arquivo chamado Procfile (sem extensão). Nós o criamos na raiz do projeto. Dentro, escrevemos worker: sh target/bin/workerBot, onde workerBot é o nome especificado em pom.xml. um shscript, gerado pelo plug-in Maven Application Assembler (appassembler-maven-plugin), será iniciado. O script descreve como iniciar um arquivo jar compilado. O nome da classe a ser iniciada é especificado entre <mainClass>e </mainClass>, enquanto o nome do script é fornecido entre <name>e </name>em 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>

Antes de iniciar este processo, você deve se registrar no Heroku e instalar o Git e a CLI do Heroku . Se seu aplicativo precisar de um banco de dados, não se esqueça de adicionar o banco de dados necessário ao criar um novo aplicativo. Além disso, você precisa determinar o host, nome de usuário, senha e porta para seu banco de dados e, em seguida, indicá-los em seu aplicativo. Em seguida, antes de implantar, construa seu projeto usando Maven .

mvn clean install

Primeiro, vamos ao diretório do nosso projeto e inicializamos o repositório com o comando git init. Em seguida, adicionamos nosso projeto a este repositório.

git add .

Em seguida, confirmamos as alterações

git commit -m "First commit in the project"

Em seguida, você precisa entrar no heroku. Escreva o seguinte na linha de comando

heroku login

Insira as credenciais que você criou durante o registro. Depois disso, determine a URL do seu repositório no heroku. Você faz isso nas configurações. Então nós escrevemos

git remote add heroku [url]

Um repositório heroku remoto é adicionado ao seu repositório. Em seguida, escrevemos

git push heroku master

Então esperamos… se o aplicativo for implantado com sucesso, execute o seguinte comando

heroku ps:scale worker=1

E é isso, seu aplicativo está instalado e funcionando. Se não estiver, observe os logs com cuidado. Muito provavelmente, um erro em seu aplicativo fez com que ele falhasse. Obrigado por ler um artigo tão longo. Espero que alguém o ache útil e que economize muito tempo nas áreas que me deram problemas durante o desenvolvimento.