/**
 * 新增用户
 * 【硬编码登录校验：后续可通过拦截器统一处理，避免重复代码】
 * @param user 新增用户信息（请求体JSON）
 * @return 统一Result格式响应
 */
@PostMapping
public Result saveUser(
        HttpSession session, // 注入Session
        @Valid @RequestBody SysUser user,
        BindingResult bindingResult) {
    String username = (String) session.getAttribute("username");
    if (username == null || username.isEmpty()) {
        return Result.fail(501, "未登录,请先登录");
    }
    // 1. 参数校验逻辑
    if (bindingResult.hasErrors()) {
        String errorMsg = bindingResult.getFieldErrors().stream()
                .map(error -> error.getField() + "：" + error.getDefaultMessage())
                .collect(Collectors.joining("；"));
        return Result.fail(500, "参数校验失败：" + errorMsg);
    }
    // 2. 业务逻辑（直接调用工具类操作数据）
    SysUser savedUser = SysUserDataUtil.saveUser(user);
    System.out.println("新增后用户：" + savedUser);
    // 3. 响应结果
    return Result.success("新增用户成功！", savedUser);
}

import java.util.List;
/**
 * 数据访问层：仅负责用户数据的增删改查，不包含任何业务逻辑
 */
public interface UserDao {
    boolean deleteById(Long id);
    boolean updateById(Long id, SysUser sysUser);
    SysUser save(SysUser sysUser);
    SysUser getById(Long id);
    List<SysUser> list(String username, String phone, Integer status);
}

import java.util.List;

/**
 * DAO实现类：仅调用SysUserDataUtil工具类完成数据操作
 */
public class UserDaoImpl implements UserDao {
    /**
     * 【DAO逻辑】调用工具类删除用户
     */
    @Override
    public boolean deleteById(Long id) {
        return SysUserDataUtil.deleteUserById(id);
    }
    /**
     * 【DAO逻辑】调用工具类更新用户
     */
    @Override
    public boolean updateById(Long id, SysUser sysUser) {
        return SysUserDataUtil.updateUserById(id, sysUser);
    }
    /**
     * 【DAO逻辑】调用工具类新增用户
     */
    @Override
    public SysUser save(SysUser sysUser) {
        return SysUserDataUtil.saveUser(sysUser);
    }
    /**
     * 【DAO逻辑】调用工具类查询单个用户
     */
    @Override
    public SysUser getById(Long id) {
        return SysUserDataUtil.getUserById(id);
    }
    /**
     * 【DAO逻辑】调用工具类条件查询用户列表
     */
    @Override
    public List<SysUser> list(String username, String phone, Integer status) {
        return SysUserDataUtil.listUsers(username, phone, status);
    }
}

import java.util.List;

/**
 * 业务逻辑层：封装用户相关核心业务规则
 */
public interface UserService {
    boolean removeUserById(Long id);
    boolean updateUserById(Long id, SysUser sysUser);
    SysUser saveUser(SysUser sysUser);
    SysUser getUserById(Long id);
    List<SysUser> getUserList(String username, String phone, Integer status);
}

import java.util.List;

/**
 * Service实现类：具体实现用户业务逻辑，手动创建DAO实例
 */
public class UserServiceImpl implements UserService {

    // 手动new DAO实例
    private UserDao userDao = new UserDaoImpl();

    /**
     * 【业务逻辑】根据ID删除用户
     */
    @Override
    public boolean removeUserById(Long id) {
        return userDao.deleteById(id);
    }

    /**
     * 【业务逻辑】根据ID更新用户
     * 核心规则：先查用户是否存在，再更新
     */
    @Override
    public boolean updateUserById(Long id, SysUser sysUser) {
        if (userDao.getById(id) == null) {
            return false;
        }
        return userDao.updateById(id, sysUser);
    }

    /**
     * 【业务逻辑】新增用户
     */
    @Override
    public SysUser saveUser(SysUser sysUser) {
        return userDao.save(sysUser);
    }

    /**
     * 【业务逻辑】根据ID查询用户
     */
    @Override
    public SysUser getUserById(Long id) {
        return userDao.getById(id);
    }

    /**
     * 【业务逻辑】条件查询用户列表
     */
    @Override
    public List<SysUser> getUserList(String username, String phone, Integer status) {
        return userDao.list(username, phone, status);
    }
}

/**
 * 表现层：仅接收请求、参数校验、调用Service、返回响应
 * 保留@RestController等Web注解，手动创建Service实例
 */
@RequestMapping("/user")
@RestController
public class UserController {

    // 手动new Service实例
    private UserService userService = new UserServiceImpl();

    /**
     * 根据ID删除用户
     * 【Controller仅做：接收请求→调用Service→返回响应】
     */
    @DeleteMapping("{id}")
    public Result removeUser(HttpSession session, @PathVariable Long id) {
        boolean deleted = userService.removeUserById(id);
        if (deleted) {
            return Result.success("删除ID为" + id + "的用户成功！");
        } else {
            return Result.fail("删除失败：ID为" + id + "的用户不存在！");
        }
    }

    /**
     * 根据ID更新用户
     * 【Controller仅做：参数校验→调用Service→返回响应】
     */
    @PutMapping("{id}")
    public Result updateUser(
            HttpSession session,
            @PathVariable Long id,
            @Valid @RequestBody SysUser sysUser,
            BindingResult bindingResult){

        // 仅做参数格式校验（无业务逻辑）
        if (bindingResult.hasErrors()) {
            String errorMsg = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + "：" + error.getDefaultMessage())
                    .collect(Collectors.joining("；"));
            return Result.fail(500, "参数校验失败：" + errorMsg);
        }
        Boolean updatedUser = userService.updateUserById(id, sysUser);
        if (updatedUser){
            return Result.success("更新ID为" + id + "的用户成功！");
        }
        return Result.fail("更新失败：ID为" + id + "的用户不存在！");
    }

    /**
     * 新增用户
     * 【Controller仅做：参数校验→调用Service→返回响应】
     */
    @PostMapping
    public Result saveUser(
            HttpSession session,
            @Valid @RequestBody SysUser user,
            BindingResult bindingResult
    ) {
        // 仅做参数格式校验（无业务逻辑）
        if (bindingResult.hasErrors()) {
            String errorMsg = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + "：" + error.getDefaultMessage())
                    .collect(Collectors.joining("；"));
            return Result.fail(500, "参数校验失败：" + errorMsg);
        }

        SysUser savedUser = userService.saveUser(user);
        return Result.success("新增用户成功！", savedUser);
    }

    /**
     * 根据ID查询用户详情
     * 【Controller仅做：接收请求→调用Service→返回响应】
     */
    @GetMapping("{id}")
    public Result findById(HttpSession session, @PathVariable Long id) {
        SysUser sysUser = userService.getUserById(id);
        System.out.println("查询到的用户：" + sysUser);
        if (sysUser == null) {
            return Result.fail("查询失败：ID为" + id + "的用户不存在！");
        }
        return Result.success("查询成功！", sysUser);
    }

    /**
     * 条件查询用户列表
     * 【Controller仅做：接收请求→调用Service→返回响应】
     */
    @GetMapping("/list")
    public Result getUserList(
            HttpSession session,
            @RequestParam(required = false) String username,
            @RequestParam(required = false) String phone,
            @RequestParam(required = false) Integer status) {

        List<SysUser> sysUserList = userService.getUserList(username, phone, status);

        return Result.success("查询成功！共找到" + sysUserList.size() + "条数据", sysUserList);
    }
}

/**
 * 数据访问层：新增登录校验方法，仅调用工具类
 */
public interface UserDao {
    // 新增：登录校验（仅调用工具类，无业务逻辑）
    boolean login(String username, String password);
}

/**
 * DAO实现类：新增登录方法，仅转发调用SysUserDataUtil
 */
public class UserDaoImpl implements UserDao {

    // 新增：登录校验（仅调用工具类，无任何业务逻辑）
    @Override
    public boolean login(String username, String password) {
        return SysUserDataUtil.login(username, password);
    }
}

/**
 * 业务逻辑层：新增登录业务方法
 */
public interface UserService {
    // 新增：登录业务校验（可扩展登录规则，如账号是否禁用）
    boolean login(String username, String password);
}

/**
 * Service实现类：新增登录业务逻辑，复用已有DAO实例
 */
public class UserServiceImpl implements UserService {

    // 新增：登录业务逻辑（可扩展规则，如校验账号状态、登录次数限制等）
    @Override
    public boolean login(String username, String password) {
        // 业务逻辑1：调用DAO校验账号密码（基础校验）
        boolean validateResult = userDao.login(username, password);
        if (!validateResult) {
            return false;
        }
        // 业务逻辑2：（可扩展）校验账号是否禁用（示例）
        // 先查询用户信息，判断状态
        // SysUser user = userDao.getByUsername(username); // 可新增DAO方法
        // if (user != null && 0 == user.getStatus()) {
        //     return false; // 账号禁用，登录失败
        // }

        return true;
    }
}

/**
 * 登录表现层：仅处理请求、参数校验、调用Service、操作Session、返回响应
 * 复用已有UserService，手动new实例（无IOC注解）
 */
@RestController
@RequestMapping("auth")
public class LoginController {

    // 手动new Service实例（复用原有UserService，无需新增Service）
    private UserService userService = new UserServiceImpl();

    /**
     * 登录接口
     * /auth/login  post方式 请求体传递参数 username password
     * 验证成功以后，将账号存储在session!
     * 返回 {code:200,message:"登录成功",data:null}
     */
    @PostMapping("login")
    public Result login(HttpSession session, @Valid @RequestBody SysUserLoginDto user, BindingResult bindingResult) {
        // 1. 表现层职责：仅做参数格式校验（无业务逻辑）
        if (bindingResult.hasErrors()) {
            return Result.fail(500, "账号和密码不符合规则,登录失败！");
        }
        // 2. 调用Service完成登录业务校验（不直接调用工具类/DAO）
        boolean logined = userService.login(user.getUsername(), user.getPassword());
        if (!logined) {
            return Result.fail("账号或者密码错误！");
        }
        // 3. 表现层职责：操作Session（属于请求响应层面，无需走Service）
        session.setAttribute("username", user.getUsername());
        return Result.success("登录成功！");
    }

    /**
     * 退出登录接口
     * /auth/logout  get方式  没有参数
     * 清空session数据，返回成功响应
     * 返回 {code:200,message:"退出登录成功",data:null}
     */
    @GetMapping("logout")
    public Result logout(HttpSession session) {
        // 表现层职责：操作Session（无需走Service/DAO）
        session.removeAttribute("username");
        session.invalidate();
        return Result.success("退出登录成功！");
    }
}

@RestController 
@RequestMapping("/auth")
public class LoginController {

    // 手动new Service实例
    private UserService userService = new UserServiceImpl();

}

// 多路径扫描
@ComponentScan(value = {"com.atguigu.spring.user","com.atguigu.spring.order"})

com.atguigu.iocdemo
  ├── IocDemoApplication.java  // 主启动类（核心：获取容器+演示获取组件）
  ├── component                // 通用组件包
  │   └── DateUtil.java        // 标记@Component（无接口）
  ├── dao                      // 数据层包
  │   ├── UserDao.java         // DAO 接口
  │   └── UserDaoImpl.java     // 标记@Repository（实现类）
  ├── service                  // 业务层包
  │   ├── UserService.java     // Service 接口
  │   └── UserServiceImpl.java // 标记@Service（实现类）
  └── controller               // 表现层包
      └── UserController.java  // 标记@Controller或@RestController（无接口）

// 1. 定义UserDao接口（数据层）
public interface UserDao {
    boolean deleteById(Long id);
}

// 2. 实现类1：默认组件名称（userDaoImpl）
@Repository // 未指定name，默认组件名=类名首字母小写：userDaoImpl
public class UserDaoImpl implements UserDao {
    @Override
    public boolean deleteById(Long id) {
        System.out.println("DAO层V1：删除用户，ID=" + id);
        return true;
    }
}

// 3. 实现类2：自定义组件名称（userDaoImplV2）
@Repository("userDaoImplV2") // 手动指定组件名称
public class UserDaoImplV2 implements UserDao {
    @Override
    public boolean deleteById(Long id) {
        System.out.println("DAO层V2：删除用户（升级版），ID=" + id);
        return true;
    }
}

// 4. 定义 UserService 接口（业务层）
public interface UserService {
    boolean removeUser(Long id);
}

@Service
public class UserServiceImpl implements UserService {
    // ========== 场景1：单实现类（默认按类型匹配） ==========
    // @Autowired // 容器中只有UserDaoImpl时，直接按类型注入
    // private UserDao userDao;

    // ========== 场景2：多实现类（配合@Qualifier指定名称） ==========
    @Autowired(required = false) // 设为非必须，无匹配时不抛异常
    @Qualifier("userDaoImplV2")  // 明确注入名称为userDaoImplV2的组件
    private UserDao userDao;

    @Override
    public boolean removeUser(Long id) {
        System.out.println("Service层：校验删除权限，准备执行删除");
        return userDao.deleteById(id); // 调用注入的DAO组件
    }
}

@Service
public class UserServiceImpl implements UserService {
    // ========== 场景1：默认按名称匹配（变量名=组件名） ==========
    // @Resource // 变量名userDaoImpl匹配组件名，注入UserDaoImpl
    // private UserDao userDaoImpl;

    // ========== 场景2：手动指定名称（多实现类推荐） ==========
    @Resource(name = "userDaoImplV2", required = false)
    private UserDao userDao; // 变量名可任意，只需name属性匹配组件名

    @Override
    public boolean removeUser(Long id) {
        System.out.println("Service层：校验删除权限，准备执行删除");
        return userDao.deleteById(id);
    }
}

@RestController
@RequestMapping("/user")
public class UserController {
    // 成员变量位置注入（开发中最常用）
    @Autowired
    private UserService userService;

    // 测试接口：调用Service删除用户
    @DeleteMapping("/{id}")
    public Result removeUser(@PathVariable Long id) {
        boolean success = userService.removeUser(id);
        return success ? Result.success("删除成功") : Result.fail("删除失败");
    }
}

Service层：校验删除权限，准备执行删除
DAO层V2：删除用户（升级版），ID=100

# 应用基础配置
app.name=SpringIocDemo
app.version=1.0.0
app.port=8888
# 数据库模拟配置
db.username=root
db.password=123456

@Component // 纳入 Spring 容器管理，才能使用@Value
public class ConfigReaderUtil {
    // 读取基础配置（无默认值，key不存在会抛异常）
    @Value("${app.name}")
    private String appName;

    // 读取配置+默认值（key不存在时用默认值dev）
    @Value("${app.env:dev}")
    private String appEnv;

    // 读取数据库配置
    @Value("${db.username}")
    private String dbUsername;
    @Value("${db.password}")
    private String dbPassword;

    // 测试方法：打印读取结果
    public void printConfig() {
        System.out.println("=== 读取默认配置文件结果 ===");
        System.out.println("应用名称：" + appName);
        System.out.println("运行环境：" + appEnv);
        System.out.println("数据库账号：" + dbUsername);
        System.out.println("数据库密码：" + dbPassword);
    }
}

// 在 Spring Boot 主启动类 main 方法中添加
public static void main(String[] args) {
    ConfigurableApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);
    // 获取配置读取组件
    ConfigReaderUtil configReader = context.getBean(ConfigReaderUtil.class);
    // 打印配置
    configReader.printConfig();
}

=== 读取默认配置文件结果 ===
应用名称：SpringIocDemo
运行环境：dev
数据库账号：root
数据库密码：123456

# 外部数据库配置文件（resources/config/db.properties）
db.mysql.username=root_outer
db.mysql.password=outer_123456
db.mysql.url=jdbc:mysql://localhost:3306/outer_db
db.mysql.driver=com.mysql.cj.jdbc.Driver
db.mysql.port=3306

/**
 * 读取外部自定义properties文件（非默认配置）
 */
@Component // 必须纳入容器，注解才生效
// 加载外部文件，指定UTF-8编码避免中文乱码
@PropertySource(encoding = "UTF-8", value = "classpath:config/db.properties")
public class OuterConfigReader {

    // 读取外部文件中的配置项
    @Value("${db.mysql.username}")
    private String dbUsername;

    @Value("${db.mysql.password}")
    private String dbPassword;

    @Value("${db.mysql.url}")
    private String dbUrl;

    // 读取不存在的key，使用默认值
    @Value("${db.mysql.max-connections:10}")
    private Integer dbMaxConnections;

    // 测试方法：打印外部配置
    public void printOuterConfig() {
        System.out.println("=== 读取外部自定义配置文件结果 ===");
        System.out.println("外部数据库账号：" + dbUsername);
        System.out.println("外部数据库密码：" + dbPassword);
        System.out.println("外部数据库URL：" + dbUrl);
        System.out.println("数据库最大连接数：" + dbMaxConnections);
    }
}

public static void main(String[] args) {
    ConfigurableApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);
    // 获取外部配置读取组件
    OuterConfigReader outerConfigReader = context.getBean(OuterConfigReader.class);
    // 打印外部配置
    outerConfigReader.printOuterConfig();
}

=== 读取外部自定义配置文件结果 ===
外部数据库账号：root_outer
外部数据库密码：outer_123456
外部数据库URL：jdbc:mysql://localhost:3306/outer_db
数据库最大连接数：10

# 应用基础配置
app.name=SpringIocDemo
app.version=1.0.0
app.port=8888
# 数据库模拟配置
db.username=root
db.password=123456

/**
 * 批量绑定db前缀的配置
 * @Component：交给 Spring 容器管理
 * @ConfigurationProperties：指定配置前缀为db
 */
@Data
@Component
@ConfigurationProperties(prefix = "db")
public class DbConfig {
    // 属性名和配置文件中“db.xxx”的xxx一致
    private String username;
    private String password;

    // 必须写setter方法（Spring赋值用）
}

/**
 * 批量绑定app前缀的配置
 */
@Data
@Component
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    // 属性名和配置文件中“app.xxx”的xxx一致
    private String name;
    private String version;
    private Integer port;

    // 必须写setter方法（Spring赋值用）
}

@SpringBootApplication
public class IocDemoApplication {
    public static void main(String[] args) {
        // 启动 Spring 容器
        ApplicationContext context = SpringApplication.run(IocDemoApplication.class, args);
        System.out.println("=== 批量读取配置参数结果 ===");

        // 1. 获取数据库配置类，打印值
        DbConfig dbConfig = context.getBean(DbConfig.class);
        System.out.println("=== 数据库配置 ===");
        System.out.println("账号：" + dbConfig.getUsername());
        System.out.println("密码：" + dbConfig.getPassword());

        // 2. 获取应用配置类，打印值
        AppConfig appConfig = context.getBean(AppConfig.class);
        System.out.println("\n=== 应用配置 ===");
        System.out.println("应用名称：" + appConfig.getName());
        System.out.println("应用版本：" + appConfig.getVersion());
        System.out.println("服务端口：" + appConfig.getPort());
    }
}

=== 批量读取配置参数结果 ===
=== 数据库配置 ===
账号：root
密码：123456

=== 应用配置 ===
应用名称：SpringIocDemo
应用版本：1.0.0
服务端口：8888

import java.util.List;

/**
 * 数据访问层：仅负责用户数据的增删改查，不包含任何业务逻辑
 */
public interface UserDao {
    boolean deleteById(Long id);
    boolean updateById(Long id, SysUser sysUser);
    SysUser save(SysUser sysUser);
    SysUser getById(Long id);
    List<SysUser> list(String username, String phone, Integer status);
}

/**
 * DAO实现类：加@Repository注解，交给 Spring 容器管理
 * 仅调用SysUserDataUtil工具类完成数据操作
 */
@Repository // 核心：标记为DAO组件，纳入 Spring 容器
public class UserDaoImpl implements UserDao {
    /**
     * 【DAO逻辑】调用工具类删除用户
     */
    @Override
    public boolean deleteById(Long id) {
        return SysUserDataUtil.deleteUserById(id);
    }
    /**
     * 【DAO逻辑】调用工具类更新用户
     */
    @Override
    public boolean updateById(Long id, SysUser sysUser) {
        return SysUserDataUtil.updateUserById(id, sysUser);
    }
    /**
     * 【DAO逻辑】调用工具类新增用户
     */
    @Override
    public SysUser save(SysUser sysUser) {
        return SysUserDataUtil.saveUser(sysUser);
    }
    /**
     * 【DAO逻辑】调用工具类查询单个用户
     */
    @Override
    public SysUser getById(Long id) {
        return SysUserDataUtil.getUserById(id);
    }
    /**
     * 【DAO逻辑】调用工具类条件查询用户列表
     */
    @Override
    public List<SysUser> list(String username, String phone, Integer status) {
        return SysUserDataUtil.listUsers(username, phone, status);
    }
}

import java.util.List;

/**
 * 业务逻辑层：封装用户相关核心业务规则
 */
public interface UserService {
    boolean removeUserById(Long id);
    boolean updateUserById(Long id, SysUser sysUser);
    SysUser saveUser(SysUser sysUser);
    SysUser getUserById(Long id);
    List<SysUser> getUserList(String username, String phone, Integer status);
}

/**
 * Service实现类：加@Service注解纳入容器，通过@Autowired注入DAO（移除手动new）
 * 具体实现用户业务逻辑
 */
@Service // 核心：标记为Service组件，纳入 Spring 容器
public class UserServiceImpl implements UserService {

    // 核心改造：移除手动new，通过@Autowired从容器注入UserDao（按类型匹配UserDaoImpl）
    @Autowired
    private UserDao userDao;

    /**
     * 【业务逻辑】根据ID删除用户
     */
    @Override
    public boolean removeUserById(Long id) {
        return userDao.deleteById(id);
    }

    /**
     * 【业务逻辑】根据ID更新用户
     * 核心规则：先查用户是否存在，再更新
     */
    @Override
    public boolean updateUserById(Long id, SysUser sysUser) {
        if (userDao.getById(id) == null) {
            return false;
        }
        return userDao.updateById(id, sysUser);
    }

    /**
     * 【业务逻辑】新增用户
     */
    @Override
    public SysUser saveUser(SysUser sysUser) {
        return userDao.save(sysUser);
    }

    /**
     * 【业务逻辑】根据ID查询用户
     */
    @Override
    public SysUser getUserById(Long id) {
        return userDao.getById(id);
    }

    /**
     * 【业务逻辑】条件查询用户列表
     */
    @Override
    public List<SysUser> getUserList(String username, String phone, Integer status) {
        return userDao.list(username, phone, status);
    }
}

/**
 * 表现层：加@RestController（已保留），通过@Autowired注入Service（移除手动new）
 * 仅接收请求、参数校验、调用Service、返回响应
 */
@RequestMapping("user")
@RestController // 标记为Controller组件，纳入 Spring 容器
public class UserController {

    // 核心改造：移除手动new，通过@Autowired从容器注入UserService
    @Autowired
    private UserService userService;

    /**
     * 根据ID删除用户
     * 【Controller仅做：接收请求→调用Service→返回响应】
     */
    @DeleteMapping("{id}")
    public Result removeUser(HttpSession session, @PathVariable Long id) {
        boolean deleted = userService.removeUserById(id);
        if (deleted) {
            return Result.success("删除ID为" + id + "的用户成功！");
        } else {
            return Result.fail("删除失败：ID为" + id + "的用户不存在！");
        }
    }

    /**
     * 根据ID更新用户
     * 【Controller仅做：参数校验→调用Service→返回响应】
     */
    @PutMapping("{id}")
    public Result updateUser(
            HttpSession session,
            @PathVariable Long id,
            @Valid @RequestBody SysUser sysUser,
            BindingResult bindingResult){

        // 仅做参数格式校验（无业务逻辑）
        if (bindingResult.hasErrors()) {
            String errorMsg = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + "：" + error.getDefaultMessage())
                    .collect(Collectors.joining("；"));
            return Result.fail(500, "参数校验失败：" + errorMsg);
        }
        Boolean updatedUser = userService.updateUserById(id, sysUser);
        if (updatedUser){
            return Result.success("更新ID为" + id + "的用户成功！");
        }
        return Result.fail("更新失败：ID为" + id + "的用户不存在！");
    }

    /**
     * 新增用户
     * 【Controller仅做：参数校验→调用Service→返回响应】
     */
    @PostMapping
    public Result saveUser(
            HttpSession session,
            @Valid @RequestBody SysUser user,
            BindingResult bindingResult
    ) {
        // 仅做参数格式校验（无业务逻辑）
        if (bindingResult.hasErrors()) {
            String errorMsg = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + "：" + error.getDefaultMessage())
                    .collect(Collectors.joining("；"));
            return Result.fail(500, "参数校验失败：" + errorMsg);
        }

        SysUser savedUser = userService.saveUser(user);
        return Result.success("新增用户成功！", savedUser);
    }

    /**
     * 根据ID查询用户详情
     * 【Controller仅做：接收请求→调用Service→返回响应】
     */
    @GetMapping("{id}")
    public Result findById(HttpSession session, @PathVariable Long id) {
        SysUser sysUser = userService.getUserById(id);
        System.out.println("查询到的用户：" + sysUser);
        if (sysUser == null) {
            return Result.fail("查询失败：ID为" + id + "的用户不存在！");
        }
        return Result.success("查询成功！", sysUser);
    }

    /**
     * 条件查询用户列表
     * 【Controller仅做：接收请求→调用Service→返回响应】
     */
    @GetMapping("/list")
    public Result getUserList(
            HttpSession session,
            @RequestParam(required = false) String username,
            @RequestParam(required = false) String phone,
            @RequestParam(required = false) Integer status) {
        List<SysUser> sysUserList = userService.getUserList(username, phone, status);
        return Result.success("查询成功！共找到" + sysUserList.size() + "条数据", sysUserList);
    }
}

import java.util.List;

/**
 * 数据访问层：新增登录校验方法，仅调用工具类
 */
public interface UserDao {

    // 新增：登录校验（仅调用工具类，无业务逻辑）
    boolean login(String username, String password);
}

import org.springframework.stereotype.Repository;
import java.util.List;

/**
 * DAO实现类：加@Repository纳入容器，新增登录方法（仅转发调用SysUserDataUtil）
 */
@Repository // 核心：标记为DAO组件，纳入 Spring 容器
public class UserDaoImpl implements UserDao {

    // 新增：登录校验（仅调用工具类，无任何业务逻辑）
    @Override
    public boolean login(String username, String password) {
        return SysUserDataUtil.login(username, password);
    }
}

import java.util.List;

/**
 * 业务逻辑层：新增登录业务方法
 */
public interface UserService {

    // 新增：登录业务校验（可扩展登录规则，如账号是否禁用）
    boolean login(String username, String password);
}

/**
 * Service实现类：加@Service纳入容器，通过@Autowired注入DAO（移除手动new）
 * 新增登录业务逻辑，复用已有DAO实例
 */
@Service // 核心：标记为Service组件，纳入 Spring 容器
public class UserServiceImpl implements UserService {

    // 核心改造：移除手动new，通过@Autowired从容器注入UserDao
    @Autowired
    private UserDao userDao;

    // 新增：登录业务逻辑（可扩展规则，如校验账号状态、登录次数限制等）
    @Override
    public boolean login(String username, String password) {
        // 业务逻辑1：调用DAO校验账号密码（基础校验）
        boolean validateResult = userDao.login(username, password);
        if (!validateResult) {
            return false;
        }
        // 业务逻辑2：（可扩展）校验账号是否禁用（示例）
        // SysUser user = userDao.getByUsername(username); // 可新增DAO方法
        // if (user != null && 0 == user.getStatus()) {
        //     return false; // 账号禁用，登录失败
        // }

        return true;
    }
}

/**
 * 登录表现层：加@RestController（已保留），通过@Autowired注入Service（移除手动new）
 * 仅处理请求、参数校验、调用Service、操作Session、返回响应
 */
@RestController
@RequestMapping("auth")
public class LoginController {

    // 核心改造：移除手动new，通过@Autowired从容器注入UserService
    @Autowired
    private UserService userService;

    /**
     * 登录接口
     * /auth/login  post方式 请求体传递参数 username password
     * 验证成功以后，将账号存储在session!
     * 返回 {code:200,message:"登录成功",data:null}
     */
    @PostMapping("login")
    public Result login(HttpSession session, @Valid @RequestBody SysUserLoginDto user, BindingResult bindingResult) {
        // 1. 表现层职责：仅做参数格式校验（无业务逻辑）
        if (bindingResult.hasErrors()) {
            return Result.fail(500, "账号和密码不符合规则,登录失败！");
        }
        // 2. 调用Service完成登录业务校验（不直接调用工具类/DAO）
        boolean logined = userService.login(user.getUsername(), user.getPassword());
        if (!logined) {
            return Result.fail("账号或者密码错误！");
        }
        // 3. 表现层职责：操作Session（属于请求响应层面，无需走Service）
        session.setAttribute("username", user.getUsername());
        return Result.success("登录成功！");
    }

    /**
     * 退出登录接口
     * /auth/logout  get方式  没有参数
     * 清空session数据，返回成功响应
     * 返回 {code:200,message:"退出登录成功",data:null}
     */
    @GetMapping("logout")
    public Result logout(HttpSession session) {
        // 表现层职责：操作Session（无需走Service/DAO）
        session.removeAttribute("username");
        session.invalidate();
        return Result.success("退出登录成功！");
    }
}