JPA(四) 基本查询

最新推荐文章于 2024-07-29 11:02:40 发布
最新推荐文章于 2024-07-29 11:02:40 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： JPA 
package com.it.jpa.test;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;

import org.junit.Test;

import com.it.jpa.domain.Customer;
import com.it.jpa.util.JpaUtil;

public class testJPA {

    /**
     * 
     * 1、保存一个实体
     */
    @Test
    public void testAdd() {
        // 定义对象
        Customer c = new Customer();
        c.setCustName("张三");
        c.setCustLevel("VIP 客户");
        c.setCustSource("网络");
        c.setCustIndustry("IT");
        c.setCustAddress("北京");
        c.setCustPhone("010-84389340");
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            // 开启事务
            tx.begin();
            // 执行操作
            em.persist(c);
            // 提交事务
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    @Test
    /**
     * 2、修改
     */
    public void testMerge() {
        // 定义对象
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            // 开启事务
            tx.begin();
            // 执行操作
            Customer c1 = em.find(Customer.class, 1L);
            c1.setCustName("李四");
            em.clear();// 把 c1 对象从缓存中清除出去
            em.merge(c1);
            // 提交事务
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 3、删除
     */
    @Test
    public void testRemove() {
        // 定义对象
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            // 开启事务
            tx.begin();
            // 执行操作
            Customer c1 = em.find(Customer.class, 6L);
            em.remove(c1);
            // 提交事务
            tx.commit();

        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 4、查询一个： 使用立即加载的策略
     */
    @Test
    public void testGetOne() {
        // 定义对象
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            // 开启事务
            tx.begin();
            // 执行操作
            Customer c1 = em.find(Customer.class, 1L);
            // 提交事务
            tx.commit();
            System.out.println(c1); // 输出查询对象
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 
     * 5、查询所有客户
     */

    @Test
    public void findAll() {
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            tx.begin();
            // 创建 query 对象
            String jpql = "from Customer";
            Query query = em.createQuery(jpql);
            // 查询并得到返回结果
            List list = query.getResultList(); // 得到集合返回类型
            for (Object object : list) {
                System.out.println(object);
            }
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 
     * 6、查询一行一列
     */

    @Test
    public void findCount() {
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();

            tx.begin();
            // 查询全部客户
            // 1.创建 query 对象
            String jpql = "select count(custId) from Customer";
            Query query = em.createQuery(jpql);
            // 2.查询并得到返回结果
            Object count = query.getSingleResult(); // 得到集合返回类型
            System.out.println(count);
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 7:根据 id 查询的两种方式及区别
     * 
     * Description: JPA 的查询一个实体的两种方式
     * 
     * find 和 getReference 区别： 第一个：查询的时机不一样。 find 是立即加载 ，只要一调用方法，马上发起查询。
     * getReference 是延迟加载，什么时候使用什么时候加载。 第二个：返回的结果不一样 find 返回的是实体类类型 getReference
     * 返回的是实体类的代理对象 hibernate 中 get 和 load 方法的区别和 jpa 中的 find 和 getReference 是一样的
     * 其中: get 方法对应 find load 方法对应 getReference
     */
    public class JPAFindOneTest {
        // 查询一个
        // 立即加载
        @Test
        public void testFindOne() {
            EntityManager em = JpaUtil.getEntityManager();
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            Customer c = em.find(Customer.class, 1);
            System.out.println(c);
            tx.commit();
            em.close();
        }

        // 查询一个
        // 懒加载（延迟加载）
        @Test
        public void testFindOne2() {
            EntityManager em = JpaUtil.getEntityManager();
            EntityTransaction tx = em.getTransaction();
            tx.begin();
            Customer c = em.getReference(Customer.class, 1);
            System.out.println(c.toString());
            tx.commit();
            em.close();
        }
    }

    /**
     * 8、条件查询
     */
    @Test
    public void findCondition() {
        EntityManager em = null;

        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            tx.begin();
            // 创建 query 对象
            String jpql = "from Customer where custName like ? ";
            Query query = em.createQuery(jpql);
            // 对占位符赋值，从 1 开始
            query.setParameter(1, "传智播客%");
            // 查询并得到返回结果
            Object object = query.getSingleResult(); // 得到唯一的结果集对象
            System.out.println(object);
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 9、分页查询客户
     * 
     */
    @Test
    public void findPaged() {
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            tx.begin();
            // 创建 query 对象
            String jpql = "from Customer";
            Query query = em.createQuery(jpql);
            // 起始索引

            query.setFirstResult(0);
            // 每页显示条数
            query.setMaxResults(2);
            // 查询并得到返回结果
            List list = query.getResultList(); // 得到集合返回类型
            for (Object object : list) {
                System.out.println(object);
            }
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }

    /**
     * 10、排序查询
     */
    @Test
    public void testOrder() {
        EntityManager em = null;
        EntityTransaction tx = null;
        try {
            // 获取实体管理对象
            em = JpaUtil.getEntityManager();
            // 获取事务对象
            tx = em.getTransaction();
            tx.begin();
            // 创建 query 对象
            String jpql = "from Customer order by custId desc";
            Query query = em.createQuery(jpql);
            // 查询并得到返回结果
            List list = query.getResultList(); // 得到集合返回类型
            for (Object object : list) {
                System.out.println(object);
            }
            tx.commit();
        } catch (Exception e) {
            // 回滚事务
            tx.rollback();
            e.printStackTrace();
        } finally {
            // 释放资源
            em.close();
        }
    }
}
houysx
关注
专栏目录
Spring-data-jpa最全的查询语法总结，直入超神
我是香菜
06-05 1478
spring-data 一统江湖，玩转多种数据源今天这篇文章总结下spring data jpa的查询语法，在开发中能够灵活使用，在开始下面的之前我们定义一个entity，以便后面的部分使用这里定义一个玩家的entity@Data@Entity@ApiModel(description = "玩家信息")@Id@ApiModelProperty(value = "主键")@ApiModelProperty(value = "玩家名字")
jpa 动态查询条件 数组_Spring data jpa 复杂动态查询方式总结
weixin_39716044的博客
12-22 1645
一.Spring data jpa 简介首先JPA是Java持久层API,由Sun公司开发,希望整合ORM技术，实现天下归一.诞生的缘由是为了整合第三方ORM框架，建立一种标准的方式，目前也是在按照这个方向发展，但是还没能完全实现。在ORM框架中，Hibernate是一支很大的部队，使用很广泛，也很方便，能力也很强，同时Hibernate也是和JPA整合的比较良好，我们可以认为JPA是标准，...
JPA查询实例解析,jpa Query查询
02-20
Jpa详细查询实例介绍，教你如何使用JPA，简单，分类实例。
使用jpa实现数据的查找
m0_74067323的博客
10-29 5520
一、什么是jpa JPA本身不是一个工具或框架; 相反，它定义了一组可以由任何工具或框架实现的概念。虽然JPA的对象关系映射（ORM）模型最初基于Hibernate，但它已经发展了。简单来说，JPA只是一个简化对象关系映射来管理Java应用程序中的关系数据的规范。 它提供了一个平台，可以直接使用对象而不是使用SQL语句。 二、什么是Hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，是一个全自动的ORM框架，它可以自动生成SQL语句，自动执
SpringDataJPA（三）：多表操作，复杂查询
最新发布
you4580的专栏
07-29 1719
在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。多对多关系中：用中间表（第三章表）来描述这种关系，中间表中至少应该由两个字段组成，这两个字段作为外键指向两张表的主键，且这两个字段又组成了联合主键。在一对多关系中，我们习惯把一的一方称之为主表，把多的一方称之为从表。
jpa查询的使用
qq_44589685的博客
10-29 501
jap复杂查询的使用
【Spring Boot】Java 持久层 API（三）：JPA 的查询方式
书山有路，学海无涯。记录成长，追逐梦想
06-30 1597
QueryDSL 也是基于各种 ORM 之上的一个通用查询框架，它与 Spring Data JPA 是同级别的。使用 QueryDSL 的 API 可以写出 SQL 语句(Java 代码，非真正标准 SQL），不需要懂 SQL 语句。它能够构建类型安全的查询。这与 JPA 使用原生查询时有很大的不同，可以不必再对 Object[] 进行操作。它还可以和 JPA 联合使用。
Spring Data Jpa基础以及基本查询
Zystem
08-30 220
1、简介 Spring Data Jpa是spring基于orm、Jpa规范的基础上的封装的一套JPA应用框架，可使开发者用及其简单的代码即可实现对数据库的操作，提高开发效率。 2、搭建环境 导入坐标 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" ...
Spring Data Jpa的四种查询方式详解
08-25
Spring Data JPA 的四种查询方式详解 Spring Data JPA 是一种基于 Java Persistence API（JPA）的数据访问技术，它提供了多种查询方式来满足不同的业务需求。下面将详细介绍 Spring Data JPA 的四种查询方式。 一...
JPA的基本查询与条件查询
# 第一章：JPA简介与基本概念 ## 1.1 JPA概述 JPA（Java Persistence API）是Java EE规范中的一部分，用于简化Java应用程序与数据库之间的数据持久化操作。...JPA的基本查询是指通过预定义的方法或者查询注解来实
Spring Data Jpa的四种查询方式
song的博客
11-24 751
一、调用接口的方式 1.基本介绍 通过调用接口里的方法查询，需要我们自定义的接口继承Spring Data Jpa规定的接口 public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> 使用这几种方法的前提是你定义的实体类必须标注上相应的注解 @...
JPA(一) 常用查询方法
得已
10-18 843
以这张表为例： +-------------+--------------+------+-----+-------------------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------------+-------------...
jpa 查询详解
热门推荐
morris
01-15 1万+
1.1.  一个简单的查询示例 PersonDaoTest.java package com.morris.test;   import static org.junit.Assert.*;   import javax.persistence.EntityManager; import javax.persistence.EntityManagerF
jpa查询方式
jyblims的博客
04-10 253
sql查询 @Query(value = "select * from base_preset where base_sensor_id = ?1 and preset_no in (?2)" ,nativeQuery = true) List<BasePreset> findBySensorIdAndPresetNo(Long sensorId, List<String> presetNos); 多条件无sql查询 @Autowired private BaseDept.
JPA查询方式：方法命名规则、@Query查询、结果集类型转化器
qq_43975645的博客
07-20 1331
注意：在这里的SQL操作都是基于对象，使用的为对象属性，非数据库字段。在持久层接口中，可以直接根据方法的名字进行条件查询。，而非复杂的、定制的SQL的处理，表中的字段，所以最终封装到。保留了写SQL的方法，
jpa 查询 列表_终极JPA查询和技巧列表–第3部分
最佳 Java 编程
06-03 411
jpa 查询 列表 在阅读第三部分之前，请记住本系列的第一部分和第二部分 JPA：通过查询创建对象 JPA允许我们使用所需的值在查询内创建对象： package com.model; public class PersonDogAmountReport { private int dogAmount; private Person person; public PersonD...
Spring Data JPA Criteria查询、部分字段查询
JingAi_jia917的博客
04-28 1974
本篇分享了Spring Data JPA的Criteria查询、部分字段查询实现，以及JPA元模型的自动生成的设置
jpa查询所有的记录
朱智文的专栏
01-27 5704
public interface JpaSpecificationExecutor { /** * Returns a single entity matching the given {@link Specification}. * * @param spec * @return */ T findOne(Specificati
JPA的复杂查询包括一对多多对一和多对多的查询
m0_68856746的博客
01-07 3428
它们之间是多对多的关系，即一个学生可以选择多门课程，一门课程也可以有多个学生选择。我们想要查询选择了某门课程的所有学生，并且能够添加新的学生和课程。，它们之间是多对多的关系，即一个产品可以属于多个分类，一个分类也可以包含多个产品。现在，我们可以执行复杂查询，获取选择了某门课程的所有学生，并且能够添加新的学生和课程。方法执行了一个自定义查询，并只选择了客户的名称和邮箱属性。方法执行了一个复杂查询，获取选择了某门课程的所有学生。现在，我们可以执行多对多关联查询，并通过价格条件进行过滤。
Java私塾：Spring Data JPA深度教程
课程涵盖从入门到高级的各个层面，包括JpaRepository的基本功能、查询机制、客户化扩展以及Specifications查询。" Spring Data JPA是Spring框架的一个模块，它旨在简化Java持久层的开发，特别是针对Java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值