Você está aqui: JPA - Java Persistence Architecture API - Arquitetura de Persistência Java ::: Dicas & Truques ::: Relacionamentos e Mapeamento de Entidades

Aprenda a usar o mapeamento Many-to-One (muitos para um) em suas aplicações JPA

Quantidade de visualizações: 3451 vezes
O mapeamento Many-to-One (muitos para um) ocorre quando temos várias entidades se relacionando com uma outra (e única) entidade. Como exemplo podemos citar as entidades Produto e Categoria. Cada produto pertence a apenas uma categoria e uma categoria pode possuir 0 ou mais produtos. No caso do mapeamento muitos-para-um nós estamos olhando a partir da entidade Produto. Se olhássemos a partir da entidade Categoria, o relacionamento seria um-para-muitos.

Como outro exemplo de mapeamento Many-to-One, considere as entidades Pedido e Cliente. Cada pedido pertence a apenas um cliente e um cliente pode possuir 0 ou vários pedidos.

Para começarmos, vamos criar duas tabelas no MySQL: produtos e categorias. Veja o comando SQL DDL CREATE TABLE para a tabela categorias:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

CREATE TABLE categorias(
  id int(11) NOT NULL AUTO_INCREMENT,
  nome varchar(45) NOT NULL,
  PRIMARY KEY(id)
)ENGINE=InnoDB;

Veja que esta tabela possui apenas dois campos. O campo id é do int, auto-incremento e marcado como chave primária. O campo nome é do tipo varchar. Use o comando abaixo para inserir um registro nesta tabela:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

INSERT INTO categorias VALUES(null, 'Vestuário');

Se desejar, insira mais alguns registros na tabela categorias. Veja agora o comando SQL DDL CREATE TABLE para a tabela produtos:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

CREATE TABLE produtos(
  id int(11) NOT NULL AUTO_INCREMENT,
  descricao varchar(45) NOT NULL,
  id_categoria int(11) NOT NULL,
  preco double NOT NULL,
  PRIMARY KEY(id),
  CONSTRAINT cat_produto FOREIGN KEY(id_categoria) 
    REFERENCES categorias(id)
)ENGINE=InnoDB;


A tabela produtos possui os campos id (do tipo int, auto-incremento e chave primária), descrição (do tipo varchar), id_categoria (do tipo int e usado como chave estrangeira referenciando o campo id da tabela categorias) e preco (do tipo double).

Tendo criado as tabelas, passemos agora para a criação das entidades Produto e Categoria. Veja o código para a entidade Categoria:

Código para Categoria.java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package entidades;

import java.io.Serializable;
import javax.persistence.*;

@Entity
@Table(name="categorias")
public class Categoria implements Serializable {
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  private int id;
  private String nome;
  
  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getNome() {
    return nome;
  }

  public void setNome(String nome) {
    this.nome = nome;
  }
}

Esta entidade não apresenta nada de novo, uma vez que o mapeamento será feito do lado "muitos", ou seja, na entidade Produto. Veja seu código agora:

Código para Produto.java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package entidades;

import java.io.Serializable;
import javax.persistence.*;

@Entity
@Table(name="produtos")
public class Produto implements Serializable {
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  private int id;
  private String descricao;
  @ManyToOne
  @JoinColumn(name="id_categoria")
  private Categoria categoria;
  private double preco;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getDescricao() {
    return descricao;
  }

  public void setDescricao(String descricao) {
    this.descricao = descricao;
  }

  public Categoria getCategoria() {
    return categoria;
  }

  public void setCategoria(Categoria categoria) {
    this.categoria = categoria;
  }

  public double getPreco() {
    return preco;
  }

  public void setPreco(double preco) {
    this.preco = preco;
  }
}

O primeiro ponto a observar é que a entidade Produto mantém uma referência a um objeto da classe Categoria. Há ainda o uso da anotação @ManyToOne para indicar o mapeamento (vários produtos para uma categoria) e @JoinColumn para indicar o campo da tabela produtos que foi usado como chave estrangeira para estabelecer a relação com a tabela categorias.

Vamos agora ao arquivo persistence.xml para que você veja como estas duas entidades são declaradas:

Código para persistence.xml:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
  http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="LocadoraService" transaction-type="RESOURCE_LOCAL">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <class>entidades.Produto</class>
    <class>entidades.Categoria</class>
    <properties>
      <property name="eclipselink.logging.level" value="FINE"/>
      <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost/estudos"/>
      <property name="javax.persistence.jdbc.user" value="root"/>
      <property name="javax.persistence.jdbc.password" value="1234"/>
    </properties>
  </persistence-unit>
</persistence>

E, finalmente, a classe principal da aplicação:

Código para EstudosJPA.java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudosjpa;

import entidades.Categoria;
import entidades.Produto;
import javax.persistence.*;

public class EstudosJPA {
  public static void main(String[] args) {
    // vamos criar o EntityManagerFactory a partir do contexto de persistência
    EntityManagerFactory emf = 
      Persistence.createEntityManagerFactory("LocadoraService");
    
    // vamos obter um objeto da interface EntityManager
    EntityManager em = emf.createEntityManager();
    
    // vamos obter a categoria com o id 2
    Categoria c = em.find(Categoria.class, 2);
    
    // vamos criar um novo produto
    Produto p = new Produto();
    p.setDescricao("Notebook HP 65");
    p.setCategoria(c); // aqui a relação é estabelecida
    p.setPreco(2543.23);
    
    // vamos persistir (gravar) a entidade no banco de dados
    em.getTransaction().begin(); // inicia a transação
    em.persist(p); // grava o objeto Produto
    em.getTransaction().commit(); // finaliza a transação
  
    em.close(); // fecha o EntityManager
    emf.close(); // fecha o EntityManagerFactory
  }
}

Ao executarmos este código, o EclipseLink vai disparar as seguintes instruções SQL:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

SELECT ID, NOME FROM categorias WHERE (ID = ?)
  bind => [2]
INSERT INTO produtos (DESCRICAO, PRECO, id_categoria) VALUES (?, ?, ?)
  bind => [Notebook HP 65, 2543.23, 2]


Link para compartilhar na Internet ou com seus amigos:

Veja mais Dicas e truques de JPA - Java Persistence Architecture API - Arquitetura de Persistência Java

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 38 usuários muito felizes estudando em nosso site.