https://github.com/henriqueotogami/learning-jpa
Estudos de Java Persistente API, utilizando o framework Hibernate e o conceito de Data Mapper e ORM no MySQL8.
https://github.com/henriqueotogami/learning-jpa
datamapper intellij-idea java-11 jpa-hibernate mysql8 orm
Last synced: 21 days ago
JSON representation
Estudos de Java Persistente API, utilizando o framework Hibernate e o conceito de Data Mapper e ORM no MySQL8.
- Host: GitHub
- URL: https://github.com/henriqueotogami/learning-jpa
- Owner: henriqueotogami
- License: mit
- Created: 2022-09-07T15:35:28.000Z (over 3 years ago)
- Default Branch: main
- Last Pushed: 2025-03-04T05:33:29.000Z (over 1 year ago)
- Last Synced: 2025-03-04T06:28:37.393Z (over 1 year ago)
- Topics: datamapper, intellij-idea, java-11, jpa-hibernate, mysql8, orm
- Language: Java
- Homepage:
- Size: 656 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Learning JPA
> Repositório com estudos e exemplos de **Java Persistence API (JPA)**, utilizando Hibernate, conceitos de **ORM** e **Data Mapper** com MySQL 8. Desenvolvido no curso [Cod3r \| Java 2022 Completo](https://www.udemy.com/course/fundamentos-de-programacao-com-java/).
---
## 📋 Sobre o Projeto
Este projeto contém uma coleção de entidades JPA, testes e exemplos desenvolvidos para o aprendizado de persistência em Java. Os códigos cobrem operações básicas (CRUD), relacionamentos (One-to-One, One-to-Many, Many-to-Many), composição (embeddable), herança (Single Table, Joined, Table Per Class), acesso a dados via JDBC e JPA, além de named queries e consultas nativas.
## 📁 Estrutura do Projeto
### Entidades e relacionamentos (`src/main/java/model/`)
- **basic/** — Entidades simples: `User`, `Product` (mapeamento básico, colunas, `@Transient`)
- **onetoone/** — Relacionamento 1:1: `Client` e `Seat`
- **onetomany/** — Relacionamento 1:N: `RestaurantOrder` e `ItemFromOrder`
- **manytomany/** — Relacionamento N:N: `Actor`, `Movie`, `MovieRating` (avaliação)
- **composition/** — Composição/embeddable: `Address`, `Staff`, `Supplier`
- **inheritance/** — Estratégias de herança:
- **singletable/** — `Student`, `ScholarshipStudent` (Single Table)
- **joined/** — `Student`, `ScholarshipStudent` (Joined)
- **tableperclass/** — `Student`, `ScholarshipStudent` (Table Per Class)
### Infraestrutura e banco (`src/main/java/`)
- **model/database/jpa/** — `PersistenceEntityManager` (EntityManagerFactory e EntityManager)
- **model/database/jdbc/** — `DatabaseConnectivityManager`, `CreateTablePeople` (acesso via JDBC)
- **infrastructure/** — `DataAccessObject`, `ProductDAO` (padrão DAO)
### Testes (`src/test/java/model/`)
- **basic/** — insert, query, update, delete, newTable (criação de tabela)
- **onetoone/** — testes de cliente e assento
- **onetomany/** — testes de pedido e itens
- **manytomany/** — filmes, atores, tios/sobrinhos, avaliação
- **inheritance/** — testes por estratégia (tableperclass, etc.)
- **query/** — named queries: filmes, pedidos, média de avaliação, cliente e assento
### Configuração (`src/main/resources/`)
- **META-INF/persistence.xml** — unidade de persistência, entidades, propriedades JDBC e Hibernate
- **META-INF/queries.xml** — named queries e named native queries (JPQL e SQL)
- **connection.properties** — URL, usuário e senha do banco (JDBC)
## 📂 Estrutura do repositório
```
LICENSE
README.md
pom.xml
JPA.png
src/
main/
java/
model/
basic/ # User, Product
onetoone/ # Client, Seat
onetomany/ # RestaurantOrder, ItemFromOrder
manytomany/ # Actor, Movie, Uncle, Nephew, MovieRating
composition/ # Address, Staff, Supplier
inheritance/ # singletable, joined, tableperclass (Student, ScholarshipStudent)
database/
jpa/ # PersistenceEntityManager
jdbc/ # DatabaseConnectivityManager, CreateTablePeople
infrastructure/ # DataAccessObject, ProductDAO
resources/
META-INF/ # persistence.xml, queries.xml
connection.properties
test/
java/
model/ # testes por pacote (basic, onetoone, onetomany, manytomany, inheritance, query)
documentation/ # Javadoc gerado
```
## 🛠️ Tecnologias Utilizadas
- **Java 11** — Linguagem e API
- **JPA (Jakarta Persistence)** — API de persistência
- **Hibernate** — Implementação JPA (dialeto MySQL 8)
- **EclipseLink** — Provider configurado no `persistence.xml`
- **MySQL 8** — Banco de dados
- **Maven** — Build e dependências
- **IntelliJ IDEA** — IDE utilizada no desenvolvimento
## 📝 Funcionalidades Principais
### CRUD e operações básicas
- Inserção, consulta, atualização e exclusão de entidades
- Criação de tabelas via código (ex.: `CreateTableProduct`)
- Uso de `EntityManager` e transações
### Relacionamentos
- **One-to-One:** Cliente e assento (1:1)
- **One-to-Many:** Pedido e itens do pedido (1:N)
- **Many-to-Many:** Filmes e atores; tios e sobrinhos; filmes com avaliação
### Herança
- Single Table, Joined e Table Per Class com `Student` e `ScholarshipStudent`
### Consultas
- Named queries em JPQL (`queries.xml` e anotações)
- Named native queries e `SqlResultSetMapping`
- Exemplos: filmes com rating acima de um valor, média de avaliação, pedidos, cliente com assento
### Infraestrutura
- Conexão JPA centralizada em `PersistenceEntityManager`
- Conexão JDBC em `DatabaseConnectivityManager`
- Padrão DAO com `DataAccessObject` e `ProductDAO`
## 🚀 Como Executar
### Pré-requisitos
- **Java 11** (ou superior)
- **Maven**
- **MySQL 8** em execução, com um banco (ex.: `course_java`) criado
### Configuração do banco
1. Crie o banco no MySQL, por exemplo: `CREATE DATABASE course_java;`
2. Ajuste em `src/main/resources/connection.properties` e em `src/main/resources/META-INF/persistence.xml`:
- URL (host, porta, nome do banco)
- Usuário e senha
### Compilar e rodar testes
```bash
# Na raiz do projeto
mvn clean compile
# Executar todos os testes
mvn test
```
Para rodar uma classe de teste específica, use a IDE (IntelliJ) ou, por exemplo:
```bash
mvn test -Dtest=model.basic.insert.TestNewUser
```
**Observação:** As dependências JPA/Hibernate/MySQL estão comentadas no `pom.xml`. Para compilar e rodar, descomente o bloco `` no `pom.xml` e ajuste conforme a stack que você usa (Jakarta Persistence, Hibernate, driver MySQL, etc.).
## 📚 Conteúdos Abordados
- ✅ Entidades JPA: `@Entity`, `@Table`, `@Column`, `@Id`, `@GeneratedValue`
- ✅ Atributos transientes (`@Transient`)
- ✅ Relacionamentos: `@OneToOne`, `@OneToMany`, `@ManyToOne`, `@ManyToMany`, `@JoinColumn`, fetch
- ✅ Composição: `@Embedded`, `@Embeddable`
- ✅ Herança: `@Inheritance`, Single Table, Joined, Table Per Class
- ✅ `EntityManager`, `EntityManagerFactory`, transações
- ✅ Named queries (JPQL) e named native queries (SQL)
- ✅ `SqlResultSetMapping` e `@ConstructorResult`
- ✅ JDBC para comparação e criação de tabelas
- ✅ Padrão DAO e configuração via `persistence.xml` e `connection.properties`
## ⚙️ Como Funciona
### Fluxo JPA
1. `Persistence.createEntityManagerFactory("course_java")` lê o `persistence.xml` e cria a fábrica.
2. `EntityManagerFactory` cria `EntityManager` para operações de persistência.
3. Os testes abrem transação, persistem/consultam/atualizam/removem entidades e fazem commit/rollback.
4. As entidades listadas em `` no `persistence.xml` são gerenciadas pelo provider (Hibernate/EclipseLink).
### Named queries
- Definidas em `META-INF/queries.xml` (e possivelmente nas entidades).
- Exemplo: `getMoviesRatingHigherThan` — JPQL com `JOIN FETCH` e parâmetro `:rating`.
- Exemplo: `getMovieRating` — SQL nativo com `SqlResultSetMapping` para `MovieRating`.
### Estratégias de herança
- **Single Table:** uma tabela com coluna discriminadora.
- **Joined:** tabela base + tabelas filhas com FK.
- **Table Per Class:** uma tabela por classe concreta.
## 🖥️ Ambiente de Desenvolvimento
- **Sistema operacional:** macOS (Monterey 12.6)
- **IDE:** IntelliJ IDEA Community Edition 2022.2
**Plugins sugeridos:**
- [Atom Material Icons](https://plugins.jetbrains.com/plugin/10044-atom-material-icons)
- [Codota AI Autocomplete for Java](https://plugins.jetbrains.com/plugin/7638-codota-ai-autocomplete-for-java-and-javascript)
- [GitToolBox](https://plugins.jetbrains.com/plugin/7499-gittoolbox)
- [Nyan Progress Bar](https://plugins.jetbrains.com/plugin/8575-nyan-progress-bar)
- [Rainbow Brackets](https://plugins.jetbrains.com/plugin/10080-rainbow-brackets)
- [Wakatime](https://wakatime.com)
- [Xcode-Dark Theme](https://plugins.jetbrains.com/plugin/13106-xcode-dark-theme)
## 📄 Licença
Este projeto está licenciado sob a **MIT License**. Consulte o arquivo [LICENSE](LICENSE) para mais detalhes.
## 📖 Referências
- [Cod3r \| Java 2022 Completo](https://www.udemy.com/course/fundamentos-de-programacao-com-java/) — Curso onde o material foi desenvolvido
- Documentação JPA (Jakarta Persistence) e Hibernate
- Código-fonte em `src/main/java` e testes em `src/test/java`
---
## 🤝 Contribuições
Qualquer ajuda para melhorar este repositório é bem-vinda.
- [ ] Faça um **fork** deste repositório ([link para fork](https://github.com/henriqueotogami/learning-jpa/fork))
- [ ] Crie um **branch** para suas alterações: `git checkout -b meu-novo-recurso`
- [ ] Faça **commit**: `git commit -am 'Adicionando um novo recurso ...'`
- [ ] Envie **push**: `git push origin meu-novo-recurso`
- [ ] Abra uma **Pull Request** neste repositório
Depois que sua PR for aceita e merged na branch principal, você pode excluir sua branch.
---
**Desenvolvido por HMAP \| Henrique Matheus Alves Pereira** 🦁
---
### Hashtags
#JPA #Java #Hibernate #ORM #MySQL #JakartaPersistence #DataMapper #JavaPersistence #LearningJava #Backend #Persistence #Cod3r #OpenSource #GitHub #CodeExamples
### Meta Keywords
```
JPA, Java Persistence API, Hibernate, ORM, MySQL, Jakarta Persistence,
Data Mapper, entidades, relacionamentos, OneToOne, OneToMany, ManyToMany,
herança JPA, named queries, EntityManager, Maven, Java 11, curso Java,
persistência, CRUD, Cod3r, código exemplo, aprendizado
```