图书馆系统源码详解

本项目是一个基于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）

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9ABookDAO.scala">文件：BookDAO.scala

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

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

package app.org
package dao

import models.BookModel

import 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()
  }
}

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9ABorrowRecordDAO.scala">文件：BorrowRecordDAO.scala

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

package app.org
package dao

import models.BorrowRecordModel

import java.io.PrintWriter
import scala.collection.mutable.ListBuffer
import scala.io.Source

class 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()
    }
}

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9AUserDAO.scala">文件：UserDAO.scala

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

package app.org
package dao

import models.UserModel

import java.io.File
import scala.collection.mutable.ListBuffer

class 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）

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9ABookModel.scala">文件：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"
  }
}

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9ABorrowRecordModel.scala">文件：BorrowRecordModel.scala

定义借阅记录的数据模型。
包含借阅记录的属性，如用户ID、书籍ID、借阅时间、归还时间等。

package app.org
package models

case class BorrowRecordModel(
                            userName:String,               // 借书人
                            bookID:Int,                  // 图书ID
                            bookName:String,           // 书名
                            borrowDate:String,          // 借阅日期
                            var returnDate:Option[String] =None   // 归还日期
                            )

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9AUserModel.scala">文件：UserModel.scala

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

package app.org
package models

case class UserModel(
                    username:String,
                    password:String,
                    role:String
                    )

3. 服务层（Service）

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9ABookService.scala">文件：BookService.scala

提供图书相关的业务逻辑。
调用DAO层的方法，实现图书的增删改查等业务操作。

package app.org
package service

import 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).get
        b.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).get
        r.returnDate = Some(LocalDateTime.now().toString)
        // 3.3 把更新之后的状态写回txt文件中
        borrowRecordDAO.saveBorrowRecord(records)
        true
      case None => false
    }
  }

  // 添加图书
  def addBook(book: BookModel): Unit = {
    // 1. 生成一个book ID
    // 查询所有的图书，找到最大的ID，+1
    var id = 1
    val 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
  }

}

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9AUserService.scala">文件：UserService.scala

提供用户相关的业务逻辑。
调用DAO层的方法，实现用户的增删改查等业务操作。

package app.org
package service

import dao.UserDAO

import models.UserModel

class 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）

scala" name="%E6%96%87%E4%BB%B6%EF%BC%9ALPT.scala">文件：LPT.scala

提供用户界面的实现。
负责与用户的交互，如显示图书列表、显示借阅记录、用户登录等。

package app.org
package ui

import models.{BookModel, UserModel}
import service.{BookService, UserService}

import scala.io.StdIn
import scala.io.StdIn.readLine

class LPT {

  private val BookService = new BookService()
  private val UserService = new UserService()

  // 辅助方法： 输入图书的信息，返回一个BookModel对象
  private def inputBookInfo(): BookModel = {
    println("请输入图书的名称：")
    val name = readLine().trim
    println("请输入图书的作者：")
    val author = readLine().trim
    println("请输入图书是否可以外借（true/false）:")
    val available = StdIn.readBoolean()
    // 初始设置编号为0
    BookModel(0,name, author, available)
  }
  // 显示游客的菜单
  def showVisitorMenu(): Unit = {
    var running = true
    while (running) {
      println("欢迎来到我的图书管理系统，请选择：")
      println("1. 查看所有图书")
      println("2. 查询图书")
      println("3. 登录")
      println("4. 退出")

      // 获取用户操作
      val choice = StdIn.readLine().trim
      choice 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().trim
          println("请输入密码：")
          val password = StdIn.readLine().trim
          // 调用service的方法，进行登录
          val userOPT =UserService.authenticateUser(username, password)
          if (userOPT.isEmpty) {
            println("用户名或密码错误")
          } else {
            // 登录成功,显示登录用户的菜单
            val user = userOPT.get
            user.role match {
              case "管理员" => showAdminMenu(user)
              case "普通用户" => showUserMenu(user)
            }
          }

        case "4" =>
          running = false
          println("感谢你的使用，下次再见")
        case _ => println("无效的选择，请重新输入")
      }
    }
  }

  // 显示管理员的菜单
  def showAdminMenu(user: UserModel): Unit = {
    var running = true
    while (running) {
      println(s"欢迎管理员${user.username}来到我的图书管理系统，请选择：")
      println("1. 添加图书")
      println("2. 查询图书")
      println("3. 添加用户")
      println("4. 退出")

      // 获取用户的操作
      val choice = StdIn.readLine().trim
      choice match {
        case "1" =>
          // 1.获取图书信息-书名，作者，状态
          val book = inputBookInfo()
          // 2. 调用service的方法，做添加到books.txt中操作
          BookService.addBook(book)
          println(s"图书《${book.name}》添加成功")
        case "2" =>
          // 提示用户输入查询关键字
          println("请输入查询关键字：")
          val query = readLine().trim
          val 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 = false
        case _ => println("无效的选择，请重新输入")
      }
    }
  }



  // 显示登录用户的菜单
  def showUserMenu(user: UserModel): Unit = {
    var running = true
    while (running) {
      println(s"欢迎用户${user.username}来到我的图书管理系统，请选择：")
      println("1. 借阅图书")
      println("2. 查询借阅图书")
      println("3. 还书")
      println("4. 退出")

      // 获取用户的操作
      val choice = StdIn.readLine().trim
      choice match {
        case "1" =>
          // UI : 提示用户输入图书ID。校验：判断是否整数
          try {
            val id = readLine("请输入图书的ID:").toInt
            println(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:").toInt
            if(BookService.returnBook(user.username, id)) {
              println("归还图书成功!!!")
            } else {
              println("归还图书失败，请检查输入的图书ID是否正确")
            }
          } catch {
            case e: Exception =>
              println(e)
              println("输入的图书ID无效，请重新输入")
          }
        case "4" => running = false
        case _ => println("无效的选择，请重新输入")
      }
    }
  }

  def showMenu(): Unit = {
    showVisitorMenu()
  }
}

文件：Main.scala

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

初始化系统：设置系统运行所需的环境，例如初始化数据库连接、加载配置文件等。
启动服务：启动系统中的服务层，例如图书服务、用户服务等，这些服务可能负责处理业务逻辑。
用户界面启动：启动用户界面层，例如命令行界面或图形用户界面，允许用户与系统交互。
运行主循环：对于需要持续运行的系统，Main.scala 可能包含一个主循环，用于不断监听用户输入或处理后台任务。

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

package app.org

import ui.LPT



object Main {
  def main(args: Array[String]): Unit = {
    val m = new LPT()
    m.showMenu()
  }
}

5. 其他文件

文件：books.txt

存储图书信息的文本文件。
每行包含图书的ID、书名、作者和是否可借的信息。

文件：borrow_records.txt

存储借阅记录的文本文件。
每行包含用户ID、图书ID、借阅时间和归还时间的信息。

文件：users.txt

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

总结

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

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