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();
    }