Spring Data JPA之JPA的快速入门（二）

最新推荐文章于 2024-01-05 08:46:56 发布

CodeDevMaster

最新推荐文章于 2024-01-05 08:46:56 发布

阅读量330

点赞数 1

分类专栏： # Spring Data JPA 文章标签： jpa

本文链接：https://blog.csdn.net/qq_38628046/article/details/108612550

版权

Spring Data JPA 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

Spring Data JPA之JPA的快速入门（二）

一、JPA的API介绍
二、抽取JPAUtil工具类
三、JPA的基本CRUD
四、JPA的JPQL复杂查询

一、JPA的API介绍

1.Persistence对象

Persistence对象主要作用是用于获取EntityManagerFactory对象。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。

//JPA的核心配置文件中配置的持久化单元定义名称
String unitName = "myJpa";
//创建 EntitymanagerFactory
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

2.EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例

//创建实体管理类
EntityManager em = factory.createEntityManager();

3.EntityManager

在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作

getTransaction : 获取事务对象
persist ： 保存操作
merge ： 更新操作
remove ： 删除操作
find/getReference ： 根据id查询

4.EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在java代码中承接的功能比较简单

begin：开启事务
commit：提交事务
rollback：回滚事务

二、抽取JPAUtil工具类

由于EntityManagerFactory 是一个线程安全的对象，并且EntityManagerFactory 的创建极其浪费资源，所以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可。

public class JpaUtils {

    private static EntityManagerFactory factory;

    static  {
        //1.加载配置文件，创建一个公共的entityManagerFactory实体管理器工厂对象
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取EntityManager对象
     * 
     * 第一次访问：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
     * 第二次访问：直接通过一个已经创建好的factory对象，创建EntityManager对象
     */
    public static EntityManager getEntityManager() {
       return factory.createEntityManager();
    }
}

三、JPA的基本CRUD

Jpa的操作步骤：

 1.加载配置文件创建工厂（实体管理器工厂）对象
 
 2.通过实体管理器工厂获取实体管理器
 
 3.获取事务对象，开启事务
 
 4.完成增删改查操作
 
 5.提交事务（回滚事务）
 
 6.释放资源

1.保存操作

    @Test
    public void testSave() {
//        //1.加载配置文件创建工厂（实体管理器工厂）对象
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
//        //2.通过实体管理器工厂获取实体管理器
//        EntityManager em = factory.createEntityManager();
        EntityManager em = JpaUtils.getEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction(); //获取事务对象
        tx.begin();//开启事务
        //4.完成增删改查操作
        User user= new User();
        user.setUserName("小白");
        user.setUserPhone("6666");
        //保存，
        em.persist(user); 
        //5.提交事务
        tx.commit();
        //6.释放资源
        em.close();
 //      factory.close();

    }

2.查询操作

find（）方法
在调用find方法时，就会发送sql语句查询数据库，是立即加载。

    @Test
    public  void testFind() {
        //通过工具类获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //删改查 -- 根据id查询客户
        
        /**
         * find : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        User user1= entityManager.find(User.class, 1l);
         User user2 = entityManager.find(User.class, 1l);
         // 输出结果是true，EntityManager也有缓存
         System.out.println(user1 == user2);
        //提交事务
        tx.commit();
        //释放资源
        entityManager.close();
    }

getReference（）方法

getReference方法不会立即发送sql语句查询数据库，当调用查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库。获取的对象是一个动态代理对象，该getReference（）方法是延迟加载（懒加载）。

    @Test
    public  void testReference() {
        //通过工具类获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //根据id查询客户
        
        /**
         * getReference : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        User user = entityManager.getReference(User.class, 1l);
        System.out.print(user );
        //提交事务
        tx.commit();
        //释放资源
        entityManager.close();
    }

3.删除操作

    @Test
    public  void testRemove() {
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //删除客户

        //根据id查询客户
        User user = entityManager.find(User.class,1l);
        //调用remove方法完成删除操作
        entityManager.remove(user );
        tx.commit();
        entityManager.close();
    }

4.更新操作

    @Test
    public  void testUpdate() {
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //更新操作
        User user= entityManager.find(User.class,1l);
        user.setUserName("大白白");
        //em.clear();能把user对象从缓存中清除
        entityManager.merge(user);
        tx.commit();
        entityManager.close();
    }

四、JPA的JPQL复杂查询

JPQL全称Java Persistence Query Language

Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

jpql查询步骤:

 1.编写JPQL语句
 
 2.创建query查询对象
 
 3.对参数进行赋值
 
 4.查询，并封装结果集

1.查询全部

jqpl：from cn.ybzy.domain.User

sql：SELECT * FROM user

  @Test
    public void testFindAll() {
        //获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //查询全部
        String jpql = "from User";
        //创建Query查询对象，query对象才是执行jqpl的对象
        Query query = em.createQuery(jpql);/

        //发送查询，并封装结果集
        List list = query.getResultList();

        for (Object obj : list) {
            System.out.print(obj);
        }
        //提交事务
        tx.commit();
        //释放资源
        em.close();
    }

2.分页查询

jqpl : from User

sql：select * from user limit 0,2

@Test
    public void testPaged() {
        //获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //根据jpql语句创建Query查询对象
        String jpql = "from User";
        Query query = em.createQuery(jpql);
        //对参数赋值
        //起始索引
        query.setFirstResult(0);
        //每页查询的条数
        query.setMaxResults(2);

        //查询，并封装结果
        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }
        //提交事务
        tx.commit();
        //释放资源
        em.close();
    }

3.条件查询

jpql : from User where username like ?
 
sql：SELECT * FROM user WHERE username LIKE  ?

@Test
    public void testCondition() {
        //获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //根据jpql语句创建Query查询对象
        String jpql = "from User where username like ? ";
        Query query = em.createQuery(jpql);
        //对占位符参数参数赋值
        //第一个参数：占位符的索引位置（从1开始），第二个参数：取值
        query.setParameter(1,"%大白%");

        /**
         * 查询，并封装结果
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }
        tx.commit();
        em.close();
    }

4.统计查询

jpql：select count(userId) from User

sql：SELECT COUNT(user_id) FROM user

    @Test
    public void testCount() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql = "select count(userId) from User";
        Query query = em.createQuery(jpql);
        Object result = query.getSingleResult();
        System.out.println(result);
        tx.commit();
        em.close();
    }

5.排序查询

 jpql：from User order by userId desc
 
 sql：SELECT * FROM user ORDER BY user_id DESC

   @Test
    public void testOrders() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql = "from User order by userId desc";
        Query query = em.createQuery(jpql);

        List list = query.getResultList();

        for (Object obj : list) {
            System.out.println(obj);
        }

        tx.commit();
        em.close();
    }