Beziehung User <-> Freund, wie bei Sozialen Netzwerken

internet

Top Contributor
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":


Code:
@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;
}
 

internet

Top Contributor
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.
Code:
User friend = findUserByID(findUser.getId())

Das ganze geht doch dann mit:
Code:
user.getFriends().add(friend);
Stimmt das?
Dann eben noch in die Datenbank abspeichern über den Entity Manager
Code:
em.merge();
 

Final_Striker

Top Contributor
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

Java:
  user   | freund
---------------
user_id | user_id
 

internet

Top Contributor
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

Java:
  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?
 

internet

Top Contributor
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 :)
 

Final_Striker

Top Contributor
Also, ich würde das so machen:
Code:
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.
 
Zuletzt bearbeitet:

internet

Top Contributor
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

Top Contributor
In etwa so:

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

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

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

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

   User user;

   User friend;

   Boolean accept;
}

Die Annatations sind natürlich nicht komplet.
 

internet

Top Contributor
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

Top Contributor
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.
 

Stroker89

Bekanntes Mitglied
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

Top Contributor
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!
 

Ähnliche Java Themen


Oben