Arbeta med entitetsobjekt

4.1 Transaktioner och databasintegritet

Det normala driftsättet för en databas är när den tar emot tusentals förfrågningar varje minut från hundratals olika klienter. I det här fallet uppstår ofta situationer när samma data nås från olika frågor.

Mer sällan, men återigen, från tid till annan finns det situationer när en begäran läser en viss rad, och en annan begäran ändrar den samtidigt. Föreställ dig vad som händer om någon läser en rad som bara är halvförändrad? Inget bra.

Detta problem löses på flera sätt. Först kan du bara låsa linjen som ändras. Både för att läsa och för att skriva. Denna metod fungerar, men hastigheten på basen lider mycket.

Det andra sättet är att låsa strängen för att bara skriva. Det kommer dock fortfarande att finnas ett problem när någon försöker läsa den delvis modifierade raden. Slutsats - det bör inte finnas en situation när linjen delvis ändras.

Därför kom de på en tredje metod - transaktioner. En transaktion är en grupp av åtgärder som utförs antingen tillsammans eller inga alls. Det kan inte finnas en situation där en del av åtgärderna utfördes och den andra delen inte gjorde det. Om det inte är möjligt att göra alla ändringar, rullas alla ändringar som redan gjorts tillbaka.

Vilken modern SQL-server som helst låter dig ändra data endast i transaktioner. Du öppnar en transaktion, gör ändringar i valfritt antal tabeller och genomför transaktionen. SQL Server försöker sedan göra ändringar. Om allt är bra kommer de att läggas till i den allmänna databasen. Om det uppstår problem kommer alla ändringar att annulleras.

Hibernate använder också detta paradigm. Det är därför vi i förra föreläsningen såg att när man försökte spara Employee-objektet till databasen, öppnades först en transaktion, och efter sparandet genomfördes den.

Vi kommer att gå in på det här ämnet mer i detalj, men för nu vet du bara varför transaktioner behövs och var de vanligtvis används.

4.2 Skaffa föremål

Om Hibernate exekverar en begäran om att hämta data finns det inget behov av att explicit öppna en transaktion. Hibernate själv kommer att göra detta om det passar: det har sina inställningar, såväl som inställningarna för SQL-servern.

Vi kommer att analysera hur man arbetar med databasen. Och det enklaste av dem är att få ett objekt med dess ID . För att göra detta, använd metoden get()på sessionsobjektet . Den allmänna formen för en sådan begäran:

Class Name = session.get(Class.class, ID);

Exempel:

public User getUserById(Integer id) {
    try (Session session = sessionFactory.openSession()) {
        User user = session.get(User.class, id);
        return user;
    }
}

4.3 Spara (lägga till) objekt

Om du vill spara ditt objekt i databasen kommer en fråga att köras på SQL-nivåFÖRA IN. Därför måste dina handlingar utföras som en separat transaktion. Det är också bättre att använda persist()sessionsobjektets metod för persistens .

Den allmänna formen för en sådan begäran:

session.persist(An object);

Metoden persist()ändrar inte bara basen utan även själva objektet. Saken är den att när vi lägger till ett objekt i databasen har detta objekt ännu inte ett eget ID innan det läggs till . Tja, vanligtvis så, även om det finns nyanser. Och efter att ha lagt till objektet har redan ett 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;
   	}
}

Session- objektet har också en metod save()som utför en liknande funktion. Det är bara det att metoden save()är den gamla Hibernate-standarden och metoden persist()är JPA-standarden.

4.4 Ta bort objekt

Om du vill ta bort ett befintligt objekt är det väldigt enkelt att göra det. För att göra detta har sessionsobjektet en speciell metod - remove().

Den allmänna formen för en sådan begäran:

session.remove(An object);

Och, naturligtvis, låt oss skriva koden med ett exempel:

public boolean removeUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.remove(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

Varför är det så svårt, frågar du?

Jo, först och främst har alla ändringar i databasen alltid olika och inte alltid uppenbara konsekvenser. Och för det andra kan det här objektet ha underordnade objekt associerade med sig, etc. Så borttagningsscenarier är ofta icke-triviala.