Ajuda com hibernate @OneToMany

22 de abril de 2010 6 respostas

joshh 22 de abril de 2010

public class Aluno implements Serializable {

…

@OneToMany(cascade=CascadeType.ALL,mappedBy=“aluno”)

private List alunoCurso = new ArrayList();

…

}

public class AlunoCurso implements Serializable {
…

@ManyToOne()
@JoinColumn(name="aluno_id")
private Aluno aluno;

…
}

Tenho a classe aluno e a classe Aluno Cursos. Na hora de incluir utilizo alunoController.addAlunoCurso(Obj), adiciona o AlunoCurso no array do Aluno e grava normalmente. Porem quando utilizo alunoController.removeAlunoCurso(Obj);, debugando ele mostra que os items sairam do array, mas quando atualizo o Aluno pelo dao ele simplesmente ignora que foram deletados os AlunosCursos do Vetor. Será que meu mapeamento está incorreto?

Resumindo, ele apaga da lista mas não apaga do banco.

6 Respostas

garcia-jj 22 de abr. de 2010

Oi Josh.

Conforme a especificação:

Sendo assim se você marca um relacionamento bidirecional com o mappedBy diz que aquele lado nunca manda no relacionamento. Sendo assim basta você remover o mappedBy que quando você fizer um aluno.getCursos().clear() e salvar o aluno irá remover todos os cursos do aluno (no seu caso objetos AlunoCurso).

Abraços

ccllss 23 de abr. de 2010

Joshh,

O que essa sua classe AlunoController faz quando vc adiciona e remove um aluno?

Não basta vc remover da coleção de alunoCurso um objeto AlunoCurso, vc precisa setar neste objeto que está removendo da coleção null para o atributo aluno.

Exemplo:

public class Aluno {

    ...

    public void addAlunoCurso(AlunoCurso alunoCurso) {
        this.getAlunoCurso().add(alunoCurso);
        alunoCurso.setAluno(this);
    }

    public void removeAlunoCurso(AlunoCurso alunoCurso) {
        this.getAlunoCurso().remove(alunoCurso);
        alunoCurso.setAluno(null);
    }

    ...

}

@braços

joshh 23 de abr. de 2010

garcia-jj:
Oi Josh.

Conforme a especificação:

(Optional) The field that owns the relationship. This element is only specified on the inverse (non-owning) side of the association.

Sendo assim se você marca um relacionamento bidirecional com o mappedBy diz que aquele lado nunca manda no relacionamento. Sendo assim basta você remover o mappedBy que quando você fizer um aluno.getCursos().clear() e salvar o aluno irá remover todos os cursos do aluno (no seu caso objetos AlunoCurso).

Abraços

Realmente era esse o problema. Muito obrigado!!!

Guevara 24 de abr. de 2010

Oi joshh!
Poderia postar aqui seu form de inclusão? Estou com problemas aqui para gravar um relacionamento one-to-many, contato e mensagem.
Abraço!

joshh 25 de abr. de 2010

Guevara:
Oi joshh! Poderia postar aqui seu form de inclusão? Estou com problemas aqui para gravar um relacionamento one-to-many, contato e mensagem. Abraço!

Eu to fazendo em Swing, vou tentar mostrar mais ou menos como fiz.

Entidades:

//Aluno

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package br.com.curso.entity;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 *
 * @author Romulo
 */
@Entity
@Table(name = "ALUNO")
public class Aluno implements Serializable {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    
    @Column(length=100)
    private String nome;

    @OneToMany(cascade=CascadeType.ALL)
    private List<AlunoCurso> alunoCurso = new ArrayList<AlunoCurso>();

    @Column(length=100)
    private String cidade;

    @Column(length=100)
    private String endereco;

    @Column(length=100)
    private String bairro;

    @Column(length=9)
    private String cep;

    @Column(length=15)
    private String telefone;

    @Column(length=12)
    private String rg;

    @Column(length=14)
    private String cpf;

    @Enumerated(EnumType.STRING)
    private TipoSexoEnum sexo;

    public Aluno() {
        
    }

    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }

    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * @return the nome
     */
    public String getNome() {
        return nome;
    }

    /**
     * @param nome the nome to set
     */
    public void setNome(String nome) {
        this.nome = nome;
    }

    /**
     * @return the cursos
     */
    public List<AlunoCurso> getAlunoCurso() {
        return alunoCurso;
    }

    /**
     * @param cursos the cursos to set
     */
    public void setAlunoCurso(List<AlunoCurso> alunoCurso) {
        this.alunoCurso = alunoCurso;
    }

    /**
     * @param cursos the cursos to set
     */
    public void addAlunoCurso(AlunoCurso alunoCurso) {
        this.getAlunoCurso().add(alunoCurso);
    }

    public void removeAlunoCurso(AlunoCurso alunoCurso) {
        this.getAlunoCurso().remove(alunoCurso);
    }

    /**
     * @return the endereco
     */
    public String getEndereco() {
        return endereco;
    }

    /**
     * @param endereco the endereco to set
     */
    public void setEndereco(String endereco) {
        this.endereco = endereco;
    }

    /**
     * @return the bairro
     */
    public String getBairro() {
        return bairro;
    }

    /**
     * @param bairro the bairro to set
     */
    public void setBairro(String bairro) {
        this.bairro = bairro;
    }

    /**
     * @return the cep
     */
    public String getCep() {
        return cep;
    }

    /**
     * @param cep the cep to set
     */
    public void setCep(String cep) {
        this.cep = cep;
    }

    /**
     * @return the telefone
     */
    public String getTelefone() {
        return telefone;
    }

    /**
     * @param telefone the telefone to set
     */
    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

    /**
     * @return the rg
     */
    public String getRg() {
        return rg;
    }

    /**
     * @param rg the rg to set
     */
    public void setRg(String rg) {
        this.rg = rg;
    }

    /**
     * @return the cpf
     */
    public String getCpf() {
        return cpf;
    }

    /**
     * @param cpf the cpf to set
     */
    public void setCpf(String cpf) {
        this.cpf = cpf;
    }

    /**
     * @return the sexo
     */
    public TipoSexoEnum getSexo() {
        return sexo;
    }

    /**
     * @param sexo the sexo to set
     */
    public void setSexo(TipoSexoEnum sexo) {
        this.sexo = sexo;
    }

    /**
     * @return the cidade
     */
    public String getCidade() {
        return cidade;
    }

    /**
     * @param cidade the cidade to set
     */
    public void setCidade(String cidade) {
        this.cidade = cidade;
    }

    
}

//AlunoCurso

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package br.com.curso.entity;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

/**
 *
 * @author PHeleN
 */
@Entity
public class AlunoCurso implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;

    @ManyToOne()
    @JoinColumn(name="aluno_id")
    private Aluno aluno;

    @ManyToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="curso_id")
    private Curso curso;

    @Temporal(TemporalType.DATE)
    private Date dtMatricula;

    @Enumerated(EnumType.STRING)
    private TipoStatusAlunoCursoEnum status;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof AlunoCurso)) {
            return false;
        }
        AlunoCurso other = (AlunoCurso) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "br.com.curso.entity.NewEntity[id=" + id + "]";
    }

    /**
     * @return the aluno
     */
    public Aluno getAluno() {
        return aluno;
    }

    /**
     * @param aluno the aluno to set
     */
    public void setAluno(Aluno aluno) {
        this.aluno = aluno;
    }

    /**
     * @return the curso
     */
    public Curso getCurso() {
        return curso;
    }

    /**
     * @param curso the curso to set
     */
    public void setCurso(Curso curso) {
        this.curso = curso;
    }

    /**
     * @return the Matricula
     */
    public Date getDtMatricula() {
        return dtMatricula;
    }

    /**
     * @param Matricula the Matricula to set
     */
    public void setDtMatricula(Date Matricula) {
        this.dtMatricula = Matricula;
    }

    /**
     * @return the status
     */
    public TipoStatusAlunoCursoEnum getStatus() {
        return status;
    }

    /**
     * @param status the status to set
     */
    public void setStatus(TipoStatusAlunoCursoEnum status) {
        this.status = status;
    }

}

//GenericDao

package br.com.curso.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Map;



public interface GenericDAO<T, ID extends Serializable> {

	public void destroy();

	public T inserir(T entity) throws Exception;
	
	public T atualizar(T object) throws Exception;

	public void excluir(T object) throws Exception;
	
	public Long getSelectMax(String query);

	public Long getSelectMax(String query, Map<String, Object> params);
		
	public Integer getCount(String query);

	public Integer getCount(String query, Map<String, Object> params);

	public List<T> getNamedQuery(String namedQuery);
	
	public List<T> getTodos();
	
	public List<T> getTodos(String ordem);
	
	public T pesquisarPorId(ID id);
	
	public List<T> listPesq(String query);

	public List<T> listPesqParam(String query, Map<String, Object> params);
	
	public List<T> listPesqParam(String query, Map<String, Object> params, int maximo, int atual);
	
	public T pesqParam(String query, Map<String, Object> params);
	
	
	
}

//GenericDaoimpl

package br.com.curso.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.NoResultException;
import javax.persistence.Persistence;
import javax.persistence.Query;



public class GenericDAOImpl<T, ID extends Serializable> implements GenericDAO<T, ID> {
	
	private static EntityManagerFactory factory;
	private Class<T> tipoClasse;
	
	@SuppressWarnings("unchecked")
	public GenericDAOImpl(Class classe){
		//tipoClasse = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
		tipoClasse = classe;
	}
	
	public void destroy() {
		EntityManager manager = getEntityManagerInstance();
		manager.close();
		if (factory.isOpen())
			factory.close();
		
		System.out.println("destruindo factory...");
	}

	
	private EntityManager getEntityManagerInstance() {
		if(GenericDAOImpl.factory == null ){
			GenericDAOImpl.factory = Persistence.createEntityManagerFactory("CursoPU");
		}
		
		return GenericDAOImpl.factory.createEntityManager();
	}
	
	/** Insere a classe passada como parametro no banco de dados */
	public T inserir(T entity) throws Exception{
		EntityManager manager = getEntityManagerInstance();
		EntityTransaction trans =  manager.getTransaction();
		
		trans.begin();
		
		manager.persist(entity);
		
		trans.commit();
		manager.close();
		
		return entity;
	}
	
	/** Atualiza a classe passada como parametro no banco de dados */
	public T atualizar(T object) throws Exception {
		EntityManager manager = getEntityManagerInstance();
		EntityTransaction trans = manager.getTransaction();

		trans.begin();
		manager.merge(object);
		trans.commit();

		manager.close();
		
		return object;
	}	
	
	/** Exclui a classe passada como parametro no banco de dados */
	public void excluir(T object) throws Exception{
		EntityManager manager = getEntityManagerInstance();
		EntityTransaction trans = manager.getTransaction();
		trans.begin();
		
		if (!manager.contains(object)) //se o objeto n&#65533;o estiver persistente
			object = manager.merge(object);
		
		manager.remove(object);
		
		trans.commit();
		manager.close();		
	}
	
	/** Retorna o maior id 
	 *  @param String - query
	 *  @return Long
	 * */
	public Long getSelectMax(String query) {
		EntityManager manager = getEntityManagerInstance();

		Query q = manager.createQuery(query);
		
		Long i = (Long) q.getSingleResult();
		
		if (i == null)
			i = 0L;
		
		manager.close();
		return i + 1;
	}

	/** Retorna o maior id 
	 *  @param String - query
	 *  @param Map<String, Object> - parametros da query
	 *  @return Long
	 * */
	public Long getSelectMax(String query, Map<String, Object> params) {
		EntityManager manager = getEntityManagerInstance();

		Query q = manager.createQuery(query);
		
		for (String chave : params.keySet()) {
			q.setParameter(chave, params.get(chave));
		}
		
		Long i = (Long) q.getSingleResult();
		
		if (i == null)
			i = 0L;
		
		manager.close();
		return i + 1;
	}

	/** Retorna o total de resultados da consulta 
	 *  @param String - query
	 *  @return Integer - total
	 * */
	public Integer getCount(String query) {
		EntityManager manager = getEntityManagerInstance();

		Query q = manager.createQuery(query);
		
		Integer i = (Integer) q.getSingleResult();
		
		manager.close();
		return i;
	}
		
	/** Retorna o total de resultados da consulta 
	 *  @param String - query
	 *  @param Map<String, Object> - parametros da query
	 *  @return Integer - total
	 * */
	public Integer getCount(String query, Map<String, Object> params) {
		EntityManager manager = getEntityManagerInstance();

		Query q = manager.createQuery(query);
		
		for (String chave : params.keySet()) {
			q.setParameter(chave, params.get(chave));
		}
		
		long i = (Long) q.getSingleResult();
		
		Integer x = (int) i;
		
		manager.close();
		return x;
	}
		
	/** Retorna a pesquisa por ID (chave prim&#65533;ria - composta ou n&#65533;o) 
	 *  @return - Retorna a classe
	 * */
	public T pesquisarPorId(ID id) {
		EntityManager manager = getEntityManagerInstance();
		T object = manager.find(tipoClasse, id);
		//manager.close();
		return object; 
	}	

	/** Retorna um List com o resultado de um select do nome da namedQuery passado por parametro 
	 *  @return List<generico>
	 * */
	@SuppressWarnings("unchecked")
	public List<T> getNamedQuery(String namedQuery) {
		EntityManager manager = getEntityManagerInstance();
		Query query = manager.createNamedQuery(namedQuery);
		List<T> lista = query.getResultList();
		//manager.close();
		
		return lista;
	}

	/** Retorna um List com o resultado de um select * from... 
	 *  @return List<generico>
	 * */
	@SuppressWarnings("unchecked")
	public List<T> getTodos() {
		EntityManager manager = getEntityManagerInstance();
		String queryS = "SELECT obj FROM " + tipoClasse.getSimpleName()+ " obj";
		Query query = manager.createQuery(queryS);
		List<T> lista = query.getResultList();
		//manager.close();
		
		return lista;
	}
	
	/** Retorna um List com o resultado de um select * from...
	 *  @param String criterio(s) de ordena&#65533;&#65533;o 
	 *  @return List<generico>
	 * */
	@SuppressWarnings("unchecked")
	public List<T> getTodos(String ordem) {
		EntityManager manager = getEntityManagerInstance();
		String queryS = "SELECT obj FROM " + tipoClasse.getSimpleName()+ " obj ORDER BY obj." + ordem;
		Query query = manager.createQuery(queryS);
		List<T> lista = query.getResultList();
		//manager.close();
		
		return lista;
	}	
	/** Retorna um List com o resultado da consulta passada por parametro
	 *  @param String query
	 *  @return List<generico>
	 * */
	@SuppressWarnings("unchecked")
	public List<T> listPesq(String query) {
		EntityManager manager = getEntityManagerInstance();
		Query q = manager.createQuery(query);
		List<T> lista = q.getResultList();
		//manager.close();
		
		return lista;
	}

	
	/** Retorna um List com o resultado da consulta passada por parametro
	 *  @param String query
	 *  @param Map<String, Object> - parametros da query 
	 *  @return List<generico>
	 * */
	@SuppressWarnings("unchecked")
	public List<T> listPesqParam(String query, Map<String, Object> params) {
		EntityManager manager = getEntityManagerInstance();
		Query q = manager.createQuery(query);
		
		for(String chave : params.keySet()){
			q.setParameter(chave, params.get(chave));
		}
		List<T> lista = q.getResultList(); 
		//manager.close();
		
		return lista;
	}

	
	/** Retorna um List com o resultado da consulta passada por parametro
	 *  @param String query
	 *  @param Map<String, Object> - parametros da query 
	 *  @param int maximo - maximo de resultados
	 *  @param int atual - iniciando em atual
	 *  @return List<generico>
	 * */	
	@SuppressWarnings("unchecked")
	public List<T> listPesqParam(String query, Map<String, Object> params,
			int maximo, int atual) {
		EntityManager manager = getEntityManagerInstance();
		Query q = manager.
					createQuery(query).
					setMaxResults(maximo).
					setFirstResult(atual);
		
		for(String chave : params.keySet()){
			q.setParameter(chave, params.get(chave));
			//System.out.println("param=" + params.get(chave));
		}
		
		List<T> lista = q.getResultList();
		//manager.close();
		
		return lista;
	}	
	 
	/** Retorna uma Classe com o resultado da consulta passada por parametro
	 *  @param String query
	 *  @param Map<String, Object> - parametros da query 
	 *  @return Classe<generica>
	 * */		
	@SuppressWarnings("unchecked")
	public T pesqParam(String query, Map<String, Object> params) {
		EntityManager manager = getEntityManagerInstance();
		Query q = getEntityManagerInstance().createQuery(query);
		for(String chave : params.keySet())
			q.setParameter(chave, params.get(chave));
		
		try {
			T object = (T) q.getSingleResult();
			//manager.close();
			return object;
		}
		catch(NoResultException nre) {
			manager.close();
			return null;
		}
	}	
	
}

//AlunoController

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package br.com.curso.controller;

import br.com.curso.dao.GenericDAO;
import br.com.curso.dao.GenericDAOImpl;
import br.com.curso.entity.Aluno;
import br.com.curso.entity.AlunoCurso;
import br.com.curso.ferramentas.GLista;
import br.com.curso.ferramentas.GListaImp;
import java.util.List;
import java.util.Map;

/**
 *
 * @author PHeleN
 */
public class AlunoController {

    GenericDAO<Aluno, Integer> alunoDAO = new GenericDAOImpl<Aluno, Integer>(Aluno.class);
    GLista<Aluno> lista = new GListaImp<Aluno>(Aluno.class);
    private Aluno selecionado;

    public AlunoController() {
        lista.setList(alunoDAO.getTodos());
        selecionado = lista.first();
    }

    //Manter cadastro Aluno
    public void adicionarAluno(Aluno aluno) throws Exception {
        alunoDAO.inserir(aluno);
    }

    public void removerAluno(Aluno aluno) throws Exception {
        alunoDAO.excluir(aluno);
    }

    public void editarAluno(Aluno aluno) throws Exception {
        alunoDAO.atualizar(aluno);
    }

    public void removerAluno() throws Exception {
        alunoDAO.excluir(selecionado);
    }

    public void editarAluno() throws Exception {
        alunoDAO.atualizar(selecionado);
    }

    // ### Fim Manter cadastro Aluno

    public void atualizar() {
        lista.setList(alunoDAO.getTodos());
        setSelecionado(lista.first());
    }

    public List<Aluno> getTodos() {
        return alunoDAO.getTodos();
    }

    public List<Aluno> pesquisarParam(String query,Map<String, Object> params) {
        return alunoDAO.listPesqParam(query, params);
    }

    public void primeiro() {
        selecionado = lista.first();
    }

    public void ultimo() {
        selecionado = lista.last();
    }

    public void avancar() {
        selecionado = lista.next();
    }

    public void voltar() {
        selecionado = lista.prior();
    }

    /**
     * @return the selecionado
     */
    public Aluno getSelecionado() {
        return selecionado;
    }

    /**
     * @param selecionado the selecionado to set
     */
    public void setSelecionado(Aluno selecionado) {
        this.selecionado = selecionado;
    }

    public void removerAlunoCurso(AlunoCurso alunoCurso) {
        if (selecionado != null) {
            selecionado.removeAlunoCurso(alunoCurso);
            alunoCurso.setAluno(null);
        }

    }

}

//Agora vem a parte no meu JForm onde eu passo o Curso para a lista de cursos do aluno

atualizaObjeto(alunosController.getSelecionado()); //Atualizo objeto selecionado

        FAlunoCurso fAlunoCurso = new FAlunoCurso(this,true,alunosController.getSelecionado());//Crio JForm passando o objeto aluno que estou editando/criando
        fAlunoCurso.setLocationRelativeTo(this);
        fAlunoCurso.setVisible(true);

        if (fAlunoCurso.getSelecionado() != null) 
            alunosController.getSelecionado().addAlunoCurso(fAlunoCurso.getSelecionado()); //adiciono no aluno curso

        atualizaCampos();
        fAlunoCurso = null;

//Objeto que é retornado do fAlunoCurso

selecionado = new AlunoCurso();
            selecionado.setAluno(aluno);
            selecionado.setCurso((Curso)cCurso.getSelectedItem());
            selecionado.setDtMatricula(Data.stringToDate(eData.getText()));
            selecionado.setStatus((TipoStatusAlunoCursoEnum)cStatus.getSelectedItem());

//Ação Gravar do JForm Alunos. Ao gravar esse form ele grava automaticamente tudo que está na lista dos alunos.

Boolean erro = false;
        Aluno selecionado = alunosController.getSelecionado();
        try {

            atualizaObjeto(selecionado);

            if (incluir)
                alunosController.adicionarAluno(selecionado);
            else alunosController.editarAluno(selecionado);

            alunosController.atualizar();
            alunosController.setSelecionado(selecionado);
            atualizaCampos();

        } catch (Exception e) {
            aviso(e.getMessage(),Color.RED);
            erro = true;
        }
        if (!erro)
            aviso("Gravado com sucesso!",Color.GREEN);

Guevara 25 de abr. de 2010

Oi Joshh!
Valeu pela postagem, mas eu tô fazendo aplicação web, ai o seu código não vai ajudar, pq o meu problema não é mapeamento e sim o form mesmo, ou quem sabe as classes precisem de algum ajuste , o form só salva o nome e o email, mas não salva o assunto e a mensagem que estão na classe Mensagem.

<form action="contato/adiciona" method="post">
	
<ul>
	<c:forEach var="error" items="${errors}">   
     <li>${error.message}</li>   
	</c:forEach>  
</ul> 
<ul>	
	<li><label for="nome">Nome</label>
	<div><input name="contato.nome" type="text" maxlength="255" />
	</div>
	</li>
	
	<li><label for="email">E-mail</label>	
	<div><input name="contato.email" type="text" maxlength="255" />
	</div>
	</li>
	
	<li><label for="assunto">Assunto</label>	
	<div><input name="contato.mensagem.assunto" type="text" maxlength="255" />
	</div>
	</li>	
	
	<li><label for="mensagem">Mensagem</label>	
	<div><textarea name="contato.mensagem.mensagem" rows="5" cols="80"></textarea>
	</div>
	</li> 	

</ul>
<input type="submit" value="Enviar" />
</form>

Classe Contato:

@Entity
public class Contato {
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long idContato;
	private String nome;
	private String email;
	@OneToMany(targetEntity=Mensagem.class ,cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "contato",orphanRemoval=true)
	private List<Mensagem> mensagens = new ArrayList<Mensagem>() ;
	
	public Contato() {
	}
	
	public List<Mensagem> getMensagens() {
		return mensagens;
	}
	
	public void setMensagens(List<Mensagem> mensagens) {
		this.mensagens = mensagens;
	}
	
	public Contato(Long idContato, String nome, String email,
			List<Mensagem> mensagens) {
		this.idContato = idContato;
		this.nome = nome;
		this.email = email;
		this.mensagens = mensagens;
	}

	public Long getIdContato() {
		return idContato;
	}
	
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
}

Classe Mensagem:

@Entity
public class Mensagem {
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long idMensagem;
	private String assunto;
	private String mensagem;
	@ManyToOne
	private Contato contato;
	
	public String getAssunto() {
		return assunto;
	}
	public void setAssunto(String assunto) {
		this.assunto = assunto;
	}	
	
	public Mensagem() {
	}
	
	public Mensagem(Long idMensagem, String assunto, String mensagem,
			Contato contato) {
		this.idMensagem = idMensagem;
		this.assunto = assunto;
		this.mensagem = mensagem;
		this.contato = contato;
	}
	public Long getIdMensagem() {
		return idMensagem;
	}
	public void setIdMensagem(Long idMensagem) {
		this.idMensagem = idMensagem;
	}
	public String getMensagem() {
		return mensagem;
	}
	public void setMensagem(String mensagem) {
		this.mensagem = mensagem;
	}
	public Contato getContato() {
		return contato;
	}
	public void setContato(Contato contato) {
		this.contato = contato;
	}

}

Obrigado por responder. =)
Abraço!

Criado 22 de abril de 2010

Ultima resposta 25 de abr. de 2010

Respostas 6

Participantes 4

6 Respostas

Topicos relacionados