Mapeamento Hibernate

ninguém?

São clientes do mesmo tipo? Eu creio que não, logo, a classe compra possui um Comprador e um Vendedor (Cliente seria, apenas, uma superclasse de ambos).

drsmachado, vlw ae pela resposta…

Mas são clientes exatamente iguais.

Imagine que eu estou te vendendo uma parada hoje. Eu sou o vendedor e você o comprador, mas amanhã pode ser o inverso, sacou?

ou seja vai haver dois relacionamentos com a mesma tabela Compras vai ter um comprador (Cliente) e um vendedor (Cliente).

Se puder me dar uma luz agradeço.

Não acho que a modelagem esteja correta. Você mesmo disse que tem um Comprador e um Vendedor, se ambos podem ser clientes use composição ou herança e crie um tipo pra cada.

Não entendi? Eu tenho dois clientes, vou usar herança só pra dar um nome diferente e chamar um de comprador e outro de vendedor? não me parece correto… A única questão é que um uma hora poderá ser vendedor e outra hora comprador, mas os dados são os mesmos.

Vou tentar explicar melhor.

Imagine o mercado livre. A tabela de clientes dele não distingue comprador de vendedor. Todos são potenciais compradores e vendedores. É mais ou menos isso. o que vai mudar é na regra de negócio e não na tabela.

Quando for mapear uma compra, você vai ter um cliente comprador e um cliente vendedor.

Consegui explicar melhor?

diogogama:

Vou tentar explicar melhor.

Imagine o mercado livre. A tabela de clientes dele não distingue comprador de vendedor. Todos são potenciais compradores e vendedores. É mais ou menos isso. o que vai mudar é na regra de negócio e não na tabela.

Quando for mapear uma compra, você vai ter um cliente comprador e um cliente vendedor.

Consegui explicar melhor?

public class Compra{
    private Cliente vendedor;
    private Cliente comprador;
    //Outros atributos
    //Getters e setters
}

Poxa, então vocês não leram minha dúvida???

Se olharem a classe Compra lá tem os dois atributos, minha dúvida foi o mapeamento, peço por favor que leiam minha primeira msg para poderem me ajudar, pois lá está feito da forma que falaram.

Camarada,

Eles estão certos, faz assim:
cria a classe pai chamado pessoa
Pessoa terá classes filhas chamadas Comprador, Vendedor etc

Na tua classe compra terá algo do tipo:

public class Compra {
 Pessoa comprador = new Comprador();
 Pessoa vendedor = new Vendedor();

}

Lá no teu banco de dados vc pode criar a tabela Pessoa de várias formas recomendo que vc crie apenas uma tabela chamada pessoa lá vc coloca um campo chamado tipo(0 - comprador, 1 - vendedor)

Não esquece de por {RESOLVIDO} no titulo do post

porra... ta foda hoje hein... rs...

Vocês viram lá em cima na pergunta que coloco

public class Cliente implements Serializable {  
@OneToOne(mappedBy = "comprador")  
    private Compra compra;  
 @OneToOne(mappedBy = "vendedor")  
    private Compra venda;  
}

public class Compra implements Serializable { 
@OneToOne(cascade = CascadeType.ALL)  
    private Cliente comprador;  
    @OneToOne(cascade = CascadeType.ALL)  
    private Cliente vendedor;  
}

ou seja, minha classe compra já compõe 2 clientes... comprador e vendedor... minha dúvida é como faço esse mapeamento...

Ps.: Vou colocar resolvido quando tiver resolvido, não se preocupe que não esqueço....

Por nada camarada, é sempre um prazer ajudar.

Então me ajuda…

Um cliente do tipo comprador ter muitas compras.
Um cliente do tipo vendedor tem muitas vendas.
Uma compra terá um vendedor e um cliente.

public class Cliente implements Serializable {   
	@OneToMany(mappedBy = "comprador")
	private List<Compra> compras;

	@OneToMany(mappedBy = "vendedor")
	private List<Compra> vendas;
}

public class Compra implements Serializable {   
	@ManyToOne
	private Cliente comprador;
	@ManyToOne
	private Cliente vendedor;
}

alexporto90:

Um cliente do tipo comprador ter muitas compras.
Um cliente do tipo vendedor tem muitas vendas.
Uma compra terá um vendedor e um cliente.

public class Cliente implements Serializable {   
	@OneToMany(mappedBy = "comprador")
	private List<Compra> compras;

	@OneToMany(mappedBy = "vendedor")
	private List<Compra> vendas;
}

public class Compra implements Serializable { @ManyToOne private Cliente comprador; @ManyToOne private Cliente vendedor; }

Se vai ter só uma entidade mesmo para representar os dois. É isso aí. Faltava trocar por @ManyToOne.
Agora, seguindo assim como é que você vai diferenciar quando é comprador e quando é vendedor? Nunca haverão haver regras diferentes para quando é um ou outro?

Outra coisa, como é que você validaria estes atributos? O.o

private String cpfOuCnpj; private String rgOuInscricaoEstadual;