4.1 Mga transaksyon at integridad ng database
Ang normal na mode ng pagpapatakbo ng isang database ay kapag nakakatanggap ito ng libu-libong kahilingan bawat minuto mula sa daan-daang iba't ibang kliyente. Sa kasong ito, madalas na lumitaw ang mga sitwasyon kapag ang parehong data ay na-access mula sa iba't ibang mga query.
Mas madalas, ngunit, muli, paminsan-minsan ay may mga sitwasyon kapag ang isang kahilingan ay nagbabasa ng isang tiyak na linya, at ang isa pang kahilingan ay nagbabago nito nang sabay-sabay. Isipin kung ano ang mangyayari kung ang isang tao ay nagbabasa ng isang linya na kalahati lamang ang nabago? Walang maganda.
Ang problemang ito ay nalutas sa maraming paraan. Una, maaari mo lamang i-lock ang linyang nagbabago. Parehong para sa pagbabasa at para sa pagsusulat. Gumagana ang pamamaraang ito, ngunit ang bilis ng base ay lubhang naghihirap.
Ang pangalawang paraan ay i-lock ang string para sa pagsusulat lamang. Gayunpaman, magkakaroon pa rin ng problema kapag sinubukan ng isang tao na basahin ang bahagyang binagong linya. Konklusyon - hindi dapat magkaroon ng isang sitwasyon kapag ang linya ay bahagyang nabago.
Samakatuwid, sila ay dumating sa isang ikatlong paraan - mga transaksyon. Ang isang transaksyon ay isang pangkat ng mga aksyon na ginagawa nang sama-sama, o wala sa lahat. Hindi maaaring magkaroon ng isang sitwasyon kung saan ang bahagi ng mga aksyon ay isinagawa, at ang pangalawang bahagi ay hindi. Kung hindi posible na gawin ang lahat ng mga pagbabago, ang lahat ng mga pagbabagong nagawa na ay ibabalik.
Ang anumang modernong SQL server ay nagpapahintulot sa iyo na baguhin ang data lamang sa mga transaksyon. Magbubukas ka ng isang transaksyon, gumawa ng anumang mga pagbabago sa anumang bilang ng mga talahanayan, at i-commit ang transaksyon. Pagkatapos ay sinusubukan ng SQL Server na gumawa ng mga pagbabago. Kung maayos lang ang lahat, idadagdag sila sa pangkalahatang database. Kung may mga problema, kakanselahin ang lahat ng pagbabago.
Ginagamit din ng hibernate ang paradigm na ito. Iyon ang dahilan kung bakit sa nakaraang lecture nakita namin na kapag sinusubukang i-save ang Empleyado object sa database, isang transaksyon ay unang binuksan, at pagkatapos i-save, ito ay nakatuon.
Tatalakayin natin ang paksang ito nang mas detalyado, ngunit sa ngayon, alamin lamang kung bakit kailangan ang mga transaksyon at kung saan karaniwang ginagamit ang mga ito.
4.2 Pagkuha ng mga bagay
Kung ang Hibernate ay nagsasagawa ng kahilingan para makakuha ng data, hindi na kailangang tahasang magbukas ng transaksyon. Ang hibernate mismo ang gagawa nito kung nakikita nitong akma: mayroon itong mga setting, pati na rin ang mga setting ng SQL server.
Susuriin namin kung paano magtrabaho kasama ang database. At ang pinakasimple sa kanila ay ang pagkuha ng isang bagay sa pamamagitan ng ID nito . Upang gawin ito, gamitin ang pamamaraan get()sa object ng session . Ang pangkalahatang anyo ng naturang kahilingan:
Class Name = session.get(Class.class, ID);Halimbawa:
public User getUserById(Integer id) {
try (Session session = sessionFactory.openSession()) {
User user = session.get(User.class, id);
return user;
}
}4.3 Pag-save (pagdaragdag) ng mga bagay
Kung gusto mong i-save ang iyong object sa database, ang isang query ay isasagawa sa antas ng SQLINSERT. Samakatuwid, ang iyong mga aksyon ay dapat gawin bilang isang hiwalay na transaksyon. Gayundin, mas mainam na gamitin ang pamamaraan persist()ng object ng session para sa pagtitiyaga .
Ang pangkalahatang anyo ng naturang kahilingan:
session.persist(An object);Ang pamamaraan persist()ay nagbabago hindi lamang sa base, kundi pati na rin sa bagay mismo. Ang bagay ay kapag nagdagdag kami ng isang bagay sa database, ang bagay na ito ay wala pang sariling ID bago ito idagdag . Well, kadalasan kaya, kahit na may mga nuances. At pagkatapos idagdag ang bagay ay mayroon nang ID .
public boolean saveUser(User user) {
try (Session session = sessionFactory.openSession()) {
Transaction transaction = session.beginTransaction();
session.persist(user);
transaction.commit();
return true;
}
catch() {
return false;
}
}Ang Session object ay mayroon ding paraan save()na gumaganap ng katulad na function. Kaya lang, ang pamamaraan save()ay ang lumang pamantayang Hibernate at ang pamamaraan persist()ay ang pamantayang JPA.
4.4 Pagtanggal ng mga bagay
Kung gusto mong tanggalin ang isang umiiral na bagay, napakadaling gawin ito. Upang gawin ito, ang session object ay may isang espesyal na paraan - remove().
Ang pangkalahatang anyo ng naturang kahilingan:
session.remove(An object);At, siyempre, isulat natin ang code na may isang halimbawa:
public boolean removeUser(User user) {
try (Session session = sessionFactory.openSession()) {
Transaction transaction = session.beginTransaction();
session.remove(user);
transaction.commit();
return true;
}
catch() {
return false;
}
}Bakit napakahirap, tanong mo?
Well, una sa lahat, ang anumang mga pagbabago sa database ay palaging may iba't ibang at hindi palaging malinaw na mga kahihinatnan. At pangalawa, ang object na ito ay maaaring may mga child object na nauugnay dito, atbp. Kaya ang mga senaryo sa pagtanggal ay kadalasang hindi mahalaga.
GO TO FULL VERSION