Hibernate Wie assoziiere und instanziere ich richtig?

Dieses Thema Hibernate - Wie assoziiere und instanziere ich richtig? im Forum "Data Tier" wurde erstellt von RootWild, 30. Jan. 2013.

Thema: Wie assoziiere und instanziere ich richtig? Hallo!, ich bin Hibernate Neuling und habe schwirigkeiten die Entitys richtig zu erstellen und zu assoziieren,...

  1. RootWild
    RootWild Neues 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 (Text):

    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 (Text):

    1   Gerber
    2   Bernd
    3   Fischer
    4   Moeller
    5   Krueger
     
    Als Ergebnis hätte ich gerne einen kompletten Join, ungefähr:
    Code (Text):

    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:
    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);
        }
     
    Code (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);
        }
     
    Code (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();
        }
    }
     
    Code (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();
        }
    }
     
    Code (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: 30. Jan. 2013
  2. Vielleicht hilft dir das kostenlose Training weiter --> (hier klicken)
  3. RootWild
    RootWild Neues Mitglied
    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) :(

    Code (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 (Text):

    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: 30. Jan. 2013
  4. RootWild
    RootWild Neues Mitglied
    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.

    Code (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

    }
     

    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.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);
          }
        }
    }
     

    Code (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 (Text):

    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: 1. Feb. 2013
  5. Schau dir jetzt hier den Kurs an und lerne Java zu programmieren: --> Hier klicken, um mehr zu erfahren (Klick)