---
title: "Hibernate初探(-)"
author: "demojava"
date: "2010-10-21T14:11:36Z"
tags: []
categories: ["企业架构"]
slug: "hibernate"
draft: false
lastmod: "2012-02-16T19:52:38Z"
id: 790482
url: "https://demojava.iteye.com/blog/790482"
---

在hibernate的配置文件中出现了  
  &lt;property name="password" type="java.lang.String"&gt;  
            &lt;column name="password" length="45" not-null="true" /&gt;  
 &lt;/property&gt;  
 表明当前的属性不允许为空，Hibernate在持久化给对象时,会检查password属性是否为NULL 如果为NULL 那么就会抛出下面的异常：  
 org.hibernate.PropertyValueException:not-null property refrences a null or transient value:包名.类名.属性名  
 如果数据库中的映射的字段时不允许为空，但配置文件中没有设置not-null 属性时：&lt;column name="password" length="45" /&gt;  
 因此数据库会抛出错误：ERROR JDBCExceptionReporter:58 -General error,message from server:"Column 'password' cannot be null"

Hibernate配置文件-添加静态方法  
&lt;property name="username" type="java.lang.String"&gt;  
          &lt;meta attribute="find-method"&gt;findByName&lt;/meta&gt;  
            &lt;column name="username" length="45" not-null="true" /&gt;  
&lt;/property&gt;  
其中&lt;meta&gt;标签的find-method 选项用于设置find 的方法名，以上代码表明在某一个类中定义一个静态的方法叫：findByName(Session session,String username),该方法按照username属性到数据库中检索匹配的对象

Hibernate设置包名  
&lt;class&gt;元素的name属性时必须提供完整的类名即，类所在的包的名字，如果在一个配置文件包含多个类，并且这些类都位于一个包中，每次都设定类的名字很烦，此时一下两中映射方式是等价的：  
&lt;hibernate-mapping package="com.entity"&gt;  
 &lt;class name="User" table="UserInfo" catalog="demo"&gt;.....  
 &lt;class name="Role" table="RolrInfo" catalog="demo"&gt;.....  
&lt;/hibernate-mapping&gt;  
&lt;hibernate-mapping&gt;  
    &lt;class name="org.entry.User" table="UserInfo" catalog="demo"&gt;  
    &lt;class name="org.entry.Role" table="RolrInfo" catalog="demo"&gt;  
 &lt;/hibernate-mapping&gt;

HIbernate的Ssession的commit()和flush()方法的区别：flush()方法进行清理缓存的操作，执行一系列的sql语句，打不会提交事物，commit()方法会先调用flush()方法，然后提交事物，提交事物意味着对数据库的所有操作将被永久保存下来

Betch procession批量处理  
使用Hibernate将100000条记录插入到数据库中是一个很自然的做法可能是这样的：  
Session session=sessionFactory.openSession();  
Transaction tx= session.beginTransaction();  
for (int i = 0; i &lt; 100000; i++) {  
 User user=new User(.....);  
 session.save(user);  
}  
tx.commit();  
session.close();  
这个程序大概运行到50000行会出现内存溢出异常，这是因为Hibernate把所有的新插入的记录保存在session级别的缓存区进行缓存的原因  
一般在使用时我们配置的jdbc批量抓取数量（bath size）是10-50之间  
hibernate.jdbc.batch\_size 20当然在执行批处理时关闭二级缓存：  
hibernate.cache.use\_second\_level\_cache false  
批量插入(Batch inserts)：  
Session session=sessionFactory.openSession();  
Transaction tx= session.beginTransaction();  
for (int i = 0; i &lt; 100000; i++) {  
 User user=new User(.....);  
 session.save(user);  
 if(i%20==0)  
 {  
 session.flush();  
 session.clear();  
 }  
}  
tx.commit();  
session.close();  
批量更新(Batch updates)：  
Session session=sessionFactory.openSession();  
Transaction tx= session.beginTransaction();  
String hql="select distinct s.billNumber,s.billDate,s.billState,s.department from StockRequisition as s";  
命名查询  
&lt;hibernate-mapping&gt;  
  &lt;sql-query name="queryStaffBySex"&gt;  
    &lt;!\[CDATA\[update userInfo set sex=:sex where sex is null ]]&gt;  
    &lt;return alias="s" class="com.form.Staff"/&gt;  
  &lt;/sql-query&gt;  
&lt;/hibernate-mapping&gt;

ScrollableResults resluts=session.getNamedQuery("queryStaffBySex").setCacheMode(CacheMode.IGNORE).scroll(ScrollMode.FORWARD\_ONLY);  
  int count=0;  
 while (resluts.next()) {  
   User user=(User)resluts.get(0);  
 user.setSex("男");  
 if(++count%20==0)  
 {  
 session.flush();  
 session.clear();      
 }  
}

1 将整个继承关系放在一张表中，为了区分具体的子类信息，表中需要创建一个额外的列  
 create table paymeny(  
  .....  
  type varchar2(12)  
 );  
 &lt;class name="Payment" table="payment"&gt;  
  .....  
  &lt;discriminitor column="type" type="string"&gt;  
  &lt;sub-class name="CardPayment" discriminitor-value="card"&gt;  
   子类属性  
  &lt;/sub-class&gt;  
  &lt;sub-class name="CashPayment" discriminitor-value="cash"&gt;  
   子类属性  
  &lt;/sub-class&gt;  
 &lt;/class&gt;  
 操作方便 效率较高 多态  
 冗余 浪费空间  
2 将父类信息和每个子类信息结合在一起，创建多张具体的表  
 create table cardpayment(  
  父类信息  
  信用卡子类信息  
 )  
 create table cashpayment(  
  父类信息  
  现金子类信息  
 )  
 &lt;class name="Payment"&gt;  
  .....  
   
  &lt;union-sub-class name="CardPayment" table="cardpayment"&gt;  
   子类属性  
  &lt;/union-sub-class&gt;  
  &lt;union-sub-class name="CashPayment" table="cashpayment"&gt;  
   子类属性  
  &lt;/union-sub-class&gt;  
 &lt;/class&gt;  
 操作方便 效率较高 空间利用率较高  
 冗余 没有多态  
3 针对每个具体的对象，创建其对应得表  
 create table payment(  
  父类信息  
 )  
 create table cardpayment(  
  信用卡子类信息  
  外键cardid  
 )  
 create table cashpayment(  
  现金子类信息  
  外键cashid  
 )  
 &lt;class name="Payment" table="payment"&gt;  
  .....  
   
  &lt;joined-sub-class name="CardPayment" table="cardpayment"&gt;  
   &lt;key column="cardid"&gt;&lt;/key&gt;  
   子类属性  
  &lt;/joined-sub-class&gt;  
  &lt;joined-sub-class name="CashPayment" table="cashpayment"&gt;  
   &lt;key column="cashid"&gt;&lt;/key&gt;  
   子类属性  
  &lt;/joined-sub-class&gt;  
 &lt;/class&gt;  
 多态 没有冗余 空间利用率较高  
 操作复杂 效率较低

hibernate查询：  
 1 native sql  
  程序员精通sql  
  自己控制sql的效率  
  查询到的信息只能自己封装  
 2 hql Student1 ----1 Address  
  在sql框架基础之上，面向对象  
  from Student;  
  select s.name from Student s;  
  from Student s where s.age &gt; 20;  
  from Student s inner join address a where a.name=...;  
 3 criteria  
  标准面向对象式查询  
  session.createCriteria(Student.class);  
  session.createCriteria(Student.class)  
   .add(Restrictions.gt("age",20));  
  session.createCriteria(Student.class)  
   .createCriteria("address")  
   .add(Restrictions.eq("name","..."));  
 4 named query  
  将sql语句彻底从源代码中提取到映射文件中  
  \*.hbm.xml  
  &lt;hibernate-mapping&gt;  
   &lt;class&gt;  
    .....  
   &lt;/class&gt;  
   &lt;query name="sql变量名"&gt;  
    &lt;![CDATA[  
     hql语句... ?/:name  
    ]]&gt;  
   &lt;/query&gt;  
  &lt;/hibernate-mapping&gt;

  session.getNamedQuery("sql变量名")

hibernate对数据源的支持：  
 1 hiebrnate内置数据源，仅用于测试  
 &lt;property name="connection.username"&gt;scott&lt;/property&gt;  
 &lt;property name="connection.url"&gt;  
  jdbc:oracle:thin:@localhost:1521:sinojava  
 &lt;/property&gt;  
 &lt;property name="dialect"&gt;  
  org.hibernate.dialect.Oracle9Dialect  
 &lt;/property&gt;  
 &lt;property name="connection.password"&gt;tiger&lt;/property&gt;  
 &lt;property name="connection.driver\_class"&gt;  
  oracle.jdbc.driver.OracleDriver  
 &lt;/property&gt;

 2\*\*\*\*\*\** hibernate整合c3p0\*\*\*\*\*\**  
 &lt;property name="connection.username"&gt;scott&lt;/property&gt;  
 &lt;property name="connection.url"&gt;  
  jdbc:oracle:thin:@localhost:1521:sinojava  
 &lt;/property&gt;  
 &lt;property name="dialect"&gt;  
  org.hibernate.dialect.Oracle9Dialect  
 &lt;/property&gt;  
 &lt;property name="connection.password"&gt;tiger&lt;/property&gt;  
 &lt;property name="connection.driver\_class"&gt;  
  oracle.jdbc.driver.OracleDriver  
 &lt;/property&gt;

 添加以下信息：  
 &lt;property name="connection.provider\_class"&gt;  
  org.hibernate.connection.C3P0ConnectionProvider  
 &lt;/property&gt;  
 &lt;property name="c3p0.max\_size"&gt;5&lt;/property&gt;  
 &lt;property name="c3p0.timeout"&gt;2000&lt;/property&gt;  
 ..........

 3 jndi  
 &lt;property name="connection.username"&gt;scott&lt;/property&gt;  
 &lt;property name="connection.url"&gt;  
  jdbc:oracle:thin:@localhost:1521:sinojava  
 &lt;/property&gt;  
 &lt;property name="dialect"&gt;  
  org.hibernate.dialect.Oracle9Dialect  
 &lt;/property&gt;  
 &lt;property name="connection.password"&gt;tiger&lt;/property&gt;  
 &lt;property name="connection.driver\_class"&gt;  
  oracle.jdbc.driver.OracleDriver  
 &lt;/property&gt;

 添加以下信息：  
 &lt;property name="jndi"&gt;java:comp/env/userDs&lt;/property&gt;

 程序中必须手动获取连接，传递给hibernate:  
  getSession(){  
   Context env = new IntialContext();  
   DataSource ds = (DataSource)env.lookup("java:comp/env/userDs");  
   Conenction con = ds.getConnection();  
   ...  
   sessionFactory.openSession(conn);  
   ....  
  }

hibernate对于分页的支持：  
 query.setFirstResult(起始位置);  
 query.setMaxResults(查询条数);  
 query.list();

锁：  
 读锁/写锁  
 表级锁/列级锁

JDBC中的并发控制：  
 1 数据库  
  隔离级别  
  TRANSACTION\_NONE  0  
  TRANSACTION\_UNCOMMITED\_READ 1  
  TRANSACTION\_COMMIED\_READ 2  
  TRANSACTION\_REPEATABLE\_READ 4  
  TRANSANTION\_SERIALIZABLE 8  
  Connection.setTransactionIsolation(...)

  select \*\*\** 【for update】;  
 2 应用程序  
  synchronized  
\*\*\*\*\*\*hibernate对多线程并发的控制：  
 1 数据库  
  隔离级别  
  TRANSACTION\_NONE  0  
  TRANSACTION\_UNCOMMITED\_READ 1  
  TRANSACTION\_COMMIED\_READ 2  
  TRANSACTION\_REPEATABLE\_READ 4  
  TRANSANTION\_SERIALIZABLE 8

  hibernate.cfg.xml  
   &lt;property name="connection.isolation"&gt;2&lt;/property&gt;

   
  select \*\*\** 【for update】;  
 2 应用程序  
  悲观锁：  
   认为一定会有两个线程同时访问一个数据  
   必须针对操作进行加锁：  
    Query q = session.createQuery("from Student s")  
    q.setLockMode("s",LokeMode.WRITE);  
    LockMode:  
     NONE 不加锁  
     READ 读锁  
     WRITE 写锁  
     UPDATE 表级锁 &lt;===&gt; select \*\*\** for update;  
  乐观锁：  
   认为一个线程访问的时候，不一定会并发  
    
      线程1    线程2  
    ------------------------------------------------------  
    balance=1000  
      1000    1000  
      1000-600 commit    
     400     1000-200 commit  
     800

    解决：采用一个标志位控制数据的有效性  
     
    balance     identity 线程1    线程2  
    -----------------------------------------------------------------  
    1000    1  
       1000 1   1000 1  
       1000-600 1+1 commit  
    400    if(2&gt;1)提交   
           1000-200 1+1 commit  
        if(2&gt;2)不许提交

    标志位：  
     时间戳：  
       
     \*\*版本号：  
    
hibernate缓存机制：  
 一级缓存：Session对象  
  session.get(Class,Serializble)  
  session.load(Class,Serializble)

  get/load共性：  
   get和load发送的sql语句结构相同  
   session---&gt;SessionFactory---&gt;DB  
  get/load区别:  
   get:  
    1 只要调用get方法，则直接发送sql查询  
    2 get直接查找信息，找不到则返回null  
     
   load:  
    1 调用了load方法，默认不发送sql语句  
    直到真正使用该对象时，才发送sql查询  
    load方法返回的对象：没用到信息，则返回代理对象  
          使用到信息，则返回真正的对象      2 load方法查找不到信息，则报异常         org.hibernate.ObjectNotFoundException

 二级缓存：SessionFactory  
  1 在hibernate.cfg.xml中添加属性  
  --设置二级缓存类  
  &lt;property name="cache.provider\_class"&gt;  
   org.hibernate.cache.EhCacheProvider  
  &lt;/property&gt;二级  
  --设置query操作使用缓存，否则是对get/load生效  
  &lt;property name="cache.use\_query\_cache"&gt;true&lt;/property&gt;

  2 在hbm映射文件中设置使用二级缓存  
  &lt;class name="Concur" table="concur\_time"&gt;  
   &lt;cache usage="read-only|read-write"/&gt;  
   ...  
  &lt;/class&gt;  
   
  3 如果使用query语句查询，并且想使用二级缓存  
   Query.setCacheable(true);  
   Query.list....

hibernate对象状态及session的各个方法：  
 transient 临时对象  
 detached 游离对象  
 persist  持久化对象

  Configuration cfg = new Configuration().configure();  
  SessionFactory sf = cfg.buildSessionFactory();  
  Session session = sf.openSession();  
  Transaction tx = session.beginTransaction();  内存 session  DB  
  Concur c = new Concur("hehe");     

 session.save(c);  
  tx.commit();       

  session.close();      

 

**hibernate中的N+1问题**

在hibernate中，当进行一个表的查询时，当这个表与另外的表是多对一，  
     或者是一对多关联时，就会出现N+1问题，当查询一条语句时，比如主键name=1,  
     而与这个name相关联的另一张表对应name的有N个记录，这时就出另外发出N条语句去查询，而我又不要那些记录，这时就是N+1问题。  
            解决方法：  
            1.设置lazy=true;  
            2.在本类DTO中有关联另外表的表对象的声明，在他的get方法上面加上一个@fetch=fetchtype.lazy;  
            3.在关联的类上面设置@batchsize=2;这时就只发出两条语句。  
            4.用SQL来查询，写SQL语句时就写成联合查询的形式。