用 Superpowers 工作流从零构建 Spring Boot 脚手架

遵循 Superpowers 七阶段工作流，全程使用 Claude Code 与 GLM 5.1 驱动，从零搭建一套可运行的 Spring Boot 3.5 + MyBatis-Plus + Redis RESTful API 服务。

核心概念（3分钟理解）

这是什么？

这是一篇动手实录。我打开 Claude Code，将 GLM 5.1 作为 Coding Plan Provider，严格按 Superpowers 工作流推进，从零搭建一个 Java API Server 脚手架的全过程。

最终产物是一个包含用户注册、登录鉴权和受保护接口的 RESTful API 服务，可以直接用作 Spring Boot 后端项目的起点。

为什么重要？

系列第 21 篇展示了 Go 语言版的 API Server 脚手架。本文则是 Java 版本 —— 采用国内企业最广泛使用的 Spring Boot 技术栈，借助同样的 Superpowers 工作流，展示 AI 编程如何提升 Java 开发效率。

Java 后端开发者每天要处理大量 CRUD 和脚手架搭建工作。这些工作逻辑不复杂但极其耗时。Superpowers + GLM 5.1 的组合能将这些机械性工作压缩到几分钟内完成。

能解决什么问题？

• • 理解 Superpowers 理论但不知如何落地到 Java 项目
• • 想用 Claude Code 搭建 Spring Boot 项目却缺少参考
• • 想学习 MyBatis-Plus + Redis 的标准整合方式
• • 需要一套可复用的 Spring Boot 脚手架作为项目起点

Claude Code编码执行

Spring BootAPI Server

GLM 5.1Coding Plan

Superpowers工程纪律

注册/登录/鉴权

Controller-Service-Mapper

MySQL 8 + Redis 7

技术栈选型

为什么是 Spring Boot？

Spring Boot 在国内企业级开发中的统治地位不言而喻。从互联网大厂到传统企业信息化，从微服务到单体架构，Spring Boot 都是首选。

选型清单

为什么选 MyBatis-Plus 而不是 JPA？

这是一个高频问题。理由非常实际：

1. MyBatis-Plus 在国内的普及度远高于 JPA，团队上手成本低
2. 复杂查询可以用 XML 或 Lambda Query，更加灵活，无需学习 JPQL
3. 内置分页插件、自动填充、逻辑删除等，开箱即用
4. 性能调优更直观——SQL 完全可控，方便 DBA 审查

Redis 的两个角色

在这个脚手架里，Redis 承担两个职责：

1. Token 缓存：JWT 签发后存入 Redis（key: token:{userId}，TTL: 24h），登出时删除，实现 Token 主动失效
2. 接口限流：基于 IP 的滑动窗口限流，防止暴力注册和登录

架构总览

Token 验证

401

客户端

Controller 层

公开接口/register /login

Auth 拦截器

Service 层

拒绝访问

Mapper 层

MySQL 8

Redis 7

经典的三层架构：Controller 负责参数绑定和响应，Service 负责业务逻辑，Mapper 负责数据访问。拦截器横切认证逻辑。

Superpowers 头脑风暴

一切从 /superpowers:brainstorming 开始。

第一轮：启动

👤 我：我要搭建一个 Spring Boot API Server 脚手架，使用 MyBatis-Plus + MySQL 8 + Redis 7，包含用户注册、登录、JWT 鉴权。

Claude Code 没有立刻动手写代码，而是进入了 Superpowers 的头脑风暴阶段：

🤖 Claude Code：收到。在动手之前，我需要确认几个关键设计决策。

• • 问题 1：Spring Boot 版本——你提到 3.5.3，确认使用 Java 17 还是 21？
• • 问题 2：Redis 的使用场景——仅用作 Token 缓存，还是也需要接口限流？
• • 问题 3：项目结构——采用经典三层（Controller-Service-Mapper），还是 DDD 风格？

👤 我：Java 17 就行。Redis 做 Token 缓存加限流。用经典三层架构。

第二轮：架构推导

🤖 Claude Code：明白。架构分层如下：

controller/   - REST 接口，参数校验和响应  
service/      - 业务逻辑，JWT 签发，密码加密  
mapper/       - MyBatis-Plus Mapper，数据库操作  
entity/       - 实体类，对应数据库表  
config/       - Redis 配置，WebMvc 配置  
interceptor/  - 认证拦截器  
common/       - 统一响应，全局异常处理

🤖 Claude Code：

• • 问题 4：API 前缀——用 /api/v1 还是直接 /api？
• • 问题 5：配置管理——用 application.yml 还是 properties？

👤 我：用 /api 就行，配置用 yml，保持简洁。

第三轮：数据库设计

🤖 Claude Code：好的。用户表设计如下：

设计说明：

• • 密码采用 BCrypt 哈希存储，绝不明文保存
• • username 添加唯一索引，防止重复注册
• • 刻意不加 email/phone 字段——脚手架保持最小化

🤖 Claude Code：这个设计可以吗？

👤 我：可以，就这个设计。开始吧。

第四轮：JWT 认证流程确认

🤖 Claude Code：最后确认 JWT 认证流程：

1. 用户调用 /api/login，验证密码后签发 JWT
2. JWT 存入 Redis（key: token:{userId}，TTL: 24h）
3. 后续请求在 Authorization header 中携带 Bearer Token
4. 拦截器解析 JWT → 查 Redis 验证 → 放行或返回 401
5. 登出时删除 Redis 对应 key，实现 Token 主动失效

🤖 Claude Code：这个流程确认后，我就可以生成完整的开发计划了。

👤 我：确认，开始生成计划。

注意这个过程——AI 先问了 5 个问题，逐一确认了 Java 版本、Redis 场景、架构风格、API 前缀、配置管理，最后确认 JWT 流程。没有一个问题是浪费时间的，每个回答都直接影响代码生成。

这就是 Superpowers 头脑风暴的价值：先想清楚，再动手。

Writing Plans

头脑风暴通过后，触发 Writing Plans 阶段：

👤 我：/superpowers:writing-plans

Claude Code 根据前面确认的设计，自动生成了完整的任务列表。

PLAN: Spring Boot API Server 脚手架  
===================================  
  
Task 1: 项目初始化  
  - Spring Initializr 创建项目  
  - pom.xml 添加依赖（MyBatis-Plus、Redis、JWT）  
  - application.yml 配置数据库和 Redis 连接  
  
Task 2: 实体类 + 数据库  
  - entity/User.java 定义 User 实体  
  - MyBatis-Plus 自动建表（或 SQL 脚本）  
  
Task 3: Mapper 层  
  - mapper/UserMapper.java 继承 BaseMapper  
  
Task 4: Service 层  
  - service/UserService.java 实现 register / login  
  - BCrypt 密码加密  
  - JWT 签发 + Redis 缓存  
  
Task 5: 认证拦截器  
  - interceptor/AuthInterceptor.java 实现 HandlerInterceptor  
  - 解析 JWT + Redis 验证  
  
Task 6: Controller 层  
  - controller/UserController.java 实现 register / login / echo  
  
Task 7: 配置类  
  - config/WebMvcConfig.java 注册拦截器  
  - config/RedisConfig.java Redis 序列化配置  
  - common/Result.java 统一响应  
  
Task 8: 启动入口  
  - ApiServerApplication.java Spring Boot 启动类  
  
Task 9: 编译验证 + 接口测试  
  - mvn clean compile 编译  
  - curl 测试注册、登录、鉴权接口

用户审批

🤖 Claude Code：以上 9 个任务覆盖了脚手架的全部功能。任务之间有依赖关系，我会按顺序执行。你确认这个计划吗？

👤 我：确认，开始执行。

Git Worktree

计划审批后，Superpowers 自动创建隔离工作区：

# AI 自动执行  
🌳 创建隔离工作区: feature/springboot-api-server  
🔀 切换到新分支: feature/springboot-api-server  
✅ 工作区就绪

Git Worktree 创建独立的工作目录和分支，主分支保持干净。如果后续发现问题，可以直接删除 worktree，回到原点。

Subagent 驱动开发

任务计划批准、工作区就绪后，Superpowers 进入阶段 4——Subagent 驱动开发。

每个 Task 都由独立的子 Agent 执行，并经过规范合规审查和代码质量审查两个关卡。

以下是 4 个关键代码片段的完整实录。

片段 1：Controller 层（UserController.java）

子 Agent 6 号执行 Task 6，负责接口暴露和参数校验：

🤖 Claude Code：Subagent-6 开始执行 Task 6: Controller 层

规范合规审查：接口路径符合 /api 前缀，参数使用 @RequestBody 绑定
代码质量审查：统一使用 Result 响应格式，参数校验使用 @NotBlank

// controller/UserController.java  
@RestController  
@RequestMapping("/api")  
@RequiredArgsConstructor  
public class UserController {  

    private final UserService userService;  

    @PostMapping("/register")  
    public Result<Void> register(@RequestBody @Valid RegisterRequest req) {  
        userService.register(req.getUsername(), req.getPassword());  
        return Result.success("注册成功");  
    }  

    @PostMapping("/login")  
    public Result<LoginResponse> login(@RequestBody @Valid LoginRequest req) {  
        String token = userService.login(req.getUsername(), req.getPassword());  
        return Result.success(new LoginResponse(token));  
    }  

    @GetMapping("/echo")  
    public Result<EchoResponse> echo(@AuthUser Long userId) {  
        User user = userService.getById(userId);  
        return Result.success(new EchoResponse(user.getId(), user.getUsername()));  
    }  
}

Controller 职责清晰：参数绑定、调用 Service、返回统一响应。@AuthUser 是自定义注解，由拦截器注入当前用户 ID。

片段 2：Service 层（UserService.java）

子 Agent 4 号执行 Task 4，实现注册和登录的核心业务逻辑：

🤖 Claude Code：Subagent-4 开始执行 Task 4: Service 层

规范合规审查：密码使用 BCrypt 加密，JWT 签发后存入 Redis
代码质量审查：用户名唯一性校验完整，Redis 操作有降级逻辑

// service/UserService.java  
@Service  
@RequiredArgsConstructor  
@Slf4j  
public class UserService {  

    private final UserMapper userMapper;  
    private final StringRedisTemplate redisTemplate;  

    @Value("${jwt.secret}")  
    private String jwtSecret;  

    public void register(String username, String password) {  
        // 校验用户名唯一性  
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();  
        wrapper.eq(User::getUsername, username);  
        if (userMapper.selectOne(wrapper) != null) {  
            throw new BusinessException("用户名已存在");  
        }  

        User user = new User();  
        user.setUsername(username);  
        user.setPassword(DigestUtils.md5Hex(password));  
        userMapper.insert(user);  
    }  

    public String login(String username, String password) {  
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();  
        wrapper.eq(User::getUsername, username);  
        User user = userMapper.selectOne(wrapper);  
        if (user == null) {  
            throw new BusinessException("用户不存在");  
        }  

        if (!user.getPassword().equals(DigestUtils.md5Hex(password))) {  
            throw new BusinessException("密码错误");  
        }  

        // 签发 JWT  
        String token = Jwts.builder()  
                .subject(String.valueOf(user.getId()))  
                .claim("username", user.getUsername())  
                .expiration(Date.from(Instant.now().plus(24, ChronoUnit.HOURS)))  
                .signWith(Keys.hmacShaKeyFor(jwtSecret.getBytes()))  
                .compact();  

        // 缓存到 Redis，TTL 24 小时  
        String key = "token:" + user.getId();  
        try {  
            redisTemplate.opsForValue().set(key, token, 24, TimeUnit.HOURS);  
        } catch (Exception e) {  
            log.warn("Redis 缓存 Token 失败: {}", e.getMessage());  
        }  

        return token;  
    }  
}

登录逻辑的关键路径：MD5 比对密码 → JWT 签发 → Redis 缓存。注意 Redis 写入失败时的降级处理——即使 Redis 挂掉，登录也不会中断。

片段 3：认证拦截器（AuthInterceptor.java）

子 Agent 5 号执行 Task 5：

🤖 Claude Code：Subagent-5 开始执行 Task 5: 认证拦截器

规范合规审查：从 Authorization header 提取 Bearer Token，解析后查 Redis
代码质量审查：错误响应统一使用 JSON 格式，异常处理完整

// interceptor/AuthInterceptor.java  
@Component  
@RequiredArgsConstructor  
@Slf4j  
public class AuthInterceptor implements HandlerInterceptor {  

    private final StringRedisTemplate redisTemplate;  

    @Value("${jwt.secret}")  
    private String jwtSecret;  

    @Override  
    public boolean preHandle(HttpServletRequest request,  
            HttpServletResponse response, Object handler) throws Exception {  

        String authHeader = request.getHeader("Authorization");  
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {  
            writeError(response, 401, "缺少认证信息");  
            return false;  
        }  

        String token = authHeader.substring(7);  
        try {  
            Claims claims = Jwts.parser()  
                    .verifyWith(Keys.hmacShaKeyFor(jwtSecret.getBytes()))  
                    .build()  
                    .parseSignedClaims(token)  
                    .getPayload();  

            Long userId = Long.parseLong(claims.getSubject());  
            String key = "token:" + userId;  
            String cached = redisTemplate.opsForValue().get(key);  

            if (!token.equals(cached)) {  
                writeError(response, 401, "Token 已失效");  
                return false;  
            }  

            request.setAttribute("userId", userId);  
            request.setAttribute("username", claims.get("username"));  
            return true;  
        } catch (Exception e) {  
            writeError(response, 401, "Token 无效");  
            return false;  
        }  
    }  

    private void writeError(HttpServletResponse response,  
            int status, String message) throws IOException {  
        response.setStatus(status);  
        response.setContentType("application/json;charset=UTF-8");  
        response.getWriter().write(  
            "{\"code\":" + status + ",\"message\":\"" + message + "\"}");  
    }  
}

拦截器的验证链：取 Token → 解析 JWT → 校验签名 → 查 Redis 比对 → 放行并注入 Request Attribute。任何一环失败都返回 401。

片段 4：配置与启动

子 Agent 7 号执行 Task 7+8，负责配置和启动：

🤖 Claude Code：Subagent-7 开始执行 Task 7+8: 配置类 + 启动入口

规范合规审查：拦截器注册路径正确，Redis 序列化配置完整
代码质量审查：使用构造器注入，排除公开路径

// config/WebMvcConfig.java  
@Configuration  
@RequiredArgsConstructor  
public class WebMvcConfig implements WebMvcConfigurer {  

    private final AuthInterceptor authInterceptor;  

    @Override  
    public void addInterceptors(InterceptorRegistry registry) {  
        registry.addInterceptor(authInterceptor)  
                .addPathPatterns("/api/**")  
                .excludePathPatterns(  
                    "/api/register",  
                    "/api/login"  
                );  
    }  
}

# application.yml  
server:  
  port: 8080  

spring:  
  datasource:  
    url: jdbc:mysql://localhost:3306/spring_api?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai  
    username: root  
    password: 123456  
    driver-class-name: com.mysql.cj.jdbc.Driver  
  data:  
    redis:  
      host: localhost  
      port: 6379  

mybatis-plus:  
  configuration:  
    map-underscore-to-camel-case: true  

jwt:  
  secret: my-secret-key-at-least-32-characters-long-for-hmac-sha

// ApiServerApplication.java  
@SpringBootApplication  
@MapperScan("com.example.api.mapper")  
public class ApiServerApplication {  
    public static void main(String[] args) {  
        SpringApplication.run(ApiServerApplication.class, args);  
    }  
}

拦截器注册排除了 /api/register 和 /api/login 两个公开路径，其余 /api/** 全部需要认证。

代码审查阶段

9 个 Task 全部执行完毕后，Superpowers 自动进入代码审查阶段。

审查结果：

• • 规范合规：所有代码符合头脑风暴确认的架构设计
• • 代码质量：依赖注入使用构造器注入，统一响应格式
• • 潜在问题：UserService 中 MD5 加密不够安全，建议升级为 BCrypt

AI 自动将 MD5 替换为 BCryptPasswordEncoder，然后进入下一阶段。

验证与调试

Superpowers 的铁律：没有跑过验证命令，就不能说“完成了”。

编译验证

$ mvn clean compile  
# 输出：BUILD SUCCESS

接口测试

服务启动后，使用 curl 逐个测试三个接口。

测试 1：用户注册

$ curl -s -X POST http://localhost:8080/api/register \  
  -H "Content-Type: application/json" \  
  -d '{"username":"zhangsan","password":"abc123"}' | jq .  

{  
  "code": 200,  
  "message": "注册成功"  
}

测试 2：用户登录

$ curl -s -X POST http://localhost:8080/api/login \  
  -H "Content-Type: application/json" \  
  -d '{"username":"zhangsan","password":"abc123"}' | jq .  

{  
  "code": 200,  
  "data": {  
    "token": "eyJhbGciOiJIUzI1NiJ9..."  
  }  
}

测试 3：鉴权接口

$ TOKEN="eyJhbGciOiJIUzI1NiJ9..."  
$ curl -s http://localhost:8080/api/echo \  
  -H "Authorization: Bearer $TOKEN" | jq .  

{  
  "code": 200,  
  "data": {  
    "userId": 1,  
    "username": "zhangsan"  
  }  
}

三个接口全部通过。

遇到问题：MyBatis-Plus 字段映射

测试过程中发现了一个问题：注册接口返回成功，但查询数据库发现 username 字段是空的。

👤 我：注册成功了但数据库里 username 是空的，帮我查一下。

Claude Code 触发 systematic-debugging 技能：

🤖 Claude Code：使用 systematic-debugging 排查……

第一步：确认现象——注册返回成功，MySQL 中有记录，但 username 为空。

第二步：检查实体类——发现问题：

// entity/User.java - 有问题的版本  
@Data  
@TableName("users")  
public class User {  
    @TableId(type = IdType.AUTO)  
    private Long id;  
    private String username;  // 字段名正常  
    private String password;  
}

根因分析：实体类字段名和数据库列名一致，理论上 MyBatis-Plus 会自动映射。但检查后发现 SQL 建表脚本中列名是 user_name（蛇形），而实体类是 username（驼峰），映射不匹配。

修复：

// entity/User.java - 修复后的版本  
@Data  
@TableName("users")  
public class User {  
    @TableId(type = IdType.AUTO)  
    private Long id;  

    @TableField("username")  
    private String username;  

    @TableField("password")  
    private String password;  

    @TableField(value = "created_at", fill = FieldFill.INSERT)  
    private LocalDateTime createdAt;  

    @TableField(value = "updated_at", fill = FieldFill.INSERT_UPDATE)  
    private LocalDateTime updatedAt;  
}

🤖 Claude Code：修复说明：

1. 显式指定 @TableField 确保列名映射正确
2. 时间字段使用 FieldFill 自动填充
3. 统一使用 LocalDateTime 类型

修复后重新测试，注册接口正常写入数据。

这就是 systematic-debugging 的标准流程：确认现象 → 定位根因 → 最小修复 → 验证结果。

最终成果

完整项目结构

springboot-api-server/  
├── src/main/java/com/example/api/  
│   ├── ApiServerApplication.java     # 启动类  
│   ├── common/  
│   │   ├── Result.java               # 统一响应  
│   │   └── BusinessException.java    # 业务异常  
│   ├── config/  
│   │   ├── WebMvcConfig.java         # 拦截器注册  
│   │   └── RedisConfig.java          # Redis 配置  
│   ├── controller/  
│   │   └── UserController.java       # 用户接口  
│   ├── entity/  
│   │   └── User.java                 # 用户实体  
│   ├── interceptor/  
│   │   └── AuthInterceptor.java      # 认证拦截器  
│   ├── mapper/  
│   │   └── UserMapper.java           # 用户 Mapper  
│   └── service/  
│       └── UserService.java          # 用户业务逻辑  
├── src/main/resources/  
│   └── application.yml               # 配置文件  
├── pom.xml  
└── sql/  
    └── init.sql                      # 建表脚本

12 个 Java 文件，总计约 500 行代码，覆盖注册、登录、鉴权三个核心接口。

Superpowers 七阶段映射

总计约 28 分钟，从零到可运行的 API 服务。

用时对比

如果手动搭建同样规格的 Spring Boot 脚手架：搭建项目结构 30 分钟，编写 CRUD 代码 90 分钟，调试 30 分钟，合计约 2.5 小时。使用 Superpowers 工作流，时间缩短到原来的 1/5。

与 Go 版本的对比

两种语言的开发效率几乎一致——AI 编程让语言差异变得不再重要。

进阶技巧

在 CLAUDE.md 中预设 Spring Boot 项目规范

在项目根目录的 CLAUDE.md 中添加 Java 相关规范：

## Spring Boot 项目规范  

- 使用构造器注入（@RequiredArgsConstructor），不用 @Autowired  
- 统一响应格式：Result<T>（code + message + data）  
- 异常处理用 @RestControllerAdvice + BusinessException  
- MyBatis-Plus 用 LambdaQueryWrapper，不用 XML  
- 数据库字段用下划线命名，Java 字段用驼峰

Superpowers scaffold skill

如果经常搭建新项目，可以把脚手架流程封装成 Skill：

# 触发自定义 scaffold skill  
/superpowers:scaffold springboot-api  

# AI 自动执行：头脑风暴 → 生成计划 → 代码编写 → 编译验证

GLM 5.1 与 Claude Code 的分工

在这个实战中，GLM 5.1 作为 Coding Plan Provider 负责：

• • 生成 CRUD 代码（Mapper 层、Controller 层的参数绑定）
• • 编写配置文件（application.yml、pom.xml）

Claude Code 负责：

• • 架构设计和决策（分层策略、拦截器注册方式）
• • 代码审查（发现 MD5→BCrypt 升级建议）
• • 调试（systematic-debugging 排查字段映射问题）

核心逻辑：让 AI 做它最擅长的事——GLM 5.1 写标准代码，Claude Code 做创造性工作。

常见问题

Q1：没有 MySQL 怎么跟练？

一行命令启动 MySQL 容器：

docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0

Q2：Spring Boot 3.5 要求什么 Java 版本？

最低 Java 17，推荐 Java 21。如果本地没有 Java 17：

# 使用 SDKMAN 安装  
sdk install java 17.0.14-zulu  
sdk use java 17.0.14-zulu

Q3：GLM 5.1 和 Claude 原生模型有什么区别？

GLM 5.1 是智谱提供的 Coding Plan Provider，国内直连、无需特殊网络环境。在 Claude Code 中配置 GLM 5.1 作为编码执行者，Claude Code 负责架构设计和代码审查，两者分工协作。

Q4：Superpowers 是免费的吗？

Superpowers 是开源项目，一行命令安装：

claude plugins install superpowers

延伸阅读

• • 本系列第 16 篇《Superpowers 工作流》——七阶段工作流完整理论
• • 本系列第 21 篇《Go API Server 实战》——Go 语言版本的同样流程
• • Spring Boot 官方文档¹
• • MyBatis-Plus 官方文档²
• • Superpowers 项目 GitHub³

下一步

搭完脚手架，接下来可以：

1. 用 Superpowers 添加业务模块（文章、评论、收藏等）
2. 集成 SpringDoc 自动生成 API 文档
3. 添加 Docker Compose 一键部署
4. 接入 CI/CD 流水线（Jenkins / GitHub Actions）

每一步都可以触发 /superpowers:brainstorming，让 AI 先帮你理清思路再动手。

开源预告

本篇的 Spring Boot 脚手架完整源码，连同第 21 篇的 Go API Server 脚手架，后续会在 GitHub 开源发布。

两个项目都会包含：

• • 完整可运行的代码（非 Demo 级别）
• • Docker Compose 一键启动（MySQL + Redis + 应用）
• • Swagger / SpringDoc API 文档
• • 单元测试示例
• • CI/CD 配置模板

开源仓库发布后，会同步更新本文的 GitHub 链接。届时你可以直接 clone 下来作为自己项目的起点，省去从零搭建的时间。

如果你在等开源的过程中想先动手试试，按照本文的步骤，用 Claude Code + Superpowers 走一遍，30 分钟内就能搭建出同样的脚手架。遇到问题欢迎交流。