0Pricing
Java Academy · Aula

Mapeamento de entidades com anotações JPA

Defina @Entity, @Table, @Id, @GeneratedValue, @Column e @Embedded para um design limpo de entidades.

Mapeamento de entidades com anotações JPA é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que é o mapeamento de entidades JPA

A JPA (Jakarta Persistence API) mapeia classes Java para tabelas do banco de dados usando anotações. Hibernate é o provedor JPA mais comum. Não é necessário escrever DDL em SQL — a JPA gera esquemas a partir das anotações.

@Entity e @Table

@Entity marca uma classe como uma entidade JPA. @Table personaliza o nome da tabela, o esquema e as restrições de unicidade. Toda entidade deve ter um construtor sem argumentos (que pode ser protegido).

@Entity
@Table(name = "users", uniqueConstraints = @UniqueConstraint(columnNames = "email"))
public class User {
    // ...
    protected User() {} // required by JPA
}

@Id e @GeneratedValue

@Id marca o campo da chave primária. @GeneratedValue configura a estratégia de geração automática: IDENTITY (incremento automático do banco de dados), SEQUENCE (sequência do banco de dados, melhor para inserções em massa) ou AUTO.

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
}

@Column: Personalização de colunas

@Column define o nome da coluna, o comprimento, a aceitação de nulos e a unicidade. Sem ela, o nome do campo se torna o nome da coluna.

@Column(name = "full_name", nullable = false, length = 100)
private String name;
@Column(name = "email", unique = true, nullable = false)
private String email;
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;

@Embedded e @Embeddable

Extraia um grupo de colunas para um objeto de valor reutilizável anotado com @Embeddable. Use @Embedded na entidade para incluir os campos.

@Embeddable
public class Address {
    private String street, city, country;
    @Column(name = "zip_code") private String zipCode;
}
@Entity
public class User {
    @Embedded private Address address;
}

@Enumerated: Persistência de enumerações

Persista enumerações como sua representação textual do nome (STRING) ou como um inteiro ordinal (ORDINAL). Sempre use STRING — os valores ordinais deixam de ser válidos quando os valores da enumeração são reordenados.

@Enumerated(EnumType.STRING)
@Column(nullable = false)
private UserStatus status; // stored as "ACTIVE", "INACTIVE", etc.

@CreationTimestamp e @UpdateTimestamp

Anotações específicas do Hibernate que definem automaticamente a data e a hora na inserção e na atualização, respectivamente — não é necessário usar manualmente @PrePersist.

@CreationTimestamp
@Column(updatable = false)
private LocalDateTime createdAt;
@UpdateTimestamp
private LocalDateTime updatedAt;

@Transient: Excluindo campos

Os campos anotados com @Transient não são persistidos. Use essa anotação para campos derivados ou calculados que não devem ser armazenados no banco de dados.

@Transient
public String getFullName() { return firstName + " " + lastName; }

@Lob: Objetos grandes

Use @Lob para mapear colunas grandes de texto (TEXT/CLOB) ou binárias (BLOB). O PostgreSQL mapeia @Lob String para TEXT.

@Lob
@Column(name = "content")
private String content; // maps to TEXT in PostgreSQL

Contrato de equals e hashCode

As entidades JPA em coleções devem implementar equals / hashCode com base na chave de negócio (não no ID gerado, que é nulo antes da persistência). Use @NaturalId ou uma chave substituta UUID.

@Override public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof User u)) return false;
    return email != null && email.equals(u.email);
}
@Override public int hashCode() { return getClass().hashCode(); }

@Version para bloqueio otimista

Adicione um campo @Version. O Hibernate o incrementa a cada atualização. Se duas transações atualizarem a mesma linha simultaneamente, a segunda lançará OptimisticLockException.

@Version
private Long version; // auto-managed by Hibernate

Verificação rápida

Por que @Enumerated deve usar STRING em vez de ORDINAL?

Recapitulação

Use @Entity/@Table para mapear classes para tabelas. @Id+@GeneratedValue para chaves primárias. @Column para restrições. @Embedded para objetos de valor. Sempre @Enumerated(STRING). Adicione @Version para bloqueio otimista.

Perguntas Frequentes

A aula “Mapeamento de entidades com anotações JPA” é grátis?

Sim — o texto completo de “Mapeamento de entidades com anotações JPA” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Mapeamento de entidades com anotações JPA”?

Defina @Entity, @Table, @Id, @GeneratedValue, @Column e @Embedded para um design limpo de entidades. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Mapeamento de entidades com anotações JPA”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Mapeamento de entidades com anotações JPA
  2. Repositórios do Spring Data e métodos de consulta
  3. Relacionamentos um-para-muitos e muitos-para-muitos
  4. Paginação, ordenação e projeções
← Voltar para Java Academy