hibernate多对多 一对多 及简单入门 主键生成策略

　　Hibernate简单使用 入门 通过hibernate的 一对多 多对多轻松看懂hibernate配置 （不使用注解）

hibernate对jdbc访问数据库的代码进行轻量级封装，简化重复代码 减少内存消耗 。hibernate基于JDBC开发与mybatis不同hibernate 时完全orm实现简化dao层编码支持多种关系型数据库

hibernate下载 暂时不建议下载最新版本的  （原因 兼容问题）。hibernate已经更新到6.几版本了  这里使用的是5.0.7版本的 不推荐使用5版本一下的hibernate ，因为之前版本的有些功能随着版本更新已经没有存在的必要性了如一级缓存（之后会讲）一级缓存(session级别)、二级缓存(sessionFactory级别)以及查询缓存

这里首先说一下hibernate的配置文件 可以分为两类  一类与实体映射作为orm数据源，一个作为hibernate的配置 取名也有规定：不做其他配置的话实体映射叫XX.hbm.xml,hibernate配置文件交hibernate.cfg.xml.下面先给出例子然后会依次说明 其参数意义及配置

使用的jar包 及版本

jdk1.7  MySQL eclipsejee

背景：顾客  联系人  用户  角色 四张表  其中 顾客customer和联系人linkman是多对一的   用户user和角色Role是多对多的

请务必注意一下类中属性的set（） get（）方法不可少 此处减少代码量没写 实际中需要属性驱动

public class User {
	/*数据库建表语句
	 * CREATE TABLE `sys_user` (
	  `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
	  `user_code` varchar(32) NOT NULL COMMENT '用户账号',
	  `user_name` varchar(64) NOT NULL COMMENT '用户名称',
	  `user_password` varchar(32) NOT NULL COMMENT '用户密码',
	  `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',
	  PRIMARY KEY (`user_id`)
	) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
	 */
	private Long user_id;
	private String user_code;
	private String user_name;
	private String user_password;
	private Character user_state;
	//表达多对多
	private Set<Role> roles = new HashSet<Role>();

}
public class Customer {

	/*数据库建表语句
	 * CREATE TABLE `cst_customer` (
	  `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
	  `cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
	  `cust_source` VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
	  `cust_industry` VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业',
	  `cust_level` VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
	  `cust_linkman` VARCHAR(64) DEFAULT NULL COMMENT '联系人',
	  `cust_phone` VARCHAR(64) DEFAULT NULL COMMENT '固定电话',
	  `cust_mobile` VARCHAR(16) DEFAULT NULL COMMENT '移动电话',
	  PRIMARY KEY (`cust_id`)
	) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
	 */
	private Long cust_id;

	private String cust_name;
	private String cust_source;
	private String cust_industry;
	private String cust_level;
	private String cust_linkman;
	private String cust_phone;
	private String cust_mobile;
	//使用set集合,表达一对多关系
	private Set<LinkMan> linkMens = new HashSet<LinkMan>();
}
public class Role {
	/*
	 * 数据库建表语句
	  CREATE TABLE `sys_role` (
  `role_id` bigint(32) NOT NULL AUTO_INCREMENT,
  `role_name` varchar(32) NOT NULL COMMENT '角色名称',
  `role_memo` varchar(128) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`role_id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
	 */

	private Long role_id;
	private String role_name;
	private String role_memo;
	//表达多对多
	private Set<User> users = new HashSet<User>();
}
public class LinkMan {
		/*数据库建表语句
		 * CREATE TABLE `cst_linkman` (
		  `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
		  `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
		  `lkm_cust_id` bigint(32) NOT NULL COMMENT '客户id',
		  `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
		  `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
		  `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
		  `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
		  `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
		  `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
		  `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
		  PRIMARY KEY (`lkm_id`),
		  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
		  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
		) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
		 */
	private Long lkm_id;
	private Character lkm_gender;
	private String lkm_name;
	private String lkm_phone;
	private String lkm_email;
	private String lkm_qq;
	private String lkm_mobile;
	private String lkm_memo;
	private String lkm_position;

	//表达多对一关系
	private Customer customer ;

}

　　

重点是注释和实体之间的关系 重点是注释和实体之间的关系

关于XXX.hbm.xml的配置要说一下  hibernate自带的update方法时更新所有字段的 你给它主键它更新对应元组的所有字段，这意味着你每次更新都需要设置一遍所有的字段值。不想这么麻烦记得要配置

<classname="com.dabai.User"table="student"dynamic-update="true"/>

对应的user.hbm.xml （我的update语句使用的hql所以没改）

<?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 package="com.dabai.entity" >
    <class name="User" table="sys_user" >
        <id name="user_id"  >
            <generator class="native"></generator>
        </id>
        <property name="user_code"  ></property>
        <property name="user_name"  ></property>
        <property name="user_password"  ></property>
        <property name="user_state"  ></property>

        <!-- 多对多关系表达 -->
        <!--
            name: 集合属性名
            table: 配置中间表名
            key
             |-column:外键,别人引用"我"的外键列名
             class: 我与哪个类是多对多关系
             column:外键.我引用比人的外键列名
         -->
         <!-- cascade级联操作:
                     save-update: 级联保存更新
                     delete:级联删除
                     all:级联保存更新+级联删除
             结论: cascade简化代码书写.该属性使不使用无所谓. 建议要用只用save-update.
                  如果使用delete操作太过危险.尤其在多对多中.不建议使用.
                      -->
        <set name="roles" table="sys_user_role" cascade="save-update" >
            <key column="user_id" ></key>
            <many-to-many class="Role" column="role_id" ></many-to-many>
        </set>

    </class>
</hibernate-mapping>

重点是注释和实体之间的关系 重点是注释和实体之间的关系

对应的Customer.hbm.xml 这里可以看到Customer.hbm.xml的配置中《property》和User.hbm.xml中多了 column字段  事实上还有一个type字段 填写的是java实体对应的属性类型当确定数据库与实体类型映射不会出问题时可以省略交给hibernate框架自动映射，column字段可以省略，交给hibernate主动去映射前提条件是数据库字段名称和实体对应名称一样。解释一下其中id字段  ，id是必须配置的对应数据库中的主键,generator代表主键生成策略：通常包含这么几种：

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

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

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

4、UUID：Universally Unique Identifier 这个由Java基础的很好理解吧

5、guid，可以理解为guid。一个128位长的数字，用16进制表示

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

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

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

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

　

　我的使用原则是：assigned  hilo不用 并发量高的不用increment Oracle用seqhilo ， mysql中主键是非字符串型时用的比较多的是native。当主键是足够长的string类型时用uuid

还有一些其他属性 参照注释理解

<?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 package="com.dabai.entity" >
    <class name="Customer" table="cst_customer" lazy="false" >
        <id name="cust_id"  >
            <generator class="native"></generator>
        </id>
        <property name="cust_name" column="cust_name" ></property>
        <property name="cust_source" column="cust_source" ></property>
        <property name="cust_industry" column="cust_industry" ></property>
        <property name="cust_level" column="cust_level" ></property>
        <property name="cust_linkman" column="cust_linkman" ></property>
        <property name="cust_phone" column="cust_phone" ></property>
        <property name="cust_mobile" column="cust_mobile" ></property>

    <!--
        lazy属性: 决定是否延迟加载
            true(默认值): 延迟加载,懒加载
            false: 立即加载
            extra: 极其懒惰
        fetch属性: 决定加载策略.使用什么类型的sql语句加载集合数据
            select(默认值): 单表查询加载
            join: 使用多表查询加载集合
            subselect:使用子查询加载集合
     -->
     <!-- batch-size: 抓取集合的数量为3.
             抓取客户的集合时,一次抓取几个客户的联系人集合.
      -->
        <set name="linkMens" batch-size="3"  >
            <key column="lkm_cust_id" ></key>
            <one-to-many class="LinkMan" />
        </set>

    </class>
</hibernate-mapping>

重点是注释和实体之间的关系 重点是注释和实体之间的关系

对应的Role.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 package="com.dabai.entity" >
    <class name="Role" table="sys_role" >
        <id name="role_id"  >
            <generator class="native"></generator>
        </id>
        <property name="role_name"  ></property>
        <property name="role_memo"  ></property>

    <!-- 使用inverse属性
            true: 放弃维护外键关系
            false(默认值):维护关系

        结论: 将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.
             一般谁来放弃要看业务方向. 例如录入员工时,需要为员工指定所属角色.
             那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护
         -->
        <set name="users" table="sys_user_role" inverse="true" >
            <key column="role_id" ></key>
            <many-to-many class="User" column="user_id" ></many-to-many>
        </set>
    </class>
</hibernate-mapping>

对应的linkMan.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 package="com.dabai.entity" >
    <class name="LinkMan" table="cst_linkman" >
        <id name="lkm_id"  >
            <generator class="native"></generator>
        </id>
        <property name="lkm_gender"  ></property>
        <property name="lkm_name"  ></property>
        <property name="lkm_phone"  ></property>
        <property name="lkm_email"  ></property>
        <property name="lkm_qq"  ></property>
        <property name="lkm_mobile"  ></property>
        <property name="lkm_memo"  ></property>
        <property name="lkm_position"  ></property>
        <!--
        fetch 决定加载的sql语句
            select: 使用单表查询
            join : 多表查询
        lazy  决定加载时机
            false: 立即加载
            proxy: 由customer的类级别加载策略决定.
         -->
        <many-to-one name="customer" column="lkm_cust_id" class="Customer" fetch="join" lazy="proxy"  >
        </many-to-one>
    </class>
</hibernate-mapping>

这里还想说一下 实际应用中有些属性是没有必要的 在做优化的时候才会涉及到对性能的考虑

还一个hibernate的配置文件 hibernate.cfg.xml

<mapping resource?指定实体映射文件

<?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>
         <!-- 数据库驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <!-- 数据库url -->
        <property name="hibernate.connection.url">jdbc:mysql:///testHibernate</property>
         <!-- 数据库连接用户名 -->
        <property name="hibernate.connection.username">xiaobai</property>
         <!-- 数据库连接密码 -->
        <property name="hibernate.connection.password">xiaobai</property>
        <!-- 数据库方言
            不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
            sql99标准: DDL 定义语言  库表的增删改查
                      DCL 控制语言  事务 权限
                      DML 操纵语言  增删改查
            注意: MYSQL在选择方言时,请选择最短的方言.
         -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- #hibernate.show_sql true
             #hibernate.format_sql true
        -->
        <!-- 将hibernate生成的sql语句打印到控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 将hibernate生成的sql语句格式化(语法缩进) -->
        <property name="hibernate.format_sql">true</property>
        <!--
        ## auto schema export  自动导出表结构. 自动建表
        #hibernate.hbm2ddl.auto create        自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
        #hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
        #hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
        #hibernate.hbm2ddl.auto validate    校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
         -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 引入orm元数据
            路径书写: 填写src下的路径
         -->
         <!-- 指定hibernate操作数据库时的隔离级别
            #hibernate.connection.isolation 1|2|4|8
            0001    1    读未提交
            0010    2    读已提交
            0100    4    可重复读
            1000    8    串行化
         -->
         <property name="hibernate.connection.isolation">4</property>
         <!-- 指定session与当前线程绑定 -->
         <property name="hibernate.current_session_context_class">thread</property>

        <mapping resource="com/dabai/entity/Customer.hbm.xml" />
        <mapping resource="com/dabai/entity/LinkMan.hbm.xml" />
        <mapping resource="com/dabai/entity/Role.hbm.xml" />
        <mapping resource="com/dabai/entity/User.hbm.xml" />

    </session-factory>
</hibernate-configuration>

配置中有个坑    这里我配置的是MySQL5Dialect 但是有的配置MySQLDialect就行  我看了下 MySQL5Dialect 和MySQLDialect 继承的是一个Dialect类  讲道理是不会有错误的 但实际中我配置MySQLDialect确实是报错了的  所以此处指出 使用hibernate版本5的话最好改成和我一样的

接下来编写测试类 测试实体 实体映射文件 和hibernate配置文件与数据库连接

 public class test {
     Configuration conf = new Configuration().configure();
     // 根据配置信息,创建 SessionFactory对象
     SessionFactory sessionFactory = conf.buildSessionFactory();
     Session session=sessionFactory.openSession();
     //2开启事务
     Transaction tx = session.beginTransaction();
     /*
      * 再对实体对象进行创建修改 如 增删改查等  乱七八糟的操作 最后别忘了提交事务！！
      * User nUser=new User();
      * nUser.setUser_name("dabai");
      * session.save(nUser);
      */

     tx.commit();
     session.close();
 }

这里基本搞懂了hibernate映射对应的话 最好再弄明白一下一对一 一对多  多对多的关系 接下来是hibernate的文件配置 详解 及一些使用  之后会设计缓存之类的。有关于这些东西还是动手实践来的好 报错是最好的学习！