Java 下数据业务逻辑开发技术：Hibernate 和 SPL
在 Java 下实现以数据库为核心的业务逻辑，需要具备三项要素：数据库表的对象化、结构化数据计算能力、流程处理能力。Hibernate 是老牌技术，很早就具备了三项要素，已经在众多项目中实现了大量的数据业务逻辑。SPL 是新晋的数据计算语言，同样具备三项要素，也可以用于实现数据业务逻辑。下面对二者进行多方面的比较，从中找出开发效率更高的数据业务逻辑开发技术。至于其他相关的技术（如 MyBatis、Querydsl、JOOQ 等），出于代码耦合度、计算能力、成熟度等原因的考虑，不在此次讨论之列。
基本特征
编程风格
Hibernate 有两种差异较大的编程风格：结构化数据对象和流程处理使用 Java 的 EntityBean 和 if/switch/while/for 语句，属于面向对象编程；结构化数据计算用 HQL，风格接近 SQL。SPL 对面向对象进行了大幅简化，有对象的概念，可以用点号访问属性并进行多步骤计算，但没有继承重载这些内容，不算彻底的面向对象编程。
运行模式
Hibernate 有两种差异较大的运行模式：Java 代码属于编译型执行，HQL 属于解释执行。SPL 是解释型语言，编码更灵活，但相同代码性能会差一点。不过 SPL 有丰富且高效的库函数，总体性能并不弱，面对大数据量时常常会更有优势。
外部类库
Hibernate 可以引入其他任意的第三方 Java 类库，用来弥补自身的短板，比如用 MyBatis 提高短期的开发效率，用 Stream 弥补 HQL 的计算能力。SPL 内置专业的数据处理函数，提供了大量开发效率更高、时间复杂度更低的基本运算，通常不需要外部 Java 类库，特殊情况可在自定义函数中调用。
IDE 和调试
两者都有图形化 IDE 和完整的调试功能。SPL 的 IDE 专为数据处理而设计，结构化数据对象呈现为表格形式，观察更加方便。Hibernate 使用 Java IDE，好处是更通用，缺点是没有为数据处理做优化，无法方便地观察结构化数据对象。
学习难度
Hibernate 需要学习两种语言，即在 Java 的基础上学习 HQL，两者区别较大，又要配合使用，学习难度因此较大。另外，HQL 试图用面向对象的概念简化 SQL，但有些运算（比如关联、子查询）是 SQL 擅长而对象很难表达的，HQL 为了实现这类运算，设计了比 SQL 更复杂的数据结构和语法规则，实际的学习难度高于 SQL。SPL 的目标是简化 Java 甚至 SQL 的编码，一切都为数据计算服务，刻意简化了许多面向对象的概念，学习难度很低。
代码量
HQL 表达能力不如 SQL，复杂些的结构化数据计算要依靠特殊技巧变相实现，包括硬编码、方言 SQL、高性能计算类库等方式，导致编写、集成、管理的难度都很大。Java 的流程处理语句是为通用计算设计的，不是专门为结构化数据对象（List<EntityBean>）设计的，代码量也不小。SPL 表达能力强于 SQL，可用更低的代码量实现结构化数据计算，SPL 的流程处理语句专为结构化数据对象而设计，代码量低于 Java。
结构化数据对象
结构化数据对象用于将数据库表对象化，这是数据处理和业务逻辑开发的基础，专业的结构化数据对象可以方便地与数据库交换数据，支持丰富的计算函数，并简化流程处理的难度。
Hibernate 并没有专业的结构化数据对象，通常借用 Java 的 List<EntityBean>（本文以此为主进行说明），有时也用 Stream<EntityBean> 或 List<Object[]>。SPL 设计了专业的结构化数据对象，包括序表（本文以此为主进行说明）、内表压缩表、外存 Lazy 游标等。
定义
Hibernate（Java）是强类型的编译型语言，使用结构化数据对象前必须先定义数据结构，过程相当麻烦。以 Orders 表为例，先在 hibernate.cfg.xml 里定义实体配置文件名和实体类名：
<mapping resource="OrdersEntity.hbm.xml"/>
<mapping class="table.OrdersEntity"/>
再在实体配置文件定义数据库表和实体类的元数据对应关系，部分内容：
<class name="table.OrdersEntity" table="orders" schema="test">
<id name="orderId" column="OrderID"/>
<property name="client" column="Client"/>
<property name="sellerId" column="SellerId"/>
<property name="amount" column="Amount"/>
<property name="orderDate" column="OrderDate"/>
</class>
再在实体类里实现具体的属性和方法，部分内容：
@Entity
@Table(name = "orders", schema = "test", catalog = "")
public class OrdersEntity {
private Integer orderId;
private String client;
private Integer sellerId;
private Double amount;
private Date orderDate;
@Basic
@Column(name = "OrderID")
public Integer getOrderId() {
return orderId;
}
…
上面是最简单定义过程，如果遇到多表关联、自增类型、联合主键等情况，定义起来就更麻烦了，比如联合主键就需要定义额外的类。事实上，Hibernate 定义结构化数据对象的过程比 SQL 复杂多了，以至于要用专门的注解来简化，并没有达到提高开发效率的目标。虽然可以用工具将定义的过程自动化，但手工定义总是难以避免的（后面会遇到）。
SPL 是解释型语言，取数和计算后可以方便地推断出新的数据结构，一般不需要事先定义。
读数据库
将外部数据库的记录（集合）读为 Hiberante 内部的 List<EntityBean>，主要通过主键查询、HQL 查询、SQL 查询等方式。以最常用的 HQL 为例：
String hql ="from OrdersEntity where sellerId=10";
Query query = session.createQuery(hql);
List<OrdersEntity> orders = query.list();
for(OrdersEntity order : orders){
System.out.println(order.getOrderId()+"\t"+order.getClient()+"\t"+order.getSellerId()+"\t"+order.getAmount()+"\t"+order.getOrderDate());
}
Hibernate 代码不算长，逻辑也容易看懂。要注意的是，前面必须先定义数据结构，后面的输出代码不是必须的，主要为了解决 IDE 不便观察结果的麻烦。
SPL 主要通过 SQL 查询生成序表：
T=orcl.query("select * from test.Orders where sellerId=?",10)
SPL 代码更简单，不必事先定义数据结构，不必额外输出，可以在 IDE 中直观查看结果。
写数据库
将处理后的结构化数据对象持久化保存到数据库，Hibernate 主要通过 save(新增实体)、update（修改实体）、delete(删除实体) 等函数。以批量新增实体为例：
Transaction tx = session.beginTransaction();
for ( int i=0; i<orders.size(); i++ ) {
session.save(orders.get(i));
}
tx.commit();
Hibernate 代码表面上不算麻烦，但实际上存在隐患。Hibernate 会在 save/update 实体时不断生成缓存，直至内存崩溃或手工清空缓存，这就导致上述代码只适合新增 / 修改少量实体。如果新增 / 修改较多实体，就要解决缓存溢出的问题，上述代码还要改造，每新增一定的实体（比如 100 条，根据内存和并发而定），就将缓存刷新到数据库（sesseion.flush()），并清空缓存（session.clear()）。hibernate 用不同的函数分别实现了新增、修改、删除，用法区别较大，如果遇到混合更新的情况，就要分成三种情况分别进行批量处理，代码复杂多了。
SPL 只用一个 update 函数就实现单条或批量记录的新增、修改、删除，且支持混合更新。比如：原序表为 T，经过增删改一系列处理后的序表为 NT, 将变化结果持久化到数据库的 orders 表：
orcl.update(NT:T,orders)
orcl.commit()
SPL 代码简单多了，而且保存时不必手工控制缓存或内存。
访问字段
hibernate 采用 EntityBean 作为结构化数据对象，可以用对象的形式方便地访问字段，比如读取单条记录的 Client 字段：
Orders.get(3).getClient()
Hibernate 访问单条记录的字段比较方便，但一旦要访问记录集合的字段，代码就不那么好写了。比如取一列，要写成这样：
List<String> Clients=Orders.stream().map(Order->Order.getClient()).collect(Collectors.toList());
为了简化代码，上面借用了 Stream 对象，Java8 以上支持，否则写法更复杂。如果使用 Java16 以上版本，最后转回 List 可以更简单些，但整体还是很麻烦。至于取多个字段、按默认字段名取、按字符串名字取、按字段序号取，Hibernate 实现起来就更麻烦了。就连取字段名列表这种貌似基本的操作，对 Hibernate 来说也是件相当麻烦的事。以上种种麻烦，都是 Hibernate 专业性不足的体现。
SPL 序表是专业的结构化数据对象，同样可以用对象的形式方便地访问字段。比如单条记录的 Client 的字段：
Orders(3).Client
专业性更多体现在访问记录集合的字段，比如取一列：
Orders.(Client)
更专业的是，SPL 提供了多种字段访问方法，以提高不同场景下的开发效率：
Orders.([Client,Amount]) //取多个字段
Orders.([#2,#3]) //按默认字段名取
Orders.field(“Client”) //按字符串名取（外部参数）
Orders.field(2) //按字段序号取
Orders.fname() //取字段名列表
有序访问
Hiberante 的 List<EntityBean> 是有序集合，支持顺序相关的功能，但因为专业性不足，只提供了最基础的功能，比如按下标取记录、按区间取记录：
Orders.get(3)
Orders.subList(3,5);
再进一步的功能，就需要硬编码实现了，比如后 N 条：
Collections.reverse(o1);
List<OrdersEntity> o4= o1.subList(0,3);
至于按位置集合取记录、步进取记录等功能，表达起来就更麻烦了。
SPL 序表同样是有序集合，提供了顺序相关的基本功能，比如按下标取、按区间取：
Orders(3)
Orders.to(3,5)
序表是专业的结构化数据对象，许多顺序相关的高级功 hibernate 没有支持，SPL 则直接提供了，比如按倒数序号取记录，可以直接用负号表示：
Orders.m(-3) //倒数第3条
Orders.m(to(-3,-5)) //倒数区间
再比如按位置集合取记录、步进取记录：
Orders.m(1,3,5,7:10) //序号是1、3、5、7-10的记录
Orders.m(-1,-3,-5) //倒数第1，3，5条
Orders.step(2,1) //每2条取第1条（等价于奇数位置）
结构化数据计算
结构化数据计算能力是数据业务逻辑的核心要素，下面从简单到复杂选取几个常见题目，比较 Hibernate 和 SPL 的计算代码。
基本计算
基本计算包括选出部分字段、过滤、分组汇总、排序、关联等。这里选用最简单的计算，从现有的结构化数据对象中选出部分字段，形成新的结构化数据对象。等价的 SQL
select client,amount from Orders
用 Hibernate 实现上述功能：
String hql = "select new ClientAmount(client,amount) from Orders";
Query query = session.createQuery(hql);
List<ClientAmount> clientAmounts = query.list();
就计算代码而言，Hiberante 没有比 SQL 复杂太多，真正的麻烦在于事先要手工定义一个新的实体类（ClientAmount），该类应包含选出的字段，并体现在构造函数的参数中。先定义结果再写计算过程，违反正常的思维习惯，严重影响业务逻辑开发的流畅性。
除了常规方法，还有两种可选的做法。第一种，在现有实体类中新增构造函数，这样不用定义新类，但会增加计算代码之间的耦合性，弊大于利。第二种，直接用 HQL"select id,name from Orders" 返回 List<Object[]>，这样也不用定义新类，但会导致结构化数据类型不统一，会带来更多的麻烦。
需要事先定义数据结构的不止选出部分字段，还有分组汇总、关联等。其中，事先定义关联计算的结果尤其麻烦。较复杂的计算需要将多种基本计算组合使用，可以想象实现过程会更加麻烦。这些麻烦体现了 Hibernate 在数据业务逻辑开发方面专业性不足的问题，本质是因为 HQL 是解释型代码，而 EntityBean 是编译型代码，两者虽然勉强统一在 Java 体系内，但风格差异大，接口太复杂，配合不方便。
同样选出部分字段，SPL 就简单多了：
Orders.new(Client,Name)
SPL 不必事先定义计算结果的数据结构。类似地，所有的基础计算和复杂计算都不必定义数据结构。SPL 的计算代码简单易懂，体现出 SPL 在数据业务逻辑开发方面的专业性，本质是因为 SPL 是解释型语言，序表和计算函数经过整体设计，风格一致，接口简单，配合方便。
多步骤计算
在前一个查询结果的基础上继续查询，可以将大的计算目标分解为多个小步骤，通过解决简单问题最终实现复杂问题的求解。SQL 里的多步骤计算是 from 子查询或 with 子查询，形如：
select orderId, m from (select orderId, month(orderDate) m from Orders) t1
Hibernate 不直接支持多步骤计算，只能换其他思路，常见的做法是用上面的方言 SQL，这里就不重复了。
方言 SQL 短期来看的确可以解决问题，但严重违背了 Hibernate 的初衷，丧失了面向对象、（Java）风格一致、移植性等优点。还可以采用其他做法，常见的有 Java 硬编码、SQL 视图、Hibernate 虚拟视图等，但无论哪种做法，开发效率都不会太高，且日后维护非常麻烦。
SPL 代码：
Orders.new(orderId, month(orderDate): m).new(orderId, m)
多步骤计算是 SPL 基本功能，实现起来很容易，且具备对象访问、风格一致、移植性强的优点。
有序运算
先看简单的有序运算，以前 N 条记录为例，对应的 SQL（Oracle）：
select orderId,client,amount,orderDate from OrdersEntity where rownum<=3
Hibernate 代码：
session.createQuery("select orderId,client,amount,orderDate from OrdersEntity").setMaxResults(3);
Hibernate HQL 不支持 rownum，不能独立完成计算，要配合 Java 代码（setMaxResults）才能解决问题。虽然代码不长，但要在两种截然不同的语法间切换，编写体验较差。此外应该发现，EntityBean 是有序的，而 HQL 是无序的，两者区别较大配合困难，却硬被拉在一起完成计算任务，这也是 Hibernate 不专业的体现。
SPL 代码：
Orders.new(orderId,client,amount,orderDate).to(3)
SPL 代码不仅简单，而且只有一种代码风格，编写时无割裂感和切换动作，体验较好。
再看复杂些的有序运算，以分组环比为例，对应的 SQL（Oracle）一般可用窗口函数实现：
select sales,month,v1,v2, (v1-v2)/v2 looprate from(
select sales, month,amount v1,lag(amount,1) over(partition by sales order by month) v2
from tbl)
HQL 不够专业，不支持窗口函数，无法实现较复杂的有序计算，只能用方言 SQL 或硬编码等方式，远离 Hibernate 的初衷，开发效率很低。
SPL 代码：
tbl.sort(sales,month).derive(if(sales==sales[-1],(amount-amount[-1])/amount[-1]):loopRate)
SPL 是专业的业务逻辑开发技术，擅长进行有序计算，上面代码用 [-1] 表示当前记录的上一条记录，这是相对位置的表示方法，比 lag 函数（绝对移位）更易理解。
流程处理
Hibernate 和 SPL 都提供了通用的判断语句和循环语句，包括 if、三目判断、for、case 等，可实现任意复杂的流程处理，这里不多做讨论，下面重点比较针对集合数据的循环结构是否方便。
Hibernate 支持 foreach 循环函数，针对结构化数据对象进行了优化，比如根据一定的规则计算奖金：
Orders.forEach(r->{
Double amount=r.getAmount();
if (amount>10000) {
r.setBonus(amount*0.05);
}else if(amount>=5000 && amount<10000){
r.setBonus (amount*0.03);
}else if(amount>=2000 && amount<5000){
r.setBonus(amount*0.02);
}
});
forEach 的参数是 Lambda 表达式，可以简化函数的定义，可以方便地处理集合对象的每个成员（代码中的循环变量 r）。forEach 函数配合 Lambda 语法，整体代码要比传统循环语句简单些。但也应该注意到，forEach 函数里使用字段需要附带循环变量名，对单表计算来说是多余的，同样使用 Lambda 语法的 SQL 就可以省略变量名。实际上，定义循环变量名都是多余的，SQL 就不用定义。这些缺点都说明 Hibernate 在流程处理方面还不够专业。
SPL 也有针对结构化数据对象进行优化的循环函数，直接用括号表示。同样根据一定的规则计算奖金：
Orders.(Bonus=if(Amount>10000,Amount*0.05,
if(Amount>5000 && Amount<10000, Amount*0.03,
if(Amount>=2000 && Amount<5000, Amount*0.02)
)))
SPL 的循环函数同样支持 Lambda 表达式，而且接口更简单，不必定义循环变量，使用字段时不必引用变量名，比 Hibernate 更方便，专业性也更强。除了循环函数，SPL 还有更多专业的流程处理功能，比如：每轮循环取一批而不是一条记录；某字段值变化时循环一轮。
函数和语法
时间和字符串函数
Hibernate 内置的时间和字符串函数较少，很多常用函数都没有直接提供，只能用方言 SQL 或硬编码实现，比如：日期增减、求年中第几天、求季度数，以及替换、left 截取、求 ASCII 码等。
以日期增减为例，假设数据库是 MySQL，则应当先创建自定义方言类，继承 org.hibernate.dialect.MySQLDialect 父类。在自定义方言类中注册 HQL 函数名（比如 udf_dateadd），并引入 MySQL 的日期增减函数 date_add，关键代码为：
registerFunction("udf_dateadd", new SQLFunctionTemplate( DateType.INSTANCE,"date_add(?1,INTERVAL ?2 DAY)") );
实际计算时，再编写 HQL
select udf_dateadd (orderDate,3) from OrdersEntity
上述代码不仅编写麻烦，而且无法移植，一旦更换数据库，就要重写自定义方言类。
SPL 内置丰富的日期和字符串函数，包括日期增减。同样的功能代码：
Orders.new(elapse(ORDERDATE,3))
上述 SPL 代码与数据库无关，不必修改就可以在不同数据库中迁移。
类似地，SPL 也直接支持取年中第几天，求季度数，以及字符串替换、left 截取、求 ASCII 码等函数，移植时同样不必修改。
SPL 函数选项和层次参数
值得一提的是，为了进一步提高开发效率，SPL 还提供了独特的函数语法。
有大量功能类似的函数时，大部分程序语言只能用不同的名字或者参数进行区分，使用不太方便。而 SPL 提供了非常独特的函数选项，使功能相似的函数可以共用一个函数名，只用函数选项区分差别。比如，select 函数的基本功能是过滤，如果只过滤出符合条件的第 1 条记录，可使用选项 @1：
T.select@1(Amount>1000)
对有序数据用二分法进行快速过滤，使用 @b：
T.select@b(Amount>1000)
函数选项还可以组合搭配，比如：
Orders.select@1b(Amount>1000)
有些函数的参数很复杂，可能会分成多层。常规程序语言对此并没有特别的语法方案，只能生成多层结构数据对象再传入，非常麻烦。SQL 使用了关键字把参数分隔成多个组，更直观简单，但这会动用很多关键字，使语句结构不统一。而 SPL 创造性地发明了层次参数简化了复杂参数的表达，通过分号、逗号、冒号自高而低将参数分为三层：
join(Orders:o,SellerId ; Employees:e,EId)
SPL 完整例子
SPL 以专业的结构化数据对象为基础，配合专业的结构化数据对象和专业的流程处理功能，可大幅提高数据业务逻辑的开发效率。比如：根据规则计算出奖金，向数据库插入包含奖金字段的记录，Hibernate 需要多个文件和大段代码才能实现，SPL 就简单多了：
A |
B |
C |
|
1 |
=db=connect@e("dbName") |
/连接数据库，开启事务 |
|
2 |
=db.query@1 ("select sum(Amount) from sales where |
/查询当月销售额 |
|
3 |
=if(A2>=10000 :200, A2<10000 && A2>=2000 :100, 0) |
/本月累计奖金 |
|
4 |
=p_Amount*0.05 |
/本单固定奖金 |
|
5 |
=BONUS=A3+A4 |
/总奖金 |
|
6 |
=create(ORDERID,CLIENT,SELLERID,AMOUNT,BONUS,ORDERDATE) |
/创建订单的数据结构 |
|
7 |
=A6.record([p_OrderID,p_Client,p_SellerID,p_Amount,BONUS, |
/生成一条订单记录 |
|
8 |
>db.update@ik(A7,sales;ORDERID) |
/尝试写入库表 |
|
9 |
=db.error() |
/入库结果 |
|
10 |
if A9==0 |
>A1.commit() |
/成功，则提交事务 |
11 |
else |
>A1.rollback() |
/失败，则回滚事务 |
12 |
>db.close() |
/关闭数据库连接 |
|
13 |
return A9 |
/返回入库结果 |
应用结构
Java 集成
Hibernate 代码本身就是 Java，可被其他 Java 代码直接调用。
SPL 是基于 JVM 的数据计算语言，提供了易用的 JDBC 接口，可被 JAVA 代码无缝集成。比如，将 SPL 代码存为脚本文件，在 JAVA 中以存储过程的形式调用文件名：
Class.forName("com.esproc.jdbc.InternalDriver");
Connection connection =DriverManager.getConnection("jdbc:esproc:local://");
Statement statement = connection.createStatement();
ResultSet result = statement.executeQuery("call getClient()");
热部署
Hibernate（Java）是编译型语言，不支持热部署，修改代码后需要重新编译并重启整个应用，加大了维护难度，降低了系统稳定性。
SPL 是解释型语言，代码以脚本文件的形式外置于 JAVA，支持热部署，修改后不必编译，也不必重启应用。由于 SPL 代码不依赖 JAVA，业务逻辑和前端代码物理分离，耦合性也更低。
代码移植
代码移植是 Hibernate 的设计目标之一，即业务逻辑可在不同的数据库之间无缝切换，但由于结构化数据计算能力不足，Hibernate 在实践中普遍使用方言 SQL，深度绑定数据库，基本失去了移植能力，除非业务逻辑足够简单。
SPL 计算能力更强，不必借用 SQL，只用丰富的内置函数库就能实现复杂的结构化数据计算，这样的计算代码可在数据库间无缝移植。在数据库取数代码中，SPL 通常用 query 函数执行方言 SQL 生成序表，虽然取数 SQL 比较简单，手工移植不难，但仍有一定工作量，为了使取数代码便于移植，SPL 专门提供了不依赖特定数据库的通用 SQL，可在主流数据库间无缝移植。
通过多方面的比较可知：Hibernate 在针对数据库的业务逻辑开发方面专业性严重不足，开发效率低下。SPL 语法简练、表达效率高、代码移植方便，结构化数据对象更专业，函数更丰富且计算能力更强，流程处理更方便，开发效率远高于 Hibernate。
