hibernate配置文件详解

<meta>元素的属性
        属性                                                描述
    class-description                            指定描述类的javaDoc
    field-description                            指定描述类的属性javaDoc
    interface                                    如果为true,表明生成接口而非类,默认false
    implements                                   指定类所实现的接口
    extends                                      指定继承的父类名
    generated-class                              重新指定生成的类名
    scope-class                                  指定类的修饰符,默认public
    scope-set                                    指定set方法的修饰符,默认public
    scope-get                                    指定get方法的修饰符,默认public
    scope-field                                  指定类的属性的修饰符,默认private
    use-in-toString                              如果为true,表示在toString()方法中包含此属性
    gen-property                                 如果为false,不会在java类中生成此属性,默认true
    finder-method                                指定find方法名

   
                                     <column>元素属性
    name                 设定字段名字
    length               设定字段长度
    not-null             如为true,指名该字段不允许为null,默认false
    unique               如为true,指名该字段具有唯一约束,默认false
    index                给一个或多个字段建立索引
    unique-key           为多个字段设定唯一约束
    foreign-key          为外键约束命名,在<many-to-many><one-to-one><key><many-to-one>元素中包含
                         foreign-key属性,在双向关联中,inverse属性为true的一端不能设置foreign-key
    sql-type             设定字段sql类型
    check                设定sql检查约束

                    用于控制insert or update 语句的映射属性

  <property>元素的insert属性                  如为false,在insert中不包含该字段,默认为true
  <property>元素的update属性                  如为false,在update中不包含该字段,默认为true
  <class>元素的mutable属性                    如为false,等价于所有字段的update属性为false,默认为true
  <property>元素的dunameic-insert属性         如为true,表明动态生成insert语句,只有不为null,才会包含insert语句中,默认false
  <property>元素的dunameic-update属性         如为true,表明动态生成update语句,只有不为null,才会包含insert语句中,默认false
  <class>元素的dunameic-insert属性            如为true,表明等价于所有字段动态生成insert语句,只有不为null,才会包含insert语句 中                                               ,默认false
  <class>元素的dunameic-update属性            如为true,表明等价于所有字段动态生成update语句,只有不为null,才会包含insert语句中                 ,默认false

                 Hibernate提供的内置标识符生成器
    increment   适用于代理主键,自动递增,增1(只能是long,int,short)
    identity    适用于代理主键,底层数据库自动增长字段类型(数据库需支持,只能是long,int,short)
(oralce)sequence    适用于代理主键,根据底层数据库的序列来生成标识符(数据库支持序列,只能是long,int,short)
    hilo        适用于代理主键,根据high/low算法来生成.Hibernate把特定表的字段作为high值,在默认情况
                下选用hibernate_unique_key表的next_hi字段
(mysql,mssql)native    适用于代理主键,根据数据库自动生成标识符支持能力,来选择identity,sequence,hilo 
    uuid.hex    适用于代理主键,采用128位UUID(universal unique identification)算法来生成标识.此算法能在网络环境中生成唯一的字符串标识符,(不建议使用,字符串类型比整形类型的主键占用更多的空间)
    assigned    适用于自然主键,由java程序负责生成.

<hibernate-mapping>
  <class name="项目路径" table="库中对应表名" schema="dbo" catalog="netoa">
      <meta attribute="class-description">指定描述类的javaDoc</meta>
      <meta attribute="class-scope">指名类的修饰类型</meta>
      <meta attribute="extends">指定继承类</meta>
         <id name="bgrkbh" type="long">
            <column name="BGRKBH" precision="15" scale="0" sql-type="库中类型" check="BGRKBH>10"/>
            <meta attribute="scope-set">指定类,类属性的getxxx(),setxxx()方法的修饰符
             包括:static,final,abstract,public,protected,private
            </meta>
            <generator class="assigned" />
        </id>
         <property name="Class.fileName" type="long">
                <column name="YSLX" precision="精度" scale="刻度" not-null="默认false" sql-type="数据库中类型"/>
                附加属性不会影响Hibernate的运行行为
                <meta attribute="field-description">指定描述类的javaDoc</meta>
                指定描述类属性的javaDoc
         </property>
  </class> 
</hibernate-mapping>

注意:
1 Session的commit()和flush()方法的区别,flush()方法进行清理缓存的操作,执行一系列的SQL语句,但不会提交事务;
  commit()方法会先调用flush(),然后提交事务.提交事务意味着对数据库所作的更新被永久保存下来.

2 Session的setFlushMode()方法用于设定清理缓存的时间点.FlushMode类定义了三种不同的清理模式

清理缓存的模式        Session的查询方法                Session的commit()方法       Session的flush()方法
FlushMode.AUTO           清理                               清理                     清理   
FlushMode.COMMIT         不清理                             清理                     清理   
FlushMode.NEVER          不清理                             不清理                   清理

3 Hibernate应用中java对象的状态
临时状态 (transient):刚刚用new语句创建,还没被持久化,不处与Session的缓存中,处于临时状态的java对象被称为临时对象.
持久化状态(persistent):已经被持久化,加入session的缓存中.处于持久化状态的java对象被称为持久化对象.
游离状态(detached):已经被持久化,但不在处于session的缓存中.处于游离状态的java对象被称为游离对象.
(注意:::::)持久化类与持久化对象是不同的概念.持久化类的实例可以处于临时状态,持久化状态和游离状态.其中处于
           持久化状态的实例 被称为持久化状态.

临时对象的特性:
1 不处于缓存中,也可以说,不被任何一个Session实例关联
2 在数据中没有对应的纪录.
在此情况下,java对象进入临时状态
1 当通过new创建一个对象时,此时不和数据库中的任何纪录的
ex:
                                        对象的状态转化过程

       程序代码                                        对象的生命周期                     对象的状态
tx=session.beginTransaction();
Object obj=new Object("tow",new HashSet());               开始生命周期                临时状态
 
session.save(obj);                                        处于生命周期              转化为持久状态

Long id=obj.getId();
obj=null;
Object obj2=(Object)session.load(Object.class,id);        处于生命周期             处于持久化状态
tx.commit();                                                         

session.close();                                          处于生命周期              转变成游离状态

System.out.print(obj2.getName());                         处于生命周期               处于游离状态

obj2=null;                                                结束生命周期               结束生命周期

 4                                     cascade属性
    cascade属性值                                             描述
     none                                    在保存更新时,忽略其他关联对象,他是cascade默认属性
     save-update                             当通过Session的save(),update()以及saveOrUpdate()方法来保存
                                             或更新当前对象时,及联保存所有关联的新建的临时对象,并且及联更新所有关联的游离对象
     delete                                  当通过session的delete()方法删除当前对象时,及联删除所有对象
     all                                     包含save-update及delete行为,此外对当前对象执行evict()或lock
                                             ()操作时,也会对所有关联的持久化对象执行evict()或lock()操作
     delete-orphan                           删除所有和当前对象解除关联关系的对象
     all-delete-orphan                       包含all和delete-orphan

 5             Hibernate映射类型,对应的java基本类型及对应的标准SQL类型
      Hibernate 映射类型               java类型                     标准SQL类型
       integer或者int                  int                          INTEGER
       long                            long                         BIGINT
       short                           short                        SMALLINT
       byte                            byte                         TINYINT
       float                           float                        FLOAT
       double                          double                       DOUBLE
       big_decimal                     java.math.BigDecimal         NUMERIC
       character                       char and string              CHAR
       string                          string                       VARCHAR
       boolean                         boolean                      BIT
     
              Hibernate映射类型,对应的java时间和日期类型及对应的标准SQL类型
     映射类型           java类型                     标准SQL类型             描述
      date       java.util.Date或者java.sql.Date        DATE         代表日期,YYYY-MM-DD
      time       java.util.Date或者java.sql.Date        TIME         代表时间,形式为HH:MM:SS
      timestamp  java.util.Date或者java.sql.Timestamp   TIMESTAMP    代表日期和时间,YYYYMMDDHHMMSS
      calendar   java.util.Calendar                     TIMESTAMP    同上
   calendar_date java.util.Calendar                     DATE         代表日期,YYYY-MM-DD

 6                           JAVA大对象类型的Hibernate映射类型
   映射类型             java类型                 标准SQL类型           MYSQL类型           ORALCE类型
   binary                byte[]                 VARBINARY(或BLOB)      BLOB                  BLOB
   text                  string                 CLOB                   TEXT                  CLOB
   serializable          实现Serializable       VARBINARY(或BLOB)      BLOB                  BLOB
                         接口任意一个java类
   clob                  java.sql.Clob          CLOB                   TEXT                  CLOB            
   blob                  java.sql.Blob          BLOB                   BLOB                  BLOB
   例:
a  Session session=sessionFactory.openSession();
   Transaction tx=session.beginTransaction();
   Object obj=new Object();
   obj.setFile(Hibernate.createClob(" "));
   session.save(obj);
   session.flush();
   //锁定这条纪录
   session.refresh(obj,LocakMode.UPGRADE);
   oracle.sql.CLOB clob=(oracle.sql.CLOB)obj.getFile();
   //把长文本数据放入Clob中
   Writer pw=clob.getCharacterOutputStream();
   pw.write(longText);//longText标识长度超过255的字符串
   pw.close();
   tx.commit();
   session.close();

b  InputStream in=this.getClass().getResourceAsStream("photo.gif");
   byte[] buffer=new byte[in.available()];
   in.read(buffer);
   set

 7                     映射文件中用于设定检索策略的几个属性

    属性           可选值            默认值                                描述
    lazy          true,false         false               如为true,表延迟索引,在<class><set>中包含此属性
  outer-join     auto,true,false     在<many-to-one>     如为true,表迫切左外连接检索策略,在<many-to-one>
                                       <one-to-one>      <one-to-one>和<set>元素中包含此属性
                                     元素为auto,在<set>
                                     元素中为false
  batch-size     正整数               1                 设定批量检索的数量,合理取值在3-10间.
                                                        仅适用于关联级别的立即检索和延迟检索,在<class><set>元素中包含此属性
  caonstrained                          true            <one-to-one>中的元素,与<many-to-one>的not null
                                                        在语义上有些相似,它表明对象之间必须关联.

 8                                 HQL和QBC支持的各种运算

运算比较         HQL运算符                       QBC运算方法                        含义
                  =                             Expression.eq()                    等于
                  <>                            Expression.not(Expression.eq())    不等于
                  >                             Expression.gt()                     大于
                  >=                            Expression.ge()                    大于等于
 比较运算         <                             Expression.lt()                     小于
                  <=                            Expression.le()                     小于等于
                  is null                       Expression.isNull()                 等于空值
                  is not null                   Expression.isNotNull()              非空值

 范围运算         in(列表)                      Expression.in()                   等于列表中的某一值
                  not in(列表)                  Expression.not(Expression.in())  不等于列表中的任意一值
                  between 值1 and 值2           Expression.between()           大于等于1并小于等于2
                  not between 值1 and 值2       Expression.not(Expression.between) 小于值1或者大于值2

 字符串模式匹配   like                          Expression.like()                  字符串模式匹配
 逻辑运算         and                           Expression.and()
                                                Expression.conjunction()           逻辑与
                  or                            Expression.or()
                                                Expression.disjunction()           逻辑或
                  not                           Expression.not()                   逻辑非
引申:Expression.eq("name","tom").ignoreCase();不区分大小写

  9                       expression.MatchMode类包含的各个静态常量实例
         匹配模式                                               举例
    MatchMode.START                Expression.like("NAME","T",MatchMode.StART)姓名以T开头
    MatchMode.END                  Expression.like("NAME","T",MatchMode.END)姓名以T结尾
    MatchMode.ANYWHERE             Expression.like("NAME","T",MatchMode.ANYWHERE)姓名包含T
    MatchMode.EXACT                Expression.like("NAME","Tom",MatchMode.SEXACT)姓名必须是Tom

 10 ex:
       Iterator it=session.createQuery("select c.name,count(c) from object").list.iterator();
       while(it.hasNext()){
         Object[] pair=(Object[])it.next();
         String name=(String)pair[0];
         Integer count=(Integer)pair[1];
       }

 11 集合过滤
   Session的createFilter()方法用来过滤集合,它具有以下特点.
   a 它返回Query类型的实例
   b 它所处的对象必须处于持久化状态
   c 它的第二个参数指定过滤条件,它由合法的HQL语句组成
   d 不管持久化对象的集合是否已经被初始化,Query的list方法都会执行SQL查询语句,到数据库中检索关联对象
   e 如对象中的集合已被初始化,为保证Session中缓存不出现id相同的集合对象,Query的list不会在创建集合对象
     仅仅返回已经存在的集合对象的引用
   f 如对象中的集合对象未被初始化,Query的list()方法会创建相应的(集合名)对象,但不是初始化对象的对象集合

 12 子查询的应用
   all 表示子查询语句返回的所有纪录
   ex:返回所有订单价格都小于100的客户
   from Customer c where 100>all(select o.price from c.orders o)
   any 表示子查询语句返回的任意一条纪录
   ex:返回一条订单价格小于100的客户
   from Customer c where 100>any(select o.price from c.orders o)
   some 与any等价
   in 与=any等价
   ex:返回一条订单价格等于100的客户
   from Customer c where 100=any(select o.price from c.orders o)
   from Customer c where 100=some(select o.price from c.orders o)
   from Customer c where 100 in (select o.price from c.orders o)
   exists 表示自查询语句至少返回一条纪录
   ex:返回至少有一条的订单客户
   from Customer c where exists (select c.orders)
   
   如果子查询语句是一个集合,可采用
   from  Customer c where :order in elements(c.orders)====(from c.orders)

13 HQL操纵集合的函数或属性
   size()函数或size属性:获得集合元素的数目
   minIndex()函数或minIndex属性:对于建立了索引的集合,获得最小索引
   maxIndex()函数或maxIndex属性:对于建立了索引的集合,获得最大索引
   minElement()函数或minElement属性:对于包含基本类型元素的集合,获得集合中取值最小的元素
   maxElement()函数或maxElement属性:对于包含基本类型元素的集合,获得集合中取值最大的元素
   elements()函数:获得集合中的所有元素
   ex:from Customer c where c.orders.size>0  or from Customer c where size(c.orders)>0

14 在映射文件中配置SQL语句
<sql-query name="findCustomerAndOrders"><![CDATA[
  select {c.*},{o.*} from CUSTOMERS c inner join ORDERS o where C.ID=o.CUSTOMER_ID]]>
  <return alias="c" class="Customer"/>
  <return alias="o" class="Order"/>
</sql>

                                  比较HQL与QBC的优缺点
   比较方面                            HQL检索方式                          QBC检索方式
   可读性                 优点:和SQL查询语句较接近,易读             肢解成Criterion实例,可读性差
   功能                   优点:功能最强大,支持各类查询             不支持报表查询,子查询,连接查询也受限
   查询语句形式           缺点:应用程序必须提供基于字符串的HQL语句  优点:提供了更加面向对象的接口
   何时被解析             缺点:HQL只有在运行时才被解析              优点:更易排错
   可扩展性               缺点:不具有扩展性                         优点:允许用户扩展Criterion接口
   对动态查询语句的支持   缺点:支持动态语句但编成麻烦               优点:适合生成动态查询

15                                  Hibernate中的事务
   session.disconnect(); 释放数据库连接
   session.reconnect();  重新获得数据库连接
   对于同时运行的多个事务,当这些事务访问数据库中相同的数据时,如果没有采取必要的隔离机制,就会导致各类问题并发.可归纳为以下几类
   a 第一类丢失更新:撤销一个事务时,把其他事务已提交的更新覆盖.
   b 脏读:一个事务读到另一事务未提交的更新数据
   c 虚读:一个事务读到另一事务已提交的新插入的数据
   d 不可重复读:一个事务读到另一事务以提交的更新数据
   e 第二类丢失更新:这是不可重读中的特例,一个事务覆盖另一事务已提交的更新数据.