Java high-frequency basic interview questions——(8)

91, what is ORM?

(Recommendations for more related interview questions: java interview questions and answers)

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

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

92, 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.

93. 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.

instances of the instant state can be changed by calling Save (), Persist (), or SaveorUpdate () to become durable; 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 it 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 guarantees that it will not trigger an INSERT statement when it is called outside a transaction. When encapsulating a long session process, the persist() method is necessary;

3. The save() method does not guarantee item 2. It returns an identifier, so it will immediately execute the INSERT statement. Whether inside or outside the affairs. 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.

94, explains the process of loading entity objects by Session.
  1. Before calling the database query function, Session will first search through 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 a There is no hit in the level cache. Next, the Session will search in the current NonExists record (equivalent to a query blacklist. If repeated invalid queries appear, a quick judgment can be made to improve performance). If the same query conditions exist in NonExists, Then return null;
3. If the first-level cache query fails, query the second-level cache. If the second-level cache hits, return directly;
4. If the previous query fails, issue an SQL statement. If the query does not find the For the corresponding record, add the query to the NonExists of the Session and 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 Session (Level 1 cache) management;
7. If there is a corresponding interceptor, execute the onLoad method of the interceptor;
8. If it is turned on and set to use the second level cache, the data object will be included in the second level cache. Level cache;
9. Return data object.

95, what is the difference between using # and $ to write placeholders in MyBatis?
#As a string, the passing data will be automatically added to the passing data;

$ will directly display the transmitted 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.

96, 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 an ID defined in this namespace. 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.

(Video tutorial recommendation: java course)

97. 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 the function of dynamic SQL. to solve this problem. The elements used to implement dynamic SQL in MyBatis mainly include:
- if - choose / when / otherwise - trim - where - set - foreach

Usage example:

< ;select id="foo" parameterType="Blog" resultType="Blog">        
  select * from t_blog where 1 = 1                                                                                                                                                                                                                                                                                                                                                                                                                    

98, what are the shortcomings of JDBC programming, and how does MyBatis solve these problems?

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.

99, 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 use java The object and SQL statement are mapped to generate the final executed SQL, and finally the result of the SQL execution is mapped to generate a Java object.
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 and high flexibility. It is very suitable for software development that does not have high requirements for relational data models, such as Internet software and enterprises. Operation software, etc., because the requirements of this type of software change frequently, once the requirements change, the results must be output quickly. However, 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 for 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 threshold for learning is high, and the threshold for mastery is even higher. Moreover, how to design O/R mapping, how to weigh the performance and object model, and how to use Hibernate well requires strong experience and ability.
In short, as long as the user's needs can be maintained in a limited resource environment, as long as the maintenance and good scalability of the software architecture can be a good architecture, so the framework is only the best.

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

100, briefly talk about MyBatis’s first-level cache and second-level cache?

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 the result set 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.

Recommended related tutorials: java introductory tutorial

The above is the detailed content of Java high-frequency basic interview questions——(8). For more information, please follow other related articles on the PHP Chinese website!