Hibernate One to One Mapping Annotation Voorbeeld

Als we werken aan een hibernate applicatie of we zijn van plan om te werken aan een in de toekomst, dan kunt u gemakkelijk begrijpen van de een-op-een relaties tussen verschillende entiteiten in de toepassing. In deze hibernate een op een mapping voorbeeld, We zullen bespreken 4 verschillende variaties.

Table of ContentsVarious supported techniques for one to one mapping1. Using foreign key association2. Using join table3. Using shared primary key4. @MapsId

Voor deze hibernate een op een mapping voorbeeld, Ik ben het uitbreiden van het voorbeeld geschreven voor hibernate hello world voorbeeld. We hebben twee entiteiten hier: Employee en Account.

Een werknemer kan slechts één rekening hebben. Evenzo zal een account worden geassocieerd met slechts één werknemer. Het is een op een relatie voor dit voorbeeld.

Verschillende ondersteunde technieken

In hibernate zijn er 3 manieren om een-op-een relaties tussen twee entiteiten te creëren. In beide gevallen moeten we de @OneToOne annotatie gebruiken.

De eerste techniek wordt het meest gebruikt en maakt gebruik van een foreign key kolom in een van de tabellen.
Tweede techniek maakt gebruik van een vrij bekende oplossing van het hebben van een derde tabel op te slaan mapping tussen de eerste twee tabellen.
Derde techniek is iets nieuws die gebruik maakt van een gemeenschappelijke primaire sleutel waarde in beide tabellen.

Hibernate een op een mapping met foreign key associatie

In dit soort associatie, is een foreign key kolom gemaakt in de eigenaar entiteit. Bijvoorbeeld, als we EmployeeEntity eigenaar maken, dan zal een extra kolom "ACCOUNT_ID" worden aangemaakt in Employee tabel. Deze kolom zal de foreign key voor Account tabel opslaan.

Tabelstructuur zal er als volgt uitzien:

Om een dergelijke associatie te maken, refereer de Account entiteit in EmployeeEntity class als volgt:

@OneToOne@JoinColumn(name="ACCOUNT_ID")private AccountEntity account;

De join kolom wordt gedeclareerd met de @JoinColumn annotatie die lijkt op de @Column annotatie. Het heeft nog een parameter genaamd referencedColumnName. Deze parameter declareert de kolom in de doelentiteit die zal worden gebruikt voor de join.

Als aan de kant van de eigenaar geen @JoinColumn is gedeclareerd, gelden de standaardwaarden. In de tabel van de eigenaar wordt een join-kolom (kolommen) aangemaakt, waarvan de naam de aaneenschakeling is van de naam van de relatie aan de kant van de eigenaar, _ (onderstrepingsteken), en de naam van de primaire-sleutelkolom (kolommen) aan de kant van de eigenaar.

In een bidirectionele relatie moet één van de zijden (en slechts één) de eigenaar zijn. De eigenaar is verantwoordelijk voor het bijwerken van de associatiekolom(men). Om een partij als niet verantwoordelijk voor de relatie te verklaren, wordt het attribuut mappedBy gebruikt. “mappedBy” verwijst naar de naam van de eigenschap van de associatie aan de kant van de eigenaar.

@OneToOne(mappedBy="account")private EmployeeEntity employee;

Het attribuut “mappedBy” verklaart dat het voor de mapping afhankelijk is van de entiteit van de eigenaar.

Laten we bovenstaande mappings in lopende code testen:

Het uitvoeren van bovenstaande code creëert het gewenste schema in de database en voert deze SQL-query’s uit.

U kunt de gegevens en mappings in beide tabellen controleren wanneer u bovenstaand programma uitvoert.

Hibernate een op een mapping met gemeenschappelijke join tabel

Deze aanpak is niet nieuw voor ons allemaal. Laten we beginnen met de gerichte DB-structuur in deze techniek.

In deze techniek is de belangrijkste annotatie die moet worden gebruikt @JoinTable. Deze annotatie wordt gebruikt om de nieuwe tabelnaam (verplicht) en de foreign keys van beide tabellen te definiëren. Laten we eens kijken hoe het wordt gebruikt:

@JoinTable annotatie wordt gebruikt in de EmployeeEntity klasse. Het verklaart dat een nieuwe tabel EMPLOYEE_ACCOUNT zal worden gecreëerd met twee kolommen EMPLOYEE_ID (primaire sleutel van EMPLOYEE tabel) en ACCOUNT_ID (primaire sleutel van ACCOUNT tabel).

Het testen van bovenstaande entiteiten genereert de volgende SQL-query’s in logbestanden:

Hibernate één op één mapping met gedeelde primaire sleutel

In deze techniek zal hibernate ervoor zorgen dat het een gemeenschappelijke primaire sleutelwaarde in beide tabellen zal gebruiken. Op deze manier kan de primaire sleutel van EmployeeEntity veilig worden beschouwd als de primaire sleutel van AccountEntity.

De tabelstructuur zal er als volgt uitzien:

In deze benadering is @PrimaryKeyJoinColumn de belangrijkste annotatie die moet worden gebruikt. Laten we eens kijken hoe u deze kunt gebruiken.

@OneToOne(cascade = CascadeType.ALL)@PrimaryKeyJoinColumnprivate AccountEntity account;

In AccountEntity blijft deze voor de mapping afhankelijk van de owner entity.

@OneToOne(mappedBy="account", cascade=CascadeType.ALL)private EmployeeEntity employee;

Het testen van de bovenstaande entiteiten genereert de volgende SQL-query’s in logbestanden:

Hibernate één-op-één mapping met @MapsId

In deze techniek gaat hibernate ervan uit dat zowel de bron- als de doelentiteit dezelfde primaire-sleutelwaarden hebben.

In deze benadering is @MapsId de belangrijkste annotatie die moet worden gebruikt. Laten we eens kijken hoe het te gebruiken.

@Idprivate Integer employeeId;@OneToOne @MapsIdprivate AccountEntity account;

In AccountEntity kant, blijft het afhankelijk van de eigenaar entiteit voor de mapping.

@Idprivate Integer accountId;