Hibernate学习（1-12）

最新推荐文章于 2021-10-17 14:59:36 发布

原创最新推荐文章于 2021-10-17 14:59:36 发布 · 306 阅读

0 ·

CC 4.0 BY-SA版权

数据库知识专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了Hibernate框架，从认识Hibernate开始，逐步讲解了如何建立第一个Hibernate案例，配置文件的解析，对象生命周期，以及各种关联映射的实现，包括单向多对一、单向一对一、双向一对多、基于外键和主键的一对一关联映射。通过实例分析，帮助读者深入理解Hibernate的使用和原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第一节认识Hibernate

1.hiberna中文：冬眠

2.持久化：数据从瞬时态转换为持久状态

3.Hibernate：是一个轻量级的持久化框架。没有侵入性。是一个ORM映射框架》简化了jdbc操作。极大了提高开发效率，提供了缓存机制，强大的查询机制，支持多种数据库（数据库的移植）。

4.框架结构原理：

5.原理：

映射规则：将类名映射数据库的表名
将类的属性名映射为表的字段名
将类的属性类型映射为表的字段的数据类型
将对象的属性映射为表的记录

第二节：第一个Hibernate案例

1、包的结构解析：

2.hello hibernate
a)新建 java 项目
b)导入相关 jar 包
antlr-2.7.7.jar
dom4j-1.6.1.jar
hibernate-commons-annotations-4.0.5.Final.jar
hibernate-core-4.3.10.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-1.1.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.1.3.GA.jar
jboss-logging-annotations-1.2.0.Beta1.jar
jboss-transaction-api_1.2_spec-1.0.0.Final.jar
mysql-connector-java-5.1.20-bin.jar
c)编写 hibernate.cfg.xml 文件（拷贝 project/etc/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>
        <!-- property 元素用于配置Hibernate中的属性
            键:值
          -->
        <!-- hibernate.connection.driver_class : 连接数据库的驱动  -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>

        <!-- hibernate.connection.username : 连接数据库的用户名 -->
        <property name="hibernate.connection.username">root</property>

        <!-- hibernate.connection.password : 连接数据库的密码 -->
        <property name="hibernate.connection.password">admin</property>


        <!-- hibernate.connection.url : 连接数据库的地址,路径 -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hib?serverTimezone=UTC</property>


        <!-- show_sql: 操作数据库时,会 向控制台打印sql语句 -->
        <property name="show_sql">true</property>


        <!-- format_sql: 打印sql语句前,会将sql语句先格式化  -->
        <property name="format_sql">true</property>


        <!-- hbm2ddl.auto: 生成表结构的策略配置
             update(最常用的取值): 如果当前数据库中不存在表结构,那么自动创建表结构.
                     如果存在表结构,并且表结构与实体一致,那么不做修改
                     如果存在表结构,并且表结构与实体不一致,那么会修改表结构.会保留原有列.
             create(很少):无论是否存在表结构.每次启动Hibernate都会重新创建表结构.(数据会丢失)
             create-drop(极少): 无论是否存在表结构.每次启动Hibernate都会重新创建表结构.每次Hibernate运行结束时,删除表结构.
             validate(很少):不会自动创建表结构.也不会自动维护表结构.Hibernate只校验表结构. 如果表结构不一致将会抛出异常.
          -->
        <property name="hbm2ddl.auto">create</property>


        <!-- 数据库方言配置
         org.hibernate.dialect.MySQLDialect (选择最短的)
         -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>


        <!-- 引入ORM 映射文件
            填写src之后的路径
         -->
        <mapping resource="com/bjsxt/testhib/po/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

d)编写实体类(pojo)

public class User {
private int id;
private String name;private int age;
public User() {}
}

e)编写实体类的映射文件(*.,hbm.xml)---将映射文件加入到 hibernate.cfg.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
package="cn.sxt.pojo">
<class name="User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="age"/>
</class>
</hibernate-mapping>

f)编写测试类

public class Test {
public static void main(String[] args) {
//读取 src 下 hibernate.cfg.xml
Configuration cfg = new Configuration().configure();
//获取注册对象 4.3 的创建办法
ServiceRegistry registry = new
StandardServiceRegistryBuilder()
.applySettings(cfg.getProperties())
.build();
SessionFactory factory =
cfg.buildSessionFactory(registry);
Session session = factory.openSession();
//保存数据
Transaction tx = session.beginTransaction();
User u = new User("张三",22);
session.save(u);
tx.commit();
session.close();
}
}

第三节：配置文件详解

1、 hibernate.cfg.xml 配置文件

<hibernate-configuration>
<!-- session 工厂的配置 -->
<session-factory>
<!-- jdbc 配置 -->
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="connection.url">
<!-- url 的两种配置方式 -->
<!-- jdbc:mysql://localhost:3306/hibernate4-->
jdbc:mysql:///hibernate4
</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<!-- 数据库方言
hibernate 支持多种数据库， 通过设置方言 hibernate 才知道应该
生成对应数据库的 sql 语句： hibernate 支持的数据库的方言
hibernate.properties 文件中都有
-->
<property name="dialect">
org.hibernate.dialect.MySQL5Dialect
</property>
<!-- 打印 hibernate 生成的 sql 语句 -->
<property name="show_sql">true</property>
<!-- 格式化打印的 sql 语句 -->
<property name="format_sql">true</property>
<!-- 根据不同值， 进行数据表表的操作
create 每次执行 都删除原有表， 然后创建新表
create-drop 执行前创建表， 执行后删除表
update 如果有则不改变表， 如果没有则创建
-->
<property name="hbm2ddl.auto">update</property>
<!-- 将所有映射文件添加到这里 -->
<mapping resource="cn/sxt/pojo/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>

2、 *.hbm.xml 映射文件讲解

<!-- 类的映射文件信息 -->
<!-- package 指定类的包名 可以不配置 如果不配置 那么在配置 class 的
name 时需要指定该类所在包-->
<hibernate-mapping><!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<!-- id 主键的配置 name 配置类的属性名
column 数据库字段名 不写和属性名一致
type 指定属性的类型
length 指定字段的长度
-->
<id name="id" column="id">
<!-- 主键的生成策略
increment
用于为 long, short 或者 int 类型生成 唯一标识。 只有在
没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。
identity
对 DB2,MySQL, MS SQL Server, Sybase 和
HypersonicSQL
的内置标识字段提供支持。 返回的标识符是 long, short 或
者 int 类型的。
native -(如果是 mysql 自增， 那么 native 和 identity 是一
样)
根据底层数据库的能力选择 identity, sequence 或者
hilo 中的一个。
sequence
在 DB2,PostgreSQL, Oracle, SAP DB, McKoi 中使用序
列（sequence)，
而在 Interbase 中使用生成器(generator)。 返回的标识
符是 long, short 或者 int 类型的。
<generator class="sequence">
<param name="sequence">user_seq</param>
</generator>
assigned
让应用程序在 save()之前为对象分配一个标示符。 这是
<generator>元素没有指定时
的默认生成策略。
-->
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
</class>
</hibernate-mapping>

第四节 Hello 的代码分析

1、 Test.java

public static void main(String[] args) {
//读取 src 下 hibernate.cfg.xml 如果不为 configure 指明参数 默
认读取 hibernate.cfg.xml
Configuration cfg = new Configuration().configure();
//3.x 版本不需要 ServiceRegistry
//4.0 ServiceRegistryBuilder
//获取注册对象 4.3 的创建办法
ServiceRegistry registry = new
StandardServiceRegistryBuilder()
.applySettings(cfg.getProperties())
.build();
//SessionFactory 是一个重量级对象 session 的工厂 生命周期是进
程级别的 支持集群 线程安全的
SessionFactory factory =
cfg.buildSessionFactory(registry);
/*Session (org.hibernate.Session)
表示应用程序与持久储存层之间交互操作的一个单线程对象，
此对象生存期很短。 其隐藏了 JDBC 连接， 也是 Transaction 的工
厂。
其会持有一个针对持久化对象的必选（第一级） 缓存， 在遍历对象
图或者根据持久化标识查找对象时会用到
session 支持数据库操作
* */
Session session = null;
//事务对象
Transaction tx =null;
try{
session = factory.openSession();
tx = session.beginTransaction();
User u = new User("小红",22);
//保存数据
session.save(u);
//提交事务
tx.commit();
}catch(Exception e){
if(tx!=null)
//回滚事务
tx.rollback();
}finally{
if(session!=null)
session.close();}
factory.close();
}

2、封装 util

public class HibernateUtil {
private static Configuration cfg=null;
private static ServiceRegistry registry=null;
private static SessionFactory factory=null;
static{
cfg = new Configuration().configure();
registry = new StandardServiceRegistryBuilder()
.applySettings(cfg.getProperties())
.build();
factory = cfg.buildSessionFactory(registry);
}p
ublic static Session getSession(){
return factory.openSession();
}
}

3 、常用操作

public class HibernateTest {
//向数据库添加数据
@Test
public void testSave(){
Session session = null;
Transaction tx = null;
try{
session = HibernateUtil.getSession();
//获取事务对象
tx = session.getTransaction();
//开启事务
tx.begin();
User u = new User("张学友",55);
session.save(u);
tx.commit();
}catch(Exception e){
e.printStackTrace();
if(tx!=null)
tx.rollback();}finally{
if(session!=null)
session.close();
}
}
//获取数据
@Test
public void testGetById(){
Session session = null;
Transaction tx = null;
try{
session = HibernateUtil.getSession();
//获取事务对象
tx = session.getTransaction();
//开启事务
tx.begin();
//获取对象 第一参数 是对象的类型 第二个参数是 主键值
//User u = (User)session.get(User.class, 2);
User u = (User)session.load(User.class, 2);
System.out.println(u);
tx.commit();
}catch(Exception e){
e.printStackTrace();
if(tx!=null)
tx.rollback();
}finally{
if(session!=null)
session.close();
}
}
//获取所有对象
@Test
public void testGetAll(){
Session session = null;
Transaction tx = null;
try{
session = HibernateUtil.getSession();
//获取事务对象
tx = session.getTransaction();
//开启事务
tx.begin();
//查询所有
List<User> list =
session.createCriteria(User.class).list();for(User u:list){
System.out.println(u);
}t
x.commit();
}catch(Exception e){
e.printStackTrace();
if(tx!=null)
tx.rollback();
}finally{
if(session!=null)
session.close();
}
}
//修改数据
@Test
public void testUpdate(){
Session session = null;
Transaction tx = null;
try{
session = HibernateUtil.getSession();
//获取事务对象
tx = session.getTransaction();
//开启事务
tx.begin();
//获取对象 第一参数 是对象的类型 第二个参数是 主键值
//User u = (User)session.get(User.class, 2);
User u = (User)session.load(User.class, 2);
u.setAge(60);
//修改数据
session.update(u);
System.out.println(u);
tx.commit();
}catch(Exception e){
e.printStackTrace();
if(tx!=null)
tx.rollback();
}finally{
if(session!=null)
session.close();
}
}
@Test
public void testDelete(){
Session session = null;Transaction tx = null;
try{
session = HibernateUtil.getSession();
//获取事务对象
tx = session.getTransaction();
//开启事务
tx.begin();
//获取对象 第一参数 是对象的类型 第二个参数是 主键值
//User u = (User)session.get(User.class, 2);
User u = (User)session.load(User.class, 2);
//删除对象
session.delete(u);
System.out.println(u);
tx.commit();
}catch(Exception e){
e.printStackTrace();
if(tx!=null)
tx.rollback();
}finally{
if(session!=null)
session.close();
}
}
}

第五节 hibernate 对象生命周期

2、对象的 3 种状态：
a) 临时状态/瞬时状态
该对象是新创建的；一个持久化状态的对象被删除；一个游离状态的数据被删除
b) 持久化状态
对象从数据库中查询出来时，临时状态的数据被保存时，游离状态的数据被更新/锁定
c) 游离状态
持久化状态的数据被（session）清理

3、对象生命周期案例一

@Test
public void testSession(){
Session session = null;
//瞬时状态
User u = new User("西毒",70);
try{
session = HibernateUtil.getSession();
session.beginTransaction();
//持久状态----做脏数据检查 将 session 数据和数据库同步
session.save(u);
u.setAge(80);
//session.update(u);
session.getTransaction().commit();
}catch(Exception e){e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}/
/对象 u 是游离状态
System.out.println("======"+u);
try{
session = HibernateUtil.getSession();
session.beginTransaction();
//删除
session.delete(u);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}/
/瞬时状态
System.out.println("======"+u);
}

@Test
public void testGet(){
Session session = null;
User u =null;
try{
session = HibernateUtil.getSession();
session.beginTransaction();
//持久状态
/*
* get 查询数据如果数据不存在则返回 null
* load 查询数据如果数据不存在则抛出异常
* */
u = (User)session.get(User.class,4);
//u = (User)session.load(User.class, 50);//瞬时状态
session.delete(u);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}S
ystem.out.println("===="+u);
try{
session = HibernateUtil.getSession();
session.beginTransaction();
//持久状态 save 直接添加数据发出一条 insert 语句
session.save(u);
//saveOrUpdate 判断保存的对象是否有 id,如果有则发出
update 语句
//如果没有则发出 insert 语句
//session.saveOrUpdate(u);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}
}@
Test
public void testDelete(){
Session session = null;
User u =null;
try{
session = HibernateUtil.getSession();
session.beginTransaction();
u = new User();
u.setId(7);
session.delete(u);
session.getTransaction().commit();}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}
}@
Test
public void testUpdate(){
Session session = null;
User u =null;
try{
session = HibernateUtil.getSession();
session.beginTransaction();
u = new User();
u.setId(3);
u.setName("南帝");
u.setAge(66);
session.update(u);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}
}

5、总结：
临时状态：内存有，数据库没有
持久状态：内存有,session 有，数据库有
游离状态：内存有，数据有

第六节关联映射之单向多对一

1、实体类 Role.java

public class Role {
private Integer id;
private String name;
public Role() {
// TODO Auto-generated constructor stub
}p
ublic Role(String name) {
super();
this.name = name;
}/
/省略 get/set 方法
}

User.java

public class User {
private int id;
private String name;
private int age;
private Role role;
public User() {
}p
ublic User(String name, int age) {
super();
this.name = name;
this.age = age;
}//
省略 get/set 方法
}

3、映射文件 User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
<many-to-one name="role" column="roleId"
not-null="true"></many-to-one>
</class>
</hibernate-mapping>

Role.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.Role" table="t_role">
<id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
</class>
</hibernate-mapping>

4、测试

public class HibernateTest {
@Test
public void testCreateDB(){
Configuration cfg = new Configuration().configure();
SchemaExport se = new SchemaExport(cfg);
//第一个参数 是否打印脚本， 第二个参数是否导入数据库
se.create(true, true);
}@Test
public void testInit(){
Session session = null;
try{
session = HibernateUtil.getSession();
session.beginTransaction();
Role r1 = new Role("岛主");
Role r2 = new Role("峰主");
session.save(r1);
session.save(r2);User u1 = new User();
u1.setName("黄药师");
u1.setAge(66);
u1.setRole(r1);
User u2 = new User();
u2.setName("西毒");
u2.setAge(56);
u2.setRole(r2);
User u3 = new User();
u3.setName("郭襄");
u3.setAge(63);
u3.setRole(r1);
session.save(u1);
session.save(u2);
session.save(u3);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}
}@Test
public void testGet(){
Session session = null;
try{
session = HibernateUtil.getSession();
session.beginTransaction();
User u = (User)session.get(User.class, 1);
System.out.println("姓名： "+u.getName()+" 年龄：
"+u.getAge()+" 角色： "+u.getRole().getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();}
}
}
}

第六节关联映射之单向一对一多

2、映射文件User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
</class>
</hibernate-mapping>

Role.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.Role" table="t_role">
<id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<set name="users">
<!-- 配置外键 -->
<key column="roleId" not-null="true"></key>
<one-to-many class="cn.sxt.pojo.User"/>
</set>
</class>
</hibernate-mapping>

public class HibernateTest {
@Test
public void testCreateDB(){
Configuration cfg = new Configuration().configure();
SchemaExport se = new SchemaExport(cfg);
//第一个参数 是否打印脚本， 第二个参数是否导入数据库
se.create(true, true);
}@
Test
public void testInit(){
Session session = null;
try{
session = HibernateUtil.getSession();session.beginTransaction();
User u1 = new User();
u1.setName("黄药师");
u1.setAge(66);
User u2 = new User();
u2.setName("西毒");
u2.setAge(56);
User u3 = new User();
u3.setName("郭襄");
u3.setAge(63);
Role r1 = new Role("岛主");
r1.getUsers().add(u1);
r1.getUsers().add(u3);
Role r2 = new Role("峰主");
r2.getUsers().add(u2);
session.save(r1);
session.save(r2);
session.save(u1);
session.save(u2);
session.save(u3);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}
}@
Test
public void testGet(){
Session session = null;
try{
session = HibernateUtil.getSession();
session.beginTransaction();
Role role = (Role)session.get(Role.class, 1);
System.out.println("角色名： "+role.getName());System.out.println("--------------");
for(User u:role.getUsers()){
System.out.println(u);
}s
ession.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if(session!=null){
session.close();
}
}
}
}

第八节关联映射之双向一对多

2、映射文件User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
<many-to-one name="role" column="roleId"/>
</class>
</hibernate-mapping>

Role.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.Role" table="t_role">
<id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<set name="users">
<!-- 配置外键 -->
<key column="roleId"></key>
<one-to-many class="cn.sxt.pojo.User"/>
</set>
</class>
</hibernate-mapping>

第九节关联映射之基于外键的单向一对一

User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id"><generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
<many-to-one name="idCard" column="cardId" unique="true"/>
</class>
</hibernate-mapping>

IdCard.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.IdCard" table="t_idCard">
<id name="id" column="id">
<generator class="assigned">
</generator>
</id>
<property name="address"/>
</class>
</hibernate-mapping>

第十节关联映射之基于外键的双向一对一

User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user"><id name="id" column="id">
<generator class="identity">
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
<many-to-one name="idCard" column="cardId" unique="true"/>
</class>
</hibernate-mapping>

IdCard.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.IdCard" table="t_idCard">
<id name="id" column="id">
<generator class="assigned">
</generator>
</id>
<property name="address"/>
<one-to-one name="user" property-ref="idCard"/>
</class>
</hibernate-mapping>

第十一节关联映射之基于主键的单向一对一

User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id"><generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
<one-to-one name="idCard"
constrained="true"></one-to-one>
</class>
</hibernate-mapping>

IdCard.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.IdCard" table="t_idCard">
<id name="id" column="id">
<generator class="assigned">
</generator>
</id>
<property name="address"/>
</class>
</hibernate-mapping>

第十二节关联映射之主键一对一双向关联

User.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.User" table="t_user">
<id name="id" column="id"><generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<!-- property 是配置类的属性 name 指属性名 -->
<property name="name" length="40"/>
<property name="age" />
<one-to-one name="idCard"
constrained="true"></one-to-one>
</class>
</hibernate-mapping>

IdCard.hbm.xml

<hibernate-mapping>
<!-- class 配置类 name 指类名 table 指定表名 如果不写， 默认类名
为表名-->
<class name="cn.sxt.pojo.IdCard" table="t_idCard">
<id name="id" column="id">
<generator class="assigned">
</generator>
</id>
<property name="address"/>
<one-to-one name="user"/>
</class>
</hibernate-mapping>