Spring Data JPA处理一对一、一对多、多对多关系映射

最新推荐文章于 2024-08-16 07:38:13 发布
最新推荐文章于 2024-08-16 07:38:13 发布
阅读量2.3k 收藏 8
点赞数
分类专栏： # SpringData 文章标签： Spring Data JPA 关系映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rj2017211811/article/details/96196204
版权

1.一对一的关联
一对一关联可以把外键放在任何一放，假设Users和Roles是一对一的关系，代码如下
Users.java

package per.czt.pojo;

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.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="t_users")
public class Users {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="user_id")
	private Integer userid;
	@Column(name="user_name")
	private String username;
	@Column(name="user_age")
	private Integer userage;
	
	@OneToOne(cascade=CascadeType.PERSIST)
	@JoinColumn(name="roles_id")
	private Roles roles;
	public Users() {
		// TODO Auto-generated constructor stub
	}
	public Integer getUserid() {
		return userid;
	}
	public void setUserid(Integer userid) {
		this.userid = userid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public Integer getUserage() {
		return userage;
	}
	public void setUserage(Integer userage) {
		this.userage = userage;
	}
	public Roles getRoles() {
		return roles;
	}
	public void setRoles(Roles roles) {
		this.roles = roles;
	}
	@Override
	public String toString() {
		return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
	}
}

Roles.java

package per.czt.pojo;

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.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="t_roles")
public class Roles {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="role_id")
	private Integer roleid;
	@Column(name="role_name")
	private String rolename;
	@OneToOne(mappedBy="roles",cascade=CascadeType.PERSIST)
	private Users users;
	public Integer getRoleid() {
		return roleid;
	}

	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}

	public String getRolename() {
		return rolename;
	}

	public void setRolename(String rolename) {
		this.rolename = rolename;
	}

	public Roles() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Users getUsers() {
		return users;
	}

	public void setUsers(Users users) {
		this.users = users;
	}

	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + ", users=" + users + "]";
	}

	
	

}

测试类

package per.czt.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import per.czt.dao.UsersDao;
import per.czt.pojo.Roles;
import per.czt.pojo.Users;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value="classpath:applicationContext.xml")
public class AssociationOneToOneTest {
	
	@Autowired
	private UsersDao usersDao;
	
	@Test

	public void test1() {
	   //创建角色
		Roles roles=new Roles();
		roles.setRolename("admin");
		//创建用户
		Users users=new Users();
		users.setUserage(13);
		users.setUsername("张晓萌");
		//建立关联
		users.setRoles(roles);
		roles.setUsers(users);
		//保存对象
		this.usersDao.save(users);
		//this.usersDao.save(users);
		
		
	}
	@Test
	public void test2() {
		Users users=usersDao.findOne(22);
		System.out.println(users);
		System.out.println(users.getRoles());
	}

}

2.一对多关系
假设角色和用户是一对多的关系，一个角色对于多个用户，一个用户只能有一个角色
Roles.java

package per.czt.pojo;

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


import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

import javax.persistence.Table;

@Entity
@Table(name="t_roles4")
public class Roles {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="role_id")
	private Integer roleid;
	@Column(name="role_name")
	private String rolename;
	
	@OneToMany(mappedBy="roles")
	private Set<Users> users=new HashSet<Users>();	

	public Integer getRoleid() {
		return roleid;
	}

	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}

	public String getRolename() {
		return rolename;
	}

	public void setRolename(String rolename) {
		this.rolename = rolename;
	}

	public Roles() {
		super();
		// TODO Auto-generated constructor stub
	}


	public Set<Users> getUsers() {
		return users;
	}

	public void setUsers(Set<Users> users) {
		this.users = users;
	}

	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}

	
	
	

}

Users.java

package per.czt.pojo;


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.ManyToOne;

import javax.persistence.Table;

@Entity
@Table(name="t_users4")
public class Users {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="user_id")
	private Integer userid;
	@Column(name="user_name")
	private String username;
	@Column(name="user_age")
	private Integer userage;
	
	@ManyToOne(cascade=CascadeType.PERSIST)//开启级联操作
	@JoinColumn(name="roles_id")
	private Roles roles;
	
	
	public Users() {
		// TODO Auto-generated constructor stub
	}
	public Integer getUserid() {
		return userid;
	}
	public void setUserid(Integer userid) {
		this.userid = userid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public Integer getUserage() {
		return userage;
	}
	public void setUserage(Integer userage) {
		this.userage = userage;
	}
	
	public Roles getRoles() {
		return roles;
	}
	public void setRoles(Roles roles) {
		this.roles = roles;
	}
	@Override
	public String toString() {
		return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
	}
}

测试类
OneToManyTest.java

package per.czt.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import per.czt.dao.UsersDao;
import per.czt.pojo.Roles;
import per.czt.pojo.Users;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value="classpath:applicationContext.xml")
public class OneToManyTest {
	
	@Autowired
	private UsersDao usersDao;
	@Test
	public void test1() {
		//创建Roles对象
	
		Roles roles=new Roles();
		roles.setRolename("administrator");
		//创建Users对象
		
		Users users1=new Users();
		users1.setUsername("小孙");
		users1.setUserage(14);
		//建立关联
		
		roles.getUsers().add(users1);
		users1.setRoles(roles);
		//保存
		usersDao.save(users1);
	}
	
	@Test
	public void test2() {
		Users users=usersDao.findOne(5);
		System.out.println(users);
		System.out.println(users.getRoles());
	}
}

3.多对多关系
假设角色和菜单之间是多对多的关系，则会存在一个中间表存储角色id和菜单id，在这里从那一方建立这个表关联都可以，假设从角色表建立关联
Roles.java

package per.czt.pojo;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;

import javax.persistence.Table;

@Entity
@Table(name="t_roles5")
public class Roles {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="role_id")
	private Integer roleid;
	@Column(name="role_name")
	private String rolename;
	
	@ManyToMany(cascade=CascadeType.PERSIST,fetch=FetchType.EAGER)//级联  ， 延迟加载
	@JoinTable(name="t_roles_menus",joinColumns=@JoinColumn(name="role_id"),inverseJoinColumns=@JoinColumn(name="menu_id"))
	private Set<Menus> menus=new HashSet<Menus>();
	
	

	public Integer getRoleid() {
		return roleid;
	}

	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}

	public String getRolename() {
		return rolename;
	}

	public void setRolename(String rolename) {
		this.rolename = rolename;
	}

	public Set<Menus> getMenus() {
		return menus;
	}

	public void setMenus(Set<Menus> menus) {
		this.menus = menus;
	}

	public Roles() {
		super();
		// TODO Auto-generated constructor stub
	}


	

	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}
}

Menus.java

package per.czt.pojo;

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

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

import javax.persistence.Table;

@Entity
@Table(name="t_menus")
public class Menus {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="menus_id")
	private Integer menusid;
	@Column(name="menus_name")
	private String menusname;
	@Column(name="menus_url")
	private String menusurl;
	@Column(name="fatherid")
	private Integer fatherid;
	
	@ManyToMany(mappedBy="menus",fetch=FetchType.EAGER)// 延迟加载
	private Set<Roles> roles=new HashSet<Roles>();
	
	public Integer getMenusid() {
		return menusid;
	}
	public void setMenusid(Integer menusid) {
		this.menusid = menusid;
	}
	public String getMenusname() {
		return menusname;
	}
	public void setMenusname(String menusname) {
		this.menusname = menusname;
	}
	public String getMenusurl() {
		return menusurl;
	}
	public void setMenusurl(String menusurl) {
		this.menusurl = menusurl;
	}
	public Integer getFatherid() {
		return fatherid;
	}
	public void setFatherid(Integer fatherid) {
		this.fatherid = fatherid;
	}
	public Set<Roles> getRoles() {
		return roles;
	}
	public void setRoles(Set<Roles> roles) {
		this.roles = roles;
	}
	@Override
	public String toString() {
		return "Menus [menusid=" + menusid + ", menusname=" + menusname + ", menusurl=" + menusurl + ", fatherid="
				+ fatherid + ", roles=" + roles + "]";
	}
	public Menus() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	

}

ManyToManyTest.java

package per.czt.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import per.czt.dao.RolesDao;
import per.czt.pojo.Menus;
import per.czt.pojo.Roles;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value="classpath:applicationContext.xml")
public class ManyToManyTest {
	
	@Autowired
	private RolesDao rolesDao;
	
	@Test
	public void test() {
		//创建角色
		Roles roles=new Roles();
		roles.setRolename("超级管理员");
		
		//创建menus
		Menus menus=new Menus();
		menus.setFatherid(1);
		menus.setMenusname("xx管理平台");
		menus.setMenusurl(null);
		
		//创建menus1
		Menus menus1=new Menus();
		menus1.setFatherid(-1);
		menus1.setMenusname("用户管理平台");
		menus1.setMenusurl(null);
		
		//把roles分别与menus1和menus建立关联
		roles.getMenus().add(menus1);
		roles.getMenus().add(menus);
		menus1.getRoles().add(roles);
		menus1.getRoles().add(roles);
		//保存
		rolesDao.save(roles);
	}
	
	@Test
	public void test2() {
		Roles roles=rolesDao.findOne(1);
		System.out.println(roles);
	
		System.out.println(roles.getMenus().size());
		for(Menus menus:roles.getMenus()) {
			System.out.println(menus);
		}
	}
	
	
}
I like study.
关注
专栏目录
Spring Data JPA的一对一多表查询
m0_66884848的博客
03-22 6089
一、简单聊聊 我在写自己的课程设计的时候，用的持久层API就是JPA。整个项目给我带来的感受就是：低SQL语句开发，甚至是零SQL语句开发，使得我在开发过程中，不再关注SQL语句的书写问题与逻辑问题。这使得我在开发过程中，更加专注于自己的业务逻辑，而不在拘泥于SQL表和Java实体之间的映射。尤其在多表查询这一块，JPA以其超简洁的语法规则，给我们实现了表一对一乃至一对多的关系。那么今天想给大家分享的是，一对一的多表查询。 二、简单认识JPA 以下引用了网上对JPA的介绍： ...
JPA一对一，一对多，多对多关系映射
05-14
JPA一对一，一对多，多对多关系映射，面向对象领域
002_Spring Data JPA CRUD
aihiao的专栏
02-17 432
1. 创建一个名为spring-data-jpa-crud的Java项目, 同时添加相关jar包, 并添加JUnit能力。 2. 查看CrudRepository接口下的方法, 我们使用红色框中的方法。 3. 新建User.java package com.bjbs.pojo; import java.io.Serializable; import java.util.Date; import javax.persistence.Column; import javax.persisten
深入理解JPA双向一对一关系
最新发布
m0_62153576的博客
08-16 325
双向一对一关系意味着两个实体之间存在一对一的联系，并且这种联系是相互的。例如，一个用户可以拥有一个个人资料，同时个人资料也指向其对应的用户。在JPA中，这种关系通过在两个实体类中使用@OneToOne注解来实现。
JPA学习笔记（8）——映射双向一对多关联关系
君君的专栏
08-15 4835
双向一对多关联关系前面的博客讲的都是单向的，而本问讲的是双向的（双向一对多 = 双向多对一）什么是双向？我们来对比一下单向和双向 单向/双向 User实体类中是否有List< Order> orders Order实体类中是否有User user 单向多对一 无 有 单向一对多 有 无 双向一对多（双向多对一） 有 有 怎么构建关系User实体类pack
Spring Data JPA 一对一，一对多
weixin_42494845的博客
08-24 288
JPA中的一对一 一个学生只有一条详情信息，一条详情信息对应一个学生 学生和详情信息是一对一关系 一个学生可以有多个账户，一个账户属于一个学生 学生和账户是一对多关系 实体类关系建立以及映射配置 学生类 package domain; import javax.persistence.*; import java.util.List; @Entity @Table(name = "student") public class Student { @Id @GeneratedValue(s
springdataJPA 一对一
m0_64892750的博客
04-06 1172
导入依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> </dependency> <!-- https://mvnrepository.com/artifact/junit/junit --> <dep
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
例如，只需声明一个返回特定类型的方法，Spring Data 就会自动将其映射为对应的 JPA 查询。 2. **Entity Management**：Spring Data JPA 提供了对实体（Entity）的管理，包括实体的创建、更新、删除等操作。开发者...
Spring Data JPA 实现多表关联查询的示例代码
08-27
总结来说，Spring Data JPA提供了灵活的方式处理多表关联查询。通过自定义Repository接口和结果类，我们可以方便地进行复杂的数据检索，同时保持代码的整洁性和可维护性。这使得开发者可以更专注于业务逻辑，而不是...
spring注解+spring data jpa文档+JPA文档.rar
04-05
Spring框架的核心特性包括依赖注入（DI）和面向切面编程（AOP），并且它还提供了对数据库操作的支持，这主要通过Spring Data JPA和Java Persistence API（JPA）实现。 Spring注解是Spring框架中的一大特色，它极大...
spring data jpa 一对多关系映射关系，完整配置（没用@Data注解）
weixin_45482334的博客
04-25 741
实体 Author：作者。 实体 Article：文章。 Author 和 Article 是一对多关系(双向)。那么在JPA中，如何表示一对多的双向关联呢？ JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一端(Author)使用@OneToMany,多端(Article)使用@ManyToOne。 在JPA规范中，一对多的双向关系由多端(Article)来维护。就是...
JPA实现“一对多”映射
实践求真知
01-02 627
一代码位置 https://gitee.com/cakin24/code/tree/master/08/JpaOneToManyDemo 二关键代码 1School package com.example.demo.entity; import lombok.Data; import javax.persistence.*; import java.util.List; @En...
SpringDataJpa的使用 -- 一对一、一对多、多对多 关系映射
十七的博客
07-06 1208
SpringDataJpa的使用 -- 一对一、一对多、多对多 关系映射
JPA - 一对多自身映射
天下无双
02-27 3474
<br />@Entity @Table(name="u_module") public class Module { @Id @GeneratedValue(strategy=GenerationType.AUTO) private int id; /** * 模块名称 */ private String name; /** * 显示位置 ，默认按照从小到大的顺序排列 */ private int location; /** * 菜单
（三）springDataJPA的一对一，一对多
weixin_43189971的博客
07-14 917
1.常见注解 2.一对多 3.多对一
Jpa的对象关联映射---一对多映射
qq_38530648的博客
03-16 627
Jpa对象关联映射关系三种关系 数据库表和表之间的关系、表和表之间都是通过外键维护关系的； 对象和对象之间的关系： 1. 一对多：部门员工 班级学生 2. 多对一：员工部门 3. 多对多：项目员工（拆解成一对多 双向） 4. 一对一：一夫一妻 一个公司 一个注册地址 一对多关系映射–OneToMany 项目结构： application.properties # 连接数据库的四大参数 spring.datasource.driver-class-name=org.postgresql.Driver sp
java中一对多映射实例,JPA一对多映射
weixin_42524165的博客
03-14 656
本篇文章帮大家学习JPA一对多映射，包含了JPA一对多映射使用方法、操作技巧、实例演示和注意事项，有一定的学习价值，大家可以用来参考。一对多映射进入集合值关联的类别，其中实体与其他实体的集合关联。 因此，在这种类型的关联中，一个实体的实例可以映射到另一个实体的任意数量的实例。完整的项目目录结构如下所示 -在这个例子中，我们将创建一个学生和图书库之间的一对多系，这样一个学生能发放多种类型的图书。这个...
Spring Data JPA 定义实体类关系:一对一
zhouzhiwengang的专栏
09-04 832
JPA使用@OneToOne来标注一对一的关系。 实体 Dept：部门。 实体 User：用户。 Dept和 User 是一对一的关系。 这里使用关联字段描述JPA的一对一关系。通过关联字段的方式(一个实体通过关联字段关联到另一个实体的主键)； 通过关联字段的方式Dept表（dept_id，dept_name，dept_tel，dept_fax，email，dept_addr，deptmanager） User表（user_id，phone，zipcode，address，***） 建库脚本： ...
springdata 一对多配置
weixin_30289831的博客
04-27 92
转载于:https://www.cnblogs.com/classmethond/p/10781027.html
SpringData JPA：一对一与一对多关系详解及级联操作
总结来说，本文详细介绍了如何在Spring Data JPA中处理一对一关系，包括如何使用`@OneToOne`注解、级联操作的选择以及如何根据需求自定义外键字段。这对于理解和在实际项目中应用JPA进行数据库操作是非常重要的知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值