Analysis of the cache mechanism and principle of the Spring ORM framework
Analysis of the cache mechanism and principle of the Spring ORM framework
Overview:
The use of cache in the application can significantly improve performance and reduce frequent access to databases.The Spring ORM framework achieves this goal by providing a cache mechanism.This article will explore the cache mechanism and principles of the Spring ORM framework.We will also provide readers with examples of Java code to better understand this mechanism.
1. Spring ORM framework cache mechanism Introduction:
The Spring ORM framework realizes the interaction with the database through Hibernate or JPA and other technologies.The cache refers to storing data in memory so that it can be quickly retrieved in the data access layer.The Spring ORM framework uses two types of cache: first -level cache and secondary cache.
The first -level cache is a cache area unique to each transaction, also known as the session -level cache.It stores the object retrieved from the database and repeats the same object in the same affairs, and first returns a copy in the cache.If the object is modified in the same affairs, it will be updated to the database before the transaction is submitted.
The secondary cache is a sessionFactory level cache, which can be shared by the entire application.When a request tries to retrieve an object that has been cached from the database, the Spring ORM framework will first check the secondary cache.If the object is in the secondary cache, the data is obtained directly from the cache without having to query the database.
2. Configuration of the Spring ORM framework cache:
In order to use the cache mechanism of the Spring ORM framework, we need to configure related configurations in the Spring configuration file.The following is an example configuration:
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="com.example.model" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
<prop key="hibernate.cache.use_second_level_cache">true</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>
</props>
</property>
</bean>
In the above configuration, we designate the cache to be used, which is EHCACHE.We also turned on the use of secondary cache and query cache.
3. The working principle of the Spring ORM framework cache:
When using the Spring ORM framework for data access, the workflow of the cache mechanism is as follows:
-S when an object is retrieved, the Spring ORM framework will first try to get a copy from the first -level cache.If the object does not exist in the first cache, continue to check the secondary cache.
-If found the object in the secondary cache, return it directly without having to query the database.
-If the object is not found in the secondary cache, the query database is query, and the query results are added to the first -level cache and the secondary cache to prepare for the next use.
-Son, its cache copy will also be updated when a object is modified.Before the transaction is submitted, the object in the cache will synchronize with the object in the database.
4. Example of cache using the Spring ORM framework:
Let's demonstrate the cache mechanism of the Spring ORM framework through a simple Java code example.Suppose we have a physical class called "User" and a data access class called "UserRepository".
Define the user entity class:
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name")
private String name;
// omit other fields and access methods
}
Define the UserRePOSITORY data access class:
@Repository
public class UserRepository {
private final EntityManager entityManager;
public UserRepository(EntityManager entityManager) {
this.entityManager = entityManager;
}
@Transactional(readOnly = true)
public User findById(Long id) {
return entityManager.find(User.class, id);
}
// omit other data access methods
}
In the above example, we use the transaction attributes of the method of specifying the method to specify the method.`FindByid` method is used to retrieve a user object from the database.
Caches the cache through the Spring configuration file:
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
<property name="persistenceUnitName" value="persistenceUnit" />
</bean>
<!-Enabled transaction manager->
<tx:annotation-driven />
<!-Enable cache->
<cache:annotation-driven />
Through the above configuration, we enable the annotation driver on the cache.In this way, when the `FindByid` method is called, the Spring ORM framework will first try to retrieve user objects from the cache.
in conclusion:
The cache mechanism of the Spring ORM framework can significantly improve the performance of the application and reduce the pressure on the database.By using the first -level cache and secondary cache, the Spring ORM framework reduces frequent access to the database.In this article, we introduce the working principle of the Spring ORM framework cache in detail, and provide a simple Java code example to illustrate how to use the cache mechanism of the Spring ORM framework.It is hoped that readers will have a deeper understanding of the cache mechanism of the Spring ORM framework through this article.
