Hibernate: Eltern - /Kind-Beziehung in einem single-table

Ich kaum sehen keine Zeiger auf das folgende problem in Verbindung mit Hibernate. Dies bezieht sich auf die Umsetzung der Vererbung mit einer einzelnen Datenbank-Tabelle mit einer Eltern-Kind
Beziehung zu sich selbst. Zum Beispiel:

CREATE TABLE Employee (
  empId BIGINT NOT NULL AUTO_INCREMENT,
  empName VARCHAR(100) NOT NULL,
  managerId BIGINT,
  CONSTRAINT pk_employee PRIMARY KEY (empId)
)

Hier, die managerId Spalte null sein darf, oder kann auf eine andere Zeile der Mitarbeiter Tabelle. Business-Regel muss der Mitarbeiter wissen über alle seine reportees und für ihn zu wissen, über seine/Ihre manager. Die business-Regeln erlauben auch die Zeilen haben null managerId (CEO der organisation, die nicht mit einem manager).

Wie wir Karte diese Beziehung in Hibernate, standard viele-zu-eins-Beziehung hier nicht funktioniert? Vor allem, wenn ich Sie umsetzen wollen, meine Einheiten nicht nur als eine entsprechende "Mitarbeiter" Entity-Klasse, sondern mehrere Klassen, wie "Manager", "Assistant Manager", "Ingenieur" usw., jedes Erben von "Mitarbeiter" super-entity-Klasse, eine Entität mit Attributen, die eigentlich gar nicht für alle gelten, zum Beispiel "Manager", bekommt Vergünstigungen, andere nicht (die entsprechenden Tabellen-Spalte die null-Werte akzeptieren natürlich).

Beispiel-code wäre sehr hilfreich (ich beabsichtige zu verwenden, Hibernate 3 annotations).

InformationsquelleAutor Dchucks | 2010-03-11
  1. 9

    Du meinst die beiden Konzepte hier:

    1. erbschaft-und Sie zuordnen möchten Ihre Vererbungshierarchie in einer einzigen Tabelle.
    2. eine Eltern/Kind Beziehung.

    Zur Umsetzung 1., Sie müssen mithilfe von Hibernate ist einzelne Tabelle pro Klassenhierarchie Strategie:

    @Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
    name="emptype",
    discriminatorType=DiscriminatorType.STRING
)
public abstract class Employee { ... }

@Entity
@DiscriminatorValue("MGR")
public class Manager extends Employee { ... }

    Umsetzen 2., müssen Sie zwei self-referencing-Verbänden Employee:

    • viele Mitarbeiter haben, die kein oder ein manager (der ist auch ein Employee)
    • ein Mitarbeiter hat keine oder viele reportee(s)

    Den daraus resultierenden Employee Mai sieht wie folgt aus:

    @Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
    name="emptype",
    discriminatorType=DiscriminatorType.STRING
)
public abstract class Employee { 

    ... 

    private Employee manager;
    private Set<Employee> reportees = new HashSet<Employee>();

    @ManyToOne(optional = true)
    public Employee getManager() {
        return manager;
    }

    @OneToMany
    public Set<Employee> getReportees() {
        return reportees;
    }

    ...
}

    Und das Ergebnis wäre in den folgenden Tabellen:

    CREATE TABLE EMPLOYEE_EMPLOYEE (
        EMPLOYEE_ID BIGINT NOT NULL,
        REPORTEES_ID BIGINT NOT NULL
    );

CREATE TABLE EMPLOYEE (
        EMPTYPE VARCHAR(31) NOT NULL,
        ID BIGINT NOT NULL,
        NAME VARCHAR(255),
        MANAGER_ID BIGINT
    );

ALTER TABLE EMPLOYEE ADD CONSTRAINT SQL100311183749050 PRIMARY KEY (ID);

ALTER TABLE EMPLOYEE_EMPLOYEE ADD CONSTRAINT SQL100311183356150 PRIMARY KEY (EMPLOYEE_ID, REPORTEES_ID);

ALTER TABLE EMPLOYEE ADD CONSTRAINT FK4AFD4ACE7887BF92 FOREIGN KEY (MANAGER_ID)
    REFERENCES EMPLOYEE (ID);

ALTER TABLE EMPLOYEE_EMPLOYEE ADD CONSTRAINT FKDFD1791F25AA2BE0 FOREIGN KEY (REPORTEES_ID)
    REFERENCES EMPLOYEE (ID);

ALTER TABLE EMPLOYEE_EMPLOYEE ADD CONSTRAINT FKDFD1791F1A4AFCF1 FOREIGN KEY (EMPLOYEE_ID)
    REFERENCES EMPLOYEE (ID);
    • Ich bin verwirrt, Pascal, wenn Ihr Single Table Inheritance tun, ich muss eine join-Tabelle Employee_Employee?
    • Auch wie kann ich anzeigen die Spalte MANAGER_ID?
    • Hmm..., Was? 🙂 Ich don ' T erhalten die erste Frage. Employee_Employee ist für die OneToMany selbst-referenzierend Vereins. Ist es das, was du meinst?
    • Dann MANAGER_ID Spalte ist die Spalte standardmäßig generiert für die @ManyToOne Assoziation. Wenn Sie es ändern möchten, verwenden Sie eine @JoinColumn-annotation (java.sun.com/javaee/6/docs/api/javax/persistence/ManyToOne.html)
    • Durch die Bereitstellung von "mappedBy" - Anmerkung für die "reportees" variable können wir umgehen damit die Notwendigkeit, einen mapping-Tabelle. Der code funktioniert nun einwandfrei mit einer einzigen Tabelle. Ich arbeite jetzt auf ein weiteres Problem auf, wie man die getReportees() list eine hierarchische Liste der reportees (zum Beispiel: Geschäftsführer brauchen eine Liste von Allen Managern-reporting für ihn und der Assistant Manager reporting die Projektleiter) 🙂 vielen Dank.
    • True, können Sie vermeiden, die join-Tabelle, wenn eine bidirektional association (jetzt auch möglich mit unidirektionalen Assoziation in JPA 2.0).

    InformationsquelleAutor Pascal Thivent
  2. 3

    Dank einer Tonne Jungs. Ich habe meine Mitarbeiter Entität wie folgt:

    @Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
    name="EMPLOYEE_TYPE", 
    discriminatorType = DiscriminatorType.STRING
)
@DiscriminatorValue("Employee")
public abstract class Employee {

    @Id 
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="EMPLOYEE_ID") 
    private Integer empId = null;

    @Column(name="EMPLOYEE_NAME") 
    private String empName = null;

    @Column(name="EMPLOYEE_SECRETARY")
    private String secretary;

    @Column(name="EMPLOYEE_PERKS")
    private int perks;       

    @ManyToOne(targetEntity = Employee.class, optional=true)
@JoinColumn(name="MANAGER_ID", nullable=true)
private Employee manager = null;

    @OneToMany  
    private Set<Employee> reportees = new HashSet<Employee>();

    ...        

    public Set<Employee> getReportees() {
        return reportees;
    } 
}

    Ich dann Hinzugefügt, dass andere Entität-Klassen mit keine Körper, sondern nur Diskriminator Spalten Werte, wie Manager, Geschäftsführer und AsstManager. Ich wählte zu lassen, Hibernate erstellen der Tabelle für mich. Im folgenden ist der Haupt-Programm:

    SessionFactory sessionFactory = HibernateUtil.sessionFactory;
Session session = sessionFactory.openSession();
Transaction newTrans = session.beginTransaction();

CEO empCeo = new CEO();
empCeo.setEmpName("Mr CEO");
empCeo.setSecretary("Ms Lily");

Manager empMgr = new Manager();
empMgr.setEmpName("Mr Manager1");
empMgr.setPerks(1000);
empMgr.setManager(empCeo);

Manager empMgr1 = new Manager();
empMgr1.setEmpName("Mr Manager2");
empMgr1.setPerks(2000);
empMgr1.setManager(empCeo);

AsstManager asstMgr = new AsstManager();
asstMgr.setEmpName("Mr Asst Manager");
asstMgr.setManager(empMgr);

session.save(empCeo);
session.save(empMgr);
session.save(empMgr1);
session.save(asstMgr);
newTrans.commit();

System.out.println("Mr Manager1's manager is : "
        + empMgr.getManager().getEmpName());
System.out.println("CEO's manager is : " + empCeo.getManager());
System.out.println("Asst Manager's manager is : " + asstMgr.getManager());
System.out.println("Persons Reporting to CEO: " + empCeo.getReportees());

session.clear();
session.close();

    Code läuft wunderbar, Hibernate war die Schaffung einer Spalte "MANAGER_EMPLOYEE_ID" auf seine eigene, wo es speichert die FK. Ich habe angegeben das JoinColumn Namen zu machen, "MANAGER_ID". Hibernate auch eine Tabelle erstellt EMPLOYEE_EMPLOYED, jedoch sind die Daten nicht persistiert es.

    Methode getReportees () - Methode eine null zurück, während getManager() funktioniert gut, wie erwartet.

    InformationsquelleAutor Dchucks
  3. 1

    Ich bin nicht sicher ob Sie das wirklich wollen, aber ich denke, Sie wollen ein Tabelle pro Klassenhierarchie

    In diesem Fall, jede Entität ist, die Sortierung einer DISCRIMINATOR_COLUMN wie folgt

    @Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
    name="EMPLOYEE_TYPE", 
    discriminatorType = DiscriminatorType.STRING
)
@DiscriminatorValue("EMPLOYEE")
public class Employee {

    @Id @GeneratedValue
    @Column(name="EMPLOYEE_ID") 
    private Integer id = null;

}

    Und Ihre Kinder zugeordnet, nach

    @Entity
@DiscriminatorValue("MANAGER")
public class Manager extends Employee {

    //Manager properties goes here        
     ...
}

    Um zu testen, lassen Sie uns die folgenden

    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();

/*
insert 
into
    Employee
    (EMPLOYEE_TYPE) 
values
    ('EMPLOYEE')
*/
session.save(new Employee());

/*
insert 
into
    Employee
    (EMPLOYEE_TYPE) 
values
    ('MANAGER')
*/
session.save(new Manager());

session.clear();
session.close();

    Aber, statt der Vererbung (die Sie können sehen, eine Menge von NULL-Spalte, die durch mehr als ein Unternehmen teilen sich die gleiche Tabelle - wenn Sie mit InheritanceType.SINGLE_TABLE-Strategie), Ihr Modell besser wäre wie folgt

    @Entity
public class Employee { 

    private Employee manager;
    private List<Employee> reporteeList = new ArrayList<Employee>();

    /**
    * optional=true
    * because of an Employee could not have a Manager
    * CEO, for instance, do not have a Manager
    */  
    @ManyToOne(optional=true)
    public Employee getManager() {
        return manager;
    }

    @OneToMany
    public List<Employee> getReporteeList() {
        return reporteeList;
    }

}

    Fühlen Sie sich frei, um die Wahl der besten Vorgehensweise, die Ihre Bedürfnisse erfüllen.

    Grüße,

    InformationsquelleAutor Arthur Ronald
Schreibe einen Kommentar