Java Hibernate 프레임워크의 캐싱 및 2차 캐시에 대한 자세한 설명

캐싱

오늘은 Hibernate에서 엔터티 상태와 Hibernate 캐시에 대해 이야기하겠습니다.
1) 먼저 엔터티 상태를 살펴보겠습니다.
엔터티 상태에는 일시적, 지속적, 분리의 세 가지 주요 유형이 있습니다.
아마 영어로 읽으시면 이해가 되실 거에요.
일시적: 데이터가 아직 데이터베이스의 데이터와 일치하지 않음을 의미합니다.
지속성: 데이터가 데이터베이스의 데이터와 일치하며 이에 대한 모든 변경 사항이 데이터베이스에 반영됨을 의미합니다.
분리됨: 데이터가 데이터베이스의 데이터와 일치하지만 세션이 닫혀 있기 때문에 수정 사항이 데이터베이스의 레코드에 영향을 미치지 않음을 의미합니다.
직접 코딩해 보겠습니다.

Transaction tx = session.beginTransaction(); 
User user = new User(); 
user.setName("shun"); 
//这里的user还未保存到数据库，数据库表中并没有与之对应的记录，它为transient状态 
session.save(user); 
tx.commit(); 
//提交之后user变为persistent状态 
session.close(); 
//由于session关闭，此时的user为detached状态，它的所有修改都不会反映到数据库中。 
      
Session session2 = sessionFactory.openSession(); 
tx = session2.beginTransaction(); 
user.setName("shun123"); 
session2.saveOrUpdate(user); 
tx.commit(); 
//当我们调用了saveOrUpdate之后，user重新变为persistent状态，它的所有修改都会反映到数据库中。 
session2.close();

코드를 보면 먼저 객체 사용자를 정의한 후 저장합니다. 임시 상태이고 데이터베이스에 해당 레코드가 없습니다. 수정 사항을 저장하고 제출하면 사용자는 지속성이 있게 되며 데이터베이스에 해당 기록을 갖게 됩니다. 세션을 닫으면 사용자는 분리되고 saveOrUpdate 및 기타 해당 업데이트 및 추가 메소드를 수동으로 호출하지 않으면 해당 변경 사항이 데이터베이스에 반영되지 않습니다. 그리고 지속 상태에서 일시적 상태로 직접 변경하려면 어떻게 해야 할까요? 직접 삭제하면 삭제 후 해당 개체는 데이터베이스에 해당 레코드가 없으며 일시적인 상태가 됩니다.

Hibernate의 상태 전환은 비교적 간단합니다. 일시적인 상태에서는 데이터베이스에 해당 레코드가 없지만, 영구 및 분리에 해당하는 레코드가 있지만 유일한 차이점은 분리된 후에만 나타납니다. 세션이 닫힌 상태입니다. 그렇다면 임시와 분리의 차이점은 무엇입니까? 데이터베이스 테이블에 해당 레코드가 있는지에 대한 질문이 있습니다.

2) 상태를 읽은 후, Hibernate의 캐시를 살펴보겠습니다.
Hibernate의 캐시는 1차 캐시와 2차 캐시의 두 종류로 나누어집니다.
1차 캐시: 소위 1차 캐시라고도 불리는 것은 내부 캐시이기도 합니다.
2차 캐시: 최대 절전 모드에서는 소위 SessionFactory 캐시가 포함됩니다. 이는 가장 안전한 캐시 방법입니다.
프로그램을 직접 살펴보겠습니다:

public static void main(String[] args) { 
  
  Configuration cfg = new Configuration().configure(); 
  SessionFactory sessionFactory = cfg.buildSessionFactory(); 
  Session session = sessionFactory.openSession(); 
      
  User user = (User)session.load(User.class,new Long(29)); 
  System.out.println(user.getName()); 
      
  User user2 = (User)session.load(User.class,new Long(29)); 
  System.out.println(user2.getName()); 
      
  session.close(); 
}

결과 살펴보기:

Hibernate: select user0_.USER_ID as USER1_0_0_, user0_.USER_NAME as USER2_0_0_, user0_.age as age0_0_ from USER user0_ where user0_.USER_ID=? 
shun123123 
shun123123

예제에서는 load를 두 번 사용했지만 결과에는 SQL 문이 하나만 있습니다. 한 번만 쿼리되었음을 보여줍니다.
왜요? 이것은 최대 절전 모드의 캐시가 작동하는 곳입니다. 첫 번째 쿼리가 완료된 후 최대 절전 모드는 감지된 엔터티를 캐시에 저장하고, 다음 번 쿼리 시 먼저 캐시를 확인하여 해당 ID에 해당하는 엔터티가 있는지 확인합니다. 그렇지 않으면 데이터베이스가 쿼리됩니다.

이제 코드를 다음과 같이 수정합니다.

User user = (User)session.load(User.class,new Long(29)); 
System.out.println(user.getName()); 
      
session.evict(user);//把user从缓存中删掉 
      
User user2 = (User)session.load(User.class,new Long(29)); 
System.out.println(user2.getName()); 
      
session.close();

결과 보기:

Hibernate: select user0_.USER_ID as USER1_0_0_, user0_.USER_NAME as USER2_0_0_, user0_.age as age0_0_ from USER user0_ where user0_.USER_ID=?
shun123123
Hibernate: select user0_.USER_ID as USER1_0_0_, user0_.USER_NAME as USER2_0_0_, user0_.age as age0_0_ from USER user0_ where user0_.USER_ID=?
shun123123

캐시에서 사용자를 삭제한 후 두 번째 쿼리도 데이터베이스에서 직접 수행됩니다. 밖으로.

레벨 2 캐시 토크
엔티티 클래스를 먼저 살펴보겠습니다.

public class User implements Serializable{
  
  public Long id;
  private String name;
  private int age;
    
}

매핑 파일은 생략되어 누구나 작성할 수 있어야 합니다.
최대 절전 모드 구성 파일을 살펴보겠습니다.

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.use_query_cache">true</property>

공급자_클래스에 ehcache 공급자 클래스를 지정했음을 확인하므로 클래스 경로에도 ehcache.xml을 넣어야 합니다.

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
  <diskStore path="java.io.path"/>
  <defaultCache 
    maxElementsInMemory="10000"
    eternal="false"
    timeToIdleSeconds="120"
    timeToLiveSeconds="120"
    overflowToDisk="true"
    />
</ehcache>

계속 다음으로 테스트 메소드를 직접 살펴보겠습니다.

public static void main(String[] args) {
  
  Configuration cfg = new Configuration().configure();
  SessionFactory sessionFactory = cfg.buildSessionFactory();
  Session session = sessionFactory.openSession();
  
  Query query = session.createQuery("from User user where name = 'shun123'");
  Iterator iter = query.iterate();
  while(iter.hasNext()) {
    System.out.println(((User)iter.next()).getName());
  }
    
  session.close();
    
  Session session2 = sessionFactory.openSession();
  Query query2 = session2.createQuery("from User user where name='shun123'");
  Iterator iter2 = query2.iterate();
  while(iter2.hasNext()) {
    System.out.println(((User)iter2.next()).getName());
  }
    
  session2.close();
  
}

실행하고 나면

Hibernate: select user0_.USER_ID as col_0_0_ from USER user0_ where user0_.USER_NAME='shun123'
Hibernate: select user0_.USER_ID as USER1_0_0_, user0_.USER_NAME as USER2_0_0_, user0_.age as age0_0_ from USER user0_ where user0_.USER_ID=?
shun123
Hibernate: select user0_.USER_ID as col_0_0_ from USER user0_ where user0_.USER_NAME='shun123'
shun123

를 볼 수 있습니다. 2번째 질의에서는 2차 캐시 때문에 ID가 검색되지 않는 현상이 발생했습니다.

먼저 테스트 메소드의 코드를 분석해 보겠습니다. 테스트 방법에서는 두 개의 세션을 열고 동일한 쿼리를 수행하기 위해 두 개의 쿼리를 생성했습니다. 그러나 두 개의 세션이 두 번째 수준 캐시와 SessionFactory 수준 캐시인 캐시를 공유할 수 있습니다. 세션이 동일한 SessionFactory에 의해 생성되는 한 두 번째 수준 캐시를 공유하여 데이터베이스와의 상호 작용을 줄일 수 있습니다.
구성 파일의 의미를 살펴보겠습니다.

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.use_query_cache">true</property>

두 번째 수준 캐시를 사용해야 하는 경우 먼저 두 번째 수준을 열려면

<property name="hibernate.cache.use_second_level_cache">true</property>

를 구성해야 합니다.

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

두 번째 수준 캐시의 공급자 클래스를 지정합니다. 일반적인 상황에서 우리 모두는 당분간 다른 클래스를 사용하지 않았으므로 잘 모르겠습니다. 그들에 대해서는 당분간 이야기하지 않겠습니다.
지금의 예시처럼 위의 두 가지만 구성하면 정상적으로 실행되며 2단계 캐시를 사용할 수 있습니다.
그럼 세 번째 문장은 뭘까요?

<property name="hibernate.cache.use_query_cache">true</property>

이 구성은 쿼리할 때 캐시를 사용해야 함을 나타냅니다. 이를 사용해야 하는 경우 미리 query.setCacheable(true) 메서드를 호출하여 활성화해야 합니다.

코드를 함께 살펴보겠습니다(먼저 캐싱을 활성화하지 않음):

public static void main(String[] args) {
  
  Configuration cfg = new Configuration().configure();
  SessionFactory sessionFactory = cfg.buildSessionFactory();
  Session session = sessionFactory.openSession();
  
  Query query = session.createQuery("from User user where name = 'shun123'");
  List list = query.list();
  for (int i = 0; i < list.size(); i++){
    System.out.println(((User)list.get(i)).getName());
  }
    
  session.close();
    
  Session session2 = sessionFactory.openSession();
  Query query2 = session2.createQuery("from User user where name=&#39;shun123&#39;");
  List list2 = query2.list();
  for (int i = 0; i < list2.size(); i++){
    System.out.println(((User)list.get(i)).getName());
  }
    
  session2.close();
  
}

여기서 출력 결과는 다음과 같습니다.

Hibernate: select user0_.USER_ID as USER1_0_, user0_.USER_NAME as USER2_0_, user0_.age as age0_ from USER user0_ where user0_.USER_NAME='shun123'
shun123
Hibernate: select user0_.USER_ID as USER1_0_, user0_.USER_NAME as USER2_0_, user0_.age as age0_ from USER user0_ where user0_.USER_NAME='shun123'
shun123

캐싱을 사용하지 않는 것을 알 수 있습니다. 여기서는 목록을 사용했는데 목록은 캐시에 쓰기만 하고 읽지는 않습니다. 따라서 여기에는 두 가지 쿼리가 있습니다.
그런 다음 수정해 보겠습니다.

public static void main(String[] args) {
  
  Configuration cfg = new Configuration().configure();
  SessionFactory sessionFactory = cfg.buildSessionFactory();
  Session session = sessionFactory.openSession();
  
  Query query = session.createQuery("from User user where name = 'shun123'");
  <span style="background-color: #ffffff;"><span style="color: #ff0000;">query.setCacheable(true);</span></span>
  List list = query.list();
  for (int i = 0; i < list.size(); i++){
    System.out.println(((User)list.get(i)).getName());
  }
    
  session.close();
    
  Session session2 = sessionFactory.openSession();
  Query query2 = session2.createQuery("from User user where name=&#39;shun123&#39;");
  <span style="color: #ff0000;">query2.setCacheable(true);</span>
  List list2 = query2.list();
  for (int i = 0; i < list2.size(); i++){
    System.out.println(((User)list.get(i)).getName());
  }
    
  session2.close();
  
}

看到红色的两句代码，这是我们进行添加的两个开启查询缓存的代码，现在我们看到结果：

Hibernate: select user0_.USER_ID as USER1_0_, user0_.USER_NAME as USER2_0_, user0_.age as age0_ from USER user0_ where user0_.USER_NAME='shun123'
shun123
shun123

只剩一次查询了，为什么呢？就在那两句红色代码处，我们开启了缓存，记住，需要使用两次。把两个query都设成可缓存的才能使用查询缓存。
Criteria也是类似的做法，为免有些童鞋忘记了Criteria怎么写了，我还是放一下代码：

public static void main(String[] args) {
  
  Configuration cfg = new Configuration().configure();
  SessionFactory sessionFactory = cfg.buildSessionFactory();
  Session session = sessionFactory.openSession();
  
  Criteria criteria1 = session.createCriteria(User.class);
  criteria1.setCacheable(true);
  criteria1.add(Restrictions.eq("name","shun123"));
  List list = criteria1.list();
  for (int i = 0; i < list.size(); i++){
    System.out.println(((User)list.get(i)).getName());
  }
    
  session.close();
    
  Session session2 = sessionFactory.openSession();
  Criteria criteria2 = session2.createCriteria(User.class);
  criteria2.setCacheable(true);
  criteria2.add(Restrictions.eq("name","shun123"));
  List list2 = criteria2.list();
  for (int i = 0; i < list2.size(); i++){
    System.out.println(((User)list.get(i)).getName());
  }
    
  session2.close();
  
}

我们看结果：

Hibernate: select this_.USER_ID as USER1_0_0_, this_.USER_NAME as USER2_0_0_, this_.age as age0_0_ from USER this_ where this_.USER_NAME=?
shun123
shun123

更多详解Java的Hibernate框架中的缓存与二级缓存相关文章请关注PHP中文网！