A few of Hibernate’s core options are computerized soiled checks, flushes, and the first degree cache. They make the implementation of most traditional use instances easy and environment friendly. However in addition they add quite a lot of hidden complexity and will not be an incredible match for all use instances. Your typical nightly import job or most different use instances that carry out plenty of write operations don’t profit from these options. They usually even decelerate such use instances. In these conditions, Hibernate’s StatelessSession is perhaps a greater match.
What’s a StatelessSession?
The StatelessSession is a proprietary Hibernate function that gives a command-oriented API that’s a lot nearer to JDBC. I’ll present you a couple of examples of easy methods to use it to implement typical learn and write operations on this article. However earlier than we take a better take a look at the StatelessSession interface, we have to discuss in regards to the conceptual variations from a normal Session interface.
Hibernate’s StatelessSession doesn’t present a 1st degree cache, automated soiled checks, or write-behind automation. It additionally doesn’t present lazy loading in your managed associations and doesn’t use the 2nd degree or question cache. Any operation carried out through a StatelessSession additionally doesn’t set off any lifecycle occasions or interceptors.
As a substitute of all the automated options {that a} common Session or JPA’s EntityManager offers, the StatelessSession places you in full management of the executed SQL statements. If you wish to fetch some information from the database or initialize an affiliation, you could write and execute a question for it. And should you create a brand new or change an present entity object, you could name the insert, replace or delete technique on the StatelessSession interface to persist your change.
That requires you to place extra thought into the technical facet of your persistence layer. But when your use case doesn’t require computerized soiled checks, lazy loading, or 1st degree caches, utilizing a StatelessSession additionally drastically reduces Hibernate’s efficiency overhead. That makes Hibernate’s StatelessSession an incredible match to be used instances that import or replace an enormous set of information. That’s particularly the case should you’re already utilizing Hibernate for different components of your software and need to reuse your entity mannequin.
You might additionally attempt the StatelessSession if you could fetch many entity objects that you’ll not change and should you don’t require any lazy fetching of related entities. However queries that return use case particular DTO projections are sometimes a greater match for these use instances.
The way to use a StatelessSession?
Let’s use a StatelessSession for studying and writing entity objects. You may get a StatelessSession occasion in the same method as the traditional Session occasion. In case your software runs in an software server or relies on Spring, you possibly can merely inject a StatelessSession occasion. And should you’re utilizing plain Hibernate, you possibly can name the openStatelessSession technique in your SessionFactory and use it to begin a transaction.
StatelessSession statelessSession = sf.openStatelessSession();
statelessSession.getTransaction().start();
// do one thing
statelessSession.getTransaction().commit();
After you get a StatelessSession occasion, you need to use it to learn and write information.
Inserting and updating entities utilizing a StatelessSession
Most tasks use a StatelessSession to insert or replace big information units. So let’s begin with 2 easy write operations.
An important strategies you could know when implementing write operations utilizing a StatelessSession are the strategies insert, replace and delete. You want to name them if you wish to persist a brand new entity object or replace or delete an present one. When doing that, please bear in mind {that a} StatelessSession doesn’t assist cascading. So, you could set off your write operations for each entity object you need to persist.
Within the following check case, I need to insert a brand new ChessPlayer entity object and repair a typo within the firstName afterward.
StatelessSession statelessSession = sf.openStatelessSession();
statelessSession.getTransaction().start();
ChessPlayer participant = new ChessPlayer();
participant.setFirstName("Torben");
participant.setLastName("Janssen");
log.information("Carry out insert operation");
statelessSession.insert(participant);
log.information("Replace firstName");
participant.setFirstName("Thorben");
statelessSession.replace(participant);
statelessSession.getTransaction().commit();
You most likely already acknowledged the primary variations should you’re aware of Hibernate’s Session interface or JPA’s EntityManager. I referred to as the insert technique to persist the brand new ChessPlayer object and the replace technique to persist the modified firstName.
As I discussed earlier, a StatelessSession doesn’t present a 1st degree cache, soiled checks, and computerized write-behind optimizations. Resulting from that, Hibernate instantly performs an SQL INSERT assertion whenever you name the insert technique with an entity object. And Hibernate doesn’t detect the modified firstName attribute. You want to name the replace technique if you wish to persist that change. Hibernate then instantly executes an SQL UPDATE assertion.
When you use my beneficial logging configuration for growth programs, you possibly can see all of that within the log output.
17:46:23,963 INFO [com.thorben.janssen.TestStatelessSession] - Carry out insert operation
17:46:23,968 DEBUG [org.hibernate.SQL] -
choose
nextval('player_seq')
17:46:23,983 DEBUG [org.hibernate.SQL] -
insert
into
ChessPlayer
(birthDate, firstName, lastName, model, id)
values
(?, ?, ?, ?, ?)
17:46:23,988 INFO [com.thorben.janssen.TestStatelessSession] - Replace firstName
17:46:23,989 DEBUG [org.hibernate.SQL] -
replace
ChessPlayer
set
birthDate=?,
firstName=?,
lastName=?,
model=?
the place
id=?
and model=?
As you possibly can see on this instance, not having a 1st degree cache, computerized soiled checks, and flush operations, requires you to set off all database interactions. This places you in full management of the execution of the SQL statements, and it offers higher efficiency when writing big datasets.
Studying entity objects utilizing a StatelessSession
While you’re utilizing a StatelessSession to learn entity objects from the database, your code appears equivalent to the one utilizing a normal Session. However there are a couple of vital Hibernate-internal variations you could know.
I discussed earlier {that a} StatelessSession doesn’t present lazy loading. Resulting from that, you could initialize all of the required associations when fetching an entity object from the database. In any other case, Hibernate throws a LazyInitializationException whenever you entry the affiliation for the first time. One of the best ways to initialize an affiliation is to make use of an EntityGraph or embody a JOIN FETCH clause in your JPQL question.
Within the following examples, I exploit a JPQL question with 2 JOIN FETCH clauses to load a ChessPlayer entity object. The JOIN FETCH clauses inform Hibernate to initialize the affiliation to the video games they performed with the white and black items.
StatelessSession statelessSession = sf.openStatelessSession();
statelessSession.getTransaction().start();
ChessPlayer participant = statelessSession.createQuery("""
SELECT p
FROM ChessPlayer p
JOIN FETCH p.gamesWhite
JOIN FETCH p.gamesBlack
WHERE p.id=:id""", ChessPlayer.class)
.setParameter("id", 1L)
.getSingleResult();
log.information(participant.getFirstName() + " " + participant.getLastName());
log.information("White items: " + participant.getGamesWhite().measurement());
log.information("Black items: " + participant.getGamesBlack().measurement());
statelessSession.getTransaction().commit();
As talked about earlier, the variations between a learn operation carried out utilizing a StatelessSession, and a Session occasion just isn’t instantly seen in your code. And the identical is true for the log output.
17:58:09,648 DEBUG [org.hibernate.SQL] -
choose
c1_0.id,
c1_0.birthDate,
c1_0.firstName,
g2_0.playerBlack_id,
g2_0.id,
g2_0.chessTournament_id,
g2_0.date,
g2_0.playerWhite_id,
g2_0.spherical,
g2_0.model,
g1_0.playerWhite_id,
g1_0.id,
g1_0.chessTournament_id,
g1_0.date,
g1_0.playerBlack_id,
g1_0.spherical,
g1_0.model,
c1_0.lastName,
c1_0.model
from
ChessPlayer c1_0
be a part of
ChessGame g1_0
on c1_0.id=g1_0.playerWhite_id
be a part of
ChessGame g2_0
on c1_0.id=g2_0.playerBlack_id
the place
c1_0.id=?
17:58:09,682 DEBUG [org.hibernate.stat.internal.StatisticsImpl] - HHH000117: HQL: SELECT p
FROM ChessPlayer p
JOIN FETCH p.gamesWhite
JOIN FETCH p.gamesBlack
WHERE p.id=:id, time: 56ms, rows: 1
17:58:09,685 INFO [com.thorben.janssen.TestStatelessSession] - Magnus Carlsen
17:58:09,685 INFO [com.thorben.janssen.TestStatelessSession] - White items: 1
17:58:09,686 INFO [com.thorben.janssen.TestStatelessSession] - Black items: 2
However there are vital inside variations. Hibernate not solely doesn’t assist lazy loading for StatelessSessions but in addition doesn’t use any caches, together with the first degree cache. That reduces the overhead carried out for every database question. However Hibernate can not assure that you simply at all times get the identical object should you’re studying the identical entity a number of occasions throughout the identical session.
You may see that within the following check case, during which I execute the identical question twice.
StatelessSession statelessSession = sf.openStatelessSession();
statelessSession.getTransaction().start();
ChessPlayer player1 = statelessSession.createQuery("""
SELECT p
FROM ChessPlayer p
JOIN FETCH p.gamesWhite
JOIN FETCH p.gamesBlack
WHERE p.id=:id""", ChessPlayer.class)
.setParameter("id", 1L)
.getSingleResult();
ChessPlayer player2 = statelessSession.createQuery("""
SELECT p
FROM ChessPlayer p
JOIN FETCH p.gamesWhite
JOIN FETCH p.gamesBlack
WHERE p.id=:id""", ChessPlayer.class)
.setParameter("id", 1L)
.getSingleResult();
assertNotEquals(player1, player2);
statelessSession.getTransaction().commit();
Utilizing a normal Session occasion, Hibernate would execute the first question, instantiate an entity object for the returned document and retailer it within the 1st degree cache. After that, it might execute the 2nd question, examine the first degree cache for an entity object that represents the document returned within the end result set, and return that object. That ensures that you simply at all times get the identical entity object should you fetch a database document a number of occasions throughout the identical session.
With out the first degree cache, the StatelessSession doesn’t find out about any beforehand chosen entity objects. It has to instantiate a brand new object for each document returned by a question. Resulting from that, you will get a number of objects that characterize the identical database document. Within the earlier instance, that’s the case for the player1 and player2 objects.
Please hold that in thoughts when writing your corporation code and just remember to at all times use the identical entity object in your write operations. In any other case, you may overwrite beforehand carried out modifications.
Conclusion
Hibernate’s StatelessSession interface offers a command-oriented API that provides you extra management over the executed SQL statements. It’s a lot nearer to JDBC and doesn’t assist any caches, computerized flushes, soiled checks, cascading and lazy loading.
That makes a StatelessSession an incredible match for all use instances that don’t profit from these options. Typical examples are batch jobs or different use instances that carry out many easy write operations.
However with out all these options, implementing your persistence layer requires just a little extra work. You want to set off all database operations your self. E.g., after you modify a number of entity attributes, you could name the replace technique in your StatelessSession occasion to persist the change within the database. In any other case, Hibernate won’t concentrate on the change and won’t set off any SQL statements.
You additionally have to initialize all required associations whenever you fetch an entity object from the database. And you could bear in mind {that a} StatelessSession doesn’t return the identical entity object should you fetch the identical document a number of occasions. That makes the dealing with of question outcomes just a little extra advanced.
General, Hibernate’s StatelessSession is a good function if you wish to cut back the overhead of Hibernate’s Session dealing with and don’t want options like lazy loading, cascading, a 1st degree cache, and computerized flushes.
