多对多建立中间表,一对多的一方有set多方内容，数据库我一般在多方的数据表设置外键，如bank表的admin_id。而且该外键不需要private出来
实体类Admin.java
public class Admin {
private int id;//其主键
private String admin_code;
private String password;
private String name;
private String email;
private String telephone;
private Date enrolldate;
private Set<Role> roles;//一个管理员拥有很多角色
private Set<Bank> banks;//一个管理员拥有很多张银行卡
//省略set,get方法
}
实体类Role.java
public class Role {
private int id;
private String name;
private Set<Admin> admins;
}
实体类Bank.java
private int id;
private String bankName;
private String bankSal;
//private int adminId;作为外键可以不写
}
映射需要知道（学习时的笔记）：
常用的主键生成策略有以下几种：
1.identity：用户自动增长的主键生成方式，除了Oralce不支持以为，其他的数据库一般都支持。
2.sequence： Oracle中使用，用序列生成主键
3.native: 自动匹配，看核心配置文件hibernate.cfg.xml中方言：
如果为MySQL对应的方言，相当于identity；如果为Oracle对应的方言，相当于使用sequence。
4.increment：相当先去对应的表中查询主键的最大值，然后+1后进行添加。不要求主键自动增长。不常用。
5.assigned:手动生成id
常用的Hibernate映射类型：
A．string 字符串
B．integer:
C．double
D．date :日期，只保存年月日
E．datetime:日期：年月日时分秒
F．timestamp：时间戳：存放年月日时分秒…
G．yes_no:将在数据库保存一个字符 Y/N
H．true_false:在数据库中保存一个字符: T/F 功能和yes_no基本相同。
I．boolean
J．blob、clob用来保存大文件（比如：文档、视频，音频）
Cascade、inverse、fetch属性总结
1.cascade属性的六个值：
save-update:级联添加\修改
delete: 级联删除
delete-orphan：删除多方中某N个（大于等于1）
all: 级联添加、修改、删除 save-update + delete
all-delete-orphan： all + delete-orphan === save-update + delete + delete-orphan
2.inverse属性：
true ：将控制权限交给对方
false: 控制权自己留着。
3.fetch
a．join 连接的方式进行查询
b．select 默认的方式 Sql语句分开写，用于延迟加载
c．subselect: 子查询的方式（one-to-many的配置中不生效）
Admin.hbm.xml映射
<hibernate-mapping
package="com.zqw.pojo">
<class name="Admin" table="admin">
<id name="id">
<generator class="native"/>
</id>
<property name="admin_code"></property>
<property name="password"></property>
<property name="name"></property>
<property name="email"/>
<property name="telephone"></property>
<property name="enrolldate" type="timestamp"/>
<set name="roles" table="admin_role" inverse="false" lazy="false" >
<key column="admin_id"></key>
<many-to-many class="Role" column="role_id"/>
</set>
<set name="banks" inverse="false" cascade="all">
<key column="admin_id" />
<one-to-many class="com.zqw.pojo.Bank" />
</set>
</class>
</hibernate-mapping>
Role.hbm.xml映射
<hibernate-mapping
package="com.zqw.pojo">
<class name="Role" table="role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="admins" table="admin" lazy="false">
<key column="role_id"/>
<many-to-many class="Admin" column="admin_id"/>
</set>
</class>
</hibernate-mapping>
Bank.hbm.xml映射
<hibernate-mapping>
<class name="com.zqw.pojo.Bank" table="BANK" >
<id name="id" type="java.lang.Integer">
<column name="ID" precision="11" scale="0" />
<generator class="native"/>
</id>
<property name="bankName" type="java.lang.String">
<column name="BANK_NAME" length="50" />
</property>
<property name="bankSal" type="java.lang.String">
<column name="BANK_SAL" length="50" />
</property>
<!--当然也不需要写外键adminId-->
</class>
</hibernate-mapping>
测试如下
//@Test
public void save(){
Admin admin = new Admin();
admin.setAdmin_code("zgdw");
admin.setName("zgdw");
admin.setEmail("110@qq.com");
admin.setPassword("111");
admin.setEnrolldate(new Date(System.currentTimeMillis()));
admin.setTelephone("110");
//多对多
int[] ids = {1,2};
Set<Role> roles = new HashSet<Role>();
for (int i:ids){
Role role = new Role();
role.setId(i);
roles.add(role);
}
//一对多
Set<Bank> bk = new HashSet<Bank>();
Bank ba = new Bank();
ba.setBankName("建行");
ba.setBankSal("100");
bk.add(b1);
Bank ba2 = new Bank();
ba2.setBankName("招商");
ba2.setBankSal("200");
bk.add(ba2);
admin.setBanks(bk);
admin.setRoles(roles);
dao.save(admin);
}
打印sql语句
Hibernate:
insert
into
admin
(admin_code, password, name, email, telephone, enrolldate)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
BANK
(BANK_NAME, BANK_SAL)
values
(?, ?)
Hibernate:
insert
into
BANK
(BANK_NAME, BANK_SAL)
values
(?, ?)
Hibernate:
insert
into
admin_role
(admin_id, role_id)
values
(?, ?)
Hibernate:
insert
into
admin_role
(admin_id, role_id)
values
(?, ?)
Hibernate:
update
BANK
set
admin_id=?
where
ID=?
我们看到执行过程，一对多有一个update，数据库中没有数据则插入数据，然后跟新bank表的admin_id这个字段。因此倘若bank表有以前有一样的数据，那么会跟新admin_id为当前的数据。（我的应用：设备与端口，一般是先增加端口，端口的shebeiId这个字段为0，然后为设备增加端口，此时端口表的shebeiId变为当前的设备ID.)
多对一，多个Service使用cost，在多方数据表设置外键，即多方Service增加cost_id字段
Service.java实体类
public class Service{
private int id;
private String name;
private Cost cost;//属于cost，其实就是cost_id（mapping文件）
}
Cost.java实体类
public class Cost {
private int id;
private String name;
}
Srevice.hbm.xml映射
<hibernate-mapping>
<class name="com.zqw.pojo.Service" table="SERVICE">
<id name="id" type="java.lang.Integer">
<column name="ID" precision="10" scale="0" />
<generator class="native"/>
</id>
<many-to-one name="cost" class="com.zqw.pojo.Cost" fetch="select">
<column name="COST_ID" precision="4" scale="0" not-null="true" />
</many-to-one>
<property name="name" type="java.lang.String">
<column name="NAME" length="15" not-null="true" />
</property>
</class>
</hibernate-mapping>
Cost.hbm.xml映射
<hibernate-mapping>
<class name="com.zqw.pojo.Cost" table="COST">
<id name="id" type="java.lang.Integer">
<column name="ID" precision="4" scale="0" />
<generator class="native"/>
</id>
<property name="name" type="java.lang.String">
<column name="NAME" length="50" not-null="true" />
</property>
</class>
</hibernate-mapping>
测试如下：
public void save(){
Cost c = dao2.findById(1);//把cost为1的数据取出来
Service s = new Service();
s.setName("zgdw");
s.setCost(c);
dao.save(s);
}
打印sql语句
Hibernate:
select
cost0_.ID as ID8_0_,
cost0_.NAME as NAME8_0_,
from
COST cost0_
where
cost0_.ID=?
Hibernate:
insert
into
SERVICE
(COST_ID,NAME)
values
(?, ?)
我们看到往Service数据表的cost_id字段增加数据，也就是cost_id为必须，cost的name这些都可以不需要，和mapping文件有关。（我的应用：jsp页面隐藏service.cost.id,但是可以显示cos.name）
这是我对hibernate的一些初步的总结，当然也可以在实体类里加上如List其他的数据，不一定要和数据表元素一一对应，如有什么错误的地方欢迎大家矫正，谢谢。
分享到：
相关推荐
### Hibernate知识点总结 #### 一、Hibernate概述 Hibernate是一个开源的ORM（Object Relational Mapping，对象关系映射）框架，用于Java应用与关系型数据库之间的交互。它通过使用描述对象和数据库之间映射的元...
在开始使用 Hibernate 之前，你需要将其添加到项目的类路径中。这通常通过 Maven 或 Gradle 的依赖管理来完成。配置 Hibernate 包括设置主配置文件（hibernate.cfg.xml），其中包含了数据库连接信息，如 URL、用户名...
《Hibernate4总结文档》 Hibernate4作为一款强大的Java对象关系映射框架，简化了数据库操作，使得开发者可以更专注于业务逻辑而不是数据库层面的细节。本文将深入探讨Hibernate4的配置和使用，帮助开发者更好地理解...
Hibernate 使用参考文档 Hibernate 是一个流行的 Java持久层框架，它提供了一种对象关系映射（Object-Relational Mapping，ORM）机制，用于将 Java 对象与关系数据库之间建立映射关系。本文档旨在指导读者快速从 ...
本文主要总结了Hibernate中常见的注解用法，涵盖了类级别和属性级别的注解，以及与主键和非主键相关的注解。 1. 类级别注解： - `@Entity`: 这个注解是必不可少的，它告诉Hibernate一个Java类是一个实体，可以映射...
【Hibernate 简单 PPT 总结】 Hibernate 是一个流行的开源对象关系映射（ORM）框架，它简化了Java应用程序对数据库的操作。通过提供一套API和元数据，Hibernate允许开发者将业务对象直接映射到数据库表，从而避免了...
**Hibernate学习笔记与总结** Hibernate 是一款开源的对象关系映射（ORM）框架，它为Java开发者提供了一种在关系数据库上操作对象数据的便捷方式。本文将深入探讨Hibernate的核心概念、配置、实体类、映射文件、...
Hibernate是一款强大的Java对象关系映射（ORM）框架，它极大地简化了数据库操作，使得开发者可以使用面向对象的方式处理数据库事务。在本文中，我们将深入探讨Hibernate的关键概念、配置、实体管理、查询语言以及...
但在某些情况下，可能会分开使用 `hibernate.properties` 和 `hibernate.cfg.xml` 两个文件： - `hibernate.properties`: 主要用于配置数据连接、二级缓存、连接池等信息。 - `hibernate.cfg.xml`: 主要用于配置...
例如，如果要使用 Hibernate 创建一张名为 t_user 的表，包含主键 id、name、age 和 pwd 四个字段，我们需要创建一个对应 Pojo 类（如 User），并确保其属性与表字段一一对应，然后使用 Hibernate API 进行实例化、...
**标题：“Hibernate课程的总结”** 在学习Hibernate框架的过程中，我们深入探讨了它在Java企业级应用中的核心地位。Hibernate作为一个强大的对象关系映射（ORM）工具，它简化了数据库与Java对象之间的交互，消除了...
**HIBERNATE技术总结** Hibernate 是一个流行的 Java 应用程序框架，它提供了一种对象关系映射（ORM）解决方案，将数据库操作转化为面向对象的编程。此文档旨在研究和对比 Hibernate 技术的不同方面，帮助开发者更...
**hibernate学习总结** Hibernate 是一款开源的对象关系映射（ORM）框架，它极大地简化了Java应用程序与数据库之间的交互。在Java世界中，Hibernate 提供了一种在对象模型和关系数据库之间进行转换的机制，使得开发...
hibernate开发的关系： one-to-one,many-to-one,many-to-many学习经验总结
本篇将深入探讨Hibernate的四种主要关联关系：一对一（OneToOne）、一对多（OneToMany）、多对一（ManyToOne）和多对多（ManyToMany），并结合实例来阐述每种关系的配置和使用。 1. **一对一关联（OneToOne）** 一...