Java Persistence/ManyToOne

Een ManyToOne relatie in Java is wanneer het bronobject een attribuut heeft dat verwijst naar een ander object, het doelobject. Dat wil zeggen het nogal typische Java-geval dat een object een verwijzing naar een ander object heeft. Een ManyToOne-relatie kan unidirectioneel worden gespecificeerd. Het is echter typisch dat het doel-object de omgekeerde relatie heeft, terug naar het bron-object. Dit zou een OneToMany-relatiespecificatie in het doelobject zijn. Alle relaties in Java en JPA zijn unidirectioneel, in die zin dat als een bronobject verwijst naar een doelobject er geen garantie is dat het doelobject ook een relatie heeft met het bronobject. Dit is anders dan in een relationele database, waarin relaties worden gedefinieerd door middel van foreign keys en query’s zodanig dat de inverse query altijd bestaat.

In JPA wordt een ManyToOne relatie gespecificeerd door middel van de @ManyToOne annotatie of het <many-to-one> element. Een @ManyToOne annotatie gaat gewoonlijk vergezeld van een @JoinColumn annotatie. De @JoinColumn annotatie specificeert hoe de relatie moet worden toegewezen aan (uitgedrukt in) de database. De @JoinColumn definieert de naam van de foreign key kolom (@JoinColumn(name = "...")) in het bronobject die moet worden gebruikt om het doelobject te vinden (join).

Indien de omgekeerde OneToMany relatie is gespecificeerd in het doelobject, dan moet de @OneToMany annotatie in het doelobject een mappedBy attribuut bevatten om deze omgekeerde relatie te definiëren.

JPA definieert ook een OneToOne-relatie, die vergelijkbaar is met een ManyToOne-relatie, behalve dat de omgekeerde relatie (als deze zou zijn gedefinieerd) een OneToOne-relatie is. Het belangrijkste verschil tussen een OneToOne en een ManyToOne relatie in JPA is dat een ManyToOne altijd een foreign key bevat van de tabel van het bronobject naar de tabel van het doelobject, terwijl bij een OneToOne relatie de foreign key zowel in de tabel van het bronobject als in de tabel van het doelobject kan staan.

Voorbeeld van een ManyToOne-relatie databaseEdit

EMPLOYEE (tabel)

PHONE (tabel)

Voorbeeld van een ManyToOne relatie annotationsEdit

@Entitypublic class Phone { @Id private long id; ... // Specifies the PHONE table does not contain an owner column, but // an OWNER_ID column with a foreign key. And creates a join to // lazily fetch the owner @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="OWNER_ID") private Employee owner; ...}// Specification of the reverse OneToMany relationship in Employee@Entitypublic class Employee { @Id private long emp_id; ... // The 'mappedBy = "owner"' attribute specifies that // the 'private Employee owner;' field in Phone owns the // relationship (i.e. contains the foreign key for the query to // find all phones for an employee.) @OneToMany(mappedBy = "owner") private List<Phone> phones; ...

Voorbeeld van een ManyToOne relatie XMLEdit

<entity name="Phone" class="org.acme.Phone" access="FIELD"> <attributes> <id name="id"/> <many-to-one name="owner" fetch="LAZY"> <join-column name="OWNER_ID"/> </many-to-one> </attributes></entity>

Zie ookEdit

• Relaties
  • Cascading
  • Lazy Fetching
  • Target Entity
  • Join Fetching
  • Batch Reading
  • Common Problems
• OneToOne
  • Mapping a OneToOne Using a Join Table
• OneToMany

Common ProblemsEdit

Foreign key maakt ook deel uit van de primaire sleutel.Bewerken

Zie Primaire sleutels via OneToOne relaties.

Foreign key is ook gemapt als een basis.Bewerken

Als u hetzelfde veld in twee verschillende mappings gebruikt, moet u gewoonlijk een van hen alleen-lezen maken met insertable, updatable = false. Zie Target Foreign Keys, Primary Key Join Columns, Cascade Primary Keys.

Constraint error on insert.Edit

Dit treedt meestal op omdat u de foreign key in een OneToOne-relatie onjuist hebt toegewezen. Zie Target Foreign Keys, Primary Key Join Columns, Cascade Primary Keys. Het kan ook voorkomen als uw JPA provider geen referentiële integriteit ondersteunt, of geen bi-directionele constraints oplost. In dit geval kan het nodig zijn om de constraint te verwijderen, of EntityManager flush() te gebruiken om de volgorde te verzekeren waarin je objecten zijn geschreven.

Foreign key value is nullEdit

Zorg ervoor dat u de waarde van de OneToOne van het object instelt, als de OneToOne deel uitmaakt van een bidirectionele OneToMany relatie, zorg er dan voor dat u de OneToOne van het object instelt wanneer u een object toevoegt aan de OneToMany, JPA onderhoudt bidirectionele relaties niet voor u. Controleer ook of u de JoinColumn correct hebt gedefinieerd, zorg ervoor dat u geen insertable, updateable = false hebt ingesteld of een PrimaryKeyJoinColumn hebt gebruikt.