双向@OneToMany / @ManyToOne关联

最新推荐文章于 2024-07-09 13:49:54 发布

dnc8371

最新推荐文章于 2024-07-09 13:49:54 发布

阅读量556

点赞数

文章标签：数据库 mysql java python hibernate

本文介绍如何在Hibernate中建立双向的一对多和多对一关联，以模拟现实世界的模型，如足球联赛中球队与球员的关系。示例使用MySQL数据库，详细解释了如何创建相关POJO并进行持久化操作。

摘要由CSDN通过智能技术生成

编程的目标之一是代表现实世界中的模型。通常，应用程序需要对实体之间的某些关系进行建模。在上一篇有关Hibernate关联的文章中，我描述了建立“一对一”关系的规则。今天，我将向您展示如何设置双向的“ 一对多 ”和“ 多对一 ”关联。这个例子将基于以前的Hibernate教程。

首先，我需要说我的代码示例将基于一个简单的情况。让我们想象一个足球联赛。每个联赛都有球队，并且在球队中可以扮演一些球员。因此，总结如下：一队有很多球员，一个球员可以为一个队效力。通过这种方式，我们得到了明显的“ 一对多 ”和“ 多对一 ”关系。
在此示例中，我将MySQL用作数据库。以下是用于创建表的脚本：

CREATE TABLE `teams` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

CREATE TABLE `players` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `lastname` varchar(20) NOT NULL,
  `team_id` int(6) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `player's team` (`team_id`),
  CONSTRAINT `player's team` FOREIGN KEY (`team_id`) REFERENCES `teams` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

下一步是创建POJO：

import java.util.Set;

import javax.persistence.*;

@Entity
@Table(name = 'teams')
public class Team {

	@Id
	@GeneratedValue
	private Integer id;

	private String name;

	@OneToMany(mappedBy='team', cascade=CascadeType.ALL)
	private Set

          players;

	public Team(String name) {
		this.name = name;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set

           getPlayers() {
		return players;
	}

	public void setPlayers(Set

            players) {
		this.players = players;
	}
}

我使用@OneToMany是因为一个团队可以拥有许多球员。在下一个POJO中，关联将为@ManyToOne，因为许多球员可以为一个团队效力。

import javax.persistence.*;

@Entity
@Table(name = 'players')
public class Player {

	@Id
	@GeneratedValue
	private Integer id;

	private String lastname;

	@ManyToOne
	@JoinColumn(name = 'team_id')
	private Team team;

	public Player(String lastname) {
		this.lastname = lastname;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getLastname() {
		return lastname;
	}

	public void setLastname(String lastname) {
		this.lastname = lastname;
	}

	public Team getTeam() {
		return team;
	}

	public void setTeam(Team team) {
		this.team = team;
	}
}

在这里，我指定将从拥有方（ Teams ）连接的列（ team_id ）。注意，我没有在POJO中声明team_id字段。如果我需要为球员更换球队，我只需要使用setTeam（Team team） setter。

声明POJO之后，我可以演示如何持久化它们：

...
	public static void main(String[] args) {

		SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
		Session session = sessionFactory.openSession();
		session.beginTransaction();

		Team team = new Team('Barcelona');
		Set

          players = new HashSet

          ();

		Player p1 = new Player('Messi');
		Player p2 = new Player('Xavi');

		p1.setTeam(team);
		p2.setTeam(team);

		players.add(p1);
		players.add(p2);

		team.setPlayers(players);

		session.save(team);

		session.getTransaction().commit();

		session.close();

	}
...

代码执行的结果是：

休眠：插入团队（名称）值（？）
休眠：插入玩家（姓氏，team_id）值（？，？）
休眠：插入玩家（姓氏，team_id）值（？，？）

就是这样，在本教程中，我演示了如何设置“ 一对多 ”和“ 多对一 ”双向关联。在同一个教程中，单向关联的示例没有任何意义。因为Hibernate具有自己的最佳实践：