4、JPA规范之基础查询

persist方法，执行添加操作

/**
 * 测试jpa的添加操作
 */
@Test
public void testInsert(){
    //1.加载配置文件创建工厂（实体类工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();

    //3.获取事务对象，开启事务
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();
    //4.完成增删改查操作
    Users user = new Users();
    user.setUserName("小黑");
    user.setUserSex("男");
    //保存
    entityManager.persist(user);
    //5.提交事务（回滚事务）
    transaction.commit();
    //6.释放资源
    entityManager.close();
    factory.close();
}

find方法，通过id查询单条数据（即时加载）

/**
 * 根据id查询用户
 *  使用find方法查询
 *      1.查询的对象就是当前客户对象本身
 *      2.在调用find方法的时候，就会发送sql语句查询数据库（立即加载）
 */
@Test
public void testFind(){
    //1.加载配置文件创建工厂（实体类工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();
    
    //3.获取事务对象，开启事务
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();
    //4.完成增删改查操作
    Users user = entityManager.find(Users.class, 1);
    System.out.println(user);

    //5.提交事务（回滚事务）
    transaction.commit();
    //6.释放资源
    entityManager.close();
    factory.close();
}

getReference方法，通过id查询单条数据（延迟加载）

/**
 * 根据id查询用户
 *      getReference方法
 *          1.获取的对象是一个动态代理对象
 *          2.调用getReference方法不会立即发送sql语句查询数据库
 *                  当调用查询结果对象时，才会发送sql语句（懒加载）
 */
@Test
public void testReference(){
    //1.加载配置文件创建工厂（实体类工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();

    //3.获取事务对象，开启事务
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();
    //4.完成增删改查操作
    Users user = entityManager.getReference(Users.class, 1);
    System.out.println(user);

    //5.提交事务（回滚事务）
    transaction.commit();
    //6.释放资源
    entityManager.close();
    factory.close();
}

remove方法，执行删除操作

@Test
public void testRemove(){
    //1.加载配置文件创建工厂（实体类工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();
    
    //3.获取事务对象，开启事务
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();
    //4.完成增删改查操作
    Users user = entityManager.find(Users.class, 4);
    entityManager.remove(user);

    //5.提交事务（回滚事务）
    transaction.commit();
    //6.释放资源
    entityManager.close();
    factory.close();
}

merge方法，执行更新操作

@Test
public void testUpdate(){
    //1.加载配置文件创建工厂（实体类工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();
    //4.完成增删改查操作
    Users user = entityManager.find(Users.class, 3);
    user.setUserName("小白");
    entityManager.merge(user);

    //5.提交事务（回滚事务）
    transaction.commit();
    //6.释放资源
    entityManager.close();
    factory.close();
}

HPQL 查询

hpql 语法与 hql语法一致

hpql 执行查询所有数据

/**
 * 查询所有
 * select * from users
 */
@Test
public void testFindAll(){
    //1.加载配置文件创建工厂（实体类工厂）对象
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = factory.createEntityManager();

    //3.获取事务对象，开启事务
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();
    //4.完成增删改查操作
    String jpql = "from com.example.pojo.Users";
    Query query = entityManager.createQuery(jpql); //创建Query查询对象，query对象才是执行jpql的对象

    List<Users> list = query.getResultList();

    for (Users user: list
         ) {
        System.out.println(user);
    }

    //5.提交事务（回滚事务）
    transaction.commit();
    //6.释放资源
    entityManager.close();
    factory.close();
}

降序查询

    @Test
    public void testDestFindAll(){
        //1.加载配置文件创建工厂（实体类工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = factory.createEntityManager();
      
        //3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //4.完成增删改查操作
        String jpql = "from com.example.pojo.Users order by userId desc";
        Query query = entityManager.createQuery(jpql); //创建Query查询对象，query对象才是执行jpql的对象

        List<Users> list = query.getResultList();

        for (Users user: list
                ) {
            System.out.println(user);
        }

        //5.提交事务（回滚事务）
        transaction.commit();
        //6.释放资源
        entityManager.close();
        factory.close();
    }

聚合函数

    /**
     * 聚合函数
     */
    @Test
    public void testFindAllCount(){
        //1.加载配置文件创建工厂（实体类工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = factory.createEntityManager();
        
        //3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //4.完成增删改查操作
        String jpql = "select count(userId) from com.example.pojo.Users";
        Query query = entityManager.createQuery(jpql); //创建Query查询对象，query对象才是执行jpql的对象

        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);

        //5.提交事务（回滚事务）
        transaction.commit();
        //6.释放资源
        entityManager.close();
        factory.close();
    }

分页查询

    /**
     * 分页查询
     * select * from users limit 0,3
     */
    @Test
    public void testlimitFind(){
        //1.加载配置文件创建工厂（实体类工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = factory.createEntityManager();
        
        //3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //4.完成增删改查操作
        String jpql = "from com.example.pojo.Users";
        Query query = entityManager.createQuery(jpql); //创建Query查询对象，query对象才是执行jpql的对象
        //设置从哪个小标开始读取数据
        query.setFirstResult(0);
        //设置最多获取几条数据
        query.setMaxResults(3);

        List<Users> resultList = query.getResultList();

        for (Users user: resultList
             ) {
            System.out.println(user);
        }

        //5.提交事务（回滚事务）
        transaction.commit();
        //6.释放资源
        entityManager.close();
        factory.close();
    }

条件查询

    /**
     * 条件查询
     * select * from users limit 0,3
     */
    @Test
    public void testCondition(){
        //1.加载配置文件创建工厂（实体类工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = factory.createEntityManager();
       
        //3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //4.完成增删改查操作
        String jpql = "from Users where userName like ?";
        Query query = entityManager.createQuery(jpql); //创建Query查询对象，query对象才是执行jpql的对象
        query.setParameter(1,"%白%");

        List<Users> resultList = query.getResultList();

        for (Users user: resultList
                ) {
            System.out.println(user);
        }

        //5.提交事务（回滚事务）
        transaction.commit();
        //6.释放资源
        entityManager.close();
        factory.close();
    }

以上方法出现过多的重复性代码，这些代码都是获取对象，事务提交回滚，释放资源，这些代码都可以向上抽取，Spring Data JPA就是对原有的JPA规范再进行封装