Hibernate的基础入门--笔记(二)

1.持久化类的编写规范

　　遵从JavaBean的编写规范.

　　什么是JavaBean?

　　　　bean:在软件开发领域,Bean表示可重用组件.

　　　　　　JavaBean就是用Java语言开发的可重用组件.

　　JavaBean的编写规范是什么?

　　　　类都是public的

　　　　都有默认无参构造函数

　　　　成员变量都是私有的

　　　　都有公有的get/set方法

　　　　一般都实现Serializable接口

　　基本类型和包装类的选择问题?

　　　　包装类可以有null值.所以实际开发中都是用包装类.

2.主键生成策略(native之外的取值)　

　　代理主键:不参与程序业务,只是用于区分表中数据的.

　　自然主键:参与程序业务.同时也能区分表中数据.

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">　　　　　　　　　　
<hibernate-mapping package="com.mypro.id">
    <class name="User" table="user">
        <id name="id" column="Id" type="int">
            <generator class="navite"></generator>
        </id>
        <property name="name" column="name" type="string"></property>
    </class>
</hibernate-mapping>

通过配置可以看到，我们有个实体类User，该类有一个id和name的属性与数据库中user表的id和name字段分别对应。其中

<generator class="navite"></generator>

 定义了主键的生成方式，下面我们将会介绍到我们常用的主键生成方式

　　1、assigned　　　　　　适用于自然主键

主键由外部程序负责生成，在 save() 之前必须指定一个，Hibernate不负责维护主键生成。也就是可以每次指定主键。该方式不推荐

2、increment　　　　　　适用于代理主键

这种方式在每次插入前，需要通过“select max(主键) from 表名 ”这种方式先查询最大ID，然后通过ID+1来作为新的主键值。这种方式也不推荐，因为这样会出现线程安全问题。

3、identity　　　　　　适用于代理主键

identity由底层数据库生成标识符。identity是由数据库自己生成的，但这个主键必须设置为自增长，使用identity的前提条件是底层数据库支持自动增长字段类型，如DB2、SQL Server、MySQL、Sybase和HypersonicSQL等，Oracle这类没有自增字段的则不支持。

4、sequence　　　　　　适用于代理主键

采用数据库提供的sequence机制生成主键，需要数据库支持sequence。如oralce、DB、SAP DB、PostgerSQL、McKoi中的sequence。MySQL这种不支持sequence的数据库则不行

5、hilo

hilo（高低位方式high low）是hibernate中最常用的一种生成方式，需要一张额外的表保存hi的值。保存hi值的表至少有一条记录（只与第一条记录有关），否则会出现错误。可以跨数据库。

6、native　　　　　　适用于代理主键

native由hibernate根据使用的数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式，灵活性很强。如果能支持identity则使用identity，如果支持sequence则使用sequence。

7、uuid　　　　　　适用于代理主键

UUID：Universally Unique Identifier，是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字，标准的UUID格式为：

　　xxxxxxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxx (8-4-4-4-12)

3.hibernate中的对象标识符

　　OID:  Object Identifier  对象标识符

　　它就是hibernate用来区分两个对象是否是同一个对象的标识.

 

4.hibernate中的一级缓存

　　什么是缓存?

　　　　内存中的临时数据.

　　hibernate中的一级缓存?

　　　　它指的是Session的对象的缓存.就是由一些集合组成的.

　　　　当我们在执行查询时,先去缓存中看看有没有数据,如果有的话,就不再去数据库中查询了.如果没有,则直接去数据库中查询.

　　　　从而提高效率.

　　　　当Session对象close了之后,一级缓存就消失了.

    /**
     * 证明一级缓存确实存在.
     * 需求：
     *     查询id为2的客户
     */
    @Test
    public void test1(){
        Session s = HibernateUtil.openSession();
        Transaction tx = s.beginTransaction();
        //1.查询id为2的客户
        Customer c1 = s.get(Customer.class, 2L);//先从缓存中找，没找到。去数据库中查询。存入一级缓存中
        System.out.println(c1);
        Customer c2 = s.get(Customer.class, 2L);//先从缓存中找，找到了，直接返回了。
        System.out.println(c2);
        
        System.out.println(c1 == c2);
        tx.commit();
        s.close();//一级缓存
    }
    

　　快照机制:

　　

session的快照

* 使用id进行查询数据库，将查询得到的结果放置到session一级缓存中，同时复制一份数据，放置到session的快照中

* 当使用tx.commit()的时候，同时清理session的一级缓存（flush）

* 当清理session一级缓存的时候，会使用OID判断一级缓存中对象和快照中的对象进行比对

* 如果2个对象（一级缓存的对象和快照的对象）中的属性发生变化，则执行update语句，此时更新数据库，更新成一级缓存中的数据

* 如果2个对象中的属性不发生变化，此时不执行update语句

目的：确保和数据库中的数据一致   

5.hibernate中的一下方法问题

　　hibernate中对象的状态

　　　　明确:学习对象的状态是为了更好的掌握hibernate中操作的方法.

　　状态的分类:

　　　　临时状态(瞬时状态):Transient

　　　　　　没有OID,和Session没有关系.

　　　　持久化状态:Persistent

　　　　　　有OID,和Session有关系.

　　　　脱管状态(游离状态):Detached

　　　　　　有OID,和Session没有关系.

　　　　

　　常用的方法:

　　　　save和persist方法:　　　

    /**
     * save方法：
     *     保存一个实体。
     * 状态的转变：
     *     把临时态对象转成了持久态。
     */
    @Test
    public void test1(){
        Customer c = new Customer();
        c.setCustName("修正save11");
        c.setCustIndustry("医药");
        c.setCustSource("网络");
        c.setCustLevel("VIP客户");
        c.setCustAddress("昌平区");
        c.setCustPhone("010-98234832");
        
        Session s = HibernateUtil.openSession();
        //Transaction tx = s.beginTransaction();
        s.save(c);
        //tx.commit();
        s.close();//一级缓存
    }
    
    /**
     * persist方法：
     *     保存一个实体
     * 状态的转变：
     *     把临时态对象转成了持久态    
     */
    @Test
    public void test2(){
        Customer c = new Customer();
        c.setCustName("修正persist");
        c.setCustIndustry("医药制造");
        c.setCustSource("网络");
        c.setCustLevel("VIP客户");
        c.setCustAddress("昌平区");
        c.setCustPhone("010-98234832");
        
        Session s = HibernateUtil.openSession();
        //Transaction tx = s.beginTransaction();
        s.persist(c);
        //tx.commit();
        s.close();//一级缓存
    }

 

　　　　共同点:

　　　　　　都是把临时态对象转换成持久态.

　　　　区别:

　　　　　　提供者不一样:

　　　　　　　　save方法是hibernate提供的.

　　　　　　　　persist方法是JPA规范提供的. (JPA: Java Persistence Api --Java持久化规范)

　　　　　　在没有事务的情况下:

　　　　　　　　save会去数据库中保存,hibernate提供了一个内置的事务来执行.

　　　　　　　　persist什么都不会做.

　　delete方法:

    /**
     * delete方法
     * 
     *         
     */
    @Test
    public void test3(){
        
        Session s = HibernateUtil.openSession();
        Transaction tx = s.beginTransaction();
        //1.查询id为11的客户
        Customer c = s.get(Customer.class, 11L);
        //2.删除客户
        s.delete(c);
        tx.commit();
        s.close();
    }

 

　　　　问题:当我们删除一个实体时，该实体已经被别的程序给删除了，此时会报错。

           <控制台报错>Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1

　　update方法:

    /**
     * update方法
     * 
     * */
    @Test
    public void test4(){
        
        Session s = HibernateUtil.openSession();
        Transaction tx = s.beginTransaction();
        //1.查询id为10的客户
        Customer c10 = s.get(Customer.class, 10L);//持久态
        tx.commit();
        s.close();//一级缓存没了
        
        //2.修改c10的客户名称
        c10.setCustName("修正update");//脱管态
        
        Session s1 = HibernateUtil.openSession();
        Transaction tx1 = s1.beginTransaction();
        //3.查询id为10的客户
        Customer c = s1.get(Customer.class, 10L);//持久态
        //4.更新c10客户
        s1.update(c10);//持久态
        tx1.commit();
        s1.close();//一级缓存没了
    }

 

　　　　

　　　　　　问题：当我们更新一个脱管态实体时，一级缓存中已经包含了一个相同OID的持久态对象，会报错。

                <控制台报错> A different object with the same identifier value was already associated with the session : [com.itheima.domain.Customer#10]

　　　　

　　merge方法:　

　　　　作用: 合并两个实体.永远是用一级缓存外的修改一级缓存内的对象.　

/**
     * merge方法
     */
    @Test
    public void test5(){
        
        Session s = HibernateUtil.openSession();
        Transaction tx = s.beginTransaction();
        //1.查询id为10的客户
        Customer c10 = s.get(Customer.class, 10L);//持久态
        tx.commit();
        s.close();//一级缓存没了
        
        //2.修改c10的客户名称
        c10.setCustName("修正update");//脱管态
        
        Session s1 = HibernateUtil.openSession();
        Transaction tx1 = s1.beginTransaction();
        //3.查询id为10的客户
        Customer c = s1.get(Customer.class, 10L);//持久态
        //4.更新c10客户
        s1.merge(c10);//持久态
        tx1.commit();
        s1.close();//一级缓存没了
    }

 

　　saveOrUpdate方法:

　　　　作用:保存或更新一个实体.

　　　　到底执行保存还是更新:

　　　　　　取决于对象的状态:

　　　　　　　　如果是临时态对象就是保存 / 如果是脱管态对象就是更新

6.满足Session的使用原则

　　在hibernate中的使用数据源(连接池)

　　　　使用步骤:

　　　　　　1.导入连接池的jar包

　　　　　　　

　　　　　　2.在hibernate主配置文件中配置

　　　　　　　　配置连接池的提供商

<!-- 配置连接池的提供商 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

 

/**
     * 证明是否使用了连接池
     */
    @Test
    public void test1(){
        Session s = HibernateUtil.openSession();
        //hibernate中使用原始JDBC对象
        s.doWork(new Work() {    
            @Override
            public void execute(Connection conn) throws SQLException {
                System.out.println(conn.getClass().getName());
            }
        });
    }

 

　

　配置hibernate中一个线程只能有一个session的方式:

　　　　配置步骤:

　　　　　　1.在hibernate主配置文件中配置

<!-- 把Session绑定到当前线程上 -->
        <property name="hibernate.current_session_context_class">thread</property>

 

　　　　　　2.获取Session时使用的方法

/**
     * Session的使用原则：
     *         一个线程只应该有一个Session对象
     */
    @Test
    public void test2(){
        Session s1 = HibernateUtil.getCurrentSession();
        Session s2 = HibernateUtil.getCurrentSession();
        System.out.println(s1 == s2);
    }

 　　　　细节:

　　　　　　当我们把Session绑定到当前线程之后,关闭Session就是Hibernate来做的,我们就不需要关了.

 

7.查询对象的使用(入门,讲解在(四))

　　Query   <掌握>

/**
 * hibernate中的查询对象
 *     Query:
 *         作用：使用的是HQL语句查询
 *         如何获取：
 *             session.createQuery(String hql);
 *         常用方法：
 *             list():获取结果集
 *             setXXXX方法():给参数占位符赋值用的。XXXX表示的是数据类型。  比如：setString(int index,String param)  setObject(int index,Object obj)
 *                          在给参数占位符赋值时，索引位置是从0开始的12  *
 */
public class HibernateDemo4 {

    /**
     * 查询所有
     */
    @Test
    public void test1(){
        Session s = HibernateUtil.getCurrentSession();
        Transaction tx = s.beginTransaction();
        //1.获取Query对象
        Query query = s.createQuery("from Customer");
        //2.执行list方法获取结果集
        List list = query.list();
        tx.commit();

        
        for(Object o : list){
            System.out.println(o);
        }
    }
    
    /**
     * 查询客户：
     *     带有条件：客户级别是VIP客户
     */
    @Test
    public void test2(){
        Session s = HibernateUtil.getCurrentSession();
        Transaction tx = s.beginTransaction();
        //1.获取Query对象
        Query query = s.createQuery("from Customer where custLevel = ? and custName like ?   ");
        //2.给参数占位符赋值
        query.setString(0, "VIP客户");
        query.setString(1, "%大%");
        //3.执行list方法获取结果集
        List list = query.list();
        tx.commit();

        
        for(Object o : list){
            System.out.println(o);
        }
    }
    
    /**
     * 具名查询：
     *      给参数占位符提供一个具体的名称
     * 参数名称的写法：
     *         :名称
     * 给占位符赋值时：
     *         注意：不需要写冒号，直接写名称
     */
    @Test
    public void test3(){
        Session s = HibernateUtil.getCurrentSession();
        Transaction tx = s.beginTransaction();
        //1.获取Query对象
        Query query = s.createQuery("from Customer where custName like :custName  and custLevel = :custLevel ");
        //2.给参数占位符赋值
        query.setString("custLevel", "VIP客户");
        query.setString("custName", "%大%");
        //3.执行list方法获取结果集
        List list = query.list();
        tx.commit();

        
        for(Object o : list){
            System.out.println(o);
        }
    }
}

 

　　Criteria　　<逐步掌握>

/**
 * hibernate中的查询对象
 *     Criteria对象：
 *         作用：使用QBC查询。 query by criteria
 *             它是一种更加面向对象的查询方式。
 *         明确：
 *             能用HQL查询的，QBC都能查。反之亦然。
 *         hibernate官方推荐的是hql查询
 *  如何获取对象
 *      使用的是session对象的createCriteria(Class clazz);
 *      参数的含义：要查询的实体类字节码对象13  *
 */
public class HibernateDemo5 {

    /**
     * 查询所有
     */
    @Test
    public void test1(){
        Session s = HibernateUtil.getCurrentSession();
        Transaction tx = s.beginTransaction();
        //1.获取Criteria对象
        Criteria criteria = s.createCriteria(Customer.class);//就相当于HQL语句from Customer
        //2.调用list获取结果集
        List list = criteria.list();
        tx.commit();
        
        for(Object obj : list){
            System.out.println(obj);
        }
    }
    
    
    /**
     * 查询客户：
     *     带有条件：客户级别是VIP客户
     *             客户名称包含大字
     */
    @Test
    public void test2(){
        Session s = HibernateUtil.getCurrentSession();
        Transaction tx = s.beginTransaction();
        //1.获取Criteria对象
        Criteria criteria = s.createCriteria(Customer.class);//就相当于HQL语句from Customer
        //2.设置查询条件
        criteria.add(Restrictions.eq("custLevel","VIP客户"));//谁=什么值   谁指的就是属性
        criteria.add(Restrictions.like("custName", "%大%"));
        //3.调用list获取结果集
        List list = criteria.list();
        tx.commit();
        
        for(Object obj : list){
            System.out.println(obj);
        }
    }
    
    
}

 

　　SQLQuery　　<了解>

/**
 * hibernate中的查询对象
 *     SQLQuery
 *         作用：使用原始SQL语句查询
 *     如何获取
 *         session.createSQLQuery(String sql); 
 8  *
 */
public class HibernateDemo6 {

    /**
     * 查询所有
     */
    @Test
    public void test1(){
        Session s = HibernateUtil.getCurrentSession();
        Transaction tx = s.beginTransaction();
        //1.获取sqlquery对象
        SQLQuery sqlquery = s.createSQLQuery(" select * from cst_customer ");
        //2.给sqlquery添加要转换的实体类
        sqlquery.addEntity(Customer.class);
        //3.获取结果集
        List list = sqlquery.list();
        tx.commit();
        for(Object o : list ){
            System.out.println(o);
        }
    }
}