Olá tudo bem ?
Para concluir o post de mapeamento de entidade com hibernate, relacionamento ManyToMany (Muitos para Muitos).
Como exemplo vamos fazer um relacionamento entre Cliente e Produto.
Vários Cliente pode ter vários Produtos e vários Produto pode ter vários Clientes.
Crie um database no banco de dados chamada manytomany.
Crie um projeto Dynamic Web Project chamado MapeamentoManyToMany adicione as lib do hibernate no projeto e configure o arquivo persistence.xml para se comunicar com a database.
persistence.xml
1.1 Crie uma classe chamada Cliente dentro do package br.com.vejajava.entidades
@Entity
@Table(name="cliente")
public class Cliente {
@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private Long codigo;
private String nome;
@ManyToMany
@JoinTable(name = "cliente_produto", joinColumns = {@JoinColumn(name = "cod_cliente")},
inverseJoinColumns ={@JoinColumn(name = "cod_produto")})
private List produtos = new ArrayList();
//getters e setters
}
Observe que no mapeamento com a classe produto temos a anotação @JoinTable essa anotação é opcional, caso você não declare ela criará o nome da classe seguida de "_" mais um novo da classe que está sendo mapeada.
Veja que temos também a anotação @JoinColumns e @InverseJoinColumns elas define o quais colunas fazem parte da chave primaria.
1.2 Crie uma classe chamada Produto dentro do package br.com.vejajava.entidades
@Entity
@Table(name = "produto")
public class Produto {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long codigo;
private String descricao;
@Column(scale = 2, precision = 4)
private double preco;
//getters e setters
}
Observe a anotação @Column seguida de
scale e
precision.
A anotação
scale: define a quantidade de casas decimais e anotação.
A anotação
precision: define a quantidade de digitos que serão armazenados.
Como estamos mostrando um relacionamento Uniderecional a classe Produto nao terá o mapeamento para a classe Cliente.
1.3 Crie uma classe ManyToMany dentro do package br.com.vejajava.principal
Vamos adicionar alguns produtos e fazer o relacionamento com os clientes.
EntityManagerFactory factory = Persistence.createEntityManagerFactory("MapeamentoManyToMany");
EntityManager manager = factory.createEntityManager();
manager.getTransaction().begin();
Produto p1 = new Produto();
p1.setDescricao("Açucar");
p1.setPreco(1.50);
Produto p2 = new Produto();
p2.setDescricao("Macarrão Favorita");
p2.setPreco(1.50);
Cliente c1 = new Cliente();
c1.setNome("Maria");
c1.getProdutos().add(p1);
c1.getProdutos().add(p2);
Cliente c2 = new Cliente();
c2.setNome("José");
c2.getProdutos().add(p2);
manager.persist(p1);
manager.persist(p2);
manager.persist(c1);
manager.persist(c2);
manager.getTransaction().commit();
manager.close();
factory.close();
Verifique no banco de dados que foi criado três tabelas
Cliente: Temos dois cliente cadastrado.
Produto: Temos dois produtos cadastro
Cliente_Produto: Aonde o codigo do cliente se referencia ao codigo do produto, observe que no cliente Maria adicionamos dois produtos por isso na tabela ele faz o relacionamentos para os dois produtos cadastrado.
mysql> select * from cliente;
+--------+-------+
| codigo | nome |
+--------+-------+
| 1 | Maria |
| 2 | José |
+--------+-------+
mysql> select * from produto;
+--------+--------------------+-------+
| codigo | descricao | preco |
+--------+--------------------+-------+
| 1 | Açucar | 1.5 |
| 2 | Macarrão Favorita | 1.5 |
+--------+--------------------+-------+
mysql> select * from cliente_produto;
+-------------+-------------+
| cod_cliente | cod_produto |
+-------------+-------------+
| 1 | 1 |
| 1 | 2 |
| 2 | 2 |
+-------------+-------------+
Obrigado pela visita = D
