持久层框架--hibernate（2）

一 .持久化对象的oid 映射为数据库表的主键，唯一不重复

当数据库表中的主键为代理主键时，持久化对象的oid 要交给hibernate来维护（避免重复）

当数据库中表的主键为自然主键时，持久化对象的oid 要由程序本身来维护

主键生成策略(生成持久化oid的方式)：
1. increment 带走+1
由hibernate来维护oid的值，
优点：与底层数据库类型无关
缺点：只适用于单线程对数据库的访问

2. identity +1带走
优点：适合多用户访问
缺点：由于+1操作由数据库完成，所以数据库必须支持自增Mysql,sql server,db2

3. sequence
由数据库来维护oid的值
数据库要支持序列 Oracle，db2

4. native
根据底层数据库的能力选择 identity、sequence 或者 hilo 中的一个。
持久化对象的oid类型必须为 long，short 或者 int 类型的，不能使用byte

5. uuid
数据库表中数据量非常大，但不会经常进行查询操作，就可以使用字符串作为表单主键。

6. assigned 手动分配id
适用于自然主键
比如：loginName作为主键


三. 定义持久化对象属性时，如果属性为基本数据类型，最好使用对应的包装类型

int score;//0
Integer score;//null

四. 快照
session的一级缓存 存在快照区域
只有在查询操作时，会产生快照区域
快照区域保存查询对象的原始状态
当session执行flush方法时，会用缓存中的对象和快照中的原始数据进行比较
如果两组数据不同，则自动发送update来更新数据库

数据库中，自己手动创建序列

对应Customer.hbm.xml做的修改：

       <generator class="native">
              <param name="sequence">cus_id_seq</param>
        </generator>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.edu.oid.Customer" table="tab_customer">
        <id name="id" column="id" type="integer">
            <!-- 主键生成策略 
            <generator class="native">
                <param name="sequence">cus_id_seq</param>
            </generator>
            -->
            <generator class="assigned"/>
        </id>
        
        <!-- 配置普通属性 -->
        <property name="name" column="name" type="string"/>
        <property name="age" column="age" type="integer"/>
        <property name="des"/>
    </class>

</hibernate-mapping>

序列跟主键号才能一一对应

二 .持久化对象生命周期的4种状态：

　　　　1. 临时状态（瞬时状态）
　　　　2. 持久化状态
　　　　3. 游离状态
　　　　4. 删除状态

session对象一级缓存 线程级别的缓存 内置的必须使用
sessionFactory对象 二级缓存 进程级别的缓存 可配置（插拔）

package com.edu.cache;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;

/**
 * 使用单元测试工具，测试hibernate 的增删改查（CRUD）操作
 * 
 * @author Administrator
 * 
 */
public class TestHibernate {

    private static SessionFactory sf;
    static {
        // 1. 加载配置文件
        Configuration cfg = new Configuration();
        cfg.configure("com/edu/cache/hibernate.cfg.xml");

        // 2. 获得SessionFactory
        sf = cfg.buildSessionFactory();
    }
    

    @Test
    public void find() {
        
        
        Session session = sf.openSession();
        Transaction tran = session.beginTransaction();
        
        Customer c1 = (Customer) session.get(Customer.class, 1);//发生sql
        Customer c3 = (Customer) session.get(Customer.class, 2);//发生sql
        Customer c2 = (Customer) session.get(Customer.class, 1);//不发生sql
        
        tran.commit();
        session.close();
    }
    
    @Test
    public void flush() {
        
        
        Session session = sf.openSession();
        Transaction tran = session.beginTransaction();
        
        //临时状态    新建对象   不被session缓存管理，oid的值为null
        Customer c = new Customer();
        c.setName("张三");
        
        /*
         *  纳入到session缓存管理，并为其分配了oid的值，由临时状态转变为持久化状态
         *  数据库中没有与之关联的记录
         */
        session.save(c);//不发送insert
        
        //刷新缓存，被生产sql语句发送给数据库，并准备执行
        session.flush();//发送
        
        /*
         * 执行sql语句，影响数据库中的记录
         * 如果程序中没有手动调用flush方法，
         * commit提交事务前，会自动调用flush.
         */
        tran.commit();
        //session关闭，缓存释放，由持久化状态转换为游离状态。处于游离状态的对象生命周期并没有结束
        session.close();
        System.out.println(c.getName());
        c = null;//对象c的生命周期结束
    }
    
    //清空缓存
    @Test
    public void clear() {
        
        
        Session session = sf.openSession();
        Transaction tran = session.beginTransaction();
        
        Customer c1 = (Customer) session.get(Customer.class, 1);//发生sql
        session.clear();
        Customer c2 = (Customer) session.get(Customer.class, 1);//发生sql
        
        tran.commit();
        session.close();
    }
    //清除
    @Test
    public void evict() {
        
        
        Session session = sf.openSession();
        Transaction tran = session.beginTransaction();
        
        Customer c1 = (Customer) session.get(Customer.class, 1);//发生sql
        Customer c2 = (Customer) session.get(Customer.class, 2);//发生sql
        session.evict(c1);
        
        Customer c3 = (Customer) session.get(Customer.class, 1);//发生sql
        //Customer c4 = (Customer) session.get(Customer.class, 2);//不发生sql
        session.update(c1);//c1从游离状态转为持久化状态
        
        tran.commit();
        session.close();
    }
    
    //批量插入50万条记录
    /*@Test
    public void batchSave() {
        
        
        Session session = sf.openSession();
        Transaction tran = session.beginTransaction();
        
        for(int i=0;i<500001;i++) {
            Customer c = new Customer();
            c.setName("tom"+i);
            session.save(c);
            
            if(i%10000==0) {
                session.flush();//向数据库发送了10000条insert语句
                session.clear();//清空缓存
            }
        }
        
        tran.commit();
        session.close();
    }*/
    
    //快照
    @Test
    public void kuaiZhao() {
        
        
        Session session = sf.openSession();
        Transaction tran = session.beginTransaction();
        
        Customer c = (Customer) session.get(Customer.class, 1);
        c.setName("tom");
        System.out.println(c.getId());
        
        
        //更新前查询，避免由此操作改名了持久化对象的状态，二影响数据库中的记录。
    //    session.refresh(c);
    //    session.update(c);
        
        tran.commit();
        session.close();
    }
    
}