转载

【JPA专题】05.JPA的基本操作CRUD

根据上一篇文章中涉及到的方法进行相关的测试，这里我们需要准备一些测试的持久化类

老师基本信息持久化类：

package com.os.model;

import javax.persistence.*;
import java.util.Date;
@Entity
@Table(name = "jpa_teacher")
public class Teacher {
    private Integer teacherId;
    private String teacherName;
    private Integer age;
    private String sex;
    private Date birthday;
    private Date createDate;

    @Column(name = "teacher_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Id
    public Integer getTeacherId() {
        return teacherId;
    }

    public void setTeacherId(Integer teacherId) {
        this.teacherId = teacherId;
    }
    @Column(name = "teacher_name",length = 16,nullable = false)
    public String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }
    @Column(length = 3)
    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    @Column(length = 1)
    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    @Temporal(TemporalType.DATE)
    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Column(name = "create_date")
    @Temporal(value = TemporalType.TIMESTAMP)
    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "teacherId=" + teacherId +
                ", teacherName='" + teacherName + '/'' +
                ", age=" + age +
                ", sex='" + sex + '/'' +
                ", birthday=" + birthday +
                ", createDate=" + createDate +
                '}';
    }
}
复制代码
【JPA专题】05.JPA的基本操作CRUD

数据也准备完毕了，使用程序添加的简单数据

引入单元测试，方便比较学习

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
复制代码

单元测试的基本模版代码如下

package com.os.test;

import org.junit.After;
import org.junit.Before;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class JPATest {

    private EntityManagerFactory factory ;
    private EntityManager entityManager ;
    private EntityTransaction tx;
    @Before
    public void init(){
        factory = Persistence.createEntityManagerFactory("jpa02");
        entityManager = factory.createEntityManager();
        tx = entityManager.getTransaction();
        tx.begin();
    }
    @After
    public void close(){
        tx.commit();
        entityManager.close();
        factory.close();
    }
}
复制代码

find 和 getReference 区别

find (Class<T> entityClass,Object primaryKey) ：返回指定的 OID 对应的实体类对象，如果这个实体存在于当前的持久化环境，则返回一个被缓存的对象；否则会创建一个新的 Entity, 并加载数据库中相关信息；若 OID 不存在于数据库中，则返回一个 null。第一个参数为被查询的实体类类型，第二个参数为待查找实体的主键值。（ 类似于Hibernate中的get方法 ）

之后的版本，我们就不在设置粘贴模版代码了，代码如下：

package com.os.test;

import com.os.model.Teacher;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class JPATest {

    private EntityManagerFactory factory ;
    private EntityManager entityManager ;
    private EntityTransaction tx;
    @Before
    public void init(){
        factory = Persistence.createEntityManagerFactory("jpa02");
        entityManager = factory.createEntityManager();
        tx = entityManager.getTransaction();
        tx.begin();
    }
    @After
    public void close(){
        tx.commit();
        entityManager.close();
        factory.close();
    }

    //类似于 hibernate 中 Session 的 get 方法.
    @Test
    public void testFind01(){
        Teacher teacher = entityManager.find(Teacher.class,1);//该ID是数据库存在
        System.out.println("=========================");
        System.out.println(teacher);
    }
    @Test
    public void testFind02(){
        Teacher teacher = entityManager.find(Teacher.class,100);//该ID是数据库不存在
        System.out.println("=========================");
        System.out.println(teacher);
    }
}
复制代码

getReference (Class<T> entityClass,Object primaryKey) ：与find()方法类似，不同的是：如果缓存中不存在指定的 Entity, EntityManager 会创建一个 Entity 类的代理，但是不会立即加载数据库中的信息，只有 第一次真正使用 此 Entity 的属性才加载，所以如果此 OID 在数据库不存在， getReference() 不会返回 null 值, 而是抛出EntityNotFoundException （ 类似于Hibernate中的load方法 ） 

//类似于 hibernate 中 Session 的 load 方法
@Test
public void testGetReference01(){
    Teacher teacher = entityManager.getReference(Teacher.class,1);//该ID是数据库存在
    System.out.println("=========================");
    System.out.println(teacher);
}

/**
  * javax.persistence.EntityNotFoundException: Unable to find com.os.model.Teacher with id 100
  */
@Test
public void testGetReference02(){
    Teacher teacher = entityManager.getReference(Teacher.class,100);//该ID是数据库存在
    System.out.println("=========================");
    System.out.println(teacher);
}

/**
* org.hibernate.LazyInitializationException: could not initialize proxy [com.os.model.Teacher#1] - no Session
*/
@Test
public void testGetReference03(){
    Teacher teacher = entityManager.getReference(Teacher.class,1);//该ID是数据库存在
    System.out.println("=========================");
    tx.commit();
    entityManager.close();

    System.out.println(teacher);
}
复制代码

getReference涉及到延迟加载，需要注意EntityManager没有被关闭

为什么使用延迟加载？大家可以执行百度

persist (Object entity) ：用于将新创建的Entity纳入到EntityManager的管理。该方法执行后，传入 persist() 方法的 Entity 对象转换成持久化状态。（类似于Hibernate中的save方法）

  • 如果传入 persist() 方法的 Entity 对象已经处于持久化状态，则 persist() 方法什么都不做。

    //类似于 hibernate 的 save 方法. 使对象由临时状态变为持久化状态.
//和 hibernate 的 save 方法的不同之处: 若对象有 id, 则不能执行 insert 操作, 而会抛出异常.
@Test
public void testPersist01(){
    Teacher teacher = new Teacher();
    teacher.setTeacherName("唐僧");
    teacher.setAge(99);
    teacher.setSex("女");
    teacher.setBirthday(new Date());
    teacher.setCreateDate(new Date());

    entityManager.persist(teacher);//teacher已经处于持久化状态
    entityManager.persist(teacher);
    entityManager.persist(teacher);

    System.out.println(teacher.getTeacherId());
}
复制代码

    上述代码说明：我们执行了三次的保存操作，但是我们实际上添加到数据库中记录数为一条，原因就是执行persist方法后，该teacher对象已经处于了持久化状态（在一级缓存中），再次执行 entityManager.persist(teacher); 在一级缓存看看是否存在，如果一致，那么不不执行任何操作 

    //类似于 hibernate 的 save 方法. 使对象由临时状态变为持久化状态.
    //和 hibernate 的 save 方法的不同之处: 若对象有 id, 则不能执行 insert 操作, 而会抛出异常.
    @Test
    public void testPersist02(){
        Teacher teacher = new Teacher();
        teacher.setTeacherName("沙僧");
        teacher.setAge(99);
        teacher.setSex("男");
        teacher.setBirthday(new Date());
        teacher.setCreateDate(new Date());

        entityManager.persist(teacher);//teacher已经处于持久化状态
        teacher.setTeacherName("卷帘大将");

        System.out.println(teacher.getTeacherId());
    }
复制代码

    上述代码说明：在事务提交之前，检查一级缓存中存储的对象和实际的对象是否一致，如果不一致会产生Update语句，很重要的

    //类似于 hibernate 的 save 方法. 使对象由临时状态变为持久化状态.
    //和 hibernate 的 save 方法的不同之处: 若对象有 id, 则不能执行 insert 操作, 而会抛出异常.
    /*
    * javax.persistence.PersistenceException: 
    * org.hibernate.PersistentObjectException: 
    *   detached entity passed to persist: com.os.model.Teacher
    * */
    @Test
    public void testPersist03(){
        Teacher teacher = new Teacher();
        teacher.setTeacherName("悟空");
        teacher.setAge(99);
        teacher.setSex("男");
        teacher.setBirthday(new Date());
        teacher.setCreateDate(new Date());
        teacher.setTeacherId(88);//注意我设置了主键ID

        entityManager.persist(teacher);//teacher已经处于持久化状态

        System.out.println(teacher.getTeacherId());
    }
复制代码

  • 如果对删除状态的 Entity 进行 persist() 操作，会转换为持久化状态。

    @Test
public void testPersist04(){
    Teacher teacher = entityManager.find(Teacher.class,5);//1.持久化状态
    entityManager.remove(teacher);
    System.out.println("teacher = " + teacher);//2.处于删除状态

    entityManager.persist(teacher);//3.处于游离状态
}
复制代码

    上述代码说明：其实根本就没有产生delete语句，只有一个查询操作，因为上述代码给人的感觉“ 还原 ”

  • 如果对游离状态的实体执行 persist() 操作，可能会在 persist() 方法抛出 EntityExistException(也有可能是在flush或事务提交后抛出)。

    @Test
public void testPersist05(){
    Teacher teacher = entityManager.find(Teacher.class,5);//1.持久化状状态
    tx.commit();
    entityManager.close();
    System.out.println("teacher = " + teacher);//2.处于游离状态

    entityManager = factory.createEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    entityManager.persist(teacher);
    /*
     *javax.persistence.PersistenceException: 
     *   org.hibernate.PersistentObjectException: 
     *       detached entity passed to persist: com.os.model.Teacher
     * */
}
复制代码

remove (Object entity) ：删除实例。如果实例是被管理的，即与数据库实体记录关联，则同时会删除关联的数据库记录。（类似于Hibernate中的Delete方法） 

//类似于 hibernate 中 Session 的 delete 方法. 把对象对应的记录从数据库中移除
//但注意: 该方法只能移除 持久化 对象. 而 hibernate 的 delete 方法实际上还可以移除 游离对象.
@Test
public void testRemove01(){
    Teacher teacher = new Teacher();//瞬时状态
    teacher.setTeacherId(4);//数据库中存在该条记录
    entityManager.remove(teacher);
    /*
     * java.lang.IllegalArgumentException: 
     *   Removing a detached instance com.os.model.Teacher#4
     * */
}
复制代码

正确使用方式

//类似于 hibernate 中 Session 的 delete 方法. 把对象对应的记录从数据库中移除
//但注意: 该方法只能移除 持久化 对象. 而 hibernate 的 delete 方法实际上还可以移除 游离对象.
@Test
public void testRemove02(){
    Teacher teacher = entityManager.getReference(Teacher.class,4);//持久化对象
    entityManager.remove(teacher);//使用的时候先查询后执行删除操作
}
复制代码

merge (T entity) ：merge() 用于处理 Entity 的同步。即数据库的插入和更新操作，这个操作的情况有点多，我们通过代码进行说明

【JPA专题】05.JPA的基本操作CRUD

总的来说: 类似于 hibernate Session 的 saveOrUpdate 方法.

1.临时对象，执行保存操作

/*
 * 若传入的是一个临时对象
 * 会创建一个新的对象, 把临时对象的属性复制到新的对象中, 然后对新的对象执行持久化操作. 所以
 * 新的对象中有 id, 但以前的临时对象中没有 id.
 * */
@Test
public void testMerge1(){
    Teacher teacher = new Teacher();
    teacher.setTeacherName("林黛玉");
    teacher.setAge(19);
    teacher.setSex("女");
    teacher.setBirthday(new Date());
    teacher.setCreateDate(new Date());

    Teacher teacher1 = entityManager.merge(teacher);
    System.out.println("teacher.getTeacherId() = " + teacher.getTeacherId());
    System.out.println("teacher1.getTeacherId() = " + teacher1.getTeacherId());

}
复制代码

2. 若传入的是一个游离对象,若在 EntityManager 缓存中没有该对象, 即传入的对象有 OID，数据库中没有对应的主键ID

执行Insert操作，老对象的teacherId是100，保存之后新对象的主键ID是数据库中的主键ID

@Test
public void testMerge2(){
    Teacher teacher = new Teacher();
    teacher.setTeacherName("林黛玉");
    teacher.setAge(19);
    teacher.setSex("女");
    teacher.setBirthday(new Date());
    teacher.setCreateDate(new Date());

    teacher.setTeacherId(100);//数据库没有该主键ID

    Teacher teacher1 = entityManager.merge(teacher);
    System.out.println("teacher.getTeacherId() = " + teacher.getTeacherId());
    System.out.println("teacher1.getTeacherId() = " + teacher1.getTeacherId());

}
复制代码

3. 若传入的是一个游离对象,若在 EntityManager 缓存中没有该对象, 即传入的对象有 OID，数据库中有对应的主键ID

JPA 会查询对应的记录, 然后返回该记录对一个的对象, 再然后会把游离对象的属性复制到查询到的对象中,执行Update操作

@Test
public void testMerge3(){
    Teacher teacher = new Teacher();
    teacher.setTeacherName("林黛玉");
    teacher.setAge(19);
    teacher.setSex("女");
    teacher.setBirthday(new Date());
    teacher.setCreateDate(new Date());

    teacher.setTeacherId(5);//数据库有该主键ID

    Teacher teacher1 = entityManager.merge(teacher);
    System.out.println("teacher.getTeacherId() = " + teacher.getTeacherId());
    System.out.println("teacher1.getTeacherId() = " + teacher1.getTeacherId());

}
复制代码

4. 若传入的是一个游离对象,若在 EntityManager 缓存中有该对象, 即传入的对象有 OID，数据库中有对应的主键ID

JPA 会把游离对象的属性复制到查询到EntityManager 缓存中的对象中,EntityManager 缓存中的对象执行 UPDATE

@Test
public void testMerge4(){
    Teacher teacher = new Teacher();
    teacher.setTeacherName("林黛玉");
    teacher.setAge(19);
    teacher.setSex("女");
    teacher.setBirthday(new Date());
    teacher.setCreateDate(new Date());

    teacher.setTeacherId(7);//数据库有该主键ID
    System.out.println("teacher = " + teacher);

    Teacher teacher1 = entityManager.find(Teacher.class,7);//一级缓存中存在该对象
    System.out.println("teacher1 = " + teacher1);

    entityManager.merge(teacher);

    System.out.println(teacher==teacher1);//返回的是false
}
复制代码

flush () ：同步持久上下文环境，即将持久上下文环境的所有未保存实体的状态信息保存到数据库中

这里需要使用断点调试，断点设置如图

【JPA专题】05.JPA的基本操作CRUD 
@Test
public void testFlush(){
    Teacher teacher = entityManager.find(Teacher.class,1);
    System.out.println("teacher = " + teacher);

    teacher.setTeacherName("林冲");

    entityManager.flush();
}
复制代码

refresh (Object entity) ：用数据库实体记录的值更新实体对象的状态，即更新实例的属性值。 

@Test
public void testReflush(){
    Teacher teacher = entityManager.find(Teacher.class,1);
    System.out.println("teacher = " + teacher);
    teacher = entityManager.find(Teacher.class,1);

    entityManager.refresh(teacher);//重新进行查询操作
}
复制代码
原文  https://juejin.im/post/5e13fd695188253a833b22b0
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：626 人
  • 运行天数：4,408天
  • 最后更新：2024年11月21日23点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG