Hibernate Wie assoziiere und instanziere ich richtig?

R

RootWild

Mitglied
Hallo!,

ich bin Hibernate Neuling und habe schwirigkeiten die Entitys richtig zu erstellen und zu assoziieren, es geht immer Information verloren, gebt mir mal einen Tip, 🙂
danke!

Also, Ich habe folgende Textdateien:

Meeting.txt (MEETING_ID, TITEL)
Code: 
1	Tee trinken	1
1	Tee trinken	2
1	Tee trinken	3
2	lecker Kuchen 		1
2	lecker Kuchen		2
3	Billiard	2
3	Billiard	3

Personen.txt (PERSON_ID, NAME)
Code: 
1	Gerber
2	Bernd
3	Fischer
4	Moeller
5	Krueger

Als Ergebnis hätte ich gerne einen kompletten Join, ungefähr:
Code: 
1	Gerber	1	Tee trinken
1	Gerber	2	lecker Kuchen
2	Bernd	1	Tee trinken
2	Bernd	2	lecker Kuchen
2	Bernd	3	Billiard
3	Fischer	1	Tee trinken
3	Fischer	3	Billiard
4	Moeller	null	null
5	Krueger	null	null

jetzt mein Code:
Java: 
package hibernatetest;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity()
@Table(name="PERSON")
public class Person implements Serializable {
    
    @Id
    //@GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name="PERSON_ID", unique=true)
    private long id;

    @Column(name="NAME")
    private String name;

    @ManyToMany()
    @JoinColumn(name="PERSON_ID")
    private Set<Meeting> meetings;

 
    public Person(long id, String name, Set<Meeting> meetings) {
        this.id = id;
        this.name = name;
        this.meetings = meetings;
    }

// [...] Getter und Setter

    public void addMeeting(Meeting meet) {
        if(meetings == null) {
            meetings = new HashSet<Meeting>();
        }
        
        meetings.add(meet);
    }

Java: 
package hibernatetest;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity()
@Table(name="MEETING")
public class Meeting implements Serializable {
    
    @Id
    //@GeneratedValue(strategy= GenerationType.AUTO)
    @Column(name="MEETING_ID",unique=true)
    private long id;
    
    @Column(name="TITEL")
    private String titel;
    
    @ManyToMany
    @JoinColumn(name="PERSON_ID")
    private Set<Person> persons;

    public Meeting() {
    }

    public Meeting(long id, String titel, Set<Person> persons) {
        this.id = id;
        this.titel = titel;
        this.persons = persons;
    }

// [...] Getter und Setter

    public void addPerson(Person p) {
        if(persons == null) {
            persons = new HashSet<Person>();
        }
        
        persons.add(p);
    }

Java: 
package hibernatetest.dau;

import hibernatetest.HibernateUtil;
import hibernatetest.Meeting;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class MeetingDAU {
    
    public void createMeeting(Meeting m) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        Transaction transaction = session.beginTransaction();
        
        session.saveOrUpdate(m);
        transaction.commit();
    }
}

Java: 
package hibernatetest.dau;

import hibernatetest.HibernateUtil;
import hibernatetest.Person;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class PersonDAU {
    
    public void createPerson(Person p) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        Transaction transaction = session.beginTransaction();
        
        session.saveOrUpdate(p);
        transaction.commit();
    }
}

Java: 
package DataIO;

import hibernatetest.HibernateUtil;
import hibernatetest.Meeting;
import hibernatetest.Person;
import hibernatetest.dau.MeetingDAU;
import hibernatetest.dau.PersonDAU;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.hibernate.Session;

public class DataImport {

    public static void read(File f, Class bean) {
        try {
            BufferedReader br = new BufferedReader(
                    new InputStreamReader(
                    new FileInputStream(f)));

            String line = "";
            while ((line = br.readLine()) != null) {
                String[] fields = line.split("\t");
                
                if(bean.equals(Person.class)) {
                    Person p = new Person(Long.parseLong(fields[0]), fields[1], null);
                    new PersonDAU().createPerson(p);

                } else if (bean.equals(Meeting.class)) {

                    Meeting m = new Meeting(Long.parseLong(fields[0]), fields[1], null);

                    if (fields[2] != null && !fields[2].equals("")) {

                        Long personID = Long.parseLong(fields[2]);

                        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
                        session.beginTransaction();
                        
                        Person p;
                        if ((p = (Person) session.get(Person.class, personID)) != null) {
                            m.addPerson(p);
                            session.flush();
                        }
                    }
                    new MeetingDAU().createMeeting(m);
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(DataImport.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
}

Viele Gruesse
 
Zuletzt bearbeitet:
Ah okay, ich habe etwas übersehen, wenn man das meeting nicht immer überschreibt geht es besser 😉 Aber es ist noch immer nicht richtig (s.u) 🙁

Java: 
    public static void read(File f, Class bean) {
        try {
            BufferedReader br = new BufferedReader(
                    new InputStreamReader(
                    new FileInputStream(f)));

            String line = "";
            while ((line = br.readLine()) != null) {
                String[] fields = line.split("\t");
                
                if(bean.equals(Person.class)) {
                    Person p = new Person(Long.parseLong(fields[0]), fields[1], 0, null, null, null);
                    new PersonDAU().createPerson(p);

                } else if (bean.equals(Meeting.class)) {
                    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
                    session.beginTransaction();
                    
                    Long meetingID = Long.parseLong(fields[0]);
                    Meeting m;
                        if ((m = (Meeting) session.get(Meeting.class, meetingID)) != null) {
                            
                        } else {
                            m = new Meeting(meetingID, fields[1] , null);
                        }
                  

                    if (fields[2] != null && !fields[2].equals("")) {

                        Long personID = Long.parseLong(fields[2]);       
                        Person p;
                        if ((p = (Person) session.get(Person.class, personID)) != null) {
                            m.addPerson(p);
                            session.flush();
                        } else {
                            p = new Person(personID);
                        }
                    }
                    new MeetingDAU().createMeeting(m);
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(DataImport.class.getName()).log(Level.SEVERE, null, ex);
        }
    }


Ich frage mich auch: warum bekomme ich wenn ich Joins ausgehend von Person mache nicht die jeweiligen Meetings?:\

Und ob man überhaupt das lesen aus Csv Dateien so macht, oder ob es da bessere Lösungen gibt?

Code: 
LEFT JOIN FROM PERSON
select person.id, person.name, meeting.id, meeting.titel from Person as person left join person.meetings as meeting
1	Gerber	null	null	
2	Bernd	null	null	
3	Fischer	null	null	
4	Moeller	null	null	
5	Krueger	null	null	

RIGHT JOIN FROM PERSON
select person.id, person.name, meeting.id, meeting.titel from Person as person right join person.meetings as meeting
null	null	1	Tee trinken	
null	null	2	lecker Kuchen 	
null	null	3	Billiard	

LEFT JOIN FROM MEETING
select meeting.id, meeting.titel, person.id, person.name from Meeting as meeting left join meeting.persons as person
1	Tee trinken	1	Gerber	
1	Tee trinken	2	Bernd	
1	Tee trinken	3	Fischer	
2	lecker Kuchen 	null	null	
3	Billiard	2	Bernd	
3	Billiard	3	Fischer	

RIGHT JOIN FROM MEETING
select meeting.id, meeting.titel, person.id, person.name from Meeting as meeting right join meeting.persons as person
1	Tee trinken	1	Gerber	
1	Tee trinken	2	Bernd	
3	Billiard	2	Bernd	
1	Tee trinken	3	Fischer	
3	Billiard	3	Fischer	
null	null	4	Moeller	
null	null	5	Krueger
 
Zuletzt bearbeitet:
Hi,
hier nun die Lösung für meine Frage :toll:

:rtfm: 🙂 Ich hätte gerne auch noch gewußt ob das so eine sinvolle möglichkeit ist dateien einzulesen, oder ob es efizientere gibt

Gruß



Eingabedateien sind nach wie vor die gleichen.

Java: 
package hibernatetest;

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="MEETING")
public class Meeting implements Serializable {
    
    @Id
    @Column(name="MEETING_ID",unique=true)
    private long id;
    
    @Column(name="TITEL")
    private String titel;

    public Meeting() {
    }

    public Meeting(long id, String titel) {
        this.id = id;
        this.titel = titel;
    }

//Getter, Setter

}


Java: 
package hibernatetest;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="PERSON")
@NamedQueries({
    @NamedQuery(name="person_left_join",        
        query="select person.id, person.name, meeting.id, meeting.titel "
                + " from Person as person "
                + " left join person.meetings as meeting"),
    
    @NamedQuery(name="person_right_join",        
        query="select person.id, person.name, meeting.id, meeting.titel"
                + " from Person as person"
                + " right join person.meetings as meeting")       
})
public class Person implements Serializable {
    
    @Id
    @Column(name="PERSON_ID", unique=true)
    private long id;

    @Column(name="NAME")
    private String name;
      
    @ManyToMany(cascade= CascadeType.ALL)
    @JoinTable( name="PERSON_MEETING",
            joinColumns={ @JoinColumn( name="PERSON_ID_FK" ) }, 
            inverseJoinColumns={ @JoinColumn( name="MEETING_ID_FK" ) } )
    private Set<Meeting> meetings;
 
    public Person(long id, String name, int age, Set<Address> addresses, Set<EMail> mails, Set<Meeting> meetings) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.addresses = addresses;
        this.mails = mails;
        this.meetings = meetings;

//Getter, Setter

     public void addMeeting(Meeting meet) {
          if(meetings == null) {
              meetings = new HashSet<Meeting>();
          }
        
          meetings.add(meet);
      }
    }
}


Java: 
package DataIO;

import hibernatetest.HibernateUtil;
import hibernatetest.Meeting;
import hibernatetest.Person;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.slf4j.LoggerFactory;


public class DataImport {
    
    private final static org.slf4j.Logger Logger = LoggerFactory.getLogger(
            DataImport.class);

    public static void read(File f, Class bean) {
        try {
            BufferedReader br = new BufferedReader(
                    new InputStreamReader(
                    new FileInputStream(f)));

            String line = "";
            while ((line = br.readLine()) != null) {
                
                //get fields from csv file
                String[] fields = line.split("\t");
                
                //get the current session
                Session session = HibernateUtil.getSessionFactory().getCurrentSession();
                Transaction transaction = session.beginTransaction();
                transaction.begin();
                       
                //PERSON-----------------------------------------------------------------------
                if (bean.equals(Person.class)) {
                    Long personID = Long.parseLong(fields[0]);
                    String name = fields[1];
                                                      
                    //if the person already exists, take it and add data
                    Person p;
                    if ((p = (Person) session.get(Person.class, personID)) != null) {
                        
                        p.setName(name);
                        session.flush();
                        Logger.info("PERSON:\tPerson\t'{}p'\t'{}'\talredy exists", personID, name);
                    }
                    
                    //if not create a new person
                    else {
                        p = new Person(personID, name, 0, null, null, null);
                        session.save(p);
                        Logger.info("PERSON:\tPerson\t'{}p'\t'{}'\tcreated", personID, name);
                    }
                    
                //MEETING----------------------------------------------------------------------
                } else if (bean.equals(Meeting.class)) {
              
                    Long meetingID = Long.parseLong(fields[0]);
                    String name = fields[1];
                    //if the meeting already exists, take it. if not create it
                    Meeting m;
                    if ((m = (Meeting) session.get(Meeting.class, meetingID)) != null) {
                        Logger.info("MEETING:\tMeeting\t'{}m'\t'{}'\talredy exists", meetingID, name);
                    
                    } else {
                        m = new Meeting(meetingID, name);
                        session.save(m);
                        Logger.info("MEETING:\tMeeting\t'{}m'\t'{}'\tcreated", meetingID, name);
                        
                        //get the current session again, because its closed due to the
                        session = HibernateUtil.getSessionFactory().getCurrentSession();
                        transaction = session.beginTransaction();
                        transaction.begin();
                    }

                    //Get the personID if this line defines an association with a person
                    if (fields[2] != null && !fields[2].equals("")) {

                        Long personID = Long.parseLong(fields[2]);
                        
                        //check if a person with the current personID already exists,
                        //if not create it
                        //then add the meeting to it
                        Person p;
                        if ((p = (Person) session.get(Person.class, personID)) != null) {
                            p.addMeeting(m);
                            session.flush();
                            Logger.info("MEETING:\tPerson\t'{}p'\t\t\talredy exists", personID);
                            
                        } else {
                            p = new Person(personID);
                            p.addMeeting(m);
                            session.save(p);
                            Logger.info("MEETING:\tPerson\t'{}p'\t\t\tcreated", personID);
                        }
                    }  else {
                        Logger.info("MEETING:\tPerson\t\t\tnot set");
                    } 
                }
            }
        } catch (IOException ex) {
            Logger.error("Parsing failed",ex);
        }
    }
    
}

Das ergebnis (Ausgabe auf der Konsole) sieht folgendermaßen aus:
Code: 
01:46:17.738 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'1m'	'Tee trinken'	created
01:46:17.748 [main] INFO  DataIO.DataImport - MEETING:	Person	'1p'			created
01:46:17.748 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'1m'	'Tee trinken'	alredy exists
01:46:17.749 [main] INFO  DataIO.DataImport - MEETING:	Person	'2p'			created
01:46:17.749 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'1m'	'Tee trinken'	alredy exists
01:46:17.749 [main] INFO  DataIO.DataImport - MEETING:	Person	'3p'			created
01:46:17.749 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'2m'	'lecker Kuchen'	created
01:46:17.759 [main] INFO  DataIO.DataImport - MEETING:	Person	'1p'			alredy exists
01:46:17.759 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'2m'	'lecker Kuchen'	alredy exists
01:46:17.761 [main] INFO  DataIO.DataImport - MEETING:	Person	'2p'			alredy exists
01:46:17.761 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'3m'	'Billiard'	created
01:46:17.762 [main] INFO  DataIO.DataImport - MEETING:	Person	'2p'			alredy exists
01:46:17.762 [main] INFO  DataIO.DataImport - MEETING:	Meeting	'3m'	'Billiard'	alredy exists
01:46:17.763 [main] INFO  DataIO.DataImport - MEETING:	Person	'3p'			alredy exists
01:46:17.766 [main] INFO  DataIO.DataImport - PERSON:	Person	'1p'	'Gerber'	alredy exists
01:46:17.767 [main] INFO  DataIO.DataImport - PERSON:	Person	'2p'	'Bender'	alredy exists
01:46:17.768 [main] INFO  DataIO.DataImport - PERSON:	Person	'3p'	'Fischer'	alredy exists
01:46:17.768 [main] INFO  DataIO.DataImport - PERSON:	Person	'4p'	'Moeller'	created
01:46:17.768 [main] INFO  DataIO.DataImport - PERSON:	Person	'5p'	'Krueger'	created

LEFT JOIN FROM PERSON

1	Gerber	1	Tee trinken	
1	Gerber	2	lecker Kuchen	
2	Bender	1	Tee trinken	
2	Bender	2	lecker Kuchen	
2	Bender	3	Billiard	
3	Fischer	1	Tee trinken	
3	Fischer	3	Billiard	
4	Moeller	null	null	
5	Krueger	null	null	

RIGHT JOIN FROM PERSON

1	Gerber	1	Tee trinken	
2	Bender	1	Tee trinken	
3	Fischer	1	Tee trinken	
1	Gerber	2	lecker Kuchen	
2	Bender	2	lecker Kuchen	
2	Bender	3	Billiard	
3	Fischer	3	Billiard
 
Zuletzt bearbeitet:

Aktuelle Jobs

Neue Themen

Ähnliche Themen

das ist meine aufgabe ich hab das problem das bei mir Wenn ich die Richtung der Linien verändern will und drei davon sind richtig, verändere ich die 4
Antworten: 3
Ich weiß nicht, wie ich meinen Code richtig designen soll und komme nicht weiter
Antworten: 4
ich muss diese aufgabe kaufen, aber ich weiß nicht wie kann ich es machen.könnten Sie mir bitte helfen
Antworten: 23
Ich ahbe einen char und diesen soll ich bei .matches prüfen, also ob der char in meiner Zeichenkette vorhanden ist, wie mache ich das?
Antworten: 9
Wie benutze ich die Main Funktion richtig?
Antworten: 10

Zurück
Oben