原生的JPA-JPQL

• JPQL全称Java Persistence Query Language
  
• 基于首次在EJB2.0中引入的EJB查询语言(EJBQL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。
  
• 其特性与原生SQL语句雷同，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。
  

getResultList getSingleResult executeUpdate
setHint(String,Object)uery
setParameter(Parameter&Ts,)Query
setParameter(Parameter<Calendar>,Calendar,Tempor setParameter(Parameter<Date>,Date,TemporalType)
setParameter(String,Object)uery
setParameter(String,Calendar,TemporalType)uery setParameter(String,Date,TemporalType)uery
setParameter(int,Object)uery
setParameter(int,Calendar,TemporalType)uery setParameter(int Date TemporalTypel）
增

1. @Test
2. public void testAdd() {
3.   // 定义对象
4.   Customer c = new Customer();
5.   c.setCustLevel("VIP客户");
6.   c.setCustSource("网络");
7.   EntityManager em = null;
8.   EntityTransaction tx = null;
9.   try {
10.     // 获取实体管理对象
11.     em = JPAUtil.getEntityManager();
12.     // 获取事务对象
13.     tx = em.getTransaction();
14.     // 开启事务
15.     tx.begin();
16.     // 执行操作
17.     em.persist(c);
18.     // 提交事务
19.     tx.commit();
20.   } catch (Exception e) {
21.     // 回滚事务
22.     tx.rollback();
23.     e.printStackTrace();
24.   } finally {
25.     // 释放资源
26.     em.close();
27.   }
28. }

复制代码

修

• 如果数据库中没有这个对象,直接发出一条insert语句
  
• 如果写了一个不存在的id.它会先查询,然后在insert
  

1. public void testMerge(){  
2.   //定义对象
3.   EntityManager em=null;  
4.   EntityTransaction tx=null;  
5.   try{  
6.     //获取实体管理对象
7.     em=JPAUtil.getEntityManager();
8.     //获取事务对象
9.     tx=em.getTransaction();
10.     //开启事务
11.     tx.begin();
12.     //执行操作
13.     Customer c1 = em.find(Customer.class, 6L);
14.     em.clear();//把c1对象从缓存中清除出去
15.     em.merge(c1);
16.     //提交事务
17.     tx.commit();
18.   }catch(Exception e){
19.     //回滚事务
20.     tx.rollback();
21.     e.printStackTrace();  
22.   }finally{  
23.     //释放资源
24.     em.close();  
25.   }   

复制代码

删

1. public void testRemove() {
2.   // 定义对象
3.   EntityManager em = null;
4.   EntityTransaction tx = null;
5.   try {
6.     // 获取实体管理对象
7.     em = JPAUtil.getEntityManager();
8.     // 获取事务对象
9.     tx = em.getTransaction();
10.     // 开启事务
11.     tx.begin();
12.     // 执行操作
13.     Customer c1 = em.find(Customer.class, 6L);
14.     em.remove(c1);
15.     // 提交事务
16.     tx.commit();
17.   } catch (Exception e) {
18.     // 回滚事务
19.     tx.rollback();
20.     e.printStackTrace();
21.   } finally {
22.     // 释放资源
23.     em.close();
24.   }
25. }

复制代码

查

立即加载的策略

1. public void testGetOne() {
2.   // 定义对象
3.   EntityManager em = null;
4.   EntityTransaction tx = null;
5.   try {
6.     // 获取实体管理对象
7.     em = JPAUtil.getEntityManager();
8.     // 获取事务对象
9.     tx = em.getTransaction();
10.     // 开启事务
11.     tx.begin();
12.     // 执行操作
13.     Customer c1 = em.find(Customer.class, 1L);
14.     // 提交事务
15.     tx.commit();
16.     System.out.println(c1); // 输出查询对象
17.   } catch (Exception e) {
18.     // 回滚事务
19.     tx.rollback();
20.     e.printStackTrace();
21.   } finally {
22.     // 释放资源
23.     em.close();
24.   }
25. }

复制代码

 查询实体的缓存问题

1. public void testGetOne() {
2.   // 定义对象
3.   EntityManager em = null;
4.   EntityTransaction tx = null;
5.   try {
6.     // 获取实体管理对象
7.     em = JPAUtil.getEntityManager();
8.     // 获取事务对象
9.     tx = em.getTransaction();
10.     // 开启事务
11.     tx.begin();
12.     // 执行操作
13.     Customer c1 = em.find(Customer.class, 1L);
14.     Customer c2 = em.find(Customer.class, 1L);
15.     System.out.println(c1 == c2);// 输出结果是true，EntityManager也有缓存
16.     // 提交事务
17.     tx.commit();
18.     System.out.println(c1);
19.   } catch (Exception e) {
20.     // 回滚事务
21.     tx.rollback();
22.     e.printStackTrace();
23.   } finally {
24.     // 释放资源
25.     em.close();
26.   }
27. }

复制代码

延迟加载策略

1. public void testLoadOne() {
2.   // 定义对象
3.   EntityManager em = null;
4.   EntityTransaction tx = null;
5.   try {
6.     // 获取实体管理对象
7.     em = JPAUtil.getEntityManager();
8.     // 获取事务对象
9.     tx = em.getTransaction();
10.     // 开启事务
11.     tx.begin();
12.     // 执行操作
13.     Customer c1 = em.getReference(Customer.class, 1L);
14.     // 提交事务
15.     tx.commit();
16.     System.out.println(c1);
17.   } catch (Exception e) {
18.     // 回滚事务
19.     tx.rollback();
20.     e.printStackTrace();
21.   } finally {
22.     // 释放资源
23.     em.close();
24.   }
25. }

复制代码

createNativeQuery

1. @SpringBootTest
2. public class HQLTest {
4.   @Autowired
5.   private EntityManager entityManager;
7.   @Test
8.   public void test() {
9.     Query selectAccountFromTsUser = entityManager.createNativeQuery("select ACCOUNT from ts_user");
10.     List resultList = selectAccountFromTsUser.getResultList();
11.   }
12. }

复制代码

 @NamedQuery

import org.hibernate.annotations.NamedQuery;
查询示例

查询全部

1. String jpql = "from Customer";
2. Query query = em.createQuery(jpql);
3. List list = query.getResultList();

复制代码

分页查询

1. //创建query对象
2. String jpql = "from Customer";
3. Query query = em.createQuery(jpql);
4. //起始索引
5. query.setFirstResult(0);
6. //每页显示条数
7. query.setMaxResults(2);
8. //查询并得到返回结果
9. List list = query.getResultList(); //得到集合返回类型

复制代码

条件查询

1. String jpql = "from Customer where custName like ? ";
2. Query query = em.createQuery(jpql);
3. query.setParameter(1, "xxx%");
4. Object object = query.getSingleResult();

复制代码

统计

1. String jpql = "select count(custId) from Customer";
2. Query query = em.createQuery(jpql);
3. // 2.查询并得到返回结果
4. Object count = query.getSingleResult(); // 得到集合返回类型

复制代码

多表

  

1. @Entity
2. @Table(name = "CUSTOMER")
3. public class Customer {
4.    @Id
5.    @GeneratedValue(strategy = GenerationType.IDENTITY)
6.    private Long id;
7.    
8.    private String name;
9.    
10.    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
11.    private List<Order> orders;
12.    
13.    // Getters and setters
14. }
15. ​
16. @Entity
17. @Table(name = "ORDER")
18. public class Order {
19.    @Id
20.    @GeneratedValue(strategy = GenerationType.IDENTITY)
21.    private Long id;
22.    
23.    @ManyToOne(fetch = FetchType.LAZY)
24.    @JoinColumn(name = "CUSTOMER_ID")
25.    private Customer customer;
26.    
27.    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
28.    private List<OrderItem> items;
29.    
30.    // Getters and setters
31. }
32. ​
33. @Entity
34. @Table(name = "ORDER_ITEM")
35. public class OrderItem {
36.    @Id
37.    @GeneratedValue(strategy = GenerationType.IDENTITY)
38.    private Long id;
39.    
40.    @ManyToOne(fetch = FetchType.LAZY)
41.    @JoinColumn(name = "ORDER_ID")
42.    private Order order;
43.    
44.    private String productName;
45.    private int quantity;
46.    
47.    // Getters and setters
48. }

复制代码

使用JOIN FETCH加载关联数据
  如果你想在一次查询中加载Customer及其所有的Order和OrderItem，可以使用JOIN FETCH：

1. public List<Customer> loadCustomersWithOrdersAndItems() {
2.    EntityManager em = getEntityManager();
3.    
4.    TypedQuery<Customer> query = em.createQuery(
5.        "SELECT c FROM Customer c "
6.        + "JOIN FETCH c.orders o "
7.        + "JOIN FETCH o.items i",
8.        Customer.class
9.    );
10.    
11.    return query.getResultList();
12. }

复制代码

在这个查询中，JOIN FETCH c.orders o将立即加载每个Customer的所有Order，而JOIN FETCH o.items i将立即加载每个Order的所有OrderItem。如许，你就可以在查询结果中直接访问这些关联的数据，而不必要担心懒加载的问题。
注意事项
使用JOIN FETCH会增加查询的复杂度和潜在的性能开销，由于它可能必要实行更复杂的SQL查询。在数据量大时，应审慎使用。
如果只是必要统计或聚合数据，而不是加载所有关联数据，可能不必要使用JOIN FETCH，而是思量使用更简单的查询或SQL聚合函数。
通过使用JOIN FETCH，你可以在JPQL查询中控制何时加载关联的数据，这对于必要立即获取完整数据集的场景非常有用。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。