本项目是一个基于Scala语言开发的图书馆管理系统。系统主要由以下几个部分组成：数据访问层（DAO）、数据模型层（Models）、服务层（Service）以及用户界面层（UI）。以下是对项目中各个文件和文件夹的详细解释。

项目目录结构

scala_tushu2/
│
├── .idea/               # IntelliJ IDEA的项目配置文件夹
├── out/                 # 编译输出文件夹
├── src/                 # 源代码文件夹
│   ├── dao/             # 数据访问层
│   ├── models/          # 数据模型层
│   ├── service/         # 服务层
│   └── ui/              # 用户界面层
├── scripts/             # 脚本文件夹
├── scala_tushu2.iml     # IntelliJ IDEA的模块文件
├── books.txt            # 图书信息文件
├── borrow_records.txt    # 借阅记录文件
└── users.txt            # 用户信息文件

详细文件解释

1. 数据访问层（DAO）

文件：BookDAO.scala

• 负责图书信息的增删改查操作。

1. 提供与数据库交互的方法，如添加新书、删除书籍、更新书籍信息和查询书籍。

   package app.org
   package daoimport models.BookModelimport java.io.File
   import scala.collection.mutable.ListBuffer// 图书，数据操作
   class BookDAO {// 加载图书，从件中读入def loadBooks(): ListBuffer[BookModel] = {val books = new ListBuffer[BookModel]()val source = scala.io.Source.fromFile("books.txt")for (line <- source.getLines()) {val Array(id, name, author, available) = line.split(",")// 实例化一本书，保存到List中books += BookModel(id.toInt, name, author, available.toBoolean)}// 关闭连接source.close()books}// 保存图书，将图书写入文件def saveBooks(books: ListBuffer[BookModel]): Unit = {val writer = new java.io.PrintWriter(new File("books.txt"))for (book <- books) {writer.println(book.id + "," + book.name + "," + book.author + "," + book.available)}writer.close()}
   }
   

文件：BorrowRecordDAO.scala

• 负责借阅记录的增删改查操作。

• 提供与数据库交互的方法，如添加借阅记录、删除记录、更新记录和查询记录。

• package app.org
  package daoimport models.BorrowRecordModelimport java.io.PrintWriter
  import scala.collection.mutable.ListBuffer
  import scala.io.Sourceclass BorrowRecordDAO {// 读出借阅记录def loadBorrowRecord(): ListBuffer[BorrowRecordModel] = {val borrowRecords =  ListBuffer[BorrowRecordModel]()val lines = Source.fromFile("borrow_records.txt")for (line <- lines.getLines()) {val parts =line.split(",")borrowRecords += BorrowRecordModel(parts(0),parts(1).toInt,parts(2),parts(3),if (parts.length>4) Some(parts(4)) else None)}borrowRecords}// 写入借阅记录def saveBorrowRecord(records: ListBuffer[BorrowRecordModel]): Unit = {val writer = new PrintWriter("borrow_records.txt")for (record <- records) {writer.println(record.userName + "," + record.bookID + "," + record.bookName + "," + record.borrowDate + "," + record.returnDate.getOrElse(""))}writer.close()}
  }
  

文件：UserDAO.scala

• 负责用户信息的增删改查操作。

• 提供与数据库交互的方法，如添加新用户、删除用户、更新用户信息和查询用户信息。

• package app.org
  package daoimport models.UserModelimport java.io.File
  import scala.collection.mutable.ListBufferclass UserDAO {//加载所有的用户def loadUsers(): ListBuffer[UserModel] = {val users = new ListBuffer[UserModel]()val source = scala.io.Source.fromFile("users.txt")for (line <- source.getLines()) {val Array(username,password,role) = line.split(",")// 实例化一用户，保存到List中users += UserModel(username,password,role)}// 关闭连接source.close()users}//保存用户// 保存图书，将图书写入文件def saveUsers(users: ListBuffer[UserModel]): Unit = {val writer = new java.io.PrintWriter(new File("users.txt"))for (user <- users) {writer.println(user.username + "," + user.password + "," + user.role)}writer.close()}
  }
  

2. 数据模型层（Models）

文件：BookModel.scala

• 定义图书的数据模型。

• 包含图书的属性，如ID、书名、作者、是否可借等。

• package app.org
  package models// 图书类
  // id,书名，作者，状态
  case class BookModel(id: Int, name: String, author: String, var available: Boolean) {override def toString: String ={val availableStr = if (available) "可外借" else "已借出"s"编号:$id \t 书名: $name \t 作者:$author \t 这本书——$availableStr"}
  }

文件：BorrowRecordModel.scala

• 定义借阅记录的数据模型。

• 包含借阅记录的属性，如用户ID、书籍ID、借阅时间、归还时间等。

• package app.org
  package modelscase class BorrowRecordModel(userName:String,               // 借书人bookID:Int,                  // 图书IDbookName:String,           // 书名borrowDate:String,          // 借阅日期var returnDate:Option[String] =None   // 归还日期)
  

文件：UserModel.scala

• 定义用户的数据模型。

• 包含用户的属性，如ID、用户名、密码、用户类型（管理员或普通用户）等。

• package app.org
  package modelscase class UserModel(username:String,password:String,role:String)
  

3. 服务层（Service）

文件：BookService.scala

• 提供图书相关的业务逻辑。

• 调用DAO层的方法，实现图书的增删改查等业务操作。

• package app.org
  package serviceimport models.{BookModel, BorrowRecordModel}
  import dao.{BookDAO, BorrowRecordDAO}import java.time.LocalDateTime
  import scala.collection.mutable.ListBuffer// 图书业务逻辑层
  class BookService {private val bookDAO = new BookDAO()private val borrowRecordDAO = new BorrowRecordDAO()// 查询所有的图书
  //  def searchBooks(query:String): 图书列表List（Book对象）def searchBooks(query:String): ListBuffer[BookModel] = {// 从文本文件中读取书本信息，并保存列表中，返回val books = bookDAO.loadBooks()query match {case "" => books  // 没有条件，就返回全部case _ => books.filter(b => b.name.contains(query) || b.author.contains(query))  // 根据条件过滤}}// 普通用户，借阅图书def borrowBook(username:String,bookId:Int): Boolean = {//   （1） 根据图书的ID，查询图书， 判断图书是否存在val books = bookDAO.loadBooks()val records = borrowRecordDAO.loadBorrowRecord()val book = books.find(b => b.id == bookId)if (book.nonEmpty) {val b = book.get//   （2） 判断图书是否已经被借出if (b.available) {//   （3） 借阅图书//        更新这本书的状态b.available = false// 把更新之后的图书的信息写回txt文件中bookDAO.saveBooks(books)//    TODO    添加一条借书记录// 读出当前全部的记录// 添加一条记录records += BorrowRecordModel(username,b.id,b.name,LocalDateTime.now().toString)// 写回txt文件中borrowRecordDAO.saveBorrowRecord(records)println("借阅成功,已保存借阅记录！！！")true} else {println("这本书已经被借走了！！！")false}} else {false}}// 普通用户，查询自己的借阅记录def queryBorrowRecords(username: String):ListBuffer[BorrowRecordModel] = {// 读出全部的借阅记录val records = borrowRecordDAO.loadBorrowRecord()// 过滤出当前用户的借阅记录records.filter(r => r.userName == username)}// 普通用户，归还自己借的某一本书def returnBook(username: String, bookId: Int): Boolean = {// 1.确定这本书是他本人借的并归还处于没有归还的状态queryBorrowRecords(username).find(r => r.bookID == bookId && r.returnDate.isEmpty) match {case Some(record) =>// 2.更新这本书的状态// 2.1 加载全部的图书信息val books = bookDAO.loadBooks()// 2.2选择当前这一本书val b = books.find(_.id == bookId).getb.available = true// 2.3 把更新之后的状态写回txt文件中bookDAO.saveBooks(books)// 3.更新借阅记录的状态// 3.1 加载全部的借阅记录val records = borrowRecordDAO.loadBorrowRecord()// 3.2 找到当前这本书的借阅记录val r = records.find(r => r.bookID == bookId && r.userName ==username && r.returnDate.isEmpty).getr.returnDate = Some(LocalDateTime.now().toString)// 3.3 把更新之后的状态写回txt文件中borrowRecordDAO.saveBorrowRecord(records)truecase None => false}}// 添加图书def addBook(book: BookModel): Unit = {// 1. 生成一个book ID// 查询所有的图书，找到最大的ID，+1var id = 1val books = bookDAO.loadBooks()if (books.nonEmpty) {id = books.map(_.id).max + 1}// 2. 更新val newBook = book.copy(id = id)// 3. 把新的图书添加到books.txt中books += newBook// 4. 把更新之后的状态写回txt文件中bookDAO.saveBooks(books)}private def queryBooks(): ListBuffer[BookModel] = {// 1. 加载全部的图书val books = bookDAO.loadBooks()// 2. 返回books}}
  

文件：UserService.scala

• 提供用户相关的业务逻辑。

• 调用DAO层的方法，实现用户的增删改查等业务操作。

• package app.org
  package serviceimport dao.UserDAOimport models.UserModelclass UserService {private val userDAO = new UserDAO()// 身份校验def authenticateUser(username: String, password: String): Option[UserModel] = {// 去根据用户名和密码查询，是否有符合要求的用户val users = userDAO.loadUsers()users.find(user => user.username == username && user.password == password)}// 注册用户def addUser(username: String): Boolean = {// 1. 查询用户名是否已经存在val users = userDAO.loadUsers()val user =users.find( _.username == username)if (user.isEmpty) {// 可以继续添加// 2.添加// 2.1 读取所有的用户// 2.2 创建新的用户users += UserModel(username, "[\\d]", "普通用户")// 2.3 保存用户userDAO.saveUsers(users)true} else {false}}
  }
  

4. 用户界面层（UI）

文件：LPT.scala

• 提供用户界面的实现。

• 负责与用户的交互，如显示图书列表、显示借阅记录、用户登录等。

• package app.org
  package uiimport models.{BookModel, UserModel}
  import service.{BookService, UserService}import scala.io.StdIn
  import scala.io.StdIn.readLineclass LPT {private val BookService = new BookService()private val UserService = new UserService()// 辅助方法： 输入图书的信息，返回一个BookModel对象private def inputBookInfo(): BookModel = {println("请输入图书的名称：")val name = readLine().trimprintln("请输入图书的作者：")val author = readLine().trimprintln("请输入图书是否可以外借（true/false）:")val available = StdIn.readBoolean()// 初始设置编号为0BookModel(0,name, author, available)}// 显示游客的菜单def showVisitorMenu(): Unit = {var running = truewhile (running) {println("欢迎来到我的图书管理系统，请选择：")println("1. 查看所有图书")println("2. 查询图书")println("3. 登录")println("4. 退出")// 获取用户操作val choice = StdIn.readLine().trimchoice match {case "1" =>// 调用业务逻辑层的方法val results = BookService.searchBooks("")if (results.nonEmpty) {results.foreach(println)} else {println("没有找到图书")}case "2" =>// 提示用户输入查询关键字val query = readLine("请输入查询关键字：").trim// 根据关键字去查询图书列表，找到满足条件的书val results = BookService.searchBooks(query)// 显示出来if (results.nonEmpty) {println("=================查询图书的结果结果====================")results.foreach(println)} else {println("没有找到图书")}case "3" =>println("请输入用户名：")val username = StdIn.readLine().trimprintln("请输入密码：")val password = StdIn.readLine().trim// 调用service的方法，进行登录val userOPT =UserService.authenticateUser(username, password)if (userOPT.isEmpty) {println("用户名或密码错误")} else {// 登录成功,显示登录用户的菜单val user = userOPT.getuser.role match {case "管理员" => showAdminMenu(user)case "普通用户" => showUserMenu(user)}}case "4" =>running = falseprintln("感谢你的使用，下次再见")case _ => println("无效的选择，请重新输入")}}}// 显示管理员的菜单def showAdminMenu(user: UserModel): Unit = {var running = truewhile (running) {println(s"欢迎管理员${user.username}来到我的图书管理系统，请选择：")println("1. 添加图书")println("2. 查询图书")println("3. 添加用户")println("4. 退出")// 获取用户的操作val choice = StdIn.readLine().trimchoice match {case "1" =>// 1.获取图书信息-书名，作者，状态val book = inputBookInfo()// 2. 调用service的方法，做添加到books.txt中操作BookService.addBook(book)println(s"图书《${book.name}》添加成功")case "2" =>// 提示用户输入查询关键字println("请输入查询关键字：")val query = readLine().trimval results = BookService.searchBooks(query)if (results.nonEmpty) {println("=================查询图书的结果====================")results.foreach(println)println("=================以上是查询图书的结果！！！！====================")println()} else {println("没有找到图书")}case "3" =>// 1.获取用户信息-用户名，密码，角色val username = StdIn.readLine("请输入用户名：")// 2. 调用service的方法，做添加到users.txt中操作if (UserService.addUser(username)) {println(s"用户${username}添加成功")} else {println("用户添加失败")}case "4" => running = falsecase _ => println("无效的选择，请重新输入")}}}// 显示登录用户的菜单def showUserMenu(user: UserModel): Unit = {var running = truewhile (running) {println(s"欢迎用户${user.username}来到我的图书管理系统，请选择：")println("1. 借阅图书")println("2. 查询借阅图书")println("3. 还书")println("4. 退出")// 获取用户的操作val choice = StdIn.readLine().trimchoice match {case "1" =>// UI : 提示用户输入图书ID。校验：判断是否整数try {val id = readLine("请输入图书的ID:").toIntprintln(id)BookService.borrowBook(user.username,id)} catch {case e: Exception =>println(e)println("输入的图书ID无效，请重新输入:")}case "2" => println("查询图书")val borrowRecords = BookService.queryBorrowRecords(user.username)//if (borrowRecords.isEmpty) {println("您还没有借阅过任何图书!!!")} else {// 打印借阅记录println("查询结果，一共借了?本，?本已归还，?本未归还")for (record <- borrowRecords) {val returnDate = record.returnDate.getOrElse("未归还")println(s"用户名：${record.userName}，图书ID：${record.bookID}，图书名称：${record.bookName}，借阅日期：${record.borrowDate}，归还日期：$returnDate")}}case "3" => println("还书")try {val id = readLine("请输入要归还的图书的ID:").toIntif(BookService.returnBook(user.username, id)) {println("归还图书成功!!!")} else {println("归还图书失败，请检查输入的图书ID是否正确")}} catch {case e: Exception =>println(e)println("输入的图书ID无效，请重新输入")}case "4" => running = falsecase _ => println("无效的选择，请重新输入")}}}def showMenu(): Unit = {showVisitorMenu()}
  }
  

文件：Main.scala

Main.scala 文件是Scala应用程序的入口点，它通常包含 main 函数，该函数是程序执行的起始点。在这个图书馆管理系统中，Main.scala 可能承担以下职责：

1. 初始化系统：设置系统运行所需的环境，例如初始化数据库连接、加载配置文件等。

2. 启动服务：启动系统中的服务层，例如图书服务、用户服务等，这些服务可能负责处理业务逻辑。

3. 用户界面启动：启动用户界面层，例如命令行界面或图形用户界面，允许用户与系统交互。

4. 运行主循环：对于需要持续运行的系统，Main.scala 可能包含一个主循环，用于不断监听用户输入或处理后台任务。

5. 错误处理：设置全局错误处理机制，确保系统在遇到错误时能够优雅地处理并给出用户友好的反馈。

   package app.orgimport ui.LPTobject Main {def main(args: Array[String]): Unit = {val m = new LPT()m.showMenu()}
   }
   

5. 其他文件

文件：books.txt

• 存储图书信息的文本文件。

• 每行包含图书的ID、书名、作者和是否可借的信息。

文件：borrow_records.txt

• 存储借阅记录的文本文件。

• 每行包含用户ID、图书ID、借阅时间和归还时间的信息。

文件：users.txt

• 存储用户信息的文本文件。

• 每行包含用户的用户名、密码和用户类型（管理员或普通用户）的信息。

总结

本项目通过分层架构实现了一个图书馆管理系统，各层之间职责明确，便于维护和扩展。数据访问层负责与数据库的交互，数据模型层定义了系统中使用的数据结构，服务层实现了具体的业务逻辑，用户界面层负责与用户的交互。通过这种方式，系统具有良好的可读性和可维护性。

 # # #本项目并不是完美的项目, 嗨有缺少的功能自行添加!!!!!!!!!!!!