怎么用Java代碼實現圖書管理系統

怎么用Java代碼實現圖書管理系統

目錄

1. 引言
2. 需求分析
3. 系統設計
   • 3.1 系統架構
   • 3.2 數據庫設計
   • 3.3 類設計
4. 環境搭建
   • 4.1 開發工具
   • 4.2 依賴管理
5. 代碼實現
   • 5.1 實體類
   • 5.2 數據庫連接
   • 5.3 數據訪問層
   • 5.4 業務邏輯層
   • 5.5 用戶界面
6. 測試與調試
7. 部署與維護
8. 總結

引言

圖書管理系統是圖書館或書店等機構用于管理圖書、讀者、借閱記錄等信息的軟件系統。通過Java編程語言實現一個圖書管理系統，可以幫助我們更好地理解面向對象編程、數據庫操作、用戶界面設計等知識。本文將詳細介紹如何使用Java代碼實現一個簡單的圖書管理系統。

需求分析

在開始編寫代碼之前，我們需要明確系統的功能需求。一個基本的圖書管理系統通常包括以下功能：

1. 圖書管理：添加、刪除、修改、查詢圖書信息。
2. 讀者管理：添加、刪除、修改、查詢讀者信息。
3. 借閱管理：記錄圖書的借閱和歸還信息。
4. 用戶權限管理：不同用戶（如管理員、普通用戶）具有不同的操作權限。
5. 數據統計：統計圖書借閱情況、讀者借閱記錄等。

系統設計

3.1 系統架構

圖書管理系統采用典型的三層架構：

1. 表現層（UI）：負責與用戶交互，展示數據和接收用戶輸入。
2. 業務邏輯層（Service）：處理業務邏輯，如借書、還書等操作。
3. 數據訪問層（DAO）：負責與數據庫交互，執行增刪改查操作。

3.2 數據庫設計

系統使用MySQL數據庫存儲數據。數據庫設計如下：

• 圖書表（Book）：

  • id：圖書ID（主鍵）
  • title：圖書標題
  • author：作者
  • publisher：出版社
  • isbn：ISBN號
  • quantity：庫存數量

• 讀者表（Reader）：

  • id：讀者ID（主鍵）
  • name：讀者姓名
  • phone：聯系電話
  • email：電子郵件

• 借閱記錄表（BorrowRecord）：

  • id：記錄ID（主鍵）
  • book_id：圖書ID（外鍵）
  • reader_id：讀者ID（外鍵）
  • borrow_date：借閱日期
  • return_date：歸還日期

3.3 類設計

根據系統需求，設計以下Java類：

• Book：圖書實體類。
• Reader：讀者實體類。
• BorrowRecord：借閱記錄實體類。
• BookDAO：圖書數據訪問類。
• ReaderDAO：讀者數據訪問類。
• BorrowRecordDAO：借閱記錄數據訪問類。
• BookService：圖書業務邏輯類。
• ReaderService：讀者業務邏輯類。
• BorrowRecordService：借閱記錄業務邏輯類。
• MainUI：主用戶界面類。

環境搭建

4.1 開發工具

• JDK：Java開發工具包，版本1.8或以上。
• IDE：推薦使用IntelliJ IDEA或Eclipse。
• MySQL：數據庫管理系統。
• Maven：項目依賴管理工具。

4.2 依賴管理

在pom.xml中添加以下依賴：

<dependencies>
    <!-- MySQL驅動 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
    <!-- JUnit測試框架 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

代碼實現

5.1 實體類

Book.java

public class Book {
    private int id;
    private String title;
    private String author;
    private String publisher;
    private String isbn;
    private int quantity;

    // 構造方法、getter和setter省略
}

Reader.java

public class Reader {
    private int id;
    private String name;
    private String phone;
    private String email;

    // 構造方法、getter和setter省略
}

BorrowRecord.java

public class BorrowRecord {
    private int id;
    private int bookId;
    private int readerId;
    private Date borrowDate;
    private Date returnDate;

    // 構造方法、getter和setter省略
}

5.2 數據庫連接

DBUtil.java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/library";
    private static final String USER = "root";
    private static final String PASSWORD = "password";

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }
}

5.3 數據訪問層

BookDAO.java

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 {
    public void addBook(Book book) throws SQLException {
        String sql = "INSERT INTO Book (title, author, publisher, isbn, quantity) VALUES (?, ?, ?, ?, ?)";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, book.getTitle());
            pstmt.setString(2, book.getAuthor());
            pstmt.setString(3, book.getPublisher());
            pstmt.setString(4, book.getIsbn());
            pstmt.setInt(5, book.getQuantity());
            pstmt.executeUpdate();
        }
    }

    public List<Book> getAllBooks() throws SQLException {
        List<Book> books = new ArrayList<>();
        String sql = "SELECT * FROM Book";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                Book book = new Book();
                book.setId(rs.getInt("id"));
                book.setTitle(rs.getString("title"));
                book.setAuthor(rs.getString("author"));
                book.setPublisher(rs.getString("publisher"));
                book.setIsbn(rs.getString("isbn"));
                book.setQuantity(rs.getInt("quantity"));
                books.add(book);
            }
        }
        return books;
    }

    // 其他方法省略
}

ReaderDAO.java

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 ReaderDAO {
    public void addReader(Reader reader) throws SQLException {
        String sql = "INSERT INTO Reader (name, phone, email) VALUES (?, ?, ?)";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, reader.getName());
            pstmt.setString(2, reader.getPhone());
            pstmt.setString(3, reader.getEmail());
            pstmt.executeUpdate();
        }
    }

    public List<Reader> getAllReaders() throws SQLException {
        List<Reader> readers = new ArrayList<>();
        String sql = "SELECT * FROM Reader";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                Reader reader = new Reader();
                reader.setId(rs.getInt("id"));
                reader.setName(rs.getString("name"));
                reader.setPhone(rs.getString("phone"));
                reader.setEmail(rs.getString("email"));
                readers.add(reader);
            }
        }
        return readers;
    }

    // 其他方法省略
}

BorrowRecordDAO.java

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 {
    public void addBorrowRecord(BorrowRecord record) throws SQLException {
        String sql = "INSERT INTO BorrowRecord (book_id, reader_id, borrow_date, return_date) VALUES (?, ?, ?, ?)";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, record.getBookId());
            pstmt.setInt(2, record.getReaderId());
            pstmt.setDate(3, new java.sql.Date(record.getBorrowDate().getTime()));
            pstmt.setDate(4, new java.sql.Date(record.getReturnDate().getTime()));
            pstmt.executeUpdate();
        }
    }

    public List<BorrowRecord> getAllBorrowRecords() throws SQLException {
        List<BorrowRecord> records = new ArrayList<>();
        String sql = "SELECT * FROM BorrowRecord";
        try (Connection conn = DBUtil.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                BorrowRecord record = new BorrowRecord();
                record.setId(rs.getInt("id"));
                record.setBookId(rs.getInt("book_id"));
                record.setReaderId(rs.getInt("reader_id"));
                record.setBorrowDate(rs.getDate("borrow_date"));
                record.setReturnDate(rs.getDate("return_date"));
                records.add(record);
            }
        }
        return records;
    }

    // 其他方法省略
}

5.4 業務邏輯層

BookService.java

import java.sql.SQLException;
import java.util.List;

public class BookService {
    private BookDAO bookDAO = new BookDAO();

    public void addBook(Book book) throws SQLException {
        bookDAO.addBook(book);
    }

    public List<Book> getAllBooks() throws SQLException {
        return bookDAO.getAllBooks();
    }

    // 其他方法省略
}

ReaderService.java

import java.sql.SQLException;
import java.util.List;

public class ReaderService {
    private ReaderDAO readerDAO = new ReaderDAO();

    public void addReader(Reader reader) throws SQLException {
        readerDAO.addReader(reader);
    }

    public List<Reader> getAllReaders() throws SQLException {
        return readerDAO.getAllReaders();
    }

    // 其他方法省略
}

BorrowRecordService.java

import java.sql.SQLException;
import java.util.List;

public class BorrowRecordService {
    private BorrowRecordDAO borrowRecordDAO = new BorrowRecordDAO();

    public void addBorrowRecord(BorrowRecord record) throws SQLException {
        borrowRecordDAO.addBorrowRecord(record);
    }

    public List<BorrowRecord> getAllBorrowRecords() throws SQLException {
        return borrowRecordDAO.getAllBorrowRecords();
    }

    // 其他方法省略
}

5.5 用戶界面

MainUI.java

import java.sql.SQLException;
import java.util.List;
import java.util.Scanner;

public class MainUI {
    private BookService bookService = new BookService();
    private ReaderService readerService = new ReaderService();
    private BorrowRecordService borrowRecordService = new BorrowRecordService();
    private Scanner scanner = new Scanner(System.in);

    public void showMenu() {
        System.out.println("1. 添加圖書");
        System.out.println("2. 查看所有圖書");
        System.out.println("3. 添加讀者");
        System.out.println("4. 查看所有讀者");
        System.out.println("5. 借閱圖書");
        System.out.println("6. 查看所有借閱記錄");
        System.out.println("0. 退出");
    }

    public void run() {
        while (true) {
            showMenu();
            System.out.print("請選擇操作：");
            int choice = scanner.nextInt();
            scanner.nextLine(); // 清除緩沖區

            try {
                switch (choice) {
                    case 1:
                        addBook();
                        break;
                    case 2:
                        showAllBooks();
                        break;
                    case 3:
                        addReader();
                        break;
                    case 4:
                        showAllReaders();
                        break;
                    case 5:
                        borrowBook();
                        break;
                    case 6:
                        showAllBorrowRecords();
                        break;
                    case 0:
                        System.out.println("退出系統");
                        return;
                    default:
                        System.out.println("無效選擇，請重新輸入");
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    private void addBook() throws SQLException {
        System.out.print("請輸入圖書標題：");
        String title = scanner.nextLine();
        System.out.print("請輸入作者：");
        String author = scanner.nextLine();
        System.out.print("請輸入出版社：");
        String publisher = scanner.nextLine();
        System.out.print("請輸入ISBN號：");
        String isbn = scanner.nextLine();
        System.out.print("請輸入庫存數量：");
        int quantity = scanner.nextInt();
        scanner.nextLine(); // 清除緩沖區

        Book book = new Book();
        book.setTitle(title);
        book.setAuthor(author);
        book.setPublisher(publisher);
        book.setIsbn(isbn);
        book.setQuantity(quantity);

        bookService.addBook(book);
        System.out.println("圖書添加成功");
    }

    private void showAllBooks() throws SQLException {
        List<Book> books = bookService.getAllBooks();
        for (Book book : books) {
            System.out.println(book);
        }
    }

    private void addReader() throws SQLException {
        System.out.print("請輸入讀者姓名：");
        String name = scanner.nextLine();
        System.out.print("請輸入聯系電話：");
        String phone = scanner.nextLine();
        System.out.print("請輸入電子郵件：");
        String email = scanner.nextLine();

        Reader reader = new Reader();
        reader.setName(name);
        reader.setPhone(phone);
        reader.setEmail(email);

        readerService.addReader(reader);
        System.out.println("讀者添加成功");
    }

    private void showAllReaders() throws SQLException {
        List<Reader> readers = readerService.getAllReaders();
        for (Reader reader : readers) {
            System.out.println(reader);
        }
    }

    private void borrowBook() throws SQLException {
        System.out.print("請輸入圖書ID：");
        int bookId = scanner.nextInt();
        System.out.print("請輸入讀者ID：");
        int readerId = scanner.nextInt();
        scanner.nextLine(); // 清除緩沖區

        BorrowRecord record = new BorrowRecord();
        record.setBookId(bookId);
        record.setReaderId(readerId);
        record.setBorrowDate(new java.util.Date());
        record.setReturnDate(new java.util.Date()); // 假設歸還日期為當前日期

        borrowRecordService.addBorrowRecord(record);
        System.out.println("借閱記錄添加成功");
    }

    private void showAllBorrowRecords() throws SQLException {
        List<BorrowRecord> records = borrowRecordService.getAllBorrowRecords();
        for (BorrowRecord record : records) {
            System.out.println(record);
        }
    }

    public static void main(String[] args) {
        MainUI ui = new MainUI();
        ui.run();
    }
}

測試與調試

在完成代碼編寫后，我們需要對系統進行測試，確保各個功能模塊能夠正常工作?？梢允褂肑Unit編寫單元測試，測試各個DAO和Service類的方法。

BookDAOTest.java

import org.junit.Before;
import org.junit.Test;
import java.sql.SQLException;
import static org.junit.Assert.*;

public class BookDAOTest {
    private BookDAO bookDAO;

    @Before
    public void setUp() {
        bookDAO = new BookDAO();
    }

    @Test
    public void testAddBook() throws SQLException {
        Book book = new Book();
        book.setTitle("Java編程思想");
        book.setAuthor("Bruce Eckel");
        book.setPublisher("機械工業出版社");
        book.setIsbn("9787111213826");
        book.setQuantity(10);

        bookDAO.addBook(book);
        assertTrue(true); // 簡單斷言，確保沒有拋出異常
    }

    @Test
    public void testGetAllBooks() throws SQLException {
        List<Book> books = bookDAO.getAllBooks();
        assertNotNull(books);
    }
}

ReaderDAOTest.java

import org.junit.Before;
import org.junit.Test;
import java.sql.SQLException;
import static org.junit.Assert.*;

public class ReaderDAOTest {
    private ReaderDAO readerDAO;

    @Before
    public void setUp() {
        readerDAO = new ReaderDAO();
    }

    @Test
    public void testAddReader() throws SQLException {
        Reader reader = new Reader();
        reader.setName("張三");
        reader.setPhone("13800138000");
        reader.setEmail("zhangsan@example.com");

        readerDAO.addReader(reader);
        assertTrue(true); // 簡單斷言，確保沒有拋出異常
    }

    @Test
    public void testGetAllReaders() throws SQLException {
        List<Reader> readers = readerDAO.getAllReaders();
        assertNotNull(readers);
    }
}

BorrowRecordDAOTest.java

”`java import org.junit.Before; import org.junit.Test; import java.sql.SQLException; import java.util.Date; import static org.junit.Assert.*;

public class BorrowRecordDAOTest { private BorrowRecordDAO borrowRecordDAO;

@Before
public void setUp() {
    borrowRecordDAO = new BorrowRecordDAO();
}

@Test
public void test