Hibernate之主键生成策略

一、主键类型

1.自然主键（主键本身就是表中的一个字段，实体中一个具体的属性）

 表中已经具有某字段，并且该字段具有业务含义作为主键，称之为自然主键

2.代理主键（主键不是实体中某个具体的属性，而是一个不相关的字段）

 表中不具备业务含义的字段作为主键，称之为代理主键。更合理的方式是使用代理主键。

二、主键生成策略

1.自然主键

assigned（用户手动录入）

　　由Java程序负责生成标识符，Hibernate不管理主键，用户手动设置主键的值。如果不指定id元素的generator属性，则默认使用该主键生成策略

2.代理主键

identity（主键自增）

　　适用于long、short或int类型主键，采用底层数据库本身提供的主键生成标识符。在DB2、MySQL、MS SQL Server、Sybase和HypersonicSQL数据库中可以使用该生成器，该生成器要求在数据库中把主键定义成为自增类型。Oracle没有自动增长

sequence（序列）

　　适用于long、short或int类型主键，Hibernate根据底层数据库序列生成标识符。条件是数据库支持序列。如oralce、DB、SAP DB、PostgerSQL、McKoi中的sequence，MySQL这种不支持sequence

increment（主键自增，单线程，maxID+1）

　　适用于long、short或int类型主键，由Hibernate提供自动递增的方式生成唯一标识符，每次增量为1。只有当没有其他进程向同一张表中插入数据时才可以使用，不能再多线程环境下使用

uuid（随机字符串作主键）

　　Hibernate采用128位的UUID算法来生成标识符。该算法能够在网络环境中生成唯一的字符串标识符，其UUID被编码为一个长度为32位的十六进制字符串。按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字

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

native（hilo+identity+sequence三选一）

　　根据底层数据库对自动生成标识符的能力来选择i dentity、sequence、hilo三种生成器中的一种，适合跨数据库平台开发

代码演示：

在上一次的代码基础上

创建与数据库对应的实体类Student：

package com.hxc.two.entity;

public class Student {

    private Integer sid;
    private String sname;

    public Integer getSid() {
        return sid;
    }
    public void setSid(Integer sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    @Override
    public String toString() {
        return "Student [sid=" + sid + ", sname=" + sname + "]";
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(Integer sid, String sname) {
        super();
        this.sid = sid;
        this.sname = sname;
    }
    
}

实体类Worker：

package com.hxc.two.entity;

public class Worker {

    private String wid;
    private String wname;
    public String getWid() {
        return wid;
    }
    public void setWid(String wid) {
        this.wid = wid;
    }
    public String getWname() {
        return wname;
    }
    public void setWname(String wname) {
        this.wname = wname;
    }
    @Override
    public String toString() {
        return "Worker [wid=" + wid + ", wname=" + wname + "]";
    }
    public Worker() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Worker(String wid, String wname) {
        super();
        this.wid = wid;
        this.wname = wname;
    }
    
}

并在同包的位置下，配置对应的hbm.xml文件：

Stuednt.hdm.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.hxc.two.entity.Student" table="t_hibernate_student">
        <id name="sid" type="java.lang.Integer" column="sid">
            
            <!--选择主键生成策略 -->
            <generator class="assigned" />
            <!-- <generator class="increment" /> -->
            <!-- <generator class="sequence" /> -->
            <!-- <generator class="sequence" > <param name="sequence_name">aaa</param> 
                </generator> -->
            <!-- <generator class="com.javaxl.two.id.Myts" /> -->
        </id>
        <property name="sname" type="java.lang.String" column="sname">
        </property>
    </class>
</hibernate-mapping>

worker.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.hxc.two.entity.Worker" table="t_hibernate_worker">
        <id name="wid" type="java.lang.String" column="wid">


            <!--选择主键生成策略  -->
            <generator class="uuid" /> 
            <!-- <generator class="sequence" > <param name="sequence_name">aaa</param> 
                </generator> -->
            <!-- <generator class="com.javaxl.two.id.Myts" /> -->
        </id>

        <property name="wname" type="java.lang.String" column="wname">
        </property>
    </class>
</hibernate-mapping>

 配置hibernate.cfg.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 1. 数据库相关 -->
        <property name="connection.username">root</property>
        <property name="connection.password">123</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/mytable?useUnicode=true&amp;characterEncoding=UTF-8
        </property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 配置本地事务（No CurrentSessionContext configured!） -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 2. 调试相关 -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <!-- 3. 添加实体映射文件 -->
        <mapping resource="com/hxc/one/entity/user.hbm.xml" />
        <!-- 主键生成策略 -->
        <mapping resource="com/hxc/two/entity/Student.hbm.xml"/>
        <mapping resource="com/hxc/two/entity/Worker.hbm.xml"/>
        
    </session-factory>
</hibernate-configuration>        

 检测hibernate中配置文件是否配置成功：

package com.hxc.two.util;


import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
/**
 * 仅在学习hibernate的工程中使用，当进入sping的学习以后就没用了，后面会有ssh来代替它
 * 作用：
 *         用来检测hibernate中配置文件的准确性。
 *                 hibernate.cfg.xml
 *                 *。mhb.xml
 * 
 * @author 旧城
 *
 */
public class SessionFactoryUtils {
    private static SessionFactory sessionFactory;
    static {
        Configuration cfg = new Configuration().configure("hibernate.cfg.xml");
        sessionFactory = cfg.buildSessionFactory();
    }
    
    public static Session openSession() {
//        从本地的线程中获取session会话，第一次肯定是获取不到的，那么需要重新让sessionfactory创建一个session出来
//        第二次就能够对第一次创建的session反复利用，节约性能
        Session session = sessionFactory.getCurrentSession();
        if(session == null) {
            session = sessionFactory.openSession();
        }
        return session;
    }
    
    public static void closeSession() {
        Session session = sessionFactory.getCurrentSession();
        if(session != null && session.isOpen()) {
            session.close();
        }
    }
    
    public static void main(String[] args) {
        Session session = SessionFactoryUtils.openSession();
        session.beginTransaction();
        System.out.println(session.isConnected());
        SessionFactoryUtils.closeSession();
        System.out.println(session.isConnected());
    }
}

 运行结果如下则证明配置无误：DemoDao

 

创建DemoDao测试：

package com.hxc.two.dao;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hxc.two.entity.Student;
import com.hxc.two.entity.Worker;
import com.hxc.two.util.SessionFactoryUtils;

public class DemoDao {

    /**
     * 新增学生
     * @param student
     */
    public void addStudent(Student student) {
        Session session=SessionFactoryUtils.openSession();
        Transaction transaction=session.beginTransaction();
        session.save(student);
        transaction.commit();
        SessionFactoryUtils.closeSession();
    }
    /**
     * 新增工人
     * @param worker
     */
    public void addWorker(Worker worker) {
        Session session=SessionFactoryUtils.openSession();
        Transaction transaction=session.beginTransaction();
        session.save(worker);
        transaction.commit();
        SessionFactoryUtils.closeSession();
    }
    
    public static void testStudent(String[] args) {
        DemoDao dao=new DemoDao();
        Student student=new Student();
        student.setSname("麻花");
        student.setSid(76);
        dao.addStudent(student);
    }
    public static void main(String[] args) {
        DemoDao dao=new DemoDao();
        Worker worker=new Worker();
        worker.setWname("旧城");
        dao.addWorker(worker);
    }
}

 效果如下（只演示了uuid和assigned）：

uuid主键生成：

 assigned主键生成：

 我们也可以自定义主键生成器

先创建一个主键生成器类

package com.hxc.two.id;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.id.IdentifierGenerator;

public class MyTsGenerator implements IdentifierGenerator {

    @Override
    public Serializable generate(SharedSessionContractImplementor arg0, Object arg1) throws HibernateException {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return "book_oder_"+sdf.format(new Date());
    }

}

在*.hbm.xml指定主键生成器类

<generator class="xxx.MyTsGenerator"/>，如下：

配置Worker.hbm.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.hxc.two.entity.Worker" table="t_hibernate_worker">
        <id name="wid" type="java.lang.String" column="wid">
            <!--选择主键生成策略  -->
             <generator class="com.hxc.two.id.MyTsGenerator" /> 
            <!-- <generator class="uuid" />  -->
            <!-- <generator class="sequence" > <param name="sequence_name">aaa</param> 
                </generator> -->
            <!-- <generator class="com.javaxl.two.id.Myts" /> -->
        </id>

        <property name="wname" type="java.lang.String" column="wname">
        </property>
    </class>
</hibernate-mapping>

运行DemoDao，效果如下：