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

Today I will show you how to understand the delayed loading of Hibernae. The content of the article is good. Now I would like to share it with you. Friends who feel in need can understand it. I hope it will be helpful to you. Let's read it along with the editor's ideas.

Deferred loading of Hibernae is a very common technique, the collection properties of entities are delayed loading by default, and the entities associated with entities are delayed loading by default. Hibernate uses this delayed loading to reduce the memory overhead of the system, thus ensuring the running performance of Hibernate.

Let's first analyze the "secret" of Hibernate deferred loading.

Delayed loading of collection properties

When Hibernate initializes a persistent entity from the database, does the collection property of that entity initialize with the persistent class? If the collection properties contain 100,000 or even millions of records, the crawling of all the collection properties while initializing the persistent entity will lead to a sharp decline in performance. It is entirely possible that the system only needs to use some of the records in the persistent class collection properties, not all of the collection properties at all, so that it is not necessary to load all the collection properties at once.

For collection properties, it is generally recommended to use a deferred loading strategy. Delayed loading means that the associated data is not loaded from the database until the system needs to use collection properties.

For example, the following Person class holds a collection attribute whose element is of type Address, and the code snippet of the Person class is as follows:

Listing 1. Person.java

Public class Person {/ / identify the name property of private Integer id; / / Person private String name; / retain the age property of Person private int age; / / use Set to save the collection property private Set addresses = new HashSet (); / / the setter and getter methods of each property are omitted below.}

To enable Hibernate to manage the collection properties of the persistent class, the program provides the following mapping file for the persistent class:

Listing 2. Person.hbm.xml

As you can see from the code in the mapping file above, the Address class in the collection properties of Person is just a normal POJO. The Address class contains two attributes, detail and zip. Because the code for the Address class is very simple, the code for that class is no longer given here.

The code in the element in the mapping file above specifies lazy= "true" (for elements, lazy= "true" is the default), which specifies that Hibernate delays loading the Address object in the collection properties.

For example, load a Person entity with an ID of 1 through the following code:

Session session = sf.getCurrentSession (); Transaction tx = session.beginTransaction (); Person p = (Person) session.get (Person.class, 1); / / System.out.println (p.getName ())

The above code just needs to access the Person entity with ID 1 and does not want to access the Address object associated with the Person entity. There are two situations at this time:

If there is no delay in loading, Hibernate grabs its associated Address object as soon as the data record corresponding to the Person entity is loaded.

If deferred loading is used, Hibernate loads only the data records corresponding to the Person entity.

Obviously, the second approach reduces interaction with the database and avoids the memory overhead of loading Address entities-- which is why Hibernate enables delayed loading by default.

The question now is, how exactly does deferred loading work? When Hibernate loads a Person entity, what is the value of the addresses attribute of the Person entity?

To solve this problem, we set a breakpoint at the code, Debug in Eclipse, and you can see that the Console window of Eclipse has the output shown in figure 1:

Figure 1. Delay loading Console output of collection properties

As you can see from the output in figure 1, Hibernate only grabs data from the data table corresponding to the Person entity, but not from the data table corresponding to the Address object, which is called deferred loading.

So what is the addresses attribute of the Person entity? At this point, you can see the result shown in figure 2 from the Variables window of Eclipse:

Figure 2. Delayed loading of collection property values

As you can see from the box in figure 2, this addresses property is not a familiar implementation class such as HashSet, TreeSet, but a PersistentSet implementation class, which is an implementation class provided by Hibernate for the Set interface.

The PersistentSet collection object does not really grab the data from the underlying data table, so it is naturally impossible to really initialize the Address object in the collection. However, there is a session attribute in the PersistentSet collection, and this session attribute is Hibernate Session. When the program needs to access the PersistentSet collection element, PersistentSet will use this session attribute to grab the corresponding data record of the actual Address object.

So which data records are crawled by Address entities? This is not difficult for PersistentSet, because there is also an owner attribute in the PersistentSet collection, which indicates the Person entity to which the Address object belongs. Hibernate will look up the Address corresponding data table and refer to the data of the Person entity.

For example, we click the addresses line in the window shown in figure 2, which tells Eclipse to debug and output the addresses property, which is to access the addresses property. At this point, you can see the output of the following SQL statement in the Console window of Eclipse:

Select addresses0_.person_id as person1_0_0_, addresses0_.detail as detail0_, addresses0_.zip as zip0_ from person_address addresses0_ where addresses0_.person_id=?

This is the SQL statement in which the PersistentSet collection grabs a specific Address record according to the owner attribute. You can see the output shown in figure 3 from the Variables window of Eclipse:

Figure 3. Loaded collection property values

As you can see from figure 3, the addresses property has been initialized and the collection contains two Address objects, which are the two Address objects associated with the Person entity.

As you can see from the above, the key to Hibernate's delayed loading of Set attributes lies in the PersistentSet implementation class. During delayed loading, no elements are held in the initial PersistentSet collection. But the PersistentSet holds a Hibernate Session that ensures that the data record is loaded "immediately" and the collection elements are loaded when the program needs to access the collection.

Similar to PersistentSet implementation classes, Hibernate also provides implementation classes such as PersistentList, PersistentMap, PersistentSortedMap, PersistentSortedSet, and so on, and their functions are roughly similar to those of PersistentSet.

Readers who are familiar with Hibernate collection properties should remember that Hibernate requires that collection properties can only be declared with interfaces such as Set, List, Map, SortedSet, SortedMap, but cannot be implemented with HashSet, ArrayList, HashMap, TreeSet, TreeMap, etc. The reason is that Hibernate needs to delay loading collection properties, while Hibernate's deferred loading depends on PersistentSet, PersistentList, PersistentMap, PersistentSortedMap, PersistentSortedSet-that is, Hibernate needs to use its own collection implementation classes to complete deferred loading. Therefore, it requires developers to declare collection properties using collection interfaces rather than collection implementation classes.

Hibernate defaults to deferred loading of collection properties, and in some special cases, set the lazy= "false" attribute for elements such as, and so on to cancel deferred loading.

The above is the whole content of how to understand the delayed loading of Hibernae. For more information about how to understand the delayed loading of Hibernae, you can search the previous articles or browse the following articles to learn! I believe the editor will add more knowledge to you. I hope you can support it!

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.