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

最新推荐文章于 2024-06-14 08:59:56 发布

Roy-sky

最新推荐文章于 2024-06-14 08:59:56 发布

阅读量626

点赞数 1

分类专栏： # 主流框架文章标签：数据库 spring java jpa hibernate

本文链接：https://blog.csdn.net/weixin_37719485/article/details/108034303

版权

主流框架专栏收录该内容

21 篇文章 0 订阅

订阅专栏

java JPA用实体类中的配置实现与数据库的交互，从而简化了开发人员自己创建数据库表的繁杂工作。
本次使用的案例是一对多案例，一个导师有多个学生，通过导师可以查询到名下多个学生，通过一个学生连接到仅有的一个导师。
一.搭建开发环境
使用MySQL数据库中的database-》insitute通过JPA将会建立必要的数据库表。
1.创建简单的maven工程
在这里插入图片描述
导入必要的坐标在pom.xml中：

<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>

二添加代码必要的包及编写代码
1.创建实体类对象在src-》main-》java包下新建class命名为：cn.lut.Student和cn.lut.SuperVisor两个实体类对象并在其中配置实体类创建数据库表的必要代码。
①SuperVisor.java中代码如下：

package cn.lut.domain;

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

@Entity
@Table(name = "sv")
public class SuperVisor {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "sv_id")
	private Long svId;
	@Column(name = "sv_name")
	private String svName;
	@Column(name = "sv_research")
	private String svResearch;
	@Column(name = "sv_age")
	private Integer svAge;
	/*@OneToMany(targetEntity = LinkMan.class)
	@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")//配置外键
	  cascade:配置级联（配置到设置多表的映射关系的注解上）
	  CascadeType.ALL：所有（推荐），.MERGE 更新， .PERSIST 保存， .REMOVE 删除。
	  fetch:配置关联对象的加载方式
	  EAGER：立即加载
	 LAZY：延迟加载
	 */

	 //配置导师到学生之间的关系一对多关系
	@OneToMany(mappedBy = "superVisor",cascade = CascadeType.ALL,fetch = FetchType.LAZY)
	//放弃外键维护权，mapperBy：对方配置关系的属性名称
	private Set<Student> students=new HashSet<Student>();
	@Override
	public String toString() {
		return "SuperVisor{" +
				"svId=" + svId +
				", svName='" + svName + '\'' +
				", svResearch='" + svResearch + '\'' +
				", svAge=" + svAge +
				", students=" + students +
				'}';
	}
	public Long getSvId() {
		return svId;
	}
	public void setSvId(Long svId) {
		this.svId = svId;
	}
	public String getSvName() {
		return svName;
	}
	public void setSvName(String svName) {
		this.svName = svName;
	}
	public String getSvResearch() {
		return svResearch;
	}
	public void setSvResearch(String svResearch) {
		this.svResearch = svResearch;
	}
	public Integer getSvAge() {
		return svAge;
	}
	public void setSvAge(Integer svAge) {
		this.svAge = svAge;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

②Student.java中代码如下：

package cn.lut.domain;

import javax.persistence.*;

@Entity
@Table(name = "stu")
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 = "stu_major")
	private String stuMajor;
	/*配置学生到导师的多对一关系
	注解配置多对一关系：
	1配置表关系，2配置外键（中间表）*/
	@ManyToOne(targetEntity = SuperVisor.class,fetch = FetchType.EAGER)
	@JoinColumn(name = "sv_stu_id",referencedColumnName = "sv_id")
	private SuperVisor superVisor;
	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 getStuMajor() {
		return stuMajor;
	}
	public void setStuMajor(String stuMajor) {
		this.stuMajor = stuMajor;
	}
	public SuperVisor getSuperVisor() {
		return superVisor;
	}
	public void setSuperVisor(SuperVisor superVisor) {
		this.superVisor = superVisor;
	}
}

2.编写接口在cn.lut.dao包下新建两个对象实体类的持久层接口
①StudentDao.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 StudentDao extends JpaRepository<Student,Long>, JpaSpecificationExecutor<Student> {
}

②SuperVisorDao.java中代码如下：

package cn.lut.dao;

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

public interface SuperVisorDao extends JpaRepository<SuperVisor,Long>, JpaSpecificationExecutor<SuperVisor> {
}

3.编写resources下面的配置代码配置文件为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:///institute?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.创建测试类在test-》java下新建class命名为：cn.lut.SvToStuTest.java
测试添加和删除操作。
其中代码如下：

package cn.lut.test;

import cn.lut.dao.StudentDao;
import cn.lut.dao.SuperVisorDao;
import cn.lut.domain.Student;
import cn.lut.domain.SuperVisor;
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;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SvToStuTest {
	@Autowired
	private StudentDao studentDao;
	@Autowired
	private SuperVisorDao superVisorDao;
	/*测试添加操作
	* 级联添加，保存一个导师的同时，保存导师的所有学生，需要在操作主题的实体类上添加Cascade注解操作
	* */
	@Test
	@Transactional
	@Rollback(value = false)//设置回滚为false
	public void testAdd(){
		//创建导师数据
		SuperVisor visor=new SuperVisor();
		visor.setSvName("Tutor");
		//创建学生数据
		Student stu=new Student();
		stu.setStuName("Jack");
		//级联添加
		visor.getStudents().add(stu);
		stu.setSuperVisor(visor);
		//保存数据
		superVisorDao.save(visor);
	}
	@Test
	@Transactional
	@Rollback(value = false)
	/*级联删除，删除一号的导师同时删除一号导师的所有学生
	* */
	public void testCascadeRemove(){
		//查询1号导师
		SuperVisor one = superVisorDao.getOne(1L);
		//删除1号导师
		superVisorDao.delete(one);
	}
}

项目创建完成后的项目结构如下：
在这里插入图片描述
首先测试add方法测试过程中的数据库变化过程如下，添加前和后都包含，

注意当第二次测试删除时我们需要把配置文件application.xml中的配置修改一下才能不出错。

 <property name="jpaProperties">
            <props>//测试add方法时使用
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>

 <property name="jpaProperties">
            <props>//测试add方法时使用
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>

数据库中信息变化如下：本来数据将会被删除，
在这里插入图片描述
至此一个简单的案例使用JPA操作的就完成了。

Roy-sky

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
java框架学习——JPA的使用简单案例实现一对多关系

java JPA用实体类中的配置实现与数据库的交互，从而简化了开发人员自己创建数据库表的繁杂工作。本次使用的案例是一对多案例，一个导师有多个学生，通过导师可以查询到名下多个学生，通过一个学生连接到仅有的一个导师。一.搭建开发环境使用MySQL数据库中的database-》insitute通过JPA将会建立必要的数据库表。1.创建简单的maven工程导入必要的坐标在pom.xml中：<properties> <hibernate.version>5.4.2
复制链接

扫一扫

专栏目录