Java 图书管理系统详解-阿里云开发者社区

介绍

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

功能需求

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

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

数据模型

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

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）。图书实体包括图书的基本信息和当前状态，用户实体包括用户的基本信息和角色，借阅记录实体用于记录图书的借阅和归还情况。

架构设计

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

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

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

开发环境和工具

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

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<User> getAllUsers() {
        List<User> 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<User> 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<Book> getAllBooks() {
        List<Book> 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<Book> 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<BorrowRecord> getBorrowRecordsByUserId(int userId) {
        List<BorrowRecord> 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<BorrowRecord> getBorrowRecordsByBookId(int bookId) {
        List<BorrowRecord> 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<BorrowRecord> getBorrowRecordsByUserId(int userId) {
        return borrowRecordDao.getBorrowRecordsByUserId(userId);
    }
    // 查询图书的借阅记录
    public List<BorrowRecord> 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<BorrowRecord> 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创建一个基本的图书管理系统，并为后续学习和开发提供参考。

Java 图书管理系统详解

介绍

功能需求

数据模型

架构设计

开发环境和工具

用户管理模块

用户实体类

用户数据访问对象（DAO）

用户服务类

图书管理模块

图书实体类

图书数据访问对象（DAO）

图书服务类

借阅管理模块

借阅记录实体类

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

借阅记录服务类

数据存储模块

用户界面

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java 图书管理系统详解

介绍

功能需求

数据模型

架构设计

开发环境和工具

用户管理模块

用户实体类

用户数据访问对象（DAO）

用户服务类

图书管理模块

图书实体类

图书数据访问对象（DAO）

图书服务类

借阅管理模块

借阅记录实体类

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

借阅记录服务类

数据存储模块

用户界面

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景