两实体：Player和Game
Player.java:
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@Entity
public class Player implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private int id;
@Column(length=30)
private String name;
@ManyToMany
@JoinTable(name="player_game",joinColumns=@JoinColumn(name="player_id"),inverseJoinColumns=@JoinColumn(name="game_id"))
private Set<Game> game=new HashSet<Game>();
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Game> getGame() {
return game;
}
public void setGame(Set<Game> game) {
this.game = game;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Player other = (Player) obj;
if (id != other.id)
return false;
return true;
}
}
//------------------------------------------------------------------------------
Game.java:
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
@Entity
public class Game implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private int id;
@Column(length=30)
private String name;
@ManyToMany(mappedBy="game")
private Set<Player> player=new HashSet<Player>();
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Player> getPlayer() {
return player;
}
public void setPlayer(Set<Player> player) {
this.player = player;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Game other = (Game) obj;
if (id != other.id)
return false;
return true;
}
}
//————————————————————————————————————————————————
jpa工具类：
JpaUitls.java
这个类省略
//————————————————————————
//测试类：
import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
public class ManyToManyTest {
public static void main(String[] args) {
Player pl=new Player();
pl.setName("玩家一");
Player pls=new Player();
pls.setName("玩家二");
Game ga=new Game();
ga.setName("游戏一");
Game gas=new Game();
gas.setName("游戏二");
// Set<Player> player=new HashSet<Player>();
// player.add(pl);
// player.add(pls);
Set<Game> game=new HashSet<Game>();
game.add(ga);
game.add(gas);
pl.setGame(game);
pls.setGame(game);
// ga.setPlayer(player);
// gas.setPlayer(player);
EntityManager em=JpaUitls.getEntityManager();
EntityTransaction tran=em.getTransaction();
tran.begin();
em.persist(pl);
em.persist(pls);
em.persist(ga);
em.persist(gas);
// Player p=em.find(Player.class, 1);
// System.out.println(p.getName());
// System.out.println(p.getGame().size());
tran.commit();
em.close();
JpaUitls.closeFactory();
System.out.println("保存成功");
}
}
整个过没有报任何的错误，但是中间表的数据就是不完全，中间表只有两条记录，按照正常的应该的有四条记录才对啊。
下面是操作后数据库中表的信息图片：
这是中间表：
这个中间表正确应该是：
player_id game_id
1 1
2 1
1 2
2 2
这才是想要的结果呀，可是它就出上面那张图片里的数据，纠结
——————————————————————————
这是玩家表：
这是游戏表：
添加评论
关注(0)
相关推荐
在JPA中，关系映射是核心特性之一，它将数据库表之间的关系映射为Java类之间的关系，使数据操作更加直观和方便。本篇将深入探讨JPA中的一对一（OneToOne）、一对多（OneToMany）以及多对多（ManyToMany）关系映射。 ...
在关系数据库中，多对多关联意味着两个表之间存在多个匹配项，每个表的记录都可以与对方表的多个记录相关联。在JPA中，这种关联通常通过中间表（或称为联接表）来实现，这个中间表包含两个表的外键。 接下来，我们...
在关系型数据库中，多对多关联通常通过中间表来实现，而JPA提供了一种声明式的方式来处理这种关联。在双向关联中，两个实体类都可以访问对方的集合，这意味着每个实体都能知道与之关联的所有其他实体。 ### 2. 实现...
**JPA（Java Persistence API）**是Java平台上用于对象关系映射（ORM）的标准API，它为开发人员提供了一种方便的方式来将Java类与数据库表进行映射，从而避免了直接编写SQL语句的繁琐工作。JPA允许你在Java对象...
**Java Persistence API (JPA)** 是Java平台上的一个标准，用于管理关系数据库中的数据，它为开发者提供了一种对象关系映射（ORM）框架，使得开发者可以使用面向对象的方式来处理数据库交互，而无需直接编写SQL语句...
在Java世界中，Java Persistence API（JPA）是用于对象关系映射（ORM）的一种标准框架，它允许开发者将数据库操作与业务逻辑紧密结合，而无需编写大量的SQL代码。本篇文章将深入探讨如何在JPA中映射关联和实现继承。...
在Spring Data JPA中，多对多关联是数据库表间关系的一种常见表示，它允许一个实体实例与多个其他实体实例相互关联。在这个“jpa-day3-manytomany.zip”压缩包中，我们很可能会找到一个关于如何在Spring Data JPA中...
在SpringBoot + JPA的项目中，Oracle作为数据存储，JPA则作为中间层，负责将Java对象转换为数据库中的记录，反之亦然。 **Maven** Maven是Java项目管理工具，用于构建、依赖管理和项目信息管理。它通过定义项目对象...
在Java的持久化框架Hibernate中，多对多（Many-to-Many）关联关系是一种常见的实体间关系类型，它表示一个实体可以与多个其他实体相关联，反之亦然。本示例"Hibernate多对多关联关系demo"将深入探讨如何在实际开发中...
- `@JoinTable`: 处理多对多关系，定义中间表。 3. **身份注解**: - `@Id`: 标记一个字段作为实体的主键。 - `@IdClass`: 使用自定义的复合主键类。 - `@EmbeddedId`: 当主键由多个字段组成时使用，嵌入一个...
JPA通过提供API和元数据来定义Java类如何映射到数据库表，以及如何进行CRUD（创建、读取、更新、删除）操作。 **Hibernate**是JPA的一个实现，它是一个开源的对象关系映射框架。虽然JPA定义了规范，但实际的持久化...
多对多关系在数据库中意味着一个表中的记录可以与另一个表中的多个记录相关联，反之亦然。例如，学生和课程的关系就是一个典型的多对多关系：一个学生可以选修多门课程，而一门课程也可以被多个学生选修。 在...
5. **关联管理**: 包括一对一（OneToOne）、一对多（OneToMany）、多对一（ManyToOne）和多对多（ManyToMany）的关联关系管理。 6. **懒加载和即时加载（Eager and Lazy Loading）**: 对于关联对象，JPA支持延迟...
多对多关系通常涉及到一个中间表，用于存储两个实体的关联信息。在Hibernate中，可以通过`@JoinTable`注解来定义这个关联表，包括表名、连接字段等。例如，我们可以指定学生ID和课程ID作为外键，它们共同构成了关联...
在上面的代码中，`@ManyToMany(mappedBy = "students")`表示`Course`实体的`students`属性是多对多关系的“反向引用”，即`Course`中的每个实例可以有多条关联到`Student`的记录。`@JoinTable`定义了中间表的名称...
8. `@OneToMany`, `@ManyToOne`, `@OneToOne`, `@ManyToMany`：这些注解用于定义实体间的关联关系，如一对一、一对多、多对一和多对多关系。 9. `@JoinColumn` 和 `@JoinTable`：用于在关联关系中指定外键或中间表...
元数据可以通过JPA注解或者XML配置文件来定义，它告诉JPA如何将Java对象映射到数据库表中。 **1.1.4 实体(entity)** 实体是JPA的核心概念之一，代表数据库中的记录。每个实体类都需要通过`javax.persistence.Entity...
2. **建立关联关系**：在实体类中，我们需要使用`@ManyToMany`注解（如果使用的是JPA）或`@CollectionOfElements`（如果使用的是Hibernate）来定义多对多的关系。这些注解告诉MyBatis如何处理中间表，并提供关联对象...
在编程领域，尤其是在Java或Spring框架中，"多对多双向关联"是一个常见的数据库关系映射概念。在数据库设计中，关系模型允许实体之间存在多种联系，而多对多关联是最复杂也是最灵活的一种关系类型。它表示一个实体...