java框架学习——JPA实现多对多关系简单案例

最新推荐文章于 2024-01-07 16:19:19 发布
最新推荐文章于 2024-01-07 16:19:19 发布
阅读量444 收藏 2
点赞数 1
分类专栏： # 主流框架 文章标签： 数据库 spring java maven hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37719485/article/details/108036156
版权

本次使用JPA实现多对多的简单案例，学生和课程之间的关系为多对多关系，所以本次使用案例选择这个来做。
环境搭建及基本包创建代码编写
1.新建基本的maven工程命名为jpa-CourseToStudent。并在pom.xml配置中配置如下依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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>cn.lut</groupId>
    <artifactId>jpa-CourseToStudent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <hibernate.version>5.4.20.Final</hibernate.version>
        <mysql.version>8.0.21</mysql.version>
        <c3p0.version>0.9.5.5</c3p0.version>
        <slf4j.version>1.7.30</slf4j.version>
        <spring.version>5.2.7.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!--junit单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--log日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!--spring beg-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</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-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring对orm框架的支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--hibernate-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!--c3p0-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.3.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.el/javax.el-api -->
        <!--使用spring data jpa 必须导入的el-->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.6</version>
        </dependency>
    </dependencies>
</project>

2.在src-main-java包下新建包cn.lut.dao和cn.lut.domain包用于创建实体类对象和相应的持久层接口。
①在domain包下新建Student和Course实体类
Student.java代码如下：

package cn.lut.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "student")
public class Student  {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "stu_id")
	private Long stuId;
	@Column(name = "stu_name")
	private String stuName;
	@Column(name = "stu_age")
	private Integer stuAge;
	@Column(name = "major")
	private String major;
	/*配置学生到课程的多对多关系
	 * 配置多对多的映射关系：
	 * 1声明表关系配置
	 * 2配置中间表（包含两个外键）
	 * */
	@ManyToMany(targetEntity = Course.class,cascade = CascadeType.ALL,fetch = FetchType.LAZY)
	@JoinTable(name = "sys_stu_cou",//中间表的名称
			//joinColumns当前对象在中间表中的外键
			joinColumns = {@JoinColumn(name = "sys_stu_id",referencedColumnName = "stu_id")},
			//inverseJoinColumns对方对象在中间表中的外键
			inverseJoinColumns = {@JoinColumn(name = "sys_cou_id",referencedColumnName = "cou_id")}
	)
	private Set<Course> courses=new HashSet<Course>();

	@Override
	public String toString() {
		return "Student{" +
				"stuId=" + stuId +
				", stuName='" + stuName + '\'' +
				", stuAge=" + stuAge +
				", major='" + major + '\'' +
				'}';
	}
	public Long getStuId() {
		return stuId;
	}
	public void setStuId(Long stuId) {
		this.stuId = stuId;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public Integer getStuAge() {
		return stuAge;
	}
	public void setStuAge(Integer stuAge) {
		this.stuAge = stuAge;
	}
	public String getMajor() {
		return major;
	}
	public void setMajor(String major) {
		this.major = major;
	}
	public Set<Course> getCourses() {
		return courses;
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
}

Course.java中代码如下：

package cn.lut.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "course")
public class Course {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "cou_id")
	private Long couId;
	@Column(name = "cou_name")
	private String couName;
	@ManyToMany(mappedBy = "courses",fetch = FetchType.LAZY)
	private Set<Student> students=new HashSet<Student>();
	@Override
	public String toString() {
		return "Course{" +
				"couId=" + couId +
				", couName='" + couName + '\'' +
				'}';
	}
	public Long getCouId() {
		return couId;
	}
	public void setCouId(Long couId) {
		this.couId = couId;
	}
	public String getCouName() {
		return couName;
	}
	public void setCouName(String couName) {
		this.couName = couName;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

②在dao包下新建持久层接口
IStudentDao.java代码如下：

package cn.lut.dao;

import cn.lut.domain.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface IStudentDao extends JpaRepository<Student,Long>, JpaSpecificationExecutor<Student> {
}

IcourseDao.java中代码如下：

package cn.lut.dao;

import cn.lut.domain.Course;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface ICourseDao extends JpaSpecificationExecutor<Course>, JpaRepository<Course,Long> {
}

3.创建resources资源包下的配置文件applicationContext.xml文件其中添加配置。
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:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/jdbc  http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/data/jpa  http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--spring和spring data jpa的配置-->
    <!--创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--自动扫描实体类的包-->
        <property name="packagesToScan" value="cn.lut.domain"/>
        <!--jap的实现方式-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--jpa的供应商适配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="false"/><!--自动创建数据库表-->
                <property name="database" value="MYSQL"/><!--数据库类型-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQL5Dialect"/><!--数据库方言：支持的特有语法-->
                <property name="showSql" value="true"/>
            </bean>
        </property>
        <!--注入jpa的配置信息,加载jpa的基本配置信息，和jpa实现方式的配置信息-->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">update</prop>

            </props>
        </property>
        <!--jpa方言高级特性-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>
    </bean>
    <!--创建数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa?serverTimezone=UTC"></property>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
    </bean>
    <!--整合spring data JPA-->
    <jpa:repositories base-package="cn.lut.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
    </bean>
    <!--声明式事务-->
    <!--配置注解包扫描-->
    <context:component-scan base-package="cn.lut"></context:component-scan>
</beans>

4.创建测试类
CouToStuTest.java

package cn.lut.test;

import cn.lut.dao.ICourseDao;
import cn.lut.dao.IStudentDao;
import cn.lut.domain.Course;
import cn.lut.domain.Student;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.Set;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class CouToStuTest {
	@Autowired
	private IStudentDao studentDao;
	@Autowired
	private ICourseDao courseDao;
	@Test
	@Transactional
	@Rollback(value = false)
	public void testAdd(){
		Student stu=new Student();
		stu.setStuName("jack");

		Course cou=new Course();
		cou.setCouName("English");
		//配置学生到课程之间的关系
		stu.getCourses().add(cou);
		//配置课程到学生之间的关系
		cou.getStudents().add(stu);

		studentDao.save(stu);
	}
	@Test
	@Transactional
	@Rollback(value = false)
	public void testDel(){
		//查询1号学生
		Student student=studentDao.getOne(1l);
		System.out.println(student);
		Set<Course> courses = student.getCourses();
		for(Course c:courses){
			System.out.println(c);
		}
		//删除一号学生
		//studentDao.delete(student);
	}
}

注意在第一次测试存储时配置文件中的配置jpa实现方式的配置为：

<property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>

测试删除时修改为：

<property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>

创建完成后的工程结构如下：
在这里插入图片描述

Roy-sky
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPA中的多对多
qq_42836176的博客
12-05 1775
4.1 示例分析 我们采用的示例为用户和角色。 用户：指的是咱们班的每一个同学。 角色：指的是咱们班同学的身份信息。 比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。 同时B同学，它也具有学生和子女的身份。 那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。 所以我们说，用户和角色之间的关系是多对多。 4.2 表关系建立 多对多的表关...
求精要诀——JavaEE编程开发案例精讲 源代码（8-12）
04-02
【标题】"求精要诀——JavaEE编程开发案例精讲 源代码（8-12）"涉及的是JavaEE平台上的高级编程实践，主要涵盖第8至12章的关键知识点。JavaEE，全称Java Platform, Enterprise Edition，是Java语言在企业级应用开发...
JPA中实现双向多对多的关联关系示例代码
12-26
JPA中实现双向多对多的关联关系示例代码;
JPA 系列教程7-双向多对多
菜鸟教程
12-13 222
双向多对多的ddl语句 同单向多对多表的ddl语句一致 Student package com.jege.jpa.many2many; import java.util.HashSet; import java.util.Set; import javax.persistence.Entity; import javax.persistence.GeneratedValue; ...
从零开始 Spring Boot 58：JPA中的多对多关系
梦幻天空
07-05 762
一般来说，我们用第一种方式即可，不用为中间实体建模会让关系复杂度降低。但如果需要中间实体保存某些信息，我们就不得不为中间实体建模。本文的完整示例可以从这里获取。
JPA实现多对多关系
Wzill
07-16 1819
在两个实体类中使用@ManyToMany注解来表示多对多关系，并通过@JoinTable注解指定中间表的名称和关联字段。JPA会自动创建中间表，并维护两个实体类之间的关联关系。如果需要在中间表中添加其他字段，可以创建一个新的实体类来表示中间表，并在两个实体类中使用@OneToMany和@ManyToOne注解来表示与中间表的一对多关系。
Java毕业设计——基于spring boot的在线选房网站设计与实现（源码+数据库）.7z
09-29
标题中的“Java毕业设计——基于spring boot的在线选房网站设计与实现”表明这是一个使用Java编程语言，并基于Spring Boot框架开发的毕业设计项目。Spring Boot是Spring生态中的一个核心组件，它简化了创建独立的、...
Java毕业设计——基于spring boot的就业信息管理网站设计与实现（源码+数据库）.7z
09-29
总的来说，这个项目为学习者提供了一个从零开始到完整部署的实战案例，涵盖了Spring Boot应用的开发、数据库设计、前后端交互等多个关键知识点。通过分析和实践这个项目，可以深入理解Spring Boot的工作原理，提高...
计算机专业毕业设计——Java合集（78套）.zip
01-12
2. JPA与Hibernate：理解ORM（对象关系映射），使用JPA规范或Hibernate框架进行数据库操作。 3. Spring框架：学习Spring的核心功能，包括依赖注入、AOP（面向切面编程）等。 4. 分布式技术：接触负载均衡、集群、...
Java实战开发（李兴华）——代码部分
04-24
以上只是部分可能涵盖的内容，实际的“Java实战开发（李兴华）——代码部分”可能还包括更多的案例、项目或特定领域的应用，如大数据处理、Android开发等。通过学习和实践这些知识点，开发者可以提升自己的Java编程...
13_jpa多对多双向关联实体定义与注解
03-25
13_传智播客JPA详解_JPA中的多对多双向关联实体定义与注解设置.rar
JPA中实现双向多对多的关联关系(附代码下载)
BADAO_LIUMANG_QIZHI的博客
12-26 313
场景 JPA入门简介与搭建HelloWorld(附代码下载)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103473937 JPA中实现单向多对一的关联关系： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103511623 JPA中实现单向一...
Spring Data JPA 之 一对一，一对多，多对多 关系映射
热门推荐
我飞故我在的专栏
06-10 7万+
&amp;amp;amp;amp;amp;amp;nbsp; 一、@OneToOne关系映射 JPA使用@OneToOne来标注一对一的关系。 实体 People ：用户。 实体 Address：家庭住址。 People 和 Address 是一对一的关系。 这里用两种方式描述JPA的一对一关系。 一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键)； 另外一种...
JPA的复杂查询包括一对多多对一和多对多的查询
最新发布
m0_68856746的博客
01-07 3255
它们之间是多对多的关系，即一个学生可以选择多门课程，一门课程也可以有多个学生选择。我们想要查询选择了某门课程的所有学生，并且能够添加新的学生和课程。，它们之间是多对多的关系，即一个产品可以属于多个分类，一个分类也可以包含多个产品。现在，我们可以执行复杂查询，获取选择了某门课程的所有学生，并且能够添加新的学生和课程。方法执行了一个自定义查询，并只选择了客户的名称和邮箱属性。方法执行了一个复杂查询，获取选择了某门课程的所有学生。现在，我们可以执行多对多关联查询，并通过价格条件进行过滤。
SpringData JPA (二) 进阶 - JPA一对多、多对多
qq_36662478的博客
04-10 1万+
1 JPA中的主键生成策略   通过annotation（注解）来映射实体类和数据库表的对应关系,基于annotation的主键标识为@Id注解, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。   其中：JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO\color{red}{TABLE,SE...
Jpa中的一对多和多对多查询
Hpeacheng的博客
12-18 3358
【1】多对一和多对多一直多是数据库的必备技能，所以jpa也少不了 【2】先复习一下多对一和多对多是怎么回事 1的一方为主表，这里也就是cst_customer1，多的一方为从表cst_linkman 这里cust_id为1，而lkm_cust_id为多。就是在主表里，id不能重复，同一个id只能有一个，而在从表中，lkm_cust_id是可以重复的。 多对多，就是两张表的字段都放到一个第三张表中 【3】...
jpa之多对多关系
面朝大海，春暖花开
11-03 422
jpa之多对多关系 单向多对多关系 单向多对多关系 @Entity @Table(name = "t_emp") public class EmployeeDo { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private int id; private String name; @...
netbeans8.1简单JPA和EJB应用
build_zzz的博客
11-18 282
netbeans8.1简单JPA和EJB应用 1.创建一个JAVAweb项目 服务器都是用默认的服务器。在框架选择处选择javaServer faces,首选页面语言为JSP。未说明的默认选项就好。 2.在项目的源包处创建两个JAVA包，mycontrol和mymodels，并在项目处右击添加JSF faces配置文件(JSF配置文件需要右键添加文件后找到jsf配置文件这个选项) 3.在mymodels包处直接通过数据库生成实体类 这里需要选择数据源，可以是软件自带的，或者是本机已经装好的数.
java 一对多关系修改_Java-JPA-保持一对多关系
05-18
在Java JPA中，要保持一对多关系需要进行以下步骤： 1. 在主实体类中定义一个集合属性来存储从实体类的实例。 ```java @Entity public class User { @Id private long id; @OneToMany(mappedBy = "user", ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值