Olá pessoal tenho o seguinte cenário ( academia de lutas ): Tenho três tabelas ALUNO, GRAU ( que seria a faixa ), E ALUNO_GRAUS. Pelo que entendi a tebela ALUNO_GRAUS seria do tipo associativa se ela não tivesse um campo DATA. Até consigo efetuar todas as operações usando ManyToMany, porém não da para usar o campo a mais. Estou há uma semana procurando na internet, e nenhum código funcionou. Alguém poderi postar um que realmente funcione, iria quebrar um galhão obrigado!!!
Coloca o campo Data na entidade GRAU se o mesmo não fizer parte da chave composta.
Isso deve resolver seu problema :idea:
Mais no caso este campo DATA representa a data em que o aluno passou para uma determinada faixa e na tabela GRAUencontra-se somente as faixas que existem na modalidade TAEKWONDO, ENTENDEU???
Associações muitos-para-muitos são representadas, em modelos de dados, como tabela1 * ---- 1 tabela_associativa 1 ----- * tabela2.
Assim, você precisa mapear as três tabelas na JPA e representar os dados assim. Se a “tabela associativa” fossse PURAMENTE associativa, você poderia usar ManyToMany. No seu caso, você precisa mapear como mencionei.
[]´s
asaudate, me desculpe a minha falta de conhecimento, seria demais pedir para vc colocar um pequeno exemplo para mim, pois eu não entendi direito,. Sempre que eu persistir um aluno, preciso que sejam persistido um List<aluno_grau> com vários aluno_grau, e cada objeto deste, por sua vez, tem uma data. a data é do aluno_grau e não do grau em si, que não possui data alguma. vc pode me ajudar?
Bom, pelo q entendí , ficaria assim:
Aluno:
@Entity
public class Aluno {
@OneToMany (mappedBy="aluno")
List<AlunoGrau> relacionamentos;
}
AlunoGrau:
@Entity
public class AlunoGrau {
@ManyToOne
Aluno aluno;
@ManyToOne
Grau grau;
Date dataGrau;
}
Grau:
@Entity
public class Grau {
@OneToMany (mappedBy="grau")
List<AlunoGrau> relacionamentos;
}
Cara ficou assim, mais não funcionou!!!
@Entity
@Table(name = "ALUNO_GRAUS")
public class aluno_grau implements Serializable{
@Id
@ManyToOne
private aluno aluno;
@Id
@ManyToOne
private grau grau;
@Column(name = "DATA")
@Temporal(TemporalType.DATE)
private Date data = new Date();
@Entity
@Table(name = "ALUNOS")
public class aluno extends pessoaFisica {
@OneToMany(mappedBy="aluno")
private List<aluno_grau> aluno_graus = new ArrayList<aluno_grau>();
@Entity
@Table(name = "GRAUS")
public class grau implements Serializable{
@OneToMany(mappedBy="grau")
private List<aluno_grau> aluno_graus = new ArrayList<aluno_grau>();
o QUE ESTOU FAZENDO DE ERRADO???
Posta a mensagem de erro.
Aproveitando… como a pessoa fisica está mapeada?
E porque esta herança não está demarcada no aluno?
Está assim:
[code]
//pesso.java
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public abstract class pessoa implements Serializable{
private static final long serialVersionUID = 7547711617077056071L;
@Id
@Column(name = "ID")
protected Integer id = 0;
//geters e seters
//pessoafisica.java
@SuppressWarnings(“serial”)
@Entity
public class pessoaFisica extends pessoa {
@Column(name = "NOME")
private String nome;
@Column(name = "DATA_NASCIMENTO")
@Temporal(TemporalType.DATE)
private java.util.Date data_nascimento;
@Column(name = "PAI")
private String pai;
@Column(name = "MAE")
private String mae;
@Column(name = "IDENTIDADE")
private String identidade;
@Column(name = "CPF")
private String cpf;
@Column(name = "TITULO")
private String titulo;
@Lob
@Column(name = "FOTO")
private byte[] foto;
@Column(name = "SEXO")
private String sexo;
@Column(name = "PROFISSAO")
private String profissao;
@Column(name = "CELULAR")
private String celular = "";
/// geters e seters
@Entity
@Table(name = “ALUNOS”)
@SuppressWarnings(“serial”)
public class aluno extends pessoaFisica {
@Column(name = "DATA_INCLUSAO")
@Temporal(TemporalType.DATE)
private java.util.Date data_inclusao;
@Transient
private boolean marcadoParaDeletar = false;
@OneToMany(mappedBy="aluno")
private List<aluno_grau> aluno_graus = new ArrayList<aluno_grau>();
etc.
//aluno_grau.java
@Entity
@Table(name = “ALUNO_GRAUS”)
public class aluno_grau implements Serializable{
@Id
@ManyToOne
private aluno aluno;
@Id
@ManyToOne
private grau grau;
@Column(name = "DATA")
@Temporal(TemporalType.DATE)
private Date data = new Date();
//grau.java
@Entity
@Table(name = “GRAUS”)
public class grau implements Serializable{
…
@OneToMany(mappedBy=“grau”)
private List<aluno_grau> aluno_graus = new ArrayList<aluno_grau>();
…
erro
Caused by: org.hibernate.AnnotationException: mappedBy reference an unknown target entity property: aftiv.associativas.aluno_grau.grau in aftiv.graus.grau.aluno_graus
at org.hibernate.cfg.annotations.CollectionBinder.bindStarToManySecondPass(CollectionBinder.java:576)
at org.hibernate.cfg.annotations.CollectionBinder$1.secondPass(CollectionBinder.java:541)
at org.hibernate.cfg.CollectionSecondPass.doSecondPass(CollectionSecondPass.java:66)
at org.hibernate.cfg.Configuration.secondPassCompile(Configuration.java:1163)
at org.hibernate…
Desculpe, clarinetabest …
Existe uma série de erros no seu mapeamento, desde a herança, que está mapeada errada, até a chave composta da tabela…
Tente pegar um manual de Hibernate e dê uma boa revisada nos conceitos.
[]´s
um pouco desencorajador, mas tudo bem é válido.
Vou tentar mais uma vez
Herança: estou utilizando tabela por classe concreta, qual estratégia seria melhor?
e que ponto eu deveria revisar? utilizando ManyToMany eu consegui fazer tudo que eu queria, o único problemaa foi que eu precisei do campo data, quais foram os erros???
[quote=clarinetabest]um pouco desencorajador, mas tudo bem é válido.
Vou tentar mais uma vez
Herança: estou utilizando tabela por classe concreta, qual estratégia seria melhor?
e que ponto eu deveria revisar? utilizando ManyToMany eu consegui fazer tudo que eu queria, o único problemaa foi que eu precisei do campo data, quais foram os erros???[/quote]
Bom… começando pela chave composta, percebí que a idéia era fazer com que aluno e grau fossem ID da classe de relacionamento, certo? Assim, você deveria criar uma nova classe que contém os dados da chave composta e usar @EmbeddedId.
Na herança, você usa @MappedSuperclass na superclasse e @InheritanceStrategy nas subclasses.
Bom da herança eu não sabia, mais não de erro, mas vou refazer, ja a chave composta eu fiz uma IdClass para a chave composta da classe aluno_grau onde pus uma referência da mesma, mais deu erro. VC acha que eu deveria criar um outro id em aluno_grau, e encarar aluno_grau.aluno e aluno_grau.grau apenas como FK?
Sim, acho que fica mais legível e mais fácil pro BD gerenciar também.