@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {
    private final UserService userService;
    private final SmsService smsService;
    private final WechatService wechatService;
    private final GithubService githubService;
    private final GoogleService googleService;

    @PostMapping("/login")
    public Result<AuthToken> login(@RequestBody Map<String, Object> request) {
        String type = (String) request.get("type");
        
        if ("password".equals(type)) {
            // ==== 账号密码登录逻辑(约 50 行代码) ====
            String username = (String) request.get("username");
            String password = (String) request.get("password");
            
            // 1. 查询用户
            User user = userService.getByUsername(username);
            if (user == null) {
                throw new RuntimeException("用户名或密码错误");
            }
            
            // 2. 检查账号状态
            if (user.getStatus() == 0) {
                throw new RuntimeException("账号已被禁用");
            }
            
            // 3. 验证密码
            if (!passwordEncoder.matches(password, user.getPassword())) {
                throw new RuntimeException("用户名或密码错误");
            }
            
            // 4. Sa-Token 登录
            StpUtil.login(user.getId());
            return Result.ok(buildAuthToken());
            
        } else if ("sms".equals(type)) {
            // ==== 手机验证码登录逻辑(约 50 行代码) ====
            String phone = (String) request.get("phone");
            String code = (String) request.get("code");
            
            // 1. 验证验证码
            if (!smsService.verifyCode(phone, code)) {
                throw new RuntimeException("验证码错误或已过期");
            }
            
            // 2. 查询或创建用户
            User user = userService.getByPhone(phone);
            if (user == null) {
                user = userService.createByPhone(phone);
            }
            
            // 3. Sa-Token 登录
            StpUtil.login(user.getId());
            return Result.ok(buildAuthToken());
            
        } else if ("wechat".equals(type)) {
            // ==== 微信扫码登录逻辑(约 50 行代码) ====
            String code = (String) request.get("code");
            
            // 1. 调用微信 API 获取 openId
            String openId = wechatService.getOpenId(code);
            
            // 2. 查询或创建用户
            User user = userService.getByWechatOpenId(openId);
            if (user == null) {
                user = userService.createByWechatOpenId(openId);
            }
            
            // 3. Sa-Token 登录
            StpUtil.login(user.getId());
            return Result.ok(buildAuthToken());
            
        } else if ("github".equals(type)) {
            // ==== GitHub OAuth2 登录逻辑(约 50 行代码) ====
            String code = (String) request.get("code");
            
            // 1. 调用 GitHub API 获取 access_token
            String accessToken = githubService.getAccessToken(code);
            
            // 2. 调用 GitHub API 获取用户信息
            GithubUser githubUser = githubService.getUserInfo(accessToken);
            
            // 3. 查询或创建用户
            User user = userService.getByGithubId(githubUser.getId());
            if (user == null) {
                user = userService.createByGithubUser(githubUser);
            }
            
            // 4. Sa-Token 登录
            StpUtil.login(user.getId());
            return Result.ok(buildAuthToken());
            
        } else if ("google".equals(type)) {
            // ==== Google OAuth2 登录逻辑(约 50 行代码) ====
            String code = (String) request.get("code");
            
            // 1. 调用 Google API 获取 access_token
            String accessToken = googleService.getAccessToken(code);
            
            // 2. 调用 Google API 获取用户信息
            GoogleUser googleUser = googleService.getUserInfo(accessToken);
            
            // 3. 查询或创建用户
            User user = userService.getByGoogleId(googleUser.getId());
            if (user == null) {
                user = userService.createByGoogleUser(googleUser);
            }
            
            // 4. Sa-Token 登录
            StpUtil.login(user.getId());
            return Result.ok(buildAuthToken());
            
        } else {
            throw new RuntimeException("不支持的登录方式: " + type);
        }
    }
    
    private AuthToken buildAuthToken() {
        return AuthToken.builder()
            .tokenName(StpUtil.getTokenName())
            .tokenValue(StpUtil.getTokenValue())
            .loginId(StpUtil.getLoginIdAsLong())
            .build();
    }
}

@PostMapping("/login")
public Result<AuthTokenVO> login(@Valid @RequestBody AuthRequest request) {
    AuthTokenVO authToken = authStrategyFactory.authenticate(request);
    return Result.ok(authToken);
}

AuthStrategy strategy = strategyMap.get(request.getAuthType());

Long userId = strategy.authenticate(request);

StpUtil.login(userId);

return AuthTokenVO.builder()
    .tokenName(StpUtil.getTokenName())
    .tokenValue(StpUtil.getTokenValue())
    .loginId(userId)
    .build();

// 步骤 1：策略类验证身份
@Component
public class PasswordAuthStrategy implements AuthStrategy {
    @Override
    public Long authenticate(AuthRequest request) {
        // 1. 查询用户
        User user = userService.getByUsername(username);
        
        // 2. 验证密码
        if (!BCrypt.checkpw(password, user.getPassword())) {
            throw new RuntimeException("密码错误");
        }
        
        // 3. 返回用户 ID（策略类的职责到此结束）
        return user.getId();
    }
}

// 步骤 2：工厂类调用 Sa-Token 登录
@Component
public class AuthStrategyFactory {
    public AuthTokenVO authenticate(AuthRequest request) {
        // 1. 选择策略
        AuthStrategy strategy = strategyMap.get(request.getAuthType());
        
        // 2. 执行认证，获取用户 ID
        Long userId = strategy.authenticate(request);
        
        // 3. Sa-Token 登录（Sa-Token 的职责从这里开始）
        StpUtil.login(userId);
        
        // 4. 返回 Token
        return AuthTokenVO.builder()
            .tokenName(StpUtil.getTokenName())
            .tokenValue(StpUtil.getTokenValue())
            .loginId(userId)
            .build();
    }
}

@PostMapping("/login")
public Result<AuthToken> login(@RequestBody Map<String, Object> request) {
    String type = (String) request.get("type");
    String username = (String) request.get("username");
    // ...
}

package com.example.auth.enums;

import lombok.Getter;

/**
 * 认证类型枚举
 * 集中管理系统支持的所有登录方式
 */
@Getter
public enum AuthType {
    /**
     * 账号密码登录
     */
    PASSWORD("password", "账号密码登录"),
    
    /**
     * 手机验证码登录
     */
    SMS("sms", "手机验证码登录"),
    
    /**
     * 微信扫码登录
     */
    WECHAT("wechat", "微信扫码登录");
    
    /**
     * 类型编码（用于前端传参）
     */
    private final String code;
    
    /**
     * 类型描述（用于日志记录）
     */
    private final String description;
    
    AuthType(String code, String description) {
        this.code = code;
        this.description = description;
    }
    
    /**
     * 根据 code 获取枚举
     */
    public static AuthType fromCode(String code) {
        for (AuthType type : values()) {
            if (type.code.equals(code)) {
                return type;
            }
        }
        throw new IllegalArgumentException("不支持的认证方式: " + code);
    }
}

package com.example.auth.model.request;

import com.example.auth.enums.AuthType;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

/**
 * 认证请求接口
 * 所有登录方式的请求参数都必须实现这个接口
 */
@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.EXISTING_PROPERTY,
    property = "authType",
    visible = true
)
@JsonSubTypes({
    @JsonSubTypes.Type(value = PasswordAuthRequest.class, name = "PASSWORD"),
    @JsonSubTypes.Type(value = SmsAuthRequest.class, name = "SMS"),
    @JsonSubTypes.Type(value = WechatAuthRequest.class, name = "WECHAT")
})
public interface AuthRequest {
    /**
     * 获取认证类型
     * 用于工厂类根据类型选择对应的策略
     */
    AuthType getAuthType();
}

package com.example.auth.model.request;

import com.example.auth.enums.AuthType;
import com.fasterxml.jackson.annotation.JsonTypeName;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;

/**
 * 账号密码登录请求
 */
@Data
@JsonTypeName("PASSWORD")
public class PasswordAuthRequest implements AuthRequest {
    
    private AuthType authType = AuthType.PASSWORD;
    
    @NotBlank(message = "用户名不能为空")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    private String password;
    
    @Override
    public AuthType getAuthType() {
        return authType;
    }
}

package com.example.auth.model.request;

import com.example.auth.enums.AuthType;
import com.fasterxml.jackson.annotation.JsonTypeName;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;

@Data
@JsonTypeName("SMS")
public class SmsAuthRequest implements AuthRequest {
    
    private AuthType authType = AuthType.SMS;
    
    @NotBlank(message = "手机号不能为空")
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
    private String phone;
    
    @NotBlank(message = "验证码不能为空")
    @Pattern(regexp = "^\\d{6}$", message = "验证码格式不正确")
    private String code;
    
    @Override
    public AuthType getAuthType() {
        return authType;
    }
}

package com.example.auth.model.request;

import com.example.auth.enums.AuthType;
import com.fasterxml.jackson.annotation.JsonTypeName;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;

@Data
@JsonTypeName("WECHAT")
public class WechatAuthRequest implements AuthRequest {
    
    private AuthType authType = AuthType.WECHAT;
    
    @NotBlank(message = "授权码不能为空")
    private String code;
    
    @Override
    public AuthType getAuthType() {
        return authType;
    }
}

if ("password".equals(type)) {
    // 查询用户、验证密码、生成 Token...
} else if ("sms".equals(type)) {
    // 验证验证码、查询或创建用户、生成 Token...
}

package com.example.auth.strategy;

import com.example.auth.enums.AuthType;
import com.example.auth.model.request.AuthRequest;

/**
 * 认证策略接口
 * 所有登录方式都必须实现这个接口
 * 
 * 设计理念：
 * 1. 统一规范：所有登录方式都遵循同一套接口
 * 2. 策略模式：将每种登录方式封装为一个独立的策略类
 * 3. 职责单一：策略类只负责验证身份，返回用户 ID
 */
public interface AuthStrategy {
    /**
     * 执行认证
     * 这是策略模式的核心方法，每个策略类都必须实现
     * 
     * 职责边界：
     * - 策略类只负责验证身份（查询用户、验证密码/验证码等）
     * - 策略类不负责生成 Token（由 Sa-Token 负责）
     * - 策略类不负责管理会话（由 Sa-Token 负责）
     * 
     * @param request 认证请求（多态参数）
     * @return 用户 ID（用于 Sa-Token 登录）
     * @throws RuntimeException 如果认证失败
     */
    Long authenticate(AuthRequest request);
    
    /**
     * 获取支持的认证类型
     * 用于工厂类根据类型选择对应的策略
     * 
     * @return 认证类型枚举
     */
    AuthType getSupportedType();
}

public interface AuthStrategy {
    AuthToken authenticate(AuthRequest request);
}

// 实现类
public class PasswordAuthStrategy implements AuthStrategy {
    @Override
    public AuthToken authenticate(AuthRequest request) {
        // 1. 验证身份
        User user = userService.getByUsername(username);
        // 2. 生成 Token
        StpUtil.login(user.getId());
        // 3. 返回 Token
        return AuthToken.builder()
            .tokenValue(StpUtil.getTokenValue())
            .build();
    }
}

public interface AuthStrategy {
    Long authenticate(AuthRequest request);
}

// 实现类
public class PasswordAuthStrategy implements AuthStrategy {
    @Override
    public Long authenticate(AuthRequest request) {
        // 只负责验证身份
        User user = userService.getByUsername(username);
        // 返回用户 ID
        return user.getId();
    }
}

// 工厂类
public class AuthStrategyFactory {
    public AuthTokenVO authenticate(AuthRequest request) {
        // 1. 选择策略
        AuthStrategy strategy = getStrategy(request.getAuthType());
        // 2. 执行认证，获取用户 ID
        Long userId = strategy.authenticate(request);
        // 3. Sa-Token 登录
        StpUtil.login(userId);
        // 4. 返回 Token
        return buildAuthToken(userId);
    }
}

// 工厂类的构造函数
public AuthStrategyFactory(List<AuthStrategy> strategies) {
    for (AuthStrategy strategy : strategies) {
        AuthType type = strategy.getSupportedType();  // 获取策略类型
        strategyMap.put(type, strategy);              // 注册到 Map
    }
}

@Override
public Long authenticate(AuthRequest request) {
    // 强制转换为具体类型
    PasswordAuthRequest passwordRequest = (PasswordAuthRequest) request;
    // 使用具体类型的字段
    String username = passwordRequest.getUsername();
    String password = passwordRequest.getPassword();
    // ...
}

// 步骤 1：策略类验证身份
@Component
public class PasswordAuthStrategy implements AuthStrategy {
    @Override
    public Long authenticate(AuthRequest request) {
        // 1. 查询用户
        User user = userService.getByUsername(username);
        
        // 2. 验证密码
        if (!BCrypt.checkpw(password, user.getPassword())) {
            throw new RuntimeException("密码错误");
        }
        
        // 3. 返回用户 ID（策略类的职责到此结束）
        return user.getId();
    }
    
    @Override
    public AuthType getSupportedType() {
        return AuthType.PASSWORD;
    }
}

// 步骤 2：工厂类调用 Sa-Token 登录
@Component
public class AuthStrategyFactory {
    public AuthTokenVO authenticate(AuthRequest request) {
        // 1. 选择策略
        AuthStrategy strategy = strategyMap.get(request.getAuthType());
        
        // 2. 执行认证，获取用户 ID
        Long userId = strategy.authenticate(request);
        
        // 3. Sa-Token 登录（Sa-Token 的职责从这里开始）
        StpUtil.login(userId);
        
        // 4. 返回 Token
        return AuthTokenVO.builder()
            .tokenName(StpUtil.getTokenName())
            .tokenValue(StpUtil.getTokenValue())
            .loginId(userId)
            .build();
    }
}

package com.example.auth.model.vo;

import lombok.Builder;
import lombok.Data;

/**
 * 认证响应对象
 * 包含 Sa-Token 生成的 Token 信息
 */
@Data
@Builder
public class AuthTokenVO {
    
    /**
     * Token 名称
     * 对应 Sa-Token 配置中的 token-name（默认为 "Authorization"）
     */
    private String tokenName;
    
    /**
     * Token 值
     * 前端需要在后续请求的 Header 中携带这个值
     */
    private String tokenValue;
    
    /**
     * 用户 ID
     * 用于前端展示或其他业务逻辑
     */
    private Long loginId;
}

package com.example.auth.factory;

import cn.dev33.satoken.stp.StpUtil;
import com.example.auth.enums.AuthType;
import com.example.auth.model.request.AuthRequest;
import com.example.auth.model.vo.AuthTokenVO;
import com.example.auth.strategy.AuthStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 认证策略工厂
 * 负责管理所有认证策略，并根据认证类型自动选择对应的策略
 */
@Slf4j
@Component
public class AuthStrategyFactory {
    /**
     * 策略容器
     * Key: 认证类型（AuthType）
     * Value: 认证策略（AuthStrategy）
     * 使用 ConcurrentHashMap 保证线程安全
     */
    private final Map<AuthType, AuthStrategy> strategyMap = new ConcurrentHashMap<>();

    public AuthStrategyFactory(List<AuthStrategy> strategies) {
        // 遍历所有策略，注册到 Map 中
        for (AuthStrategy strategy : strategies) {
            AuthType type = strategy.getSupportedType();

            // 检查是否有重复的策略类型
            if (strategyMap.containsKey(type)) {
                throw new IllegalStateException("重复的认证策略: " + type.getDescription());
            }

            // 注册策略到 Map 中
            strategyMap.put(type, strategy);
            log.info("认证策略工厂初始化完成，已注册 {} 个策略", strategyMap.size());
        }
    }

    /**
     * 获取认证策略
     * 根据认证类型从 Map 中获取对应的策略
     *
     * @param authType 认证类型
     * @return 认证策略
     * @throws IllegalArgumentException 如果认证类型不支持
     */
    public AuthStrategy getStrategy(AuthType authType) {
        AuthStrategy strategy = strategyMap.get(authType);
        if (strategy == null) {
            throw new IllegalArgumentException("不支持的认证方式: " + authType.getDescription());
        }
        return strategy;
    }

    /**
     * 执行认证（门面方法）
     * 这是工厂类对外提供的统一认证入口
     * <p>
     * 为什么需要这个方法？
     * 1. 隐藏策略选择的复杂性：调用者不需要知道如何选择策略
     * 2. 统一异常处理：可以在这里统一处理策略执行过程中的异常
     * 3. 统一日志记录：可以在这里统一记录认证日志
     * 4. 集成 Sa-Token：策略类只返回 userId，工厂类负责调用 Sa-Token 登录
     *
     * @param request 认证请求
     * @return 认证响应（包含 Token 信息）
     * @throws IllegalArgumentException 如果认证类型不支持
     * @throws RuntimeException         如果认证失败
     */
    public AuthTokenVO authenticate(AuthRequest request) {
        AuthType authType = request.getAuthType();
        // 步骤 1：选择策略
        AuthStrategy strategy = getStrategy(authType);
        try {
            // 步骤 2：策略类验证身份，返回用户 ID
            Long userId = strategy.authenticate(request);
            log.info("认证成功: type={}, userId={}", authType.getDescription(), userId);
            // 步骤 3：Sa-Token 登录
            StpUtil.login(userId);

            // 步骤 4：构建响应对象
            return AuthTokenVO.builder()
                    .tokenName(StpUtil.getTokenName())
                    .tokenValue(StpUtil.getTokenValue())
                    .loginId(userId)
                    .build();
        } catch (Exception e) {
            log.error("认证失败: type={}, error={}", authType.getDescription(), e.getMessage());
            throw e;
        }
    }

    /**
     * 获取所有已注册的认证类型
     * 用于前端动态展示支持的登录方式
     *
     * @return 所有已注册的认证类型
     */
    public List<AuthType> getSupportedTypes() {
        return List.copyOf(strategyMap.keySet());
    }
}

if (strategyMap.containsKey(type)) {
    throw new IllegalStateException("重复的认证策略: " + type.getDescription());
}

package com.example.auth.common;

import lombok.Data;

/**
 * 统一响应格式
 * 
 * @param <T> 响应数据类型
 */
@Data
public class Result<T> {
    
    /**
     * 响应码
     * 200 表示成功，其他表示失败
     */
    private Integer code;
    
    /**
     * 响应消息
     */
    private String message;
    
    /**
     * 响应数据
     */
    private T data;
    
    /**
     * 成功响应（无数据）
     */
    public static <T> Result<T> ok() {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMessage("操作成功");
        return result;
    }
    
    /**
     * 成功响应（有数据）
     */
    public static <T> Result<T> ok(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMessage("操作成功");
        result.setData(data);
        return result;
    }
    
    /**
     * 失败响应
     */
    public static <T> Result<T> fail(String message) {
        Result<T> result = new Result<>();
        result.setCode(500);
        result.setMessage(message);
        return result;
    }
    
    /**
     * 失败响应（自定义错误码）
     */
    public static <T> Result<T> fail(Integer code, String message) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        return result;
    }
}

package com.example.auth.controller;

import cn.dev33.satoken.stp.StpUtil;
import com.example.auth.common.Result;
import com.example.auth.enums.AuthType;
import com.example.auth.factory.AuthStrategyFactory;
import com.example.auth.model.request.AuthRequest;
import com.example.auth.model.vo.AuthTokenVO;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 认证控制器
 * 提供登录、注销等接口
 */
@Slf4j
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {
    
    private final AuthStrategyFactory authStrategyFactory;
    
    /**
     * 统一登录接口
     * 支持多种登录方式，通过 authType 字段区分
     * 
     * @param request 认证请求（多态参数）
     * @return 统一响应格式
     */
    @PostMapping("/login")
    public Result<AuthTokenVO> login(@Valid @RequestBody AuthRequest request) {
        log.info("收到登录请求: type={}", request.getAuthType().getDescription());
        
        // 委托给工厂类，工厂类会自动选择对应的策略
        AuthTokenVO authToken = authStrategyFactory.authenticate(request);
        
        return Result.ok(authToken);
    }
    
    /**
     * 注销登录接口
     * 
     * @return 统一响应格式
     */
    @PostMapping("/logout")
    public Result<Void> logout() {
        log.info("收到注销请求");
        
        // Sa-Token 注销登录
        StpUtil.logout();
        
        return Result.ok();
    }
    
    /**
     * 获取支持的登录方式
     * 前端可以调用这个接口，动态展示登录按钮
     * 
     * @return 所有支持的登录方式
     */
    @GetMapping("/supported-types")
    public Result<List<Map<String, String>>> getSupportedTypes() {
        List<AuthType> types = authStrategyFactory.getSupportedTypes();
        
        // 转换为前端友好的格式
        List<Map<String, String>> result = types.stream()
                .map(type -> {
                    Map<String, String> map = new HashMap<>();
                    map.put("code", type.getCode());
                    map.put("description", type.getDescription());
                    return map;
                })
                .toList();
        
        return Result.ok(result);
    }
}

@PostMapping("/login")
public Result<AuthTokenVO> login(@Valid @RequestBody AuthRequest request) {
    log.info("收到登录请求: type={}", request.getAuthType().getDescription());
    AuthTokenVO authToken = authStrategyFactory.authenticate(request);
    return Result.ok(authToken);
}

public Result<AuthTokenVO> login(@Valid @RequestBody AuthRequest request)

@GetMapping("/supported-types")
public Result<List<Map<String, String>>> getSupportedTypes() {
    List<AuthType> types = authStrategyFactory.getSupportedTypes();
    
    // 转换为前端友好的格式
    List<Map<String, String>> result = types.stream()
            .map(type -> {
                Map<String, String> map = new HashMap<>();
                map.put("code", type.getCode());
                map.put("description", type.getDescription());
                return map;
            })
            .toList();
    
    return Result.ok(result);
}

@PostMapping("/login")
public Result<AuthToken> login(@RequestBody Map<String, Object> request) {
    String type = (String) request.get("type");
    
    if ("password".equals(type)) {
        // 账号密码登录逻辑（50 行代码）
        String username = (String) request.get("username");
        String password = (String) request.get("password");
        // 查询用户、验证密码、生成 Token...
        
    } else if ("sms".equals(type)) {
        // 手机验证码登录逻辑（50 行代码）
        String phone = (String) request.get("phone");
        String code = (String) request.get("code");
        // 验证验证码、查询或创建用户、生成 Token...
        
    } else if ("wechat".equals(type)) {
        // 微信扫码登录逻辑（50 行代码）
        String code = (String) request.get("code");
        // 调用微信 API、查询或创建用户、生成 Token...
        
    } else {
        throw new RuntimeException("不支持的登录方式: " + type);
    }
}

@PostMapping("/login")
public Result<AuthTokenVO> login(@Valid @RequestBody AuthRequest request) {
    log.info("收到登录请求: type={}", request.getAuthType().getDescription());
    AuthTokenVO authToken = authStrategyFactory.authenticate(request);
    return Result.ok(authToken);
}