Hibernate: Mapping utenti-Amici rapporto in Social Networks

Question

E 'un bel po' di tempo che sto cercando di capire questo problema e da googling intorno molte persone hanno problemi simili.

Sto cercando di modellare un utente in un Social Network, usando Hibernate, e ciò che è più fondamentale di una rete sociale che per mappare un rapporto di amicizia? Ogni utente del sistema dovrebbe avere una lista di E 'amici e ho pensato che questo potrebbe essere un compito incredibilmente facile (basta usare un rapporto ManyToMany, giusto?). Così sono andato a provare il seguente:

@Entity
@Table(name="users")
public class User {
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   @Column(name="userid")
   protected Long id = null;
   @ManyToMany
   protected List<User> friends = null
}

Il problema ora è che mi dice che io uso ManyToMany torto avendo una chiara distinzione tra amico e amicizia. Fin qui tutto bene, ottengo l'errore, ma come posso fare quello che voglio?

Qualche idea? Ho raggiunto la fine della mia saggezza.

Answer 1

Il fatto che riguarda molti a molti è che ha bisogno di un po 'più di configurazione, perché il suo imperativo che Hibernate genera una tabella relazione. Prova questo:

@Entity
@Table(name="users")
public class User {
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   @Column(name="userid")
   protected Long id = null;
   @ManyToMany
   @JoinTable(name = "user_friends", 
       joinColumns = @JoinColumn(name = "user_id"), 
       inverseJoinColumns = @JoinColumn(name = "friend_id"))
   protected List friends = null;
   @ManyToMany(mappedBy = "friends")
   protected List befriended = null;
}

Spero che funziona =)

EDIT: Inoltre, essere molto attenti con prendere i tipi ... è possibile inserire un utente recupero loop out-of-control e ottenere tutte le DB.

Answer 2

L'annotazione ManyToMany ha un parametro mappedBy. Credo che qualcosa di simile

@ManyToMany(mappedBy = "friends")

potrebbe funzionare. In ogni caso, vedere la docs .

Modifica:

E 'come se una relazione molti a molti deve essere accessibile da entrambe le estremità. Attualmente il vostro è accessibile solo da un capo all'altro. Forse si dovrebbe aggiungere l'altra relazione così:

@Entity
@Table(name="users")
public class User {
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   @Column(name="userid")
   protected Long id = null;
   @ManyToMany
   protected List<User> friends = null;
   @ManyToMany(mappedBy = "friends")
   protected List<User> befriended = null;
}

Se questo non funziona si può sempre introdurre una classe separata che rappresenta la relazione tra due utenti, e lasciare che ogni utente ha una raccolta di istanze di questa classe.

Answer 3

Buon punto, e infatti ho provato. Il problema è che ho poi ricevo una denuncia circa l'attributo mappedBy stato impostato su entrambi i lati della relazione, che è vero, ma non valida. Mi chiedevo che scendessimo un semplice @ManyToMany con alcune query personalizzata intelligente per recuperare i tuoi amici potrebbe essere una soluzione: Il ManyToMany genererebbe un tavolo unirsi user_id e friend_id, ma la query sarebbe abbinare uno dei campi, di ritorno in cui tutti gli utenti che corrispondono né la friend_id o user_id che è. Tutte le idee?

Answer 4

Che ovviamente sarebbe un buon correzione, ma non sono ancora del tutto venduto. In sostanza per ottenere gli amici che avrei dovuto unire le due collezioni, che è abbastanza soddisfacente.

C'è assolutamente alcun modo per creare un idempotente, relazione riflessiva in ibernazione?

Answer 5

Ho avuto lo stesso problema anche oggi.

@Entity
@Table(name="users")
public class User {
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   @Column(name="userid")
   protected Long id = null;
   @ManyToMany
   protected List<User> friends = null
}

dovrebbe essere ok, ho usato una struttura simile. Tuttavia ho avuto eccezioni lazy loading e quando si imposta il fetchType a EAGER, ho ricevuto lamentele per l'inizializzazione ricorsiva di borse.

Come ho risolto il mio problema: Nella query si usa per andare a prendere l' 'utente', fare qualcosa di simile:

from User as u left join fetch u.friends

In questo modo inizializzare l'elenco di amici per tale entità. Attenzione però che non inizializzare amici da quegli amici. Questa è una buona cosa in realtà.