十三 关联映射操作-一对多的关联关系

最新推荐文章于 2020-10-14 00:38:25 发布
最新推荐文章于 2020-10-14 00:38:25 发布
阅读量284 收藏
点赞数
分类专栏： Spring Data 文章标签： SpringDataJPA 关联映射操作一对多的关联关系
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangguozi/article/details/90436606
版权
本文介绍了如何使用SpringDataJPA处理一对多的关联关系，以角色和用户为例，从需求出发，详细阐述了创建项目、配置文件、实体类、DAO接口以及测试类的步骤。
摘要由CSDN通过智能技术生成

需求：从角色到用户的一对多的关联关系

角色：一方

用户：多方

创建项目09-spring-data-jpa-onetomany

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.bjsxt</groupId>
	<artifactId>09-spring-data-jpa-onetomany</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
		<java.version>1.8</java.version>
		<spring.version>4.3.23.RELEASE</spring.version>
		<hibernate.version>5.1.17.Final</hibernate.version>
		<mysql.version>5.1.47</mysql.version>
		<c3p0.version>0.9.2.1</c3p0.version>
		<junit.version>4.12</junit.version>
		<lombok.version>1.18.6</lombok.version>
		<hibernate-entitymanager.version>5.0.7.Final</hibernate-entitymanager.version>
		<spring-data-jpa.version>1.7.0.RELEASE</spring-data-jpa.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>

		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>${c3p0.version}</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>${lombok.version}</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate-entitymanager.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
			<version>${spring-data-jpa.version}</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/log4j/log4j -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

	</dependencies>
</project>

jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/spring-data-test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
#jdbc.url=jdbc:mysql://localhost:3306/spring-data-test 这个保存到数据库中会导致乱码
jdbc.driver.class=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=123456

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.11.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

	<!-- 配置读取properties文件的工具类 -->
	<context:property-placeholder location="classpath:jdbc.properties" />

	<!-- 配置c3p0数据库连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="driverClass" value="${jdbc.driver.class}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- spring整合jpa 配置EntityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<!-- hibernate相关的属性注入 -->
				<!-- 配置数据库类型 -->
				<property name="database" value="MYSQL" />
				<!-- 正向工程自动创建表 -->
				<property name="generateDdl" value="true" />
				<!-- 显示执行的sql -->
				<property name="showSql" value="true" />
			</bean>
		</property>
		
		<!-- 配置扫描实体的包 -->
		<property name="packagesToScan">
			<list>
				<value>com.bjsxt.pojo</value>
			</list>
		</property>
	</bean>
	
	<!-- 配置hibernate的事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<!-- 配置开启注解事务处理 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

	<!-- 配置springIOC的注解扫描 -->
	<context:component-scan base-package="com.bjsxt"></context:component-scan>
	
	<!-- Spring Data JPA的配置 base-package扫描dao接口所在的包 -->
	<jpa:repositories base-package="com.bjsxt.dao"></jpa:repositories>
</beans>

1  编写实体类

package com.bjsxt.pojo;

import java.io.Serializable;

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="ts_users")
public class Users implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="id")
	private Long id;
	
	@Column(name="user_name")
	private String userName;
	
	@Column(name="age")
	private Integer age;
	
	@ManyToOne(cascade=CascadeType.ALL)
	@JoinColumn(name = "role_id")
	private Roles roles;

	public Long getId() {
		return id;
	}

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

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public Roles getRoles() {
		return roles;
	}

	public void setRoles(Roles roles) {
		this.roles = roles;
	}

	@Override
	public String toString() {
		return "Users [id=" + id + ", userName=" + userName + ", age=" + age + "]";
	}
}

package com.bjsxt.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;

/**
 * 
 * @author guozi
 *
 */
@Entity
@Table(name = "ts_roles")
public class Roles {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "role_id")
	private Long roleId;
	
	@Column(name = "role_name")
	private String roleName;
	
	// mappedBy:users中指定的roles属性
	@OneToMany(mappedBy = "roles")
	private Set<Users> users = new HashSet<>();

	public Long getRoleId() {
		return roleId;
	}

	public void setRoleId(Long roleId) {
		this.roleId = roleId;
	}

	public String getRoleName() {
		return roleName;
	}

	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}

	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 + "]";
	}
}

2 创建dao接口

package com.bjsxt.dao;

import org.springframework.data.jpa.repository.JpaRepository;

import com.bjsxt.pojo.Users;

/**
 * JpaRepository接口使用
 * JpaRepository是开发中使用最多的接口
 * @author guozi
 *
 */
public interface UsersDao extends JpaRepository<Users, Long> {
	
}

3 创建测试类

package com.bjsxt.dao;

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 com.bjsxt.pojo.Roles;
import com.bjsxt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class OneToManyTest {
	
	@Autowired
	private UsersDao usersDao;

	/**
	 * 保存
	 * 	Hibernate: insert into ts_roles (role_name) values (?)
		Hibernate: insert into ts_users (age, role_id, user_name) values (?, ?, ?)
		注意：此处如果实体类用的时lombok时，会报java.lang.StackOverflowError异常，所以将原有的使用lombok去掉，改成setter和getter及toString处理，
		请参考https://www.jianshu.com/p/d6bb1c343146
	 */
	@Test
	public void test() {
		// 创建角色
		Roles role = new Roles();
		role.setRoleName("船员");
		
		// 创建用户
		Users user = new Users();
		user.setAge(10);
		user.setUserName("乔巴");
		
		// 建立关系
		user.setRoles(role);
		role.getUsers().add(user);
		
		// 保存数据
		this.usersDao.save(user);
	}

	/**
	 * 查询
	 * 	Hibernate: select users0_.id as id1_1_0_, users0_.age as age2_1_0_, users0_.role_id as role_id4_1_0_, users0_.user_name as user_nam3_1_0_, roles1_.role_id as role_id1_0_1_, roles1_.role_name as role_nam2_0_1_ from ts_users users0_ left outer join ts_roles roles1_ on users0_.role_id=roles1_.role_id where users0_.id=?
		Users [id=15, userName=乔巴, age=10]
		Roles [roleId=2, roleName=船员]
	 */
	@Test
	public void test2 () {
		Users users = this.usersDao.findOne(15l);
		System.out.println(users);
		System.out.println(users.getRoles());
	}
}

 

 

fangguozi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
11.27--一对多关联映射
大海
11-28 386
一对多关联映射单向 一对多和多对一映射原理是一样的，都是在多的一端加入一个外键指向一的一端；区别在于维护的关系不同： 多对一维护的关系：多指向一的关系，如果维护了多指向一的关系，那么加载多的时候会把一加载上来； 一对多维护的关系：一指向多的关系，如果维护了一指向多的关系，那么加载一的时候会把多加载上来。 classes——》studenttable-classes: id , nameclasses
03. 关联关系映射（一对一）
远方水木
06-06 231
关联关系映射 一对一关联关系 表结构中关系为一对一，那么类结构中也是一对一的关系。表结构层面上，一对一的关系都是双向的，从任何一侧表都可以访问到对方另一侧表中的内容。而类一对一的关联关系可以分为单向和双向两种。双向表示在两个关联的类中，都存放对方类信息，并提供相应的获取和设置方法；单向表示只在某一侧存放另一方的信息，我们只能从这一方去访问另一方，而不能从另一方访问这一方。 一对一单向...
多对多关联映射
lkfmiaomiao的博客
10-30 310
多对多关联映射 两个实体型之间的联系 多对多联系 定义 如果对于实体集A中的每一个实体，实体集B中有n个实体（n≥0）与之联系，反之，对于实体集B中的每一个实体，实体集A中也有m个实体（m≥0）与之联系，则称实体集A与实体B具有多对多联系，记为m:n。 在实体中实现多对多联系的设计 在需要关联的实体中设计关联对象的集合 数据库中实现多对多联系的设计 可是使用第三方表 该表中会生成...
dljd_(071-074)_hibernate_多对多关联关系映射
dianmo9374的博客
12-17 129
一、多对多关联关系映射 　　多对多关联关系映射其实就是两个一对多关联关系映射组成的。要用到中间表(中间表充当多方) 二、示例(一个学生可以选多门课程、一门课程可以被多个学生选) 　　1.1定义学生实体 package edu.aeon.beans; import java.util.HashSet; import java.util.Set; /** * [...
Hibernate对象关系映射-- 多对多关联关系映射
小小小森屿的博客
04-30 431
在关系型数据库中，如果表与表之间存在多对多的关系，是不符合关系型数据库设计范式的。一般需要把一个多对多关系映射为一张关联双方的表，这张表叫做连接表。 不管是单向映射还是双向映射，多对多关系都是基于连接表实现的。 下面通过用户(User)和角色(Role)来讲解多对多的关联映射。一个用户(User)有多个角色(Role)，一个角色对应多个用户，因此用户和角色之间构成多对多的关联关系。
Hibernate多对多单向关联和双向关联映射的方法
还有一点时间
07-30 774
Hibernate多对多关联映射主要是通过一张中间表进行设置，把两个表的标识记录项添加到中间表中进行关联，如下图所示： 系统权限类： public class SystemPrivilege { private String id; private String name; private Set groups = new HashSet(); public Set
数据库实体间多对多关系处理
iteye_1907的博客
08-22 2660
 数据库实体间多对多关系处理   数据库实体间有三种对应关系：一对一，一对多，多对多。 一对一关系示例：一个学生对应一个学生档案材料，或者每个人都有唯一的身份证编号。 一对多关系示例：一个学生只属于一个班，但是一个学院有多名学生。 多对多关系示例：一个学生可以选择多门课，一门课也有多名学生。   这三种关系在数据库中逻辑结构处理分析：   1.一对多关系处理： 我们以学生和班级...
Mybatis一对多关联关系映射实现过程解析
08-25
Mybatis的一对多关联关系映射实现过程解析 Mybatis是一款基于Java的持久层框架，它提供了对数据库的操作接口，包括数据的增删改查等操作。在实际开发中，我们经常会遇到一对多关联关系映射的问题，例如用户和订单...
hibernate一对多关联映射学习小结
08-29
在Hibernate中，一对多关联映射和多对一关联映射的区别在于维护的关系不同。多对一关联映射中，多的一端维护一的一端的关系，在加载多的一端时，可以将一的一端加载上来。一对多关联映射中，一的一端维护多的一端的...
SpringBoot中mybatis表关联映射关系(一对多嵌套：结果方式)
07-11
SpringBoot 中 MyBatis 表关联映射关系（一对多嵌套：结果方式） 在 SpringBoot 中，MyBatis 是一个非常流行的持久...最后，我们可以使用 MyBatis 来映射 Lesson 和 Stu 之间的一对多关联关系，实现数据的持久化操作。
Spring+Hibernate一对多关联映射---部门与员工表的级联添加
10-15
在数据库设计中，一对多关联是一个常见的关系类型，例如一个部门可以有多名员工，但每个员工只能属于一个部门。在Hibernate中，这种关系可以通过配置XML映射文件或使用注解来实现。我们将以XML映射为例，探讨如何...
实现Mybatis框架中一对多关联映射的查询操作。
01-14
本篇将详细讲解如何在Mybatis中实现一对多关联映射的查询操作。 首先，我们要明确一对多关联映射的基本概念。在这个例子中，User表（用户表）和Order_form表（订单表）之间存在1-N的关系，意味着一个用户可以有多个...
Mybatis多表查询之多对多（角色到用户的查询，用户到角色的查询）
骑着蜗牛行天下
09-21 4145
Mybatis多表查询之多对多 实现用户和角色之间的多对多 用户与角色之间的关系模型： 一个用户可以有多个角色。 一个角色可以赋予多个用户。 步骤： 1.建立两张表，用户表和角色表。 让用户表和角色表之间具有多对多的关系。 需要使用中间表，中间表包含各自的主键，在中间表中是外键。 2.建立两个实体类：用户实体类和角色实体类。 让用户和角色的实体类能体现出来多对多的关系。 各自包含对方的一个集合引用。 3.建立两个配制文件 用户的配制文件。 角色的配制文件。 4.实现配置：
Kubernetes－核心组件－kube-proxy
热门推荐
了解➔熟悉➔掌握➔精通
03-20 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 每台机器上都运行一个kube-proxy服务，它监听API server中service和endpoint的变化情况，并通过iptables等来为服务配置负载均衡（仅支持TCP和UDP）。 kube-proxy可以直接运行在物理机上，也可以以static pod或者daemonset的方式运行。 kube-proxy当前支持一下几种实现 users
mybatis之关联关系映射（一对多和多对多关系）
men_ma的博客
10-14 1422
转载请标明出处：https://blog.csdn.net/men_ma/article/details/106847165. 本文出自 不怕报错 就怕不报错的小猿猿 的博客 mybatis之关联关系映射（一对多和多对多关系）目标目录结构准备工作（使用逆向生成工具生成mapper及model）数据库中所需的数据库表（已存在的表）使用逆向生成工具自动生成实体类及dao类一对多关联关系步骤（订单案例）多对多关联关系步骤（书籍案例） 目标 1、一对多关联关系 2、多对多关联关系 目录结构 续接： .
Java对象关系映射（ORM）
Procedure_bear的博客
07-26 4172
一、什么是对象关系映射 简单来说，对象关系映射即是将Java中的对象一一对应映射到MySQL（本文基于MySQL）的Table（表）中，通过对对象各个属性赋值来更新数据库。 官方的说，对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。（本段来自百度百科） 二、如何写OR...
多对多关联映射原理
北漂的IT小白菜
02-04 1178
在生活中也常常需要多对多的关系，例如多个学生对应多门课程，或者多个用户对应多个角色，那他们之间的关系如何维护呢？ 这时候就需要第三方来维护两者之间的关系。例如：      简单的说点就是多对多的关系需要一张关系表来维护。通过一张关系表分别建立与另外两张表的一对多的关系就OK了。例如用户和角色之间，通过用户角色关系表分别建立了与用户表、角色表之间的关系。如此看多对多的关系其实就是演化了的
九 JpaRepository接口的使用（常用）
fangguozi的专栏
05-20 9739
JpaRepository接口是我们开发时使用最多的接口。其特点是可以帮助我们将其他接口的返回值做适配处理，可以使得我们在开发时可以更方便的使用这些方法。 创建项目07-spring-data-jpa-jparepository pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://w...
MyBatis配置与关联映射详解-一对多关系
"配置一对多关系，MyBatis的使用，MyBatis关联映射" 在MyBatis中，配置一对多关系是实现对象关系映射的重要部分。一对多关系通常出现在一个实体可以拥有多个相关联的子实体的情况，例如订单与订单详情的关系。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值