Hibernate第六篇【多对多映射、一对一映射】
前言
前面已经讲解了一对多和多对一的映射是怎么配置了，也讲解了inverse和cascade属性对关联关系的影响，本博文讲解多对多的映射和一对一的映射！
多对多映射
需求：一个项目由多个员工开发，一个员工开发多个项目
设计数据库表
一般地，如果是多对多的映射，我们都会使用一张中间表来保存它们的关联关系….
设计实体
我们在设计实体的时候，一般是核心数据表对应一个JavaBean实体【中间表并不是核心数据表】，那么我们将会设计两个JavaBean对象
project.java
package zhongfucheng.many2many;
import java.util.HashSet;
import java.util.Set;
/**
* Created by ozc on 2017/5/7.
*/
public class Project {
private int projectId;
private String projectName;
//使用Set集合与developer实体维护关系
private Set<Developer> developers = new HashSet<>();
public int getProjectId() {
return projectId;
}
public void setProjectId(int projectId) {
this.projectId = projectId;
}
public String getProjectName() {
return projectName;
}
public void setProjectName(String projectName) {
this.projectName = projectName;
}
public Set<Developer> getDevelopers() {
return developers;
}
public void setDevelopers(Set<Developer> developers) {
this.developers = developers;
}
}
developer.java
package zhongfucheng.many2many;
import java.util.HashSet;
import java.util.Set;
/**
* Created by ozc on 2017/5/7.
*/
public class Developer {
private int developerId;
private String developerName;
//使用Set集合来维护与Project关系
private Set<Project> projects = new HashSet<>();
public int getDeveloperId() {
return developerId;
}
public void setDeveloperId(int developerId) {
this.developerId = developerId;
}
public String getDeveloperName() {
return developerName;
}
public void setDeveloperName(String developerName) {
this.developerName = developerName;
}
public Set<Project> getProjects() {
return projects;
}
public void setProjects(Set<Project> projects) {
this.projects = projects;
}
}
映射配置文件
以项目映射文件为例：我们不急着写，首先来分析一下关键点……想要在多对多映射中产生正确的关联关系，下面几步必不可少：
- 配置映射集合的属性(developers)
- 映射集合对应的中间表(developer_project)
- 中间表的外键字段(project_id)
- 集合元素的类型(Developer)
- 中间表另外的外键字段(developer_id)
Project和Developer的映射文件都需要这几个关键步骤
Project映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.many2many">
<class name="Project" table="Project">
<!--映射主键-->
<id name="projectId" column="projectId">
<generator class="native"></generator>
</id>
<!--映射普通字段-->
<property name="projectName" column="projectName"></property>
<!--映射多对多的关系-->
<!--Set的属性名称为developers，对应developer_project表-->
<set name="developers" table="developer_project">
<!--对应developer_project表的外键列-->
<key column="project_id"></key>
<!--集合的类型和developer_project表的另一个外键列-->
<many-to-many column="developer_id" class="Developer"></many-to-many>
</set>
</class>
</hibernate-mapping>
Developer映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.many2many">
<class name="Developer" table="Developer">
<!--映射主键-->
<id name="developerId" column="developerId">
<generator class="native"></generator>
</id>
<!--映射普通字段-->
<property name="developerName" column="developerName"></property>
<!--映射多对多的关系-->
<!--Set的属性名称为developers，对应developer_project表-->
<set name="projects" table="developer_project">
<!--对应developer_project表的外键列-->
<key column="developer_id"></key>
<!--集合的类型和developer_project表的另一个外键列-->
<many-to-many column="project_id" class="Project"></many-to-many>
</set>
</class>
</hibernate-mapping>
测试
package zhongfucheng.many2many;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
/**
* Created by ozc on 2017/5/6.
*/
public class App2 {
public static void main(String[] args) {
/*
*
*
* Project Developer
电商系统
曹吉
王春
OA系统
王春
老张
*/
//创建对象
Developer cj = new Developer();
Developer wc = new Developer();
Developer lz = new Developer();
Project ds = new Project();
Project oa = new Project();
//设置对象的数据
cj.setDeveloperName("曹吉");
wc.setDeveloperName("王春");
lz.setDeveloperName("老张");
oa.setProjectName("OA系统");
ds.setProjectName("电商系统");
//使用Project来关联数据【在多对多中，一样的】
oa.getDevelopers().add(wc);
oa.getDevelopers().add(lz);
ds.getDevelopers().add(cj);
ds.getDevelopers().add(wc);
//获取加载配置管理类
Configuration configuration = new Configuration();
//加载User的映射文件！
configuration.configure().addClass(Developer.class).addClass(Project.class);
//创建Session工厂对象
SessionFactory factory = configuration.buildSessionFactory();
//得到Session对象
Session session = factory.openSession();
//使用Hibernate操作数据库，都要开启事务,得到事务对象
Transaction transaction = session.getTransaction();
//开启事务
transaction.begin();
//在Project映射文件中设置级联保存了
session.save(oa);
session.save(ds);
//提交事务
transaction.commit();
//关闭Session
session.close();
}
}执行了9条SQL语句，数据库中的记录也是正确的。
一对一的映射
需求：用户与身份证信息..一个用户对应一个身份证
数据库表设计
对于数据库表设计我们有两种方式
- 第一种：在身份证的数据表中设置一个外键来维护用户的关系，这个外键也应该是唯一的【一个用户对应一张身份证】
- 第二种：在身份证的数据表中使用主键+外键的方式来维护用户的关系。
设计实体
idCard.java
package zhongfucheng.one2one;
/**
* Created by ozc on 2017/5/7.
*/
public class IdCard {
private int idCardId;
private String idCardName;
//维护与用户之间的关系
private User user ;
public int getIdCardId() {
return idCardId;
}
public void setIdCardId(int idCardId) {
this.idCardId = idCardId;
}
public String getIdCardName() {
return idCardName;
}
public void setIdCardName(String idCardName) {
this.idCardName = idCardName;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
User.java
package zhongfucheng.one2one;
/**
* Created by ozc on 2017/5/7.
*/
public class User {
private int userId;
private String userName;
//维护与身份证一对一的关系
private IdCard idCard ;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
第一种方式映射文件
我们有两种方式来设计数据库中的表实现一对一的关系，首先我们来挑比较熟悉的外键方式来写映射文件
user映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="zhongfucheng.one2one">
<class name="User" table="User">
<!--映射主键-->
<id name="userId" column="userId">
<generator class="native"></generator>
</id>
<!--映射普通字段-->
<property name="userName" column="userName"></property>
<!--
User是没有外键字段的表
一对一的关系的属性名称name是idCard
类型是IdCard
-->
<one-to-one name="idCard" class="IdCard"></one-to-one>
</class>
</hibernate-mapping>
idCard映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="zhongfucheng.one2one">
<class name="IdCard" table="IdCard">
<!--映射主键-->
<id name="idCardId" column="idCardId">
<generator class="native"></generator>
</id>
<!--映射普通字段-->
<property name="idCardName" column="idCardName"></property>
<!--idCart是有外键的表，要把字段映射成外键，用的是manyToOne-->
<!--
外键的属性name是user
对应表的字段是userId
属性的类型是User
该字段需要唯一性 unique
-->
<many-to-one name="user" column="user_id" class="User" unique="true" cascade="save-update"></many-to-one>
</class>
</hibernate-mapping>
测试
要使用IdCart来维护User的关联关系。
- 如果使用User来维护idCart的关联关系，idCart的外键列是为NULL的，因为重头到尾我们都没有给它赋值
- 而使用IdCart来维护User，是外键值是根据User的主键id来生成的
package zhongfucheng.one2one;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
/**
* Created by ozc on 2017/5/6.
*/
public class App3 {
public static void main(String[] args) {
//创建对象
User user = new User();
IdCard idCard = new IdCard();
//设置对象的数据
user.setUserName("你好");
idCard.setIdCardName("身份证001");
//一对一关联数据
idCard.setUser(user);
//获取加载配置管理类
Configuration configuration = new Configuration();
//加载User的映射文件！
configuration.configure().addClass(User.class).addClass(IdCard.class);
//创建Session工厂对象
SessionFactory factory = configuration.buildSessionFactory();
//得到Session对象
Session session = factory.openSession();
//使用Hibernate操作数据库，都要开启事务,得到事务对象
Transaction transaction = session.getTransaction();
//开启事务
transaction.begin();
//保存对象的数据,idCard配置文件使用级联保存
session.save(idCard);
//提交事务
transaction.commit();
//关闭Session
session.close();
}
}第二种方式映射文件
因为IdCart使用userId作为了主键，因此需要在JavaBean中配置多一个属性UserId…其他的都不用变
private int userId;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}在Hibernate第三篇讲解配置的时候，在generator节点下还有一个属性没有讲解，也就是foreign属性…现在来填坑了..
idCard映射文件
idCart的映射文件主要在于:将主键也映射成外键来使用，这就需要用到foreign属性值了
使用<one-to-one>标签来配置基于主键的映射
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="zhongfucheng.one2one2.one2one">
<class name="IdCard" table="IdCard">
<!--映射主键-->
<id name="userId" column="userId">
<!--
做主键的同时也做外键
外键的类型名称为user
-->
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
<!--映射普通字段-->
<property name="idCardName" column="idCardName"></property>
<property name="idCardId" column="idCartId"></property>
<!--
有外键的一方：
基于主键映射，使用oneToOne
constrained="true" 指定在主键上添加外键约束
-->
<one-to-one name="user" class="User" constrained="true"></one-to-one>
</class>
</hibernate-mapping>
user映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="zhongfucheng.one2one2.one2one">
<class name="User" table="User">
<!--映射主键-->
<id name="userId" column="userId">
<generator class="native"></generator>
</id>
<!--映射普通字段-->
<property name="userName" column="userName"></property>
<!--
User是没有外键字段的表
一对一的关系的属性名称name是idCard
类型是IdCard
-->
<one-to-one name="idCard" class="IdCard"></one-to-one>
</class>
</hibernate-mapping>
测试
package zhongfucheng.one2one2.one2one;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
/**
* Created by ozc on 2017/5/6.
*/
public class App4 {
public static void main(String[] args) {
//创建对象
User user = new User();
IdCard idCard = new IdCard();
//设置对象的数据
user.setUserName("你好3");
idCard.setIdCardName("身份证003");
idCard.setIdCardId(4235);
//一对一关联数据
idCard.setUser(user);
//获取加载配置管理类
Configuration configuration = new Configuration();
//加载User的映射文件！
configuration.configure().addClass(User.class).addClass(IdCard.class);
//创建Session工厂对象
SessionFactory factory = configuration.buildSessionFactory();
//得到Session对象
Session session = factory.openSession();
//使用Hibernate操作数据库，都要开启事务,得到事务对象
Transaction transaction = session.getTransaction();
//开启事务
transaction.begin();
//保存对象的数据,idCard配置文件使用级联保存
session.save(idCard);
//提交事务
transaction.commit();
//关闭Session
session.close();
}
}
如果您觉得这篇文章帮助到了您，可以给作者一点鼓励
浙公网安备 33010602011771号