Objectrelationele mapping

1.1 Klassen toewijzen aan tabellen

Na het leren van JDBC heb je hoogstwaarschijnlijk de indruk dat het werken met een database vanuit een Java-applicatie nog steeds een plezier is. Wat als ik je zou vertellen dat al dit werk 10 keer makkelijker gedaan kan worden?

Wat is het belangrijkste voordeel van de SQL-taal? Dit is een declaratieve taal - het beschrijft wat we willen krijgen, en zegt helemaal niets over hoe we het moeten doen. Hoe - dit is de zorg van de SQL-server.

Dezelfde aanpak kan worden gebruikt bij het werken met databases.

In een ideale wereld zouden we eenvoudigweg SQL-query's naar de database kunnen schrijven en als antwoord zouden we kant-en-klare Java-objecten of verzamelingen Java-objecten ontvangen als we om meerdere stukken zouden vragen.

Wat kan ik zeggen, dit is wat verschillende jongens in 2000 dachten en besloten om hun eigen ORM-framework te schrijven.

ORM staat voor Object-Relational Mapping en is in wezen een toewijzing van Java-objecten aan SQL-query's.

De jongens bedachten iets heel eenvoudigs: elke tabel in de database moet overeenkomen met een bepaalde klasse in de Java-toepassing . In een Java-toepassing werken we met objecten en deze objecten weten al hoe ze zichzelf moeten opslaan in de database.

Er waren drie benaderingen om dit probleem op te lossen, en ze zagen er ongeveer zo uit:

1. Het object slaat zichzelf op in de database en werkt de velden bij op basis van informatie uit de database.
2. Het object kan zichzelf opslaan in de database, maar start deze case nooit.
3. Het object bevat alleen gegevens en iemand slaat het op in de database en laadt het vanuit de database.

Aanvankelijk domineerde de eerste benadering, daarna waren applicatieservers en Enterprise Java Beans populair. Er was zelfs een hele klasse bonen genaamd Persistence EJB's die zichzelf in de database konden opslaan.

Maar op een dag veranderde alles...

1.2 Opkomst van de slaapstand

In 2001 werd de eerste versie van het Hibernate-framework uitgebracht. Het was een heel eenvoudig raamwerk, maar het stond het gebruik toe van gewone "stomme objecten" die niets wisten over hoe ze in de database moesten worden opgeslagen of van daaruit moesten worden geladen.

Mapping van velden van Java-klassen en kolommen in een tabel in de database werd ingesteld met behulp van een XML-bestand. En soms waren ze behoorlijk omvangrijk. Oké, wie houd ik voor de gek. Het waren flinke canvassen met XML-code. En de situatie werd alleen gered door het feit dat er 20 jaar geleden niet zulke gigantische databases waren als nu.

Maar in feite was de krachtigste beslissing om eindelijk het object dat in de database moet worden opgeslagen te scheiden van de code die het daar heeft opgeslagen . Deze oplossing ligt niet echt voor de hand. Omdat het principe van inkapseling stelt dat het object het beste weet hoe het moet worden opgeslagen en geladen.

En de ORM-benadering doorbreekt dat concept echt. De dataklasse legt zijn interne structuur bloot, maar het is veel gemakkelijker geworden om met groepen objecten van verschillende typen te werken.

Een grote doorbraak kwam na de release van Java 5 , toen er twee dingen in de JDK verschenen:

• Annotaties
• volmacht

AnnotatiesXML werd snel verdrongen en nu was het eenvoudig om alle benodigde instellingen voor het toewijzen van een Java-klasse aan een tabel in de database direct in de Java-klasse op te geven.

Volmachtniet zo opvallend voor de Hibernate-gebruiker, maar hun bijdrage was zelfs nog serieuzer. Wanneer u een specifiek object of specifieke objecten uit Hibernate opvraagt, geeft het u gewoon een stub (proxy) terug en onderschept het alle oproepen naar zijn methoden.

Dit maakte het mogelijk om verschillende Lazy Loading mechanismen te implementeren en bracht de snelheid en efficiëntie van Hibernate naar een voor die tijd volledig torenhoog niveau. Hibernate is niet alleen een de facto industriestandaard geworden - het wordt ook in andere talen vertaald. Zo verscheen bijvoorbeeld Framework NHibernate voor C#.

1.3 Opkomst van PPV

De facto gevolgd door de jure erkenning. De JDK-ontwikkelaars besloten een specificatie te maken voor het correct toewijzen van objecten aan tabellen in een database. Deze specificatie heetPPV- Java-persistentie-API.

Dit is precies de specificatie. Het beschrijft hoe alles zou moeten werken en welke annotaties we nodig hebben om verschillende delen van de klas te markeren als we willen dat de objecten in de database worden opgeslagen.

Het lijkt erop dat de jongens gewoon Hibernate als basis hebben genomen en de pakketnamen ervan hebben gewijzigd. Omdat alle annotaties die in Hibernate stonden bijna één voor één naar JPA zijn verplaatst.

Tegenwoordig implementeert Hibernate de volledige JPA-specificatie volledig, evenals enkele extra functies die het werken ermee nog comfortabeler maken. Daarom kunnen we in termen van standaardisatie zeggen dat Hibernate twee sets functies heeft:

• JPA-standaard
• Hibernate Native API (aanvullende functionaliteit)

De officiële Hibernate-documentatie beschrijft het als volgt:

Maar zowel op basis van mijn ervaring als na het herlezen van de Hibernate-documentatie, kan ik zeggen dat JPA en Hibernate API voor 95% hetzelfde zijn. Het zijn gewoon identieke concepten.

1.4 Maven voor slaapstand

Omdat ik Hibernate zo heb geprezen, denk ik dat het tijd is om er wat harder mee te gaan werken.

Ten eerste is er een officiële site, waar alleen een heleboel Engelstalige documentatie te vinden is. Ze heeft natuurlijk een voorkeur voor referentie-informatie en niet voor training. Maar het is nog steeds beter dan de bronnen debuggen, toch? :)

Instructie:

1. Je opent de link .
2. Je kijkt haar lang aan.
3. Terugkomend op CodeGym.
4. Je leest mijn verdere lezingen.

Het is mijn taak om complexe zaken te vereenvoudigen en in eenvoudige bewoordingen uit te leggen. En als je dit niveau hebt bereikt, dan kan ik het.

Nou, om met Hibernate aan de slag te gaan, moet je het toevoegen aan je pom.xml. Tot op heden is de 6e versie van Hibernate al beschikbaar, of liever 6.1.1, dus we zullen leren werken met de nieuwste versie.

Voeg gewoon deze regels toe aan uw pom.xml:

<dependency>
	<groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
	<version>6.1.1.Final</version>
</dependency>

Leest u deze lezing buiten het raam van 2023+, dan is de nieuwe versie hier te downloaden .

Belangrijk! Sommige bibliotheken die Hibernate gebruikt, zijn verouderd in JDK 11 en JDK 17, dus als u problemen ondervindt om uw project aan de gang te krijgen, voegt u deze afhankelijkheden eraan toe:

<dependency>
        <groupId>jakarta.xml.bind</groupId>
        <artifactId>jakarta.xml.bind-api</artifactId>
      	<version>4.0.0</version>
</dependency>

<dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
      	<version>4.0.0</version>
</dependency>

<dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.29.0-GA</version>
</dependency>