Hoekom @OneToMany nie werk met erfenis in Hibernate

Question

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Problem {
    @ManyToOne
    private Person person;
}

@Entity
@DiscriminatorValue("UP")
public class UglyProblem extends Problem {}

@Entity
public class Person {
    @OneToMany(mappedBy="person")
    private List< UglyProblem > problems;
}

Ek dink dit is redelik duidelik wat ek probeer om te doen. Ek verwag @ManyToOne persoon wat geërf word deur UglyProblem klas. Maar daar sal 'n uitsondering iets sê soos:. "Daar is nie so goed gevind in UglyProblem klas (mappedBy =" persoon ")"

Al wat ek gevind is hierdie . Ek was nie in staat om die plasing deur Emmanuel Bernard verduidelik redes agter hierdie te vind.

---

  

Ongelukkig, volgens die Hibernate dokumentasie "Properties uit superclasses nie gekarteer as @MappedSuperclass geïgnoreer."

Wel, ek dink dit beteken dat as ek hierdie twee klasse:

public class A {
    private int foo;
}

@Entity
public class B extens A {
}

dan veld foo sal nie gekarteer vir klas B. Watter sin maak. Maar as ek iets soos hierdie:

@Entity
public class Problem {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

private String name;

public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
}

@Entity
public class UglyProblem extends Problem {

private int levelOfUgliness;

public int getLevelOfUgliness() {
    return levelOfUgliness;
}

public void setLevelOfUgliness(int levelOfUgliness) {
    this.levelOfUgliness = levelOfUgliness;
}
}

Ek verwag dat die klas UglyProblem te hê fileds id en name en beide klasse word gekarteer met behulp van dieselfde tafel. (Trouens, dit is presies wat gebeur, ek het net weer bewys). Ek het hierdie tafel het:

CREATE TABLE "problem" (
    "DTYPE" varchar(31) NOT NULL,
    "id" bigint(20) NOT NULL auto_increment,
    "name" varchar(255) default NULL,
    "levelOfUgliness" int(11) default NULL,
    PRIMARY KEY  ("id")
) AUTO_INCREMENT=2;

Gaan terug na my vraag:

  

Ek verwag @ManyToOne persoon wat geërf word deur UglyProblem klas.

Ek verwag dat omdat alle ander gekarteer velde geërf en ek sien geen rede om hierdie uitsondering maak vir ManyToOne verhoudings te sien.

---

Ja, het ek gesien dat. Trouens, ek gebruik slegs-lees oplossing vir my saak. Maar my vraag was "Hoekom ..." :). Ek weet dat daar is 'n verduideliking gegee deur 'n lid van hiberneer span. Ek was nie in staat om dit te vind en dit is hoekom ek gevra.

Ek wil om uit te vind die motivering van hierdie ontwerp besluit.

(indien u belangstel hoe ek hierdie probleem in die gesig gestaar: Ek 'n projek gebou met behulp van hiberneer 3. geërf Dit was JBoss 4.0.something + hiberneer was daar reeds (wil jy dit alles bymekaar te laai) is ek beweeg hierdie projek te. JBoss 4.2.2 en ek het uitgevind dat daar is geërf afbeeldings van "@OneToMany mappedBy" en dit werk goed op ou setup ...)

Answer 1

Ek dink dit is 'n wyse besluit geneem deur die Hibernate span. Hulle kon minder arrogante wees en maak dit duidelik waarom dit op hierdie manier geïmplementeer, maar dit is net hoe Emmanuel, Chris en Gavin werk. :)

Kom ons probeer om die probleem te verstaan. Ek dink jou konsepte "lieg". Eerste sê jy dat baie Probleem s is verbonde aan Mense . Maar, dan sê jy dat 'n mens Persoon het baie UglyProblem s (en nie verband hou met ander Probleem s). Iets is verkeerd met wat ontwerp.

Dink net hoe dit gaan gekarteer om die databasis. Jy het 'n enkele tafel erfenis, so:

          _____________
          |__PROBLEMS__|          |__PEOPLE__|
          |id <PK>     |          |          |
          |person <FK> | -------->|          |
          |problemType |          |_________ |
          -------------- 

Hoe word hiberneer gaan die databasis te dwing om te maak Probleem net betrekking het op Mense as sy problemType is gelyk UP? Dit is 'n baie moeilike probleem op te los. Dus, as jy hierdie soort verhouding wil, moet elke subklas wees in sy eie tafel. Dit is wat @MappedSuperclass doen.

PS .: Jammer vir die lelike tekening: D

Answer 2

In my geval ek wou die SINGLE_TABLE erfenis tipe gebruik, so gebruik te maak van @MappedSuperclass was nie 'n opsie.

Wat werk, hoewel nie baie skoon, is om die Hibernate eiendom @ Waar klousule aan die @OneToMany vereniging om die tipe in navrae te dwing:

@OneToMany(mappedBy="person")
@Where(clause="DTYPE='UP'")
private List< UglyProblem > problems;

Answer 3

Ongelukkig, volgens die Hibernate dokumentasie "Properties uit superclasses nie gekarteer as @MappedSuperclass geïgnoreer. " Ek het teen hierdie ook. My oplossing was om die verlangde erfenis deur koppelvlakke eerder as die entiteit bone self. Verteenwoordig

In jou geval, kan jy die volgende te definieer:

public interface Problem {
    public Person getPerson();
}

public interface UglyProblem extends Problem {
}

implementeer Toe hierdie koppelvlakke met behulp van 'n abstrakte superklas en twee entiteit subklasse:

@MappedSuperclass
public abstract class AbstractProblemImpl implements Problem {
    @ManyToOne
    private Person person;

    public Person getPerson() {
        return person;
    }
}

@Entity
public class ProblemImpl extends AbstractProblemImpl implements Problem {
}

@Entity
public class UglyProblemImpl extends AbstractProblemImpl implements UglyProblem {
}

As 'n bykomende voordeel, as jy kode met behulp van die interfaces eerder as die werklike entiteit bone dat diegene koppelvlakke implementeer, dit maak dit makliker om die onderliggende afbeeldings later op (minder risiko van breek verenigbaarheid) verander.

Answer 4

Ek dink jy moet annoteer jou Probleem super-klas met @ MappedSuperclass in plaas van @Entity .

Answer 5

Ek uitgepluis het hoe om die OneToMany mappedBy probleem doen.

In die afgeleide klas UglyProblem van die oorspronklike post. Die terugbel metode moet wees in die afgeleide klas nie die ouer klas.

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@ForceDiscriminator
public class Problem {

}

@Entity
@DiscriminatorValue("UP")
public class UglyProblem extends Problem {
    @ManyToOne
    private Person person;
}

@Entity
public class Person {
    @OneToMany(mappedBy="person")
    private List< UglyProblem > problems;
}

Resultate die geheim sous vir die gebruik van Hibernate ten minste. http://docs.jboss.org/ hiberneer / stabiel / notas / api / org / hiberneer / notas / ForceDiscriminator.html die @ForceDiscriminator maak die @OneToMany eer die diskriminator

Vereis Hibernate Annotations.