介绍

图书管理系统是一种用于管理图书信息、借阅记录、用户信息等的软件系统。它可以帮助图书馆、书店或个人管理和组织图书资源，提供了方便的借阅和查询功能。在这篇博客中，我们将详细介绍如何使用Java编程语言创建一个简单的图书管理系统。

功能需求

在设计图书管理系统之前，我们首先需要明确系统应该具备的功能需求。以下是一个简单的功能列表：

1. 添加图书：管理员可以添加新的图书信息，包括书名、作者、出版社、ISBN号等。
2. 删除图书：管理员可以删除已有的图书信息。
3. 查询图书：用户可以通过关键字搜索图书，系统将返回匹配的图书列表。
4. 借阅图书：用户可以借阅图书，并记录借阅时间。
5. 归还图书：用户可以归还已借阅的图书，并记录归还时间。
6. 查看借阅记录：用户可以查看自己的借阅记录，包括借阅时间、归还时间等。
7. 用户管理：管理员可以管理用户信息，包括添加、删除用户。
8. 权限管理：管理员可以设置用户的权限，例如普通用户和管理员用户。

数据模型

在设计图书管理系统时，首先需要考虑数据模型，即如何存储和管理图书信息、用户信息、借阅记录等数据。以下是一个简化的数据模型示意图：

Book
- ID
- Title
- Author
- Publisher
- ISBN
- Status (Available, Checked Out)
- Borrower ID (if checked out)
- Due Date (if checked out)
User
- ID
- Name
- Email
- Password
- Role (Admin, User)
BorrowRecord
- ID
- Book ID
- User ID
- Borrow Date
- Return Date

数据模型包括三个主要实体：图书（Book）、用户（User）和借阅记录（BorrowRecord）。图书实体包括图书的基本信息和当前状态，用户实体包括用户的基本信息和角色，借阅记录实体用于记录图书的借阅和归还情况。

架构设计

在开始编写代码之前，我们需要考虑系统的架构设计。通常，一个图书管理系统可以分为以下几个模块：

1. 用户管理模块：负责用户的注册、登录和权限管理。
2. 图书管理模块：负责图书的添加、删除、查询和状态管理。
3. 借阅管理模块：负责借阅和归还图书，以及记录借阅记录。
4. 数据存储模块：负责将数据存储到数据库或文件中，以及从数据库或文件中检索数据。

接下来，我们将逐步实现这些模块。

开发环境和工具

在开始编写代码之前，确保您已经准备好了以下开发环境和工具：

• Java开发工具（例如Eclipse、IntelliJ IDEA或VS Code）
• 数据库（可以选择关系型数据库如MySQL或SQLite，也可以选择文件存储）
• Java数据库连接库（例如JDBC）
• 项目构建工具（例如Maven或Gradle）

  用户管理模块

  用户实体类

  首先，让我们创建一个用户实体类，用于表示系统中的用户信息。用户实体包括ID、用户名、密码、邮箱和角色。

  public class User {
      private int id;
      private String username;
      private String password;
      private String email;
      private UserRole role;
      // 构造函数、getter和setter方法
  }
  

  UserRole是一个枚举类型，表示用户的角色，可以定义为管理员和普通用户。

  public enum UserRole {
      ADMIN,
      USER
  }
  

  用户数据访问对象（DAO）

  接下来，创建一个用户数据访问对象（DAO），用于与数据库或文件进行用户的数据交互。我们将使用JDBC（Java Database Connectivity）来连接数据库并执行数据库操作。

  首先，我们需要建立数据库连接。假设我们选择MySQL数据库，以下是建立数据库连接的示例代码：

  import java.sql.Connection;
  import java.sql.DriverManager;
  import java.sql.SQLException;
  public class DatabaseConnection {
      private static final String URL = "jdbc:mysql://localhost:3306/library";
      private static final String USERNAME = "root";
      private static final String PASSWORD = "password";
      public static Connection getConnection() throws SQLException {
          return DriverManager.getConnection(URL, USERNAME, PASSWORD);
      }
  }
  

  在上面的示例中，我们使用JDBC连接了名为"library"的MySQL数据库，使用用户名"root"和密码"password"。请根据您的实际数据库配置进行更改。

  接下来，创建一个用户DAO类，用于执行用户相关的数据库操作，包括用户的添加、删除、查询和权限管理。以下是一个简单的用户DAO示例：

  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.List;
  public class UserDao {
      private Connection connection;
      public UserDao() {
          try {
              connection = DatabaseConnection.getConnection();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 添加用户
      public void addUser(User user) {
          String sql = "INSERT INTO users (username, password, email, role) VALUES (?, ?, ?, ?)";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setString(1, user.getUsername());
              preparedStatement.setString(2, user.getPassword());
              preparedStatement.setString(3, user.getEmail());
              preparedStatement.setString(4, user.getRole().toString());
              preparedStatement.executeUpdate();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 删除用户
      public void deleteUser(int userId) {
          String sql = "DELETE FROM users WHERE id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setInt(1, userId);
              preparedStatement.executeUpdate();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 根据用户名查询用户
      public User getUserByUsername(String username) {
          String sql = "SELECT * FROM users WHERE username = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setString(1, username);
              ResultSet resultSet = preparedStatement.executeQuery();
              if (resultSet.next()) {
                  return extractUserFromResultSet(resultSet);
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return null;
      }
      // 查询所有用户
      public List getAllUsers() {
          List userList = new ArrayList<>();
          String sql = "SELECT * FROM users";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              ResultSet resultSet = preparedStatement.executeQuery();
              while (resultSet.next()) {
                  userList.add(extractUserFromResultSet(resultSet));
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return userList;
      }
      // 从ResultSet提取用户信息
      private User extractUserFromResultSet(ResultSet resultSet) throws SQLException {
          User user = new User();
          user.setId(resultSet.getInt("id"));
          user.setUsername(resultSet.getString("username"));
          user.setPassword(resultSet.getString("password"));
          user.setEmail(resultSet.getString("email"));
          user.setRole(UserRole.valueOf(resultSet.getString("role")));
          return user;
      }
  }
  

  上述示例中，我们创建了一个UserDao类，该类包含了添加用户、删除用户、查询用户和查询所有用户的方法。这些方法使用了预备语句（PreparedStatement）来执行SQL查询和更新操作，并将查询结果映射到User对象。

  用户服务类

  用户服务类用于处理用户管理模块的业务逻辑。它可以调用用户DAO来执行数据库操作，例如添加用户、删除用户、查询用户等。

  以下是一个简单的用户服务类示例：

  public class UserService {
      private UserDao userDao;
      public UserService() {
          userDao = new UserDao();
      }
      // 注册用户
      public void registerUser(String username, String password, String email, UserRole role) {
          User user = new User();
          user.setUsername(username);
          user.setPassword(password);
          user.setEmail(email);
          user.setRole(role);
          userDao.addUser(user);
      }
      // 删除用户
      public void deleteUser(int userId) {
          userDao.deleteUser(userId);
      }
      // 根据用户名查询用户
      public User getUserByUsername(String username) {
          return userDao.getUserByUsername(username);
      }
      // 查询所有用户
      public List getAllUsers() {
          return userDao.getAllUsers();
      }
  }
  

  在上面的示例中，UserService类提供了注册用户、删除用户、查询用户和查询所有用户的方法，它通过调用UserDao来实现这些功能。

  图书管理模块

  接下来，让我们创建图书管理模块，包括图书实体、图书DAO和图书服务类。

  图书实体类

  首先，创建一个图书实体类，用于表示系统中的图书信息。图书实体包括ID、书名、作者、出版社、ISBN号、状态、借阅人ID和归还日期等属性。

  public class Book {
      private int id;
      private String title;
      private String author;
      private String publisher;
      private String isbn;
      private BookStatus status;
      private int borrowerId;
      private LocalDate dueDate;
      // 构造函数、getter和setter方法
  }
  

  BookStatus是一个枚举类型，表示图书的状态，可以定义为“可借阅”和“已借出”。

  public enum BookStatus {
      AVAILABLE,
      CHECKED_OUT
  }
  

  图书数据访问对象（DAO）

  接下来，创建一个图书数据访问对象（DAO），用于执行图书相关的数据库操作，包括添加图书、删除图书、查询图书和更新图书状态。

  以下是一个简单的图书DAO示例：

  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.List;
  public class BookDao {
      private Connection connection;
      public BookDao() {
          try {
              connection = DatabaseConnection.getConnection();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 添加图书
      public void addBook(Book book) {
          String sql = "INSERT INTO books (title, author, publisher, isbn, status, borrower_id, due_date) " +
                       "VALUES (?, ?, ?, ?, ?, ?, ?)";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setString(1, book.getTitle());
              preparedStatement.setString(2, book.getAuthor());
              preparedStatement.setString(3, book.getPublisher());
              preparedStatement.setString(4, book.getIsbn());
              preparedStatement.setString(5, book.getStatus().toString());
              preparedStatement.setInt(6, book.getBorrowerId());
              preparedStatement.setDate(7, Date.valueOf(book.getDueDate()));
              preparedStatement.executeUpdate();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 删除图书
      public void deleteBook(int bookId) {
          String sql = "DELETE FROM books WHERE id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setInt(1, bookId);
              preparedStatement.executeUpdate();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 根据ID查询图书
      public Book getBookById(int bookId) {
          String sql = "SELECT * FROM books WHERE id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setInt(1, bookId);
              ResultSet resultSet = preparedStatement.executeQuery();
              if (resultSet.next()) {
                  return extractBookFromResultSet(resultSet);
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return null;
      }
      // 查询所有图书
      public List getAllBooks() {
          List bookList = new ArrayList<>();
          String sql = "SELECT * FROM books";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              ResultSet resultSet = preparedStatement.executeQuery();
              while (resultSet.next()) {
                  bookList.add(extractBookFromResultSet(resultSet));
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return bookList;
      }
      // 更新图书状态
      public void updateBookStatus(int bookId, BookStatus status, int borrowerId, LocalDate dueDate) {
          String sql = "UPDATE books SET status = ?, borrower_id = ?, due_date = ? WHERE id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setString(1, status.toString());
              preparedStatement.setInt(2, borrowerId);
              preparedStatement.setDate(3, Date.valueOf(dueDate));
              preparedStatement.setInt(4, bookId);
              preparedStatement.executeUpdate();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 从ResultSet提取图书信息
      private Book extractBookFromResultSet(ResultSet resultSet) throws SQLException {
          Book book = new Book();
          book.setId(resultSet.getInt("id"));
          book.setTitle(resultSet.getString("title"));
          book.setAuthor(resultSet.getString("author"));
          book.setPublisher(resultSet.getString("publisher"));
          book.setIsbn(resultSet.getString("isbn"));
          book.setStatus(BookStatus.valueOf(resultSet.getString("status")));
          book.setBorrowerId(resultSet.getInt("borrower_id"));
          book.setDueDate(resultSet.getDate("due_date").toLocalDate());
          return book;
      }
  }
  

  上述示例中，我们创建了一个BookDao类，该类包含了添加图书、删除图书、查询图书、更新图书状态和查询所有图书的方法。这些方法使用了预备语句（PreparedStatement）来执行SQL查询和更新操作，并将查询结果映射到Book对象。

  图书服务类

  图书服务类用于处理图书管理模块的业务逻辑。它可以调用图书DAO来执行数据库操作，例如添加图书、删除图书、查询图书等。

  以下是一个简单的图书服务类示例：

  import java.util.List;
  public class BookService {
      private BookDao bookDao;
      public BookService() {
          bookDao = new BookDao();
      }
      // 添加图书
      public void addBook(String title, String author, String publisher, String isbn) {
          Book book = new Book();
          book.setTitle(title);
          book.setAuthor(author);
          book.setPublisher(publisher);
          book.setIsbn(isbn);
          book.setStatus(BookStatus.AVAILABLE); // 默认设置为可借阅状态
          bookDao.addBook(book);
      }
      // 删除图书
      public void deleteBook(int bookId) {
          bookDao.deleteBook(bookId);
      }
      // 根据ID查询图书
      public Book getBookById(int bookId) {
          return bookDao.getBookById(bookId);
      }
      // 查询所有图书
      public List getAllBooks() {
          return bookDao.getAllBooks();
      }
      // 借阅图书
      public void borrowBook(int bookId, int userId, LocalDate dueDate) {
          Book book = bookDao.getBookById(bookId);
          if (book.getStatus() == BookStatus.AVAILABLE) {
              book.setStatus(BookStatus.CHECKED_OUT);
              book.setBorrowerId(userId);
              book.setDueDate(dueDate);
              bookDao.updateBookStatus(bookId, book.getStatus(), book.getBorrowerId(), book.getDueDate());
          }
      }
      // 归还图书
      public void returnBook(int bookId) {
          Book book = bookDao.getBookById(bookId);
          if (book.getStatus() == BookStatus.CHECKED_OUT) {
              book.setStatus(BookStatus.AVAILABLE);
              book.setBorrowerId(0);
              book.setDueDate(null);
              bookDao.updateBookStatus(bookId, book.getStatus(), book.getBorrowerId(), book.getDueDate());
          }
      }
  }
  

  在上面的示例中，BookService类提供了添加图书、删除图书、查询图书、借阅图书和归还图书的方法，它通过调用BookDao来实现这些功能。

  借阅管理模块

  借阅管理模块负责处理用户借阅和归还图书的操作，并记录借阅记录。

  借阅记录实体类

  首先，创建一个借阅记录实体类，用于表示用户的借阅记录。借阅记录实体包括ID、图书ID、用户ID、借阅日期和归还日期。

  public class BorrowRecord {
      private int id;
      private int bookId;
      private int userId;
      private LocalDate borrowDate;
      private LocalDate returnDate;
      // 构造函数、getter和setter方法
  }
  

  借阅记录数据访问对象（DAO）

  接下来，创建一个借阅记录数据访问对象（DAO），用于执行借阅记录相关的数据库操作，包括记录借阅和归还图书。

  以下是一个简单的借阅记录DAO示例：

  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.List;
  public class BorrowRecordDao {
      private Connection connection;
      public BorrowRecordDao() {
          try {
              connection = DatabaseConnection.getConnection();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 记录借阅
      public void borrowBook(int bookId, int userId, LocalDate borrowDate) {
          String sql = "INSERT INTO borrow_records (book_id, user_id, borrow_date) VALUES (?, ?, ?)";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setInt(1, bookId);
              preparedStatement.setInt(2, userId);
              preparedStatement.setDate(3, Date.valueOf(borrowDate));
              preparedStatement.executeUpdate();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      // 记录归还
      public void returnBook(int bookId, LocalDate returnDate) {
          String sql = "UPDATE borrow_records SET return_date = ? WHERE book_id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setDate(1, Date.valueOf(returnDate));
              preparedStatement.setInt(2, bookId);
              preparedStatement.executeUpdate();
          } catch (SQLException
          e) {
              e.printStackTrace();
          }
      }
      // 查询用户的借阅记录
      public List getBorrowRecordsByUserId(int userId) {
          List recordList = new ArrayList<>();
          String sql = "SELECT * FROM borrow_records WHERE user_id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setInt(1, userId);
              ResultSet resultSet = preparedStatement.executeQuery();
              while (resultSet.next()) {
                  recordList.add(extractBorrowRecordFromResultSet(resultSet));
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return recordList;
      }
      // 查询图书的借阅记录
      public List getBorrowRecordsByBookId(int bookId) {
          List recordList = new ArrayList<>();
          String sql = "SELECT * FROM borrow_records WHERE book_id = ?";
          try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
              preparedStatement.setInt(1, bookId);
              ResultSet resultSet = preparedStatement.executeQuery();
              while (resultSet.next()) {
                  recordList.add(extractBorrowRecordFromResultSet(resultSet));
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return recordList;
      }
      // 从ResultSet提取借阅记录信息
      private BorrowRecord extractBorrowRecordFromResultSet(ResultSet resultSet) throws SQLException {
          BorrowRecord record = new BorrowRecord();
          record.setId(resultSet.getInt("id"));
          record.setBookId(resultSet.getInt("book_id"));
          record.setUserId(resultSet.getInt("user_id"));
          record.setBorrowDate(resultSet.getDate("borrow_date").toLocalDate());
          if (resultSet.getDate("return_date") != null) {
              record.setReturnDate(resultSet.getDate("return_date").toLocalDate());
          }
          return record;
      }
  }
  

  上述示例中，我们创建了一个BorrowRecordDao类，该类包含了记录借阅和归还图书、查询用户的借阅记录以及查询图书的借阅记录等方法。这些方法使用了预备语句（PreparedStatement）来执行SQL查询和更新操作，并将查询结果映射到BorrowRecord对象。

  借阅记录服务类

  借阅记录服务类用于处理借阅管理模块的业务逻辑。它可以调用借阅记录DAO来执行数据库操作，例如记录借阅和归还图书、查询用户的借阅记录以及查询图书的借阅记录。

  以下是一个简单的借阅记录服务类示例：

  import java.util.List;
  public class BorrowRecordService {
      private BorrowRecordDao borrowRecordDao;
      public BorrowRecordService() {
          borrowRecordDao = new BorrowRecordDao();
      }
      // 记录借阅
      public void borrowBook(int bookId, int userId, LocalDate borrowDate) {
          borrowRecordDao.borrowBook(bookId, userId, borrowDate);
      }
      // 记录归还
      public void returnBook(int bookId, LocalDate returnDate) {
          borrowRecordDao.returnBook(bookId, returnDate);
      }
      // 查询用户的借阅记录
      public List getBorrowRecordsByUserId(int userId) {
          return borrowRecordDao.getBorrowRecordsByUserId(userId);
      }
      // 查询图书的借阅记录
      public List getBorrowRecordsByBookId(int bookId) {
          return borrowRecordDao.getBorrowRecordsByBookId(bookId);
      }
  }
  

  在上面的示例中，BorrowRecordService类提供了记录借阅和归还图书、查询用户的借阅记录以及查询图书的借阅记录的方法，它通过调用BorrowRecordDao来实现这些功能。

  数据存储模块

  数据存储模块负责将数据存储到数据库或文件中，以及从数据库或文件中检索数据。在本示例中，我们使用了数据库作为数据存储的方式。您可以根据需要选择适当的数据存储方式。

  用户界面

  最后，我们需要创建一个用户界面，允许用户与图书管理系统进行交互。用户界面可以是命令行界面、图形界面或Web界面，具体实现方式取决于您的需求和技术栈。用户界面需要调用用户服务类、图书服务类和借阅记录服务类来实现用户注册、登录、添加图书、借阅图书、归还图书等功能。

  以下是一个简单的命令行用户界面示例：

  import java.time.LocalDate;
  import java.util.List;
  import java.util.Scanner;
  public class LibraryManagementSystem {
      private UserService userService;
      private BookService bookService;
      private BorrowRecordService borrowRecordService;
      private User currentUser;
      public LibraryManagementSystem() {
          userService = new UserService();
          bookService = new BookService();
          borrowRecordService = new BorrowRecordService();
      }
      public void run() {
          Scanner scanner = new Scanner(System.in);
          while (true) {
              if (currentUser == null) {
                  System.out.println("Welcome to the Library Management System!");
                  System.out.println("1. Register");
                  System.out.println("2. Login");
                  System.out.println("3. Exit");
                  System.out.print("Please select an option: ");
                  int choice = scanner.nextInt();
                  scanner.nextLine(); // Consume newline
                  switch (choice) {
                      case 1:
                          registerUser(scanner);
                          break;
                      case 2:
                          loginUser(scanner);
                          break;
                      case 3:
                          System.out.println("Goodbye!");
                          return;
                      default:
                          System.out.println("Invalid option. Please try again.");
                          break;
                  }
              } else {
                  System.out.println("Welcome, " + currentUser.getUsername() + "!");
                  System.out.println("1. Add Book");
                  System.out.println("2. Borrow Book");
                  System.out.println("3. Return Book");
                  System.out.println("4. View Borrowed Books");
                  System.out.println("5. Logout");
                  System.out.print("Please select an option: ");
                  int choice = scanner.nextInt();
                  scanner.nextLine(); // Consume newline
                  switch (choice) {
                      case 1:
                          addBook(scanner);
                          break;
                      case 2:
                          borrowBook(scanner);
                          break;
                      case 3:
                          returnBook(scanner);
                          break;
                      case 4:
                          viewBorrowedBooks();
                          break;
                      case 5:
                          currentUser = null;
                          System.out.println("Logged out successfully.");
                          break;
                      default:
                          System.out.println("Invalid option. Please try again.");
                          break;
                  }
              }
          }
      }
      private void registerUser(Scanner scanner) {
          System.out.print("Enter username: ");
          String username = scanner.nextLine();
          System.out.print("Enter password: ");
          String password = scanner.nextLine();
          System.out.print("Enter email: ");
          String email = scanner.nextLine();
          // Assume default role is USER
          UserRole role = UserRole.USER;
          userService.registerUser(username, password, email, role);
          System.out.println("Registration successful. You can now log in.");
      }
      private void loginUser(Scanner scanner) {
          System.out.print("Enter username: ");
          String username = scanner.nextLine();
          System.out.print("Enter password: ");
          String password = scanner.nextLine();
          currentUser = userService.getUserByUsername(username);
          if (currentUser != null && currentUser.getPassword().equals(password)) {
              System.out.println("Login successful. Welcome, " + currentUser.getUsername() + "!");
          } else {
              currentUser = null;
              System.out.println("Login failed. Please check your username and password.");
          }
      }
      private void addBook(Scanner scanner) {
          System.out.print("Enter book title: ");
          String title = scanner.nextLine();
          System.out.print("Enter author: ");
          String author = scanner.nextLine();
          System.out.print("Enter publisher: ");
          String publisher = scanner.nextLine();
          System.out.print("Enter ISBN: ");
          String isbn = scanner.nextLine();
          bookService.addBook(title, author, publisher, isbn);
          System.out.println("Book added successfully.");
      }
      private void borrowBook(Scanner scanner) {
          System.out.print("Enter book ID to borrow: ");
          int bookId = scanner.nextInt();
          scanner.nextLine(); // Consume newline
          LocalDate dueDate = LocalDate.now().plusWeeks(2); // Borrow period of 2 weeks
          bookService.borrowBook(bookId, currentUser.getId(), dueDate);
          System.out.println("Book borrowed successfully.");
      }
      private void returnBook(Scanner scanner) {
          System.out.print("Enter book ID to return: ");
          int bookId = scanner.nextInt();
          scanner.nextLine(); // Consume newline
          bookService.returnBook(bookId);
          System.out.println("Book returned successfully.");
      }
      private void viewBorrowedBooks() {
          List borrowRecords = borrowRecordService.getBorrowRecordsByUserId(currentUser.getId());
          if (borrowRecords.isEmpty()) {
              System.out.println("You have not borrowed any books.");
          } else {
              System.out.println("Your borrowed books:");
              for (BorrowRecord record : borrowRecords) {
                  Book book = bookService.getBookById(record.getBookId());
                  System.out.println("Book Title: " + book.getTitle());
                  System.out.println("Borrow Date: " + record.getBorrowDate
  () + "   Due Date: " + record.getDueDate());
                  System.out.println("------------------------------------------------");
              }
          }
      }
      public static void main(String[] args) {
          LibraryManagementSystem libraryManagementSystem = new LibraryManagementSystem();
          libraryManagementSystem.run();
      }
  }
  

  在上述示例中，我们创建了一个简单的命令行用户界面，允许用户注册、登录、添加图书、借阅图书、归还图书以及查看已借阅的图书。界面根据用户的登录状态显示不同的选项。

  总结

  通过本博客，我们详细介绍了如何使用Java编程语言创建一个简单的图书管理系统。系统包括用户管理模块、图书管理模块和借阅管理模块，以及相应的数据模型、数据访问对象和服务类。此外，我们还提供了一个简单的命令行用户界面，允许用户与系统进行交互。

  要构建完整的图书管理系统，您可能需要进一步扩展和优化代码，包括添加异常处理、安全性、性能优化等方面的功能。希望本博客能够帮助初学者了解如何使用Java创建一个基本的图书管理系统，并为后续学习和开发提供参考。

  作者信息 作者 ： 繁依Fanyi CSDN： https://techfanyi.blog.csdn.net 掘金：https://juejin.cn/user/4154386571867191

   
   邢台网站  公司网络营销策划书  广告设计与制作  网站设计报价明细表  中国建筑网建设通查询  怎么注册公司企业邮箱