第2章：快速上手与对比实践¶

引言：对比式学习，理解ORM选型之道¶

在上一章中，我们回顾了Java持久化技术的演进历程，深入了解了从JDBC、Hibernate到现代ORM框架的发展脉络，以及Jimmer框架的创新特性。本章将通过实际代码和案例，帮助你快速掌握Jimmer的核心用法，并通过与其他主流框架的对比，加深对Jimmer优势的理解。

本章目标与学习方式¶

想象一下，你是一位技术负责人，正在为公司的新项目选择持久化方案。团队中有人推荐使用Hibernate，有人建议采用MyBatis，还有人提出尝试新兴的Jimmer框架。面对这些选择，你需要充分了解各个框架的优缺点，才能做出明智的决策。

本章的主要目标是：

1. 实践掌握Jimmer的基础用法：通过具体代码示例，使你能够快速上手Jimmer框架
2. 对比理解不同框架的特点：将Jimmer与Hibernate/JPA、MyBatis、原生JDBC进行并列比较
3. 建立框架选型的思维模型：学会从多个维度评估ORM框架，形成自己的技术决策能力
4. 掌握Jimmer解决实际问题的方法：通过典型案例，理解Jimmer如何解决传统框架的痛点

我们将采用"实例驱动"的学习方式，每个技术点都会通过具体的业务场景展示。例如，当讲解动态查询时，我们会展示一个电商平台的商品搜索功能，分别用四种框架实现，并分析比较它们的异同。

这种方法不仅帮助你理解抽象概念，更能使你体会到不同框架在实际应用中的优劣势。就像学开车一样，光看说明书不如实际坐在驾驶座上操作来得直观。

案例设计说明¶

为什么选择电商平台作为我们的案例项目？因为它包含了企业应用中最常见且具有代表性的数据模型和业务场景：

1. 多样的实体关系
2. 商品与分类：一对多关系
3. 订单与订单项：一对多关系，带有丰富的业务规则
4. 用户与角色：多对多关系，涉及权限管理

5. 商品分类：自引用的树形结构

6. 典型的业务场景

7. 商品管理：基础的CRUD操作
8. 商品搜索：复杂的动态查询条件
9. 订单处理：涉及事务和状态管理

10. 数据统计：聚合查询和报表生成

11. 常见的技术挑战

12. N+1查询问题：处理关联数据时的性能瓶颈
13. 动态对象图：不同场景需要不同深度的数据
14. 复杂查询：多条件、多表关联的查询优化
15. 缓存管理：数据一致性与性能平衡

电商平台的这些特点，恰恰是各个ORM框架设计时需要重点考虑的问题，也是开发者在实际工作中经常遇到的挑战。通过这个案例，你可以直观地看到Jimmer如何优雅地解决这些问题，以及它与传统方案的差异。

就像建筑师通过模型展示设计理念一样，电商平台这个"模型"将帮助我们呈现Jimmer的核心设计思想和价值主张。

多框架对比的意义¶

"知己知彼，百战不殆"。只有了解多种技术方案，才能做出明智的选择。我们对比Jimmer、Hibernate/JPA、MyBatis和原生JDBC的目的在于：

1. 建立参照系

当你初次接触一个新框架时，如果没有参照物，很难判断它的优劣。就像评价一辆新车，如果没有对比其他车型，你很难说它"加速快"还是"操控好"。通过与已知框架对比，你能更客观地评估Jimmer的价值。

1. 理解设计取舍

每个框架都有其设计哲学和重点关注的问题。Hibernate追求对象关系映射的完整性，MyBatis注重SQL的掌控能力，而Jimmer则强调动态数据结构和类型安全。通过对比，你能理解这些设计取舍背后的思考。

1. 明确适用场景

没有绝对完美的框架，只有更适合特定场景的选择。通过多框架对比，你将了解到： - 什么情况下Jimmer是最佳选择 - 什么场景可能更适合使用其他框架 - 如何在项目中合理组合多种技术方案

1. 平滑技术迁移

如果你已经熟悉其他ORM框架，对比学习可以帮助你建立知识连接，快速掌握Jimmer。这就像学习一门新的编程语言，如果你能将它与已知语言对比，学习效率会大大提高。

通过这种对比式学习，你不仅能掌握Jimmer的使用方法，更能理解它为什么被设计成这样，以及它相比其他框架的独特价值。这些洞察将帮助你在实际项目中做出更明智的技术决策。

阅读指南¶

本章内容循序渐进，从环境搭建开始，逐步深入到实体建模、数据操作、关联处理、动态查询等方面。每个部分都遵循"问题-解决方案-对比分析"的结构，帮助你理解各个框架的异同。

针对不同背景的读者，我们提供以下阅读建议：

1. ORM新手
2. 建议按顺序阅读全章内容
3. 重点关注案例中的问题描述和解决思路

4. 尝试运行代码示例，加深理解

5. Hibernate/JPA经验者

6. 可以重点关注2.2.2节Jimmer的接口式实体和2.5.2节动态查询实现
7. 注意比较Jimmer与Hibernate在关联处理和延迟加载方面的差异

8. 思考Jimmer如何解决你在使用Hibernate时遇到的痛点

9. MyBatis经验者

10. 重点关注2.2.2节和2.6.2节，了解Jimmer的类型安全和动态DTO机制
11. 对比Jimmer与MyBatis在SQL控制和对象映射方面的差异

12. 思考如何将MyBatis的优势与Jimmer结合使用

13. 技术决策者

14. 关注每节末尾的对比分析和2.7节的综合案例
15. 重点理解各框架的性能特性和适用场景
16. 思考如何在现有项目中引入或迁移到Jimmer

本章大量使用代码示例，建议你在阅读时在IDE中尝试运行这些代码，亲身体验不同框架的使用感受。记住，理解概念很重要，但通过实践获得的体验更加深刻。

现在，让我们开始这段对比式学习之旅，探索Jimmer如何重新定义Java持久化的开发体验。

2.1 项目环境搭建¶

在开始深入探索Jimmer和其他ORM框架之前，我们需要先搭建一个完整的开发环境。想象一下，你刚刚受命负责一个新电商平台的研发工作，团队成员正在等待你确定技术栈和项目架构。在这样的场景下，合理的环境搭建和技术选型将直接影响项目的开发效率和未来的可维护性。

对于一个现代Java应用来说，我们不仅需要考虑开发语言和框架，还需要关注构建工具、数据库、容器化技术等多方面的选择。特别是当我们计划对比多种ORM框架时，如何设计一个既能体现各框架特点，又便于横向比较的项目结构就显得尤为重要。

本节将带你完成这个电商平台的基础环境搭建，包括技术栈选型、开发环境准备以及各ORM框架的基础配置。通过这一过程，你不仅能够为后续的学习做好准备，还能了解不同框架在项目初始阶段的配置差异，从而更好地理解它们的设计理念。

记住，好的开始是成功的一半。一个精心设计的项目结构和开发环境，会让后续的编码工作事半功倍。让我们开始动手搭建吧。

2.1.1 技术栈选择与规划¶

"我们应该使用什么技术栈来构建新的电商平台？"这可能是你作为技术负责人面临的第一个问题。在回答这个问题前，让我们先分析一下电商平台的核心需求和技术挑战。

电商平台需求与架构设计

电商平台本质上是一个处理商品、订单、用户等核心业务实体的系统。它需要应对的技术挑战包括：

• 高并发访问：尤其在促销活动期间，系统需要处理大量的并发请求
• 复杂的数据关系：商品、订单、用户之间存在丰富的关联关系
• 动态的数据结构：不同场景下需要展示不同深度的数据
• 高性能查询：特别是商品搜索和订单查询等核心功能
• 数据一致性：在分布式环境下保证交易数据的一致性

基于这些需求，我们设计了以下电商系统的核心数据模型：

@startuml
!theme plain
skinparam defaultFontName Source Han Sans CN
skinparam defaultFontSize 14
skinparam classFontStyle bold
skinparam classFontSize 16
skinparam classFontColor #333333
skinparam classBackgroundColor #F8F8F8
skinparam classBorderColor #CCCCCC

package "电商核心模型" {
  class Product {
    + id: Long
    + name: String
    + price: BigDecimal
    + stock: Integer
    + attributes: JSONB
    + images: String[]
    + isPublished: Boolean
  }

  class Category {
    + id: Long
    + name: String
    + parentId: Long?
    + path: String
  }

  class Order {
    + id: Long
    + orderNo: String
    + totalAmount: BigDecimal
    + status: String
    + createdTime: LocalDateTime
  }

  class OrderItem {
    + id: Long
    + orderId: Long
    + productId: Long
    + quantity: Integer
    + price: BigDecimal
  }

  class User {
    + id: Long
    + username: String
    + email: String
    + phone: String?
    + isActive: Boolean
  }

  class Role {
    + id: Long
    + name: String
    + description: String?
  }

  class Address {
    + id: Long
    + userId: Long
    + recipient: String
    + phone: String
    + province: String
    + city: String
    + detail: String
    + isDefault: Boolean
  }
}

Category "1" *-- "0..*" Category : 父分类
Category "1" *-- "0..*" Product : 包含
Product "1" o-- "0..*" OrderItem : 引用
Order "1" *-- "1..*" OrderItem : 包含
User "1" *-- "0..*" Order : 创建
User "1" *-- "0..*" Address : 拥有
User "many" -- "many" Role : 拥有 >
Order "1" -- "1" Address : 使用 >

@enduml

这个数据模型清晰地展示了电商系统中的实体关系：商品分类形成树形结构；商品归属于分类；订单由多个订单项组成；用户可以创建订单、管理地址、拥有多个角色。模型设计涵盖了一对多关系（用户与订单）、多对多关系（用户与角色）和自引用关系（分类的树形结构），很好地代表了企业应用中常见的数据建模场景。

示例代码库简介

为了帮助你更好地理解和实践本书中的概念，我们提供了完整的配套示例代码库：jimmer-in-action-samples。这个代码库包含了书中所有章节的示例代码，你可以通过以下方式获取：

git clone https://github.com/lijma/jimmer-in-action-samples.git

示例代码库的目的不仅是展示Jimmer框架的功能，还包括与其他主流ORM框架的对比实现。通过这些示例，你可以：

1. 在本地环境中运行和测试所有示例
2. 直接对比不同框架实现同一功能的差异
3. 在实际项目中参考或复用这些最佳实践
4. 跟随书中的进度逐步深入学习

我强烈建议你在阅读本书的同时，克隆并探索这个代码库。实际的动手操作将帮助你更深入地理解概念，培养实践能力。

多项目代码组织方式

为了方便对比不同ORM框架的实现差异，我们采用"按章节和框架分离"的项目组织方式：

jimmer-in-action-samples/
├── chapter2/                # 第二章相关代码
│   ├── jimmer/              # Jimmer实现
│   ├── hibernate/           # Hibernate/JPA实现
│   ├── mybatis/             # MyBatis实现
│   ├── jdbc/                # 原生JDBC实现
│   └── common/              # 共享代码和资源
│
├── chapter3/                # 第三章相关代码（基于第二章演进）
│   └── ...

这种组织方式有几个显著优势：

1. 便于横向比较：同一功能点的四种实现并列展示，直观对比
2. 简化学习曲线：读者可以选择先深入学习一个框架，再横向对比其他框架
3. 保持演进连续性：每章代码基于前一章演进，体现渐进式开发过程
4. 独立可运行：每个框架项目都能独立运行，方便实践和测试

在共享代码和资源方面，我们将数据库脚本、共用工具类和测试数据等放在common目录下，确保不同框架实现基于相同的业务模型和测试数据，保证对比的公平性。

基础技术栈选择与理由

在开始构建项目前，我们需要确定基础技术栈。这些选择不仅关系到当前的开发体验，也会影响未来的维护和扩展。作为读者，无论你是已经熟悉这些技术，还是初次接触，理解这些选择的原因都能帮助你在实际工作中做出更明智的决策。

1. JDK 21

作为Java开发者，你可能会疑惑："最新的JDK 21是否稳定可靠？我们是否应该选择更保守的JDK 17？"

实际上，JDK 21不仅是最新的长期支持版本，它还引入了许多能显著提升开发效率的新特性：虚拟线程让我们能用同步的代码风格处理异步任务；增强的模式匹配简化了对复杂对象的处理；字符串模板让文本处理更加直观。这些特性在本书的示例代码中都会直接受益，让你体验到更现代的Java编程方式。

1. Gradle 8.5+

如果你曾在Maven和Gradle之间犹豫，本书选择Gradle的原因很简单 - 它在管理多模块项目时的优势正好满足我们按框架分离示例代码的需求。尤其是当你需要为不同的框架（如Jimmer和Hibernate）配置不同的编译流程时，Gradle的灵活性会让你的工作轻松许多。

1. PostgreSQL 15

虽然任何关系型数据库都能支持基本的SQL操作，但当你需要处理JSON数据和数组时，PostgreSQL的优势就非常明显了。在本书的电商示例中，这些高级数据类型能让你用更贴近业务模型的方式存储和查询数据，而不必为了适应数据库结构扭曲你的领域模型。

1. Docker & Docker Compose

想象一下，能否让所有读者在几分钟内启动一个完全相同的开发环境？Docker正是这一挑战的答案。通过本书提供的Docker配置，你可以一键启动包含数据库、缓存等所有必要组件的环境，无论你使用的是Windows、macOS还是Linux系统。这样你就可以专注于学习ORM框架本身，而不是纠结于环境配置问题。

1. Spring Boot 3.2+

作为Java生态中最流行的应用框架，Spring Boot让不同的ORM框架能够在统一的应用结构中运行，这对于我们比较不同ORM框架的实现差异至关重要。同时，它的自动配置特性也大大简化了每个框架的初始设置，让你能更快进入到核心概念的学习中。

这些技术选择反映了现代Java应用开发的最佳实践，它们共同构成了一个高效、灵活且易于理解的开发环境。在接下来的章节中，我们将基于这些基础技术，逐步构建并比较不同ORM框架的实现方式。即使你在实际工作中使用的技术栈与此不同，这里的原则和模式也同样适用，能够帮助你做出更合理的技术决策。

各框架技术栈对比

在共同的基础技术栈之上，四种ORM框架各有其特定的依赖和版本：

在框架与技术栈的适配性方面：

• Jimmer与JDK 21：Jimmer的核心设计（编译时代码生成、接口声明式实体）与JDK 21的记录模式和模式匹配相得益彰，能够发挥Java最新特性的优势。

• Hibernate与PostgreSQL：Hibernate 6.x对PostgreSQL特有功能（如JSONB、数组类型）的支持已经相当成熟，可以充分利用数据库特性。

• MyBatis与Spring Boot：MyBatis的Spring Boot Starter提供了良好的自动配置，简化了传统MyBatis繁琐的XML配置。

• 所有框架与Gradle：所有框架都能良好地集成到Gradle构建系统中，特别是Jimmer的代码生成插件与Gradle的任务系统集成得很好。

通过以上技术栈的选择和规划，我们为电商平台项目奠定了坚实的技术基础。接下来，我们将详细介绍如何搭建这套开发环境。

2.1.2 开发环境准备¶

作为新项目的技术负责人，你需要为团队搭建一个标准的开发环境。理想情况下，无论是经验丰富的高级开发者，还是刚加入团队的新人，都应该能在短时间内完成环境配置并开始编码。这不仅提高了团队的整体效率，也减少了因环境差异导致的"在我电脑上能跑"问题。

基础环境搭建

我们的开发环境基于以下核心组件：

1. JDK安装与配置

本项目使用JDK 21 LTS版本。可使用多种方式安装JDK：

# 使用SDKMAN(跨平台)
sdk install java 21.0.7-amzn

# macOS (使用Homebrew)
brew install --cask temurin

# Ubuntu/Debian Linux
sudo apt-get install temurin-21-jdk

# Windows
# 可从Oracle、Adoptium或Microsoft等官方渠道下载

安装完成后，设置JAVA_HOME环境变量并验证安装：

# 验证Java版本
java -version
# 输出示例: openjdk version "21.0.7" 2025-04-15 LTS

1. Gradle安装与配置

本项目使用Gradle 8.5+版本：

# macOS (使用Homebrew)
brew install gradle

# 使用SDKMAN(跨平台)
sdk install gradle 8.5

# 手动安装(所有平台)
# 1. 下载Gradle二进制包
# 2. 解压到指定目录
# 3. 添加到PATH环境变量

验证Gradle安装：

gradle --version
# 应显示Gradle 8.5或更高版本

1. Docker环境配置

Docker和Docker Compose是我们环境的核心部分，它们帮助我们统一数据库等基础设施：

# macOS/Windows
# 下载并安装Docker Desktop

# Ubuntu/Debian Linux
sudo apt-get update
sudo apt-get install docker-ce docker-compose
sudo systemctl enable docker
sudo systemctl start docker
sudo usermod -aG docker $USER

验证Docker安装：

docker --version
docker-compose --version

1. IDE配置选项

虽然任何Java IDE或文本编辑器都可以用于开发，IntelliJ IDEA为Java和Kotlin开发提供了全面的支持。对于本书的示例，以下插件可能有助于提高开发效率：

• Jimmer IDEA Plugin：为Jimmer实体提供代码提示和导航支持
• Database Navigator：管理和查询PostgreSQL数据库
• Gradle Plugin：集成Gradle构建功能
• PlantUML Integration：查看和编辑UML图

Docker化数据库环境

为了确保所有开发者使用完全相同的数据库环境，我们使用Docker容器运行PostgreSQL和相关工具。

1. PostgreSQL容器配置

在jimmer-in-action-samples/chapter2/common/docker目录下，创建了专用的docker-compose.yml文件：

version: '3.8'

services:
  postgres:
    image: postgres:15
    container_name: postgres-ch2
    environment:
      POSTGRES_DB: jimmer_demo
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"
    volumes:
      - ./../sql:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

  pgadmin:
    image: dpage/pgadmin4
    container_name: pgadmin-ch2
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@example.com
      PGADMIN_DEFAULT_PASSWORD: admin
    ports:
      - "5050:80"
    depends_on:
      - postgres

这个配置定义了两个服务：PostgreSQL数据库和pgAdmin管理工具。特别要注意的是，我们设置了健康检查，确保数据库完全就绪后才标记为可用。

1. 数据库初始化脚本

在common/sql目录中，提供了两个关键的SQL脚本：

• 01-schema.sql：创建数据库表结构，包括Product、Category、Order等实体
• 02-test-data.sql：插入测试数据，以便开发和测试

这些脚本通过Docker volume挂载到容器的初始化目录，实现了数据库的自动初始化。而且每个章节都有独立的容器和配置，避免了章节之间的相互干扰。

1. 数据库管理

通过配置的pgAdmin工具，你可以在浏览器中访问http://localhost:5050来管理数据库，执行SQL查询，或者查看表结构。这对于理解ORM框架的底层行为非常有帮助，特别是在学习和调试阶段。

框架特定开发工具

为了高效使用各种ORM框架，以下是一些可用的专用工具：

1. Jimmer开发工具

Jimmer框架有配套的IDEA插件和Gradle插件：

• IDEA插件提供了接口式实体与生成类之间的导航、智能补全等功能
• Gradle插件自动执行代码生成任务，集成到构建流程中

此外，Jimmer官方提供了Web控制台用于探索和调试，可用于查看生成的SQL和缓存状态。

1. Hibernate/JPA工具

JPA开发可用的工具包括：

• JPA Buddy：IDEA插件，提供实体创建和管理功能
• Hibernate Query Analyzer：用于分析和优化HQL查询

• JPA Model Gen：从数据库生成实体类

• MyBatis工具

MyBatis开发相关工具：

• MyBatis Generator：自动生成实体类、Mapper接口和XML
• MyBatisX：IDEA插件，提供Mapper和XML之间的导航

• PageHelper：简化分页查询

• SQL开发工具

对于所有框架，理解底层SQL是重要的：

• DBeaver：跨平台数据库工具，支持PostgreSQL和其他数据库
• Database Navigator：IDEA内置的数据库工具
• p6spy：SQL日志库，可记录和格式化应用程序执行的SQL语句

测试环境准备

良好的测试实践是项目成功的关键。以下是本项目使用的测试工具：

1. 单元测试框架

所有项目使用JUnit 5和AssertJ进行测试：

// build.gradle
testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
testImplementation 'org.assertj:assertj-core:3.24.2'

1. API测试工具

REST API测试可使用的工具：

• REST Assured：Java库，用于验证REST服务
• Testcontainers：提供临时数据库实例用于集成测试

• Spring Boot Test：集成测试支持

• 数据库测试策略

数据库测试的常用做法包括：

• 测试前重置数据库状态
• 使用事务回滚保持测试独立性

• 使用特定框架的测试辅助工具

• 性能测试工具

评估不同框架性能的工具包括：

• JMH (Java Microbenchmark Harness)：微基准测试工具
• Gatling：负载测试框架
• Metrics API：收集性能指标

环境验证与问题排查

为了帮助你确认环境配置正确，我们提供了一个全面的检查脚本check-environment.sh：

#!/bin/bash

# 设置颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m' # No Color

# 省略部分脚本内容...

# 主函数
main() {
    echo "==================================================="
    echo "     Jimmer实战 - 第2章 环境检查脚本                "
    echo "==================================================="

    # 检查JDK、Docker、Gradle等基础工具
    check_basic_tools

    # 检查Docker容器状态
    check_docker_containers

    # 检查项目配置文件
    check_project_configuration

    # 显示最终结果
    if [[ $all_checks_passed ]]; then
        print_success "环境检查完成，所有检查均通过！"
    else
        print_error "环境检查发现问题，请解决上述问题后再继续。"
    fi
}

这个脚本会检查基础工具、Docker容器状态和项目配置，帮助你快速发现和解决可能的环境问题。

开发环境启动流程

现在，让我们总结一下基础开发环境的启动流程：

1. 克隆代码库：

   git clone https://github.com/lijma/jimmer-in-action-samples.git
   cd jimmer-in-action-samples/chapter2
   

2. 启动Docker环境：

   cd common/docker
   docker-compose up -d
   

3. 验证环境状态：

   cd ..
   ./check-environment.sh
   

通过以上步骤，你就完成了基础开发环境的搭建，包括必要的工具安装和数据库环境准备。接下来，我们将在2.1.3节中详细介绍如何为每个ORM框架配置具体的项目结构和依赖。

完成环境准备后，你已经拥有了一个标准化、可复制的基础环境，这为我们后续比较不同ORM框架提供了公平的基础。

2.1.3 基础项目配置¶

"选择正确的持久化方案就像选择一把合适的剑——它不仅要锋利，还要适合你的手。"一位拥有20年Java开发经验的架构师曾这样告诉我。在企业级应用开发中，持久化框架的选择往往决定了项目的长期成功。不同的框架虽然都能完成数据库操作这一基本任务，但它们的设计理念、编程模型和性能特性却各不相同。

想象一下，当你站在技术选型的十字路口，面前是传统的JDBC、成熟的Hibernate、标准化的JPA、灵活的MyBatis和新锐的Jimmer，你会如何做出选择？仅靠框架官网的介绍显然是不够的。真正的理解来自于实践和对比——当这些框架处理相同问题时的不同表现，才能真正揭示它们的本质。

这一节，我们将带你进行一次"框架探索之旅"。通过一个电子商城的分类管理功能，我们将展示五种不同框架的配置和实现方式。这个示例虽然简单，但蕴含了企业应用中常见的复杂关系——树形自引用结构。正是这种结构，最能测试框架处理对象关系的能力。

在我们的示例项目jimmer-in-action-samples/chapter2中，你将看到五个独立但结构相似的子项目：

jimmer-in-action-samples/chapter2/
├── common/              # 共享配置和工具
│   ├── docker/         # Docker配置
│   └── sql/           # SQL脚本
├── jdbc/               # JDBC示例项目
├── hibernate/          # Hibernate示例项目
├── jpa/                # JPA示例项目
├── mybatis/            # MyBatis示例项目
└── jimmer/             # Jimmer示例项目

为了确保比较的公平性，所有项目都连接到同一个PostgreSQL数据库，使用相同的数据模型和初始数据。这就像是在相同的赛道上进行一场技术马拉松——相同的起点和终点，但每个参赛者都有自己独特的跑步姿势。

统一的数据世界

在探索框架差异之前，让我们先理解它们所共享的数据世界。我们的电子商城数据库设计得简单而实用，核心是商品分类(Category)和商品(Product)这两个实体。特别值得注意的是分类表的设计——它采用了自引用的树形结构：

-- 商品分类表
CREATE TABLE category (
    id BIGSERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    parent_id BIGINT,
    path VARCHAR(200),
    created_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    modified_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT fk_category_parent FOREIGN KEY (parent_id) REFERENCES category(id)
);

这种设计在现实世界中非常常见。想想亚马逊的商品分类：电子产品包含手机、电脑等子类别；服装包含男装、女装等子类别。这种层次结构不仅直观，还允许无限层级的分类扩展。

然而，从技术角度看，这种自引用结构也带来了挑战： 1. 如何优雅地表示父子关系 2. 如何处理循环引用问题 3. 如何高效查询特定层级的分类 4. 如何避免N+1查询性能问题

正是这些挑战，让不同框架的差异变得清晰可见。

初始数据：构建分类树

为了让示例更加生动，我们预置了一些分类和商品数据：

-- 插入分类数据
INSERT INTO category (id, name, parent_id, path) VALUES 
(1, '电子产品', NULL, '/1'),
(2, '手机', 1, '/1/2'),
(3, '电脑', 1, '/1/3'),
(4, '服装', NULL, '/4'),
(5, '男装', 4, '/4/5'),
(6, '女装', 4, '/4/6');

这些数据构成了一个两层的分类树，根分类是"电子产品"和"服装"，各自有自己的子分类。特别注意path字段——它存储了从根到当前节点的完整路径，是一种称为"物化路径"(Materialized Path)的树形结构优化技术。这种技术允许我们通过简单的模式匹配快速找到所有子孙节点，而不需要复杂的递归查询。

现在，我们的舞台已经搭建完成，数据世界已经构建好。接下来，就让我们看看各个框架如何在这个相同的世界中施展各自的魔法。从最基础的JDBC开始，我们将一步步了解每种框架的独特风格和优势。

1. JDBC项目配置

让我们从最基础的JDBC项目开始探索。作为Java程序员几乎都要接触的技术，JDBC提供了与数据库交互的基本API。与其他ORM框架相比，JDBC是最"接近底层"的选择，它让开发者获得对SQL和数据库操作的完全控制。

JDBC项目结构如下：

jimmer-in-action-samples/chapter2/jdbc/
├── build.gradle              # 项目构建脚本
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── org/lijma/jdbc/samples/
│   │   │       ├── entity/           # 实体类
│   │   │       │   └── Category.java
│   │   │       ├── repository/       # 数据访问层
│   │   │       │   ├── CategoryRepository.java
│   │   │       │   └── CategoryRepositoryImpl.java
│   │   │       └── JdbcApplication.java  # 应用入口
│   │   └── resources/
│   │       └── application.yml       # 配置文件
│   └── test/
│       └── ...                       # 测试代码

构建配置

JDBC项目的build.gradle配置简洁明了，仅包含必要的依赖：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'org.lijma.jdbc.samples'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // 数据库驱动
    runtimeOnly 'org.postgresql:postgresql'

    // 开发辅助工具
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // 测试相关
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

test {
    useJUnitPlatform()
}

这里使用了Spring Boot的JDBC启动器，它包含了必要的JDBC依赖和连接池。PostgreSQL驱动负责与数据库的实际通信。

应用配置

application.yml文件包含基本的数据源配置：

spring:
  application:
    name: jdbc-sample

  datasource:
    url: jdbc:postgresql://localhost:5432/jimmer_demo
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
    hikari:
      connection-timeout: 30000
      maximum-pool-size: 10
      minimum-idle: 5

server:
  port: 8084

logging:
  level:
    org.springframework.jdbc: DEBUG

配置很直观：指定数据库连接URL、用户名和密码，以及Hikari连接池的相关参数。为了方便调试，我们设置了较高的JDBC日志级别。

实体定义

使用JDBC时，实体类只是简单的Java对象（POJO），没有任何ORM注解。以Category类为例：

package org.lijma.jdbc.samples.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class Category {
    private Long id;
    private String name;
    private Long parentId;  // 父分类ID
    private Category parent; // 父分类对象
    private String path;
    private LocalDateTime createdTime;
    private LocalDateTime modifiedTime;
}

这里使用了Lombok的@Data注解来自动生成getter/setter、toString等方法，使代码更简洁。注意parentId和parent两个属性：它们反映了同一个关联关系的两个方面——ID引用和对象引用。在纯JDBC中，我们需要手动维护这种关联。

数据访问层

JDBC项目的数据访问层分为接口和实现：

// 接口定义
public interface CategoryRepository {
    List<Category> findAll();
}

// 实现类
@Repository
public class CategoryRepositoryImpl implements CategoryRepository {

    private final JdbcTemplate jdbcTemplate;

    public CategoryRepositoryImpl(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Override
    public List<Category> findAll() {
        String sql = "SELECT id, name, parent_id, path, created_time, modified_time FROM category";
        return jdbcTemplate.query(sql, new CategoryRowMapper());
    }

    private static class CategoryRowMapper implements RowMapper<Category> {
        @Override
        public Category mapRow(ResultSet rs, int rowNum) throws SQLException {
            Category category = new Category();
            category.setId(rs.getLong("id"));
            category.setName(rs.getString("name"));
            category.setParentId(rs.getLong("parent_id"));
            if (rs.wasNull()) {
                category.setParentId(null);
            }
            category.setPath(rs.getString("path"));
            category.setCreatedTime(rs.getTimestamp("created_time").toLocalDateTime());
            category.setModifiedTime(rs.getTimestamp("modified_time").toLocalDateTime());
            return category;
        }
    }
}

在这里，我们使用了Spring的JdbcTemplate来简化JDBC操作，但仍需要手动编写SQL查询和对象映射代码。特别是CategoryRowMapper内部类，它负责将数据库结果集的一行转换为一个Category对象，这是JDBC方式最明显的特征之一。

JDBC方式的特点

JDBC方式的优势在于： 1. 完全控制SQL：开发者可以精确控制执行的每一条SQL语句 2. 最小依赖：只需要JDBC驱动，没有额外的框架依赖 3. 学习曲线平缓：基于Java标准API，容易理解

但同时也有明显的劣势： 1. 大量样板代码：需要手动处理连接获取、SQL执行、结果映射等 2. 缺乏ORM特性：没有自动的对象-关系映射 3. 手动管理关联：需要额外代码处理对象间的关联关系

2. Hibernate项目配置

从JDBC的原始方法，我们现在转向第一个成功的Java ORM框架——Hibernate。作为JPA规范的前身和主要实现，Hibernate允许开发者以面向对象的方式思考数据访问问题，而非关系型数据库的表与行。

Hibernate项目结构如下：

jimmer-in-action-samples/chapter2/hibernate/
├── build.gradle              # 项目构建脚本
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── org/lijma/hibernate/samples/
│   │   │       ├── config/            # 配置类
│   │   │       │   └── HibernateConfig.java
│   │   │       ├── entity/            # 实体类
│   │   │       │   └── Category.java
│   │   │       ├── repository/        # 数据访问层
│   │   │       │   ├── CategoryRepository.java
│   │   │       │   └── CategoryRepositoryImpl.java
│   │   │       └── HibernateApplication.java
│   │   └── resources/
│   │       └── application.yml        # 配置文件
│   └── test/
│       └── ...                        # 测试代码

构建配置

Hibernate项目的build.gradle明显比JDBC复杂一些：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'org.lijma.hibernate.samples'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

repositories {
    mavenCentral()
}

dependencies {
    // 使用原生Hibernate而非Spring Data JPA
    implementation 'org.hibernate.orm:hibernate-core:6.4.0.Final'
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // 数据库驱动
    runtimeOnly 'org.postgresql:postgresql'

    // 开发辅助工具
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // 测试相关
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

test {
    useJUnitPlatform()
}

这里我们使用了Hibernate核心库，而不是通过Spring Data JPA，以便更清晰地展示Hibernate本身的特性。

应用配置

application.yml文件包含Hibernate特有的配置参数：

spring:
  application:
    name: hibernate-sample

  datasource:
    url: jdbc:postgresql://localhost:5432/jimmer_demo
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
    hikari:
      connection-timeout: 30000
      maximum-pool-size: 10
      minimum-idle: 5

# Hibernate原生配置，不使用JPA
hibernate:
  connection:
    url: jdbc:postgresql://localhost:5432/jimmer_demo
    username: postgres
    password: postgres
    driver_class: org.postgresql.Driver
  dialect: org.hibernate.dialect.PostgreSQLDialect
  show_sql: true
  format_sql: true
  hbm2ddl:
    auto: validate

server:
  port: 8083

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE

除了基本的数据源配置外，这里还有Hibernate专有的设置： - dialect指定方言，让Hibernate能生成针对特定数据库的SQL - show_sql和format_sql用于调试 - hbm2ddl.auto设为validate，表示Hibernate会验证数据库结构与实体映射是否一致

Hibernate配置类

与JDBC不同，Hibernate需要一个专门的配置类来设置会话工厂：

package org.lijma.hibernate.samples.config;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.lijma.hibernate.samples.entity.Category;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import java.util.Properties;

@org.springframework.context.annotation.Configuration
public class HibernateConfig {

    @Value("${hibernate.connection.url}")
    private String url;

    @Value("${hibernate.connection.username}")
    private String username;

    @Value("${hibernate.connection.password}")
    private String password;

    @Value("${hibernate.connection.driver_class}")
    private String driverClass;

    @Value("${hibernate.dialect}")
    private String dialect;

    @Value("${hibernate.show_sql}")
    private String showSql;

    @Value("${hibernate.format_sql}")
    private String formatSql;

    @Value("${hibernate.hbm2ddl.auto}")
    private String hbm2ddlAuto;

    @Bean
    public SessionFactory sessionFactory() {
        Properties settings = new Properties();
        settings.put(Environment.DRIVER, driverClass);
        settings.put(Environment.URL, url);
        settings.put(Environment.USER, username);
        settings.put(Environment.PASS, password);
        settings.put(Environment.DIALECT, dialect);
        settings.put(Environment.SHOW_SQL, showSql);
        settings.put(Environment.FORMAT_SQL, formatSql);
        settings.put(Environment.HBM2DDL_AUTO, hbm2ddlAuto);
        settings.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "thread");

        Configuration configuration = new Configuration();
        configuration.setProperties(settings);

        // 添加实体类
        configuration.addAnnotatedClass(Category.class);

        return configuration.buildSessionFactory(
            new StandardServiceRegistryBuilder()
                .applySettings(configuration.getProperties())
                .build()
        );
    }
}

这个配置类负责设置Hibernate的SessionFactory，它是Hibernate应用的核心。通过代码配置，我们指定了连接参数、方言和实体类。

实体定义

Hibernate的实体类通过注解映射到数据库表：

package org.lijma.hibernate.samples.entity;

import lombok.Data;
import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "category")
@Data
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Category parent;

    @Column(name = "path")
    private String path;

    @Column(name = "created_time", nullable = false)
    private LocalDateTime createdTime;

    @Column(name = "modified_time", nullable = false)
    private LocalDateTime modifiedTime;
}

与JDBC的实体类相比，Hibernate实体包含了大量ORM映射注解： - @Entity和@Table表明这是一个实体类，对应数据库中的category表 - @Id和@GeneratedValue标识主键及其生成策略 - @Column指定列属性，如是否可为空、长度等 - @ManyToOne和@JoinColumn定义了与父分类的多对一关系

特别注意parent属性：与JDBC中需要同时保存ID和对象不同，Hibernate中我们只需定义对象引用，框架会自动处理背后的外键关系。

数据访问层

Hibernate的数据访问层实现如下：

package org.lijma.hibernate.samples.repository;

import org.lijma.hibernate.samples.entity.Category;
import java.util.List;

public interface CategoryRepository {
    List<Category> findAll();
}

package org.lijma.hibernate.samples.repository;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.lijma.hibernate.samples.entity.Category;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class CategoryRepositoryImpl implements CategoryRepository {

    private final SessionFactory sessionFactory;

    public CategoryRepositoryImpl(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    public List<Category> findAll() {
        try (Session session = sessionFactory.openSession()) {
            Query<Category> query = session.createQuery("FROM Category", Category.class);
            return query.list();
        }
    }
}

与JDBC相比，Hibernate的数据访问代码简洁很多： - 不需要编写SQL语句（使用HQL - Hibernate Query Language） - 不需要手动映射结果集 - 通过Session管理对象的持久化状态 - 可以直接使用面向对象的查询语言

Hibernate方式的特点

Hibernate方式的优势在于： 1. 减少样板代码：自动化的对象-关系映射减少了大量手动代码 2. 对象化思维：允许开发者以面向对象方式思考数据访问 3. 自动化关联管理：自动处理实体间的关联关系，包括懒加载

但同时也有一些挑战： 1. 配置复杂：相比JDBC，需要更多配置 2. 学习曲线陡峭：需要理解很多概念，如会话、持久化上下文等 3. 性能调优复杂：需要注意N+1查询等性能问题

3. JPA项目配置

JPA（Java Persistence API）是Java EE规范的一部分，它标准化了对象关系映射的API。虽然Hibernate是JPA的主要实现之一，但JPA提供了更标准化的接口，使应用程序可以在不同JPA实现之间切换。

JPA项目结构如下：

jimmer-in-action-samples/chapter2/jpa/
├── build.gradle              # 项目构建脚本
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── org/lijma/jpa/samples/
│   │   │       ├── entity/            # 实体类
│   │   │       │   └── Category.java
│   │   │       ├── repository/        # 数据访问层
│   │   │       │   └── CategoryRepository.java
│   │   │       └── JpaApplication.java
│   │   └── resources/
│   │       └── application.yml        # 配置文件
│   └── test/
│       └── ...                        # 测试代码

构建配置

JPA项目的build.gradle使用Spring Data JPA：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'org.lijma.jpa.samples'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

repositories {
    mavenCentral()
}

dependencies {
    // Spring Data JPA
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // 数据库驱动
    runtimeOnly 'org.postgresql:postgresql'

    // 开发辅助工具
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // 测试相关
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

test {
    useJUnitPlatform()
}

Spring Data JPA在JPA基础上提供了更高层次的抽象，进一步简化了数据访问层的开发。

应用配置

application.yml文件包含JPA特有的配置：

spring:
  application:
    name: jpa-sample

  datasource:
    url: jdbc:postgresql://localhost:5432/jimmer_demo
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
    hikari:
      connection-timeout: 30000
      maximum-pool-size: 10
      minimum-idle: 5

  jpa:
    database-platform: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        format_sql: true
    show-sql: true
    open-in-view: false

server:
  port: 8085

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE

这里的配置与Hibernate类似，但遵循Spring Boot对JPA的命名约定。特别注意open-in-view: false设置，这是一个避免常见性能问题的最佳实践。

实体定义

JPA实体类使用JPA标准注解：

package org.lijma.jpa.samples.entity;

import lombok.Data;
import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "category")
@Data
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Category parent;

    @Column(name = "path")
    private String path;

    @Column(name = "created_time", nullable = false)
    private LocalDateTime createdTime;

    @Column(name = "modified_time", nullable = false)
    private LocalDateTime modifiedTime;
}

JPA实体的注解与Hibernate几乎相同，这不足为奇，因为Hibernate是JPA规范的核心实现者之一。关键的区别在于，这些注解来自jakarta.persistence包，而不是Hibernate特有的包。

数据访问层

JPA项目的数据访问层利用Spring Data JPA的强大功能：

package org.lijma.jpa.samples.repository;

import org.lijma.jpa.samples.entity.Category;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface CategoryRepository extends JpaRepository<Category, Long> {
}

与之前的例子相比，这里最显著的变化是接口直接继承自JpaRepository，无需编写实现类。Spring Data JPA会自动为接口生成实现，包括标准的CRUD操作。只需要声明接口，即可获得完整的数据访问功能，包括： - findAll() - findById() - save() - delete() - 分页查询 - 自定义查询方法

JPA方式的特点

JPA方式的优势在于： 1. 标准API：使用Java EE标准API，避免厂商锁定 2. 简化的DAO层：通过Spring Data JPA，可以几乎不写实现代码 3. 丰富的查询能力：支持方法名派生查询、JPQL和原生SQL

和Hibernate类似，JPA也面临一些挑战： 1. 性能调优：需要注意懒加载和N+1查询问题 2. 配置复杂度：虽然有所简化，但仍需要不少配置 3. 灵活性限制：标准化带来了一些灵活性的损失

4. MyBatis项目配置

与Hibernate和JPA这样的全功能ORM框架不同，MyBatis采取了一种"SQL映射"的方法，让开发者保持对SQL的控制，同时提供简便的结果映射机制。这种方法尤其适合那些对SQL控制要求较高的项目。

MyBatis项目结构如下：

jimmer-in-action-samples/chapter2/mybatis/
├── build.gradle                # 项目构建脚本
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── org/lijma/mybatis/samples/
│   │   │       ├── entity/            # 实体类
│   │   │       │   └── Category.java
│   │   │       ├── mapper/            # SQL映射层
│   │   │       │   └── CategoryMapper.java
│   │   │       └── MyBatisApplication.java
│   │   └── resources/
│   │       ├── application.yml        # 配置文件
│   │       └── mapper/                # XML映射文件
│   │           └── CategoryMapper.xml
│   └── test/
│       └── ...                        # 测试代码

构建配置

MyBatis项目的build.gradle配置如下：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'org.lijma.mybatis.samples'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

repositories {
    mavenCentral()
}

dependencies {
    // MyBatis 相关
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3'
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // 数据库驱动
    runtimeOnly 'org.postgresql:postgresql'

    // 开发辅助工具
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // 测试相关
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

test {
    useJUnitPlatform()
}

MyBatis Spring Boot Starter提供了良好的自动配置，简化了传统MyBatis项目中繁琐的XML配置。

应用配置

application.yml文件包含MyBatis特有的配置：

spring:
  application:
    name: mybatis-sample

  datasource:
    url: jdbc:postgresql://localhost:5432/jimmer_demo
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver
    hikari:
      connection-timeout: 30000
      maximum-pool-size: 10
      minimum-idle: 5

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: org.lijma.mybatis.samples.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

server:
  port: 8086

logging:
  level:
    org.lijma.mybatis.samples.mapper: DEBUG

MyBatis的配置主要关注两点： 1. mapper-locations: 指定XML映射文件的位置 2. type-aliases-package: 指定实体类所在的包，简化XML中的类型引用 3. map-underscore-to-camel-case: 启用下划线命名到驼峰命名的自动转换

实体定义

MyBatis的实体类与JDBC类似，是一个简单的POJO，没有任何特殊注解：

package org.lijma.mybatis.samples.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class Category {
    private Long id;
    private String name;
    private Long parentId;
    private Category parent;
    private String path;
    private LocalDateTime createdTime;
    private LocalDateTime modifiedTime;
}

这种"纯净"的实体类是MyBatis的一个优点，实体类无需感知持久化框架的存在。

数据访问层

MyBatis项目的数据访问层分为Java接口和XML映射文件：

package org.lijma.mybatis.samples.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.lijma.mybatis.samples.entity.Category;

import java.util.List;

@Mapper
public interface CategoryMapper {
    List<Category> findAll();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.lijma.mybatis.samples.mapper.CategoryMapper">

    <resultMap id="categoryResultMap" type="org.lijma.mybatis.samples.entity.Category">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="parentId" column="parent_id"/>
        <result property="path" column="path"/>
        <result property="createdTime" column="created_time"/>
        <result property="modifiedTime" column="modified_time"/>
    </resultMap>

    <select id="findAll" resultMap="categoryResultMap">
        SELECT id, name, parent_id, path, created_time, modified_time
        FROM category
    </select>

</mapper>

MyBatis的数据访问层有两个关键部分： 1. 接口定义：使用@Mapper注解标记的接口，方法声明对应数据库操作 2. XML映射：包含SQL语句和对象映射规则的XML文件，与接口方法一一对应

这种分离的设计让SQL可以单独维护，同时享受接口的类型安全。

MyBatis方式的特点

MyBatis方式的优势在于： 1. SQL完全可控：开发者可以精确控制执行的每一条SQL语句 2. 性能可预期：性能表现与手写JDBC接近，但代码量显著减少 3. 灵活的映射：可以处理复杂的查询结果映射，包括一对多、多对多关系 4. 上手简单：概念少，学习曲线平缓

但同时也有一些挑战： 1. SQL维护成本：SQL语句分散在XML文件中，维护和重构有一定难度 2. 动态SQL复杂：复杂的条件查询需要编写较多的动态SQL标签 3. 代码生成依赖：对于大型项目，往往需要代码生成工具来减少重复劳动

5. Jimmer项目配置

最后，我们来到本书的主角——Jimmer。作为一个现代的ORM框架，Jimmer融合了不可变对象、编译时代码生成和类型安全查询等创新特性，为Java开发者提供了全新的数据访问体验。

Jimmer项目结构如下：

jimmer-in-action-samples/chapter2/jimmer/
├── build.gradle              # 项目构建脚本
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── org/lijma/jimmer/samples/
│   │   │       ├── entity/            # 实体接口
│   │   │       │   └── Category.java
│   │   │       ├── repository/        # 数据访问层
│   │   │       │   ├── CategoryRepository.java
│   │   │       │   └── CategoryRepositoryImpl.java
│   │   │       └── JimmerApplication.java
│   │   └── resources/
│   │       └── application.yml        # 配置文件
│   └── test/
│       └── ...                        # 测试代码

构建配置

Jimmer项目的build.gradle配置如下：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'org.lijma.jimmer.samples'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

ext {
    jimmerVersion = '0.8.69'
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    // Jimmer依赖
    implementation "org.babyfish.jimmer:jimmer-spring-boot-starter:${jimmerVersion}"

    // Jimmer APT注解处理器
    annotationProcessor "org.babyfish.jimmer:jimmer-apt:${jimmerVersion}"

    // Spring Boot依赖
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // 数据库依赖
    implementation 'org.postgresql:postgresql'

    // 测试依赖
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testAnnotationProcessor "org.babyfish.jimmer:jimmer-apt:${jimmerVersion}" // 为测试添加APT处理器
}

tasks.named('test') {
    useJUnitPlatform()
}

Jimmer的构建脚本比其他框架略复杂，主要是因为需要配置注解处理器（APT），这是Jimmer实现编译时代码生成的关键。注意jimmer-apt依赖被声明为注解处理器，它会在编译时生成额外的类。

应用配置

application.yml文件包含Jimmer特有的配置：

server:
  port: 8081

spring:
  application:
    name: jimmer-sample
  datasource:
    url: jdbc:postgresql://localhost:5432/jimmer_demo
    username: postgres
    password: postgres
    driver-class-name: org.postgresql.Driver

# Jimmer配置
jimmer:
  dialect: org.babyfish.jimmer.sql.dialect.PostgresDialect
  show-sql: true
  pretty-sql: true
  database-validation-mode: WARNING

logging:
  level:
    org.babyfish.jimmer: DEBUG

Jimmer的配置相对简单，主要是指定数据库方言和调试选项。

实体定义

Jimmer的实体定义与传统ORM框架有显著不同，它使用接口而非类：

package org.lijma.jimmer.samples.entity;

import org.babyfish.jimmer.sql.*;
import org.jetbrains.annotations.Nullable;
import java.time.LocalDateTime;

@Entity
public interface Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    long id();

    String name();

    @Nullable
    @ManyToOne
    @JoinColumn(name = "parent_id")
    Category parent();

    @Nullable
    String path();

    @Column(name = "created_time")
    LocalDateTime createdTime();

    @Column(name = "modified_time")
    LocalDateTime modifiedTime();
}

这种接口式定义是Jimmer的一个核心特性，与传统的ORM框架有本质区别： 1. 实体是接口而非类，方法名采用命名式（无get前缀） 2. 没有setter方法，体现了不可变对象的设计理念 3. 使用@Nullable明确标注可空属性，提高类型安全性

虽然注解看起来与JPA类似，但Jimmer实体接口没有setter方法，这反映了Jimmer的不可变对象设计哲学。在编译时，Jimmer会根据这些接口生成真正的实现类。

数据访问层

Jimmer项目的数据访问层实现如下：

package org.lijma.jimmer.samples.repository;

import org.lijma.jimmer.samples.entity.Category;
import java.util.List;

public interface CategoryRepository {
    List<Category> findAll();
}

package org.lijma.jimmer.samples.repository;

import org.babyfish.jimmer.sql.JSqlClient;
import org.lijma.jimmer.samples.entity.Category;
import org.lijma.jimmer.samples.entity.CategoryTable;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class CategoryRepositoryImpl implements CategoryRepository {

    private final JSqlClient sqlClient;

    public CategoryRepositoryImpl(JSqlClient sqlClient) {
        this.sqlClient = sqlClient;
    }

    @Override
    public List<Category> findAll() {
        CategoryTable table = CategoryTable.$;
        return sqlClient
            .createQuery(table)
            .select(table)
            .execute();
    }
}

Jimmer的数据访问层使用了完全不同的API风格： 1. JSqlClient是核心API，用于创建查询和执行数据操作 2. CategoryTable.$是自动生成的表元数据，提供类型安全的查询条件 3. 查询API采用流式风格，既直观又类型安全

这种强类型的查询方式让开发者能在编译期就发现潜在问题，而不是运行时才出错。

Jimmer方式的特点

Jimmer方式的优势在于： 1. 不可变对象模型：实体对象一旦创建就不可修改，避免了状态管理的复杂性 2. 类型安全：编译时代码生成和强类型API，减少运行时错误 3. 高效的关联处理：自动解决N+1查询问题，智能优化查询 4. 动态对象图：可以按需获取不同深度和形状的对象图

但也有一些考虑点： 1. 学习曲线：新概念和API需要时间学习 2. 构建复杂度：需要配置注解处理器 3. 社区成熟度：相比其他成熟框架，社区和生态还在成长中

小结

通过这五种不同框架对同一个业务场景的实现，我们可以清晰地看到它们在设计理念和使用方式上的差异：

1. JDBC：直接、底层、完全控制，但需要大量样板代码
2. Hibernate：完全ORM、对象化思维、自动关联管理，但配置复杂
3. JPA：标准API、简化DAO层、平衡控制与便利，但有一定性能挑战
4. MyBatis：SQL可控、灵活映射、半自动ORM，但需要维护大量SQL
5. Jimmer：不可变实体、类型安全、智能查询优化，但有学习成本

每种框架都有其适用场景，选择哪一种取决于你的项目需求和团队偏好。在接下来的章节中，我们将更深入地探索Jimmer的核心特性，这些特性让它在现代应用开发中脱颖而出。

完成这个基础项目配置后，你已经具备了使用不同ORM框架处理相同业务场景的能力。这种对比学习方法不仅帮助你理解各个框架的特性，还能让你在项目中做出更明智的技术选择。

2.2 实体建模对比¶

数据建模是使用任何ORM框架的第一步也是最核心的步骤，它直接决定了应用如何看待数据以及如何组织业务逻辑。在本节中，我们将深入对比五种不同持久化框架的实体建模方式，包括Jimmer、JPA、Hibernate、MyBatis和JDBC。为了便于对比，所有示例都基于同一个电商系统的Category（商品分类）实体。

2.2.1 数据库表结构设计¶

首先，我们来看一下底层数据库中商品分类表的结构设计：

-- 商品分类表
CREATE TABLE category (
    id BIGSERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    parent_id BIGINT,
    path VARCHAR(200),
    created_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    modified_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT fk_category_parent FOREIGN KEY (parent_id) REFERENCES category(id)
);

这个表包含以下字段： - id: 主键标识 - name: 分类名称 - parent_id: 父分类ID（自引用关系） - path: 分类路径（用于快速查找层级关系） - created_time: 创建时间 - modified_time: 最后修改时间

特别值得注意的是parent_id字段，它构成了一个自引用关系，使得Category实体可以形成树状结构，这是电商系统中常见的分类设计模式。

2.2.2 Jimmer的接口式实体与不可变设计¶

Jimmer采用了与传统ORM框架完全不同的实体定义方式——接口而非类。这种设计是Jimmer不可变对象模型的基础，也是它区别于其他框架的关键特征。

package org.lijma.jimmer.samples.entity;

import org.babyfish.jimmer.sql.*;
import org.jetbrains.annotations.Nullable;
import java.time.LocalDateTime;

@Entity
public interface Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    long id();

    String name();

    @Nullable
    @ManyToOne
    @JoinColumn(name = "parent_id")
    Category parent();

    @Nullable
    String path();

    @Column(name = "created_time")
    LocalDateTime createdTime();

    @Column(name = "modified_time")
    LocalDateTime modifiedTime();
}

Jimmer实体的底层设计原理：

1. 接口-实现分离模式：Jimmer采用了接口定义、编译时生成实现的架构，这种设计模式与Java的SPI(Service Provider Interface)机制类似，实现了关注点分离。开发者只需关注"做什么"（What），而框架负责"怎么做"（How）。

例子：这就像是我们在餐厅点菜一样，你只需要告诉服务员"我要一份宫保鸡丁"（接口定义），而不需要关心厨师如何切菜、炒菜的具体步骤（实现细节）。Jimmer的接口定义就是这样的"菜单"，而编译器则是"厨师"，自动为你准备好符合要求的实现类。

1. 不可变对象的实现机制：
2. Jimmer在编译时生成的实现类包含所有属性的final字段
3. 使用内部Builder进行对象构造
4. 每次修改都会创建新对象，不会改变原对象
5. 所有实现类都覆盖了equals()和hashCode()，基于所有属性值计算

例子：假设你要修改一个分类名称从"电子产品"到"数码产品"：

// 原始对象
Category electronics = findCategoryById(1L);  // 电子产品

// 在传统ORM中的修改方式
electronics.setName("数码产品");  // 直接修改原对象

// 在Jimmer中的修改方式
Category digital = electronics.withName("数码产品"); 
// electronics对象保持不变，返回新的Category对象
System.out.println(electronics.name()); // 仍然输出 "电子产品"
System.out.println(digital.name());     // 输出 "数码产品"

1. 类型安全的自引用处理：
2. 传统ORM中的递归引用容易导致JSON序列化问题和无限循环
3. Jimmer通过动态视图(动态DTO)和智能遍历机制，优雅地处理了这个问题

4. 编译期类型检查确保所有引用都是类型安全的

5. 运行时元模型：

6. Jimmer为每个实体生成静态元模型类（如Categories）
7. 元模型类提供了类型安全的属性访问器，用于构建查询

8. 这些元模型对象包含实体所有属性的信息，实现真正的"代码即文档"

9. 内存效率优化：

10. 使用自定义的内部位图(bitmap)跟踪已修改字段
11. 智能差异检测，只序列化修改的字段
12. 支持稀疏对象，无需所有属性都有值

代码生成与使用模式：

当编译上述代码时，Jimmer会生成多个重要的类：

1. CategoryImpl: 实际的不可变实现类，包含：
2. 所有属性的final字段
3. 递归的equals()和hashCode()实现
4. 高效的toString()方法

5. 链式的修改器方法（返回新对象）

6. CategoryDraft: 可变的"草稿"类，用于复杂对象创建场景

7. 提供setter方法用于构建对象

8. 可转换为不可变的CategoryImpl

9. Categories: 静态元模型类，用于类型安全的查询

// Jimmer的使用模式
// 创建新对象（不可变）
Category category = Objects.createCategory(draft -> {
    draft.setName("电子产品");
    draft.setPath("/electronics");
});

// 修改对象（返回新实例）
Category updatedCategory = Objects.createCategory(draft -> {
    draft.setId(category.id());
    draft.setName("电子产品更新");
    draft.setPath(category.path());
    // 其他属性会自动复制
});

// 类型安全的查询
Categories categories = Categories.CATEGORY;
List<Category> electronics = sqlClient
    .createQuery(categories)
    .where(categories.name().eq("电子产品"))
    .select(categories)
    .execute();

通过这种设计，Jimmer在编译期就能检测大量潜在错误，如：

• 属性名拼写错误
• 类型不匹配
• 访问不存在的属性
• 尝试修改不可变对象

2.2.3 JPA/Hibernate的注解式实体与代理增强¶

JPA和Hibernate采用了注解驱动的类定义方式，这是Java生态中最广泛使用的ORM实体定义模式。其核心是运行时增强和代理对象。

package org.lijma.jpa.samples.entity;

import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;

@Entity
@Table(name = "category")
@Data
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Category parent;

    @Column(name = "path")
    private String path;

    @Column(name = "created_time", nullable = false)
    private LocalDateTime createdTime;

    @Column(name = "modified_time", nullable = false)
    private LocalDateTime modifiedTime;
}

JPA/Hibernate实体的底层设计原理：

1. 代理对象与延迟加载：
2. Hibernate使用字节码增强（ByteBuddy或Javassist）创建实体类的子类作为代理
3. 代理对象拦截属性访问，实现懒加载
4. 对于@ManyToOne(fetch = FetchType.LAZY)，Hibernate不会立即加载parent对象，而是创建代理
5. 只有首次访问parent的属性时才会触发SQL查询

例子：这就像是你在看电视节目，节目信息中显示"更多细节请按遥控器上的INFO键"。你只有在真正需要这些额外信息时才会按下INFO键（触发加载）。同样，当你获取一个Category对象时，它的parent关系初始是一个看起来像Category但实际是代理的对象：

Category category = entityManager.find(Category.class, 1L);
System.out.println(category.getClass().getName());
// 输出: org.lijma.jpa.samples.entity.Category$HibernateProxy$a7bc23f1

// 直到这一刻才会触发SQL查询加载parent的实际数据
String parentName = category.getParent().getName();

1. 脏检查机制：
2. JPA/Hibernate实体在加载后会被持久化上下文（PersistenceContext）跟踪
3. 任何属性修改都会被记录
4. 事务提交时，通过比较当前状态和快照来检测变更

5. 这种机制无需显式调用save/update方法

6. 缓存与关联管理：

7. 一级缓存（Session级别）自动管理，确保同一个会话中实体唯一性
8. 二级缓存（可选）实现跨会话的缓存

9. 级联操作通过cascade属性配置，可实现关联对象的自动保存、更新或删除

10. 反射与内省机制：

11. Hibernate大量使用Java反射机制
12. 在启动时扫描所有实体类的注解
13. 构建元数据模型用于运行时映射

14. 这种动态特性带来了灵活性，但也增加了运行时开销

15. JDBC与SQL生成：

16. 实体状态变更自动转换为SQL语句
17. SQL方言(Dialect)确保跨数据库兼容性
18. 批量操作优化减少数据库往返

使用模式与问题：

// JPA/Hibernate的使用模式
// 创建与保存
Category category = new Category();
category.setName("电子产品");
category.setPath("/electronics");
category.setCreatedTime(LocalDateTime.now());
category.setModifiedTime(LocalDateTime.now());
entityManager.persist(category);

// 延迟加载与N+1问题
Category electronics = entityManager.find(Category.class, 1L);
// 如果未使用join fetch，下面的代码会触发新的SQL查询（N+1问题）
Category parent = electronics.getParent(); 

// 脏检查自动更新
electronics.setName("电子设备");  // 无需显式调用update方法
// 事务提交时自动保存更改

JPA/Hibernate的这种设计存在几个固有问题：

1. N+1查询问题：不当使用懒加载容易导致大量额外查询
2. 代理对象限制：实体类需要有无参构造器、非final类和属性
3. 序列化问题：懒加载属性在脱离持久化上下文后可能无法访问
4. 双向关联维护负担：需手动维护双向关联的两端

以N+1查询问题为例： 假设我们要获取所有分类及其父分类名称：

List<Category> categories = entityManager
    .createQuery("FROM Category", Category.class)
    .getResultList();

// 看似简单的代码，但每次循环都可能触发新的SQL查询
for (Category category : categories) {
    if (category.getParent() != null) {
        System.out.println(
            category.getName() + " 的父分类是: " + 
            category.getParent().getName()  // 这里可能触发额外查询!
        );
    }
}

如果有100个分类，且大部分有父分类，这段代码可能会执行1次查询获取所有分类，然后再执行近100次查询获取各自的父分类，这就是典型的N+1查询问题。解决方法是使用JOIN FETCH:

List<Category> categories = entityManager
    .createQuery("FROM Category c LEFT JOIN FETCH c.parent", Category.class)
    .getResultList();

2.2.4 MyBatis的轻量级实体与SQL映射¶

与完全的ORM框架不同，MyBatis采用了更为轻量的"对象-SQL映射"方式，实体类通常更加简单，映射信息集中在XML文件中。

package org.lijma.mybatis.samples.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class Category {
    private Long id;
    private String name;
    private Long parentId;
    private Category parent;
    private String path;
    private LocalDateTime createdTime;
    private LocalDateTime modifiedTime;
}

MyBatis实体与映射的底层设计原理：

1. SQL中心设计：
2. 实体类只是数据容器，不包含ORM元数据
3. 所有映射逻辑和SQL位于XML映射文件中
4. 这种分离使SQL优化与重构更容易

例子：这类似于建筑设计中的"结构与装饰分离"原则。实体类就像建筑的骨架结构，而XML映射则是可以灵活变化的装饰风格。比如同一个Category实体可以有多种查询方式：

<!-- 基本查询 -->
<select id="findByName" resultMap="categoryMap">
  SELECT * FROM category WHERE name = #{name}
</select>

<!-- 性能优化查询 -->
<select id="findByNameOptimized" resultMap="categoryMap">
  SELECT id, name FROM category WHERE name = #{name}
</select>

<!-- 关联查询 -->
<select id="findWithProducts" resultMap="categoryWithProductsMap">
  SELECT c.*, p.* 
  FROM category c
  LEFT JOIN product p ON p.category_id = c.id
  WHERE c.name = #{name}
</select>

1. 半自动映射机制：
2. 结果映射（ResultMap）定义了SQL结果集与对象的映射关系
3. 参数映射定义了Java对象如何映射到SQL参数

4. 开发者完全控制SQL和映射过程

5. 动态SQL能力：

6. XML中的条件标签（如<if>、<choose>）实现动态SQL构建
7. 这种模板化方法既保留了SQL的可读性，又提供了动态生成能力

8. 不依赖编程语言的类型系统，更接近原生SQL

9. 缓存设计：

10. 简单的两级缓存系统
11. 一级缓存基于SqlSession（默认启用）
12. 二级缓存基于命名空间（需手动配置）

13. 缓存粒度较粗，可能导致缓存失效问题

14. 对象加载策略：

15. 懒加载通过额外的查询实现，而非代理对象
16. 关联查询依赖嵌套查询(<association>)或联表查询

典型的MyBatis映射文件（XML）：

<mapper namespace="org.lijma.mybatis.samples.repository.CategoryMapper">
  <resultMap id="categoryMap" type="org.lijma.mybatis.samples.entity.Category">
    <id property="id" column="id"/>
    <result property="name" column="name"/>
    <result property="parentId" column="parent_id"/>
    <result property="path" column="path"/>
    <result property="createdTime" column="created_time"/>
    <result property="modifiedTime" column="modified_time"/>
    <association property="parent" column="parent_id" 
                 select="selectCategoryById"/>
  </resultMap>

  <select id="selectCategoryById" resultMap="categoryMap">
    SELECT id, name, parent_id, path, created_time, modified_time
    FROM category
    WHERE id = #{id}
  </select>

  <select id="selectCategoryByName" resultMap="categoryMap">
    SELECT id, name, parent_id, path, created_time, modified_time
    FROM category
    WHERE name LIKE CONCAT('%', #{name}, '%')
  </select>

  <insert id="insertCategory" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO category (name, parent_id, path, created_time, modified_time)
    VALUES (#{name}, #{parentId}, #{path}, #{createdTime}, #{modifiedTime})
  </insert>
</mapper>

使用模式：

// MyBatis的使用模式
// Mapper接口
public interface CategoryMapper {
    Category selectCategoryById(Long id);
    List<Category> selectCategoryByName(String name);
    int insertCategory(Category category);
}

// 使用Mapper
Category category = new Category();
category.setName("电子产品");
category.setPath("/electronics");
category.setCreatedTime(LocalDateTime.now());
category.setModifiedTime(LocalDateTime.now());
categoryMapper.insertCategory(category);

// 查询
Category electronics = categoryMapper.selectCategoryById(1L);

MyBatis实体与SQL映射的设计带来了几个明显的优缺点：

优势： 1. SQL完全可控，便于性能优化 2. 缓存粒度可细化到语句级别 3. 更容易与遗留系统集成 4. 学习曲线平缓，接近原生JDBC

劣势： 1. 大量SQL需要手动管理 2. XML与Java的割裂降低了重构和类型安全 3. 映射关系不直观，需要同时理解Java和XML 4. 缺乏高级ORM特性如脏检查和自动关联管理

2.2.5 JDBC的手动映射与底层控制¶

在最基础的JDBC应用中，实体类通常是最简单的数据容器，所有映射逻辑完全由开发者手动控制。

package org.lijma.jdbc.samples.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class Category {
    private Long id;
    private String name;
    private Long parentId;
    private Category parent;
    private String path;
    private LocalDateTime createdTime;
    private LocalDateTime modifiedTime;
}

JDBC的底层设计与映射原理：

1. 全手动映射：
2. JDBC不提供任何自动映射
3. 开发者需要手动从ResultSet获取数据并设置到对象
4. 所有转换逻辑都需要显式编码

例子：这就像是手工组装一台电脑，每个组件都需要你亲自选择、连接和配置。以下是从ResultSet到Category对象的手动映射：

Category category = new Category();
category.setId(rs.getLong("id"));
category.setName(rs.getString("name"));

// 类型转换也需要手动处理
Timestamp createdTs = rs.getTimestamp("created_time");
if (createdTs != null) {
    category.setCreatedTime(createdTs.toLocalDateTime());
}

// 处理NULL值也要格外小心
Long parentId = rs.getLong("parent_id");
if (!rs.wasNull()) {  // 必须检查是否为NULL
    category.setParentId(parentId);
}

这种"一砖一瓦"的手工建造方式既繁琐又容易出错，但给予了开发者最大的控制权。

1. 底层连接管理：
2. 显式的连接获取、释放和事务控制
3. 需要精心管理资源以避免泄漏

4. 手动设置和重置所有数据库参数

5. 批处理与性能：

6. 手动创建和管理PreparedStatement
7. 显式批量操作优化

8. 手动调优每个SQL语句

9. 纯SQL控制：

10. 没有任何中间层抽象
11. SQL错误在运行时而非编译时检测
12. 数据库方言差异需要手动处理

典型的JDBC代码示例：

// JDBC实体加载示例
public Category findById(Long id) {
    String sql = "SELECT id, name, parent_id, path, created_time, modified_time FROM category WHERE id = ?";
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {
        ps.setLong(1, id);
        try (ResultSet rs = ps.executeQuery()) {
            if (rs.next()) {
                Category category = new Category();
                category.setId(rs.getLong("id"));
                category.setName(rs.getString("name"));
                category.setParentId(rs.getLong("parent_id"));
                category.setPath(rs.getString("path"));
                category.setCreatedTime(rs.getTimestamp("created_time").toLocalDateTime());
                category.setModifiedTime(rs.getTimestamp("modified_time").toLocalDateTime());

                // 如果需要加载父类别，必须手动执行另一次查询
                if (category.getParentId() != null) {
                    category.setParent(findById(category.getParentId()));
                }

                return category;
            }
        }
    } catch (SQLException e) {
        throw new RuntimeException("Failed to find category by id: " + id, e);
    }
    return null;
}

// JDBC保存示例
public void save(Category category) {
    String sql = "INSERT INTO category (name, parent_id, path, created_time, modified_time) VALUES (?, ?, ?, ?, ?)";
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
        ps.setString(1, category.getName());
        if (category.getParentId() != null) {
            ps.setLong(2, category.getParentId());
        } else {
            ps.setNull(2, Types.BIGINT);
        }
        ps.setString(3, category.getPath());
        ps.setTimestamp(4, Timestamp.valueOf(category.getCreatedTime()));
        ps.setTimestamp(5, Timestamp.valueOf(category.getModifiedTime()));

        int rows = ps.executeUpdate();
        if (rows > 0) {
            try (ResultSet rs = ps.getGeneratedKeys()) {
                if (rs.next()) {
                    category.setId(rs.getLong(1));
                }
            }
        }
    } catch (SQLException e) {
        throw new RuntimeException("Failed to save category: " + category, e);
    }
}