Object Relational Mapping

1.1 Pagma-map ng mga klase sa mga talahanayan

Matapos matutunan ang JDBC, malamang na mayroon kang impresyon na ang pagtatrabaho sa isang database mula sa isang Java application ay isang kasiyahan pa rin. Paano kung sabihin ko sa iyo na ang lahat ng gawaing ito ay maaaring gawin nang 10 beses na mas madali?

Ano ang pangunahing bentahe ng wikang SQL? Ito ay isang deklaratibong wika - inilalarawan nito kung ano ang gusto nating makuha, at walang sinasabi tungkol sa kung paano ito gagawin. Paano - ito ang alalahanin ng SQL server.

Ang parehong diskarte ay maaaring gamitin kapag nagtatrabaho sa mga database.

Sa isang perpektong mundo, maaari lang kaming sumulat ng mga SQL query sa database, at bilang tugon ay makakatanggap kami ng mga yari na Java object, o mga koleksyon ng mga Java object, kung humiling kami ng ilang piraso.

Ano ang masasabi ko, ito ang naisip ng ilang lalaki noong 2000 at nagpasyang magsulat ng kanilang sariling ORM framework.

Ang ORM ay nakatayo para sa Object-Relational Mapping at mahalagang pagmamapa ng mga object ng Java sa mga query sa SQL.

Ang mga lalaki ay dumating sa isang napaka-simpleng bagay - ang bawat talahanayan sa database ay dapat na tumutugma sa ilang klase sa Java application . Sa isang application ng Java, nagpapatakbo kami sa mga bagay, at alam na ng mga bagay na ito kung paano i-save ang kanilang mga sarili sa database.

Mayroong tatlong mga diskarte sa paglutas ng problemang ito, at mukhang ganito ang mga ito:

1. Ini-imbak ng object ang sarili nito sa database at ina-update ang mga field nito batay sa impormasyon mula sa database.
2. Nagagawa ng object na i-save ang sarili nito sa database, ngunit hindi kailanman pinasimulan ang kasong ito.
3. Ang bagay ay naglalaman lamang ng data, at may nagse-save nito sa database at naglo-load nito mula sa database.

Sa una, ang unang diskarte ay nangibabaw, pagkatapos ay ang mga server ng Application at Enterprise Java Beans ay sikat. Mayroong kahit isang buong klase ng beans na tinatawag na Persistence EJBs na maaaring mag-save ng kanilang sarili sa database mismo.

Pero isang araw nagbago ang lahat...

1.2 Pag-usbong ng Hibernate

Noong 2001, inilabas ang unang bersyon ng framework ng Hibernate. Ito ay isang napaka-simpleng balangkas, ngunit pinahintulutan nito ang paggamit ng ordinaryong "mga hangal na bagay" na hindi alam ang anumang bagay tungkol sa kung paano sila dapat na maimbak sa database o mai-load mula doon.

Ang pagmamapa ng mga patlang ng mga klase ng Java at mga haligi sa isang talahanayan sa database ay itinakda gamit ang isang XML file. At kung minsan sila ay napakalaki. Okay, sinong niloloko ko. Ang mga ito ay mabibigat na canvases ng XML code. At ang sitwasyon ay nai-save lamang sa pamamagitan ng katotohanan na 20 taon na ang nakalilipas ay walang mga napakalaking database tulad ngayon.

Ngunit sa katunayan, ang pinakamakapangyarihang desisyon ay sa wakas ay paghiwalayin ang bagay na kailangang i-save sa database mula sa code na nag-save dito . Ang solusyon na ito ay hindi talaga halata. Dahil ang prinsipyo ng encapsulation ay nagsasaad na ang bagay ay higit na nakakaalam tungkol sa kung paano ito kailangang maimbak at mai-load.

At talagang sinisira ng diskarte ng ORM ang konseptong iyon. Inilalantad ng klase ng data ang panloob na istraktura nito, ngunit naging mas madali itong gumana sa mga pangkat ng mga bagay na may iba't ibang uri.

Isang malaking tagumpay ang dumating pagkatapos ng paglabas ng Java 5 , nang lumitaw ang dalawang bagay sa JDK:

• Mga anotasyon
• proxy

Mga anotasyonMabilis na napalitan ang XML, at ngayon ay madaling tukuyin ang lahat ng kinakailangang setting para sa pagmamapa ng isang klase ng Java sa isang talahanayan sa database mismo sa klase ng Java.

Proxyhindi gaanong kapansin-pansin sa gumagamit ng Hibernate, ngunit ang kanilang kontribusyon ay mas seryoso. Kapag humiling ka ng isang partikular na bagay o mga bagay mula sa Hibernate, ibabalik lang nito sa iyo ang isang stub (proxy), at haharangin ang lahat ng tawag sa mga pamamaraan nito.

Dahil dito, naging posible na ipatupad ang iba't ibang mekanismo ng Lazy Loading at itinaas ang bilis at kahusayan ng Hibernate sa isang ganap na sky-high level para sa panahong iyon. Ang hibernate ay naging hindi lamang isang de facto na pamantayan sa industriya - nagsimula itong isalin sa ibang mga wika. Kaya, halimbawa, lumitaw ang Framework NHibernate para sa C#.

1.3 Pag-usbong ng JPA

De facto na sinundan ng de jure recognition. Nagpasya ang mga developer ng JDK na lumikha ng isang detalye sa kung paano tama ang pagmamapa ng mga bagay sa mga talahanayan sa isang database. Ang pagtutukoy na ito ay tinatawag naJPA- Java Persistence API.

Ito ang eksaktong detalye. Inilalarawan nito kung paano dapat gumana ang lahat at kung anong mga anotasyon ang kailangan nating markahan ang iba't ibang bahagi ng klase kung gusto nating ma-save ang mga bagay nito sa database.

Tila kinuha lamang ng mga lalaki ang Hibernate bilang batayan at binago ang mga pangalan ng pakete mula dito. Dahil halos isa-isang inilipat sa JPA ang lahat ng anotasyon na nasa Hibernate.

Ngayon, ganap na ipinapatupad ng Hibernate ang buong detalye ng JPA, pati na rin ang ilang karagdagang feature na ginagawang mas komportable ang pagtatrabaho dito. Samakatuwid, sa mga tuntunin ng standardisasyon, maaari nating sabihin na ang Hibernate ay may dalawang hanay ng mga tampok:

• pamantayan ng JPA
• Hibernate Native API (karagdagang functionality)

Inilalarawan ito ng opisyal na dokumentasyon ng Hibernate tulad nito:

Ngunit pareho batay sa aking karanasan at pagkatapos basahin muli ang dokumentasyon ng Hibernate, masasabi kong 95% pareho ang JPA at Hibernate API. Magkapareho lang sila ng mga konsepto.

1.4 Maven para sa Hibernate

Dahil labis kong pinuri ang Hibernate, sa tingin ko ay oras na para magpatuloy sa pagtatrabaho dito nang mas mahirap.

Una, mayroong isang opisyal na site, kung saan mayroon lamang isang bungkos ng dokumentasyon sa wikang Ingles. Siya, siyempre, ay may bias sa reference na impormasyon, at hindi sa pagsasanay. Ngunit mas mahusay pa rin ito kaysa sa pag-debug ng mga mapagkukunan, tama ba? :)

Tagubilin:

1. Buksan mo ang link .
2. Tinitigan mo siya ng matagal.
3. Babalik sa CodeGym.
4. Basahin mo ang mga karagdagang lecture ko.

Ang aking trabaho ay pasimplehin ang mga kumplikadong bagay at ipaliwanag ang mga ito sa mga simpleng termino. At kung naabot mo na ang antas na ito, magagawa ko ito.

Well, para makapagsimula sa Hibernate, kailangan mong idagdag ito sa iyong pom.xml. Sa ngayon, available na ang ika-6 na bersyon ng Hibernate, o sa halip ay 6.1.1, kaya matututunan natin kung paano magtrabaho kasama ang pinakabagong bersyon.

Idagdag lang ang mga linyang ito sa iyong pom.xml:

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

Kung binabasa mo ang lecture na ito sa labas ng window ng 2023+, maaaring ma -download ang bagong bersyon dito .

Mahalaga! Ang ilan sa mga aklatan na ginagamit ng Hibernate ay hindi na ginagamit sa JDK 11 at JDK 17, kaya kung nahihirapan kang patakbuhin at patakbuhin ang iyong proyekto, idagdag ang mga dependency na ito dito:

<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>