hibernate框架

hibernate框架

一.hibernate介绍

1.  **什么是hibernate**

 - Hibernate是一个开放源代码的对象关系映射框架（ORM）
 - 它对JDBC进行了非常轻量级的对象封装（消耗资源少）
 - 它将POJO与数据库表建立映射关系，是一个全自动的orm框架
 - Hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 
 - Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用


 - 具有数据库兼容性

2. **下载地址**

* [官网](http://hibernate.org/orm/)
* [下载](https://sourceforge.net/projects/hibernate/files/hibernate-orm/)

本教程使用的版本:

​```
hibernate-release-3.2.0.Final
​```

3. **什么是ORM**

- 对象-关系映射（Object Relational Mapping）
- 把对象模型表示的对象映射到基于SQL 的关系模型数据库结构中去。
- 操作实体对象的时候，不需要和复杂的SQL语句打交道，只需简单的操作实体对象的属性和方法

​```
Java对象    -->     关系数据库
-----------------------------
属性        -->     字段
对象        -->     记录
​```

二.hibernate环境搭建

创建数据库表
下载并布署jar包
配置hibernate.cfg.xml文件

在src下引入该文件并配置

 <?xml version="1.0"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
    <session-factory>
        <!--  MySQL 数据库信息,name是约定值，不能改变-->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
           <property name="connection.url">jdbc:mysql://localhost:3306/javaee</property>
           <property name="connection.username">root</property>
           <property name="connection.password">tiger</property>
           <property name="dialect">org.hibernate.dialect.MySQLDialect</property>   
           <!--显示sql语句-->
        <property name="show_sql">true</property>
        <!--使显示的sql语句格式化-->
        <property name="format_sql">true</property>
        <!--引入的映射对象的xml文件的全路径及文件名-->
        <mapping resource="model/User.hbm.xml"/>
    </session-factory>
    </hibernate-configuration>

4创建持久化类并配置mapper.xml映射文件
持久化类

public class User implements Serializable{

private Integer id;
private String username;
private String password;
private Integer gender;
private Integer age;
private String address;
//省略getter和setter方法
}

配置User.mapper.xml文件
注意:mapper.xml文件最好引在model包中,命名格式类名.hbm.xml的形式

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!-- 对像关系映射配置 -->
<hibernate-mapping>
<!--类和表的映射  -->
<class name="model.User" table="USER">
    <!-- 主键的映射 -->
    <id name="id" column="ID"></id>
    <!--其他字段的映射  -->
    <property name="username" column="USERNAME"></property>
    <property name="password" column="PASSWORD"></property>
    <property name="age" column="AGE"></property>
    <property name="gender" column="GENDER"></property>
    <property name="address" column="ADDRESS"></property>
</class>
</hibernate-mapping>

5使用hiberanteAPI进行CRUD操作

• 1工具类

public class DBUtil {
static SessionFactory sf;
static {
    //1.初始化hibernate.cfg.xml文件
    Configuration cfg = new Configuration().configure("hibernate.cfg.xml");
    //2.创建SessionFacotry工厂
    sf =cfg.buildSessionFactory();
}
//获取session
public static Session findSession(){    
    //老版本用法,现推荐使用getCurrentSession()
    return sf.openSession();    
}
}

2 工具类2

public class DBUtil {
static SessionFactory sf;
static {
    //1.初始化hibernate.cfg.xml文件
    Configuration cfg = new Configuration().configure("hibernate.cfg.xml");
    //2.创建SessionFacotry工厂
    sf =cfg.buildSessionFactory();
}
//获取session
public static Session findSession(){    

    return sf.getCurrentSession();  
}
}

注意:
​ 使用getCurrentSession(),在方法中无需手动关联session.因为当提交事务时,会自动关联session
​ 使用getCurrentSession(),查询时也需要事务支持
​ 使用getCurrentSession()获取session时,必须和线程绑定,需要在hibernate.cfg.xml文件中配置. 如下:
1 <property name="current_session_context_class">thread</property>

注:上述属性的取值有 thread(常用) | jta | custom | managed
其中jta是分布式配置,管理事务任务由中间件提供,如webLogic,JBoss等,Tomcat不支持

3 工具类3
使用ThreadLocal对像管理Session

public class DBUtil {  
 public static final ThreadLocal local =new ThreadLocal();  
 public static final SessionFactory sessionFactory;  
 static {  
     try {  
         sessionFactory = new Configuration().configure().buildSessionFactory();  
     }catch(Throwable ex) {  
         throw new ExceptionInInitializerError(ex);  
     }      
 }  

 public static Session currentSession() throws HibernateException {  
     Session session = local.get();  
     if(session == null) {  
       session = sessionFactory.openSession();  
       local.set(session);  
     }  
     return session;  
 }  
 public static void closeSession() throws HibernateException {  
     Session session = local.get();  
     if(session != null) {  
         session.close();  
     }  
     local.set(null);  
 }  
}  

4 CRUD操作

增
public void insert(User user){
    Session session  = DBUtil.findSession();
    //开启事务
    Transaction tx = session.beginTransaction();
    try {
        session.save(user);
        //提交事务
        tx.commit();
    } catch (Exception e) {
        e.printStackTrace();
        //回滚
        tx.rollback();
    }finally{
        //关闭资源
        session.close();
    }
}

删
public void delete(User user){
    Session session  = DBUtil.findSession();
    //开启事务
    Transaction tx = session.beginTransaction();
    try {
        session.delete(user);
        //提交事务
        tx.commit();
    } catch (Exception e) {
        e.printStackTrace();
        //回滚
        tx.rollback();
    }finally{
        //关闭资源
        session.close();
    }
}

改
public void update(User user){
    Session session  = DBUtil.findSession();
    //开启事务
    Transaction tx = session.beginTransaction();
    try {
        session.update(user);
        //提交事务
        tx.commit();
    } catch (Exception e) {
        e.printStackTrace();
        //回滚
        tx.rollback();
    }finally{
        //关闭资源
        session.close();
    }
}

查
public User selectById(Integer id){
    Session session  = DBUtil.findSession();
    User user = (User) session.get(User.class, id);
    session.close();
    return user;
}

1单元测试
public class HibernateTest {
UserDao dao;
@Before
public void init(){
    dao = new UserDao();
}
//查
@Test
public void select() {
    User user = dao.selectById(1);
    System.out.println(user);
    System.out.println(user.getId()+","+user.getUsername()+","+user.getPassword());
}
//删
@Test
public void delete(){
    User user = new User();
    user.setId(12);
    dao.delete(user);
}
//增
@Test
public void insert(){
    User user = new User();
    user.setUsername("admin");
    user.setPassword("123456");
    dao.insert(user);
}
//改
@Test
public void update(){
    User user = new User();
    user.setId(1);
    user.setUsername("admin");
    user.setPassword("000000");
    dao.update(user);
}
}

    三.hibernate管理对像的三种状态和相互转化方式
    
    瞬时态(Transient)
    
    内存中有该对像的OID,数据库中没有
    
    持久态(Persistent)
    
    内存中有该对像的OID,Session中有该对像的OID,数据库中也有该对像对应的记录
    
    游离态(Detached)
    
    内存中有该对像的OID,Session中没有该对像的OID,数据库中有该对像对应的记录
  
 四.核心接口

Hibernate 的核心 API 一共有 6 个

**1 Configuration**

Configuration 类的作用是对 Hibernate 进行配置，以及对它进行启动。在 Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动 Hibernate 时所遇到的第一个对象。

指定配置文件的名字：例如将文件放入源码路径的 config 文件夹下

    Configuration cfg = new Configuration();
    cfg.configure();
    cfg.configure("/config/hibernate.cfg.xml");
注意事项：Configuration 对象应该只创建一个，Configuration 对象是单例的

 1. 1 SessionFactory
    SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
    
    注意事项：通常一个项目只需要创建一个
    SessionFactory，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory
1 Session

Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。
注意事项：Session 是线程不安全的对象，在项目中需要创建多个 Session 对象，一个线程就创建一个 Session 对象。

2 Transaction
Transaction 接口的作用是用于执行事务操作。
Transaction 接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。 Transaction 接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA 中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移植。

  Transaction 的方法：
/

    /开启事务
    Transaction tx = session.beginTransaction();
    //提交事务
    tx.commit();
    //回滚事务
    tx.rollback();

3 Query
Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。

后面的章节中会具体讲到这个接口。

4 Criteria

QBC 查询 - Query By Criteria
Criteria接口与Query接口非常类似，允许创建并执行面向对象的标准化查询。值得注意的是Criteria接口也是轻量级的，它不能在Session之外使用。

后面的章节中会具体讲到这个接口。


五 .hibernate的session对像中常用方法

5 insert()

对像的持久化方法,需要事务支持

6 delete()

删除对应对像的方法,需要事务支持

注意:hibernate根据对像的OID去删除对应数据
7 update()
更新对像的方法,需要事务支持
注意:hibernate根据对像的OID去更新数据
8  load()

根据对像的OID值 ,把数据库的数据加载到内存中,当使用OpenSession方式获得Session对像时,无需事务支持

而使用getCurrentSession方式获取Session对像时,需要事务支持

9 get()

根据对像的OID值 ,把数据库的数据加载到内存中,当使用OpenSession方式获得

Session对像时,无需事务支持

而使用getCurrentSession方式获取Session对像时,需要事务支持

get方法与load方法不同区别:

get方法不支持lazy加载,而load方法支持
get方法加载数据库中不存在的记录时,会返回null值,而load方法会抛出ObjectNotFoundException异常
10 saveOrUpdate()

可以理解为save和update方法的合写方式,当关联到Session中的数据有OID时,则执行update操作,否则执行insert操作.

另外,如果当数据库中没有记录时,通过update方式更新此不存在的记录,则会抛出异常,而使用saveOrUpdate方法不会抛出异常,会执行insert操作

11  merge()

使用方式如同saveOrUpdate方法

注意:当session同时关联多个对像时,且多个对像具有相同的OID时,则执行update或saveOrUpdate方法会抛出异常,这时请使用merge方法,对Session中的多个相同OID对像进行合并即可
12  flush()

刷新缓存,把内存中的对像更新到Session缓存中

13 clear()

清空缓存,把Session中的所有对像清空

14  evit()

剥离Session中对应的对像,不会清空其他对像


**六.hibernate.cfg.xml文件详解**

 1. 数据库连接参数
    
hibernate.connection.driver_class
hibernate.connection.url
hibernate.connection.username
hibernate.connection.password

2.数据库方言

org.hibernate.dialect.MySQLDialect 5.0版本使用（mysql版本5.5）
org.hibernate.dialect.MySQL5InnoDBDialect 5.2版本使用，否则无法自动建表，或有时自动建表是
​ engine=MyISAM（mysql版本5.5）

3.扩展参数

1）hibernate.show_sql : 是否输出 Hibernate 生成的 sql 语句

2）hibernate.format_sql： 是否格式化 Hibernate 生成的 sql 语句

3）hibernate.hbm2ddl.auto ： 是否需要 Hibernate 维护表结构
       update：Hibernate会维护表结构。没有表的时候创建表，有表的时候不创建，字段有更新会增加新字段，不删除原有字段。（推荐使用） create：每次
       Hibernate 都会删除原来的表，生成新的表结构。（开发环境中测试使用）
       create-drop：自动建表，每次框架运行结束都会将所有表删除。（开发环境中测试使用）
       validate：校验。不自动生成表，每次启动会校验数据库中表和实体配置是否一致，如果校验失败，则抛出异常。

**七.mappper文件(*.hbm.xml)文件详解**
1hibernate-mapping根标签
   1  package属性:设置统一的包名
   2   default-lazy属性:设置该mapper文件中全局的lazy机制.默认是true
 2.关联关系

类和类之间最普遍的联系就是关联关系
hibernate把关联关系分成 一对多(1~n),多对一(n~1),一对一(1~1),和多对多(n~n)关系
一对多关联(班级Clazz~学生Student)

类中一对多关联关系的表达(set类型)
public class Clazz {
    private Integer id;
    private String name;
    //一对多关系
    private Set<Student> stus;
    //省略getter和setter方法
}

mapper文件中一对多关系的表达
以下是Clazz.hbm.xml文件配置:
<hibernate-mapping package="model">
    <class name="Clazz" table="CLASS">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="name" column="NAME"></property>
        <!--一对多关系 -->
        <!--name指成员属性名,是对Set集合属性的描述-->
        <set name="stus" lazy="false">
            <!--外键-->
            <key column="CID"></key>
            <!--多方的类形,指定类的完全限定名-->
            <one-to-many class="Student"/>
        </set> 
    </class>
</hibernate-mapping>

类中一对多关联关系的表达(list类型)
public class Clazz {
    private Integer id;
    private String name;
    //一对多关系
    private List<Student> stus;
    //省略getter和setter方法
}

mapper文件中一对多关系的表达
以下是Clazz.hbm.xml文件配置:
<hibernate-mapping package="model">
    <class name="Clazz" table="CLASS">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="name" column="NAME"></property>
        <!--一对多关系 -->
        <!--name指成员属性名,是对list集合属性的描述-->
        <list name="stus" lazy="false">
            <!--外键-->
            <key column="CID"></key>
            <!--column指定的是数据库中标识列,该列的作用是hibernate用来维护查询到list集合中数据的排序-->
            <list-index column="_index"/>
            <!--多方的类形,指定类的完全限定名-->
            <one-to-many class="Student"/>
        </list> 
    </class>
</hibernate-mapping>

多对一关联关系(学生Student~班级Clazz)

类中关联关系表达
如下是Student类的代码
public class Student {
    private Integer id;
    private String name;
    private String password;
    private Integer age;
    private Integer sex;
    //多对一关系
    private Clazz clazz;

    //省略setter和getter
}

mapper文件中关联关系的表达
如下是Student.hbm.xml文件中配置
<hibernate-mapping package="model" default-lazy="false">
    <class name="Student" table="STUDENT">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="name" column="NAME"></property>
        <property name="password" column="PASSWORD"></property>
        <property name="age" column="AGE"></property>
        <property name="sex" column="SEX"></property>
        <!-- 多对一 -->
        <many-to-one name="clazz" column="CID" class="Clazz" ></many-to-one>
    </class>
</hibernate-mapping>

一对一关联关系(学生Student~学生证IDCard)
主键关联(这里以Student关联IDCard为例)
Student类中一对一关系的表达
public class Student {
    private Integer id;
    private String name;
    private String password;
    private Integer age;
    private Integer sex;
    /*
     * 一对一关联:主键关联
     * 通过左外连方式实现查询
     */
    private IDCard card;//学生证类

    //省略setter和getter方法
}

mapper文件中主键一对一关联关系表达
以下是Student.hbm.xml文件配置
<hibernate-mapping package="model" default-lazy="false">
    <class name="Student" table="STUDENT">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="name" column="NAME"></property>
        <property name="password" column="PASSWORD"></property>
        <property name="age" column="AGE"></property>
        <property name="sex" column="SEX"></property>
        <!-- 一对一:主键关联 -->
        <!--name:指定类中对应关联属性的名字-->
        <one-to-one name="card"></one-to-one>
    </class>
</hibernate-mapping>

反过来,当IDCard关联Student时, 也与上述配置一样,使用标签,指定对应关联属性即可

外键关联
Student类中一对一关系的表达(同上主键一对一方式)
mapper文件中外键一对一关联关系表达
以下是Student.hbm.xml文件配置
<hibernate-mapping package="model" default-lazy="false">
    <class name="Student" table="STUDENT">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="name" column="NAME"></property>
        <property name="password" column="PASSWORD"></property>
        <property name="age" column="AGE"></property>
        <property name="sex" column="SEX"></property>
        <!-- 一对一:外键关联 -->
        <!--name:指定类中对应关联属性的名字-->
        <!--property-ref:指定被关联方,即IDCard类中的关联属性-->
        <!--注意:这里property-ref必需指定,否则hibernate不会使用外键关联-->
        <one-to-one name="card" property-ref="stu"></one-to-one>
    </class>
</hibernate-mapping>

IDCard类中一对一关联关系表达
public class IDCard {
    private Integer id;
    private String cardname;
    //一对一关联
    private Student stu;
}

mapper文件中外键一对一关联关系表达
以下是IDCard.hbm.xml文件中的配置
<hibernate-mapping package="model">
    <class name="IDCard" table="IDCARD">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="cardname" column="CARDNAME"></property>
        <!-- 一对一:外键关联 -->
        <!--column指定外键,unique标识该关联关系是one-to-one形式  -->
        <many-to-one name="stu2" column="SID" unique="true"></many-to-one>
    </class>
</hibernate-mapping>

多对多关联关系(学生Student类~老师Teacher类)

以学生关联老师为例
Student类中的多对多关联关系表达
public class Student {
    private Integer id;
    private String name;
    private String password;
    private Integer age;
    private Integer sex;
    //多对多
    private Set<Teacher> teaches;
    //省略setter和getter
}

mapper文件中外键多对多关联关系表达
以下是Student.hbm.xml文件中的配置
<hibernate-mapping package="model" default-lazy="false">
    <class name="Student" table="STUDENT">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="name" column="NAME"></property>
        <property name="password" column="PASSWORD"></property>
        <property name="age" column="AGE"></property>
        <property name="sex" column="SEX"></property>
        <!--多对多 -->
        <!-- table中间表的名字 -->
        <set name="teaches" table="STU_TEACH">
            <!-- column:学生表关联中间表外键 -->
            <key column="SID"></key>
            <!-- column:中间表关联老师表的外键-->
            <!--class:指定被关联类model.Teacher -->
            <many-to-many column="TID" class="Teacher"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

反之,老师到学生多对多关联关系配置,亦同上一样,只需从老师到中间表,从中间表到学生表相继指定即可

3.主键生成策略

assigned

主键由外部程序负责生成，在 save() 之前必须指定一个。Hibernate不负责维护主键生成。与Hibernate和底层数据库都无关，可以跨数据库。在存储对象前，必须要使用主键的setter方法给主键赋值，至于这个值怎么生成，完全由自己决定，这种方法应该尽量避免。

<id name="id" column="id">
    <generator class="assigned" />
</id>

​ 特点：可以跨数据库，人为控制主键生成，应尽量避免。

increment

由Hibernate从数据库中取出主键的最大值（每个session只取1次），以该值为基础，每次增量为1，在内存中生成主键，不依赖于底层的数据库，因此可以跨数据库。

<id name="id" column="id">  
    <generator class="increment" />
</id>

​ Hibernate调用org.hibernate.id.IncrementGenerator类里面的generate()方法，使用select max(idColumnName) from tableName语句获取主键最大值。该方法被声明成了synchronized，所以在一个独立的Java虚拟机内部是没有问题的，然而，在多个JVM同时并发访问数据库select max时就可能取出相同的值，再insert就会发生Dumplicate entry的错误。所以只能有一个Hibernate应用进程访问数据库，否则就可能产生主键冲突，所以不适合多进程并发更新数据库，适合单一进程访问数据库，不能用于群集环境。
官方文档：只有在没有其他进程往同一张表中插入数据时才能使用，在集群下不要使用。
特点：跨数据库，不适合多进程并发更新数据库，适合单一进程访问数据库，不能用于群集环境。

hilo

hilo（高低位方式high low）是hibernate中最常用的一种生成方式，需要一张额外的表保存hi的值。保存hi值的表至少有一条记录（只与第一条记录有关），否则会出现错误。可以跨数据库。

<id name="id" column="id">
  <generator class="hilo">
    <param name="table">hibernate_hilo</param>
    <param name="column">next_hi</param>
    <param name="max_lo">100</param>
  </generator>
</id>

<param name="table">hibernate_hilo</param> 指定保存hi值的表名
<param name="column">next_hi</param> 指定保存hi值的列名
<param name="max_lo">100</param> 指定低位的最大值
也可以省略table和column配置，其默认的表为hibernate_unique_key，列为next_hi
<id name="id" column="id">
    <generator class="hilo">        
        <param name="max_lo">100</param>
    </generator>
</id>

​ hilo生成器生成主键的过程（以hibernate_unique_key表，next_hi列为例）：

1)获得hi值：读取并记录数据库的hibernate_unique_key表中next_hi字段的值，数据库中此字段值加1保存。

 2)获得lo值：从0到max_lo循环取值，差值为1，当值为max_lo值时，重新获取hi值，然后lo值继续从0到max_lo循环。

​ 3)根据公式 hi * (max_lo + 1) + lo计算生成主键值。

​ 注意：当hi值是0的时候，那么第一个值不是0*(max_lo+1)+0=0，而是lo跳过0从1开始，直接是1、2、3……那max_lo配置多大合适呢？

​ 这要根据具体情况而定，如果系统一般不重启，而且需要用此表建立大量的主键，可以吧max_lo配置大一点，这样可以减少读取数据表的次数，提高效率；反之，如果服务器经常重启，可以吧max_lo配置小一点，可以避免每次重启主键之间的间隔太大，造成主键值主键不连贯。

特点：跨数据库，hilo算法生成的标志只能在一个数据库中保证唯一。

seqhilo

与hilo类似，通过hi/lo算法实现的主键生成机制，只是将hilo中的数据表换成了序列sequence，需要数据库中先创建sequence，适用于支持sequence的数据库，如Oracle。

<id name="id" column="id">
  <generator class="seqhilo">
    <param name="sequence">hibernate_seq</param>
    <param name="max_lo">100</param>    
  </generator>
</id>

​ 特点：与hilo类似，只能在支持序列的数据库中使用。

sequence

采用数据库提供的sequence机制生成主键，需要数据库支持sequence。
如oralce、DB、SAP DB、PostgerSQL、McKoi中的sequence。
MySQL这种不支持sequence的数据库则不行（可以使用identity）。

<generator class="sequence">
    <param name="sequence">hibernate_id</param>
</generator>    
<param name="sequence">hibernate_id</param> 指定sequence的名称

​ Hibernate生成主键时，查找sequence并赋给主键值，主键值由数据库生成，
​ Hibernate不负责维护，使用时必须先创建一个sequence，
​ 如果不指定sequence名称，则使用Hibernate默认的sequence，
​ 名称为hibernate_sequence，前提要在数据库中创建该sequence。

​ 特点：只能在支持序列的数据库中使用，如Oracle。

identity

identity由底层数据库生成标识符。identity是由数据库自己生成的，
但这个主键必须设置为自增长，使用identity的前提条件是底层数据库支持自动增长字段类型，
如DB2、SQL Server、MySQL、Sybase和HypersonicSQL等，Oracle这类没有自增字段的则不支持。

<id name="id" column="id">
    <generator class="identity" />
</id>

​ 例：如果使用MySQL数据库，则主键字段必须设置成auto_increment。

​ id int(11) primary key auto_increment

​ 特点：只能用在支持自动增长的字段数据库中使用，如MySQL。

native

native由hibernate根据使用的数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式，
灵活性很强。如果能支持identity则使用identity，如果支持sequence则使用sequence。

<id name="id" column="id">  
    <generator class="native" />
</id>

​ 例如MySQL使用identity，Oracle使用sequence

​ 注意：如果Hibernate自动选择sequence或者hilo，则所有的表的主键都会从Hibernate默认的sequence或hilo表中取。并且，有的数据库对于默认情况主键生成测试的支持，效率并不是很高。使用sequence或hilo时，可以加入参数，指定sequence名称或hi值表名称等，如

hibernate_id 1 ​ 特点：根据数据库自动选择，项目中如果用到多个数据库时，可以使用这种方式，使用时需要设置表的自增字段或建立序列，建立表等。

uuid

UUID：Universally Unique Identifier，是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。
按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字，标准的UUID格式为：

xxxxxxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxx (8-4-4-4-12)

​ 其中每个 x 是 0-9 或 a-f 范围内的一个十六进制的数字。

<id name="id" column="id">  
    <generator class="uuid" />
</id>

​ Hibernate在保存对象时，生成一个UUID字符串作为主键，保证了唯一性，但其并无任何业务逻辑意义，
​ 只能作为主键，唯一缺点长度较大，32位（Hibernate将UUID中间的“-”删除了）的字符串，占用存储空间大，
​ 但是有两个很重要的优点，Hibernate在维护主键时，不用去数据库查询，从而提高效率，
​ 而且它是跨数据库的，以后切换数据库极其方便。

​ 特点：uuid长度大，占用空间大，跨数据库，不用访问数据库就生成主键值，所以效率高且能保证唯一性，移植非常方便，推荐使用。

guid

GUID：Globally Unique Identifier全球唯一标识符，也称作 UUID，
是一个128位长的数字，用16进制表示。算法的核心思想是结合机器的网卡、
当地时间、一个随即数来生成GUID。从理论上讲，如果一台机器每秒产生10000000个GUID，
则可以保证（概率意义上）3240年不重复。

<id name="id" column="id">
    <generator class="guid" />      
</id>

​ Hibernate在维护主键时，先查询数据库，获得一个uuid字符串，该字符串就是主键值，该值唯一，缺点长度较大，支持数据库有限，优点同uuid，跨数据库，但是仍然需要访问数据库。

注意：长度因数据库不同而不同

MySQL中使用select uuid()语句获得的为36位（包含标准格式的“-”）

Oracle中，使用select rawtohex(sys_guid()) from dual语句获得的为32位（不包含“-”）

特点：需要数据库支持查询uuid，生成时需要查询数据库，效率没有uuid高，推荐使用uuid。

foreign

使用另外一个相关联的对象的主键作为该对象主键。主要用于一对一关系中。

<id name="id" column="id">  
    <generator class="foreign">
        <param name="property">user</param>
    </generator>
</id>

<one-to-one name="user" class="domain.User" constrained="true" />

该例使用domain.User的主键作为本类映射的主键。

特点：很少使用，大多用在一对一关系中。

select

使用触发器生成主键，主要用于早期的数据库主键生成机制，能用到的地方非常少。

其他注释方式配置

注释方式与配置文件底层实现方式相同，只是配置的方式换成了注释方式

自动增长，适用于支持自增字段的数据库

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)

根据底层数据库自动选择方式，需要底层数据库的设置

如MySQL，会使用自增字段，需要将主键设置成auto_increment。

@Id
@GeneratedValue(strategy = GenerationType.AUTO)

使用表存储生成的主键，可以跨数据库。

每次需要主键值时，查询名为”hibernate_table”的表，查找主键列”gen_pk”值为”2”记录，得到这条记录的”gen_val”值，根据这个值，和allocationSize的值生成主键值。

@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "ud")
@TableGenerator(name = "ud",
                table = "hibernate_table",
                pkColumnName = "gen_pk",
                pkColumnValue = "2",
                valueColumnName = "gen_val",
                initialValue = 2,
                allocationSize = 5)

使用序列存储主键值

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ud")
@SequenceGenerator(name = "ud",
                  sequenceName = "hibernate_seq",
                  allocationSize = 1,   
                  initialValue = 2)

小结
1)为了保证对象标识符的唯一性与不可变性，应该让Hibernate来为主键赋值，而不是程序。
2)正常使用Hibernate维护主键，最好将主键的setter方法设置成private，从而避免人为或程序修改主键，而使用assigned方式，就不能用private，否则无法给主键赋值。
3)Hibernate中唯一一种最简单通用的主键生成器就是uuid。虽然是个32位难读的长字符串，但是它没有跨数据库的问题，将来切换数据库极其简单方便，推荐使用！
4)关于hilo机制注意：hilo算法生成的标志只能在一个数据库中保证唯一。当用户为Hibernate自行提供连接，或者Hibernate通过JTA，从应用服务器的数据源获取数据库连接时，无法使用hilo，因为这不能保证hilo单独在新的数据库连接的事务中访问hi值表，这种情况，如果数据库支持序列，可以使用seqhilo。
5)使用identity、native、GenerationType.AUTO等方式生成主键时，只要用到自增字段，数据库表的字段必须设置成自动增加的，否则出错。
6)还有一些方法未列出来，例如uuid.hex，sequence-identity等，这些方法不是很常用，且已被其他方法代替，如uuid.hex，官方文档里建议不使用，而直接使用uuid方法。
7)Hibernate的各版本主键生成策略配置有略微差别，但实现基本相同。如，有的版本默认sequence不指定序列名，则使用名为hibernate_sequence的序列，有的版本则必须指定序列名。
8)还可以自定义主键生成策略，这里暂时不讨论，只讨论官方自带生成策略。

---

原文：https://blog.csdn.net/jinyefei/article/details/78962862?utm_source=copy