JPA JPQL/持久化查询语言

本章介绍有关JPQL和它的工作原理与持久性单元。在这一章中，给出的例子遵循相同的包层次结构，和我们在前面的章节中使用一样。

Java持久化查询语言

JPQL代表Java持久化查询语言。它被用来创建针对实体的查询存储在关系数据库中。 JPQL是基于SQL语法的发展。但它不会直接影响到数据库。

JPQL可以检索使用SELECT子句中的数据，可以使用 UPDATE子句做批量UPDATE和DELETE子句。

查询结构

JPQL语法非常类似于SQL语法。SQL的语法是一个优势，因为SQL很简单，被广泛使用。 SQL工作直接针对关系数据库表，记录和字段，而JPQL适用于Java类和实例。

例如，JPQL查询可以检索实体对象，而不是从一个数据库中设置字段结果，作为与SQL。该JPQL查询结构如下。

SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]

JPQL的结构，DELETE和UPDATE查询，如下所示。

DELETE FROM ... [WHERE ...]
 
UPDATE ... SET ... [WHERE ...]

标量和聚合函数

标量函数返回基于输入值所得的数值。集合函数，通过计算输入值返回的结果值。

我们将使用相同的例子员工管理，在前面的章节。在这里将通过使用JPQL的标量和聚合函数的服务类。

让我们假定 jpadb.employee 表包含下述记录。

Eid	Ename	Salary	Deg
1201	Gopal	40000	技术经理
1202	Manisha	40000	接待员
1203	Masthanvali	40000	技术作家
1204	Satish	30000	技术作家
1205	Krishna	30000	技术作家
1206	Kiran	35000	接待员

创建一个在 com.yiibai.eclipselink.service 包命名为 ScalarandAggregateFunctions.java类如下。

package com.yiibai.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class ScalarandAggregateFunctions 
{
   public static void main( String[ ] args ) 
   {
   	EntityManagerFactory emfactory = Persistence.
   			createEntityManagerFactory( "Eclipselink_JPA" );
   	EntityManager entitymanager = emfactory.
   			createEntityManager();
   	//Scalar function
   	Query query = entitymanager.
   	createQuery("Select UPPER(e.ename) from Employee e");
   	List<String> list=query.getResultList();
   	
   	for(String e:list)
   	{
   		System.out.println("Employee NAME :"+e);
   	}
   	//Aggregate function
   	Query query1 = entitymanager.
   			createQuery("Select MAX(e.salary) from Employee e");
   	Double result=(Double) query1.getSingleResult();
   	System.out.println("Max Employee Salary :"+result);
   }
}

编译和执行上面的程序，在Eclipse IDE的控制台面板上会得到以下输出。

Employee NAME :GOPAL
Employee NAME :MANISHA
Employee NAME :MASTHANVALI
Employee NAME :SATISH
Employee NAME :KRISHNA
Employee NAME :KIRAN
Max Employee Salary :40000.0

Between, And, Like 关键词

Between, And, 和Like是JPQL的主要关键字。这些关键字在查询子句后使用。

创建一个名为 BetweenAndLikeFunctions.java 类在 com.yiibai.eclipselink.service包下，如下所示：

package com.yiibai.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.yiibai.eclipselink.entity.Employee;

public class BetweenAndLikeFunctions 
{
   public static void main( String[ ] args ) 
   {
   	EntityManagerFactory emfactory = Persistence.
   		createEntityManagerFactory( "Eclipselink_JPA" );
   	EntityManager entitymanager = emfactory.
   		createEntityManager();
   	//Between
   	Query query = entitymanager.
   		createQuery( "Select e " +
   			"from Employee e " +
   			"where e.salary " +
   			"Between 30000 and 40000" )
   	List<Employee> list=(List<Employee>)query.getResultList( );
   	 
   	for( Employee e:list )
   	{
   		System.out.print("Employee ID :"+e.getEid( ));
   		System.out.println("\t Employee salary :"+e.getSalary( ));
   	}
   	
   	//Like
   	Query query1 = entitymanager.
   		createQuery("Select e " +
   			"from Employee e " +
   			"where e.ename LIKE 'M%'");
   	List<Employee> list1=(List<Employee>)query1.getResultList( );
   	for( Employee e:list1 )
   	{
   		System.out.print("Employee ID :"+e.getEid( ));
   		System.out.println("\t Employee name :"+e.getEname( ));
   	}
   }
}

编译并执行上述程序后，将在Eclipse IDE的控制台面板下面输出以下内容。

Employee ID :1201    Employee salary :40000.0
Employee ID :1202    Employee salary :40000.0
Employee ID :1203    Employee salary :40000.0
Employee ID :1204    Employee salary :30000.0
Employee ID :1205    Employee salary :30000.0
Employee ID :1206    Employee salary :35000.0

Employee ID :1202    Employee name :Manisha
Employee ID :1203    Employee name :Masthanvali

排序

要排序JPQL中的记录，我们使用ORDER BY子句。这一个子句的使用类似于SQL中的用法，但它涉及的实体。下面的示例演示了如何使用ORDER BY子句。

在com.yiibai.eclipselink.service包中创建类 Ordering.java 如下：

package com.yiibai.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.yiibai.eclipselink.entity.Employee;

public class Ordering 
{
   public static void main( String[ ] args ) 
   {
   	EntityManagerFactory emfactory = Persistence.
   		createEntityManagerFactory( "Eclipselink_JPA" );
   	EntityManager entitymanager = emfactory.
   		createEntityManager();
   	//Between
   	Query query = entitymanager.
   		createQuery( "Select e " +
   			"from Employee e " +
   			"ORDER BY e.ename ASC" );
   	List<Employee> list=(List<Employee>)query.getResultList( );
   	 
   	for( Employee e:list )
   	{
   		System.out.print("Employee ID :"+e.getEid( ));
   		System.out.println("\t Employee Name :"+e.getEname( ));
   	}
   }
}

编译和执行上面的程序，在Eclipse IDE的控制台面板会产生下面的输出。

Employee ID :1201    Employee Name :Gopal
Employee ID :1206    Employee Name :Kiran
Employee ID :1205    Employee Name :Krishna
Employee ID :1202    Employee Name :Manisha
Employee ID :1203    Employee Name :Masthanvali
Employee ID :1204    Employee Name :Satish

命名查询

@NamedQuery注解被定义为一个预定义的查询字符串，它是不可改变的查询。相反，动态查询，命名查询可以通过POJO分离JPQL查询字符串提高代码的组织。它也传送的查询参数，而不是动态地嵌入文本到查询字符串，并因此产生更高效的查询。

首先，@NamedQuery注解添加到com.yiibai.eclipselink.entity包中的 Employee实体，类名为Employee.java下，如下所示：

package com.yiibai.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@Table
@NamedQuery(query = "Select e from Employee e where e.eid = :id", 
   name = "find employee by id")
public class Employee 
{
   @Id
   @GeneratedValue(strategy= GenerationType.AUTO) 	
   private int eid;
   private String ename;
   private double salary;
   private String deg;
   public Employee(int eid, String ename, double salary, String deg) 
   {
   	super( );
   	this.eid = eid;
   	this.ename = ename;
   	this.salary = salary;
   	this.deg = deg;
   }
   public Employee( ) 
   {
   	super();
   }
   
   public int getEid( ) 
   {
   	return eid;
   }
   public void setEid(int eid)  
   {
   	this.eid = eid;
   }
   
   public String getEname( ) 
   {
   	return ename;
   }
   public void setEname(String ename) 
   {
   	this.ename = ename;
   }
   
   public double getSalary( ) 
   {
   	return salary;
   }
   public void setSalary(double salary) 
   {
   	this.salary = salary;
   }
   
   public String getDeg( ) 
   {
   	return deg;
   }
   public void setDeg(String deg) 
   {
   	this.deg = deg;
   }
   @Override
   public String toString() {
   	return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
   			+ salary + ", deg=" + deg + "]";
   }
}

创建一个名为com.yiibai.eclipselink.service包下的NamedQueries.java类，如下所示：

package com.yiibai.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.yiibai.eclipselink.entity.Employee;

public class NamedQueries 
{
   public static void main( String[ ] args ) 
   {
   	EntityManagerFactory emfactory = Persistence.
   		createEntityManagerFactory( "Eclipselink_JPA" );
   	EntityManager entitymanager = emfactory.
   		createEntityManager();
   	Query query = entitymanager.createNamedQuery(
   		"find employee by id");
   	query.setParameter("id", 1204);
   	List<Employee> list = query.getResultList( );
   	for( Employee e:list )
   	{
   		System.out.print("Employee ID :"+e.getEid( ));
   		System.out.println("\t Employee Name :"+e.getEname( ));
   	}
   }
}

经过编译和执行上面的程序，在Eclipse IDE的控制台面板上会得到下面的输出。

Employee ID :1204    Employee Name :Satish

加入上述所有类后，包层次结构如下所示：

急切和延迟加载

JPA中最重要的概念是为了使数据库的副本在高速缓冲存储器中。虽然有一个数据库事务，但JPA首先创建一个重复的数据集，只有当它使用实体管理提交，所做的更改影响到数据库中。

从数据库中获取记录有两种方式。

预先抓取

在预先抓取，相关的子对象获取一个特定的记录自动上传。

延迟加载

在延迟装载，涉及的对象不会自动上传，除非你特别要求他们。首先，它检查相关对象和通知可用性。以后，如果调用任何实体的getter方法，那么它获取的所有记录。

延迟装载可能在第一次尝试获取记录。这样一来，在整个记录的副本已经被存储在高速缓冲存储器中。性能方面，延迟装载最好。