AI生成代码（待修改）

src/AbstractProblemGenerator.java

@@ -0,0 +1,51 @@
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+/**
+ * 抽象题目生成器，提供了题目生成的通用模板方法。
+ * 封装了唯一性检查和主生成循环。
+ */
+public abstract class AbstractProblemGenerator implements IProblemGenerator {
+
+  protected static final Random random = new Random();
+  protected static final int MIN_OPERAND = 1;
+  protected static final int MAX_OPERAND = 100;
+
+  @Override
+  public List<Equation> generate(int count, Set<String> existingProblems) {
+    List<Equation> newProblems = new ArrayList<>();
+    Set<String> currentBatchCanonicalForms = new HashSet<>();
+
+    // 为了避免无限循环，设置一个最大尝试次数
+    int maxAttempts = count * 100;
+    int attempts = 0;
+
+    while (newProblems.size() < count && attempts < maxAttempts) {
+      Equation candidate = createSingleProblem();
+      String canonicalForm = candidate.toCanonicalString();
+
+      // 检查是否与历史题目或本次生成的题目重复
+      if (!existingProblems.contains(canonicalForm) &&!currentBatchCanonicalForms.contains(canonicalForm)) {
+        newProblems.add(candidate);
+        currentBatchCanonicalForms.add(canonicalForm);
+      }
+      attempts++;
+    }
+
+    if (newProblems.size() < count) {
+      System.err.println("警告: 未能生成足够数量的唯一题目。可能题库已饱和。");
+    }
+
+    return newProblems;
+  }
+
+  /**
+   * 创建单个数学题目的抽象方法，由子类实现具体逻辑。
+   *
+   * @return 一个新的 Equation 实例
+   */
+  protected abstract Equation createSingleProblem();
+}

src/Application.java

@@ -0,0 +1,125 @@
+import java.util.List;
+import java.util.Scanner;
+import java.util.Set;
+
+/**
+ * 应用程序的主入口和控制器。
+ * 负责管理应用生命周期、解析用户输入并协调各服务。
+ */
+public class Application {
+
+  private static final int MIN_PROBLEMS = 10;
+  private static final int MAX_PROBLEMS = 30;
+
+  // 依赖注入：在主类中创建和组装服务
+  private final Scanner scanner = new Scanner(System.in);
+  private final AuthService authService = new AuthService(new InMemoryUserRepository());
+  private final SessionManager sessionManager = SessionManager.getInstance();
+  private final IFileService fileService = new TextFilePersistence();
+
+  public static void main(String args) {
+    Application app = new Application();
+    app.run();
+  }
+
+  /**
+   * 启动并运行应用程序的主循环。
+   */
+  public void run() {
+    System.out.println("欢迎使用模块化数学题目生成系统！");
+    while (true) {
+      if (!sessionManager.isUserLoggedIn()) {
+        handleLoggedOutState();
+      } else {
+        handleLoggedInState();
+      }
+    }
+  }
+
+  /**
+   * 处理用户未登录时的交互逻辑。
+   */
+  private void handleLoggedOutState() {
+    System.out.print("请输入用户名和密码（用空格隔开）: ");
+    String credentials = scanner.nextLine().split("\\s+");
+    if (credentials.length!= 2) {
+      System.out.println("输入格式错误，请重新输入。");
+      return;
+    }
+
+    authService.login(credentials, credentials)
+            .ifPresentOrElse(
+                    sessionManager::startSession,
+                    () -> System.out.println("请输入正确的用户名、密码")
+            );
+  }
+
+  /**
+   * 处理用户已登录时的交互逻辑。
+   */
+  private void handleLoggedInState() {
+    String levelName = sessionManager.getCurrentLevel().getDisplayName();
+    System.out.printf("当前选择为%s出题，准备生成%s数学题目，请输入生成题目数量（输入-1将退出当前用户，重新登录）：%n", levelName, levelName);
+
+    String input = scanner.nextLine().trim();
+
+    if (input.equals("-1")) {
+      sessionManager.endSession();
+      System.out.println("已退出当前用户。");
+      return;
+    }
+
+    if (input.startsWith("切换为")) {
+      handleSwitchLevel(input);
+      return;
+    }
+
+    try {
+      int count = Integer.parseInt(input);
+      if (count >= MIN_PROBLEMS && count <= MAX_PROBLEMS) {
+        generateAndSaveProblems(count);
+      } else {
+        System.out.printf("题目数量的有效输入范围是“%d-%d”。%n", MIN_PROBLEMS, MAX_PROBLEMS);
+      }
+    } catch (NumberFormatException e) {
+      System.out.println("无效输入，请输入数字或有效指令。");
+    }
+  }
+
+  /**
+   * 处理切换题目类型的逻辑。
+   *
+   * @param input 用户的输入指令，如 "切换为初中"
+   */
+  private void handleSwitchLevel(String input) {
+    String targetLevelName = input.substring("切换为".length());
+    EducationLevel targetLevel = EducationLevel.fromDisplayName(targetLevelName);
+
+    if (targetLevel!= null) {
+      sessionManager.setCurrentLevel(targetLevel);
+      System.out.printf("切换成功，当前选择为%s出题。%n", targetLevelName);
+    } else {
+      System.out.println("请输入小学、初中和高中三个选项中的一个");
+    }
+  }
+
+  /**
+   * 协调题目生成和保存的整个流程。
+   *
+   * @param count 要生成的题目数量
+   */
+  private void generateAndSaveProblems(int count) {
+    User currentUser = sessionManager.getCurrentUser();
+    System.out.println("正在加载历史题目以确保唯一性...");
+    Set<String> history = fileService.loadAllProblemHistory(currentUser);
+
+    System.out.println("正在生成题目...");
+    List<Equation> newProblems = sessionManager.getCurrentGenerator().generate(count, history);
+
+    if (!newProblems.isEmpty()) {
+      fileService.saveProblems(currentUser, newProblems);
+    } else {
+      System.out.println("未能生成任何新题目。");
+    }
+  }
+}

src/AuthService.java

@@ -0,0 +1,31 @@
+import java.util.Optional;
+
+/**
+ * 认证服务，处理用户登录逻辑。
+ * 这是一个无状态的服务类。
+ */
+public class AuthService {
+
+  private final UserRepository userRepository;
+
+  /**
+   * 构造一个认证服务。
+   *
+   * @param userRepository 用户仓库的实例
+   */
+  public AuthService(UserRepository userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  /**
+   * 验证用户凭证。
+   *
+   * @param username 用户名
+   * @param password 密码
+   * @return 如果凭证有效，则返回包含用户对象的 Optional；否则返回空的 Optional
+   */
+  public Optional<User> login(String username, String password) {
+    return userRepository.findByUsername(username)
+            .filter(user -> user.password().equals(password));
+  }
+}

src/EducationLevel.java

@@ -0,0 +1,38 @@
+/**
+ * 枚举类，表示用户的教育水平或题目难度级别。
+ */
+public enum EducationLevel {
+  PRIMARY("小学"),
+  MIDDLE("初中"),
+  HIGH("高中");
+
+  private final String displayName;
+
+  EducationLevel(String displayName) {
+    this.displayName = displayName;
+  }
+
+  /**
+   * 获取级别的中文显示名称。
+   *
+   * @return 显示名称字符串
+   */
+  public String getDisplayName() {
+    return displayName;
+  }
+
+  /**
+   * 根据显示的中文名查找对应的枚举实例。
+   *
+   * @param displayName 要查找的中文名
+   * @return 对应的 EducationLevel 实例，如果未找到则返回 null
+   */
+  public static EducationLevel fromDisplayName(String displayName) {
+    for (EducationLevel level : EducationLevel.values()) {
+      if (level.getDisplayName().equals(displayName)) {
+        return level;
+      }
+    }
+    return null;
+  }
+}

src/ElementaryProblemGenerator.java

@@ -0,0 +1,29 @@
+import java.util.List;
+
+/**
+ * 小学难度题目生成器。
+ * 规则：两个1-100的操作数，仅含加减法，减法结果不能为负。
+ */
+public class ElementaryProblemGenerator extends AbstractProblemGenerator {
+
+  @Override
+  protected Equation createSingleProblem() {
+    int operand1 = random.nextInt(MAX_OPERAND) + MIN_OPERAND;
+    int operand2 = random.nextInt(MAX_OPERAND) + MIN_OPERAND;
+
+    // 随机选择加法或减法
+    if (random.nextBoolean()) {
+      // 加法
+      return new Equation(List.of(operand1, operand2), List.of(Operator.ADD));
+    } else {
+      // 减法，确保结果非负
+      if (operand1 < operand2) {
+        // 如果第一个数小，则交换它们
+        int temp = operand1;
+        operand1 = operand2;
+        operand2 = temp;
+      }
+      return new Equation(List.of(operand1, operand2), List.of(Operator.SUBTRACT));
+    }
+  }
+}

src/Equation.java

@@ -0,0 +1,98 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * 领域实体，表示一个数学方程式。
+ * 包含了操作数、操作符、计算结果，并能生成不同格式的字符串表示。
+ */
+public class Equation {
+
+  private final List<Integer> operands;
+  private final List<Operator> operators;
+  private final int result;
+
+  /**
+   * 构造一个新的方程式。
+   *
+   * @param operands 操作数列表
+   * @param operators 操作符列表
+   */
+  public Equation(List<Integer> operands, List<Operator> operators) {
+    this.operands = List.copyOf(operands);
+    this.operators = List.copyOf(operators);
+    this.result = calculate();
+  }
+
+  /**
+   * 计算方程式的结果。
+   * 当前实现为简单的从左到右计算，未考虑运算符优先级。
+   *
+   * @return 计算结果
+   */
+  private int calculate() {
+    if (operands.isEmpty()) {
+      return 0;
+    }
+    int currentResult = operands.get(0);
+    for (int i = 0; i < operators.size(); i++) {
+      currentResult = operators.get(i).apply(currentResult, operands.get(i + 1));
+    }
+    return currentResult;
+  }
+
+  /**
+   * 生成用于显示和保存到文件的标准字符串格式。
+   * 示例: "35 + 12 = 47"
+   *
+   * @return 格式化的方程式字符串
+   */
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append(operands.get(0));
+    for (int i = 0; i < operators.size(); i++) {
+      sb.append(" ").append(operators.get(i).getSymbol()).append(" ").append(operands.get(i + 1));
+    }
+    sb.append(" = ").append(result);
+    return sb.toString();
+  }
+
+  /**
+   * 生成一个“规范化”的字符串表示，用于唯一性检查。
+   * 对于可交换的运算符 (+, *)，操作数会按升序排列，以确保 "3 + 5" 和 "5 + 3"
+   * 具有相同的规范化形式。
+   *
+   * @return 规范化的方程式字符串
+   */
+  public String toCanonicalString() {
+    if (operators.size()!= 1) {
+      // 对于多操作符的复杂情况，暂不进行排序，直接返回标准形式
+      return getSimpleExpression();
+    }
+
+    Operator op = operators.get(0);
+    if (op == Operator.ADD || op == Operator.MULTIPLY) {
+      List<Integer> sortedOperands = new ArrayList<>(operands);
+      Collections.sort(sortedOperands);
+      return sortedOperands.get(0) + " " + op.getSymbol() + " " + sortedOperands.get(1);
+    }
+
+    return getSimpleExpression();
+  }
+
+  /**
+   * 获取不包含答案的表达式部分。
+   *
+   * @return 表达式字符串
+   */
+  private String getSimpleExpression() {
+    StringBuilder sb = new StringBuilder();
+    sb.append(operands.get(0));
+    for (int i = 0; i < operators.size(); i++) {
+      sb.append(" ").append(operators.get(i).getSymbol()).append(" ").append(operands.get(i + 1));
+    }
+    return sb.toString();
+  }
+}

src/HighSchoolProblemGenerator.java

@@ -0,0 +1,30 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 高中难度题目生成器。
+ * 规则：3-5个操作数，混合使用四则运算。
+ */
+public class HighSchoolProblemGenerator extends AbstractProblemGenerator {
+
+  private static final Operator OPERATORS = {
+          Operator.ADD, Operator.SUBTRACT, Operator.MULTIPLY
+  }; // 暂时排除除法以简化生成逻辑
+
+  @Override
+  protected Equation createSingleProblem() {
+    int numOperands = random.nextInt(3) + 3; // 3到5个操作数
+    List<Integer> operands = new ArrayList<>();
+    List<Operator> operators = new ArrayList<>();
+
+    for (int i = 0; i < numOperands; i++) {
+      operands.add(random.nextInt(MAX_OPERAND) + MIN_OPERAND);
+    }
+
+    for (int i = 0; i < numOperands - 1; i++) {
+      operators.add(OPERATORS);
+    }
+
+    return new Equation(operands, operators);
+  }
+}

src/IFileService.java

@@ -0,0 +1,24 @@
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 文件服务接口，定义了数据持久化操作的契约。
+ */
+public interface IFileService {
+
+  /**
+   * 将生成的题目列表保存到为指定用户生成的新文件中。
+   *
+   * @param user 当前用户
+   * @param problems 要保存的题目列表
+   */
+  void saveProblems(User user, List<Equation> problems);
+
+  /**
+   * 加载指定用户的所有历史题目记录。
+   *
+   * @param user 要加载历史记录的用户
+   * @return 一个包含所有历史题目规范化字符串的集合
+   */
+  Set<String> loadAllProblemHistory(User user);
+}

src/IProblemGenerator.java

@@ -0,0 +1,18 @@
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 题目生成器接口 (策略接口)。
+ * 定义了所有具体题目生成器必须遵守的契约。
+ */
+public interface IProblemGenerator {
+
+  /**
+   * 生成指定数量的、不重复的数学题目。
+   *
+   * @param count 要生成的题目数量
+   * @param existingProblems 一个包含历史题目规范化字符串的集合，用于唯一性检查
+   * @return 一个包含新生成的 Equation 对象的列表
+   */
+  List<Equation> generate(int count, Set<String> existingProblems);
+}

src/InMemoryUserRepository.java

@@ -0,0 +1,33 @@
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 用户仓库的内存实现。
+ * 在程序启动时预加载所有预设的用户账户。
+ */
+public class InMemoryUserRepository implements UserRepository {
+
+  private static final Map<String, User> userDatabase = new ConcurrentHashMap<>();
+
+  // 静态初始化块，用于加载预设用户数据
+  static {
+    // 小学老师
+    userDatabase.put("primary_teacher1", new User("primary_teacher1", "p123", EducationLevel.PRIMARY));
+    userDatabase.put("primary_teacher2", new User("primary_teacher2", "p123", EducationLevel.PRIMARY));
+    userDatabase.put("primary_teacher3", new User("primary_teacher3", "p123", EducationLevel.PRIMARY));
+    // 初中老师
+    userDatabase.put("middle_teacher1", new User("middle_teacher1", "m123", EducationLevel.MIDDLE));
+    userDatabase.put("middle_teacher2", new User("middle_teacher2", "m123", EducationLevel.MIDDLE));
+    userDatabase.put("middle_teacher3", new User("middle_teacher3", "m123", EducationLevel.MIDDLE));
+    // 高中老师
+    userDatabase.put("high_teacher1", new User("high_teacher1", "h123", EducationLevel.HIGH));
+    userDatabase.put("high_teacher2", new User("high_teacher2", "h123", EducationLevel.HIGH));
+    userDatabase.put("high_teacher3", new User("high_teacher3", "h123", EducationLevel.HIGH));
+  }
+
+  @Override
+  public Optional<User> findByUsername(String username) {
+    return Optional.ofNullable(userDatabase.get(username));
+  }
+}

src/MiddleSchoolProblemGenerator.java

@@ -0,0 +1,30 @@
+import java.util.List;
+
+/**
+ * 初中难度题目生成器。
+ * 规则：2-3个操作数，包含加减乘除，除法结果必须为整数。
+ */
+public class MiddleSchoolProblemGenerator extends AbstractProblemGenerator {
+
+  private static final Operator OPERATORS = {
+          Operator.ADD, Operator.SUBTRACT, Operator.MULTIPLY, Operator.DIVIDE
+  };
+
+  @Override
+  protected Equation createSingleProblem() {
+    // 简单实现：目前仅生成两个操作数的题目
+    Operator operator = OPERATORS;
+
+    if (operator == Operator.DIVIDE) {
+      // 为除法生成能整除的数
+      int divisor = random.nextInt(MAX_OPERAND - 1) + 2; // 除数不为0或1
+      int quotient = random.nextInt(MAX_OPERAND / divisor) + 1;
+      int dividend = divisor * quotient;
+      return new Equation(List.of(dividend, divisor), List.of(Operator.DIVIDE));
+    } else {
+      int operand1 = random.nextInt(MAX_OPERAND) + MIN_OPERAND;
+      int operand2 = random.nextInt(MAX_OPERAND) + MIN_OPERAND;
+      return new Equation(List.of(operand1, operand2), List.of(operator));
+    }
+  }
+}

src/Operator.java

@@ -0,0 +1,40 @@
+import java.util.function.IntBinaryOperator;
+
+/**
+ * 枚举类，表示数学运算符及其相关操作。
+ * 封装了符号和对应的计算逻辑。
+ */
+public enum Operator {
+  ADD('+', (a, b) -> a + b),
+  SUBTRACT('-', (a, b) -> a - b),
+  MULTIPLY('*', (a, b) -> a * b),
+  DIVIDE('/', (a, b) -> a / b);
+
+  private final char symbol;
+  private final IntBinaryOperator operation;
+
+  Operator(char symbol, IntBinaryOperator operation) {
+    this.symbol = symbol;
+    this.operation = operation;
+  }
+
+  /**
+   * 获取运算符的字符表示。
+   *
+   * @return 运算符符号
+   */
+  public char getSymbol() {
+    return symbol;
+  }
+
+  /**
+   * 应用该运算符于两个操作数。
+   *
+   * @param a 第一个操作数
+   * @param b 第二个操作数
+   * @return 计算结果
+   */
+  public int apply(int a, int b) {
+    return operation.applyAsInt(a, b);
+  }
+}

src/SessionManager.java

@@ -0,0 +1,79 @@
+/**
+ * 会话管理器，使用单例模式管理当前应用的会话状态。
+ * 负责跟踪当前登录的用户和选择的题目生成器。
+ */
+public class SessionManager {
+
+  private static final SessionManager INSTANCE = new SessionManager();
+
+  private User currentUser;
+  private IProblemGenerator currentGenerator;
+  private EducationLevel currentLevel;
+
+  private SessionManager() {
+    // 私有构造函数防止外部实例化
+  }
+
+  /**
+   * 获取 SessionManager 的唯一实例。
+   *
+   * @return SessionManager 实例
+   */
+  public static SessionManager getInstance() {
+    return INSTANCE;
+  }
+
+  /**
+   * 在用户成功登录后启动一个会话。
+   *
+   * @param user 登录的用户
+   */
+  public void startSession(User user) {
+    this.currentUser = user;
+    setCurrentLevel(user.defaultLevel());
+  }
+
+  /**
+   * 结束当前会话 (用户退出登录)。
+   */
+  public void endSession() {
+    this.currentUser = null;
+    this.currentGenerator = null;
+    this.currentLevel = null;
+  }
+
+  /**
+   * 检查当前是否有用户登录。
+   *
+   * @return 如果有用户登录则为 true，否则为 false
+   */
+  public boolean isUserLoggedIn() {
+    return currentUser!= null;
+  }
+
+  public User getCurrentUser() {
+    return currentUser;
+  }
+
+  public IProblemGenerator getCurrentGenerator() {
+    return currentGenerator;
+  }
+
+  public EducationLevel getCurrentLevel() {
+    return currentLevel;
+  }
+
+  /**
+   * 切换当前的题目难度级别和对应的生成器。
+   *
+   * @param level 要切换到的新级别
+   */
+  public void setCurrentLevel(EducationLevel level) {
+    this.currentLevel = level;
+    this.currentGenerator = switch (level) {
+      case PRIMARY -> new ElementaryProblemGenerator();
+      case MIDDLE -> new MiddleSchoolProblemGenerator();
+      case HIGH -> new HighSchoolProblemGenerator();
+    };
+  }
+}

src/TextFilePersistence.java

@@ -0,0 +1,82 @@
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 文件服务的文本文件实现。
+ * 负责将题目读写到本地文件系统。
+ */
+public class TextFilePersistence implements IFileService {
+
+  private static final DateTimeFormatter FILE_NAME_FORMATTER =
+          DateTimeFormatter.ofPattern("yyyy-MM-dd-HH-mm-ss");
+  // 正则表达式用于从文件中提取表达式部分，例如 "1. 3 + 5 = 8" -> "3 + 5"
+  private static final Pattern EXPRESSION_PATTERN = Pattern.compile("^\\d+\\.\\s*(.*?)\\s*=.*$");
+
+
+  @Override
+  public void saveProblems(User user, List<Equation> problems) {
+    String userDirectoryPath = user.getStoragePath();
+    try {
+      Files.createDirectories(Paths.get(userDirectoryPath));
+      String fileName = LocalDateTime.now().format(FILE_NAME_FORMATTER) + ".txt";
+      Path filePath = Paths.get(userDirectoryPath, fileName);
+
+      try (PrintWriter writer = new PrintWriter(Files.newBufferedWriter(filePath))) {
+        for (int i = 0; i < problems.size(); i++) {
+          writer.println((i + 1) + ". " + problems.get(i).toString());
+          if (i < problems.size() - 1) {
+            writer.println(); // 每题之间空一行
+          }
+        }
+        System.out.println("题目已成功保存至: " + filePath.toAbsolutePath());
+      }
+    } catch (IOException e) {
+      System.err.println("错误：无法保存文件。 " + e.getMessage());
+    }
+  }
+
+  @Override
+  public Set<String> loadAllProblemHistory(User user) {
+    Set<String> history = new HashSet<>();
+    File userDirectory = new File(user.getStoragePath());
+
+    if (!userDirectory.exists() ||!userDirectory.isDirectory()) {
+      return history; // 目录不存在，没有历史记录
+    }
+
+    File files = userDirectory.listFiles((dir, name) -> name.endsWith(".txt"));
+    if (files == null) {
+      return history;
+    }
+
+    for (File file : files) {
+      try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
+        String line;
+        while ((line = reader.readLine())!= null) {
+          Matcher matcher = EXPRESSION_PATTERN.matcher(line);
+          if (matcher.matches()) {
+            // 此处不进行规范化，因为生成器在检查时会进行规范化
+            // 直接添加文件中的表达式字符串
+            history.add(matcher.group(1).trim());
+          }
+        }
+      } catch (IOException e) {
+        System.err.println("警告：读取历史文件失败 " + file.getName() + "。 " + e.getMessage());
+      }
+    }
+    return history;
+  }
+}

src/User.java

@@ -0,0 +1,19 @@
+/**
+ * 用户实体类，代表一个用户账户。
+ * 这是一个不可变的数据对象 (Value Object)。
+ *
+ * @param username 用户的唯一标识符
+ * @param password 用户的密码 (在实际应用中应存储哈希值)
+ * @param defaultLevel 用户的默认出题级别
+ */
+public record User(String username, String password, EducationLevel defaultLevel) {
+
+  /**
+   * 获取该用户存储历史题目的文件夹路径。
+   *
+   * @return 文件夹路径字符串
+   */
+  public String getStoragePath() {
+    return "./" + username + "/";
+  }
+}

src/UserRepository.java

@@ -0,0 +1,16 @@
+import java.util.Optional;
+
+/**
+ * 用户仓库接口，定义了访问用户数据的契约。
+ * 这是领域层对数据持久化的抽象。
+ */
+public interface UserRepository {
+
+  /**
+   * 根据用户名查找用户。
+   *
+   * @param username 要查找的用户名
+   * @return 一个包含用户对象的 Optional，如果用户不存在则为空
+   */
+  Optional<User> findByUsername(String username);
+}