O documento discute mapeamento objeto-relacional usando anotações JPA. Ele explica como mapear diferentes tipos de relacionamentos entre entidades, incluindo atributos compostos, relacionamentos um-para-um, um-para-muitos, muitos-para-um e muitos-para-muitos. Também aborda cascateamento, carregamento de associações e uso de classes internas para mapear relacionamentos muitos-para-muitos com atributos.

1. Programação Orientada a Objetos
Estudo de Frameworks
(Mapeamento Objeto-Relacional em Java)
Objetivo: Identificar os processos de
mapeamento Objeto-Relacional
Prof. Nécio de Lima Veras

2. Parte III
Mapeamento de Relacionamentos

3. Atributos compostos
• Se a entidade possuir um atributos que,
em sua abstração, deve ser dividido em
outros campos, então usa-se a anotação
@Embeddable
• Ou seja, este campo, na verdade foi
promovido à classe;

4. Visualizando Relações
• Se a entidade possuir uma propriedade
composta cujo tipo é uma outra entidade:
– use a anotação @OneToOne em uma propriedade do
tipo correspondente;
– Em associações one-to-one bidirecionais, usamos o
atributo mappedBy para explicitar o lado não
proprietário da associação.

5. Entendendo
Empresa
Diretor

6. Mais Exemplos
@Entity
public class Cliente {
...
@OneToOne
@JoinColumn(name="iConjugeId", unique=true,
nullable=false, updatable=false)
public Conjuge conjuge;
...
}
@Entity
public class Conjuge {
...
@OneToOne(mappedBy="conjuge")
public Cliente cliente;
...
}

7. Prática

8. Relacionamento
de muitos para um
● Se a entidade faz parte de uma coleção de
entidades de outras entidades:
● Use a anotação @ManyToOne para uma
propriedade que representará a entidade dona
da coleção;

9. Outro Exemplo
@Entity
public class Pedido {
...
@ManyToOne
@JoinColumn(name="ClienteID", nullable=false)
private Cliente cliente;
...
}

10. De um para muitos
• Se a entidade possui uma coleção de outras
entidades:
– Use a anotação @OneToMany para uma propriedade
que representará a coleção;

11. Mais um exemplo
@Entity
public class Cliente {
...
@OneToMany(cascade=ALL, mappedBy="cliente")
private Set<Pedido> pedidos;
...
}

12. Observações
• Em caso de associações bidirecionais, em uma
classe temos um atributo OneToMany e na outra
classe (a que detém a chave estrangeira) temos
um atributo ManyToOne.
– No lado OneToMany de uma associação
bidirecional, usamos o atributo mappedBy para
explicitar que o relacionamento (chave
estrangeira) fica no lado oposto (inverso) da
associação.

13. Prática

14. De muitos para muitos
• Se duas entidades possuem coleções umas das
outras:
– Então ambas entidades terão propriedades de coleção
com a anotação @ManyToMany;

15. Visualizando
@ManyToMany

16. Outro exemplo
@Entity
public class Cliente {
...
@ManyToMany
@JoinTable(
name="PhoneCli",
joinColumns=
@JoinColumn(name="iCli_ID", referencedColumnName="ID"),
inverseJoinColumns=
@JoinColumn(name="iFone_ID", referencedColumnName="ID")
)
private Set<Telefone> fones;
...
}
@Entity
public class Telefone {
...
@ManyToMany(mappedBy="fones")
private Set<Cliente> clientes;
...
}

17. Considerações
• Novamente, o mappedBy fica do lado não
proprietário da associação e é usado em
associações bidirecionais.
• Prática:

18. ManyToMany com atributo
• E se caso a associação N:N possuir um
(ou mais) atributo(s) intermediário(s) não-
chave?
• Solução:
1.Mapear a classe N:N;
2.Criar uma classe está-
tica interna com suas
chaves.
3.Criar as relações “ManyToOne” com as tabelas
que fornecem as chaves.

19. Visualizando em termos de
código
@Embeddable
private static class Id {
@Column (name = "idAviao")
private int idAviao;
@Column (name = "idAeroporto")
private int idAeroporto;
public int getIdAviao() {
return idAviao;
}
public void setIdAviao(int idAviao) {
this.idAviao = idAviao;
}
public int getIdAeroporto() {
return idAeroporto;
}
public void setIdAeroporto(int
idAeroporto) {
this.idAeroporto = idAeroporto;
}
}

20. Cascateamento
• O cascateamento pode ser usado para propagar operações para
classes associadas;
• Tipos:
– ALL – Todas as operações possíveis são cascateadas para as
classes associadas.
– MERGE – Se a entidade fonte estiver “merged”, o merge é
cascateado para as classes associadas.
– PERSIST – Se a entidade fonte for persistida, a persistência é
cascateada para as classes associadas.
– REFRESH – Se a entidade fonte for atualizada, a atualização é
cascateada para as classes associadas.
– REMOVE – Se a entidade fonte for removida, as classes
associadas também serão removidas.
• Exemplo:
@OneToMany(cascade={CascadeType.REMOVE})
private List<Pessoa> dependentes;

21. Carregando as Associações
• A associações podem ser carregadas de duas formas:
– EAGER – A associação é carregada juntamente com a classe
base.
@OneToMany(fetch=FetchType.EAGER)
– LAZY – A associação somente é carregada quando for usada.
• @OneToMany(fetch=FetchType.LAZY)
• Em associações ManyToOne e OneToOne, EAGER é padrão.
• Em associações OneToMany e ManyToMany, LAZY é padrão.
– As coleções só são inicializadas quando houver necessidade;
– Apenas quando algum método que acesse o conteúdo da coleção
for executado é que ela será preenchida;

22. Prática
• Atualize as classes anteriores conforme o
diagrama abaixo: