Hibernate学习笔记（六）：概念（二）

• 一级缓存

Hibernate默认是开启一级缓存的，一级缓存存放在Session上
测试用栗TestHibernation

 System.out.println("log1");
        Category c1 = (Category)s.get(Category.class, 1);
        System.out.println("log2");
        Category c2= (Category)s.get(Category.class, 1);
        System.out.println("log3"); 

第一次获取id=1对象的时候，Session中没有对应缓存对象，所以在"log1"后出现sql查询语句
第二次获取id=1对象的时候，Session中有对应的缓存对象，所以在"log2"后不会出现sql查询语句

• 二级缓存

二级缓存是在SessionFactory上
测试用栗TestHibernation

package com.how2java.test;
   
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
  
import com.how2java.pojo.Category;
   
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
        Session s = sf.openSession();
        s.beginTransaction();
         
        Category c1 = (Category)s.get(Category.class, 1);
        System.out.println("log1");
        Category c2= (Category)s.get(Category.class, 1);
        System.out.println("log2");
        s.getTransaction().commit();
        s.close();
        Session s2 = sf.openSession();
        s2.beginTransaction();
        Category c3 = (Category)s2.get(Category.class, 1);
        System.out.println("log3");
  
        s2.getTransaction().commit();
        s2.close();
        sf.close();
    }
}

在Session s中，因为有一级缓存，所以只进行一次数据库查询
但在Session s2中，因为是另一个Session，所以又进行了一次SQL查询

1.在hibernate.cfg.xml中增加二级缓存配置
Hibernate本身不提供二级缓存，都是使用第三方的二级缓存插件，这里使用EhCache提供的二级缓存

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>
 
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/test?characterEncoding=GBK</property>
        <property name="connection.username">root</property>
        <property name="connection.password">admin</property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
         
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
          
        <mapping resource="com/how2java/pojo/Product.hbm.xml" />
        <mapping resource="com/how2java/pojo/Category.hbm.xml" />
        <mapping resource="com/how2java/pojo/User.hbm.xml" />
         
    </session-factory>
 
</hibernate-configuration>

2.在src目录下建立ehcache.xml用于EhCache的缓存配置

<ehcache>
    <diskStore path="java.io.tmpdir"/>
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
</ehcache>

3.修改Category.hbm.xml
对要进行二级缓存的实体类进行配置，增加<cache usage="read-only" />
 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.how2java.pojo">
    <class name="Category" table="category_">
        <cache usage="read-only" />
        <id name="id" column="id">
            <generator class="native">
            </generator>
        </id>
        <property name="name" />
 
        <set name="products" lazy="true">
            <key column="cid" not-null="false" />
            <one-to-many class="Product" />
        </set>
                 
    </class>
     
</hibernate-mapping>

4.运行TestHibernate

可以看到，使用不同的Session获取id=1的Category,只会访问一次数据库
因为c3在获取时虽然没有从第二个Session中拿到缓存，但是从SessionFactory中拿到了Category缓存对象

• 分页

使用Criteria进行分页查询 
测试用栗TestHibernation

package com.how2java.test;
  
import java.util.List;
 
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
 
import com.how2java.pojo.Product;
  
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
  
        String name = "iphone";
          
        Criteria c= s.createCriteria(Product.class);
        c.add(Restrictions.like("name", "%"+name+"%"));
        c.setFirstResult(2);//表示从第3条数据开始
        c.setMaxResults(5);//表示一共查询5条数据
         
        List<Product> ps = c.list();
        for (Product p : ps) {
            System.out.println(p.getName());
             
        }
          
        s.getTransaction().commit();
        s.close();
        sf.close();
    }
}

• 两种获取方式

通过id获取对象的方式有两种，分别是get和load 
他们的区别分别在于 
1. 延迟加载
get方式是非延迟加载，无论后面的代码是否会访问到属性，马上执行sql语句
load方式是延迟加载，只有属性被访问的时候才会调用sql语句
2. 对于id不存在的时候的处理
栗如通过id=500去获取对象 
get方式会返回null 
load方式会抛出异常

• 两种Session方式

Hibernate有两种方式获得Session,分别是： 
openSession()和getCurrentSession() 
他们的区别在于 
1. 获取的是否是同一个session对象 
openSession()每次都会得到一个新的Session对象 
getCurrentSession()在同一个线程中，每次都是获取相同的Session对象，但是在不同的线程中获取的是不同的Session对象 
2. 事务(Transaction)提交的必要性 
openSession()只有在增加，删除，修改的时候需要事务，查询时不需要的 
getCurrentSession()是所有操作都必须放在事务中进行，并且提交事务后，Session就自动关闭，不能够再进行关闭 

        s1.beginTransaction();
        s1.get(Product.class, 5);
        s1.getTransaction().commit();