Princípios de bons Relacionamentos

-O primeiro princípio necessário para a correta utilização dos relacionamentos é: 

Todo relacionamento tem que ter um lado dominante. 

O que quer dizer lado dominante? Qual tabela do banco de dados terá a chave estrangeira. É possível definir o nome da chave estrangeira através da anotação @JoinColum
como no código:

@OneToOne
@JoinColumn(name = "id_nome_chave")

A anotação tem o atributo name para indicar qual deve ser o nome da chave localizada na tabela.


-O segundo princípio a se entender sobre relacionamentos é: 

Pode existir relacionamento Unidirecional ou Bidirecional. 

Um relacionamento unidirecional é o relacionamento em que apenas uma entity conhece a outra; 

E o Bidirecional ambas se conhecem, porém é necessário informar qual é o lado dominante, adicionando o atributo mappedBy no relacionamento que não for dominante.

CascadeType.

O CascadeType é uma maneira de definir a forma como serão propagadas as operações em cascata de uma Entity para suas referencias. A vantagem do Cascade é a propagação automaticamente da ação configurada nos relacionamentos da entidade.

As definições do Cascade são passadas dentro das anotações @OneToOne, @OneToMany e @ManyToMany, e as possibilidades de valores para o Cascade podem ser encontradas dentro de um enum javax.persistence.CascadeType.

Tipos:

• CascadeType.PERSIST– disparado toda vez que uma nova entity for inserida no banco de dados pelo comando entityManager.persist();
• CascadeType.DETACH – disparado toda vez que uma entity é retirada do Persistence Context. Comandos que podem disparar essa ação: entityManager.detach(), entityManager.clear(). Ocorrerá um detach também quando o Persistence Context deixar de existir;
• CascadeType.MERGE – disparado toda vez que uma alteração é executada em uma entity. Essa alteração pode acontecer ao final de uma transação com a qual uma managed Entity foi alterada (4.2), ou pelo comando entityManager.merge();
• CascadeType.REFRESH – disparada quando uma entity for atualizada com informações no banco de dados. Comando: entityManager.refresh();
• CascadeType.REMOVE – disparado quando uma entity é removida (apagada) do banco de dados, os relacionamentos marcados também serão eliminados O comando utilizado é o entityManager.remove();
• CascadeType.ALL – todos os eventos anteriores serão sempre refletidos nas Entities relacionadas.

Exemplo para setar apenas um tipo de Cascade:

@OneToMany(cascade = CascadeType.ALL)
private List usuarios;

Exemplo para setar um ou mais tipos, (porém não todos):

@OneToMany(cascade ={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REMOVE })
private List usuarios;

Observações sobre o Cascade:

• É preciso ter bastante cuidado ao anotar um relacionamento com CascadeType.ALL. Uma vez que se a entidade fosse removida o seu relacionamento também seria removido do banco de dados.
• CascadeType.ALL (ou opções únicas) pode causar lentidão em todas as ações realizadas na entidade. Caso a entidade tenha muitas listas um merge() poderia causar todas as listas a receberem merge().

Relacionamento OneToOne

Confesso que sempre me confundo um pouco com os relacionamentos do Hibernate, por isso hoje vou falar do Relacionamento @OneToOne (com annotation) e posteriormente sobre os demais.

Relacionamento convencional @OneToOne

O relacionamento convencional um-para-um trata-se de um relacionamento onde os atributos das entidades relacionadas serão persistidas em tabelas distintas. O relacionamento das classes Pessoa e Endereço em um relacionamento convencional um-para-um é declarado da seguinte forma:

package testes;

import javax.persistence.*;

@Entity

public class Pessoa {

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String nome;

@OneToOne(cascade = CascadeType.ALL)

private Endereco endereco;

//get's e set's
}

package testes; 

import javax.persistence.*;

@Entity

public class Endereco { 

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String logradouro;

@OneToOne(mappedBy = "endereco")

private Pessoa pessoa;

//get's e set's
}

O annotaion @OneToOne(mappedBy = "endereco") serve para indicar um relacionamento bidirecional, informando que Endereço é o final do relacionamento entre Pessoa-Endereço e que é mapeado em Pessoa pelo atributo endereço. Ou seja, a tabela Pessoa terá a chave estrangeira para Endereço. Com esses Annotations, o Hibernate irá criar duas tabelas: Pessoa e Endereço com os seguintes atributos:

Pessoa
id bigint not null
nome varchar(255)
endereco_id bigint

Endereco
id bigint not null
logradouro varchar(255)

Podemos também declarar um relacionamento unidirecional. Para isso basta não declarar o atributo Pessoa em Endereço:

package testes; 

import javax.persistence.*; 

@Entity

public class Endereco { 

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String logradouro;
//get's e set's}

Embedded

O relacionamento "embedded one-to-one" trata-se de um relacionamento onde os atributos das entidades relacionadas serão persistidas na mesma tabela.
Por exemplo temos uma classe Pessoa que tem um relacionamento um-para-um com a classe Endereço, esse relacionamento será definido da seguinte forma:

package testes;
import javax.persistence.*;
@Entity

public class Pessoa { 

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String nome; 

@Embedded

private Endereco endereco;
//get's e set's
}

package testes;

import javax.persistence.Embeddable;

@Embeddable 

public class Endereco {

private String logradouro;

//get's e set's

}

Com esses 'Annotations', o Hibernate irá criar uma tabela Pessoa com os seguintes atributos:

id bigint not nulllogradouro varchar(255)
nome varchar(255)