Análise Detalhada do Projeto - Jogo de Dados

Visão Geral do Projeto

Este documento apresenta uma análise detalhada de cada fase do desenvolvimento do projeto "Jogo de Dados", uma aplicação web desenvolvida com Spring Boot que demonstra conceitos fundamentais de desenvolvimento Java para iniciantes.

---

📋 Tópico 1: Criação das Classes de Implementação dos Models

Descrição da Fase

Nesta primeira fase do projeto, foi estabelecida a estrutura fundamental da aplicação através da criação das classes de domínio (Models) e suas respectivas camadas de acesso a dados e serviços.

Entidades de Domínio Criadas

1. AbstractEntity

Localização: com.lunaltas.dicegame.domain.AbstractEntity

Classe abstrata genérica que serve como base para todas as entidades do sistema, implementando funcionalidades comuns:

• Gerenciamento de ID: Utiliza @Id e @GeneratedValue(strategy = GenerationType.IDENTITY) para geração automática de identificadores
• Métodos fundamentais: Implementa hashCode(), equals() e toString() baseados no ID
• Serialização: Implementa Serializable para suportar persistência e transmissão de dados

Características técnicas:

• Utiliza @MappedSuperclass para permitir herança sem criar tabela própria
• Tipo genérico ID extends Serializable permite flexibilidade no tipo de chave primária

2. User (Usuário)

Localização: com.lunaltas.dicegame.domain.User

Entidade que representa os usuários do sistema:

Atributos principais:

• name (String): Nome do usuário (obrigatório, máximo 60 caracteres)
• email (String): Email do usuário (obrigatório, validado com @Email, máximo 60 caracteres)
• password (String): Senha do usuário (obrigatória, será criptografada posteriormente)
• role (String): Papel do usuário no sistema (padrão: "USER")

Validações implementadas:

• @NotBlank em todos os campos obrigatórios
• @Email para validação de formato de email
• Mensagens de erro personalizadas em português

Relacionamentos:

• @OneToMany com Bet: Um usuário pode ter múltiplas apostas

3. Bet (Aposta)

Localização: com.lunaltas.dicegame.domain.Bet

Entidade que representa as apostas realizadas no jogo:

Atributos principais:

• name (String): Nome da aposta (obrigatório, máximo 60 caracteres)

Relacionamentos:

• @ManyToOne com User: Múltiplas apostas pertencem a um usuário

Camada de Acesso a Dados (DAO)

AbstractDao<T, PK>

Localização: com.lunaltas.dicegame.dao.AbstractDao

Classe abstrata genérica que implementa operações CRUD básicas usando JPA:

Métodos implementados:

• save(T entity): Persiste uma nova entidade
• update(T entity): Atualiza uma entidade existente
• delete(PK id): Remove uma entidade pelo ID
• findById(PK id): Busca uma entidade pelo ID
• findAll(): Retorna todas as entidades do tipo
• createQuery(String jpql, Object... params): Método auxiliar para consultas JPQL customizadas

Características técnicas:

• Utiliza EntityManager injetado via @PersistenceContext
• Usa reflexão para determinar a classe da entidade automaticamente
• Suporta consultas parametrizadas para segurança

Implementações Específicas

UserDao e UserDaoImpl:

• Interface: com.lunaltas.dicegame.dao.UserDao
• Implementação: com.lunaltas.dicegame.dao.UserDaoImpl
• Estende AbstractDao<User, Long>

BetDao e BetDaoImpl:

• Interface: com.lunaltas.dicegame.dao.BetDao
• Implementação: com.lunaltas.dicegame.dao.BetDaoImpl
• Estende AbstractDao<Bet, Long>

Camada de Serviços (Service)

Interfaces de Serviço

UserService:

• Interface que define operações de negócio para usuários
• Estende UserDetailsService para integração com Spring Security
• Métodos: save(), update(), delete(), findById(), findAll(), hasBets()

BetService:

• Interface que define operações de negócio para apostas
• Métodos: save(), update(), delete(), findById(), findAll()

Implementações de Serviço

UserServiceImpl:

• Implementa UserService
• Injeta UserDao e UserRepository
• Gerencia criptografia de senhas usando PasswordEncoder
• Implementa loadUserByUsername() para autenticação

BetServiceImpl:

• Implementa BetService
• Injeta BetDao
• Delega operações CRUD para a camada DAO

Resultado da Fase

Ao final desta fase, o projeto possuía:

• ✅ Estrutura de entidades bem definida
• ✅ Camada de acesso a dados genérica e reutilizável
• ✅ Camada de serviços preparada para regras de negócio
• ✅ Separação clara de responsabilidades (Domain, DAO, Service)
• ✅ Base sólida para integração com banco de dados

---

📋 Tópico 2: Integração dos Models com Banco de Dados

Descrição da Fase

Nesta segunda fase, foi realizada a integração completa entre as entidades JPA e o banco de dados PostgreSQL, configurando todas as dependências e mapeamentos necessários.

Configurações Realizadas

1. Dependências Maven (pom.xml)

Spring Data JPA:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Driver PostgreSQL:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

2. Configuração do Banco de Dados

Arquivo: src/main/resources/application.properties

Configurações de DataSource:

spring.datasource.url = jdbc:postgresql://localhost:5432/dice_game
spring.datasource.username = TOKA
spring.datasource.password = 123

Configurações JPA/Hibernate:

# Exibe as consultas SQL no console para debug
spring.jpa.show-sql = true

# Mantém a sessão JPA aberta durante o processamento de requisições
spring.jpa.open-in-view = true

Mapeamentos JPA Implementados

Entidade User

Anotações utilizadas:

• @Entity: Marca a classe como entidade JPA
• @Table(name = "users"): Define o nome da tabela no banco
• @Column: Especifica detalhes das colunas (nullable, length)
• @OneToMany(mappedBy = "user"): Define relacionamento um-para-muitos com Bet

Estrutura da tabela users:

• id (BIGSERIAL PRIMARY KEY): Gerado automaticamente
• name (VARCHAR(60) NOT NULL): Nome do usuário
• email (VARCHAR(60) NOT NULL): Email único
• password (VARCHAR NOT NULL): Senha criptografada
• role (VARCHAR NOT NULL): Papel do usuário (padrão: "USER")

Entidade Bet

Anotações utilizadas:

• @Entity: Marca a classe como entidade JPA
• @Table(name = "bet"): Define o nome da tabela
• @ManyToOne: Define relacionamento muitos-para-um com User
• @JoinColumn(name = "user_id"): Especifica a coluna de chave estrangeira

Estrutura da tabela bet:

• id (BIGSERIAL PRIMARY KEY): Gerado automaticamente
• name (VARCHAR(60) NOT NULL): Nome da aposta
• user_id (BIGINT FOREIGN KEY): Referência ao usuário

Implementação do EntityManager

Classe: AbstractDao

O EntityManager é injetado via @PersistenceContext e utilizado para:

1. Persistência:

   entityManager.persist(entity);
   

2. Atualização:

   entityManager.merge(entity);
   

3. Remoção:

   entityManager.remove(entityManager.getReference(entityClass, id));
   

4. Consultas:

   entityManager.find(entityClass, id);
   entityManager.createQuery("from " + entityClass.getSimpleName(), entityClass);
   

Gerenciamento de Transações

Anotações utilizadas nos serviços:

• @Transactional(readOnly = false): Para operações de escrita (padrão)
• @Transactional(readOnly = true): Para operações de leitura (otimização)

Exemplo em UserServiceImpl:

@Service @Transactional(readOnly = false)
public class UserServiceImpl implements UserService {
    // Operações de escrita usam transação completa
    
    @Override @Transactional(readOnly = true)
    public User findById(Long id) {
        return dao.findById(id);
    }
}

Validações de Integridade

Validações Bean Validation:

• @NotBlank: Campos obrigatórios não podem ser vazios
• @Email: Validação de formato de email
• Mensagens personalizadas em português

Validações de Relacionamento:

• Integridade referencial entre User e Bet
• Prevenção de exclusão de usuários com apostas associadas

Resultado da Fase

Ao final desta fase, o projeto possuía:

• ✅ Banco de dados PostgreSQL configurado e conectado
• ✅ Entidades mapeadas corretamente para tabelas
• ✅ Relacionamentos JPA funcionando (OneToMany, ManyToOne)
• ✅ Operações CRUD funcionais através do EntityManager
• ✅ Gerenciamento de transações implementado
• ✅ Validações de dados ativas
• ✅ Consultas SQL visíveis para debug

---

📋 Tópico 3: Integração dos Controllers com as Views e Models

Descrição da Fase

Nesta terceira fase, foi implementada a camada de apresentação completa, conectando os controllers Spring MVC às views Thymeleaf e integrando tudo com os models e serviços já criados.

Controllers Implementados

1. UsersController

Localização: com.lunaltas.dicegame.Controller.UsersController Rota base: /users

Endpoints implementados:

Método HTTP	Rota	Descrição
GET	/users/index	Lista todos os usuários
GET	/users/new	Exibe formulário de criação
POST	/users/create	Salva novo usuário
GET	/users/show/{id}	Exibe detalhes do usuário
GET	/users/edit/{id}	Exibe formulário de edição
PUT	/users/update/{id}	Atualiza usuário existente
DELETE	/users/delete/{id}	Remove usuário

Funcionalidades especiais:

1. Validação de Senha Customizada:

   if (user.getPassword() != null && 
       (user.getPassword().length() < 8 || 
        user.getPassword().length() > 20)) {
       result.rejectValue("password", "error.password", 
           "A senha deve ter entre 8 e 20 caracteres.");
   }
   

2. Proteção contra Exclusão:

   if (userService.hasBets(id)) {
       redirectAttributes.addFlashAttribute("error", 
           "Usuário não pode ser deletado porque tem Bets associadas");
       return "redirect:/users/show/" + id;
   }
   

3. Mensagens de Feedback:

   • Uso de RedirectAttributes para mensagens de sucesso/erro
   • Flash attributes para persistência entre redirecionamentos

2. BetsController

Localização: com.lunaltas.dicegame.Controller.BetsController Rota base: /bets

Endpoints implementados:

Método HTTP	Rota	Descrição
GET	/bets/index	Lista todas as apostas
GET	/bets/new	Exibe formulário de criação
POST	/bets/create	Salva nova aposta
GET	/bets/show/{id}	Exibe detalhes da aposta
GET	/bets/edit/{id}	Exibe formulário de edição
PUT	/bets/update/{id}	Atualiza aposta existente
DELETE	/bets/delete/{id}	Remove aposta

Funcionalidades especiais:

• Injeção de lista de usuários para seleção em formulários
• Validação de dados usando Bean Validation
• Tratamento de erros de validação com retorno ao formulário

Camada de Serviços - Funcionalidades Avançadas

Criptografia de Senhas

UserServiceImpl - Método save():

@Override
public void save(User user) {
    // Criptografa a senha antes de salvar
    if (user.getPassword() != null && !user.getPassword().isEmpty()) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
    }
    dao.save(user);
}

UserServiceImpl - Método update():

@Override
public void update(User user) {
    User existingUser = dao.findById(user.getId());
    if (existingUser != null && user.getPassword() != null && 
        !user.getPassword().isEmpty() && 
        !user.getPassword().equals(existingUser.getPassword())) {
        // Verifica se a senha já está criptografada
        if (!user.getPassword().startsWith("$2a$") &&