PARTE 1 Olá! No artigo anterior criamos um bot simples que nos recebia em qualquer evento. Já escrevemos milhares de linhas de código e é hora de adicionar funcionalidades mais complexas ao nosso bot. Hoje tentaremos escrever um bot simples para que em nosso tempo livre possamos aprimorar nosso conhecimento de Java Core antes das entrevistas (surpreendentemente, não encontrei um único bot funcional desse tipo). Para fazer isso, faremos o seguinte:
- conecte um banco de dados Postgres externo ao Heroku;
- Vamos escrever nossos primeiros scripts para inicializar e preencher o banco de dados;
- vamos conectar o Spring Boot Data JPA para trabalhar com o banco de dados;
- Implementamos vários cenários de comportamento de bot.
- cadastre-se no Heroku ;
- Acesse nosso painel -> Novo -> Criar novo aplicativo e crie um novo aplicativo;
- Entramos no aplicativo recém-criado, ficamos intimidados com os vários botões, mas nos concentramos no painel “Complementos instalados” - ao lado dele há um botão Configurar Complementos, clicamos nele;
- Digite “Heroku Postgres” na busca, selecione o plano “Hobby Dev - Free” -> Enviar Formulário de Pedido;
- Abra o banco de dados recém-obtido -> Configurações -> Exibir credenciais. Esta aba conterá nossas chaves de acesso ao banco de dados. Lembramos sua localização - precisaremos deles para conectar o banco de dados, como o DataSource no IDEA.
- Lombok é uma biblioteca graças à qual reduziremos significativamente a quantidade de códigos diferentes. Com ele podemos criar automaticamente construtores, setters, getters e muito mais.
- Spring Data JPA é uma estrutura para trabalhar com bancos de dados (embora pareça muito simples). A descrição dos recursos do Spring Data JPA seria uma série de artigos, e a dependência que especificamos também envolve Hibernate e muito mais, então vamos pular os detalhes e tentar escrever algo usando Spring JPA hoje.
- PostgreSQL - extraímos a biblioteca para obter um driver que funcione com nosso banco de dados.
DROP TABLE IF EXISTS java_quiz;
DROP TABLE IF EXISTS users;
CREATE SEQUENCE global_seq START WITH 100000;
CREATE TABLE users
(
id INTEGER PRIMARY KEY DEFAULT nextval('global_seq'),
chat_id INTEGER UNIQUE NOT NULL,
name VARCHAR NOT NULL,
score INTEGER DEFAULT 0 NOT NULL,
high_score INTEGER DEFAULT 0 NOT NULL,
bot_state VARCHAR NOT NULL
);
CREATE TABLE java_quiz
(
id INTEGER PRIMARY KEY DEFAULT nextval('global_seq'),
question VARCHAR NOT NULL,
answer_correct VARCHAR NOT NULL,
option1 VARCHAR NOT NULL,
option2 VARCHAR NOT NULL,
option3 VARCHAR NOT NULL
);
O que nosso script faz? As duas primeiras linhas apagam tabelas, se presentes, para recriá-las. A terceira linha cria uma sequência que será usada para criar entradas de id exclusivas em nosso banco de dados. A seguir criamos duas tabelas: para usuários e para perguntas. O usuário terá um id único, id do chat do telegrama, nome, quantidade de pontos (atual e máximo), bem como o status atual do bot. As perguntas também terão um id único, bem como campos responsáveis pela pergunta e opções de resposta para a mesma. Podemos executar o script resultante clicando com o botão direito sobre ele e selecionando "Executar SQL Script". Atenção especial deve ser dada ao item “Interface Cmd-Line” - aqui precisaremos do PostgreSQL recém-instalado. Ao configurar este campo, selecione "Nova interface Cmd-Line" e especifique o caminho para psql.exe. Como resultado, as configurações devem ser mais ou menos assim: Executamos o script e se não cometemos nenhum erro, o resultado do nosso trabalho será o seguinte: <h3>Criar um modelo</h3>Agora é a hora para voltar a escrever código Java. Para encurtar o artigo, omitirei a descrição das anotações usadas para escrever as aulas para que você possa se familiarizar com elas. Vamos criar um pacote modelo no qual teremos três classes:
- AbstractBaseEntity é uma classe que descreve qualquer objeto que pode ter um id (esta classe é uma forte simplificação do que você pode ver em um estágio):
package com.whiskels.telegram.model; import lombok.Getter; import lombok.Setter; import javax.persistence.*; // Аннотация, которая говорит нам, что это суперкласс для всех Entity // https://vladmihalcea.com/how-to-inherit-properties-from-a-base-class-entity-using-mappedsuperclass-with-jpa-and-hibernate/ @MappedSuperclass // http://stackoverflow.com/questions/594597/hibernate-annotations-which-is-better-field-or-property-access @Access(AccessType.FIELD) // Аннотации Lombok для автогенерации сеттеров и геттеров на все поля @Getter @Setter public abstract class AbstractBaseEntity { // Аннотации, описывающие механизм генерации id - разберитесь в documentации каждой! @Id @SequenceGenerator(name = "global_seq", sequenceName = "global_seq", allocationSize = 1, initialValue = START_SEQ) @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "global_seq") // See https://hibernate.atlassian.net/browse/HHH-3718 and https://hibernate.atlassian.net/browse/HHH-12034 // Proxy initialization when accessing its identifier managed now by JPA_PROXY_COMPLIANCE setting protected Integer id; protected AbstractBaseEntity() { } }
- Do utilizador :
package com.whiskels.telegram.model; import com.whiskels.telegram.bot.State; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import org.hibernate.annotations.BatchSize; import javax.persistence.*; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import java.util.Set; import static javax.persistence.FetchType.EAGER; @Entity @Table(name = "users", uniqueConstraints = {@UniqueConstraint(columnNames = "chat_id", name = "users_unique_chatid_idx")}) @Getter @Setter @NoArgsConstructor @AllArgsConstructor public class User extends AbstractBaseEntity { @Column(name = "chat_id", unique = true, nullable = false) @NotNull private Integer chatId; @Column(name = "name", unique = true, nullable = false) @NotBlank private String name; @Column(name = "score", nullable = false) @NotNull private Integer score; @Column(name = "high_score", nullable = false) @NotNull private Integer highScore; @Column(name = "bot_state", nullable = false) @NotBlank private State botState; // Конструктор нужен для создания нового пользователя (а может и нет? :)) public User(int chatId) { this.chatId = chatId; this.name = String.valueOf(chatId); this.score = 0; this.highScore = 0; this.botState = State.START; } }
- Classe de perguntas :
package com.whiskels.telegram.model; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Table; import javax.validation.constraints.NotBlank; @Entity @Table(name = "java_quiz") @Getter @Setter @NoArgsConstructor @AllArgsConstructor public class Question extends AbstractBaseEntity { @Column(name = "question", nullable = false) @NotBlank private String question; @Column(name = "answer_correct", nullable = false) @NotBlank private String correctAnswer; @Column(name = "option2", nullable = false) @NotBlank private String optionOne; @Column(name = "option1", nullable = false) @NotBlank private String optionTwo; @Column(name = "option3", nullable = false) @NotBlank private String optionThree; @Override public String toString() { return "Question{" + "question='" + question + '\'' + ", correctAnswer='" + correctAnswer + '\'' + ", optionOne='" + optionOne + '\'' + ", optionTwo='" + optionTwo + '\'' + ", optionThree='" + optionThree + '\'' + '}'; } }
- JpaUserRepositório:
package com.whiskels.telegram.repository; import com.whiskels.telegram.model.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import java.util.Optional; @Repository @Transactional(readOnly = true) public interface JpaUserRepository extends JpaRepository<user, integer=""> { // По названию метода Spring сам поймет, что мы хотим получить пользователя по переданному chatId Optional<user> getByChatId(int chatId); } </user></user,>
- Repositório JpaQuestion:
package com.whiskels.telegram.repository; import com.whiskels.telegram.model.Question; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; @Repository @Transactional(readOnly = true) public interface JpaQuestionRepository extends JpaRepository<question, integer=""> { // А здесь мы написали SQL Query, которая будет выбирать 1 случайный вопрос из таблицы вопросов @Query(nativeQuery = true, value = "SELECT * FROM java_quiz ORDER BY random() LIMIT 1") Question getRandomQuestion(); } </question,>
package com.whiskels.telegram.bot;
public enum State {
NONE,
START,
ENTER_NAME,
PLAYING_QUIZ,
}
A seguir, criaremos um pacote bot/handler no qual declararemos a interface do manipulador:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import java.io.Serializable;
import java.util.List;
public interface Handler {
// основной метод, который будет обрабатывать действия пользователя
List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message);
// метод, который позволяет узнать, можем ли мы обработать текущий State у пользователя
State operatedBotState();
// метод, который позволяет узнать, Howие команды CallBackQuery мы можем обработать в этом классе
List<string> operatedCallBackQuery();
}
</string></partialbotapimethod<?>
Criaremos os manipuladores um pouco mais tarde, mas por enquanto vamos delegar o processamento de eventos para a nova classe UpdateReceiver , que criaremos na raiz do pacote do bot: ATENÇÃO! Aqui e mais adiante haverá métodos que são exibidos como List> handle(args); na realidade eles se parecem com isto, mas o formatador de código os quebrou:
package com.whiskels.telegram.bot;
import com.whiskels.telegram.bot.handler.Handler;
import com.whiskels.telegram.model.User;
import com.whiskels.telegram.repository.JpaUserRepository;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.Update;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
@Component
public class UpdateReceiver {
// Храним доступные хендлеры в списке (подсмотрел у Miroha)
private final List<handler> handlers;
// Имеем доступ в базу пользователей
private final JpaUserRepository userRepository;
public UpdateReceiver(List<handler> handlers, JpaUserRepository userRepository) {
this.handlers = handlers;
this.userRepository = userRepository;
}
// Обрабатываем полученный Update
public List<partialbotapimethod<? extends="" serializable="">> handle(Update update) {
// try-catch, чтобы при несуществующей команде просто возвращать пустой список
try {
// Проверяем, если Update - сообщение с текстом
if (isMessageWithText(update)) {
// Получаем Message из Update
final Message message = update.getMessage();
// Получаем айди чата с пользователем
final int chatId = message.getFrom().getId();
// Просим у репозитория пользователя. Если такого пользователя нет - создаем нового и возвращаем его.
// Как раз на случай нового пользователя мы и сделали конструктор с одним параметром в классе User
final User user = userRepository.getByChatId(chatId)
.orElseGet(() -> userRepository.save(new User(chatId)));
// Ищем нужный обработчик и возвращаем результат его работы
return getHandlerByState(user.getBotState()).handle(user, message.getText());
} else if (update.hasCallbackQuery()) {
final CallbackQuery callbackQuery = update.getCallbackQuery();
final int chatId = callbackQuery.getFrom().getId();
final User user = userRepository.getByChatId(chatId)
.orElseGet(() -> userRepository.save(new User(chatId)));
return getHandlerByCallBackQuery(callbackQuery.getData()).handle(user, callbackQuery.getData());
}
throw new UnsupportedOperationException();
} catch (UnsupportedOperationException e) {
return Collections.emptyList();
}
}
private Handler getHandlerByState(State state) {
return handlers.stream()
.filter(h -> h.operatedBotState() != null)
.filter(h -> h.operatedBotState().equals(state))
.findAny()
.orElseThrow(UnsupportedOperationException::new);
}
private Handler getHandlerByCallBackQuery(String query) {
return handlers.stream()
.filter(h -> h.operatedCallBackQuery().stream()
.anyMatch(query::startsWith))
.findAny()
.orElseThrow(UnsupportedOperationException::new);
}
private boolean isMessageWithText(Update update) {
return !update.hasCallbackQuery() && update.hasMessage() && update.getMessage().hasText();
}
}
</partialbotapimethod<?></handler></handler>
E delegamos o processamento a ele na classe Bot:
package com.whiskels.telegram.bot;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import java.io.Serializable;
import java.util.List;
@Slf4j
@Component
public class Bot extends TelegramLongPollingBot {
@Value("${bot.name}")
@Getter
private String botUsername;
@Value("${bot.token}")
@Getter
private String botToken;
private final UpdateReceiver updateReceiver;
public Bot(UpdateReceiver updateReceiver) {
this.updateReceiver = updateReceiver;
}
@Override
public void onUpdateReceived(Update update) {
List<partialbotapimethod<? extends="" serializable="">> messagesToSend = updateReceiver.handle(update);
if (messagesToSend != null && !messagesToSend.isEmpty()) {
messagesToSend.forEach(response -> {
if (response instanceof SendMessage) {
executeWithExceptionCheck((SendMessage) response);
}
});
}
}
public void executeWithExceptionCheck(SendMessage sendMessage) {
try {
execute(sendMessage);
} catch (TelegramApiException e) {
log.error("oops");
}
}
}
</partialbotapimethod<?>
Agora nosso bot delega o processamento de eventos para a classe UpdateReceiver , mas ainda não temos nenhum manipulador. Vamos criá-los! ISENÇÃO DE RESPONSABILIDADE! Eu realmente queria compartilhar as possibilidades de escrever um bot assim, para que códigos adicionais (como, em princípio, o código UpdateReceiver) possam ser muito bem refatorados usando vários padrões. Mas estamos aprendendo e nosso objetivo é um bot minimamente viável, então como outra tarefa de casa, você pode refatorar tudo o que viu :) Crie um pacote utilitário, e nele - a classe TelegramUtil :
package com.whiskels.telegram.util;
import com.whiskels.telegram.model.User;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
public class TelegramUtil {
public static SendMessage createMessageTemplate(User user) {
return createMessageTemplate(String.valueOf(user.getChatId()));
}
// Создаем шаблон SendMessage с включенным Markdown
public static SendMessage createMessageTemplate(String chatId) {
return new SendMessage()
.setChatId(chatId)
.enableMarkdown(true);
}
// Создаем кнопку
public static InlineKeyboardButton createInlineKeyboardButton(String text, String command) {
return new InlineKeyboardButton()
.setText(text)
.setCallbackData(command);
}
}
Escreveremos quatro manipuladores: HelpHandler, QuizHandler, RegistrationHandler, StartHandler. IniciarHandler:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import com.whiskels.telegram.repository.JpaUserRepository;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
import static com.whiskels.telegram.util.TelegramUtil.createMessageTemplate;
@Component
public class StartHandler implements Handler {
@Value("${bot.name}")
private String botUsername;
private final JpaUserRepository userRepository;
public StartHandler(JpaUserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message) {
// Приветствуем пользователя
SendMessage welcomeMessage = createMessageTemplate(user)
.setText(String.format(
"Hola! I'm *%s*%nI am here to help you learn Java", botUsername
));
// Просим назваться
SendMessage registrationMessage = createMessageTemplate(user)
.setText("In order to start our journey tell me your name");
// Меняем пользователю статус на - "ожидание ввода имени"
user.setBotState(State.ENTER_NAME);
userRepository.save(user);
return List.of(welcomeMessage, registrationMessage);
}
@Override
public State operatedBotState() {
return State.START;
}
@Override
public List<string> operatedCallBackQuery() {
return Collections.emptyList();
}
}
</string></partialbotapimethod<?>
Manipulador de registro:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import com.whiskels.telegram.repository.JpaUserRepository;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import java.io.Serializable;
import java.util.List;
import static com.whiskels.telegram.bot.handler.QuizHandler.QUIZ_START;
import static com.whiskels.telegram.util.TelegramUtil.createInlineKeyboardButton;
import static com.whiskels.telegram.util.TelegramUtil.createMessageTemplate;
@Component
public class RegistrationHandler implements Handler {
//Храним поддерживаемые CallBackQuery в виде констант
public static final String NAME_ACCEPT = "/enter_name_accept";
public static final String NAME_CHANGE = "/enter_name";
public static final String NAME_CHANGE_CANCEL = "/enter_name_cancel";
private final JpaUserRepository userRepository;
public RegistrationHandler(JpaUserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message) {
// Проверяем тип полученного события
if (message.equalsIgnoreCase(NAME_ACCEPT) || message.equalsIgnoreCase(NAME_CHANGE_CANCEL)) {
return accept(user);
} else if (message.equalsIgnoreCase(NAME_CHANGE)) {
return changeName(user);
}
return checkName(user, message);
}
private List<partialbotapimethod<? extends="" serializable="">> accept(User user) {
// Если пользователь принял Name - меняем статус и сохраняем
user.setBotState(State.NONE);
userRepository.save(user);
// Создаем кнопку для начала игры
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Start quiz", QUIZ_START));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user).setText(String.format(
"Your name is saved as: %s", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
private List<partialbotapimethod<? extends="" serializable="">> checkName(User user, String message) {
// При проверке имени мы превентивно сохраняем пользователю новое Name в базе
// идея для рефакторинга - добавить временное хранение имени
user.setName(message);
userRepository.save(user);
// Doing кнопку для применения изменений
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Accept", NAME_ACCEPT));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user)
.setText(String.format("You have entered: %s%nIf this is correct - press the button", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
private List<partialbotapimethod<? extends="" serializable="">> changeName(User user) {
// При requestе изменения имени мы меняем State
user.setBotState(State.ENTER_NAME);
userRepository.save(user);
// Создаем кнопку для отмены операции
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Cancel", NAME_CHANGE_CANCEL));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user).setText(String.format(
"Your current name is: %s%nEnter new name or press the button to continue", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
@Override
public State operatedBotState() {
return State.ENTER_NAME;
}
@Override
public List<string> operatedCallBackQuery() {
return List.of(NAME_ACCEPT, NAME_CHANGE, NAME_CHANGE_CANCEL);
}
}
</string></inlinekeyboardbutton></partialbotapimethod<?></inlinekeyboardbutton></partialbotapimethod<?></inlinekeyboardbutton></partialbotapimethod<?></partialbotapimethod<?>
Manipulador de ajuda:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static com.whiskels.telegram.bot.handler.RegistrationHandler.NAME_CHANGE;
import static com.whiskels.telegram.util.TelegramUtil.createInlineKeyboardButton;
import static com.whiskels.telegram.util.TelegramUtil.createMessageTemplate;
@Component
public class HelpHandler implements Handler {
@Override
public List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message) {
// Создаем кнопку для смены имени
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Change name", NAME_CHANGE));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user).setText(String.format("" +
"You've asked for help %s? Here it comes!", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
@Override
public State operatedBotState() {
return State.NONE;
}
@Override
public List<string> operatedCallBackQuery() {
return Collections.emptyList();
}
}
</string></inlinekeyboardbutton></partialbotapimethod<?>
QuizHandler (o pior
GO TO FULL VERSION