MySQL 存储过程、游标、存储函数与触发器最佳实践

┌─────────────────────────────────────────────────────────────┐
│                     普通 SQL 执行流程                          │
├─────────────────────────────────────────────────────────────┤
│  客户端 → 发送SQL语句 → 数据库解析 → 编译 → 优化 → 执行 → 返回  │
│  （每次都要重复上述全部步骤）                                    │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│                   存储过程执行流程                              │
├─────────────────────────────────────────────────────────────┤
│  第一次：客户端 → CALL → 解析 → 编译 → 优化 → 执行 → 返回      │
│  后续次：客户端 → CALL → 直接执行已编译代码 → 返回               │
│  （省去了解析、编译、优化步骤）                                  │
└─────────────────────────────────────────────────────────────┘

-- 不用存储过程：客户端需要发送多条SQL
SELECT balance FROM account WHERE id = 1;
-- 客户端判断余额是否足够
UPDATE account SET balance = balance - 100 WHERE id = 1;
UPDATE account SET balance = balance + 100 WHERE id = 2;
INSERT INTO transfer_log VALUES (...);
-- 用存储过程：一条命令搞定
CALL TransferMoney(1, 2, 100.00, @status);

-- 修改结束符（因为存储过程内部有分号）
DELIMITER //
CREATE PROCEDURE 过程名([参数列表])
BEGIN
    -- SQL 语句和逻辑
END //
-- 恢复结束符
DELIMITER ;

CREATE PROCEDURE 过程名(
    IN    输入参数名  数据类型,    -- 调用方传入，过程内只读
    OUT   输出参数名  数据类型,    -- 过程内写入，调用方获取
    INOUT 双向参数名  数据类型     -- 调用方传入，过程内修改后调用方可获取
)

DELIMITER //
CREATE PROCEDURE HelloWorld()
BEGIN
    SELECT 'Hello, Stored Procedure!' AS message;
END //
DELIMITER ;
-- 调用
CALL HelloWorld();

+---------------------------+
| message                   |
+---------------------------+
| Hello, Stored Procedure!  |
+---------------------------+

DELIMITER //
CREATE PROCEDURE GetUserById(IN p_id INT)
BEGIN
    SELECT id, username, email, create_time
    FROM users
    WHERE id = p_id;
END //
DELIMITER ;
-- 调用
CALL GetUserById(1);
CALL GetUserById(5);

DELIMITER //
CREATE PROCEDURE GetUserCount(OUT p_count INT)
BEGIN
    SELECT COUNT(*) INTO p_count FROM users;
END //
DELIMITER ;
-- 调用
CALL GetUserCount(@total);
SELECT @total AS user_count;

DELIMITER //
CREATE PROCEDURE Accumulate(INOUT p_counter INT, IN p_increment INT)
BEGIN
    SET p_counter = p_counter + p_increment;
END //
DELIMITER ;
-- 调用
SET @counter = 100;
CALL Accumulate(@counter, 50);
SELECT @counter;  -- 输出 150
CALL Accumulate(@counter, 30);
SELECT @counter;  -- 输出 180

DELIMITER //
CREATE PROCEDURE EvaluateScore(IN p_score INT, OUT p_level VARCHAR(20))
BEGIN
    IF p_score >= 90 THEN
        SET p_level = '优秀';
    ELSEIF p_score >= 80 THEN
        SET p_level = '良好';
    ELSEIF p_score >= 60 THEN
        SET p_level = '及格';
    ELSE
        SET p_level = '不及格';
    END IF;
END //
DELIMITER ;
-- 调用
CALL EvaluateScore(85, @level);
SELECT @level;  -- 输出：良好

DELIMITER //
CREATE PROCEDURE BatchUpdateStatus()
BEGIN
    DECLARE v_id INT;
    DECLARE v_done INT DEFAULT 0;
    -- 声明游标
    DECLARE cur CURSOR FOR
        SELECT id FROM orders WHERE status = 'pending' AND create_time < DATE_SUB(NOW(), INTERVAL 30 DAY);
    -- 声明结束处理器
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN cur;
    read_loop: LOOP
        FETCH cur INTO v_id;
        IF v_done = 1 THEN
            LEAVE read_loop;
        END IF;
        -- 将超过30天的待处理订单自动取消
        UPDATE orders SET status = 'cancelled' WHERE id = v_id;
    END LOOP;
    CLOSE cur;
END //
DELIMITER ;
-- 调用
CALL BatchUpdateStatus();

DELIMITER //
CREATE PROCEDURE TransferMoney(
    IN p_from_id INT,
    IN p_to_id INT,
    IN p_amount DECIMAL(10,2),
    OUT p_status VARCHAR(50)
)
BEGIN
    -- 声明异常处理：发生任何 SQL 异常时回滚
    DECLARE EXIT HANDLER FOR SQLEXCEPTION
    BEGIN
        ROLLBACK;
        SET p_status = '转账失败：发生异常';
    END;
    -- 余额校验
    DECLARE v_balance DECIMAL(10,2);
    SELECT balance INTO v_balance FROM account WHERE id = p_from_id FOR UPDATE;
    IF v_balance < p_amount THEN
        SET p_status = '转账失败：余额不足';
    ELSE
        START TRANSACTION;
            UPDATE account SET balance = balance - p_amount WHERE id = p_from_id;
            UPDATE account SET balance = balance + p_amount WHERE id = p_to_id;
            INSERT INTO transfer_log(from_id, to_id, amount, transfer_time)
            VALUES (p_from_id, p_to_id, p_amount, NOW());
        COMMIT;
        SET p_status = '转账成功';
    END IF;
END //
DELIMITER ;

-- 遇到异常后继续执行后续语句
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION SET @err = 1;
-- 遇到异常后退出当前 BEGIN...END 块
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
    ROLLBACK;
    SELECT '执行出错' AS error_msg;
END;
-- 处理特定错误码
DECLARE CONTINUE HANDLER FOR 1062  -- 重复键错误
    SET @duplicate = 1;

-- ========== 查看 ==========
-- 查看当前数据库所有存储过程
SHOW PROCEDURE STATUS WHERE Db = 'your_database';
-- 查看某个存储过程的创建语句
SHOW CREATE PROCEDURE TransferMoney;
-- 从系统表查询
SELECT * FROM information_schema.ROUTINES
WHERE ROUTINE_SCHEMA = 'your_database'
  AND ROUTINE_TYPE = 'PROCEDURE';
-- ========== 修改 ==========
-- MySQL 不支持 ALTER PROCEDURE 修改过程体
-- 只能先删除再重新创建
DROP PROCEDURE IF EXISTS TransferMoney;
-- 然后重新 CREATE PROCEDURE ...
-- ========== 删除 ==========
DROP PROCEDURE IF EXISTS GetUserById;

① DECLARE  →  声明游标（绑定一条 SELECT 语句，此时不执行）
② OPEN     →  打开游标（执行 SELECT，将结果集加载到内存）
③ FETCH    →  逐行读取（将当前行数据存入变量，指针下移）
④ CLOSE    →  关闭游标（释放结果集占用的内存）

DELIMITER //
CREATE PROCEDURE cursor_demo()
BEGIN
    -- 1. 声明局部变量（用于存放每行数据）
    DECLARE v_id   INT;
    DECLARE v_name VARCHAR(50);
    DECLARE v_done INT DEFAULT 0;  -- 游标结束标志
    -- 2. 声明游标（绑定 SELECT，注意：此时并不执行查询）
    DECLARE cur CURSOR FOR
        SELECT id, username FROM users WHERE status = 1;
    -- 3. 声明结束处理器（FETCH 到末尾触发 NOT FOUND，将 v_done 置 1）
    --    注意：HANDLER 必须声明在游标之后
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    -- 4. 打开游标（此时才真正执行 SELECT 查询）
    OPEN cur;
    -- 5. 循环读取
    read_loop: LOOP
        FETCH cur INTO v_id, v_name;  -- 读取当前行到变量，指针后移
        IF v_done = 1 THEN            -- 没有更多行，退出循环
            LEAVE read_loop;
        END IF;
        -- 处理当前行的业务逻辑
        -- ...
    END LOOP read_loop;
    -- 6. 关闭游标（释放资源）
    CLOSE cur;
END //
DELIMITER ;

DELIMITER //
CREATE PROCEDURE sp_send_notification_log()
BEGIN
    DECLARE v_user_id INT;
    DECLARE v_email   VARCHAR(100);
    DECLARE v_done    INT DEFAULT 0;
    DECLARE cur CURSOR FOR
        SELECT id, email FROM users WHERE is_active = 1;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN cur;
    user_loop: LOOP
        FETCH cur INTO v_user_id, v_email;
        IF v_done = 1 THEN
            LEAVE user_loop;
        END IF;
        INSERT INTO notification_log(user_id, email, send_time, content)
        VALUES (v_user_id, v_email, NOW(), '系统有重要通知，请及时查看。');
    END LOOP user_loop;
    CLOSE cur;
END //
DELIMITER ;

DELIMITER //
CREATE PROCEDURE sp_update_user_points()
BEGIN
    DECLARE v_id      INT;
    DECLARE v_orders  INT;
    DECLARE v_done    INT DEFAULT 0;
    DECLARE cur CURSOR FOR
        SELECT u.id, COUNT(o.id) AS order_count
        FROM users u
        LEFT JOIN orders o ON u.id = o.user_id AND o.status = 'completed'
        GROUP BY u.id;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN cur;
    point_loop: LOOP
        FETCH cur INTO v_id, v_orders;
        IF v_done = 1 THEN
            LEAVE point_loop;
        END IF;
        -- 根据完成订单数量差异化增加积分
        IF v_orders >= 100 THEN
            UPDATE users SET points = points + 500 WHERE id = v_id;
        ELSEIF v_orders >= 50 THEN
            UPDATE users SET points = points + 200 WHERE id = v_id;
        ELSEIF v_orders >= 10 THEN
            UPDATE users SET points = points + 50 WHERE id = v_id;
        END IF;
    END LOOP point_loop;
    CLOSE cur;
END //
DELIMITER ;

DELIMITER //
CREATE PROCEDURE sp_sync_department_stats()
BEGIN
    DECLARE v_dept_id    INT;
    DECLARE v_emp_count  INT;
    DECLARE v_avg_salary DECIMAL(10,2);
    DECLARE v_done       INT DEFAULT 0;
    DECLARE dept_cur CURSOR FOR
        SELECT id FROM departments;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN dept_cur;
    dept_loop: LOOP
        FETCH dept_cur INTO v_dept_id;
        IF v_done = 1 THEN
            LEAVE dept_loop;
        END IF;
        -- 对每个部门单独做聚合查询
        SELECT COUNT(*), IFNULL(AVG(salary), 0)
        INTO v_emp_count, v_avg_salary
        FROM employees
        WHERE department_id = v_dept_id;
        -- 更新统计表（存在则更新，不存在则插入）
        INSERT INTO department_stats(dept_id, emp_count, avg_salary, updated_at)
        VALUES (v_dept_id, v_emp_count, v_avg_salary, NOW())
        ON DUPLICATE KEY UPDATE
            emp_count  = v_emp_count,
            avg_salary = v_avg_salary,
            updated_at = NOW();
    END LOOP dept_loop;
    CLOSE dept_cur;
END //
DELIMITER ;

-- ❌ 用游标逐行更新（慢，不推荐）
-- 声明游标 → 循环 FETCH → 逐条 UPDATE ...
-- ✅ 用一条集合 SQL 批量更新（快，推荐）
UPDATE orders
SET status = 'cancelled'
WHERE status = 'pending'
  AND create_time < DATE_SUB(NOW(), INTERVAL 30 DAY);

-- 内置函数的使用方式
SELECT LENGTH(username), UPPER(email) FROM users;
-- 自定义存储函数可以做到完全一样的事
SELECT fn_mask_phone(phone), fn_get_age_group(age) FROM users;
SELECT * FROM users WHERE fn_is_vip(id) = 1;

DELIMITER //
CREATE FUNCTION 函数名(参数1 数据类型, 参数2 数据类型, ...)
RETURNS 返回值类型
[特性关键字]
BEGIN
    -- 函数体（只有 IN 参数，没有 OUT/INOUT）
    RETURN 返回值;
END //
DELIMITER ;

SET GLOBAL log_bin_trust_function_creators = 1;

-- 存储过程：必须用 CALL，不能嵌入 SQL
CALL sp_get_user_by_id(1);
-- 存储函数：像内置函数一样随处可用
SELECT fn_mask_phone('13812345678');                -- 直接查询
SELECT id, fn_mask_phone(phone) FROM users;         -- SELECT 字段中
SELECT * FROM users WHERE fn_get_age_group(age) = '青年';  -- WHERE 条件中
INSERT INTO report SELECT fn_calc_score(id) FROM users;    -- INSERT...SELECT 中

DELIMITER //
CREATE FUNCTION fn_mask_phone(p_phone VARCHAR(20))
RETURNS VARCHAR(20)
DETERMINISTIC
BEGIN
    -- 13812345678 → 138****5678
    IF p_phone IS NULL OR LENGTH(p_phone) != 11 THEN
        RETURN p_phone;  -- 不符合格式，原样返回
    END IF;
    RETURN CONCAT(
        LEFT(p_phone, 3),
        '****',
        RIGHT(p_phone, 4)
    );
END //
DELIMITER ;
-- 使用：直接嵌入 SELECT
SELECT id, username, fn_mask_phone(phone) AS masked_phone FROM users;

DELIMITER //
CREATE FUNCTION fn_get_age_group(p_age INT)
RETURNS VARCHAR(10)
DETERMINISTIC
BEGIN
    DECLARE v_group VARCHAR(10);
    CASE
        WHEN p_age < 18 THEN SET v_group = '未成年';
        WHEN p_age < 30 THEN SET v_group = '青年';
        WHEN p_age < 50 THEN SET v_group = '中年';
        ELSE                  SET v_group = '老年';
    END CASE;
    RETURN v_group;
END //
DELIMITER ;
-- 使用：嵌入 ORDER BY 和 GROUP BY 也没问题
SELECT fn_get_age_group(age) AS age_group, COUNT(*) AS cnt
FROM users
GROUP BY fn_get_age_group(age);

DELIMITER //
CREATE FUNCTION fn_get_user_total_amount(p_user_id INT)
RETURNS DECIMAL(12,2)
READS SQL DATA
BEGIN
    DECLARE v_total DECIMAL(12,2) DEFAULT 0.00;
    SELECT IFNULL(SUM(amount), 0.00)
    INTO v_total
    FROM orders
    WHERE user_id = p_user_id
      AND status = 'completed';
    RETURN v_total;
END //
DELIMITER ;
-- 使用：在 WHERE 中筛选高价值用户
SELECT id, username, fn_get_user_total_amount(id) AS total_amount
FROM users
WHERE fn_get_user_total_amount(id) > 10000
ORDER BY total_amount DESC;

DELIMITER //
CREATE FUNCTION fn_fibonacci(n INT)
RETURNS BIGINT
DETERMINISTIC
BEGIN
    IF n <= 0 THEN RETURN 0; END IF;
    IF n = 1  THEN RETURN 1; END IF;
    RETURN fn_fibonacci(n - 1) + fn_fibonacci(n - 2);
END //
DELIMITER ;
-- 使用前需设置最大递归深度（默认为0，即不允许递归）
SET max_sp_recursion_depth = 20;
SELECT fn_fibonacci(10);  -- 输出 55

-- 查看所有存储函数
SHOW FUNCTION STATUS WHERE Db = 'your_database';
-- 查看函数定义
SHOW CREATE FUNCTION fn_mask_phone;
-- 从系统表查询
SELECT ROUTINE_NAME, ROUTINE_TYPE, DTD_IDENTIFIER, ROUTINE_DEFINITION
FROM information_schema.ROUTINES
WHERE ROUTINE_SCHEMA = 'your_database'
  AND ROUTINE_TYPE = 'FUNCTION';
-- 删除函数
DROP FUNCTION IF EXISTS fn_mask_phone;

DELIMITER //
CREATE TRIGGER trigger_name
{BEFORE | AFTER} {INSERT | UPDATE | DELETE}
ON table_name
FOR EACH ROW
BEGIN
    -- 触发器逻辑
END //
DELIMITER ;

-- 在 BEFORE INSERT 中预处理数据
SET NEW.username   = LOWER(NEW.username);   -- 用户名统一转小写
SET NEW.create_time = NOW();                 -- 自动填充创建时间

-- 操作日志表
CREATE TABLE operation_log (
    id           INT AUTO_INCREMENT PRIMARY KEY,
    table_name   VARCHAR(50)  NOT NULL,
    operation    VARCHAR(20)  NOT NULL,
    record_id    INT,
    operate_time DATETIME     NOT NULL,
    detail       TEXT
);
DELIMITER //
CREATE TRIGGER trg_users_after_insert
AFTER INSERT ON users
FOR EACH ROW
BEGIN
    INSERT INTO operation_log(table_name, operation, record_id, operate_time, detail)
    VALUES (
        'users',
        'INSERT',
        NEW.id,
        NOW(),
        CONCAT('新增用户：', NEW.username, '，邮箱：', NEW.email)
    );
END //
DELIMITER ;

DELIMITER //
CREATE TRIGGER trg_users_after_update
AFTER UPDATE ON users
FOR EACH ROW
BEGIN
    -- 只有 status 字段变更时才写日志，避免无效日志
    IF OLD.status != NEW.status THEN
        INSERT INTO operation_log(table_name, operation, record_id, operate_time, detail)
        VALUES (
            'users',
            'UPDATE',
            NEW.id,
            NOW(),
            CONCAT('用户[', NEW.username, ']状态变更：', OLD.status, ' → ', NEW.status)
        );
    END IF;
END //
DELIMITER ;

DELIMITER //
CREATE TRIGGER trg_orders_before_insert
BEFORE INSERT ON orders
FOR EACH ROW
BEGIN
    -- 校验：订单金额不能为负数
    IF NEW.amount <= 0 THEN
        SIGNAL SQLSTATE '45000'
            SET MESSAGE_TEXT = '订单金额必须大于0';
    END IF;
    -- 自动填充创建时间
    IF NEW.create_time IS NULL THEN
        SET NEW.create_time = NOW();
    END IF;
    -- 自动生成订单号
    IF NEW.order_no IS NULL OR NEW.order_no = '' THEN
        SET NEW.order_no = CONCAT(
            'ORD',
            DATE_FORMAT(NOW(), '%Y%m%d%H%i%s'),
            LPAD(NEW.user_id, 6, '0')
        );
    END IF;
END //
DELIMITER ;

DELIMITER //
CREATE TRIGGER trg_orders_after_delete
AFTER DELETE ON orders
FOR EACH ROW
BEGIN
    -- 被删除的数据自动归档到备份表
    INSERT INTO orders_archive(
        id, user_id, amount, status, create_time, archived_at
    )
    VALUES (
        OLD.id,
        OLD.user_id,
        OLD.amount,
        OLD.status,
        OLD.create_time,
        NOW()
    );
END //
DELIMITER ;

DELIMITER //
-- 订单状态只能单向流转：pending → paid → shipped → completed
-- 已完成或已取消的订单不允许再修改状态
CREATE TRIGGER trg_orders_before_update
BEFORE UPDATE ON orders
FOR EACH ROW
BEGIN
    IF OLD.status = 'completed' AND NEW.status != 'completed' THEN
        SIGNAL SQLSTATE '45000'
            SET MESSAGE_TEXT = '已完成的订单不允许修改状态';
    END IF;
    IF OLD.status = 'cancelled' THEN
        SIGNAL SQLSTATE '45000'
            SET MESSAGE_TEXT = '已取消的订单不允许再操作';
    END IF;
END //
DELIMITER ;

以执行一条 UPDATE orders SET status='paid' WHERE id=1 为例：
┌──────────────────────────────────────────────────────────────────┐
│  1. BEFORE UPDATE 触发器执行                                      │
│     → 可以通过 SET NEW.xxx 修改即将写入的值                        │
│     → 可以通过 SIGNAL 抛错阻止本次操作（整个语句回滚）              │
├──────────────────────────────────────────────────────────────────┤
│  2. 实际执行 UPDATE 语句（数据写入磁盘）                            │
├──────────────────────────────────────────────────────────────────┤
│  3. AFTER UPDATE 触发器执行                                       │
│     → 数据已确定写入，适合做日志记录、数据同步                      │
│     → 若此处抛错，整个事务（含 UPDATE）一起回滚                    │
└──────────────────────────────────────────────────────────────────┘

-- 查看当前数据库所有触发器
SHOW TRIGGERS FROM your_database;
-- 查看特定表的触发器
SHOW TRIGGERS FROM your_database LIKE 'orders';
-- 查看触发器定义
SHOW CREATE TRIGGER trg_users_after_insert;
-- 从系统表查询（可获取更详细的信息）
SELECT TRIGGER_NAME, EVENT_MANIPULATION, EVENT_OBJECT_TABLE,
       ACTION_TIMING, ACTION_STATEMENT
FROM information_schema.TRIGGERS
WHERE TRIGGER_SCHEMA = 'your_database';
-- 删除触发器
DROP TRIGGER IF EXISTS trg_users_after_insert;

2005年的架构：
┌─────────┐      ┌──────────────────┐
│  客户端  │ ──→  │   单体应用 + DB   │  ← 业务逻辑大量放在存储过程中
└─────────┘      └──────────────────┘
2020年的架构：
┌─────────┐      ┌─────────┐  ┌─────────┐  ┌─────────┐
│  客户端  │ ──→  │ 服务A   │  │ 服务B   │  │ 服务C   │
└─────────┘      └────┬────┘  └────┬────┘  └────┬────┘
                      │            │            │
                  ┌───┴───┐   ┌───┴───┐   ┌───┴───┐
                  │  DB-A  │  │  DB-B  │  │  DB-C  │
                  └───────┘   └───────┘   └───────┘

-- MySQL 的存储过程语法
DELIMITER //
CREATE PROCEDURE ...
BEGIN
    DECLARE v INT;
    ...
END //
-- Oracle 的存储过程语法（PL/SQL）
CREATE OR REPLACE PROCEDURE ...
IS
    v NUMBER;
BEGIN
    ...
END;
-- SQL Server 的存储过程语法（T-SQL）
CREATE PROCEDURE ...
AS
BEGIN
    DECLARE @v INT;
    ...
END

// MyBatis —— 用 XML 或注解写 SQL，逻辑在 Java 中
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(int id);
}
// JPA —— 连 SQL 都不用写
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByAgeGreaterThan(int age);
}

┌─────────────────────────────────────────────────────────────┐
│              什么时候用存储过程？                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ✅ 用：                                                    │
│     • 大批量数据处理（ETL、定时任务）                           │
│     • 对性能要求极致的数据库操作                               │
│     • 需要严格权限控制，不允许直接操作表                        │
│     • 数据库平台固定，不考虑迁移                               │
│                                                             │
│  ❌ 不用：                                                   │
│     • 常规 CRUD 业务逻辑                                     │
│     • 微服务架构项目                                          │
│     • 需要频繁迭代的业务                                      │
│     • 需要跨数据库平台的项目                                  │
│     • 团队没有熟悉存储过程的 DBA                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// 调用带输入输出参数的存储过程
try (Connection conn = dataSource.getConnection();
     CallableStatement cs = conn.prepareCall("{CALL GetUserCount(?)}")) {
    // 注册输出参数
    cs.registerOutParameter(1, Types.INTEGER);
    // 执行
    cs.execute();
    // 获取输出参数
    int count = cs.getInt(1);
    System.out.println("用户总数：" + count);
}

<!-- Mapper XML -->
<select id="getUserCount" statementType="CALLABLE" resultType="map">
    {CALL GetUserCount(#{count, mode=OUT, jdbcType=INTEGER})}
</select>

// Mapper 接口
@Mapper
public interface UserMapper {
    void getUserCount(Map<String, Object> params);
}
// 使用
Map<String, Object> params = new HashMap<>();
userMapper.getUserCount(params);
System.out.println(params.get("count"));

@Autowired
private JdbcTemplate jdbcTemplate;
public int getUserCount() {
    SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate)
        .withProcedureName("GetUserCount");
    Map<String, Object> result = call.execute();
    return (Integer) result.get("p_count");
}

@Entity
@NamedStoredProcedureQuery(
    name = "User.getUserCount",
    procedureName = "GetUserCount",
    parameters = {
        @StoredProcedureParameter(mode = ParameterMode.OUT, name = "p_count", type = Integer.class)
    }
)
public class User { ... }
// 调用
StoredProcedureQuery query = entityManager.createNamedStoredProcedureQuery("User.getUserCount");
query.execute();
Integer count = (Integer) query.getOutputParameterValue("p_count");

-- 推荐：动词 + 名词，前缀表明类型
sp_transfer_money        -- sp = stored procedure
sp_get_user_by_id
sp_batch_cancel_orders
sp_calculate_monthly_report
-- 不推荐
proc1
my_procedure
test

DELIMITER //
CREATE PROCEDURE sp_example(
    IN  p_user_id  INT,          -- 参数用 p_ 前缀
    OUT p_result   VARCHAR(50)
)
COMMENT '示例存储过程：简要说明功能'
BEGIN
    -- 局部变量用 v_ 前缀
    DECLARE v_count INT DEFAULT 0;
    DECLARE v_status VARCHAR(20);
    -- 业务逻辑...
    -- 1. 每个步骤加注释
    -- 2. 适当的错误处理
    -- 3. 避免嵌套过深（建议不超过3层）
END //
DELIMITER ;