Shulou(Shulou.com)06/01 Report--

Editor to share with you an example of the transition of the three states of Hibernate. I hope you will get something after reading this article. Let's discuss it together.

1. Miraculous things that happen to you

Using jpa to operate the database, when I use the findAll () method to find and deal with an List object, I do some operations on the list entity, and do not call the update or saveOrUpdate method, but the changed data is magically saved to the database.

Finally, the simple and rude solution is to make a copy of the List found in the data, then operate it, and then return. The data is normal and the database is not updated. After looking for information, I found that jpa is the encapsulation of hibernate, and the bottom layer is hibernate, which is caused by the persistent state of hibernate.

Second, the three states of hibernate

1. Instantaneous state (Transient)

When we use the new keyword of Java to generate an entity object, the entity object is in a free state, as follows:

Customer customer=new Customer ("zx", 27 images)

At this point, the customer object is in a free state. Why is the customer object in a free state? This is because, at this time, customer has only obtained a piece of memory space through JVM, and has not been saved into the database through the save () method of Session object, so it has not been included in the cache management of Hibernate, that is to say, customer object is still free to wander outside the Hibernate cache management. So we can see that the most important feature of free objects is that there is no corresponding record in the database.

Characteristics of instantaneous objects:

Not associated with Session instance

There are no records associated with transient objects in the database

2. Persistent status (Persistent)

A persistent object is an entity object that has been stored in the database, and this entity object is still under the cache management of Hibernate. This is any modification to the entity object that is synchronized to the database when the cache is cleaned. As follows:

Customer customer=new Customer ("zx", 27 images)

Tx=session.beginTransaction ()

Session.save (customer)

Customer= (Customer) session.load (Customer.class, "1")

Customer.setAge (28)

Tx.commit ()

At this time, we do not show that we call the session.update () method to save the update, but the changes to the entity object will be synchronously updated to the database, because after the customer object is saved into the database through the save method, it is already a persistent object, and then loaded again by the load method, it is still under the management of the Hibernate cache, when the tx.commit () method is executed Hibernate automatically cleans up the cache and automatically synchronizes the property changes of the persisted object to the database.

Persistent instances have a corresponding record in the database and have a persistence identity (identifier).

Persistent objects are always associated with Session and Transaction. In a Session, changes to persistent objects do not immediately change the database, but must be terminated by Transaction, that is, after the execution of commit (), before the SQL is actually run in the database to make changes before the state of the persistent object is synchronized with the database. Persistent objects before synchronization are called dirty objects.

An instantaneous object becomes a persistent object:

Associate a transient object with the database through Session's save () and saveOrUpdate () methods, and the transient object becomes a persistent object.

Data objects to be queried by methods using fine (), get (), load (), and iterater () will become persistent objects.

Characteristics of persistent objects:

Associated with a Session instance

There are records associated with persistent objects in the database

3. Off-tube status (Detached)

When a persistent object is separated from the cache management of Hibernate, it is in a free state. The biggest difference between a free object and a free object is that there may still be a record corresponding to it in the database, but now this free object is separated from the cache management of Hibernate, and the free object will not appear its corresponding data record in the database. As follows:

Customer customer=new Customer ("zx", 27 images)

Tx=session.beginTransaction ()

Session.save (customer)

Customer= (Customer) session.load (Customer.class, "1")

Customer.setAge (28)

Tx.commit ()

Session.close ()

When session is closed, the customer object is no longer in the cache management of Hibernate, but there is still a data record corresponding to the customer object in the database, so the customer object is in a free state.

When the Session associated with a persistent object is turned off, the object becomes an unmanaged object. The reference to the detached object is still valid and the object can continue to be modified.

Characteristics of out-of-tube objects:

Essentially the same as the instantaneous object.

It's just that there is one more database record identification value id than the love of instantaneous objects.

A persistent object becomes an out-of-pipe object:

When close () or clear (), evict () is executed, the persistent object becomes an unmanaged object.

An instantaneous object becomes a persistent object:

Through Session's update (), saveOrUpdate () and lock () methods, an out-of-pipe object is turned into a persistent object.

Third, the transition of the three states

4. Cite examples

Explain the state of the object by combining save (), update (), saveOrUpdate () methods

(1) the Save () method saves the transient object to the database, and the temporary state of the object becomes persistent. When an object is in a persistent state, it is always in Session's cache, and any operations on it will be synchronized to the database when the transaction commits, so it makes no sense to call the save () or update () method on an object that is already persistent. Such as:

Student stu = new Strudnet ()

Stu.setCarId ("200234567")

Stu.setId ("100")

/ / Open Session and start the transaction

Session.save (stu)

Stu.setCardId ("20076548")

Session.save (stu); / / invalid

Session.update (stu); / / invalid

/ / commit the transaction and close Session

(2) there are two uses of the update () method to re-associate the out-of-pipe object to a persistent state object and display a call to update () to update the object. Calling update () is just to associate an unmanaged object to a persistent state, and it doesn't make much sense to call update () when the object is already in a persistent state. Such as:

/ / Open session and start the transaction

Stu = (Student) session.get (Student.class, "123456")

Stu.setName ("Body")

Session.update (stu); / / since stu is a persistent object, it must be in the Session buffer

Changes made to stu are / / synchronized to the database. So update () is meaningless, so we don't want this sentence to have the same effect.

/ / commit the transaction and close Session

Hibernate always executes the update statement, regardless of whether the detached object has changed since it left Session. Hibernate always sends a update statement when cleaning the cache to ensure that the detached object is consistent with the data recorded in the database, such as:

Student stu = new Strudnet ()

Stu.setCarId ("1234")

/ / Open Session1 and start the transaction

Session1.save (stu)

/ / commit the transaction and close Session1

Stu.set ("4567"); / / A change is made to the unmanaged object

/ / Open Session2 and start the transaction

Session2.update (stu)

/ / commit the transaction and close Session2

Note: even if session2.update (stu); is removed, a update () statement will still be executed when the transaction is committed.

If you want Hibernate to generate a update statement only if the detached object has changed, you can set the select-before-update of the tag in the mapping file to true. This will first send a select statement to get the value in the database to determine whether the value is the same. If it is the same, the update statement will not be executed. However, this approach has some disadvantages: an extra update statement is always sent before each select statement, which affects performance. The setting is valid for classes that change occasionally, and it affects efficiency for classes that change frequently.

(3) the saveOrUpdate () method has the function of both save () and update () methods. For the incoming object, saveOrUpdate () first determines whether it is a detached object or a temporary object, and then calls the appropriate method.

After reading this article, I believe you have a certain understanding of the "example of the transition of the three states of Hibernate". If you want to know more about it, please follow the industry information channel. Thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.