hibernate学习笔记

=====================================


目录:
1.基本操作增删查改
1.1.按主键查询
1.2.添加操作
1.3.删除
1.4.更新整个对象状态
2.HQL查询
2.1.查询所有记录
2.2.查询一条记录
2.3.查询部分字段
2.4.实现分页查询
2.5.将HQL定义到hbm.xml文件中
2.6.带有条件的查询语句设置条件位置的两种方式
2.7.两个表的查询
3.主键生成方式之:sequence
4.清除一级缓存中的对象
5.在持久状态将缓存对象与数据库同步
6.采用延迟加载的操作有哪些
7.OpenSessionInView模式控制Session关闭
8.一对多关系映射
9.多对一关系映射
10.关联操作
10.1.join fetch查询
10.2.级联操作
11.多对多关系映射  
12.继承关系映射
13. 将底层的sql操作显示出来
14.SQLQuery查询
15.二级缓存
15.1.二级缓存使用方法
15.2.二级缓存的管理
16.查询缓存
16.1.查询缓存的使用方法
17.锁机制
17.1.悲观锁设置
17.2.乐观锁设置
=============================
1.基本操作增删查改


1.1.按主键查询: session.load();/session.get();   

例子:session.load(Account.class,1011);

1.2.添加操作: session.save(obj);

1.3.按id删除: session.delete(obj);// obj需要设置id

1.4.更新整个对象状态: session.update(obj);



2.HQL查询


2.1.查询所有记录:
Query query = session.createQuery("hql语句.例如:from Cost");
List<Cost> list = query.list();

2.2.查询一条记录:
Query query = session.createQuery("例如from Account where id=?");
query.setInteger(0, 1011);// 设置参数,下标从0开始
Account account = (Account)query.uniqueResult();// 查询一条记录

2.3.查询部分字段:
a.查询结果默认采用Object[]封装一行记录

例子:
String hql = "select id,realName,idcardNo from Account";
Query query = session.createQuery(hql);
// 查询部分字段，默认采用Object[]封装一行记录
List<Object[]> list = query.list();
for(Object[] objs : list){
System.out.println(objs[0]+" "+objs[1]+" "+objs[2]);
}

b.采用Account对应参数的构造方法封装一行记录

例子:
String hql = "select new Account(id,realName,idcardNo) " +
"from Account";
Query query = session.createQuery(hql);
// 查询部分字段，采用Account对应参数的构造方法封装一行记录
List<Account> list = query.list();
for(Account account : list){
System.out.println(account.getId()+" "
+account.getRealName()+" "
+account.getIdcardNo());
}


2.4.实现分页查询:
int page = 2;// 当前第几页
int pageSize = 5;// 每页最大记录数

// 设置分页参数

query.setFirstResult((page-1)*pageSize);// 抓取起点索引,从0开始
query.setMaxResults(pageSize);// 最大抓取数量


2.5.将HQL定义到hbm.xml文件中:

hbm.xml中的配置:

   <query name="findAll">
    <![CDATA[
    from Account where id>:id
    ]]>
   </query>
Test:
// 获取hbm中定义名为findAll的hql语句
Query query = session.getNamedQuery("findAll");
   query.setInteger("id", 300);
   
2.6.带有条件的查询语句设置条件位置的两种方式:

?问号  和  :占位符 (上面就是:占位符的例子)
   
2.7.两个表的查询

//不需要关联关系
String hql = 
 "select s.id,s.unixHost," +
"s.osUsername,a.realName," +
"a.idcardNo " +
"from Service s,Account a " +
"where s.account.id=a.id";
//需要关联关系
String hql =
 "select s.id,s.unixHost," +
"s.osUsername,a.realName," +
"a.idcardNo " +
"from Service s join s.account a";
//需要关联关系
String hql = 
 "select s.id,s.unixHost," +
"s.osUsername,s.account.realName," +
"s.account.idcardNo " +
"from Service s";




3.主键生成方式之:sequence


使用格式如下：

<generator class="sequence">
 <param name="sequence">
              序列名
     </param>        
</generator>


例子:
       <id name="id" type="integer">

   <column name="ID" precision="9" scale="0" />
   
   <generator class="sequence">
    <param name="sequence">ACCOUNT_SEQ</param>
   </generator>
   
</id>


4.清除一级缓存中的对象


session.evict(obj);// 清除指定的obj对象


session.clear();// 清除所有缓存对象

session.close();// 释放session及其缓存


5.在持久状态将缓存对象与数据库同步


session.flush();




6.采用延迟加载的操作有哪些


a.session.load();

b.query.iterator();

c.采用关联映射后，获取关联属性的getter



7.OpenSessionInView模式控制Session关闭




8.一对多关系映射


a.首先:要在一方的实体类中添加一个集合属性，用于存放关联的多方对象集合

例如:private Set<Service> services;

b.然后:在一方的hbm.xml中配置描述信息

描述信息格式:
<set name="集合属性名">
  <key column="指定关联的外键字段"></key>
  <one-to-many  class="要关联的另一方类型"/>
</set>

例子:Account中对Service的配置

       <!-- 采用一对多关系加载相关的Service记录 -->
       <set name="services" inverse="true" cascade="all">
        <!-- 指定关联条件字段，写外键字段 -->
        <key column="ACCOUNT_ID"></key>
        <!-- 指定要采用的关系，要加载的数据类型 -->
        <one-to-many class="org.tarena.entity.Service"/>
       </set>

8.1.关联使用 Set<Service> services = account.getServices();



9.多对一关系映射


a.首先:在n方的实体类中添加一个属性，用于存储相关的一方数据

例子:private Account account;


b.其次:在n方的hbm.xml中添加下面格式描述信息

 <many-to-one name="属性名" 
 class="要关联的Account类型" 
 column="关联的外键字段"/>

例子:
       <!-- 指定account属性，采用many-to-one关系加载 -->
       <many-to-one name="account" column="ACCOUNT_ID"
        class="org.tarena.entity.Account">
       </many-to-one>


c.最后:删除n方中原关联字段外键的映射和定义的属性


 

10.关联操作




10.1.join fetch查询

将关关联属性的数据和当前主对象一起被加载

方法:：采用HQL语句，使用join fetch查询

例子:from Account a join fetch a.services;
       
       
10.2.级联操作

// 对主对象做增删改时，可以将关联属性中的数据也执行相应的增删改操作

默认情况下，关联属性不支持级联操作

// 需要在hbm.xml中定义关联属性映射时

使用cascade属性,就可以实现级联操作

// 该属性值可以为none,delete,save-update,all等
 
例子:

       <set name="services" inverse="true" cascade="all">
        <key column="ACCOUNT_ID"></key>
        <one-to-many class="org.tarena.entity.Service"/>
       </set>

a.级联添加
例子:
// account
Account account = new Account();
        ...
        // service1
        // service的映射中没有了accountId
        // 用setAccount可以设置
        Service service1 = new Service();
        ...
        service1.setAccount(account);
        ...
        // service2
    service2.setAccount(account);
        ...
        Service service2 = new Service();
        ...
    // 将service1和service2给account指定
    account.getServices().add(service1);
    account.getServices().add(service2);
   
    Session session = HibernateUtil.getSession();
    Transaction tx = session.beginTransaction();
    // 保存
    // 对account做添加，它的services数据也做添加
    session.save(account);
    tx.commit();
    HibernateUtil.closeSession(session);
 
b.inverse属性的使用
 
inverse=true  将关系维护交给了另一方负责
inverse=false 自己管理关联关系
例子:

       <set name="services" inverse="true" cascade="all">
        <key column="ACCOUNT_ID"></key>
        <one-to-many class="org.tarena.entity.Service"/>
       </set>
 
c.级联删除
 
删除的对象需要通过session的load,get方法查询出来

// 注意：删除的对象需要通过session的load,get方法查询出来，不要采用new的方式。
// load,get方法才能查询出关联的数据,方便级联删除
 

 
11.多对多关系映射  
 
数据中由3张数据表才能表示多对多关系,两个一对多就是多对多
需要由中间的关系表存储关联数据。
 
描述信息:

<set name="属性名" table="中间关系表">
<key column="关系表与当前类型关联的字段"></key>
<many-to-many class="要关联的数据类型" column="关系表与class类型关联的字段"/>
</set>

例子:Admin中的描述信息与Role是多对多关系

       <!-- 描述roles，采用多对多关系加载Role信息 -->
   <set name="roles" table="ADMIN_ROLE">
    <!-- 指定关系表哪个字段与当前admin进行关联 -->
    <key column="ADMIN_ID"></key>
    <!-- class指定与哪一方关联,column指定关系表的关联字段 -->
    <many-to-many class="org.tarena.entity.Role" column="ROLE_ID">
    </many-to-many>
   </set>
    
操作例子:
// 测试查询某个角色及其拥有该角色的管理员信息
Role role = (Role)session.load(Role.class,224 );
   Set<Admin> admins = role.getAdmins();
   //取消admin管理员的某个角色
Admin admin = (Admin)session.load(Admin.class, 1409);
Role role1 = (Role)session.load(Role.class, 243);
admin.getRoles().remove(role1);
//给管理员指定role1,role2
admin.getRoles().add(role1);
admin.getRoles().add(role2);




12.继承关系映射


将父类和子类分别映射到父类表,子类表

--修改实体类，将子类extends父类

--子类的hbm.xml采用<joined-subclass>元素描述

<joined-subclass 
 name="子类类型" 
 extends="父类类型" 
 table="子类映射的表名">
 <key column="子表的关联字段"></key>
</joined-subclass>


例子:
   <joined-subclass name="org.tarena.entity.Book" 
    extends="org.tarena.entity.Product" table="BOOK">
    <!-- 指定BOOK表的ID与PRODUCT的主键关联 -->
    <key column="ID"></key>
    <!--
    ......
    -->
   
   </joined-subclass>

13. 将底层的sql操作显示出来


<property name="show_sql">true</property>
<property name="format_sql">true</property>




14.SQLQuery查询


执行原始的SQL语句
SQLQuery query = session.createSQLQuery();
利用Query执行查询操作

例子1:

String sql = "select * from ACCOUNT where real_name like ?";
SQLQuery query = session.createSQLQuery(sql);
//指定采用Account类型封装一行记录
query.addEntity(Account.class);
//指定查询条件的?参数
query.setString(0, "%Struts%");
//指定分页查询
query.setFirstResult(0);
query.setMaxResults(5);
List<Account> list = query.list();
for(Account a:list){
System.out.println(a.getId()+" "+a.getLoginName());
}

例子2:

String sql = "select * from ACCOUNT";
SQLQuery query = session.createSQLQuery(sql);
query.setFirstResult(0);
query.setMaxResults(5);
List<Object[]> list = query.list();
for(Object[] objs:list){
System.out.println(objs[0]+" "+objs[2]);
}




15.二级缓存


15.1.二级缓存使用方法(适用3.2及其以上版本)

a.引入第三方提供的缓存组件

引入ehcache.jar包和ehcache.xml配置文件(配置文件放在src目录下,可以修改配置)

b.在hibernate.cfg.xml中启用二级缓存，指定缓存组件的驱动类

<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">
true
</property>
<!-- 指定二级缓存组件的驱动类 -->
<property name="hibernate.cache.provider_class">
net.sf.ehcache.hibernate.EhCacheProvider
</property>
<!-- 指定开启查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>

c.在要缓存的hbm.xml中添加<cache>元素

    <!-- usage指定缓存的对象将来支持操作
      region指定对象采用ehcahe.xml哪组参数存储 -->
  <cache usage="read-only" region="sampleCache1"/>


15.2.二级缓存的管理

如果需要立刻释放二级缓存空间，可以使用下面API

SessionFactory.evict();//移除缓存对象

例子:

HibernateUtil.getSessionFactory().evict(Account.class,1011);




16.查询缓存


一级和二级缓存只能缓存单个对象
查询缓存可以缓存集合

16.1.查询缓存的使用方法

a.需要建立目标类型的二级缓存存储
 
 
b.在hibernate.cfg.xml中开启查询缓存
 
<!-- 指定开启查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>

c.在执行query.list之前需要调用   
 
query.setCahceable(true);
 
例子:
String hql = "from Account";
Query query = session.createQuery(hql);
//采用查询缓存机制查询
//如果发现缓存中执行过sql和结果集，直接将缓存的结果集返回
//如果未发现缓存执行过sql,去数据库查询，并结果集和sql语句存入查询缓存中
query.setCacheable(true);
List<Account> list = query.list();
for(Account a : list){
System.out.println(a.getId()+" "+a.getLoginName());
}


17.锁机制


17.1.悲观锁设置

session.load(Train.class,1,LockMode.UPGRADE);


自己定义的查询的设置

query.setLockMode(LockMode.UPGRADE);

17.2.乐观锁设置


a.实体类中追加版本号字段属性
数据库中追加字段

例如:private Integer version;

b.hbm.xml文件中追加字段映射

<class name="org.tarena.entity.Train" 
optimistic-lock="version"
    table="T_TRAIN" >

   <!-- 指定乐观锁的版本字段映射 -->
   <version name="version" type="integer" 
    column="t_version">
   </version>