6.图书管理系统+IO处理

图书管理系统+IO处理

• 程序主要目的是学习mvc分层编写程序，学习对象序列化和反序列化。

主要包括以下功能:

• 用户登陆
• 增加图书
• 删除图书
• 修改图书
• 查询图书
• 返回主菜单

其中查询图书包含四种排序:

• 模糊查询显示
• 价格从高到低排序显示
• 价格从低到高排序显示
• 出版日期排序

bean包下实体类

Book.java

package bean;
import java.io.Serializable;
import java.util.Objects;
public class Book implements Serializable {
    private static final long serialVersionUID = 3497715600718471901L;
    //必须有序列化id
    //排序的方式： 价格（升降） 新旧（出版时间）
    private String bookName;//书名;
    private double bookPrice;//价格
    private String bookPublishDate;//出版时间

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", bookPrice=" + bookPrice +
                ", bookPublishDate='" + bookPublishDate + '\'' +
                '}';
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public double getBookPrice() {
        return bookPrice;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return Objects.equals(bookName, book.bookName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(bookName);
    }

    public void setBookPrice(double bookPrice) {
        this.bookPrice = bookPrice;
    }

    public String getBookPublishDate() {
        return bookPublishDate;
    }

    public void setBookPublishDate(String bookPublishDate) {
        this.bookPublishDate = bookPublishDate;
    }

    public Book(String bookName, double bookPrice, String bookPublishDate) {
        this.bookName = bookName;
        this.bookPrice = bookPrice;
        this.bookPublishDate = bookPublishDate;
    }
}

User.java

package bean;
public class User {
    private String username,password;
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }
    public String getUsername() { return username; }
    public String getPassword() { return password;}
    public void setPassword(String password) { this.password = password; }
    public void setUsername(String username) {  this.username = username; }
}

util包下序列化工具类

IOUtil.java

package util;
import bean.Book;
import java.io.*;
import java.util.ArrayList;

public class IOUtil {
    //IO功能：从文本中读取数据,将数据存储到文本中
    //序列化方法,写 把集合写到文本去
    private static File file = new File("图书信息.txt");

    /**
     * 必须要注意：list中的实体类对象必须实现序列化接口
     *
     * @param list
     */
    public static void writeToFile(ArrayList<Book> list) {
        try(ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file))) {
            oos.writeObject(list);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读文本，读成一个集合
    public static ArrayList<Book> readFromFile() {
        //第一次读，有可能文本还不存在，不能读
        if (!file.exists() || file.length() == 0) return new ArrayList<>();
        InputStream in;
        ArrayList<Book> list = new ArrayList<>();
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
            list = (ArrayList<Book>) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return list;
    }
}

view包下视图层

package util;

import bean.Book;

import java.io.*;
import java.util.ArrayList;

public class IOUtil {
    //IO功能：从文本中读取数据,将数据存储到文本中
    //序列化方法,写 把集合写到文本去
    private static File file = new File("图书信息.txt");

    /**
     * 必须要注意：list中的实体类对象必须实现序列化接口
     *
     * @param list
     */
    public static void writeToFile(ArrayList<Book> list) {
        try (ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file))) {
            oos.writeObject(list);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读文本，读成一个集合
    public static ArrayList<Book> readFromFile() {
        //第一次读，有可能文本还不存在，不能读
        if (!file.exists() || file.length() == 0) return new ArrayList<>();
        InputStream in;
        ArrayList<Book> list = new ArrayList<>();
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
            list = (ArrayList<Book>) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return list;
    }
}

service包

UserService.java

package service;
public class UserService {
    private static final String ADMIN="admin";
    private static final String PASSWORD="123456";
    
    public boolean login(String username, String password) {
        return username.equals(ADMIN)&&password.equals(PASSWORD);
    }
}

dao包下操作数据

package dao;
import bean.Book;
import util.IOUtil;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;

public class BookDao {
    private ArrayList<Book> list = IOUtil.readFromFile();

    public boolean addBook(Book book) {

        if (list.contains(book)) return false;
        list.add(book);
        IOUtil.writeToFile(list);
        return true;
    }

    public boolean removeBook(String bookName) {
        //如果equals方法不是只对bookName的，这么写是无法删除的
        boolean remove = list.remove(new Book(bookName, 0, null));
        IOUtil.writeToFile(list);
        return remove;
    }

    public boolean modify(String bookName, Book newBook) {
        int index = list.indexOf(new Book(bookName, 0, null));
        if (index == -1) return false;
        list.set(index, newBook);
        IOUtil.writeToFile(list);
        return true;
    }

    /**
     * 模糊查询
     *
     * @param keyWord
     * @return
     */
    public ArrayList<Book> queryBooksByName(String keyWord) {
        list = IOUtil.readFromFile();
        ArrayList<Book> temp = new ArrayList<>();

        for (Book book : list) {
            if (book.getBookName().contains(keyWord)) {
                temp.add(book);
            }
        }
        return temp;
    }

    public ArrayList<Book> sortByPublishDate() {
//        Collections.sort(list, new Comparator<Book>() {
//            @Override
//            public int compare(Book o1, Book o2) {
//                return 0;
//            }
//        });
        //
        list = IOUtil.readFromFile();
        list.sort(new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
                Date d1 = null;
                Date d2 = null;
                try {
                    d1 = df.parse(o1.getBookPublishDate());
                    d2 = df.parse(o2.getBookPublishDate());

                } catch (ParseException e) {
                }
                return (int) (d1.getTime() - d2.getTime());
            }
        });
        return list;
    }

    public ArrayList<Book> sortByPriceUp() {
        list = IOUtil.readFromFile();
        list.sort(new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                return (int) ((o1.getBookPrice() - o2.getBookPrice()) * 100);
            }
        });
        return list;
    }

    public ArrayList<Book> sortByPriceDown() {
        list = IOUtil.readFromFile();
        list.sort(new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                return (int) ((o2.getBookPrice() - o1.getBookPrice()) * 100);
            }
        });
        return list;
    }
}

Main.java调度逻辑

import bean.Book;
import dao.BookDao;
import service.UserService;
import view.Views;
import java.util.ArrayList;

public class Main {
    static Views v = new Views();
    static UserService userService = new UserService();
    static BookDao bookDao = new BookDao();

    public static void main(String[] args) {
        v.welcome();
        //主流程：1.登录，2退出
        //如果登录成功，进入2级菜单：增删改查，返回
        //查三级菜单：模糊查询，3个排序，1.返回
        boolean flag = true;
        while (flag) {
            v.printMainMenu();
            int key = v.inputChoose(2);
            switch (key) {
                case 1:
                    login();
                    break;
                case 2:
                    flag = false;
                    v.bye();
                    break;
            }
        }
    }

    private static void login() {
        String username = v.inputUsername();
        String password = v.inputPassword();
        boolean flag = userService.login(username, password);
        if (flag) {
            v.loginSuccess();
            adminLoop();

        } else {
            v.loginFail();
        }
    }

    private static void adminLoop() {
        boolean flag = true;
        while (flag) {
            v.printAdminMenu();
            int key = v.inputChoose(5);
            switch (key) {
                case 1:
                    addBook();
                    break;
                case 2:
                    removeBook();
                    break;
                case 3:
                    modifyBook();
                    break;
                case 4:
                    showBooks();
                    break;
                case 5:
                    flag = false;
                    v.backMain();
                    break;
            }
        }
    }

    private static void showBooks() {
        boolean flag = true;
        while (flag) {
            v.printShowMenu();
            int key = v.inputChoose(5);
            switch (key) {
                case 1:
                    queryBook();
                    break;
                case 2:
                    sortBookByPriceDown();
                    break;
                case 3:
                    sortBookByPriceUp();
                    break;
                case 4:
                    sortByPublishDate();
                    break;
                case 5:
                    flag = false;
                    v.backAdmin();
                    break;
            }
        }

    }

    private static void sortByPublishDate() {
        ArrayList<Book> list = bookDao.sortByPublishDate();
        v.showBooks(list);
    }

    private static void sortBookByPriceUp() {
        ArrayList<Book> list = bookDao.sortByPriceUp();
        v.showBooks(list);
    }

    private static void sortBookByPriceDown() {
        ArrayList<Book> list = bookDao.sortByPriceDown();
        v.showBooks(list);
    }

    /**
     * 模糊查询,
     */
    private static void queryBook() {
        String bookName = v.inputBookName();
        ArrayList<Book> list = bookDao.queryBooksByName(bookName);
        v.showBooks(list);
    }

    private static void modifyBook() {
        String bookName = v.inputBookName();
        String newBookName = v.inputNewBookName();
        double newBookPrice = v.inputNewBookPrice();
        String newBookDate = v.inputNewBookDate();
        Book newBook = new Book(newBookName, newBookPrice, newBookDate);
        boolean modify = bookDao.modify(bookName, newBook);
        v.printModifyResult(modify);
    }

    private static void removeBook() {
        String bookName = v.inputBookName();
        boolean remove = bookDao.removeBook(bookName);
        v.printRemoveResult(remove);
    }

    private static void addBook() {
        String bookName = v.inputBookName();
        double bookPrice = v.inputBookPrice();
        String bookPublishDate = v.inputBookDate();
        boolean add = bookDao.addBook(new Book(bookName, bookPrice, bookPublishDate));
        v.printAddResult(add);
    }
}