Hibernate核心文件

1.hibernate.cfg.xml文件
1.1 JDBC连接
hibernate.connection.driver_class、hibernate.connection.url
hibernate.connection.username、hibernate.connection.password
hibernate.connection.pool_size
1.2 配置C3P0连接池
hibernate对C3P0提供了内嵌支持，可直接配置和使用

     <!-- 设置C3P0连接池最大连接数 -->
     <property name="hibernate.c3p0.max_size">50</property>
     <!-- 设置C3P0连接池最小连接数 -->
     <property name="hibernate.c3p0.min_size">1</property>
     <!-- 设置C3P0连接池中连接的超时时长，超时则抛出异常，单位：ms -->
     <property name="hibernate.c3p0.timeout">1000</property>
     <!-- 设置C3P0缓存Statement的数量 -->
     <property name="hibernate.c3p0.max_statements">50</property>

1.3 配置JNDI数据源
JNDI常见用途：数据源配置、JMS相关配置等。
Hibernate中除了可以通过JDBC连接数据库外，还可以通过JNDI配置数据源，与数据库建立连接。
JNDI数据源常用连接属性：
属性名 ： 用途
hibernate.connection.datasource ： 数据源JNDI名称
hibernate.connection.username ： 数据库用户名（可选）
hibernate.connection.password ： 数据库密码（可选）
hibernate.jndi.url ： JNDI提供者的URL（可选）
hibernate.jndi.class ： JNDI InitialContextFactory的实现类（可选）
1.4 Hibernate二级缓存属性
Hibernate共有两级缓存，第一级为Session级的缓存（事务范围的缓存），可以由Hibernate自动管理.
第二级缓存是由SessionFactory管理的（进程级缓存），可在hibernate.cfg.xml配置文件中进行配置和更改，而且可以
动态加载和卸载。
配置Hibernate二级缓存所需属性：

1.5 Hibernate事务属性
Hibernate依赖于JDBC或JTA的事务管理功能。默认采用JDBC的事务管理，可在文件中配
置hibernate.transaction.factory_class属性来指定Transaction的工厂类别。
与事务相关的属性：

      //使用JDBC的事务处理机制
      <property name="hibernate.transaction.factory_class">  
      net.sf.hibernate.transaction.JDBCTransactionFactory</property>
      //使用JTA的事务处理机制
      <property name="hibernate.transaction.factory_class">  
      net.sf.hibernate.transaction.JTATransactionFactory</property>

2.映射文件xxx.hbm.xml
2.1 文件结构

    <!-- hibernate-mapping定义了xml配置文件的基本属性 -->
    <hibernate-mapping>
      <!-- （声明持久化类）name指定持久化类的类名，table指定数据表的表名 -->
      <class name=" " table=" ">
        <!-- 标识属性（数据库主键列） -->
        <id name=" " type=" " column=" ">
          <!-- 主键生成方式 -->
          <generator class=" "/>
        </id>
        <property name=" " type=" " column=" " length=" "/>
      </class>   
    </hibernate-mapping>

2.2 映射集合属性
（1）集合类介绍
顶层接口：java.util.Collection、java.util.Map
子接口：java.util.Set、java.util.List、java.util.SortedSet、SortedMap
实现类：TreeSet、HashSet、LinkedHashSet
ArrayList、LinkedList
ArrayList底层使用的是Object数组，查询速度快，但是增加、删除元素时速度慢
LinkedList底层是以链表形式存储，增加和删除元素速度快，但是查询速率低。
TreeMap、HashMap、LinkedHashMap
（2）持久化集合类
Hibernate中声明持久化集合时必须声明为接口（顶层接口或子接口）；可以是自定义接口，但必须
实现org.hibernate.usertype.UserCollectionType接口。
（3）集合映射

（4）集合外键
（5）集合元素的数据类型
（6）索引集合类

          <map-key>:映射任何基础类型的索引及Map集合索引。
          <map-key-many-to-many>:映射Map集合和实体引用的索引字段。
          <list-index>:映射list集合和数组的索引字段。
          <composite-map-key>:映射Map集合和复合类型的索引字段。

（7）集合类映射

2.3 Hibernate关联关系映射
2.3.1单向的一对一关联
（1）通过主键关联
从表不能拥有自己的主键生成策略；需在从表类中定义一个主表实体属性并在映射文件中添加配置信息：

          <id name="congbiao_id" type="int" column="CongBiao_id">
             <generator class="foreign">
               <param name="property">zhubiao</param>
             </generator>
          </id>
          ...
          <one-to-one name="zhubiao" class="主表类" constrained="true"/>

  （2）通过外键关联
      在从表配置文件中添加配置信息：

          <many-to-one name="主表类实例" class="主表类" unique="true">
             <column name="ZhuBiao_id"/>
          </many-to-one>

2.3.2单向的一对多关联
      在表示多的一方的数据表中增加一个外键，并由“一”的一方指向“多”的一方。
      “一”：User类；“多”：Address类
      在User类中添加如下代码：

           //集合属性保存关联实体
           private Set<Address> addresses=new HashSet<Address>();
           //Address属性的getter和setter方法

     User类映射文件中添加如下代码：

         <set name="addresses" table="address" inverse="false" lazy="true">
            <key>
              <column name="user_id"/>     <!-- 确定关联的外键列 -->
            </key>
            <one-to-many class="Address"/>  <!-- 映射到关联类属性 -->
         </set>

 2.3.3单向多对一关联
       “一”的一方为主表，“多”的一方为从表;“多”的一方数据表中增加一个外键。
       “多”：User；“一”：Address
       User类添加如下代码：

            private Address address;  //User类的关联实体属性
            //getter,setter方法

       User类映射文件添加如下配置：

            <many-to-one name="address" class="Address" fetch="join">
                <column name="address_id"/>
            </many-to-one>

 2.3.4单向的多对多关联
      利用中间表将两个主表联系起来，中间表将两个主表的主键作为其外键，建立映射关系。
      在主控端的类定义中增加一个Set集合属性，使被关联一方的类实例以集合形式存在。

           //User类添加如下代码
           private Set<Address> addresses=new HashSet<Address>();

       User类映射文件添加如下代码：

            <set name="addressss" table="user_address" inverse="false" lazy="true">
               <key>
                 <column name="user_id"/>
               </key>
               <many-to-many class="Address" column="address_id"/>
            </set>

 2.3.5双向一对一关联
    （1）通过主键关联
        一方的主键生成策略配置成foreign;

            //User类添加代码
            private Address address;
            //Address类添加代码
            private User user;

       User类配置文件添加代码：

           <one-to-one name="address" class="Address" cascade="all">
           </one-to-one>

       Address类配置文件添加代码：

           <id name="addressId" type="int" access="field">
              <column name="address_id/>
              <generator class="foreign">
                <param name="property">user</param>
              </generator>
           </id>
           ...
           <one-to-one name="user" class="User" constrained="true">
           </one-to-one>

  （2）通过外键关联
      存放外键一方为从表；

            //User类添加代码
            private Address address;
            //Address类添加代码
            private User user;

      User类（主表）映射文件添加代码：

          <one-to-one name="address" cascade="all"/>

      Address类映射文件添加信息：

          <many-to-one name="user" class="User" fetch="select" unique="true">
            <column name="user_id"></column>
          </many-to-one>

 2.3.6双向一对多关联（实际上与双向多对一一样）
      “一”：user表；“多”：address表

          //User类添加代码：
          private Set<Address> addresses = new HashSet<Address>();
          ...
          //Address类添加代码：
          private User user;
          ...

     User类映射配置文件添加信息：

         <set name="addresses" table="address" inverse="true" lazy="true">
            <key>
              <column name="user_id"/>     <!-- 确定关联的外键列 -->
            </key>
            <one-to-many class="Address"/>  <!-- 映射到关联类属性 -->
         </set>

    Address类映射配置文件添加信息：

        <many-to-one name="user" class="User" fetch="join">
           <column name="user_id" not-null="true"/>
        </many-to-one>

2.3.7双向多对多关联
     使用中间表来实现两个实体间的关联关系     

         //User类添加代码：
          private Set<Address> addresses = new HashSet<Address>();
          ...
         //Address类添加代码：
          private Set<User> users = new HashSet<User>();
          ...

    User类映射文件添加代码：    

         <set name="addressss" table="user_address" inverse="true">
               <key>
                 <column name="user_id"/>
               </key>
               <many-to-many class="Address" column="address_id"/>
         </set>

    Address类映射文件添加代码：    

         <set name="users" table="user_address">
               <key>
                 <column name="address_id"/>
               </key>
               <many-to-many class="User" column="user_id"/>
         </set>