Javase结束项目-图书管理系统

在框架搭建完的基础上，完成了管理员与普通用户的具体操作。可根据不同角色登录进行不同的操作。

各角色可执行操作如上

主要代码如下：
Proxyuser

package user;

import book.Library;
import constant.Constant;
import utils.PermissionException;

public class ProxyUser {

    private User realUser;

    private Library library;

    public ProxyUser(User user){
        this.realUser = user;
        library = Library.getLibrary();
    }

    public User getRealUser(){
        return this.realUser;
    }

    //其他操作
    //调⽤菜单
    public int display() {
        return this.realUser.display();
    }

    private void checkRealUserWhetherAdminUser(String msg){
        if(this.realUser instanceof NormalUser){
            throw new PermissionException(msg);
        }
    }
    //添加书籍操作
    public void addBook() {

        System.out.println("代理类addbook执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限添加书籍...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).addBook();

    }
    //更新书籍操作
    public void updateBook() {
        System.out.println("代理类updatebook执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限修改书籍...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).updateBook();
    }

    //移除图书
    public void removeBook() {
        System.out.println("代理类removebook执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限删除书籍...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).removeBook();
    }

    //查看图书的借阅次数
    public void borrowCount( ) {
        System.out.println("代理类borrowCount执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限查看借阅次数...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).borrowCount();
    }

    //查看最受欢迎的前K本书
    public void generateBook() {
        System.out.println("代理类generateBook执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限查看最受欢迎的前K本书...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).generateBook();
    }

    //查看库存状态
    public void checkInventoryStatus() {
        System.out.println("代理类checkInventoryStatus执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限查看库存状态...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).checkInventoryStatus();
    }

    //移除上架超过1年的书籍
    public void checkAndRemoveOldBooks() {
        System.out.println("代理类checkAndRemoveOldBooks执行了...");

        try {
            checkRealUserWhetherAdminUser("普通用户没有权限操作...");
        }catch (PermissionException e){
            e.printStackTrace();
        }

        ((AdminUser)(this.realUser)).checkAndRemoveOldBooks();
    }
//--------------------------------普通相关⽅法-----------------------------

    private void checkRealUserWhetherNormalUser(String exceptionMessage) {
        if(!(realUser instanceof NormalUser)){
            throw new PermissionException(exceptionMessage);
        }
    }

    //借阅图书
    public void borrowBook() {
        System.out.println("代理类borrowBook执行了...");

        checkRealUserWhetherNormalUser("管理员不能借阅，请换取普通账号借阅...");
        ((NormalUser)(this.realUser)).borrowBook();
    }

    //归还图书
    public void returnBook() {
        System.out.println("代理类returnBook执行了...");

        checkRealUserWhetherNormalUser("管理员不能借阅，请换取普通账号借阅...");
        ((NormalUser)(this.realUser)).returnBook();
    }
    //查看个⼈借阅情况
    public void viewBorrowHistory() {
        checkRealUserWhetherNormalUser("管理员请以普通⽤⼾的⽅式查看个⼈当前借阅情况");
        ((NormalUser) realUser).viewBorrowBooks();
    }

    public void handleOperation(int choice) {
        if(this.realUser  instanceof AdminUser){
            switch (choice){
                case Constant.SEARCH_BOOK:
                    library.searchBook();
                    break;
                case Constant.DISPLAY_BOOK:
                    library.displayBooks();
                    break;
                case Constant.EXIT:
                    library.exit();
                    break;
                case Constant.ADD_BOOK:
                    addBook();
                    break;
                case Constant.UPDATE_BOOK:
                    updateBook();
                    break;
                case Constant.REMOVE_BOOK:
                    removeBook();
                    break;
                case Constant.BORROWED_BOOK_COUNT:
                    borrowCount();
                    break;
                case Constant.GENERATE_BOOK:
                    generateBook();
                    break;
                case Constant.CHECK_INVENTORY_STATUS:
                    checkInventoryStatus();
                    break;
                case Constant.CHECK_AND_REMOVE_OLD_BOOK:
                    checkAndRemoveOldBooks();
                    break;
                default:
                    break;
            }
        }else{
                switch (choice){
                    case Constant.SEARCH_BOOK:
                        library.searchBook();
                        break;
                    case Constant.DISPLAY_BOOK:
                        library.displayBooks();
                        break;
                    case Constant.EXIT:
                        library.exit();
                        break;
                    case Constant.BORROWED_BOOK:
                        borrowBook();
                        break;
                    case Constant.RETURN_BOOK:
                        returnBook();
                        break;
                    case Constant.VIEW_BORROW_HISTORY_BOOK:
                        viewBorrowHistory();
                        break;
                    default:
                        break;
                }
        }
    }
}

AdminUser

package user;

import book.Book;
import book.Library;
import jdk.jshell.execution.LoaderDelegate;
import utils.ScannerSingleton;

import java.time.LocalDate;
import java.util.Scanner;

/*
管理员
 */
public class AdminUser extends User{
    public Scanner scanner;
    private Library library;

    public AdminUser(String name,int userID){
        super(name,userID,"管理员");
        scanner = ScannerSingleton.getScannerSingleton();
        library = library.getLibrary();
    }

    @Override
    public int display() {
        System.out.println("管理员 " + this.getName() + " 的操作菜单:");
        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("7. 统计借阅次数");
        System.out.println("8. 查看最后欢迎的前K本书");
        System.out.println("9. 查看库存状态");
        System.out.println("10. 检查超过⼀年未下架的图书");
        System.out.println("请选择你的操作：");
        return scanner.nextInt();
    }

    //其他操作⽅法
    //上架图书
    public void addBook() {
        System.out.println("管理员Admin的addbook执行了...");
        scanner.nextLine();

        System.out.println("请输⼊书名：");
        String title = scanner.nextLine(); // 输⼊书名
        System.out.println("请输⼊作者：");
        String author = scanner.nextLine(); // 输⼊作者
        System.out.println("请输⼊类别：");
        String category = scanner.nextLine(); // 输⼊图书类别
        System.out.println("请输⼊出版年份：");
        int year = scanner.nextInt(); // 输⼊出版年份

        scanner.nextLine(); // 吞掉换⾏符

        LocalDate shelfDate = LocalDate.now(); // 当前时间作为上架时间
        Book newBook = new Book(title, author, category, year, shelfDate); // 创

        //调⽤图书类 添加图书
        library.addBook(newBook);

    }
    //图书修改 ⽀持修改书名 作者 类别
    public void updateBook() {
        library.displayBooks();
        System.out.println("请输入你要修改图书的ID");
        int bookId = scanner.nextInt();
        scanner.nextLine();

        Book book = library.searchById(bookId);
        if(book == null){
            System.out.println("没有你要找的这本书ID"+bookId);
            return;
        }

        System.out.println("当前书名：" + book.getTitle());
        System.out.println("请输⼊新的书名：");
        String newTitle = scanner.nextLine(); // 输⼊新的书名
        System.out.println("当前作者：" + book.getAuthor());
        System.out.println("请输⼊新的作者：");
        String newAuthor = scanner.nextLine(); // 输⼊新的作者
        System.out.println("当前类别：" + book.getCategory());
        System.out.println("请输⼊新的类别：");
        String newCategory = scanner.nextLine(); // 输⼊新的类别

        //更新对应书籍的信息
        book.setTitle(newTitle);
        book.setAuthor(newAuthor);
        book.setCategory(newCategory);

        library.updateBook(book);

    }

    //删除书籍
    public void removeBook() {
        library.displayBooks();
        System.out.println("请输入要删除的图书ID");
        int bookId = scanner.nextInt();
        scanner.nextLine();

        Book removeBook = library.searchById(bookId);
        if(removeBook == null){
            System.out.println("没有你要删除的书籍!");
            return;
        }

        library.removeBook(bookId);

        System.out.println("图书："+ removeBook.getTitle() +"已经删除！");
    }

    //统计每本书的借阅次数
    public void borrowCount() {
        library.borrowCount();
    }

    //查询最受欢迎的前n本书
    public void generateBook() {
        System.out.println("输入你要查看的最受欢迎的前K本书，注意k不能超过："+ library.getBookCount());
        int k = scanner.nextInt();

        if(k<= 0 || k>library.getBookCount()){
            System.out.println("没有最受欢迎的前"+k+"本书！");
            return;
        }

        library.generateBook(k);
    }

    //查看库存状态
    public void checkInventoryStatus() {
        library.checkInventoryStatus();
    }

    //并移除上架超过⼀年的图书
    public void checkAndRemoveOldBooks() {
        library.checkAndRemoveOldBooks();

    }

}

NormalUser

package user;

import book.Book;
import book.Library;
import book.PairOfUidAndBookId;
import constant.Constant;
import utils.AnalyzingBorrowedBook;
import utils.ScannerSingleton;

import java.io.IOException;
import java.util.Scanner;

public class NormalUser extends User{

    public Scanner scanner;
    //存储图书借阅信息
    private PairOfUidAndBookId[] pairOfUidAndBookIds;
    //当前借阅量
    private int borrowedCount;
    private Library library;

    private AnalyzingBorrowedBook analyzingBorrowedBook = new AnalyzingBorrowedBook();

    public NormalUser(String name,int userID){
        super(name,userID,"普通用户");
        scanner = ScannerSingleton.getScannerSingleton();
        library = Library.getLibrary();
    }

    private void loadBorrowedBook(){

        PairOfUidAndBookId[] allBorrowedBook;

        try {
            allBorrowedBook = analyzingBorrowedBook.loadObject(Constant.BORROWED_BOOK_FILE_NAME);

            pairOfUidAndBookIds = new PairOfUidAndBookId[Constant.BORROW_BOOK_MAX_NUM];

            if(allBorrowedBook == null){
                borrowedCount = 0;
            }else {
                int allBorrowedBookLen = allBorrowedBook.length;

                if(allBorrowedBookLen > pairOfUidAndBookIds.length){
                    pairOfUidAndBookIds = new PairOfUidAndBookId[allBorrowedBookLen];
                }

                for (int i = 0; i < allBorrowedBookLen; i++) {
                    pairOfUidAndBookIds[i] = allBorrowedBook[i];
                }

                borrowedCount = allBorrowedBookLen;
            }
        }catch (IOException e){
            throw new RuntimeException(e);
        }
    }

    private void storeBorrowedBook(){
        try {
            analyzingBorrowedBook.storeObject(pairOfUidAndBookIds,Constant.BORROWED_BOOK_FILE_NAME);
        }catch (IOException e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public int display() {
        System.out.println("普通用户 " + this.getName() + " 的操作菜单:");
        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("请选择你的操作：");
        return scanner.nextInt();
    }

    //借阅图书
    public void borrowBook() {
        scanner.nextLine();
        System.out.println("请输入你要借阅书籍的ID");
        int bookId = scanner.nextInt();
        scanner.nextLine();

        if(library.getBookCount() == 0){
            System.out.println("图书馆为空，没有书籍可借阅...");
            return;
        }

        loadBorrowedBook();

        Book book = library.searchById(bookId);
        if(book == null){
            System.out.println("没有该Id书籍...");
            return;
        }

        for (int i = 0; i < borrowedCount; i++) {
            PairOfUidAndBookId pairOfUidAndBookId = pairOfUidAndBookIds[i];

            if(pairOfUidAndBookId.getBookId() == book.getBookId()){
                if(pairOfUidAndBookId.getUserId() == getUserID()){
                    System.out.println("这本书是你已经借阅过的..");
                    return;
                }else{
                    System.out.println("这本书已经被别人借阅了...");
                    return;
                }
            }
        }

        library.borrowBook(bookId);

        //写入借阅图书文件
        PairOfUidAndBookId pairOfUidAndBookId = new PairOfUidAndBookId(getUserID(),book.getBookId());
        pairOfUidAndBookIds[borrowedCount] = pairOfUidAndBookId;
        borrowedCount++;

        storeBorrowedBook();
        System.out.println("借阅书籍成功..");

    }
    //归还图书
    public void returnBook() {
        loadBorrowedBook();

        if(borrowedCount == 0){
            System.out.println("没有用户借阅过书籍..");
            return;
        }

        scanner.nextLine();
        System.out.println("请输入你要归还的书籍Id:");
        int bookId = scanner.nextInt();
        scanner.nextLine();

        Book book = library.searchById(bookId);
        if(book == null){
            System.out.println("没有该Id书籍...");
            return;
        }

        for (int i = 0; i < borrowedCount; i++) {
            if (pairOfUidAndBookIds[i].getBookId()==book.getBookId()) {

                //借阅⽤⼾也⼀样
                if (getUserID() == pairOfUidAndBookIds[i].getUserId()) {
                    library.returnBook(bookId);
                    System.out.println("图书 '" + book.getTitle() + "' 已成功归还。");
                    // ⽤最后⼀本替换归还的书
                    pairOfUidAndBookIds[i] = pairOfUidAndBookIds[borrowedCount - 1];

                    // 清空最后⼀个
                    pairOfUidAndBookIds[borrowedCount - 1] = null;
                    borrowedCount--;
                    storeBorrowedBook();
                }else{
                    System.out.println("该书籍不是你借阅的书籍，不能归还："+book.getTitle());
                }
                return;
            }
        }
        System.out.println("你没有借阅该书籍，不需要归还，书籍ID为："+bookId);

    }

    // 查看个⼈借阅情况
    public void viewBorrowBooks() {
        loadBorrowedBook();

        System.out.println("您的借阅情况如下:");

        if(borrowedCount == 0){
            System.out.println("目前没有借阅记录..");
        }else {
            boolean flg = false;

            for (int i = 0; i < borrowedCount; i++) {

                if(pairOfUidAndBookIds[i].getUserId() == getUserID()){
                    flg = true;
                    Book book = library.searchById(pairOfUidAndBookIds[i].getBookId());
                    System.out.println(book);
                }
            }

            if(!flg){
                System.out.println("您没有借阅过书籍...");
            }
        }
    }

}

Library

package book;

import constant.Constant;
import utils.AnalyzingBook;
import utils.ScannerSingleton;

import java.io.IOException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Scanner;

public class Library {
    //存储书籍
    private Book[] books;
    //记录有效书的数量
    private int bookCount;
    private static Library library;
    public Scanner scanner;
    private AnalyzingBook analyzingBook = new AnalyzingBook();

    private Library(){
        //读
        loadAllBook();
        scanner = ScannerSingleton.getScannerSingleton();
    }

    public int getBookCount() {
        return bookCount;
    }

    public static Library getLibrary(){
        if(library == null){
            library = new Library();
        }

        return library;
    }

    //写成独立方法，可实时查看书架多少本书(实时更新book的值)
    public void loadAllBook(){

        try {
            Book[] allbook = analyzingBook.loadObject(Constant.ALL_BOOK_FILE_NAME);

            books = new Book[Constant.CAPACITY];
            if(allbook == null){
                bookCount = 0;
            }else {
                int allBookLen = allbook.length;
                if(allBookLen > books.length){
                    books = new Book[allBookLen];
                }

                for (int i = 0; i < allBookLen; i++) {
                    books[i] = allbook[i];
                }

                bookCount = allBookLen;
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    //将books存到文件中
    public void storeBook(){
        try {
            analyzingBook.storeObject(books,Constant.ALL_BOOK_FILE_NAME);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    //公用的方法
    public void searchBook(){
        System.out.println("library的searchBook执行了..");
        scanner.nextLine();
        System.out.println("请输入您要查找的书名：");
        String title = scanner.nextLine();

        Book book = search(title);

        if(book == null){
            System.out.println("没有你要找的这本书！");
        }else {
            System.out.println("您查找书的信息如下：");
            System.out.println(book);
        }
    }

    private Book search(String title) {
        loadAllBook();

        for (int i = 0; i < bookCount; i++) {
            Book book = books[i];
            if(book.getTitle().equals(title)){
                return book;
            }
        }

        return null;
    }

    //显示图书
    public void displayBooks(){

        System.out.println("显示图书");
        loadAllBook();
        for (int i = 0; i < bookCount; i++) {
            System.out.println(books[i]);
        }
    }

    public void exit(){
        System.out.println("退出系统...");
        System.exit(0);
    }

    //添加图书
    public void addBook(Book book) {
        System.out.println("library执行了....");

        if(bookCount >= books.length){
            //System.out.println("图书馆已满，无法上架图书");
            //return;
            //扩容
            books = Arrays.copyOf(books,bookCount);
        }

        books[bookCount] = book;

        Book bookLast = books[bookCount-1];

        bookCount++;

        book.setBookId(bookLast.getBookId()+1);

        storeBook();
        System.out.println("图书上架成功！图书的名称是："+ book.getTitle());
    }

    //通过bookID找到对应ID
    public Book searchById(int bookId){
        loadAllBook();
        for (int i = 0; i < bookCount; i++) {
            Book book = books[i];
            if(book.getBookId() == bookId){
                return book;
            }
        }
        return null;
    }

    //更新图书
    public void updateBook(Book book) {

        int index = searchByIdReturnIndex(book.getBookId());
        if(index == -1){
            System.out.println("没有你要更新的图书...");
        }

        books[index] = book;

        //将更新的写回到文件中，确保更新
        storeBook();

        System.out.println("书籍已被更新，更新书籍为：");
        System.out.println(books[index]);
    }

    /**
     * 根据bookId查询到书籍下标
     * @param bookId
     * @return
     */
    private int searchByIdReturnIndex(int bookId){
        loadAllBook();
        for (int i = 0; i < bookCount; i++) {
            Book book = books[i];
            if(book.getBookId() == bookId){
                return i;
            }
        }
        return -1;
    }

    //删除图书
    public void removeBook(int bookId) {

        int index = searchByIdReturnIndex(bookId);

        if(index == -1){
            System.out.println("没有你要删除的图书");
            return;
        }

        for(int i = index; i < bookCount-1; i++){
            books[i] = books[i+1];
        }
        books[bookCount-1] = null;
        bookCount--;

        storeBook();
    }


    public void borrowCount() {
        loadAllBook();
        for (int i = 0; i < bookCount; i++) {
            Book book = books[i];
            System.out.println("图书 "+ book.getTitle() + "借阅次数为 " +book.getBorrowedCount());
        }
    }

    public void generateBook(int k) {

        loadAllBook();

        Book[] tmp = new Book[getBookCount()];
        for (int i = 0; i < getBookCount(); i++) {
            tmp[i] = books[i];
        }

        Arrays.sort(tmp);

        Book[] generateBook = new Book[k];

        for (int i = 0; i < k; i++) {
            generateBook[i] = tmp[i];
        }

        System.out.println("最受欢迎的书籍为：");
        for (int i = 0; i < generateBook.length; i++) {
            System.out.println("书籍ID："+ generateBook[i].getBookId() +" |书名："+
                    generateBook[i].getTitle() + " |作者：" + generateBook[i].getAuthor()
                    + " |借阅次数："+ generateBook[i].getBorrowedCount());
        }
    }

    public void checkInventoryStatus() {
        loadAllBook();

        for (int i = 0; i < getBookCount(); i++) {
            Book book = books[i];

            String borrow = "未借出";
            if(book.isBorrowed()){
                borrow = "已借出";
            }

            System.out.println("书籍："+ book.getTitle() + " 借阅状态 " + borrow);
        }
    }

    public void checkAndRemoveOldBooks() {
        loadAllBook();

        long currentTimestamp = System.currentTimeMillis();
        LocalDate currentDate = Instant.ofEpochMilli(currentTimestamp)
                .atZone(ZoneId.systemDefault())
                .toLocalDate();
        boolean flg = false;
        for (int i = 0; i < getBookCount(); i++) {
            Book book = books[i];
            //获取当前书籍的上架时间
            LocalDate specifiedDate = book.getShelfDate();
            // 计算两个⽇期之间的差值（以年为单位）
            long yearsBetween = ChronoUnit.YEARS.between(specifiedDate,
                    currentDate);
            if(yearsBetween >= 1) {
                System.out.print("图书 " + book.getTitle() + " 已经上架超过⼀年，是否移除？(y/n)：");
                scanner.nextLine();
                String response = scanner.nextLine();
                //scanner.nextLine();
                if (response.equalsIgnoreCase("y")) {
                    //确认删除调⽤remove⽅法进⾏删除
                    removeBook(book.getBookId());
                    i--; // 因为后⾯的书已经向前移动，所以要重新检查当前索引位置
                }
                flg = true;
            }
        }
        if(!flg) {
            System.out.println("没有上架超过⼀年的图书！");
        }

        storeBook();

    }

    public void borrowBook(int bookId) {
        loadAllBook();

        Book book = searchById(bookId);
        book.setBorrowed(true);
        book.incrementBorrowCount();

        storeBook();
    }

    public void returnBook(int bookId) {

        loadAllBook();
        Book book = searchById(bookId);
        book.setBorrowed(false);
        storeBook();
    }
}

完整项目已上传至Gitee码云仓库