Hibernate基础总结

整体结构

一、Hibernate相关的API

1. configuration ，到src下面找到名称hibernate.cfg.xml配置文件，创建对象，把配置文件放到对象里面（加载核心配置文件）;
2. sessionFactory ，使用configuration对象创建sessionFactory对象；

• （1）创建sessionfactory过程中做事情：
  • 根据核心配置文件中，有数据库配置，有映射文件部分，到数据库里面根据映射关系把表创建;
• （2）创建sessionFactory过程中，这个过程特别耗资源的：
  • 在hibernate操作中，建议一个项目一般创建一个sessionFactory对象；
• （3）具体实现：
  • 写工具类，写静态代码块实现，静态代码块在类加载时候执行，执行一次；

3. session ，类似于jdbc中connection；

• （1）调用session里面不同的方法实现crud操作：
  • 添加 save方法；
  • 修改 update方法；
  • 删除 delete方法；
  • 根据id查询 get方法；
  • Load方法，根据ID查，（返回的是代理，不会立即访问数据库）；
  • saveOrUpdate,merge（根据ID和version的值来确定是save或update）,调用merge你的对象还是托管的；
  • lock（把对象变成持久对象，但不会同步对象的状态）；
• （2）调用session里面不同的方法实现crud操作：
  • session对象单线程对象

4. Transaction 事务；

• （1）事务提交和回滚方法
  • 事务开启：Transaction tx = session.beginTransaction();
    事务提交：tx.commit();
    事务回滚：tx.rollback();
• （2）事务概念
  • 事务四个特性
    • 原子性（事务不可再被分割）；
    • 一致性（数据操作前后是一致的）；
    • 隔离性（多个事务同时调用一条记录时互不干扰）；
    • 持久性（提交到数据库才算持久对象） ；

5. Query，Qyuery主要用于Hibernate执行hql语句。

• hql语句：hibernate提供的面向对象的查询语句，使用对象（类）和属性进行查询，区分大小写。

• 获得Query对象：Query query = session.createQuery(“hql”)

6. Criteria实际上是个条件附加的容器，如果想要设定查询条件，则要使用org.hibernate.criterion.Restrictions的各种静态方法传回org.hibernate.criterion.Criteria实例，传回的每个org.hibernate.criterion.Criteria实例代表着一个条件：

Criteria criteria = session.createCriteria(User.class); criteria.add(Restrictions.gt("age", new Integer(20))); criteria.add(Restrictions.lt("age", new Integer(40))); List users = criteria.list(); 

二、集合属性

• Set
  • HashSet 无序，不重复
• List
  • 有序，可重复，使用List时，配置文件中可以使用Bag标签
• Map
  • 键值对
  • HashMap 无序，不重复（以key为准）
• 注意：
  • 使用集合属性时，一定要使用接口，而不能声明为具体的实现类。
    因为经过Session操作后，集合就变成了Hibernate自己的集合实现类。
  • 值类型的集合，集合元素是普通类型
  • 实体类型的集合，集合元素是另一个实体

三、关联关系

1. 单向多对一

public class Person{ private int pid; private String name; private Address address; ...//生成相应的getter、setter方法 } 

public class Address{ private int id; private String detail; ...//生成相应的getter、setter方法 } 

这里我们需要维护的关系是多个Person可以对应同一个地址,使用单向的多对一，映射我们只需要在多的一端加入一个外键指向一的一端即可

 <class name="Person"> <id name="id"> <generator class="native"/> </id> ...//部分字段配置省略 <many-to-one name="address" column="addressId"/>//关键配置 </class> 

这样配置以后hibernate就会帮我们在多的一端（Person）添加一个外键addressId指向一的一端；
2. 单向多对一单向一对多
看代码,我们知道一个班级有多名学生，这就是一个典型的一对多关系

public class Classes { private int id; private String name; private Set students; ...//生成相应的getter、setter方法 } 

public class Student { private int id; private String name; ..//生成相应是getter、setter方法 } 

映射原理:一对多关联映射，在多的一端添加一个外键指向一的一端,它维护的关系是一指向多

<class name="Classes" table="t_classes"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <set name="students"> <key column="classesid"/>//在一的一端添加的外键指向多的一端(默认情况下市主键匹配) <one-to-many class="xxx.Student"/>//注意它维护的是一指向多的关系 </set> </class> 

3. 单向一对一
   可以采用标签，指定多的一端的unique=true，这样就限制了多的一端的多重性唯一；
   通过这种手段映射一对一唯一外键关联，配置文件只需要修改为:

<many-to-one name="address" column="addressId" unique="true"/> 

4. 单向多对多
   先看两个POJO

public class User { private int id; private String name; private Set roles; ..//生成相应的getter、setter方法 } 

public class Role { private int id; private String name; ..//生成相应的getter、setter方法 } 

现在需要映射这样的多对多关系，一个User可以有多个Role，而一个Role有可以被多个User所拥有
这样我们就可以将一个多对多关系拆分为两个多对一的关系

<class name="xxx.User" table="t_user"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <set name="roles" table="t_user_role"> <key column="userid"/> <many-to-many class="xxx.Role" column="roleid"/> </set> </class> 

这样我们的关系的明确了
t_user t_user_role t_role
id name < ——-userid roleid —– > id name
5. 双向一对多
上面提到了单向的1-N在一的一端添加的外键指向多的一端即可,对于双向的1-N则类似于N-N，集合元素中不使用
元素映射关联属性，而使用元素，但是为了保证一的一端，因此需要增加unique=”true”属性

<class name="xxx.Classes" table="t_classes"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <set name="students"> <key column="classesid"/> <many-to-many class="xxx.Student" unique="true"/> </set> </class> 

6. 双向一对一
   双向的一对一关联有两种形式:
   （1）、基于外键的双向一对一关联
   我们可以回想一下上面提到的单向一对一映射,它是有N-1的一个特例，只需要在标签多的一端添加unique=”true”属性就可以形成单向的1-1映射关系,那么该怎么样将这种映射改为双向的呢?
   下面我们再举个例子：一个User必须要有一个唯一的identityId
   首先创建两个POJO类

public class Person { private int id; private String name; private IdentityId identityId; ..//生成相应的getter、setter方法 } 

public class IdentityId { private int id; private String cardNo; private Person person; ..//生成相应的getter、setter方法 } 

<class name="xxx.Person" table="t_person"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <many-to-one name="identityId" class="xxx.IdentityId" unique="true"/> </class> 

<class name="xxx.IdentityId" table="t_identity"> <id name="id"> <generator class="native"/> </id> <property name="cardNo"/> <one-to-one name="person" class="xxx.Person" property-ref="identityId"/> </class> 

注意：这里的property-ref属性为identity表明建立了从identity对象到person对象的关联.
因此只要调用identity持久化对象的getIdentityId()方法就可以导航到Person对象 由此可见：
Person对象和IdentityId对象之间为双向的关联关系person.getIdentityId().getPerson()；
（2）、基于主键的1-1双向关联
上面的POJO类不需要有任何变化，我们只需要修改配置文件

<class name="xxx.Person" table="t_person"> <id name="id" column="ID"> <generator class="foreign"> <param name="property">identityId</param> </generator> </id> <property name="name"/> <one-to-one name="identity" clsss="xxx.IdentityId" constrained="true"/> </class> 

注意：这里的constrained=”true”表明Person表的主键ID同时作为外键参考IdentityId表

<class name="xxx.Identity" table="t_identity"> <id name="id"> <generator class="native"/> </id> <property name="cardNo"/> <one-to-one name="person" class="xxx.Person"/> </class> 

注意：这里Person表中ID既是主键同时还作为外键参照表IdentityId,因为使用了foreign标识符生成策略Hibernate就保证了Person
对象与关联的IdentityId对象共享一个主键
7. 双向多对多
双向的多对多映射需要在两边都增加集合元素，用于映射集合属性
修改上面的单向N-N映射
在Role中添加集合属性

public class Role { private int id; private String name; privarte Set user ..//生成相应的getter、setter方法 } 

<class name="xxx.User" table="t_user"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <set name="roles" table="t_user_role"> <key column="userid"/> <many-to-many class="xxx.Role" column="roleid"/> </set> </class> 

<class name="xxx.Role" table="t_role"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <set name="users" table="t_user_role" order-by="userid"> <key column="roleid"/> <many-to-many class="xxx.User" column="userid"/> </set> </class> 

• 注意点:
  • 双向多对多关联两边都需要指定连接表的表名和外键列的列名
  • 两个集合元素Set的table值必须指定,而且需要相同

四、主配置

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"     "https://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory name="mysqldb"> <!-- 配置方言：选择数据库类型 --> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 配置数据库连接信息 --> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql:///test?characterEncoding=utf8</property> <property name="connection.username">root</property> <property name="connection.password">123456</property> <!-- 允许显示sql语句 --> <property name="show_sql">true</property> <!-- 导入映射文件 --> <mapping resource="com/mypro/domain/Person.hbm.xml" /> </session-factory> </hibernate-configuration> 

1. 方言
   < property name=“dialect”>

<property name="dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 指定数据库类型为Mysql --> <property name="dialect">hibernate.dialect org.hibernate.dialect.OracleiDialect</property> <!-- 指定数据库类型为Oracle --> <property name="dialect">hibernate.dialect org.hibernate.dialect.SQLServerDialect</property> <!-- 指定数据库类型为Sql Server --> 

2. < property name=“connection.driver_class”>：配置数据库驱动

<property name="connection.driver_class">com.mysql.jdbc.Driver</property> 

3. < property name=“connection.url”>：配置数据库的url

<property name="connection.url">jdbc:mysql:///test?characterEncoding=utf8</property> 

4. < property name=“connection.username”>：配置数据库登录名

<property name="connection.username">root</property> 

5. < property name=“connection.password”>：配置数据库登录密码

<property name="connection.password">123456</property> 

6. < property name=“hibernate.hbm2ddl.auto”>

• 该属性有4个值
  　　a、create-drop:表示在hebarinate初始化时创建表格,程序运行结束的时候会删除相应的表格，在实际项目中不用
  　　b、create：在hibernate初始化时会创建表格，在运行结束之后不删除表格，而是在下一次运行的时候如果有旧的先删掉再创建，没有旧的，直接创建
  　　c、update：加载hibernate自动更新数据库结构，如果没有表，则创建，如果有，且有更新，则直接更新，没有更新，则不变化
  　　d、校验映射文件和数据库中的表是不是能对应起来，不能对应报错，实际中常用
  　　总之请慎重使用此参数，没必要就不要随便用。

7. 其它

<!-- 允许显示sql语句 --> <property name="show_sql">true</property> <!-- 格式化sql语句 --> <property name="format_sql">true</property> <!-- 设置连接池大小 --> <property name="connection.pool.size">20</property> <!--jdbc.fetch_size是指Hibernate每次从数据库中取出并放到JDBC的Statement中的记录条数。FetchSize设的越大，读数据库的次数越少，速度越快，Fetch Size越小，读数据库的次数越多，速度越慢--> <property name="jdbc.fetch_size">50</property> <!--jdbc.batch_size是指Hibernate批量插入,删除和更新时每次操作的记录数。BatchSize越大，批量操作的向数据库发送Sql的次数越少，速度就越快，同样耗用内存就越大--> <property name="jdbc.batch_size">23</property> <!--connection.useUnicode连接数据库时是否使用Unicode编码--> <property name="Connection.useUnicode">true</property> <!--connection.characterEncoding连接数据库时数据的传输字符集编码方式-->   <propertynamepropertyname="connection.characterEncoding">gbk</property> 

（未完待续…）