- 浏览: 330922 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
di1984HIT:
谢谢,写的不错。
使用hector操作Cassandra -
mr_von:
非常感谢!
paoding的分词使用 -
howgoo:
http://www.dhtmlx.com/docs/prod ...
dhtmlxGrid分页与排序 -
青春的、脚步:
谢谢
spring-data-mongodb的MongoTemplate 使用小例子 -
青春的、脚步:
xiaofancn 写道青春的、脚步 写道这个能查询都个值在某 ...
spring-data-mongodb的MongoTemplate 使用小例子
EJB3.0 JPQL
JPQL就是一种查询语言,具有与
SQL
相类似的特征,
JPQL
是完全面向对象的,具备继承、多态和关联等特性,和hibernate
HQL很相似。
查询语句的参数
JPQL
语句支持两种方式的参数定义方式
:
命名参数和位置参数
。
。在同一个查询语句中只允许使用一种参数定义方式。
命令参数的格式为:“
: +
参数名”
例:
Query query = em.createQuery("select p from Person p where
p.personid=:Id
");
query.setParameter("Id",new
Integer(1));
位置参数的格式为“
?+
位置编号”
例:
Query query = em.createQuery("select p from Person p where
p.personid=?1
");
query.setParameter(1,new
Integer(1));
如果你需要传递
java.util.Date
或
java.util.Calendar
参数进一个参数查询
,你需要使用一个特殊的
setParameter()
方法
,相关的
setParameter
方法定义如下:
public interface
Query
{
//
命名参数查询时使用,参数类型为
java.util.Date
Query setParameter(String name,
java.util.Date value, TemporalType temporalType);
//
命名参数查询时使用,参数类型为
java.util.Calendar
Query setParameter(String name,
Calendar value, TemporalType temporalType);
//
位置参数查询时使用,参数类型为
java.util.Date
Query setParameter(int position,
Date value, TemporalType temporalType);
//
位置参数查询时使用,参数类型为
java.util.Calendar
Query setParameter(int position,
Calendar value, TemporalType temporalType);
}
因为一个
Date
或
Calendar
对象能够描述一个真实的日期、时间或时间戳
.
所以我们需要告诉
Query
对象怎么使用这些参数,我们把
javax.persistence.TemporalType
作为参数传递进
setParameter
方法,告诉查询接口在转换
java.util.Date
或
java.util.Calendar
参数到本地
SQL
时使用什么数据库类型
。
下面通过实例来学习JPQL语句,例子的entity
Bean
有
Person,
Order, OrderItem
,
他们之间的关系是:一个
Person
有多个
Order,
一个
Order
有多个
OrderItem
。
JPQL语句的大小写敏感性:除了
Java
类和属性名称外,查询都是大小写不敏感的
。所以,
SeLeCT
和
sELEct
以及
SELECT
相同的,但是
com.foshanshop.ejb3.bean.Person
和
com.foshanshop.ejb3.bean.PERSon
是不同的,
person.name
和
person.NAME
也是不同的。
命名查询
可以在实体
bean
上通过
@NamedQuery
or
@NamedQueries
预先定义一个或多个查询语句,减少每次因书写错误而引起的
BUG
。通常把经常使用的查询语句定义成命名查询
。
定义单个命名查询:
@NamedQuery
(name=
"getPerson"
, query=
"FROM Person WHERE
personid=?1"
)
@Entity
public
class
Person
implements
Serializable{
如果要定义多个命名查询,应在@javax.persistence.NamedQueries里定义
@NamedQuery
:
@NamedQueries
({
@NamedQuery
(name=
"getPerson"
, query=
"FROM Person WHERE
personid=?1"
),
@NamedQuery
(name=
"getPersonList"
,
query=
"FROM
Person WHERE age>?1"
)
})
@Entity
public
class
Person
implements
Serializable{
当命名查询定义好了之后,我们就可以通过名称执行其查询。代码如下:
Query query
=
em
.
createNamedQuery("getPerson")
;
query.setParameter(1,
1);
排序
(order by)
"ASC"
和
"DESC"
分别为升序和降序,
JPQL
中默认为
asc
升序
例:
//
先按年龄降序排序,然后按出生日期升序排序
Query query =
em.createQuery("select p from Person p order by p.age desc, p.birthday
asc
");
查询部分属性
通常来说,都是针对
Entity
类的查询,返回的也是被查询的
Entity
类的实体。J
P
QL
也允许我们直接查询返回我们需要的属性,而不是返回整个
Entity
。在一些
Entity
中属性特别多的情况,这样的查询可以提高性能
例:
//
只
查询我们感兴趣的属性
(
列
)
Query
query=em.createQuery("select p.personid, p.name from Person p order
by p.personid desc ");
//
集合中的元素不再是
Person,
而是一个
Object[]
对象数组
List result =
query.getResultList();
if
(result!=null){
Iterator iterator =
result.iterator();
while( iterator.hasNext()
){
Object[] row = ( Object[])
iterator.next();
int personid =
Integer.parseInt(row[0].toString());
String PersonName =
row[1].toString();
。。。。
}
}
查询中使用构造器
(Constructor)
JPQL
支持将查询的属性结果直接作为一个
java
class
的构造器参数,并产生实体作为结果返回
。例如上面的例子只获取person
entity bean的name and
personid属性,我们不希望返回的集合的元素是object[],而希望用一个类来包装它。就要用到使用构造器
。
例:
public
class
SimplePerson {
private Integer
personid;
private
String
name
;
。。。。
public
SimplePerson() {
}
public
SimplePerson(Integer personid,
String name) {
this
.
name
= name;
this
. personid = personid;
}
}
查询代码为:
//
我们把需要的两个属性作为
SimplePerson
的构造器参数,并使用
new
函数。
Query query =
em.createQuery("
select new
com.foshanshop.ejb3.bean.SimplePerson(p. personid, p.name) from
Person p order by p.personid desc
");
//
集合中的元素是
SimplePerson
对象
List result =
query.getResultList();
if
(result!=null){
Iterator iterator =
result.iterator();
while( iterator.hasNext()
){
SimplePerson simpleperson =
(SimplePerson) iterator.next();
。。。。
}
}
聚合查询
(Aggregation)
JPQL
支持的聚合函数
包括:
1. AVG()
2. SUM()
3. COUNT()
,返回类型为
Long
,注意
count(*)
语法在
hibernate
中可用,但在
toplink
其它产品中并不可用
4. MAX()
5. MIN()
例:
//
获取最大年龄
Query query =
em.createQuery("select
max(p.age)
from Person p");
Object result
=
query.getSingleResult();
String maxAge
=
result.toString();
//
获取平均年龄
query =
em.createQuery("select
avg(p.age)
from Person p");
//
获取最小年龄
query =
em.createQuery("select
min(p.age)
from Person p");
//
获取总人数
query =
em.createQuery("select
count(p)
from Person p");
//
获取年龄总和
query =
em.createQuery("select
sum(p.age)
from Person p");
如果聚合函数不是
select...from
的唯一一个返回列,需要使用
"GROUP BY"
语句
。
"GROUP
BY"
应该包含
select
语句中除了聚合函数外的所有属性。
例:
//
返回男女生各自的总人数
Query query =
em.createQuery("
select p.sex, count(p) from Person
p group by p.sex
");
//
集合中的元素不再是
Person,
而是一个
Object[]
对象数组
List result
=
query.getResultList();
如果还需要加上查询条件,需要使用
"HAVING"
条件语句而不是
"WHERE"
语句
例:
//
返回人数超过
1
人的性别
Query query =
em.createQuery("select p.sex, count(p) from Person p group by p.sex
having count(*)
>?1");
//
设置查询中的参数
query.setParameter(1, new
Long(1));
//
集合中的元素不再是
Person,
而是一个
Object[]
对象数组
List result =
query.getResultList();
关联
(join)
JPQL
仍然支持和
SQL
中类似的关联语法:
left out join/left
join
inner
join
left join
fetch/inner join fetch
left out
join/left join
等,都是允许符合条件的右边表达式中的
Entiies
为空(
需要显式使用
left join/left outer join
的情况会比较少。
)
例:
//
获取
26
岁人的订单
,
不管
Order
中是否有
OrderItem
select o from Order o
left join o.orderItems
where
o.ower.age=26 order by o.orderid
inner
join
要求右边的表达式必须返回
Entities
。
例:
//
获取
26
岁人的订单
,Order
中必须要有
OrderItem
select o from Order o
inner join o.orderItems
where
o.ower.age=26 order by o.orderid
!!重要知识点
:
在默认的查询中,
Entity
中的集合属性默认不会被关联,集合属性默认是延迟加载
(
lazy-load )
。那么,
left fetch/left out fetch/inner join
fetch
提供了一种灵活的查询加载方式来提高查询的性能。
例:
private String
QueryInnerJoinLazyLoad(){
//
默认不关联集合属性变量
(orderItems)
对应的表
Query query =
em.createQuery("select o from Order o
inner join
o.orderItems where
o.ower.age=26 order by o.orderid");
List result =
query.getResultList();
if (result!=null
&&
result.size()>0){
//
这时获得
Order
实体中
orderItems(
集合属性变量
)
为空
Order order = (Order)
result.get(0);
//
当需要时,
EJB3
Runtime
才会执行一条
SQL
语句来加载属于当前
Order
的
//OrderItems
Set<OrderItem>
list =
order.getOrderItems
();
Iterator<OrderItem>
iterator = list.iterator();
if
(iterator.hasNext()){
OrderItem orderItem
=iterator.next();
System.out.println
("
订购产品名:
"+
orderItem.getProductname());
}
}
上面代码在执行
"select o from Order o inner join
o.orderItems where o.ower.age=26 order by
o.orderid"
时编译成的
SQL
如下(
他不包含集合属性变量
(orderItems)
对应表的字段
)
:
select order0_.orderid as
orderid6_, order0_.amount as amount6_, order0_.person_id
as
person4_6_, order0_.createdate
as createdate6_ from Orders order0_ inner join
OrderItems
orderitems1_ on
order0_.orderid=orderitems1_.order_id, Person person2_
where
order0_.person_id=person2_.personid and
person2_.age=26 order by order0_.orderid
上面代码当执行到
Set<OrderItem>
list = order.getOrderItems();
时才会执行一条
SQL
语句来加载
属于当前
Order
的
OrderItems
,编译成的
SQL
如下
:
select orderitems0_.order_id
as order4_1_, orderitems0_.id as id1_, orderitems0_.id as
id7_0_,
orderitems0_.order_id as
order4_7_0_, orderitems0_.productname as
productn2_7_0_,
orderitems0_.price as
price7_0_ from OrderItems orderitems0_ where
orderitems0_.order_id=?
order by orderitems0_.id
ASC
这样的查询性能上有不足的地方
。为了查询
N
个
Order
,我们需要一条
SQL
语句获得所有的
Order
的原始对象属性,但需要另外
N
条语句获得每个
Order
的
orderItems
集合属性。为了避免
N+1
的性能问题,我们可以利用
join
fetch
一次过用一条
SQL
语句把
Order
的所有信息查询出来
例子
//
获取
26
岁人的订单
,Order
中必须要有
OrderItem
Query query =
em.createQuery("select o from Order o
inner join fetch
o.orderItems
where
o.ower.age=26
order by o.orderid");
上面这句HPQL编译成以下的
SQL
:
select order0_.orderid as
orderid18_0_, orderitems1_.id as id19_1_, order0_.amount
as
amount18_0_,order0_.person_id
as person4_18_0_, order0_.createdate as
createdate18_0_,
orderitems1_.order_id
as order4_19_1_, orderitems1_.productname
as
productn2_19_1_,
orderitems1_.price
as price19_1_, orderitems1_.order_id
as order4_0__,
orderitems1_.id
as
id0__
from Orders order0_ inner join
OrderItems orderitems1_ on
order0_.orderid=orderitems1_.order_id, Person
person2_ where
order0_.person_id=person2_.personid and
person2_.age=26 order by order0_.orderid,
orderitems1_.id
ASC
上面由于使用了
fetch,
这个查询只会产生一条
SQL
语句,比原来需要
N+1
条
SQL
语句在性能上有了极大的提升
排除相同的记录
DISTINCT
使用关联查询,我们很经常得到重复的对象,如下面语句:
"
select o from Order o inner join
fetch o.orderItems order by o.orderid
"
当有
N
个
orderItem
时就会产生
N
个
Order,
而有些
Order
对象往往是相同的,这时我们需要使用
DISTINCT
关键字来排除掉相同的对象
。
例:
select
DISTINCT
o from Order o inner join fetch
o.orderItems order by o.orderid
比较
Entity
在查询中使用参数查询时
,参数类型除了
String,
原始数据类型
(
int, double
等
)
和它们的对象类型
( Integer, Double
等
),
也可以是
Entity
的实例
。
例:
//
查询某人的所有订单
Query query =
em.createQuery("select o from Order o where
o.ower
=?1
order by
o.orderid");
Person person =
new Person();
person.setPersonid(new
Integer(1));
//
设置查询中的参数
query.setParameter(1,person);
批量更新
(Batch Update)
HPQL支持批量更新
例:
//
把所有订单的金额加
10
Query query =
em.createQuery("
update Order as o set
o.amount=o.amount+10
");
//update
的记录数
int result =
query.
executeUpdate
();
批量删除
(Batch Remove)
例:
//
把金额小于100的订单删除,先删除订单子项,再删除订单
Query query
=
em
.createQuery(
"delete from OrderItem item where
item.order in(from Order as o where
o.amount<100)"
);
query.
executeUpdate();
query =
em
.createQuery(
"delete from Order as o where
o.amount<100"
);
query.executeUpdate();
//delete
的记录数
使用操作符
NOT
//
查询除了指定人之外的所有订单
Query query =
em.createQuery("select o from Order o where
not(o.ower
=?1)
order by
o.orderid");
Person person =
new Person();
person.setPersonid(new
Integer(2));
//
设置查询中的参数
query.setParameter(1,person);
使用操作符
BETWEEN
select o from Order as o where
o.amount between 300 and
1000
使用操作符
IN
//
查找年龄为
26,21
的
Person
select p from Person as p
where p.age in(26,21)
使用操作符
LIKE
//
查找以字符串
"li"
开头的
Person
select p from Person as p
where p.name like
'li%'
使用操作符
IS NULL
//
查询含有购买者的所有
Order
select o from Order as o where
o.ower is [not] null
使用操作符
IS EMPTY
IS
EMPTY
是针对集合属性
(Collection)
的操作符
。可以和
NOT
一起使用
。
注:低版权的
Mysql
不支持
IS
EMPTY
//
查询含有订单项的所有
Order
select o from Order as o where
o.orderItems is [not]
empty
使用操作符
EXISTS
[NOT]EXISTS
需要和子查询配合使用
。注:低版权的
Mysql
不支持
EXISTS
//
如果存在订单号为
1
的订单,就获取所有
OrderItem
select oi from OrderItem as oi
where exists
(select o from Order o where o.orderid=1)
//
如果不存在订单号为
10
的订单,就获取
id
为
1
的
OrderItem
select oi from OrderItem as oi
where oi.id=1 and not
exists
(select o from Order o where
o.orderid=10)
字符串函数
JPQL
定义了内置函数方便使用。这些函数的使用方法和
SQL
中相应的函数方法类似。包括:
1. CONCAT
字符串拼接
2. SUBSTRING
字符串截取
3. TRIM
去掉空格
4. LOWER
转换成小写
5. UPPER
装换成大写
6. LENGTH
字符串长度
7. LOCATE
字符串定位
例:
//
查询所有人员,并在姓名后面加上字符串
"_foshan"
select p.personid,
concat(p.name, '_foshan')
from
Person as p
//
查询所有人员
,
只取姓名的前三个字符
select p.personid,
substring
(p.name,1,3) from Person
as p
计算函数
HPQL
定义的计算函数包括:
ABS
绝对值
SQRT
平方根
MOD
取余数
SIZE
取集合的数量
例:
//
查询所有
Order
的订单号及其订单项的数量
select o.orderid, size
(o.orderItems) from Order as o group by
o.orderid
//
查询所有
Order
的订单号及其总金额
/10
的余数
select o.orderid, mod
(o.amount, 10) from Order as o
子查询
子查询可以用于
WHERE
和
HAVING
条件语句中
例:
//
查询年龄为
26
岁的购买者的所有
Order
select o from
Order as o where o.ower in(select p from Person as p where p.age
=26)
结果集分页
有些时候当执行一个查询会返回成千上万条记录,事实上我们只需要显示一部分数据。这时我们需要对结果集进行分页
,
QueryAPI
有两个接口方法可以解决这个问题:
setMaxResults(
)
和
setFirstResult(
)
。
setMaxResults
方法设置获取多少条记录
setFirstResult
方法设置从结果集中的那个索引开始获取
(假如返回的记录有
3
条,容器会自动为记录编上索引,索引从
0
开始,依次为
0
,
1
,
2
)
例:
public
List
getPersonList(
int
max,
int
whichpage) {
try
{
int
index = (whichpage-1) *
max;
Query query =
em
.createQuery(
"from Person p order by personid
asc"
);
List list =
query.
setMaxResults(max)
.
setFirstResult(index)
.
getResultList();
em
.clear();
//
分离内存中受EntityManager管理的实体bean,让VM进行垃圾回收
return
list;
}
catch
(Exception e) {
e.printStackTrace();
return null
;
}
}
文章出处 http://blog.sina.com.cn/s/blog_594196850100nmao.html
发表评论
-
spring cloud gateway 全局过滤器。
2019-03-17 23:11 527spring cloud gateway 网关 ... -
elasticsearch 5.4搜索
2017-05-19 08:37 148@Test public void t ... -
netty简单的操作memcached
2017-04-19 18:59 976pom文件 <dependency> ... -
juc系列-Executor框架
2017-03-20 13:34 699转自 juc系列-Executor框架 什 ... -
ReentrantLock 类
2017-03-19 21:11 11.1 什么是reentrantlock java.u ... -
juc之CountDownLatch、CyclicBarrier和Semaphore例子
2017-03-19 17:23 833import java.util.concurren ... -
netty客户端与服务端例子
2017-03-12 20:07 2799package com.snailteam.nett ... -
freemaker集成spring
2017-02-26 19:00 567<bean id="freeMark ... -
spring集成Hessian插件配置改成自动注入。
2017-02-10 15:39 834原来的配置 <bean name="/ ... -
web开发模版
2017-02-09 14:42 0# Rules reminder: # DEBUG &l ... -
Java多线程
2017-02-04 14:39 515线程状态图 新建状态(New): ... -
hash冲突解决
2017-01-23 18:30 4531、开放地址法有一个公式: m是hash表长度,di ... -
mybatis +spring 分库
2015-04-30 17:56 353<context:component-scan b ... -
Java并发任务处理例子
2014-02-12 16:06 1125public void init() { su ... -
JAVA动态代理模式
2012-10-03 01:01 1183这是我要实现的效果 public static ... -
paoding的分词使用
2012-06-13 21:30 4865paoding下载 http://code.googl ... -
使用spring-hadoop操作hadoop
2012-05-20 02:12 32参考文章 http://blog.springsource. ... -
solr3.5集成paoding和位置搜索及对solrj的使用。
2012-04-28 02:12 1978http://xiaofancn.iteye.com/blog ... -
日期处理DateUtils
2012-03-24 09:47 4811import java.text.SimpleDateF ... -
Cassandra的数据分布情况测试
2012-03-16 15:09 20331、规划种子节点ip和Token值的对应 4个种子 ...
相关推荐
Java Persistence Query Language(JPQL)是EJB 3.0中的一种面向对象的查询语言,类似于SQL,但操作的是对象而不是数据库记录。通过JPQL,开发者可以方便地进行复杂的数据查询,如`SELECT e FROM Employee e WHERE ...
《精通EJB3.0》是一本深入探讨企业级JavaBeans(EJB)3.0技术的专业书籍,由Rima Patel、Sriganesh、Gerald Brose和Micah Silverman共同编写,由Wiley Publishing出版。该书为读者提供了全面且深入的EJB3.0知识体系...
压缩包中的文件如“ejb-3_0-fr-spec-persistence.pdf”、“ejb-3_0-fr-spec-simplified.pdf”和“ejb-3_0-fr-spec-ejbcore.pdf”可能是EJB 3.0官方规范的文档,分别详细阐述了持久化、简化的规范和核心EJB 3.0的内容...
在"**EJB3.0+JBOSS+MyEclipse初体验(完整代码和过程).txt**"文件中,你将找到一个完整的示例,涵盖了上述所有步骤,包括具体的代码片段和执行过程,这对于初学者来说是一个很好的起点,可以快速理解并实践EJB 3.0在...
在"ejb3.0入门经典教程-source"这个压缩包中,包含了书中各个章节的示例代码,覆盖了EJB 3.0的各个方面,例如实体Bean的创建、会话Bean的使用、事务管理、安全性设置以及JPA的持久化操作等。这些源码对于初学者来说...
"李腾飞EJB3.0 源码 源代码"可能包含的是李腾飞教授或团队关于EJB 3.0技术的实践示例或教学资源。通过分析这些源码,开发者可以深入理解EJB 3.0的实现细节,例如如何使用注解定义Bean、如何处理持久化、如何进行依赖...
**企业级JavaBeans(EJB)3.0详解** 企业级JavaBeans(Enterprise JavaBeans,简称EJB)是Java平台上用于构建分布式企业级应用的重要组件模型。EJB 3.0是EJB规范的一个重大革新,它极大地简化了EJB的开发过程,引入...
4. **查询语言(JPA & JPQL)**:EJB 3.0引入了Java Persistence API(JPA),其中包含Java Persistence Query Language(JPQL),这是一种面向对象的查询语言,用于从数据库检索和操作实体Bean。 5. **依赖注入...
**EJB3.0实例教程**是一份详细指导开发者如何使用Enterprise JavaBeans 3.0(EJB3.0)技术进行企业级应用开发的电子文档。EJB3.0是Java EE(Java Platform, Enterprise Edition)规范的一部分,旨在简化企业级组件的...
8. **查询语言(JPQL)**:Java Persistence Query Language(JPQL)是EJB3.0中的一个强大工具,用于在对象级别编写查询,类似于SQL,但面向对象模型。 9. **实体关系图(ERD)**:EJB3.0规范支持通过注解定义复杂...
7. **查询语言(Query Language)**:Java Persistence Query Language (JPQL) 是EJB 3.0中用于检索和操作数据库的语句,类似于SQL,但操作的是对象而非记录。 8. **生命周期方法(Lifecycle Callbacks)**:开发者可以...
**电子书-EJB3.0实例教程** EJB(Enterprise JavaBeans)是Java平台企业版(Java EE)的一部分,主要用于构建可复用的、模块化的、面向服务的企业级应用程序。EJB 3.0是其重要的一个版本,它在EJB 2.x的基础上进行...
EJB3.0引入了Java Persistence Query Language(JPQL),一种面向对象的查询语言,类似于SQL,但用于操作对象而不是数据库记录。JPQL使得开发者可以方便地执行复杂的数据查询,而无需关心底层的数据库细节。 六、...
【EJB3.0查询语句JPQL用法详解】 Java企业版(Java EE)中的EJB3.0引入了一种新的查询语言,即JPQL(Java Persistence Query Language)。JPQL是EJB2中EJB QL的扩展,旨在简化Java应用程序对持久化实体的访问和操作...
**EJB3.0实例教程及源代码** 本教程专注于企业级JavaBeans(EJB)3.0技术的实践应用,由黎活明提供。EJB是Java平台上的一个核心组件,用于构建可扩展的、可靠的、安全的分布式应用程序。EJB 3.0是EJB规范的一个重要...
7. **查询语言(Query Language)**:EJB3.0提供了JPQL(Java Persistence Query Language),一种面向对象的查询语言,可以用来查询持久化对象。此外,它还支持JPA的Criteria API,提供了更灵活的动态查询方式。 ...
全书共分16章,内容依次包含了Java EE概述、EJB基础、搭建EJB环境、会话bean、持久化实体、持久化实体管理器、对象关系映射、JPQL查询、消息驱动bean、事务、提高EJB 3.0性能、从Web层访问EJB 3和EJB安全、EJB和Web...
**EJB 3.0规范和API文档** Enterprise JavaBeans(EJB)是Java平台企业版(Java EE)的核心组成部分,用于构建可扩展、安全且事务处理能力强大的分布式应用程序。EJB 3.0是EJB规范的一个重大更新,极大地简化了开发...
在这个"Ejb3.0帮助文档包"中,我们有两个重要的文件:《ejb3.0实例教程.pdf》和《EJB3.0持久化开发手册.chm》,它们将深入讲解EJB 3.0的关键概念和实践。 1. **EJB 3.0概述** EJB 3.0主要关注的是简化编程模型,...
EJB 3.0的JPA规范引入了JPQL(Java Persistence Query Language),类似于SQL但面向对象,用于查询实体Bean。此外,Criteria API提供了一种更强大且类型安全的方式来构建动态查询。 7. **EJB容器服务** EJB容器...