使用注解的Hibernate one-to-many映射

已于 2022-12-29 10:46:52 修改
阅读量9.5k 收藏
点赞数 1
分类专栏： hibernate 文章标签： Hibernate one-to-many
于 2015-12-24 23:32:26 首次发布

One to many映射关系指的是两个实体间一个实体可以和多个实体有关联关系，但是多的这一端只能和一的这一端的一个实例有关系。它是一个1 到 n的关系。例如在任何的公司员工可以注册多个银行账户，一个银行账户只能和一个员工相关联，在这篇文章中我们将会学习怎么在Hibernate3中建立这种映射关系。

问题陈述

我们要写两个实体一个是Employee实体另一个是Account实体，这样多个银行账户就可以和一个员工关联了，但是这些账户不能被两个或以上的用户共享。

设计解决方案

这种问题可以使用两种方式解决。一种方式是在Account表中设置一个外键EMPLOYEE_ID，这一列指向Employee表的主键，这种方式没有两个账号可以和多个用户相关联，显然，为了完成这种限制，账号应该是独特的。另一种方式是建立一个连接表，比如说是叫EMPLOYEE_ACCOUNT，这个表有两列，EMP_ID作为EMPLOYEE表中主键的外键，对于ACCOUNT_ID也是这种情况。

使用外键连接

这种方式，两个实体都要负责建立关系并维护这种关系，EMPLOYEE实体应该申明的关系是one to many，Account实体应该声明的关系是many  to one。首先来看一下关系设计：
EMPLOYEE实体 
package hibernate.test.oneToMany.foreignKeyAsso;

import java.io.Serializable;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity(name = "ForeignKeyAssoEntity")
@Table(name = "Employee", uniqueConstraints = {
@UniqueConstraint(columnNames = "ID"),
@UniqueConstraint(columnNames = "EMAIL") })
public class EmployeeEntity implements Serializable {

	private static final long serialVersionUID = -1798070786993154676L;

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "ID", unique = true, nullable = false)
	private Integer employeeId;

	@Column(name = "EMAIL", unique = true, nullable = false, length = 100)
	private String email;

	@Column(name = "FIRST_NAME", unique = false, nullable = false, length = 100)
	private String firstName;

	@Column(name = "LAST_NAME", unique = false, nullable = false, length = 100)
	private String lastName;

	@OneToMany(cascade=CascadeType.ALL)
	@JoinColumn(name="EMPLOYEE_ID")
	private Set<AccountEntity> accounts;

	public Integer getEmployeeId() {
		return employeeId;
	}

	public void setEmployeeId(Integer employeeId) {
		this.employeeId = employeeId;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public Set<AccountEntity> getAccounts() {
		return accounts;
	}

	public void setAccounts(Set<AccountEntity> accounts) {
		this.accounts = accounts;
	}
}

Account实体 
package hibernate.test.oneToMany.foreignKeyAsso;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity(name = "ForeignKeyAssoAccountEntity")
@Table(name = "ACCOUNT", uniqueConstraints = {
@UniqueConstraint(columnNames = "ID")})
public class AccountEntity implements Serializable
{

	private static final long serialVersionUID = -6790693372846798580L;

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "ID", unique = true, nullable = false)
	private Integer accountId;

	@Column(name = "ACC_NUMBER", unique = true, nullable = false, length = 100)
	private String accountNumber;

	@ManyToOne
	private EmployeeEntity employee;

	public Integer getAccountId() {
		return accountId;
	}

	public void setAccountId(Integer accountId) {
		this.accountId = accountId;
	}

	public String getAccountNumber() {
		return accountNumber;
	}

	public void setAccountNumber(String accountNumber) {
		this.accountNumber = accountNumber;
	}

	public EmployeeEntity getEmployee() {
		return employee;
	}

	public void setEmployee(EmployeeEntity employee) {
		this.employee = employee;
	}
}

测试代码 
package hibernate.test.oneToMany;

import hibernate.test.HibernateUtil;
import hibernate.test.oneToMany.foreignKeyAsso.AccountEntity;
import hibernate.test.oneToMany.foreignKeyAsso.EmployeeEntity;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;

public class TestForeignKeyAssociation
{

	public static void main(String[] args)
	{
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();

		AccountEntity account1 = new AccountEntity();
		account1.setAccountNumber("Account detail 1");

		AccountEntity account2 = new AccountEntity();
		account2.setAccountNumber("Account detail 2");

		AccountEntity account3 = new AccountEntity();
		account3.setAccountNumber("Account detail 3");

		//Add new Employee object
		EmployeeEntity firstEmployee = new EmployeeEntity();
		firstEmployee.setEmail("demo-user-first@mail.com");
		firstEmployee.setFirstName("demo-one");
		firstEmployee.setLastName("user-one");

		EmployeeEntity secondEmployee = new EmployeeEntity();
		secondEmployee.setEmail("demo-user-second@mail.com");
		secondEmployee.setFirstName("demo-two");
		secondEmployee.setLastName("user-two");

		Set<AccountEntity> accountsOfFirstEmployee = new HashSet<AccountEntity>();
		accountsOfFirstEmployee.add(account1);
		accountsOfFirstEmployee.add(account2);

		Set<AccountEntity> accountsOfSecondEmployee = new HashSet<AccountEntity>();
		accountsOfSecondEmployee.add(account3);

		firstEmployee.setAccounts(accountsOfFirstEmployee);
		secondEmployee.setAccounts(accountsOfSecondEmployee);
		//Save Employee
		session.save(firstEmployee);
		session.save(secondEmployee);

		session.getTransaction().commit();
		HibernateUtil.shutdown();
	}
}
Output:

Hibernate: insert into Employee (EMAIL, FIRST_NAME, LAST_NAME) values (?, ?, ?)
Hibernate: insert into ACCOUNT (ACC_NUMBER, employee_ID) values (?, ?)
Hibernate: insert into ACCOUNT (ACC_NUMBER, employee_ID) values (?, ?)
Hibernate: insert into Employee (EMAIL, FIRST_NAME, LAST_NAME) values (?, ?, ?)
Hibernate: insert into ACCOUNT (ACC_NUMBER, employee_ID) values (?, ?)
Hibernate: update ACCOUNT set EMPLOYEE_ID=? where ID=?
Hibernate: update ACCOUNT set EMPLOYEE_ID=? where ID=?
Hibernate: update ACCOUNT set EMPLOYEE_ID=? where ID=?
 

使用关联表

这种方式使用关联表存储两个实体间的关系@JoinTable注解是用来建立这种关系的，先来看一下数据库模式
EMPLOYEE实体 
package hibernate.test.oneToMany.joinTable;

import java.io.Serializable;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity(name = "JoinTableEmployeeEntity")
@Table(name = "Employee", uniqueConstraints = {
@UniqueConstraint(columnNames = "ID"),
@UniqueConstraint(columnNames = "EMAIL") })
public class EmployeeEntity implements Serializable
{
	private static final long serialVersionUID = -1798070786993154676L;

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "ID", unique = true, nullable = false)
	private Integer employeeId;

	@Column(name = "EMAIL", unique = true, nullable = false, length = 100)
	private String email;

	@Column(name = "FIRST_NAME", unique = false, nullable = false, length = 100)
	private String firstName;

	@Column(name = "LAST_NAME", unique = false, nullable = false, length = 100)
	private String lastName;

	@OneToMany(cascade=CascadeType.ALL)
	@JoinTable(name="EMPLOYEE_ACCOUNT", joinColumns={@JoinColumn(name="EMPLOYEE_ID", referencedColumnName="ID")}
	, inverseJoinColumns={@JoinColumn(name="ACCOUNT_ID", referencedColumnName="ID")})
	private Set<AccountEntity> accounts;

	public Integer getEmployeeId() {
		return employeeId;
	}

	public void setEmployeeId(Integer employeeId) {
		this.employeeId = employeeId;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public Set<AccountEntity> getAccounts() {
		return accounts;
	}

	public void setAccounts(Set<AccountEntity> accounts) {
		this.accounts = accounts;
	}
}

Account实体 
package hibernate.test.oneToMany.joinTable;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity(name = "JoinTableAccountEntity")
@Table(name = "ACCOUNT", uniqueConstraints = {
@UniqueConstraint(columnNames = "ID")})
public class AccountEntity implements Serializable
{

	private static final long serialVersionUID = -6790693372846798580L;

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "ID", unique = true, nullable = false)
	private Integer accountId;

	@Column(name = "ACC_NUMBER", unique = true, nullable = false, length = 100)
	private String accountNumber;

	public Integer getAccountId() {
		return accountId;
	}

	public void setAccountId(Integer accountId) {
		this.accountId = accountId;
	}

	public String getAccountNumber() {
		return accountNumber;
	}

	public void setAccountNumber(String accountNumber) {
		this.accountNumber = accountNumber;
	}
}

在配置文件中配置实体，我们已经有了两个在运行时的实体，我们必须在配置文件中增加他们。请注意只有一个集合实体可以在配置文件中配置，否则会有意外的情况发生 
< ?xml version="1.0" encoding="utf-8"?>
< !DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatetest</property>
		<property name="hibernate.connection.password">XXXXXX</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="show_sql">true</property>
		<property name="hbm2ddl.auto">create</property>
		<mapping clas="hibernate.test.oneToMany.foreignKeyAsso.AccountEntity"></mapping>
		<mapping clas="hibernate.test.oneToMany.foreignKeyAsso.EmployeeEntity"></mapping>
	</session-factory>
</hibernate-configuration>

测试代码： 
package hibernate.test.oneToMany;

import hibernate.test.HibernateUtil;
import hibernate.test.oneToMany.joinTable.AccountEntity;
import hibernate.test.oneToMany.joinTable.EmployeeEntity;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;

public class TestJoinTable
{
	public static void main(String[] args)
	{
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();

		AccountEntity account1 = new AccountEntity();
		account1.setAccountNumber("123-345-65454");

		AccountEntity account2 = new AccountEntity();
		account2.setAccountNumber("123-345-6542222");

		//Add new Employee object
		EmployeeEntity emp = new EmployeeEntity();
		emp.setEmail("demo-user@mail.com");
		emp.setFirstName("demo");
		emp.setLastName("user");

		Set<AccountEntity> accounts = new HashSet<AccountEntity>();
		accounts.add(account1);
		accounts.add(account2);

		emp.setAccounts(accounts);
		//Save Employee
		session.save(emp);

		session.getTransaction().commit();
		HibernateUtil.shutdown();
	}
}

Output:

Hibernate: insert into Employee (EMAIL, FIRST_NAME, LAST_NAME) values (?, ?, ?)
Hibernate: insert into ACCOUNT (ACC_NUMBER) values (?)
Hibernate: insert into ACCOUNT (ACC_NUMBER) values (?)
Hibernate: insert into EMPLOYEE_ACCOUNT (EMPLOYEE_ID, ACCOUNT_ID) values (?, ?)
Hibernate: insert into EMPLOYEE_ACCOUNT (EMPLOYEE_ID, ACCOUNT_ID) values (?, ?)

 
可以在原文中下载源码，原文链接：http://howtodoinjava.com/2012/11/17/hibernate-one-to-many-mapping-using-annotations/
关注我，获取400个的赚钱金点子，轻松开启程序员的副业生涯

txxs
关注
专栏目录
Hibernate one-to-many / many-to-one关系映射
07-03
NULL 博文链接：https://xiangtui.iteye.com/blog/680938
(4)Hibernate中的many-to-one和one-to-many关系
03-17
本话题主要探讨两种基本的关系映射类型：many-to-one（多对一）和one-to-many（一对多）。这两种关系映射是数据库中常见的关联类型，理解和掌握它们对于开发高质量的Java应用至关重要。 1. many-to-one关系 many-to...
hibernate的OneToMany和ManyToOne映射
justlpf的专栏
01-06 480
这里@JoinColumn()中name="member_id"指子表（MANY）中的字段， referencedColumnName = "id"指当前表(ONE)中的字段。这里的name=“member_id”， 指的当前表（MANY）的字段，referencedColumnName = "id"只能是主表（ONE）的主键id。这里的name=“member_id”， 指的当前表（MANY）的字段，referencedColumnName = "id"只能是主表（ONE）的主键id。
java springboot中@OneToMany、@ManyToOne以及@ManyToMany讲解
最新发布
m0_72642319的博客
07-09 1545
java springboot中@OneToMany、@ManyToOne以及@ManyToMany讲解
hibernate注解onetomany manytoone
系统运维
09-19 107
@OneToMany(cascade =CascadeType.ALL,fetch=FetchType.EAGER) @JoinColumn(name="user_id") @ManyToOne @JoinColumn(name="user_id") //不加出现3张表
Hibernate @OneToMany 一对多注解
07-22 185
配置一 @OneToMany(cascade=CascadeType.ALL) @JoinColumn(name="fatherID") //对应儿子类的哪个字段 子类中配置ManyToOne的字段名称 private Set<Child> children; 配置二 @OneToMany(mappedBy ...
hibernate-one-to-many
05-18
<many-to-one name="department" class="com.example.Department" column="DEPARTMENT_ID" /> ``` 如果使用注解，上述关系已经在实体类中定义。 ### 3. 操作一对多关系 在实际应用中，我们可以通过Hibernate提供...
hibernate one-to-many 单/双向关联映射配置心得
03-16
本文主要关注Hibernate中的一个核心概念——一对一（One-to-One）、一对多（One-to-Many）和多对一（Many-to-One）关联映射，特别是关于“一到多”单向和双向关联映射的配置心得。 首先，让我们了解“一到多”关联...
Hibernate one-to-many-annotation
07-30
本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`注解用于在Java类中表示一个实体与另一实体的多对一关系。例如，一个用户可以拥有多个订单，而每个订单...
@OneToMany或@ManyToOne的用法-annotation关系映射篇（上)
热门推荐
AndyLizh的专栏
03-30 7万+
例如我们用一个例子来开启JPA的一对多和多对一的学习。   比如你去当当网上买书籍，当当网就给你一个订单。   通过上面的业务活动描述你可以分析得出：一个订单可以包含一个或多个订单项.那么我们将将订单和订单项设计关系为(1:N)一对多的关系(排除0)。得出关系我们就使用JPA来实现这个关系(关于建立JPA和基本的配置我就不再说了，如果不明白请看JPA入门篇)。 首先建立订单实体类
Hibernate OneToMany等注解详解
亻也倔强小男人
03-14 3949
cascade属性： 指定级联操作的行为(可多选)CascadeType.PERSIST 级联新增（又称级联保存）： 获取A对象里也同时也重新获取最新的B时的对象。即会重新查询数据库里的最新数据，并且，只有A类新增时，会级联B对象新增。若B对象在数据库存（跟新）在则抛异常（让B变为 持久态），对应EntityManager的presist方法,调用JPA规范中的persist()，不适用...
Hibernate的那些事-manyToOne注解映射(Map集合)
skewen的专栏
04-21 4129
hibernate4,onetomany
weixin_34256074的博客
09-10 81
项目搭建使用spring3 + hibernate4 + spring mvc 几个框架 来说说hibernate4onetomany onetomany：应用场景如一个团队有很多玩家。贴代码： import java.util.Set; import javax.persistence.*; @Entity @Table(name = "teams") public class...
hibernate单向一对多关联映射(one-to-many)XML与注解版
fendo
05-04 4416
单向一对多关联映射原理:  hibernate对于一对多的关系的处理，是通过操作classess端，间接操作或者自动操作Student端。比如添加，我直接添加classess端的数据，多个Student就会被添加自动添加进去。也可以通过这个classess获取到所有对应的学生信息。 一对多关联映射和多对一关联映射原理是一致的，都是在多的一端加入一个外键，指向
Hibernate的注解many-to-one
topMan'blog
11-28 192
項目中一個實例：    最近使用annotation做hibernate映射，有两张表乘客（Passanger）表 和订单（VacationOrder )表，乘客表和订单表是ManyToOne,业务只需要从订单表出发设置不同乘客,根据乘客查看预订的订单，采用双向关联,ManyToOne 和Many-To-One    VacationOrder 對象中关于乘客的注解: VacationOr...
hibernate映射技巧one-to-many(单项一对多)
yangxn的专栏
09-09 4943
    一对多关系在系统实现中也很常见。典型的例子就是父亲与孩子的关系。 而在我们现在的这个示例中，每个用户（TUser）都关联到多个地址(TAddress)，如一个用户可能拥有办公室地址、家庭地址等多个地址属性。这样，在系统中，就反应为一个“一对多”关联。一对多关系分为单向一对多关系和双向一对多关系。单向一对多关系只需在“一”方进行配置，双向一对多关系需要在关联双方均加以配置。 
hibernate one-to-many many-to-one 双向注解
xwygn的专栏
12-21 540
Hibernate 3.3.1 Maven 3.0.4 MySQL 5.5.13 Myeclipse 8.6.1 建表语句： DROP TABLE IF EXISTS `t_company`; CREATE TABLE `t_company` ( `companyId` int(10) unsigned NOT NULL AUTO_INCREMENT, `compa
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值