springdata jpa的学习笔记
什么是jpa
JPA全称Java Persistence API（2019年重新命名为 Jakarta Persistence API ），是Sun官方提出的一种ORM规范。
O:Object R: Relational M:mapping
jpa的作用
1.简化持久化操作的开发工作：让开发者从繁琐的 JDBC 和 SQL 代码中解脱出来，直接面向对象持久化操作。
2.Sun希望持久化技术能够统一，实现天下归一：如果你是基于JPA进行持久化你可以随意切换数据库。
该规范为我们提供了:
- ORM映射数据: JPA 支持XML和注解两种数据的形式,元数据描述对象和表之间的映射关系,框架据此将实体对象持久化到数据库表中 如(@Entity,@Table,@Column等注解)
- JPA 的API：用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和 SQL代码中解脱出来
- JPQL查询语言：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。
总结来说: 就是基本不用写sql,基本的增删改查都有对应的api实现,但是对于一些复杂的操作,多表联查,动态条件查询,我个人觉的不如mybatis写的舒服方便, 所以我认为jpa适合用在逻辑关系比较简单的程序中, 在现在逻辑关系都比较复杂的情况的下,我觉的被淘汰时是难免的.但是随着微服务的兴起,我看到了jpa的兴起,毕竟单个服务的逻辑还是没有那么复杂的.所以我觉的jpa还是有必要掌握一些实现框架的 像hibernate这种的.
jpa和hibernate的关系
简单来说: jpa底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。 也就是说： JPA是一套ORM规范，Hibernate实现了JPA规范！学过jdbc的应该明白,就像 jdbc 和 实现它的框架类似, jpa 对 hibernate 的关系 就像 jdbc 对 mysql 的类似. jpa 也有许多的实现 如下图:
入门代码
第一步 : 新建一个maven项目 导入依赖
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- 使用hibernate 实现 jpa-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.6.9.Final</version>
</dependency>
</dependencies>
第二步 : 新建配置文件persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.2"
xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
<!-- 开启本地事务-->
<persistence-unit
name="hibernateJpa"
transaction-type="RESOURCE_LOCAL">
<!-- jpa 实现 方式-->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<class>com.pojo.User</class>
<!-- jpa 配置 中心-->
<properties>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="root"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/study_jpa"/>
<!-- 配置 jpa 的实现 方式(hibernate )-->
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
<!-- 配对 那种 数据库 版本-->
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL8Dialect"/>
</properties>
</persistence-unit>
</persistence>
第三步: 创建实体类
package com.ply.pojo;
import javax.persistence.*;
import java.util.Objects;
/**
* @author XiaoPan
* date: 2022/6/9 14:10
* <p>
* action:
*/
@Entity
@Table(name = "user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "user_id")
private Integer id;
@Column(name = "user_name")
private String userName;
@Column(name = "user_pwd")
private String userPwd;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPwd() {
return userPwd;
}
public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", userName='" + userName + '\'' +
", userPwd='" + userPwd + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(id, user.id) && Objects.equals(userName, user.userName) && Objects.equals(userPwd, user.userPwd);
}
@Override
public int hashCode() {
return Objects.hash(id, userName, userPwd);
}
}
第四步: 编写测试类
package com.ply;
import com.pojo.User;
import org.junit.Before;
import org.junit.Test;
import javax.persistence.*;
/**
* @author XiaoPan
* date: 2022/6/12 13:34
* <p>
* action:
*/
public class test {
private EntityManagerFactory factory;
EntityManager em;
@Before
public void init() {
// 加载配置文件 创建除 EntityManagerFactory
factory = Persistence.createEntityManagerFactory("hibernateJpa");
em = factory.createEntityManager();
}
// 增加+
@Test
public void textC() {
// 数据库的桥梁
// 获取事务
EntityTransaction transaction = em.getTransaction();
// 开启事务
transaction.begin();
User user = new User();
user.setUserName("zhansan");
em.persist(user);
// 提交事务
transaction.commit();
}
// 查询
@Test
public void textQ(){
// 使用 find 进行查询
// 立即查询
User user = em.find(User.class, 1);
System.out.println("=============");
System.out.println(user);
}
@Test
public void textQL(){
// 使用 进行查询
// 延迟查询 懒惰法 用到再去查询
User reference = em.getReference(User.class, 1);
System.out.println("==========");
System.out.println(reference);
}
@Test
public void testUP(){
User user1 = em.find(User.class, 1);
System.out.println(user1);
User user = new User();
user.setId(1);
user.setUserName("new");
// 保存和更新 操作 没有主键的值 的话 就插入
User merge = em.merge(user);
System.out.println(merge);
user1 = em.find(User.class, 1);
System.out.println(user1);
}
@Test
public void testUO2() throws InterruptedException {
User user1 = em.find(User.class, 1);
System.out.println(user1);
EntityTransaction transaction = em.getTransaction();
transaction.begin();
// 使用jpql 进行 数据库操作
String jpql = "UPDATE User set userName=:name where id=:id";
em.createQuery(jpql)
.setParameter("name", "new")
.setParameter("id", 1)
.executeUpdate();
transaction.commit();
em.clear();
user1 = em.find(User.class, 1);
System.out.println(user1);
}
}
使用jpa 对 数据库的基本增删改查 操作就完成了
jpa对象的4种状态
临时状态：刚创建出来，∙没有与entityManager发生关系，没有被持久化，不处于entityManager中的对象
持久状态：∙与entityManager发生关系，已经被持久化，您可以把持久化状态当做实实在在的数据库记录。
删除状态：执行remove方法，事物提交之前 游离状态：
游离状态就是提交到数据库后，事务commit后实体的状态，因为事务已经提交了，此时实体的属 性任你如何改变，也不会同步到数据库，因为游离是没人管的孩子，不在持久化上下文中。
对于不同的方法 所使用的场景也是不同的
public void persist(Object entity)
方法可以将实例转换为managed(托管)状态。在调用flush()方法或提交事物后，实 例将会被插入到数据库中。
对不同状态下的实例A，persist会产生以下操作:
- 如果A是一个new状态的实体，它将会转为managed状态；
- 如果A是一个managed状态的实体，它的状态不会发生任何改变。但是系统仍会在数据库执行INSERT操作；
- 如果A是一个removed(删除)状态的实体，它将会转换为受控状态；
- 如果A是一个detached(分离)状态的实体，该方法会抛出IllegalArgumentException异常，具体异常根据不同的 JPA实现有关
public void merge(Object entity)
merge方法的主要作用是将用户对一个detached状态实体的修改进行归档，归档后将产生 一个新的managed状态对象。
对不同状态下的实例A，merge会产生以下操作:
5. 如果A是一个detached状态的实体，该方法会将A的修改提交到数据库，并返回一个新的managed状态的实例A2
6. 如果A是一个new状态的实体，该方法会产生一个根据A产生的managed状态实体A2;
7. 如果A是一个managed状态的实体，它的状态不会发生任何改变。但是系统仍会在数据库执行UPDATE操作；
8. 如果A是一个removed状态的实体，该方法会抛出IllegalArgumentException异常。
public void refresh(Object entity)
refresh方法可以保证当前的实例与数据库中的实例的内容一致。 对不同状态下的实例A，refresh会产生以下操作:
9. 如果A是一个new状态的实例，不会发生任何操作，但有可能会抛出异常，具体情况根据不同JPA实现有关；
10. 2. 如果A是一个managed状态的实例，它的属性将会和数据库中的数据同步；
11. 3. 如果A是一个removed状态的实例，该方法将会抛出异常: Entity not managed
12. 4. 如果A是一个detached状态的实体，该方法将会抛出异常。
public void remove(Object entity)
remove方法可以将实体转换为removed状态，并且在调用flush()方法或提交事物后删除数据库中的数据。 对不同状态下的实例A，remove会产生以下操作:
13. 如果A是一个new状态的实例，A的状态不会发生任何改变，但系统仍会在数据库中执行DELETE语句；
14. 如果A是一个managed状态的实例，它的状态会转换为removed；
15. 如果A是一个removed状态的实例，不会发生任何操作;
16. 如果A是一个detached状态的实体，该方法将会抛出异常。
最后
有什么问题多多讨论呀,也可以私信我, 下一篇说spring 集成 jpa 实现
3033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
