Hibernate（十）

1.批处理

 //批处理 ：批量处理
     //批量插入数据
     @Test
     public void addData(){
         Random random=new Random();
         for(int i=1;i<=100000000;i++){
             Teacher teacher=new Teacher();
             teacher.setTname(randomName());
             //teacher : 持久化状态，持久化状态的对象是放在Session的一级缓存中,因为一级缓存是放在内存中.(1亿对象存放在内存中)
             session.save(teacher);
             // 当一级缓存中的对象达到一定数量，那就把一级缓存中的对象同步到底层的数据库，再清空一级缓存，释放内存
             if(i%100==0){
                 //把一级缓存中的对象同步到底层的数据库.把session当中的数据刷到数据库，真正的保存
                 session.flush();
                 //清空一级缓存，释放内存
                 session.clear();
                 //如果写上边两句有问题，就加上下边两句
                 transaction.commit();
                 transaction = session.beginTransaction();
             }
         }
     }

     //批量修改
     @Test
     public void test6(){
         for(int i=1;i<100000000;i++){
             Teacher teacher = (Teacher) session.get(Teacher.class, i);
             teacher.setTname(randomName());
             session.update(teacher);
             if(i%100==0){
                 session.flush();
                 session.clear();
                 transaction.commit();
                 transaction=session.beginTransaction();
             }
         }
     }

     //批量删除
     @Test
     public void test7(){
         for(int i=1;i<100000000;i++){
             Teacher teacher = (Teacher) session.get(Teacher.class, i);
             session.delete(teacher);
             if(i%100==0){
                 session.flush();
                 session.clear();
                 transaction.commit();
                 transaction=session.beginTransaction();
             }
         }
     }

2.一级缓存Session

缓存的是对象
跟Session相关(存放在内存中).
默认是开启的.
作用：提高CUD操作的性能.
操作一级缓存的方法：
boolean contains(Object object)
判断Session的一级缓存中是否包含一个对象，包含的话这个对象就是持久化状态。
void evict(Object object)
从Session的一级缓存中逐出一个对象.(该对象就不是持久化状态的对象).
void flush()
将Session的一级缓存中的对象，同步到底层数据库表中.(立即同步)
void clear()
清空Session的一级缓存，所有的持久化状态的对象都清空。(释放内存)
void close()
关闭Session，先调用flush()，再调用clear().

     @Test
     public void test8(){
         //list与iterate的区别

         //1.list不读取缓存，但是查询结果放入缓存
         Query query = session.createQuery("select t from Teacher t where t.tid<?");
         List list = query.setParameter(0, 100).list();
         System.out.println("========================");
         //2.iterate 读取缓存
         Query query2 = session.createQuery("select t from Teacher t where t.tid<?");
         query2.setParameter(0, 100);
         Iterator iterator = query2.iterate();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
         }
         System.out.println("========================");
         Iterator iterator1 = query2.iterate();
         while(iterator1.hasNext()){
             System.out.println(iterator1.next());
         }
         //3.get/load 都会查询缓存
         Teacher teacher = (Teacher)session.get(Teacher.class, 100);
         System.out.println(teacher.getTid()+teacher.getTname());
         System.out.println("========================");
         Teacher teacher1 = (Teacher)session.get(Teacher.class, 100);
         System.out.println(teacher1.getTid()+teacher1.getTname());
         System.out.println("========================");
         Teacher teacher2 = (Teacher)session.load(Teacher.class, 100);
         System.out.println(teacher2.getTid()+teacher2.getTname());
         System.out.println("========================");
         Teacher teacher3 = (Teacher)session.load(Teacher.class, 100);
         System.out.println(teacher3.getTid()+teacher3.getTname());
     }

3.二级缓存ehcache

缓存的是对象
跟SessionFactory相关，因为SessionFactory存活的时间长。
默认是关闭的.
作用：提高查询效率.
二级缓存中的对象存放到哪里，这个需要配置.
一般会配置内存中存放一些对象，超出了内存中放存的对象个数，就写入磁盘.
ehcache.xml (配置二级缓存对象存放的配置文件).

A.导包

B.开启二级缓存

hibernate.cfg.xml配置文件配置信息：

  <!-- 配置开启二级缓存 -->
  <property name="hibernate.cache.use_second_level_cache">true</property>
  <!-- 配置二级缓存的提供商 -->
  <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
    

C.从官方project示例中拷贝一个ehcache.xml文件到src目录底下

<ehcache>
    <!-- diskStore: 配置二级缓存中的对象磁盘存储目录   -->
    <diskStore path="C:\\ehcache"/>
     <!-- 配置默认缓存区：
         maxElementsInMemory : 配置二级缓存中的对象在内存中存放的最大数量.
         eternal : 二级缓存中的对象是否永久有效。true: 永久有效、false: 不是永久有效.
         timeToIdleSeconds :  配置二级缓存中的对象空闲的有效时间 120秒.
         timeToLiveSeconds :  配置二级缓存中的对象存活的有效时间 120秒.
         overflowToDisk : 配置二级缓存中的对象超出了内存中存放的最大数量，就写入磁盘.
      -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <!-- 配置命名的缓存区 -->
    <cache name="myCache"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
</ehcache>

D.配置哪些持久化类用二级缓存

方式一：在hibernate.cfg.xml配置

        <!-- 配置持久化类用二级缓存 -->
        <!-- region 不写就指定用ehcache.xml中的defaultCache,写了myCache就使用myCache名称的  -->
        <class-cache usage="read-write" class="com.rong.entity.sql.Teacher" region="myCache"/>

方式二：在持久化类上

 package com.rong.entity.sql;

 import java.util.HashSet;
 import java.util.Set;

 import javax.persistence.Entity;
 import javax.persistence.FetchType;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.OneToMany;

 import org.hibernate.annotations.Cache;
 import org.hibernate.annotations.CacheConcurrencyStrategy;

 @Entity
 @Cache(usage=CacheConcurrencyStrategy.READ_WRITE,region="myCache")
 public class Teacher {
     @Id
     @GeneratedValue(strategy=GenerationType.AUTO)
     private int tid;
     private String tname;
     @OneToMany(targetEntity=Student.class,fetch=FetchType.LAZY,mappedBy="teacher")
     private Set<Student> students=new HashSet<Student>();
     public int getTid() {
         return tid;
     }
     public void setTid(int tid) {
         this.tid = tid;
     }
     public String getTname() {
         return tname;
     }
     public void setTname(String tname) {
         this.tname = tname;
     }
     public Set<Student> getStudents() {
         return students;
     }
     public void setStudents(Set<Student> students) {
         this.students = students;
     }
 }

E.代码查询

     public static void main(String[] args) {
         Configuration config = new Configuration().configure();
         ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(config.getProperties())
                 .build();
         SessionFactory factory = config.buildSessionFactory(serviceRegistry);
         // 第一个session
         Session session = factory.openSession();
         Transaction transaction = session.beginTransaction();

         Object object = session.get(Teacher.class, 1);
         System.out.println(object);

         Object object2 = session.get(Teacher.class, 2);
         System.out.println(object2);

         transaction.commit();
         session.close();

         // 第二个session
         Session session1 = factory.openSession();
         Transaction transaction1 = session1.beginTransaction();

         Object object1 = session1.get(Teacher.class, 1);
         System.out.println(object1);

         transaction1.commit();
         session1.close();

         //看效果，休眠60秒
         try {
             Thread.sleep(1000*60);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         factory.close();
     }

生成缓存文件，但factory.close()执行后会删除该文件！！！

缓存操作

     public static void main(String[] args) {
         Configuration config = new Configuration().configure();
         ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(config.getProperties())
                 .build();
         SessionFactory factory = config.buildSessionFactory(serviceRegistry);
         // 第一个session
         Session session = factory.openSession();
         Transaction transaction = session.beginTransaction();

         Object object = session.get(Teacher.class, 1);
         System.out.println(object);

         Object object2 = session.get(Teacher.class, 2);
         System.out.println(object2);

         transaction.commit();
         session.close();

         // 第二个session
         Session session1 = factory.openSession();
         Transaction transaction1 = session1.beginTransaction();

         Object object1 = session1.get(Teacher.class, 1);
         System.out.println(object1);

         transaction1.commit();
         session1.close();

         //获取缓存对象
         Cache cache = factory.getCache();
         //清空二级缓存中所有对象
 //        cache.evictAllRegions();
         //从二级缓存中踢出指定的对象
 //        cache.evictEntity(Teacher.class, 1);
 //        cache.evictEntity("com.rong.entity.sql.Teacher", 1);
         //从二级缓存中踢出指定类型所有的对象
 //        cache.evictEntityRegion(Teacher.class);
 //        cache.evictEntityRegion("com.rong.entity.sql.Teacher");
         //判断二级缓存中在是否包含一个对象
         boolean s1 = cache.containsEntity(Student.class, 1);
         boolean s2 = cache.containsEntity("com.rong.entity.sql.Student", 1);
         System.out.println(s1);
         System.out.println(s2);

         boolean t1 = cache.containsEntity(Teacher.class, 1);
         boolean t2 = cache.containsEntity("com.rong.entity.sql.Teacher", 1);
         System.out.println(t1);
         System.out.println(t2);

         factory.close();
     }

获取统计信息

　　1.hibernate.cfg.xml配置

<!-- 配置生成二级缓存的统计信息 -->
<property name="hibernate.generate_statistics">true</property>
<!-- 让Hibernate4用更友好的方式格式化统计信息 -->
<property name="hibernate.cache.use_structured_entries">true</property>

　　2.代码

     public static void main(String[] args) {
         Configuration config = new Configuration().configure();
         ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(config.getProperties())
                 .build();
         SessionFactory factory = config.buildSessionFactory(serviceRegistry);
         // 第一个session
         Session session = factory.openSession();
         Transaction transaction = session.beginTransaction();

         Object object = session.get(Teacher.class, 1);
         System.out.println(object);

         Object object2 = session.get(Teacher.class, 2);
         System.out.println(object2);

         transaction.commit();
         session.close();

         // 第二个session
         Session session1 = factory.openSession();
         Transaction transaction1 = session1.beginTransaction();

         Object object1 = session1.get(Teacher.class, 1);
         System.out.println(object1);

         transaction1.commit();
         session1.close();

         //获取缓存对象
         Cache cache = factory.getCache();
         //清空二级缓存中所有对象
 //        cache.evictAllRegions();
         //从二级缓存中踢出指定的对象
 //        cache.evictEntity(Teacher.class, 1);
 //        cache.evictEntity("com.rong.entity.sql.Teacher", 1);
         //从二级缓存中踢出指定类型所有的对象
 //        cache.evictEntityRegion(Teacher.class);
 //        cache.evictEntityRegion("com.rong.entity.sql.Teacher");
         //判断二级缓存中在是否包含一个对象
         boolean s1 = cache.containsEntity(Student.class, 1);
         boolean s2 = cache.containsEntity("com.rong.entity.sql.Student", 1);
         System.out.println(s1);
         System.out.println(s2);

         boolean t1 = cache.containsEntity(Teacher.class, 1);
         boolean t2 = cache.containsEntity("com.rong.entity.sql.Teacher", 1);
         System.out.println(t1);
         System.out.println(t2);

         //获取统计信息
         Statistics statistics = factory.getStatistics();
         //命中的数量
         long secondLevelCacheHitCount = statistics.getSecondLevelCacheHitCount();
         System.out.println(secondLevelCacheHitCount);//1
         //错失的数量
         long secondLevelCacheMissCount = statistics.getSecondLevelCacheMissCount();
         System.out.println(secondLevelCacheMissCount);//2
         //获取老师的二级缓存的统计信息
         SecondLevelCacheStatistics scs = statistics.getSecondLevelCacheStatistics("com.rong.entity.sql.Teacher");
         System.out.println(scs.getEntries());

         factory.close();
     }

代码查询语句

　　1.注意配置

<!-- 配置开启查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>

把查询的结果放入缓存

 List<Student> students = session.createQuery("select s from Student s join fetch s.teacher where s.age > ?")
 .setParameter(0, 30)
 .setCacheable(true) // 设置缓存查询语句
 .list();

 List<Student> students = session.createQuery("select s from Student s join fetch s.teacher where s.age > ?")
 .setParameter(0, 20)
 .setCacheable(true) // 设置缓存查询语句
 .list();

4.Session线程安全问题

如果是Hibernate3.1之前版本，它提供了HibernateUtil工具类可以获取当前线程相关的Session.
如果是Hibernate3.1之后版本，它提供了可配置的方式，让我们把Session配置成线程相关的Session.

A.在hibernate.cfg.xml中配置

<property name="hibernate.current_session_context_class">thread</property>

B.代码

     public static void main(String[] args) {
         Configuration config = new Configuration().configure();
         ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(config.getProperties())
                 .build();
         SessionFactory factory = config.buildSessionFactory(serviceRegistry);
         // 第一个session
         Session session = factory.getCurrentSession();
         Transaction transaction = session.beginTransaction();

         Object object = session.get(Teacher.class, 1);
         System.out.println(object);

         Object object2 = session.get(Teacher.class, 2);
         System.out.println(object2);

         transaction.commit();
         //session.close();自动关闭，不用手动关闭
         System.out.println(session);

         // 第二个session
         Session session1 = factory.getCurrentSession();
         Transaction transaction1 = session1.beginTransaction();

         Object object1 = session1.get(Teacher.class, 1);
         System.out.println(object1);

         transaction1.commit();
         //session1.close();自动关闭，不用手动关闭
         System.out.println(session1);

         factory.close();
     }