题目：设计一个Java程序，在线图书馆管理系统。（进阶）_用java设计一个图书管理系统,包括图书(book)类和图书馆(library)类。图书类具有书

题目：设计一个Java程序，实现一个简单的在线图书馆管理系统。

要求：

使用面向对象编程，定义至少两个类：Book（书籍）和Library（图书馆）。
书籍类包含属性：书名、作者、出版年份、ISBN号、价格。
图书馆类包含属性：图书馆名称、地址、藏书列表（List）。
为书籍类提供构造方法、getter和setter方法。
为图书馆类提供构造方法、getter和setter方法。
在图书馆类中，实现以下功能： a. 添加书籍到藏书列表。 b. 根据书名或作者查找书籍。 c. 显示所有藏书信息。
使用Java集合框架存储和管理书籍信息。
使用Java I/O操作，将图书馆的藏书信息保存到文件中，以及从文件中读取藏书信息。
使用Java多线程，实现一个简单的图书借阅功能，允许多个用户同时借阅书籍。
使用Java网络编程，实现一个简单的图书馆查询系统，允许用户通过网络查询图书馆的书籍信息。

示例代码：
好的，以下是中文注释的代码：

// Book.java
public class Book {
    private String title; // 书名
    private String author; // 作者
    private int year; // 出版年份
    private String isbn; // ISBN号
    private double price; // 价格

    public Book(String title, String author, int year, String isbn, double price) {
        this.title = title;
        this.author = author;
        this.year = year;
        this.isbn = isbn;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", year=" + year +
                ", isbn='" + isbn + '\'' +
                ", price=" + price +
                '}';
    }
}

// Library.java
import java.util.*;
import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class Library {
    private String name; // 图书馆名称
    private String address; // 地址
    private List<Book> books; // 图书列表
    private ExecutorService executor; // 线程池
    private final Object lock = new Object(); // 同步锁对象

    public Library(String name, String address) {
        this.name = name;
        this.address = address;
        this.books = new ArrayList<>();
        this.executor = Executors.newFixedThreadPool(10); // 创建10个线程的线程池
    }

    public void addBook(Book book) {
        synchronized (lock) { // 同步添加图书操作
            books.add(book);
        }
    }

    public Book findBook(String title, String author) {
        synchronized (lock) { // 同步查找图书操作
            for (Book book : books) {
                if (book.getTitle().equals(title) || book.getAuthor().equals(author)) {
                    return book;
                }
            }
        }
        return null;
    }

    public void displayBooks() {
        synchronized (lock) { // 同步显示所有图书操作
            for (Book book : books) {
                System.out.println(book);
            }
        }
    }

    public void saveBooksToFile(String filename) throws IOException {
        synchronized (lock) { // 同步保存图书到文件操作
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(filename));
            out.writeObject(books);
            out.close();
        }
    }

    public void loadBooksFromFile(String filename) throws IOException, ClassNotFoundException {
        synchronized (lock) { // 同步从文件加载图书操作
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(filename));
            books = (List<Book>) in.readObject();
            in.close();
        }
    }

    public void borrowBook(String title, String author) {
        executor.execute(new Runnable() { // 使用线程池异步执行借书操作
            @Override
            public void run() {
                synchronized (lock) { // 同步借书操作
                    Book book = findBook(title, author);
                    if (book != null) {
                        try {
                            System.out.println("Borrowing book: " + book.getTitle());
                            Thread.sleep(2000); // 模拟借书耗时
                            System.out.println("Book borrowed: " + book.getTitle());
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("Book not found");
                    }
                }
            }
        });
    }

    public void startLibraryQueryServer() throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080); // 启动一个查询服务器，监听8080端口
        while (true) {
            try {
                Socket clientSocket = serverSocket.accept(); // 接受客户端连接请求
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                String request = in.readLine(); // 读取客户端请求内容
                String response = processRequest(request); // 处理客户端请求并生成响应结果
                out.println(response); // 将响应结果发送回客户端
                clientSocket.close(); // 关闭客户端连接
            } catch (IOException e) {
                e.printStackTrace(); // 处理可能出现的异常情况
            }
        }
    }

    private String processRequest(String request) {
        String[] tokens = request.split("\\s+"); // 将请求内容按空格分割成多个标记（token）
        if (tokens[0].equalsIgnoreCase("find")) { // 如果请求是查找图书操作
            synchronized (lock) { // 同步查找图书操作
                Book book = findBook(tokens[1], tokens[2]); // 根据标题和作者查找图书信息
                if (book != null) {
                    return book.toString(); // 返回图书信息字符串表示形式
                } else {
                    return "Book not found"; // 返回图书未找到的提示信息
                }
            }
        } else if (tokens[0].equalsIgnoreCase("display")) { // 如果请求是显示所有图书操作
            synchronized (lock) { // 同步显示所有图书操作
                return displayBooks(); // 调用显示所有图书方法并返回其结果字符串表示形式
            }
        } else {
            return "Invalid request"; // 返回无效请求的提示信息
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188