Beziehung User <-> Freund, wie bei Sozialen Netzwerken

[internet]

Hallo,
ich möchte mit Hibernate es realisieren, dass ein User einen (Freund),
also einen anderen User hinzufügen kann. (Wie bei sozialen Netzwerken)
Das ganze ist eine Many - to - Many Beziehung.
Mittels Hibernate kann man eine Many-to-many Beziehung auch einfach realieren, sodass Hibernate
eine Zwischentabelle anlegt.
Nun aber zu meinen Problemen:
1. Brauche ich überhaupt eine Entitätsklasse "Friend" ?
2. Wenn ja, welche Attribute muss diese haben?

3. Wie sieht das in der Datenbank aus (mysql)?
Mein Vorschlag:
Tabelle "user", kein Fremdschlüssel
Tabelle "friend_user" wird selbst von Hibernate erstellt.
Tabelle "friend" mit den Attributen:
friend_id, accept, user_fk

Accept: Ob der Freund vom User als Freund akzptiert wurde. Ist ein boolean

4. Hier mein Vorschlag für die Entitätsklasse "User":

@Entity
@Table(name="users")
public class User {
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   @Column(name="userid")
   protected Long id = null;
  
  // Andere Attribute wie Name usw.

   @ManyToMany
   @JoinTable(name = "user_friends", 
       joinColumns = @JoinColumn(name = "user_id"), 
       inverseJoinColumns = @JoinColumn(name = "friend_id"))
   protected List<User>friends = null;
}

 

[brauner1990]

Die Idee ist gut, wobei hier noch die Implementierung mit der Freund anfrage fehlt.

 

[internet]

wie meinst du das genau?

Passt das so mit der Tabelle user und friend??????
Wie meinst du das genau?
ich stelle mir das so vor:
Ein User klickt den Button "Freund hinzufügen".
Der "Freund" bekommt dann eine Anfrage.
Er kann sie bestätigen oder ablehnen. (accept)

Das hinzufügen müsste doch so gehen?
Zunächst muss ich mir die ID von dem User holen, der hinzugefügt werden soll und dann
diesen als ein Objekt "User", wobei eig Freund erzeugen.

User friend = findUserByID(findUser.getId())

Das ganze geht doch dann mit:

user.getFriends().add(friend);

Stimmt das?
Dann eben noch in die Datenbank abspeichern über den Entity Manager

em.merge();

 

[Final_Striker]

zu 1. Nein, brauchst du nicht. Ein Freund ist doch auch nur ein User.

zu 3. in der Zwischentabelle hast du dann sowas stehen wie

  user   | freund
---------------
user_id | user_id

 

[internet]

zu 1. Nein, brauchst du nicht. Ein Freund ist doch auch nur ein User.

zu 3. in der Zwischentabelle hast du dann sowas stehen wie

  user   | freund
---------------
user_id | user_id

Die Zwischentabelle erzeugt mir ja sowieso Hibernate.
Eine Tabelle "friend" benötige ich auch, oder?

Wie würden generell die anderen 2 Tabellen "user" und "friend" aussehen, inkl. Fremdschlüssel?

 

[Final_Striker]

Nein du brauchst keine andere Tabelle. Du hast doch eine many-to-many Beziehung zwischen der Tabelle User und der Tabelle User.

 

[internet]

Wie kann ich das dann mit "accept" realisieren, wenn ich keine Tabelle "friend" habe?
Könntest du bitte mal die sql tabellen posten mit attributen und referencen, dann wirds mir denk ich klarer

 

[brauner1990]

Du müsstes anstatt eines Sets eine Map persistieren, aber wie das geht ka...hab ich noch nie.

 

[internet]

Du müsstes anstatt eines Sets eine Map persistieren, aber wie das geht ka...hab ich noch nie.

für das hinzufügen eines Freundes, oder was meinst du?

 

[Final_Striker]

Also, ich würde das so machen:

Tabelle User:
id  | name | ...
---------------
1   | tom  | ...
2   | tim  | ...


Tabelle Friends:
user_id  | friend_id  | accept
-----------------------------
 1       |    2      | false     <- tom fügt tim als Freund hinzu
....

user_id  | friend_id  | accept
----------------------------
 1       |    2      | true      <- tim bestätigt tom als Freund

Frends ist dann quasi die Zwischentabelle der du noch das Attribut "accept" hinzugefügt hast.

 

[internet]

OK. Jetzt ist nur noch die Frage wie ich das dann mit Hibernate mache?
Also eine Many - To - Many Tabelle ist ja kein Problem mit der Annotation.
Aber wie kann ich der Many To Many - Tabelle bei Hibernate das Attribut "accept" hinzufügen?

 

[Final_Striker]

In etwa so:

@Entity
@Table(name="users")
public class User {

   Long id = null;
   ...
  
   @OneToMany
   ...
   List<User>friends = null;

   @OneToMany
   ...
   List<User>isFriendOf = null;
}

@Entity
@Table(name="friends")
public class User {

   User user;

   User friend;

   Boolean accept;
}

Die Annatations sind natürlich nicht komplet.

 

[internet]

Das verstehe ich nun nicht was du nun machst?!
1. Warum 2x eine Klasse mit dem Name "User"? Das geht doch nicht?
2. Warum nun OneToMany?

 

[Final_Striker]

Ach sorry, die zweite Klasse muss natürlich "Friends" heißen. Die erste ist aber auch noch falsch, sehe ich gerade.
Werde es mir nochmal anschauen, wenn ich zu Hause bin.

 

[internet]

Hallo,
hast du nochmal nachgeschaut ?

 

[Stroker89]

Hallo

ich habe sowas im Rahmen einer Projektarbeit für die FH realisiert. (Alumni Netzwerk)

Ich habe eine Tabelle "connect" in der es 4 Spalten gibt.

connectid (primärschlüssel und ist einfach die ID der Verbindung)
fromid (UserID von wem die Anfrage kam)
toid (UserID an wen sich die Anfrage richtet)
status (Integerwert der die Beziehung zwischen den beiden Usern beschreibt)

status 0: freundschaftsanfrage austehend
status 1: freundschaftsanfrage akzeptiert und damit befreundet

was man noch machen könnte:

status -1: ein User blockiert den anderen

Im Endeffekt könnte man über so eine einfache Tabelle auch Beziehungen von Gruppen zu seinen Mitgliedern beschreiben oder umgekehrt.

Ich hoffe ich konnte dir helfen

Gruß

 

[internet]

Hallo,
vielen Dank für deine Antwort.
Genau so habe ich es auch gemacht.
Das mit dem ignore habe ich nicht bedacht, finde ich aber auch einen tollen Lösungvorschlag.
Vielen Dank!

 

[Stroker89]

Dann ist ja gut wenn es funktioniert , sonst hätte ich dir auch ein Beispiel von mir schicken können

Gruß