Como salvar as associações Hibernate?[Resolvido]

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "grupos")   
    private Set<Participantes> participanteses = new HashSet<Participantes>(0);

@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)  
@JoinColumn(name = "Grupos_idGrupos")  
private Grupos grupos;

Session sessao = SessionFactory.getSession();  
Transaction tx = sessao.beginTransaction();  
  
Grupos grupos = new Grupos();  
Participantes participantes = new Participantes();  
  
participantes.setNome("Nome Qualquer");  
participantes.setEmail("[email removido]");  
participantes.setCpf("xxx.xxx.xxx-xx");  
participantes.setGrupos(grupos); //<<==== VC PRECISA SETAR O GRUPO!
  
grupos.setNome("Xique Mill");  
grupos.getParticipanteses().add(participantes);  // <=== ISSO AQUI NÃO SETA O GRUPO SOZINHO
  
sessao.save(participantes);   
  
tx.commit();  
sessao.close();

public class Grupos implements java.io.Serializable { //....
   boolean addParticipante(Participante p) {
     if (p != null) {
        p.setGrupos(this);
        return getParticipantes().add(p);
     } else
        return false;
   }

ids for this class must be manually assigned before calling save()

sessao.save(grupos);

@Entity
@Table(name = "Grupos", catalog = "database_bgp")
public class Grupos implements java.io.Serializable {

	// Fields

	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "idGrupos", unique = true, nullable = false)
	private Integer idGrupos;
	
	@Column(name = "nome", length = 45)
	private String nome;
	
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "grupos")
	private Collection<Participantes> participantes;

	// Constructor, get and set

@Entity
@Table(name = "Participantes", catalog = "database_bgp")
public class Participantes implements java.io.Serializable {

	// Fields
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "idParticipantes", unique = true, nullable = false)
	private Integer idParticipantes;
	
	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "idGrupos")
	private Grupos grupos;
	
	@Column(name = "nome", length = 95)
	private String nome;
	
	@Column(name = "email", length = 65)
	private String email;
	
	@Column(name = "cpf", length = 14)

	// Constructor, get and set

Session sf = SessionFactory.getSession();
		
		Grupos grupos = new Grupos();
		grupos.setNome("Stratovarius");
		
		Participantes part = new Participantes();
		part.setNome("Fabiano Fernandes");
		part.setCpf("xxx.xxx.xxx-xx");
		part.setEmail("[email removido]");
		part.setGrupos(grupos);
			
		grupos.setParticipantes(new HashSet<Participantes>());
		grupos.getParticipantes().add(part);
		
		
		Transaction tx = sf.beginTransaction();
		sf.save(grupos);
		tx.commit();
		sf.close();

-----------                -----------------               ---------------  
| Aluno   |                |     Reserva     |             |   Livro      |  
-----------                -----------------               ---------------  
| idAluno | <------------->| idReserva - PK  | <---------->| idLivro      |  
|         |                | idAluno -FK     |             |              |  
-----------                | idLivro -FK     |              ---------------  
                           | dtLocacao       |    
                           -------------------

---------------- ---------- ---------- -------------
 |  idReserva    | idAluno | idLivro  |  dtLocacao  |
 ---------------- ---------- ---------- -------------           
 |     1         |     1   |     5    |  2012-08-18 |
 |     2         |     1   |     2    |  2012-08-18 |
 |     3         |     1   |     8    |  2012-08-18 |
 --------------- ----------- ------------------------

@Entity
@Table(name = "aluno", catalog = "baselibrus")
public class Aluno implements java.io.Serializable {

	private Integer idAluno;
	private List<Livro> livros;
	
   
    @Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "idAluno", unique = true, nullable = false)
	public Integer getIdAluno() {
		return idAluno;
	}

	public void setIdAluno(Integer idAluno) {
		this.idAluno = idAluno;
	}

        
    @ManyToMany
	@JoinTable(name = "reserva",
	joinColumns =  @JoinColumn( name = "idAluno"),
    inverseJoinColumns = @JoinColumn(name = "idLivro") )
	public List<Livro> getLivros() {
		return livros;
	}

	public void setLivros(List<Livro> livros) {
		this.livros = livros;
	}
}

@Entity
@Table(name = "reserva", catalog = "baselibrus")
public class Reserva implements java.io.Serializable {

	private Integer idReserva;
	private Aluno aluno;
	private Livro livro;
	private Date dtLocacao;
	
    @Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "idReserva", unique = true, nullable = false)
	public Integer getIdReserva() {
		return this.idReserva;
	}

	public void setIdReserva(Integer idReserva) {
		this.idReserva = idReserva;
	}

	
	@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinColumn(name="idAluno", insertable = false, updatable = false)
	public Aluno getAluno() {
		return aluno;
	}

	public void setAluno(Aluno aluno) {
		this.aluno = aluno;
	}
	
	
	@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinColumn(name="idLivro", insertable = false, updatable = false)
	public Livro getLivro() {
		return livro;
	}

	public void setLivro(Livro livro) {
		this.livro = livro;
	}
	
	
	@Temporal(TemporalType.DATE)
	@Column(name = "dtLocacao", length = 10)
	public Date getDtLocacao() {
		return this.dtLocacao;
	}

	
	public void setDtLocacao(Date dtLocacao) {
		this.dtLocacao = dtLocacao;
	}
	
	
}

@Entity
@Table(name = "livro", catalog = "baselibrus")
public class Livro implements java.io.Serializable {

	private Integer idLivro;
	
    @Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "idLivro", unique = true, nullable = false)
	public Integer getIdLivro() {
		return idLivro;
	}

	public void setIdLivro(Integer idLivro) {
		this.idLivro = idLivro;
	}

}

@Embeddable
public class ReservaId implements java.io.Serializable {  
    @ManyToOne
    private Aluno aluno;  
   @ManyToOne
    private Livro livro; 

//getter e setters 
}

//Na classe Reserva
@Entity
public class Reserva{
    @EmbeddedId
    private ReservaId id;

//getters e setters
}

//Na hora de salvar eu faria isso
public void salvaReserva(Aluno a, List<Livro> livros){
   for(Livro l:livros){
    Reserva r = new Reserva();
    reserva.getId.setAluno(a);// Como o aluno seria constante então precisamos somente de um
   reserva.getId.setLivro(l);
    ...
    session.save()
   ....
  }
}

//na classe livro
@OneToMany(mappedBy="id.livro")
private Reserva reserva;

//na classe aluno
@OneToMany(mappedBy="id.aluno")
private Reserva reserva;