1. What is ORM?

Object-Relational Mapping (ORM for short) is a technology to solve the problem of mismatch between the object-oriented model of the program and the relational model of the database;

Simple In other words, ORM automatically persists objects in the program to a relational database or converts rows in a relational database table by using metadata that describes the mapping between objects and databases (XML or annotations can be used in Java). into a Java object, which essentially converts data from one form to another.

2. Is SessionFactory in Hibernate thread-safe? Is Session thread-safe (can two threads share the same Session)?

SessionFactory corresponds to a data storage concept of Hibernate. It is thread-safe and can be accessed concurrently by multiple threads. SessionFactory is generally only built at startup. For applications, it is best to encapsulate SessionFactory through singleton mode for easy access.

(Learning video recommendation: java video tutorial)

Session is a lightweight non-thread-safe object (session cannot be shared between threads), which represents the connection with the database A unit of work that interacts with. Session is created by SessionFactory and it will be closed after the task is completed. Session is the main interface provided by the persistence layer service.

Session will delay obtaining the database connection (that is, it will only obtain it when needed). In order to avoid creating too many sessions, you can use ThreadLocal to bind the session to the current thread, so that the same thread always gets the same session. The getCurrentSession() method of SessionFactory in Hibernate 3 can do this.

3. What do the save(), update(), merge(), lock(), saveOrUpdate() and persist() methods of Session do? What's the difference?

Hibernate objects have three states: transient, persistent and detached.

Transient instances can become persistent by calling the save(), persist() or saveOrUpdate() methods;

Free instances can be made persistent by calling update(), saveOrUpdate(), lock() or replicate() becomes persistent. save() and persist() will trigger SQL INSERT statements, and update() or merge() will trigger UPDATE statements.

The difference between save() and update() is that one turns a transient object into a persistent state, and the other turns a free object into a persistent state. The merge() method can complete the functions of the save() and update() methods. Its intention is to merge the new state into the existing persistent object or create a new persistent object.

For the persist() method, follow the instructions in the official documentation:

1. The persist() method persists a transient instance, but does not guarantee that the identifier will be filled in immediately. In a persistent instance, filling in the identifier may be postponed until the flush time;

2. The persist() method ensures that when it is called outside a transaction, it will not trigger an INSERT statement. When needed When encapsulating a long session process, the persist() method is necessary;

(Recommended tutorial: java quick start)

3. save() method Item 2 is not guaranteed, it returns the identifier, so it will execute the INSERT statement immediately, whether inside or outside the transaction. As for the difference between the lock() method and the update() method, the update() method turns an object in a detached state that has been changed into a persistent state; the lock() method turns an object in a detached state that has not changed. into a persistent state.

4. Describe the process of loading entity objects by Session

1. Before calling the database query function, Session will first use the entity type and primary key in the first-level cache. Search, if the first-level cache search hits and the data status is legal, it will return directly;

2. If the first-level cache does not hit, then the Session will be recorded in the current NonExists (equivalent to a query blacklist, if there is Repeated invalid queries can be quickly judged, thus improving performance). If the same query condition exists in NonExists, null will be returned;

3. If the first-level cache query fails to query the second-level cache, If the second-level cache hits, it will be returned directly;

4. If the previous queries have not hit, the SQL statement will be issued. If the query does not find the corresponding record, the query will be added to the NonExists of the Session to record it, and Return null;

5. Obtain the ResultSet according to the mapping configuration and SQL statement, and create the corresponding entity object;

6. Incorporate the object into the management of Session (level one cache);

7. If there is a corresponding interceptor, execute the onLoad method of the interceptor;

8. If it is enabled and set to use the second-level cache, the data object will be included in the second-level cache;

9. Return the data object.

5. What is the difference between using # and $ to write placeholders in MyBatis?

# Treat the incoming data as a string, and automatically add quotation marks to the incoming data;

$ Directly display and generate the incoming data in SQL.

Note: Using $ placeholder may lead to SQL injection attacks. Do not use $ where # can be used. You should use $ instead of # when writing the order by clause.

Related tutorial recommendations: java interview questions

The above is the detailed content of Java persistence layer interview questions (1). For more information, please follow other related articles on the PHP Chinese website!