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 JPAQuantidade 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 |
Python - Como excluir e retornar um item da lista Python baseado em seu índice usando a função pop() |
Códigos Fonte |
Software 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 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 |