Java persistence layer interview questions

What is ORM? (Recommended Learning: Java Interview Question )

Object-Relational Mapping (ORM) is an object-oriented model of the object-oriented model to solve the program. Technology for mismatching problems;

Simply put, ORM automatically persists objects in the program by using metadata that describes the mapping between objects and databases (XML or annotations can be used in Java) into a relational database or convert rows in a relational database table into Java objects, which is essentially converting data from one form to another.

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.

Session is a lightweight non-thread-safe object (session cannot be shared between threads), which represents a unit of work that interacts with the database. 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.

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 identification. The identifier is immediately filled into the persistent instance, and the filling in of the identifier may be delayed until the flush time;

2. The persist() method guarantees that it will not be triggered when it is called outside a transaction. When an INSERT statement needs to encapsulate a long session process, the persist() method is necessary;

3. The save() method does not guarantee item 2. It must return an identifier, so it The INSERT statement will be executed immediately, whether inside or outside the transaction.

As for the difference between the lock() method and the update() method, the update() method changes an object that has been changed in a detached state into a persistent state; the lock() method changes an object that has not changed An object in a detached state becomes a persistent state.

Explains the process of loading entity objects by Session.

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

2. If there is no hit in the first-level cache, the Session will then search in the current NonExists record (equivalent to a query blacklist. If repeated invalid queries appear, a judgment can be made quickly to improve performance). If the same query condition exists in NonExists, null will be returned;

3. If the first-level cache query fails, query the second-level cache. If the second-level cache hits, return directly;

4. If before If none of the queries are hit, an SQL statement will be issued. If the corresponding record is not found in the query, the query will be added to the NonExists of the Session to be recorded, and null will be returned;

5. Obtained according to the mapping configuration and SQL statement ResultSet, 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 of the interceptor Method;

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.

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

$ will The entered data is directly displayed and generated 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.

Explain the role of namespace in MyBatis.

In large projects, there may be a large number of SQL statements. At this time, it is not easy to give each SQL statement a unique identification (ID).

In order to solve this problem, in MyBatis, you can create a unique namespace for each mapping file, so that each SQL statement defined in this mapping file becomes defined in this namespace. an ID.

As long as we can ensure that this ID is unique in each namespace, even if the statement IDs in different mapping files are the same, conflicts will no longer occur.

What does dynamic SQL in MyBatis mean?

For some complex queries, we may specify multiple query conditions, but these conditions may or may not exist. If we do not use the persistence layer framework, we may need to assemble the SQL statements ourselves, but MyBatis Provides dynamic SQL functionality to solve this problem. The elements used to implement dynamic SQL in MyBatis mainly include:

- if    - choose / when / otherwise    - trim    - where    - set     - foreach

Usage examples:

<select id="foo" parameterType="Blog" resultType="Blog">        
select * from t_blog where 1 = 1
<if test="title != null">            
   and title = #{title}
</if>
<if test="content != null">            
   and content = #{content}
</if>
<if test="owner != null">            
   and owner = #{owner}
</if>
</select>

What are the shortcomings of JDBC programming and how MyBatis solves them These questions?

1. JDBC: Frequent creation and release of database links causes a waste of system resources and affects system performance. This problem can be solved by using a database connection pool.

MyBatis: Configure the data link pool in SqlMapConfig.xml and use the connection pool to manage database links.

2. JDBC: Sql statements are written in the code, making the code difficult to maintain. The actual application of sql may change greatly, and sql changes require changes to the java code.

MyBatis: Configure the Sql statement in the XXXXmapper.xml file and separate it from the java code.

3. JDBC: It is troublesome to pass parameters to the sql statement, because the where condition of the sql statement is not necessarily certain, it may be more or less, and the placeholders need to correspond to the parameters one-to-one.

MyBatis: Mybatis automatically maps java objects to sql statements.

4, JDBC: It is troublesome to parse the result set. SQL changes lead to changes in the parsing code, and it needs to be traversed before parsing. It would be more convenient to parse the database records into pojo objects.

MyBatis: Mybatis automatically maps sql execution results to java objects.

What are the differences between MyBatis and Hibernate?

1. Mybatis is different from hibernate. It is not entirely an ORM framework because MyBatis requires programmers to write Sql statements themselves. However, mybatis can flexibly configure the sql statements to be run through XML or annotations. And map java objects and sql statements to generate the final executed sql, and finally map the results of sql execution to generate java objects.

2. Mybatis has a low learning threshold and is easy to learn. Programmers can directly write original SQL, which can strictly control SQL execution performance. It is highly flexible and is very suitable for software development that does not have high requirements for relational data models, such as the Internet. Software, enterprise operation software, etc. Because the needs of this type of software change frequently, once the needs change, the results must be output quickly.

But the premise of flexibility is that mybatis cannot be database independent. If you need to implement software that supports multiple databases, you need to customize multiple sets of sql mapping files, which is a heavy workload.

3. Hibernate has strong object/relational mapping capabilities and good database independence. For software with high requirements on relational models (such as customized software with fixed requirements), if you use hibernate to develop it, you can save a lot of code and improve efficiency.

However, the disadvantage of Hibernate is that the learning threshold is high, and the threshold for mastery is even higher. Moreover, how to design O/R mapping, how to trade off between performance and object model, and how to use Hibernate well requires strong experience. and ability.​ ​ ​

In short, as long as a software architecture with good maintainability and scalability can be made according to the needs of users in a limited resource environment, it is a good architecture, so the best framework is only suitable.

(You can also combine it with your own understanding here, don’t hold back)

Briefly talk about the first-level cache and second-level cache of MyBatis?

Mybatis first queries the result set in the cache. If there is no result set, it queries the database. If there is, it retrieves the result set from the cache and returns it without going to the database. Mybatis internal storage cache uses a HashMap, and the key is hashCode sqlId Sql statement. value is the java object generated by mapping from the query.

Mybatis's second-level cache is the query cache. Its scope is the namespace of a mapper, that is, querying SQL in the same namespace can obtain data from the cache. The second-level cache can span SqlSession.

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