【JPA】从入门到高级

已于 2022-08-29 17:32:37 修改
阅读量1.4k 收藏 11
点赞数 2
文章标签： 数据库 mysql java
于 2022-08-29 17:31:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuxuxux123/article/details/126578608
版权

JPA教程：入门到高级

文章目录

一、JPA的基本注解？

@Entity

写在类上，表示这个类是一个实体类，加了它之后，就表示当前类跟数据库中的表有对应关系了

@Table(name = “t_user”)

指定当前实体类对应哪一张表；

@Entity  //如果只加@Entity，其实也行，但是你数据库中对应的表名，也得是user，如果t_user，你需要用Table(name="t_user")来指定
public class User{
	...
}

@Id

用来指定实体类中哪个属性对应表中的注解，可以写在属性上，也可以写在属性的getter方法上；

@GenerateValue

用来指定主键的生成策略，总共有四种策略，通过strategy来指定到底使用哪种策略；（这个注解跟@Id一样，可以写在属性上，也可以写在属性的getter方法上）
1.@GenerateValue(strategy = GenerationType.AUTO)
AUTO是JPA默认的主键生成策略，你不加strategy = GenerationType.AUTO，他也是使用这个策略；这个策略下他会根据你表的情况自动生成主键，比如当他检测到你是mysql数据库，它就会自动给使用主键自增；
2.@GenerateValue(strategy = GenerationType.IDENTITY)
这个就是直接指定为主键自增了；
3.@GenerateValue(strategy = GenerationType.SEQUENCE)
这个就是通过序列生成主键，通常Oracle数据库用的多，除此之外你还需要通过@SequenceGenerator来指定序列名，告诉它到底使用哪个序列来生成主键； mysql是不支持这种方式的；
4.@GenerateValue(strategy = GenerationType.TABLE)
这个就是通过另外一个数据表来生成主键，这个比较麻烦，后面再阐述；

@GenerateValue
@Id
public Long getId(Long id){
	return this.id;
}

@Column

写在属性上，也可以写在属性的getter方法上；

@Column(name="last_name",length=50,nullable=false)
public String lastName;

这里表示指定属性lastName对应表中的last_name字段，还指定了该字段的长度为50，不能为空，nullable表示询问你该字段是否可以为空，false表示不能为空；
另外如果你没有通过length指定字段长度的话，那么JPA在通过实体类创建表时，String类型的属性就会被创建为varchar类型，并且给它一个默认的长度255，这就可能造成空间的浪费；

以下就是指定后的效果：
在这里插入图片描述

@Basic

你实体类的属性上，或者它对应的getter方法上，默认就会自带@Basic，就算你没写@Basic它也自带；
比如下面的例子：

public class User{
	//@Basic  就是说在这里，JPA会给你默认加一个@Basic，表示在创建表时，它会自动帮你创建一个名为lastname的字段；
	private String lastName;
}

public class User{
	//@Basic  在getter方法上，它也会默认加上@Basic
	public String getLastName(){
		return this.lastName;
	}
}

注意：@Basic加在属性上在本质上就是加在了getter方法上；

@Transient

这个注解的作用是：由于JPA会默认给你的实体类属性上加上@Basic注解，然后JPA再去给你这些属性创建字段；但是有时候你的实体类中，你会加一些不是表的字段的属性，此时我们就要用@Transient将其标注出来，让JPA在创建表时，忽略这些属性，否则JPA就会默认标注为@Basic；

注意：这个注解写在getter方法上也是可以的；

@Temporal

该注解主要用来指定Date类型的精确度，它有三种精确度：DATE，TIME，TIMESTAMP
分别表示精确到日期，精确到时分秒，精确到日期+时分秒
举例：

@Entity
@Table(name = "t_user")
public class User{
	private Date createTime;
	private Date birth;
}
User user = new User();
 user.setCreateTime(new Date());
 user.setBirth(new Date());
userRepository.save(user);

当你在创建表时，如果你没有给Date类型的属性加@Temporal注解，那么以后你往里面set值的时候：默认设置进去的时间，就是日期加时分秒的格式：比如下面这种；
在这里插入图片描述
但是我们在保存生日birth时，我们并不需要保存时分秒，只需要保存日期就行了，而创建时间则可以精确到秒；那么此时就产生了问题，@Temporal就派上用场了；

@Entity
@Table(name = "t_user")
public class User{
	@Temporal(TemporalType.TIMESTAMP) //这个表示当你往这个日期属性里设置值时，时间格式就是日期加时分秒的格式，yy-mm-dd HH:MM:SS
	private Date createTime;
	
	@Temporal(TemporalType.DATE) //表示时间格式仅为日期：yy-mm-dd
	private Date birth;

	@Temporal(TemporalType.TIME) //表示时间格式仅为时分秒：HH:MM:SS
	private Date clock;
}

二、JPA的api

三、JPA中的多表操作

1. 一对一关系

举例：身份证与用户的关系

@Entity
@Table(name = "t_user")
public class User{
	@Id
	@GenerateValue
	private Long id;
	
	@Column(name = "user_number")
	private String userNumber;
	
	@JoinToOne(name = "idcard_id")
	@oneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)  
	private IDCard idcard ;
}

@Entity
@Table(name = "t_user")
public class IDCard{
	@Id
	@GenerateValue
	private Long id;
	
	@Column(name = "id_number")
	private String idNumber;
}

注意1：fetch = FetchType.LAZY表示拦截
注意2：cascade = CascadeType.ALL表示无论你对User表做什么操作，JPA都会自动帮你关联操作身份证表；
如果改成PERSIST，cascade = CascadeType.PERSIST那么只有在你保存User表时，JPA才会帮你关联操作身份证表，其他时候比如像修改这样的操作，JPA就不会自动帮修改身份证表；
注意3：关联类型有几种
第一种：ALL：表示所有操作都会关联操作
第二种：PERSIST：表示只有在保存时，才会关联操作
第三种：REMOVE：只有在删除时，才会关联操作
第四种：MERGE：只有在修改时，才会关联操作
一般后面几种我们都不用，我们都用ALL
注意4：以上两个具有关联关系的实体类创建好后，我们再运行一个空的测试方法，就能正在数据库中创建好这两张表，并且它们之间的关联关系也弄好了；

1.1 测试

你要测试的话，首先你这是两张表，一张t_user表，一张t_idcard表，你想要JPA自动帮你进行关联操作，你除了要写userRepository，你还需要写idcardRepository，没有idcardRepository，那么连操作身份证表的mapper接口都没有；

@Repository
public interace userRepository extends JpaRepository<User,Long>{
}

@Repository
public interace idcardRepositoryextends JpaRepository<IDCard,Long>{
}

2. 一对多关系 @OneToMany

以作者跟文章为例，一个作者有多个文章，一个文章只能有一个作者；
所以我们在作者类中，就要用@OneToMany，在文章类中就要用@ManyToOne；
注意：在JPA中，一对多的双向关系是由多端来进行维护的，也就是由文章端来进行维护，也就是说由Article文章端来负责增删改查，你只能对文章表进行增删改查，然后JPA再关联操作作者表；你不能直接对作者端增删改查；这就是JPA中一对多关系只能由多端来进行维护的意思；

所以说：我们在一端这边，Author这边，我们使用@OneToMany，并且里面加上mappedBy = “author”表示Author表现在是被维护的一端；

Author类：

@Entity
@Table(name = "t_author")
public class Author{
	@Id
	@GenerateValue
	private Long id;
	
	@Column(name = "user_name")
	private String userName;
	
	@OneToMany(mappedBy = "author", cascade = CascadeType.All, fetch = FetchType.LAZY)
	private List<Article> articleList;
}

注意1：mappedBy = "author"中的author是Article类中的author属性，表示这是被author属性维护的；
注意2：cascade = CascadeType.All表示我对作者的任何操作，JPA都会关联操作文章；

Article类：

@Entity
@Table(name = "t_article")
public class Article{
	@Id
	@GenerateValue
	private Long id;
	
	@Lob  //加了这个注解，就表示这是大文本数据类型，对应Mysql中的Long Text类型；
	@Basic(fetch = FetchType.LAZY)
	@Column(nullable = false)
	private String context;

	@Column(nullable = false ,name = "title")
	private String title;
	
	@JoinToOne(name = "author_id")
	@ManyToOne(cascade = {CascadeType.MERGE, CascadeType.REFRESH},optional = false)
	private Author author;
}

注意：optional = false表示author不能为空

2.1 一对多注意的点：

1.懒加载的问题：

我们先通过id将author查出来，看能不能一并把author下面的所有文章articleList也查出来；

authorRepository.findById(1L).ifPresent(System.out::println)

当我们执行后，我们会发现报了一个懒加载异常
在这里插入图片描述
解决办法：把Author中的懒加载改成实时加载。
修改前：
在这里插入图片描述
修改后：

@OneToMany(mappedBy = "author", cascade = CascadeType.All, fetch = FetchType.EAGER)
private List<Article> articleList;
2. 栈内存溢出的问题

当我们上面把懒加载改成实时加载后，我们再次运行这句代码；

authorRepository.findById(1L).ifPresent(System.out::println)

发现报了一个占内存溢出的异常：这是为什么呢？
这是因为这里产生了循环遍历的问题：上面的authorRepository.findById(1L)代码会查询出author下面的articleList，并且点儿了ifPresent(System.out::println)这句代码，它就会一直调用articleList里每一个article的toString方法，但是又由于article又有一个author属性，它就会调用author的toString，调用author的toString，又会导致要调用article的toString，导致陷入无限循环；
在这里插入图片描述
解决办法：破坏掉它们任意一个toString方法；
比如我现在破坏掉Article的toString，使用@ToString(exclude = {“author”})来排除author的转换；
意思就是，当我们在调用Article的toString时，不会将author属性也算进去；

@Entity
@Table(name = "t_article")
@Data
@ToString(exclude = {"author"}) //.........................看这里
public class Article{
	@Id
	@GenerateValue
	private Long id;
	
	@Lob  //加了这个注解，就表示这是大文本数据类型，对应Mysql中的Long Text类型；
	@Basic(fetch = FetchType.LAZY)
	@Column(nullable = false)
	private String context;

	@Column(nullable = false ,name = "title")
	private String title;
	
	@JoinToOne(name = "author_id")
	@ManyToOne(cascade = {CascadeType.MERGE, CascadeType.REFRESH},optional = false)
	private Author author;
}

3. 多对多关系 @ManyToMany

比如用户跟权限的关系，用户跟权限之间就是多对多关系；
注意1：多对多关系中，我们一般不会像一对多，多对一那样设置CascadeType级联操作，因为多对多已经有中间表了；
注意2：一对多，多对一中，由多方来做维护端，但是在多对多中，可以指定任意一方为维护端；

以用户类跟权限类举例：
User类：

@Entity
@Data
@Table(name = "t_user")
public class User{
	@Id
	@GenerateValue
	private Long id;
	
	@Column(name = "user_name", nullable = false, length = 20, unique = true)
	private String userName;

	@Column(length = 100)
	private String password;
	
	@JoinTable(name = "user_authority", joinColumns = @joinColumn(name = "user_id"),inverseJoinColumns = @JoinColumn(name = "authority_id"))
	@ManyToMany
	private List<Authority> authorityList;
}

注意1：unique = true表示当前属性是唯一不可重复的；
注意2：
@JoinTable中name = "user_authority"表示指定中间表的名字为user_authority，
joinColumns = @joinColumn(name = “user_id”)表示t_user表在中间表中使用user_id进行表示，
inverseJoinColumns = @JoinColumn(name = “authority_id”))表示被转换的列，也就是authority表在中间表中用authority_id进行表示；

Authority类：

@Entity
@Data
@Table(name = t_authority)
public class Authority{
	@Id
	@GenerateValue
	private Long id;
	
	@Column(nullable = false)
	private String name;

	@ManyToMany(mappedBy = "authorityList")  //意思就是Authority类是根据User类中authorityList进行的关系的维护
	private List<User> userList;
}

注意：这样写好后，我们再任意运行一个空的测试方法，就能在数据库中创建出对应的表，并且生成对应的中间表；

一缕情丝一生珍藏
关注
JPA使用教程
08-25
spring-data-jpa psf文档，全面的jpa使用教程，提供全面api操作说明
SpringBoot JPA 使用教程
showadwalker的博客
05-02 4030
文章目录1. 简介2. 常用注解2.1 @Entity2.2 @Table2.3 @Id 、@GeneratedValue、@SequenceGenerator、@Column2.3.1 @Id2.3.2 @GeneratedValue2.3.3 @SequenceGenerator2.3.4 @Column2.4 @Transient2.5 @Temproal3. EntityManagerFactory 1. 简介 Jpa 是一套ORM 的规范 hibernate 不就是一个 ORM 框架也提供了对于
Spring Data JPA使用及实现原理总结
JingAi_jia917的博客
07-02 1350
本文对Spring Data JPA的使用及其实现原理进行总结。包括：Repository接口类型、EntityManager的数据库操作、Criteria查询、多表关系、ID生成策略、复合主键、Auditing审计、事务。
实战系列（四）| JPA详解，包含详细代码
Web3 & Basketball
09-15 1020
JPA（Java Persistence API）是 Java EE 规范中的一部分，它定义了一组标准的 API，用于将 Java 对象映射到关系数据库表。JPA 的目标是简化企业应用开发，使得开发者能够更容易地实现对象与数据库表之间的映射关系。
SpringData JPA 快速入门案例详解
zp8126的专栏
03-19 1779
JPA（Java Persistence API）是 Java 持久层规范，定义了一些列 ORM 接口，它本身是不能直接使用的，因为接口需要实现才能使用，Hibernate 框架就是实现 JPA 规范的框架。
JPA详解
系统运维
09-23 423
1.1 01、全面阐释和精彩总结JPA 1.2 02、JPA开发环境和思想介绍 1.3 03、搭建JPA开发环境和全局事务介绍 1.4 04、第一个JPA实例与JPA主键生成策略 1.5 05、日期_枚举等字段类型的JPA映射 1.6 06、大数据字段映射与字段延迟加载 1.7 07、使用JPA加载_更新_删除对象 1.8 08、分析JPA与持久化实现产品对接的源代码 1.9 ...
JPA学习笔记2——JPA高级
10-27 639
1.JPA的实体生命周期： JPA的实体有以下4中生命周期状态： (1).New：瞬时对象，尚未有id，还未和Persistence Context建立关联的对象。 (2).Managed：持久化受管对象，有id值，已经和Persistence Context建立了关联的对象。 (3).Datached：游离态离线对象，有id值，但没有和Persistence Context建立关联的对象
JPA 教程（一）
pengwei1221的博客
02-21 204
1.JPA概述 JPA(Java Persistence API)作为Java EE 5.0平台标准的ORM规范，将得到所有Java EE服务器的支持。 Sun这次吸取了之前EJB规范惨痛失败的经历，在充分吸收现有ORM框架的基础上，得到了一个易于使用、伸缩性强的ORM规范。 从目前的开发社区的反应上看，JPA受到了极大的支持和赞扬，JPA作为ORM领域标准化整合者的目标应该不难实现...
JPA的学习
weixin_30924087的博客
04-09 84
JPA 1.实体注解 @Entity主键注解 @Id 主键策略@GeneratedValue（strategy=GenerationType.AUTO[IDENTITY,SEQUENCE,TABLE]) auto:根据方言数据库自己选择，默认选项 identity：MySQL支持 sequence：oracle支持@Column(length=32)字段长度 @Temporal(...
JPA教程
hchhan的博客
10-21 971
JPA只是一个简化对象关系映射来管理Java应用程序中的关系数据的规范。 它提供了一个平台，可以直接使用对象而不是使用SQL语句。 Java持久性API(JPA)是Java的一个规范。 它用于在Java对象和关系数据库之间保存数据。 JPA充当面向对象的领域模型和关系数据库系统之间的桥梁。 由于JPA只是一个规范，它本身不执行任何操作。 它需要一个实现。 因此，像Hibernate，TopLi...
JPA入门教程【转】
weixin_34205826的博客
12-04 414
JPA(Java Persistence API，Java持久化API)一、什么是JPA对象关系映射ORM（Object-RelationMapping）是用来将对象和对象之间的关系对应到数据库中表与表之间的关系的一种模式。ORM框架能够将Java对象映射到关系数据库，能够直接持久化复杂的Java对象。ORM框架的出现，使开发者从数据库编程中解脱出来，把更多的精力放在了业务模...
JPA教程JPA教程JPA教程
07-18
JPA教程JPA教程JPA教程JPA教程JPA教程
jpa教程
04-28
jpa教程中文版通过 JDK 5.0 注解或 XML 描述对象－关系表的映射关系
简单JPA教程
02-06
JPA(Java Persistence API)作为 Java EE 5.0 平台标准的 ORM 规范，将得到所有 Java EE 服务器的支持。Sun 这次吸取了之前 EJB 规范惨痛失败的经历，在充分吸收现 有 ORM 框架的基础上，得到了一个易于使用、伸缩性强的 ORM 规范。从目 前的 开发社区的反应上看，JPA 受到了极大的支持和赞扬，JPA 作为 ORM 领域标准化 整合者的目标应该不难实现。
从入门到高级实战-深度探索SpringSecurity安全框架视频.zip
最新发布
08-29
10.Spring Security+Spring Data Jpa 11.RememberMe 功能展示 12.RememberMe 实现原理分析 13.RememberMe 持久化令牌方案 14.RememberMe 二次校验 15.Spring Security+MyBatis 做登录 16.AuthenticationProvider ...
jpa入门
08-10
**JPA（Java Persistence API）入门指南** JPA，全称Java Persistence API，是Java平台上的一个标准，用于处理对象关系映射（ORM），它提供了一种将Java类与数据库表进行映射的方法，简化了数据库操作。在本文中，...
Spring Data JPA 极速入门
q1472750149的博客
01-05 219
0.阅读完本文你将会学会 如何在Spring项目中引入Spring Data JPA 本文一共约1800读时长大概等于一首黑眼豆豆的《Where Is The Love?》。 1. 概述 这篇文章将重点介绍如何在Spring项目中引入Spring Data JPA，并全面配置持久化层。 2.Spring Data生成的DAO--不再有DAO的实现 DAO层的设计中含有很多样板代码，它应该被简化。这种简化的好处有很多：减少我们需要定义和维护的组件数量；维护数据访问模式的一致性；以及维护配置的一致性。
《Spring Data Jpa从入门到精通》知识点总结
quick_snail的博客
08-14 860
以下内容纯属个人扯淡，仅供参考，建议拜读原著 目录 读后感 第一部分：基础 第1章：整体认识JPA 第2章：JPA基础查询方法 第3章：定义查询方法 第4章：注解式查询方法 第5章：@Entity实例中常用注解详解 第二部分：高级 第6章：JpaRepository扩展详解 第7章：Spring Data JPA的扩展 第8章：DataSource的配置 第三部分：扩展 第9章：IDEA与Spring JPA 第10章：Spring Data Redis 详解 第11章：Sp
JPA注解详解：从入门到高级实践
1. **@Entity 注解**：这是JPA中最基本的注解，用于标记一个Java类作为持久化实体类，意味着这个类的对象将被映射到数据库中的一个表。如示例中的Employee类，通过`@Entity`注解声明，表明该类应与数据库中的某个表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值