Relacionamentos do mapeamento OR

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

Parte III
Mapeamento de Relacionamentos

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;

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.

Entendendo
Empresa

Diretor

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;
...
}

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;

Outro Exemplo

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

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;

Mais um exemplo

@Entity
...
@OneToMany(cascade=ALL, mappedBy="cliente")
private Set<Pedido> pedidos;
...
}

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.

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;

Outro exemplo
@Entity
...
@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;
...
}

Considerações

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

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.

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;
}
}

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;

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;

Prática

• Atualize as classes anteriores conforme o
diagrama abaixo:

Relacionamentos do mapeamento OR

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Relacionamentos do mapeamento OR (20)

Mais de Nécio de Lima Veras (20)

Relacionamentos do mapeamento OR