1 概述
随着java的深入学习，通过JDBC连接数据库实现图书管理系统，简单实现登录，注册，图书信息的增删改查，借书之前必须要注册借阅证，储存到数据库中，查询学生借阅的情况，还有一个借阅排行榜功能，本系统对于非法操作，该系统有识别作用。更多的功能还有待完善，不喜勿喷······
2 需求分析
2.1用户需求
该系统是一个管理员的对图书管理借还系统，是一个比较智能化的系统，虽然仅面向管理员，但具有比较高的识别作业及其安全性能。他能够实现学生办理借阅卡，借阅书籍，查看借还情况功能，图书添加，修改书籍，删除书籍，图书借阅排行榜查询。用户必修输入有效密码才能成功进入系统，进入系统后可以进行相应的操作。
该系统界面不是很友好，但操作非常容易上手。做到了看了就知道怎么操作的要求。非常适合用初学者练手
2.2业务流程分析
该系统的主要面向的管理员。下面分角色对该系统的不同操作范围做说明。
该系统主要有以下功能模块：
-
登陆功能：登陆系统为数据库表信息登陆。分为管理员登陆，同时具备注册功能。
-
登陆后：显示该书籍增删改查功能，图书借阅排行榜功能。学生可以办理借阅卡，然后才可以进行借书、还书功能，查看学生借阅信息。
-
查询书籍：查看所有的书籍，按编号查询，按图书名称查询，按图书作者查询。
-
删除书籍：按编号查询，按姓名查询。
-
更新（修改）书籍信息：查看书籍的具体信息后，根据编号可以对该书籍信息进行修改。
-
删除书籍信：查看书籍的具体信息后，可以按编号删除单本书，也可以批量删除。
-
增加书籍：增加书籍信息。
-
借书：根据借阅表信息判断能否借阅，书籍是否借阅出去，并记录借阅时间。
-
还书：根据借阅表判断是否借阅，记录还书时间，根据借阅表判断时间是否逾期，逾期则按每天1元钱罚款。
-
查看借阅证信息：查看信息后，然而不进行信息修改
-
查看图书借阅排行榜。
业务流程图如下：
2.3信息需求分析
资料收集：业务流程中用到的相关数据主要是书籍的信息
事项分析：根据以上资料中标题、表头等中各栏目名，可以得出相关事项，作为数据项；分析这些数据项，找出组合项、导出项、非结构化数据项，确定基本项。检查是否有要补充的基本数据项，是否有要改进的地方，补充改进之，得出所有基本项。
2.4功能需求分析
该系统的主要结构功能如下：
3 概念设计
基本项构思ERD的四条基本原则：
①原则1 （确定实体）：能独立存在的事物，例如人、物、事、地、团体、机构、活动、事项等等，在其有多个由基本项描述的特性需要关注时，就应把它作为实体。
②原则2 （确定联系）：两个或多个实体间的关联与结合，如主管，从属，组成，占有，作用，配合，协同等等，当需要予以关注时，应作为联系。实体间的联系可分为一对一、一对多、多对多等三类，在确定联系时还要确定其类型。
③原则3 （确定属性）：实体的属性是实体的本质特征。实体应有标识属性（能把不同个体区分开来的属性组），并指定其中一个作为主标识。联系的属性是联系的结果或状态。
④原则4（一事一地）：信息分析中得到的基本项要在且仅在实体联系图中的一个地方作为属性出现。
经过上述系统功能分析和需求总结，设计如下面所示的数据项和数据结构。
书籍表：存放书籍记录。包括书籍编号，书籍名称，书籍作者，书籍出版社，书籍状态（是否借阅），备注。
借阅证信息表：存放学生信息。包括学生学号，姓名，班级编号，年龄，性别，手机号码。
借阅表：存放借书记录的信息。包括学号，书籍号，借书时间，预计还书时间。
归还表：存放还书记录的信息学号，包括学号，书籍号，借书的时间，还书的时间。
学生借书情况：学号，书籍编号，借书时间，借书到期时间
学生还书情况：学号，书籍编号，还书时间
4 逻辑设计
4.1一般逻辑模型设计
关系模型的逻辑结构是一组关系模式的集合。将E-R图转换为关系模型就是要将实体型、实体的属性和实体型之间的联系转换为关系模式。
由ERD导出一般关系模型的四条原则；
①一个1：1联系可以转换为一个独立的关系模式，也可以与任意一端对应的关系模式合并。如果软换为一个独立的关系模式，则与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，每个实体的码均是该关系的候选码。如果与某一端实体对应的关系模式何明，则需要在该关系模式的属性中加入另一个关系模式的码和联系本身的属性。
②一个1：n联系可以转换为一个独立的关系模式，也可以与n端对应的关系模式合并。如果转换为一个独立的关系模式，则与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为n端实体的码。
③一个m：n联系转换为一个关系模式。与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，各实体的码组成关系的码或关系码的一部分。
④3个或3个以上实体间的一个多元联系可以转换为一个关系模式。与该多元联系项链呢的各实体的码以及联系本身的属性均转换为关系的属性，各实体的码组成关系的码或关系码的一部分。
根据以上原则将E-R图转换成的关系模式如下：
书籍表：（书籍编号，书籍名称，书籍作者，书籍出版社，书籍状态（是否借阅），备注）
借阅证信息表：（学生学号，姓名，班级编号，年龄，性别，手机号码)
借阅表：（学号，书籍号，借书时间，预计还书时间)
归还表：（学号，书籍号，借书的时间，还书的时间)
借书表：(学号，书籍编号，借书时间，借书到期时间)
还书表：(学号，书籍编号，还书时间)
4.2具体逻辑模型设计
在MySql 数据库中，创建 book_system 数据库，然后根据数据库的逻辑结构分析创建的6张数据表。在前台访问数据库阶段设置了用户和密码，用户为root，密码为123456。
Book表信息：
借阅证表信息：
学生借书表信息：
学生还书表信息：
管理员登录信息表：
5 系统设计与实现
5.1完整性设计
列出主要字段完整性的字段名、完整性约束条件；列出记录完整性约束及其约束条件；列出参照完整性表。
主要字段的完整性字段名和参照完整性表可以参照上图各个表之间的关系来看。
5.2处理功能统计
该系统的面向管理员进行操作。下面分角色对该系统的不同操作范围做说明。
首先会自动打开“登录界面”，登录后会跳转到用户界面，用户界面则可以使用相应的功能。
该系统主要有以下功能模块：
-
登陆功能：登陆系统为数据库表信息登陆。分为管理员登陆，同时具备注册功能。
-
登陆后：显示该书籍增删改查功能，图书借阅排行榜功能。学生可以办理借阅卡，然后才可以进行借书、还书功能，查看学生借阅信息。
-
查询书籍：查看所有的书籍，按编号查询，按图书名称查询，按图书作者查询。
-
删除书籍：按编号查询，按姓名查询。
-
更新（修改）书籍信息：查看书籍的具体信息后，根据编号可以对该书籍信息进行修改。
-
删除书籍信：查看书籍的具体信息后，可以按编号删除单本书，也可以批量删除。
-
增加书籍：增加书籍信息。
-
借书：根据借阅表信息判断能否借阅，书籍是否借阅出去，并记录借阅时间。
-
还书：根据借阅表判断是否借阅，记录还书时间，根据借阅表判断时间是否逾期，逾期则按每天1元钱罚款。
-
查看借阅证信息：查看信息后，然而不进行信息修改
-
查看图书借阅排行榜。
5.3用户操作
鼠标和键盘操作
6 数据库应用系统运行
6.1操作系统使用的简要说明
本系统的运行需要安装jre和MySql软件。操作该系统，首先把备份的数据库还原出来，创建表成功并储存少量数据后，通过JDBC连接数据库，然后打开该系统，就可以运行了。
6.2系统实施过程
- 打开eclipse编程
2.通过JDBC连接数据库，打开该系统进行相应的操作
BaseDao类：
package com.book_system.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public abstract class BaseDao {
/**
* 获得连接的方法
*
* @return
*/
protected Connection getConnection() {
// 加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/book_system", "root", "123456");
return conn;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
}
return null;
}
//Object...objs 中间三个..表示当前参数可能有0个到多个 如果传了参数 就当成数组处理
// 如果传入一个参数 数组长度就是3 如果不传参数 数组长度为0
protected int executeUpdate(String sql, Object... objs) {
Connection conn = this.getConnection();
PreparedStatement stmt = null;
try {
stmt = conn.prepareStatement(sql);
for (int i = 0; i < objs.length; i++) {
stmt.setObject(i + 1, objs[i]);
}
int result = stmt.executeUpdate();
return result;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
this.closeAll(null, stmt, conn);
}
return 0;
}
protected void closeAll(ResultSet rs, Statement stmt, Connection conn) {
try {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
- 编写实体类，代码如下：
图书类：
package com.book_system.entity;
//图书类
public class Book {
private int book_id;
private String book_name;
private String book_author;
private String book_adress;
public Book() {
}
public Book(int book_id, String book_name, String book_author, String book_adress) {
super();
this.book_id = book_id;
this.book_name = book_name;
this.book_author = book_author;
this.book_adress = book_adress;
}
public int getBook_id() {
return book_id;
}
public void setBook_id(int book_id) {
this.book_id = book_id;
}
public String getBook_name() {
return book_name;
}
public void setBook_name(String book_name) {
this.book_name = book_name;
}
public String getBook_author() {
return book_author;
}
public void setBook_author(String book_author) {
this.book_author = book_author;
}
public String getBook_adress() {
return book_adress;
}
public void setBook_adress(String book_adress) {
this.book_adress = book_adress;
}
@Override
public String toString() {
return "Book [book_id=" + book_id + ", book_name=" + book_name + ", book_author=" + book_author
+ ", book_adress=" + book_adress + "]";
}
}
package com.book_system.entity;
//图书类
public class Book {
private int book_id;
private String book_name;
private String book_author;
private String book_adress;
public Book() {
}
public Book(int book_id, String book_name, String book_author, String book_adress) {
super();
this.book_id = book_id;
this.book_name = book_name;
this.book_author = book_author;
this.book_adress = book_adress;
}
public int getBook_id() {
return book_id;
}
public void setBook_id(int book_id) {
this.book_id = book_id;
}
public String getBook_name() {
return book_name;
}
public void setBook_name(String book_name) {
this.book_name = book_name;
}
public String getBook_author() {
return book_author;
}
public void setBook_author(String book_author) {
this.book_author = book_author;
}
public String getBook_adress() {
return book_adress;
}
public void setBook_adress(String book_adress) {
this.book_adress = book_adress;
}
@Override
public String toString() {
return "Book [book_id=" + book_id + ", book_name=" + book_name + ", book_author=" + book_author
+ ", book_adress=" + book_adress + "]";
}
}
借阅学生信息类：
package com.book_system.entity;
/**
* 借阅信息类
* @author Administrator
*
*/
public class User {
private int user_id;
private String user_name;
private int user_age;
private String user_gender;
private String user_phone;
public User() {
super();
}
public User(int user_id, String user_name, int user_age, String user_gender, String user_phone) {
super();
this.user_id = user_id;
this.user_name = user_name;
this.user_age = user_age;
this.user_gender = user_gender;
this.user_phone = user_phone;
}
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public int getUser_age() {
return user_age;
}
public void setUser_age(int user_age) {
this.user_age = user_age;
}
public String getUser_gender() {
return user_gender;
}
public void setUser_gender(String user_gender) {
this.user_gender = user_gender;
}
public String getUser_phone() {
return user_phone;
}
public void setUser_phone(String user_phone) {
this.user_phone = user_phone;
}
@Override
public String toString() {
return "User [user_id=" + user_id + ", user_name=" + user_name + ", user_age=" + user_age + ", user_gender="
+ user_gender + ", user_phone=" + user_phone + "]";
}
}
借书表类
package com.book_system.entity;
/*
* 借书表
*/
public class Borrow {
private int user_id;
private int book_id;
private String borrow_time;
private String expect_time;
public Borrow() {
super();
}
public Borrow(int user_id, int book_id, String borrow_time, String expect_time) {
super();
this.user_id = user_id;
this.book_id = book_id;
this.borrow_time = borrow_time;
this.expect_time = expect_time;
}
public String getBorrow_time() {
return borrow_time;
}
public void setBorrow_time(String borrow_time) {
this.borrow_time = borrow_time;
}
public String getExpect_time() {
return expect_time;
}
public void setExpect_time(String expect_time) {
this.expect_time = expect_time;
}
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
public int getBook_id() {
return book_id;
}
public void setBook_id(int book_id) {
this.book_id = book_id;
}
}
还书表类
package com.book_system.entity;
/**
* 还书表
* @author Administrator
*
*/
public class Return {
private int user_id;
private int book_id;
private String borrow_time;
private String return_time;
public Return() {
super();
}
public Return(int user_id, int book_id, String borrow_time, String return_time) {
super();
this.user_id = user_id;
this.book_id = book_id;
this.borrow_time = borrow_time;
this.return_time = return_time;
}
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
public int getBook_id() {
return book_id;
}
public void setBook_id(int book_id) {
this.book_id = book_id;
}
public String getBorrow_time() {
return borrow_time;
}
public void setBorrow_time(String borrow_time) {
this.borrow_time = borrow_time;
}
public String getReturn_time() {
return return_time;
}
public void setReturn_time(String return_time) {
this.return_time = return_time;
}
}
4.创建接口，代码如下：
书籍方法的接口：
package com.book_system.impl;
import com.book_system.entity.Book;
public interface BookDao {
// 新书入库
public boolean addBook(Book book);
// 查询所有图书信息
public boolean bookInfo();
// 查询该图书编号图书信息(编号)
public void searchBook1(int id);
// 查询该图书编号图书信息(姓名模糊查询)
public boolean searchBook2(String author);
// 查询该图书编号图书信息(按名称模糊查询)
public boolean searchBook3(String name);
// 用图书编号修改图书信息
public boolean bookUpdate(int id, Book book);
// 按编号删除旧图书
public boolean delelteBook(int id);
// 批量删除旧图书
public boolean delelteBook1(String id);
}
借阅信息的接口：
package com.book_system.impl;
import com.book_system.entity.User;
public interface UserDao {
// 办理借阅证
public boolean loanCard(User user);
// 用借书证搜索读者
public boolean searchUser(int id);
// 搜索所有拥有借书证读者
public boolean userInof();
// 查询违规记录表
public boolean userInof1();
}
借书表接口
package com.book_system.impl;
import com.book_system.entity.Borrow;
public interface BorrowDao {
// 借书
public boolean borrow(Borrow borrow);
// 在借阅表中搜索该图书
public boolean serachBorrow(int book_id);
// 还书之后，书本状态返回1(未借状态)
public void resetBook(int book_status, String book_comment);
// 借阅表删除记录
public boolean delelteBorrow(int user_id);
}
还书表接口
package com.book_system.impl;
import com.book_system.entity.Return;
public interface ReturnDao {
// 还书
public boolean Return(Return return1);
// 借书排行榜
public void maxRankList();
}
4.接口实现类，代码如下：
书籍接口实现：
package com.book_system.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import com.book_system.dao.BaseDao;
import com.book_system.entity.Book;
public class BookDaoImpl extends BaseDao implements BookDao {
static Scanner input = new Scanner(System.in);
private Connection conn = super.getConnection();
@Override
public boolean addBook(Book book) {
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "insert into book(book_id,book_name,book_author,book_adress) values(?,?,?,?)";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, book.getBook_id());
pstmt.setString(2, book.getBook_name());
pstmt.setString(3, book.getBook_author());
pstmt.setString(4, book.getBook_adress());
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
return flag;
}
@Override
public boolean bookInfo() {
Statement stmt = null;
String sql = "select * from book";
try {
stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
System.out.println("图书编号" + "\t 书名" + "\t\t\t" + "作者" + "\t\t 出版社\t\t 是否借阅(1不是 0是)\t\t\t备注");
// System.out.println("图书编号"+" 书名"+" " +
// "作者"+" 出版社"+" 联系方式");
while (rs.next()) { // 如果对象中有数据，就会循环打印出来
// System.out.println(rs.getString("book_id") + "\t" + rs.getString("book_name") + "\t\t"
// + rs.getString("book_author") + "\t" + rs.getString("book_adress"));
System.out.printf("%-10s", rs.getString("book_id"));
System.out.printf("%-20s", rs.getString("book_name"));
System.out.printf("%-30s", rs.getString("book_author"));
System.out.printf("%-20s", rs.getString("book_adress"));
System.out.printf("%-30s", rs.getString("book_status"));
System.out.printf("%-30s\n", rs.getString("book_comment"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, stmt, null);
}
return true;
}
@Override
public void searchBook1(int book_id) {
PreparedStatement pstmt = null;
String sql = "SELECT book_id,book_name,book_author,book_adress,book_status,book_comment FROM book WHERE book_id=?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, book_id);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println("图书编号：" + rs.getInt(1) + "\n" + "书名：" + rs.getString(2) + "\n" + "图书作者："
+ rs.getString(3) + "\n" + "出版社：" + rs.getString(4) + "\n是否借阅(1不是 0是)" + rs.getString(5)
+ "\n备注" + rs.getString(6));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
}
@Override
public boolean searchBook2(String author) {
PreparedStatement pstmt = null;
String sql = "SELECT book_id,book_name,book_author,book_adress,book_status,book_comment FROM book WHERE book_author LIKE?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, "%" + author + "%");
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println("图书作者：" + rs.getString(3) + "\t" + "图书编号：" + rs.getInt(1) + "\t" + "书名："
+ rs.getString(2) + "\t" + "出版社：" + rs.getString(4) + "\t是否借阅(1不是 0是):" + rs.getString(5)
+ "\t备注:" + rs.getString(6));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
return false;
}
@Override
public boolean searchBook3(String name) {
PreparedStatement pstmt = null;
String sql = "SELECT book_id,book_name,book_author,book_adress,book_status,book_comment FROM book WHERE book_name Like?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, "%" + name + "%");
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println("书名：" + rs.getString(2) + "\t" + "图书编号：" + rs.getInt(1) + "\t" + "图书作者："
+ rs.getString(3) + "\t" + "出版社：" + rs.getString(4) + "\t是否借阅(1不是 0是)" + rs.getString(5)
+ "\t备注" + rs.getString(6));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
return true;
}
@Override
public boolean bookUpdate(int id, Book book) {
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "UPDATE book SET book_name=?,book_author=?,book_adress=? WHERE book_id=?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, book.getBook_name());
pstmt.setString(2, book.getBook_author());
pstmt.setString(3, book.getBook_adress());
pstmt.setInt(4, book.getBook_id());
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
return flag;
}
@Override
public boolean delelteBook(int id) {
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "DELETE FROM book WHERE book_id=?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, id);
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
return flag;
}
@Override
public boolean delelteBook1(String id) {
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "DELETE FROM book WHERE book_id in (" + id + ")";
try {
pstmt = conn.prepareStatement(sql);
// pstmt.setString(1, id);
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
return flag;
}
}
借阅信息接口实现：
package com.book_system.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import com.book_system.dao.BaseDao;
import com.book_system.entity.User;
public class UserDaoImpl extends BaseDao implements UserDao {
static Scanner input = new Scanner(System.in);
private Connection conn = super.getConnection();
@Override
public boolean loanCard(User user) {
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "insert into user(user_id,user_name,user_age,user_gender,user_phone) values(?,?,?,?,?)";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, user.getUser_id());
pstmt.setString(2, user.getUser_name());
pstmt.setInt(3, user.getUser_age());
pstmt.setString(4, String.valueOf(user.getUser_gender()));
pstmt.setString(5, user.getUser_phone());
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
return flag;
}
@Override
public boolean searchUser(int id) {
PreparedStatement pstmt = null;
String sql = "SELECT user_id,user_name,user_age,user_gender,user_phone FROM user WHERE user_id=?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, id);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println("读者借书证号：" + rs.getInt(1) + "\n" + "读者姓名：" + rs.getString(2) + "\n" + "读者年龄："
+ rs.getString(3) + "\n" + "读者性别" + rs.getString(4) + "\n" + "读者联系方式" + rs.getString(5));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
return true;
}
@Override
public boolean userInof() {
Statement stmt = null;
String sql = "select * from user";
try {
stmt = conn.createStatement();
// 执行查询数据库的SQL语句 ，返回一个结果集（ResultSet）对象。
ResultSet rs = stmt.executeQuery(sql);
System.out.println("借书证号" + "\t读者姓名" + "\t" + "读者年龄" + "\t读者性别" + "\t联系方式");
while (rs.next()) { // 如果对象中有数据，就会循环打印出来
System.out.println(
rs.getInt("user_id") + "\t" + rs.getString("user_name") + "\t" + rs.getInt("user_age")
+ "\t" + rs.getString("user_gender") + "\t" + rs.getString("user_phone"));
// System.out.printf("%-10s", rs.getString("user_id"));
// System.out.printf("%20s", rs.getString("user_name"));
// System.out.printf("%20s", rs.getString("user_age"));
// System.out.printf("%20s", rs.getString("user_sex"));
// System.out.printf("%20s\n", rs.getString("user_phone"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, stmt, null);
}
return true;
}
@Override
public boolean userInof1() {
Statement stmt = null;
String sql = "select * from punish";
try {
stmt = conn.createStatement();
// 执行查询数据库的SQL语句 ，返回一个结果集（ResultSet）对象。
ResultSet rs = stmt.executeQuery(sql);
System.out.println("借书证号" + "\t图书编号" + "\t" + "超期天数" + "\t处罚金额" + "\t是否交罚款");
while (rs.next()) { // 如果对象中有数据，就会循环打印出来
System.out.println(
rs.getInt(1) + "\t" + rs.getInt(2) + "\t" + rs.getInt(3)
+ "\t" + rs.getInt(4) + "\t" + rs.getString(5));
// System.out.printf("%-10s", rs.getString("user_id"));
// System.out.printf("%20s", rs.getString("user_name"));
// System.out.printf("%20s", rs.getString("user_age"));
// System.out.printf("%20s", rs.getString("user_sex"));
// System.out.printf("%20s\n", rs.getString("user_phone"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, stmt, null);
}
return true;
}
}
借书表接口实现：
package com.book_system.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;
import com.book_system.dao.BaseDao;
import com.book_system.entity.Borrow;
public class BorrowDaoImpl extends BaseDao implements BorrowDao {
static Scanner input = new Scanner(System.in);
private Connection conn = super.getConnection();
@Override
public boolean borrow(Borrow borrow) {
if (serachBorrow(borrow.getBook_id())) {
return false;
}
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "insert into borrow(user_id,book_id,borrow_time,expect_time) values(?,?,?,?)";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, borrow.getUser_id());
pstmt.setInt(2, borrow.getBook_id());
pstmt.setString(3, borrow.getBorrow_time());
pstmt.setString(4, borrow.getExpect_time());
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
return flag;
}
@Override
public boolean serachBorrow(int book_id) {
String sql = "SELECT book_id FROM borrow WHERE book_id=?";
PreparedStatement ptmt = null;
try {
ptmt = conn.prepareStatement(sql);
ptmt.setInt(1, book_id);
ResultSet rs = ptmt.executeQuery();
if (rs.next()) {
System.out.println("图书已被借走！\n");
return true;
} else {
return false;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, null, null);
}
return false;
}
@Override
public void resetBook(int book_status, String book_comment) {
PreparedStatement pstmt = null;
String sql = "UPDATE book SET book_status=? WHERE book_comment=?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, book_status);
pstmt.setString(2, book_comment);
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
}
@Override
public boolean delelteBorrow(int user_id) {
PreparedStatement pstmt = null;
String sql = "DELETE FROM borrow WHERE user_id=?";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, user_id);
if (pstmt != null) {
return true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
return false;
}
}
还书表接口实现：
package com.book_system.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;
import com.book_system.dao.BaseDao;
public class ReturnDaoImpl extends BaseDao implements ReturnDao {
static Scanner input = new Scanner(System.in);
private Connection conn = super.getConnection();
@Override
public boolean Return(com.book_system.entity.Return return1) {
// if (return1.getBook_id() != 0) {
// System.out.println("该书还未被借出去！！！");
// return true;
// }
boolean flag = false;
PreparedStatement pstmt = null;
String sql = "insert into `book_system`.`return`(`user_id`, `book_id`, `borrow_time`,`return_time`) values(?,?,?,?)";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, return1.getUser_id());
pstmt.setInt(2, return1.getBook_id());
pstmt.setString(3, return1.getBorrow_time());
pstmt.setString(4, return1.getReturn_time());
if (pstmt.executeUpdate() > 0) {
flag = true;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
return flag;
}
@Override
public void maxRankList() {
PreparedStatement pstmt = null;
String sql = "select r.user_id,k.book_name,k.book_author,COUNT(*) AS MaxRankList FROM book k,`return` r WHERE k.book_id=r.user_id group by r.user_id order by MaxRankList desc limit 10;";
try {
pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery(sql);
System.out.println("图书编号" + "\t图书名称" + "\t图书作者" + "\t借阅排行榜");
while (rs.next()) { // 如果对象中有数据，就会循环打印出来
System.out
.println(rs.getInt(1) + "\t" + rs.getString(2) + "\t" + rs.getString(3) + "\t" + rs.getInt(4));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
super.closeAll(null, pstmt, null);
}
}
}
5.main方法菜单显示及调用方法，代码如下：
登录类：
package com.book_system.entity;
import java.util.Calendar;
import java.util.Scanner;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import com.book_system.dao.BaseDao;
public class DBDao extends BaseDao {
static Scanner input = new Scanner(System.in);
private Connection conn = super.getConnection();
// 管理员登陆
public boolean login() {
System.out.println("----管理员登录----");
System.out.println("请您输入用户名：");
String adminName = input.next();
System.out.println("请您输入密码：");
String adminPwd = input.next();
String sql = "SELECT ADMIN_NAME,ADMIN_PWD FROM ADMIN WHERE ADMIN_NAME=? AND ADMIN_PWD=?";
PreparedStatement ptmt = null;
try {
ptmt = conn.prepareStatement(sql);
ptmt.setString(1, adminName);
ptmt.setString(2, adminPwd);
ResultSet rs = ptmt.executeQuery();
if (rs.next()) {
System.out.println("登录成功！");
return true;
} else {
System.out.println("账号或密码不正确，请重新登录！\n");
return false;
}
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}
// 管理员注册
public boolean register() {
System.out.println("----管理员注册----");
System.out.println("输入用户名：");
String adminName = input.next();
System.out.println("输入密码：");
String adminPwd1 = input.next();
System.out.println("再次确认密码");
String adminPwd2 = input.next();
if (adminPwd1.equals(adminPwd2)) {
String password = adminPwd1;
String sql = "INSERT INTO ADMIN(ADMIN_NAME,ADMIN_PWD) VALUES(?,?)";
PreparedStatement ptmt = null;
try {
ptmt = conn.prepareStatement(sql);
ptmt.setString(1, adminName);
ptmt.setString(2, password);
ptmt.execute();
System.out.println("注册成功！");
return true;
} catch (SQLException e) {
e.printStackTrace();
}
} else {
System.out.println("你输入的两次密码不一致，请重新注册!");
return false;
}
return false;
}
// 定义函数，用于判断日期是否合法
public class bookLending {
boolean judge(String str) {
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");// 括号内为日期格式，y代表年份，M代表年份中的月份（为避免与小时中的分钟数m冲突，此处用M），d代表月份中的天数
try {
sd.setLenient(false);// 此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
sd.parse(str);// 从给定字符串的开始解析文本，以生成一个日期
} catch (Exception e) {
return false;
}
return true;
}
}
// 租金计算
public int daysBetween(String borrow_time, String return_time) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//2020-12-12
Calendar cal = Calendar.getInstance();
cal.setTime(sdf.parse(borrow_time));
long time1 = cal.getTimeInMillis();
cal.setTime(sdf.parse(return_time));
long time2 = cal.getTimeInMillis();
long between_days = (time2 - time1) / (1000 * 3600 * 24);
return Integer.parseInt(String.valueOf(between_days));
}
// 惩罚表
public boolean punish(Punish punish) {
PreparedStatement pstmt = null;
String sql = "insert into punish(user_id,book_id,overdue_time,punish_monney,pay_off) values(?,?,?,?,?)";
try {
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, punish.getUser_id());
pstmt.setInt(2, punish.getBook_id());
pstmt.setInt(3, punish.getOverdue_time());
pstmt.setInt(4, punish.getPush_monney());
pstmt.setString(5, punish.getPay_off());
if (pstmt.executeUpdate() > 0) {
System.out.println("添加成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return false;
}
}
测试类：
package com.book_system.view;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.book_system.entity.Book;
import com.book_system.entity.Borrow;
import com.book_system.entity.DBDao;
import com.book_system.entity.Punish;
import com.book_system.entity.Return;
import com.book_system.entity.User;
import com.book_system.impl.BorrowDaoImpl;
import com.book_system.impl.ReturnDaoImpl;
import com.book_system.impl.BookDaoImpl;
import com.book_system.impl.UserDaoImpl;
public class Test {
public static Scanner scanner = new Scanner(System.in);
public static DBDao dbDao = new DBDao();
public static BookDaoImpl bdl1 = new BookDaoImpl();
public static BorrowDaoImpl bdl2 = new BorrowDaoImpl();
public static UserDaoImpl udl = new UserDaoImpl();
public static ReturnDaoImpl rdl = new ReturnDaoImpl();
public static void main(String[] args) throws ParseException {
System.out.println("欢迎使用图书馆管理系统");
System.out.println("1.登陆 \n2.注册\n3.退出");
Test test = new Test();
System.out.println("请选择你要进行的操作：");
int choose = scanner.nextInt();
switch (choose) {
case 1:
if (dbDao.login()) {
test.manager();
}
break;
case 2:
if (dbDao.register()) {
if (dbDao.login()) {
test.manager();
}
} else {
System.out.println("注册失败");
}
break;
case 3:
System.out.println("青山不改，绿水长流，下期再会！! ！");
System.exit(0);
break;
default:
System.out.println("青山不改，绿水长流，下期再会！! ！");
System.exit(0);
}
}
// 登陆后才能进行操作
public void manager() throws ParseException {
String c = "";
do {
System.out.println();
System.out.println("---------------------管理员操作-----------------------");
System.out.println("1.新图书入库\n" + "2.图书信息查询\n" + "3.图书更新（修改）\n" + "4.旧图书删除\n" + "5.办理借阅证登记\n" + "6.图书借阅管理\n"
+ "7.图书借阅排行榜\n" + "8.退出操作");
System.out.println("请选择你要进行的操作：");
int choose2 = scanner.nextInt();
switch (choose2) {
case 1:
insertNewbook();
break;
case 2:
System.out.println("1.查询所有图书信息\n2.按图书编号查询图书信息\n3.按作者姓名查询图书信息\n4.按图书名称查询图书信息");
int choose3 = scanner.nextInt();
if (choose3 == 1) {
bdl1.bookInfo();
} else if (choose3 == 2) {
System.out.println("请输入如图书编号");
int id = scanner.nextInt();
bdl1.searchBook1(id);
} else if (choose3 == 3) {
System.out.println("请输入作者的姓名");
String name = scanner.next();
bdl1.searchBook2(name);
} else {
System.out.println("请输入图书名称");
String name = scanner.next();
bdl1.searchBook3(name);
}
// dbDao.bookInof();
break;
case 3:
updatebook();
break;
case 4:
System.out.println("1.单条删除 \n2.批量删除");
int choose4 = scanner.nextInt();
if(choose4==1) {
deleteBook();
}else {
deleteBook1();
}
break;
case 5:
loanCard();
break;
case 6:
loanManagement();
break;
case 7:
MaxRankList();
break;
case 8:
System.out.println("青山不改，绿水长流，下期再会！! ！");
System.exit(0);
break;
default:
System.out.println("嘟嘟嘟，青山不改，绿水长流，下期再会！! ！");
System.exit(0);
break;
}
System.out.println("是否还要继续？Y/N");
c = scanner.next();
} while (c.equalsIgnoreCase("Y"));
System.out.println("青山不改，绿水长流，下期再会！! ！");
System.exit(0);
}
// 新图书入库
public void insertNewbook() {
System.out.println("请输入要插入的图书编号：");
int book_id = scanner.nextInt();
System.out.println("请输入要插入的图书名称：");
String book_name = scanner.next();
System.out.println("请输入要插入的图书作者：");
String book_author = scanner.next();
System.out.println("请输入要插入的图书出版出版社：");
String book_adress = scanner.next();
Book book = new Book(book_id, book_name, book_author, book_adress);
if (bdl1.addBook(book)) {
System.out.println("新图书入库成功！");
} else {
System.out.println("新图书入库失败！");
}
}
// 修改图书
public void updatebook() {
System.out.println("请输入要修改的图书的编号：");
int book_id = scanner.nextInt();
System.out.println("查询到该图书信息：");
bdl1.searchBook1(book_id);
System.out.println("请输入修改后的图书名称：");
String book_name = scanner.next();
System.out.println("请输入修改后的图书作者：");
String book_author = scanner.next();
System.out.println("请输入修改后的图书出版号：");
String book_adress = scanner.next();
Book book = new Book(book_id, book_name, book_author, book_adress);
if (bdl1.bookUpdate(book_id, book)) {
System.out.println("图书信息修改成功！");
} else {
System.out.println("图书信息修改失败！");
}
}
public void deleteBook() {
System.out.println("请输入要删除的图书编号");
int book_id = scanner.nextInt();
if (bdl1.delelteBook(book_id)) {
System.out.println("删除成功！");
} else {
System.out.println("删除失败！");
}
}
public void deleteBook1() {
System.out.println("请输入您要批量删除的图书编号(1,2,3···格式)：");
String book_id = scanner.next();
if (bdl1.delelteBook1(book_id)) {
System.out.println("删除成功！");
} else {
System.out.println("删除失败！");
}
}
// 办理借阅证
public void loanCard() {
System.out.println("办理借阅证登记：");
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("MMDDmmss");
Date date = new Date();
int user_id = Integer.parseInt(simpleDateFormat.format(date));
System.out.println("请输入该读者的名字：");
String user_name = scanner.next();
System.out.println("请输入该读者的年龄：");
int user_age = scanner.nextInt();
System.out.println("请输入该用户的性别：");
String user_gender = scanner.next();
System.out.println("请输入该读者的联系方式：");
String user_phone = scanner.next();
Pattern p = Pattern.compile(
"^[1](([3][0-9])|([4][5,7,9])|([5][0-9])|([6][6])|([7][3,5,6,7,8])|([8][0-9])|([9][8,9]))[0-9]{8}$");
Matcher m = p.matcher(user_phone);
if (m.matches()) {
User user = new User(user_id, user_name, user_age, user_gender, user_phone);
if (udl.loanCard(user)) {
System.out.println("借阅证登记成功！");
System.out.println("该读者的借书证号为" + user_id);
} else {
System.out.println("借阅证登记失败！");
}
} else {
System.out.println("输入的手机号格式不对");
System.out.println("借阅证登记失败！");
}
}
// 图书借阅管理
public void loanManagement() throws ParseException {
System.out.println("1.借书\n2.还书\n3.读者信息\n4.书籍逾期记录情况");
System.out.println("请选择操作");
int choose3 = scanner.nextInt();
switch (choose3) {
case 1:
borrow(); // 借书
break;
case 2:
Return(); // 还书
break;
case 3:
user();
break;
case 4:
udl.userInof1();
break;
}
}
public String borrow() {
System.out.println("请输入该读者的借书证号：");
int user_id = scanner.nextInt();
System.out.println("请输入要借的图书编号：");
int book_id = scanner.nextInt();
System.out.println("请输入借出的日期（年-月-日）:");
String borrow_time = scanner.next();
// String borrow_time = System.currentTimeMillis() + "";
System.out.println("请输入预计归还的日期（年-月-日）:");
String expect_time = scanner.next();
Borrow borrow = new Borrow(user_id, book_id, borrow_time, expect_time);
if (bdl2.borrow(borrow)) {
System.out.println("借书成功");
} else {
System.out.println("借书失败");
bdl2.resetBook(1, expect_time);
}
return borrow_time;
}
public void Return() throws ParseException {
System.out.println("请输入该读者的借书证号：");
int user_id = scanner.nextInt();
System.out.println("请输入要还的图书编号：");
int book_id = scanner.nextInt();
System.out.println("请输入借书的日期（年-月-日）:");
String borrow_time = scanner.next();
// String borrow_time = borrow();
System.out.println("请输入归还的日期（年-月-日）:");
String return_time = scanner.next();
// String return_time = System.currentTimeMillis() + "";
Return return1 = new Return(user_id, book_id, borrow_time, return_time);
if (rdl.Return(return1)) {
System.out.println("还书成功");
int money = 0;
try {
money = dbDao.daysBetween(borrow_time,return_time) * 1;
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println("应付租金（元）：" + money);
bdl2.resetBook(1, return_time);
bdl2.delelteBorrow(user_id);
dbDao.punish(new Punish(user_id,book_id,dbDao.daysBetween(borrow_time, return_time),money,"y"));
} else {
System.out.println("还书失败");
}
}
public void user() {
udl.userInof();
}
public void MaxRankList() {
rdl.maxRankList();
}
}
6.3系统使用结果
连接数据后，打开程序后进行登录，注册账号密码进行登录，然后进行相应的操作。
登录界面：
注册界面：
登录成功界面：
查询界面：
删除界面：
图书借阅界面：
图书借阅排行榜界面：
扫一扫
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
