[大数据]图书馆系统项目（完整版+简单版）

第一部分：技术要求

Java知识。
GUI图形界面。
JDBC知识。
MySQL知识。

第二部分：软件结构

第三部分：部分页面展示

第四部分：数据库

第五部分：部分代码展示

service类：

package service;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import util.DateUtil;
import modle.Book;
import modle.Record;
import dao.BaseDaoImpl;
import dao.BookDaoImpl;
import dao.RecordDaoImpl;
public class BookService {//描述书籍的业务逻辑类
        //静态属性
        private static BookService bookService;
        //静态块创建对象
        static {
            bookService = new BookService();
        }
        private BookDaoImpl bookDao;//书籍的数据
        private RecordDaoImpl recordDao;//借还记录的数据
        //无参构造方法
        private BookService() {
            bookDao = BookDaoImpl.getInstance();//获取书本的数据的对象
            recordDao  = RecordDaoImpl.getInstance();//获取借还记录的数据的对象
        }
        //静态方法获取该类的对象
        public static BookService getInstance() {
            return bookService;
        }
        //可借的属性
        public static final String CAN = "可借";
        //无库存的属性
        public static final String CANT = "无库存";
        //设计通过用户的id和名字借书的方法
        public boolean lendBook(int uId, String name){
            Book bk = bookDao.searchBook(name);//通过名字找寻书籍信息
            // 已借出数量等于书籍总数量，则不可借
            if(bk.getCount() == bk.getHasLended()) {
                return false;
            }
            //创建借还记录对象
            Record rd = new Record(uId,bk.getId(), DateUtil.getDate(), "未还");
            bk.setHasLended(bk.getHasLended() + 1);//每借出一本书就增加一本
            bk.setDiscount(bk.getDiscount());//获取数量
            Connection conn = BaseDaoImpl.getConn();//连接数据库
            try {//设置为false
                conn.setAutoCommit(false);
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            //更新书籍
            boolean res = bookDao.updateBook(bk, conn);
            if(!res) {
                try {
                    conn.commit();//连接数据库提交
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {//关闭连接
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                return false;
            }
            //增加借还记录
            res = recordDao.insertRecord(rd, conn);
            if (!res) {
                try {
                    conn.rollback();//连接数据库返回
                    conn.commit();//连接数据库提交
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {//关闭连接
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                return false;
            } else {
                try {
                    conn.commit();
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                return true;
            }
        }
        //返回书本的方法
        public boolean returnBook(int uId, String name){
            Book bk = bookDao.searchBook(name);//通过书名查找书籍
            if (bk.getId() <= 0){//判断id是否小于0
                return false;
            }
            bk.setHasLended(bk.getHasLended() - 1);//每次借一本就减一本
            Connection conn = BaseDaoImpl.getConn();//连接数据库
            try {
                conn.setAutoCommit(false);
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            //是否更新了借还记录
            boolean res = recordDao.updataRecord(uId, bk.getId(), DateUtil.getDate(), conn);
            if(!res) {
                try {//连接数据库的提交
                    conn.commit();
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {//关闭连接
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                return false;
            }
            res = bookDao.updateBook(bk, conn);//更新数据库的书籍
            if(!res) {
                try {
                    conn.rollback();//数据库的返回
                    conn.commit();//数据库的提交
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {//关闭连接
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                return false;
            } else {
                try {
                    conn.commit();
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                return true;
            }
        }
        //设计一个方法--查询所有书籍--返回所有书籍的属性
        public Object[][] queryAllBooks() {
            List<Book> list = bookDao.queryAllBooks();//将查询出来的书籍存在list
            Object[][] obj = new Object[list.size()][7];//书籍的长度
            int i = 0;
            for (Book book: list) {//遍历所有书籍的属性
                obj[i][0] = book.getHasLended() < book.getCount() ? CAN : CANT;
                obj[i][1] = book.getName();
                obj[i][2] = book.getCount() - book.getHasLended();
                obj[i][3] = book.getType();
                obj[i][4] = book.getAuthor();
                obj[i][5] = book.getDiscount();
                obj[i][6] = book.getAddress();
                i++;
            }
            return obj;
        }
        //设计一个方法--查询书籍
        public Object[][] queryBooks() {
            List<Book> list = bookDao.queryAllBooks();
            Object[][] obj = new Object[list.size()][8];
            int i = 0;
            for (Book book: list) {//循环输出书籍的属性
                obj[i][0] = book.getId();
                obj[i][1] = book.getName();
                obj[i][2] = book.getCount() - book.getHasLended();
                obj[i][3] = book.getType();
                obj[i][4] = book.getAuthor();
                obj[i][5] = book.getDiscount();
                obj[i][6] = book.getAddress();
                obj[i][7] = book.getBookDate();
                i++;
            }
            return obj;
        }
        //增加书籍
        public boolean insertBook(String name, int count, String type,
                                  String author, String address) {
            if (bookDao.searchBook(name).getId() > 0) {//判断书籍的id是否大于0
                return false;
            }
            return bookDao.insertBook(name, count, type, author, address);
        }
}

package service;
import util.ShowMessageUtil;
import dao.AdminDaoImpl;
import dao.UserDaoImpl;
import modle.Admin;
import modle.User;
public class LoginService {//描述登录的业务逻辑
        //属性
        private static LoginService loginService;
        private UserDaoImpl userDao;
        private AdminDaoImpl admDao;
        private RemindService remindService;
        //静态块
        static {
            loginService = new LoginService();
        }
        //获取当前对象方法
        public static LoginService getInstance() {
            return loginService;
        }
        //无参构造方法
        private LoginService() {
            userDao = UserDaoImpl.getInstance();//获取用户数据
            admDao = AdminDaoImpl.getInstance();//获取管理员数据
            remindService = RemindService.getInstance();//获取提醒数据
        }
        //设计一个用户登录的方法
        public User userLogin(int id, String password) {
            User u = userDao.queryUser(id, password);//查询用户信息
            if (u != null) {//判断是否为空
                //通过id提示
                String remind = remindService.getRemindByUid(id);
                if(remind != null && !remind.equals("")) {//判断是否要提示
                    ShowMessageUtil.winMessage("您预约的书" + remind + "需要尽快归还！\n赶紧去看看吧!");
                }
            }
            return u;
        }
        //设计一个方法查找用户数据
        public Admin adminLogin(int id, String password) {
            return admDao.queryAdmin(id, password);
        }
}

package service;
import java.util.List;
import modle.Book;
import dao.RemindDaoImpl;
public class RemindService {//描述提醒用户归还书籍的业务逻辑
        //属性
        public static final String PRE = "《";
        public static final String TAIL = "》";
        public static final String SPACE = "、";
        public static final String SPLIT = ",";
        private static RemindService remindService;
        //静态块
        static {
            remindService = new RemindService();
        }
        //提醒的数据作为属性
        private RemindDaoImpl remindDao;
        //获取提醒类对象
        private RemindService() {
            remindDao = RemindDaoImpl.getInstance();
        }
        //获取提醒业务逻辑的对象
        public static RemindService getInstance() {
            return remindService;
        }
        //设计一个通过id提醒用户的方法
        public String getRemindByUid(int id) {
            //获取书籍
            List<Book> books = remindDao.getRemindByUid(id);
            StringBuilder str = new StringBuilder();
            StringBuilder ids = new StringBuilder();
            if (books.size() > 0) {//判断是否还有书籍
                str.append(PRE).append(books.get(0).getName()).append(TAIL);
                ids.append(books.get(0).getId());
            }
            for(int j = 1; j < books.size(); j++) {
                str.append(SPACE).append(PRE);
                str.append(books.get(j).getName()).append(TAIL);
                ids.append(SPLIT);
                ids.append(books.get(j).getId());
            }
            //判断书籍是否被阅读的状态
            if (ids.length() > 0) {
                remindDao.updateRemindBatch(ids.toString());
            }
            return str.toString();
        }
}

dao类：

package dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import modle.*;

public class AdminDaoImpl {//描述用户的数据类
        //私有的静态属性
        private static AdminDaoImpl adminDaoImpl;
        //静态块--用来创建对象
        static {
            adminDaoImpl = new AdminDaoImpl();
        }
        //无参构造
        private AdminDaoImpl() {}
        //静态方法获取对象
        public static AdminDaoImpl getInstance() {
            return adminDaoImpl;
        }
        //设计一个查找用户的方法--参数要id和密码。返回一个用户对象
        public Admin queryAdmin(int id, String password) {
            //根据id和密码在管理员里面找用户
            String sql = "select * from Administrator where id = ? and password = ?";
            Connection conn = BaseDaoImpl.getConn();//获取连接
            // 创建一个结果集
            ResultSet rs = null;
            Admin admin = null;
            PreparedStatement psts = null;
            try {
                psts = conn.prepareStatement(sql); // 对sql语句进行预处理
                // 简单防sql注入攻击，传入参数
                psts.setObject(1, id);
                psts.setObject(2, password);
                // 执行
                rs = psts.executeQuery();
                while (rs.next()) {//循环判断是否有下一个
                    int return_id = rs.getInt("id");
                    String return_password = rs.getString("password");
                    admin = new Admin(return_id, return_password);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {//关闭
                try {
                        conn.close();
                        psts.close();
                        rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return admin;
        }

}

package dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import modle.Book;

public class BookDaoImpl {//描述书籍的数据
        //属性
        private static BookDaoImpl bookDao;
        //静态的程序块
        static {
            bookDao = new BookDaoImpl();
        }
        //无参构造方法
        private BookDaoImpl() {}
        //获取本类的对象
        public static BookDaoImpl getInstance() {
            return bookDao;
        }

        //设计增加图书的方法--参数是书名，几本，类型，作者，地址。返回值是布尔类型的
        public boolean insertBook(String name, int count, String type,
                                  String author, String address) {
            String sql = "insert into " +
                    "Book(name, count, type, author, discount, hasLended, address)" +
                    "values(?,?,?,?,?,?,?)";
            Connection conn = BaseDaoImpl.getConn();//创建数据库的连接
            PreparedStatement psts = null;

            try {
                //设置列表
                psts = conn.prepareStatement(sql);
                psts.setObject(1, name);
                psts.setObject(2, count);
                psts.setObject(3, type);
                psts.setObject(4, author);
                psts.setObject(5, 0);
                psts.setObject(6, 0);
                psts.setObject(7, address);
                return psts.executeUpdate() > 0;// 执行 ，返回值为int
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {//关闭
                try {
                    conn.close();
                    psts.close();// 关闭预编译
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }

        // 设计一个查询所有书籍的方法
        public List<Book> queryAllBooks() {
            String sql = "select * from Book";
            Connection conn = BaseDaoImpl.getConn();//连接数据库
            ResultSet rs = null;//创建结果集
            List<Book> list = new ArrayList<Book>();//将所有书籍存在arraylist集合里面
            PreparedStatement psts = null;
            try {
                psts = conn.prepareStatement(sql);
                rs = psts.executeQuery(); // 执行
                while (rs.next()) {//循环判断是否有下一个
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    int count = rs.getInt("count");
                    String type = rs.getString("type");
                    String author = rs.getString("author");
                    int discount = rs.getInt("discount");
                    int hasLended = rs.getInt("hasLended");
                    String address = rs.getString("address");
                    String book_date = rs.getString("book_date");
                    Book book = new Book(id, name, count,type,author,discount,hasLended,address,book_date);
                    list.add(book);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {//关闭
                try {
                    conn.close();
                    psts.close();
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return list;
        }

        //设计一个删除书籍的方法--根据书名删除书籍
        public boolean delBook(String name) {
            String sql="delete from Book where name = '" + name + "'";
            Connection conn = BaseDaoImpl.getConn();//连接数据库
            PreparedStatement psts = null;
            try {
                psts = conn.prepareStatement(sql);
                int res = psts.executeUpdate();
                if(res > 0) {
                    return true;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {//关闭连接
                try {
                    conn.close();
                    psts.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }

        //设计一个增加书籍的方法
        public boolean updateBook(Book book, Connection conn) {
            boolean isRelease = false;
            String sql = "update Book set ";
            if (book.getCount() != 0) {
                sql += "count="+book.getCount() + ",";
            }
            if (book.getDiscount() != 0) {
                sql += "discount="+book.getDiscount() + ",";
            }
            if (book.getHasLended() != 0) {
                sql += "hasLended="+book.getHasLended() + ",";
            }
            if (book.getType() != null) {
                sql += "type='"+book.getType() + "',";
            }
            if (book.getAddress() != null) {
                sql += "address='"+book.getAddress() + "' ,";
            }
            if (book.getAuthor() != null) {
                sql += "author='"+book.getAuthor() + "' ,";
            }
            sql = sql.substring(0, sql.length() - 1);
            sql += " where name='" + book.getName() + "'";
            System.out.println(sql);
            if(conn == null) {
                conn = BaseDaoImpl.getConn();
                isRelease = true;
            }
            PreparedStatement psts = null;
            try {
                psts = conn.prepareStatement(sql);
                int res = psts.executeUpdate();
                if(res > 0) return true;
            } catch (SQLException e) {
                e.printStackTrace();
            } finally{
                try {
                    if (isRelease && conn != null) conn.close();
                    if (psts != null) psts.close();//关闭预编译
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }

        //设计一个查找书籍的方法
        public Book searchBook(String name) {
            String sql = "select * from Book where name = '" + name + "'";
            Connection conn = BaseDaoImpl.getConn();
            ResultSet rs = null;
            Book book = new Book();
            PreparedStatement psts = null;
            try {
                psts = conn.prepareStatement(sql);
                rs = psts.executeQuery(); // 执行
                if (rs.next()) {
                    book.setId(rs.getInt("id"));
                    book.setName(rs.getString("name"));
                    book.setCount(rs.getInt("count"));
                    book.setType(rs.getString("type"));
                    book.setAuthor(rs.getString("author"));
                    book.setDiscount(rs.getInt("discount"));
                    book.setHasLended(rs.getInt("hasLended"));
                    book.setAddress(rs.getString("address"));
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    conn.close();
                    psts.close();
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return book;
        }
        //设计一个查找书籍的方法--根据id找书籍--返回一本书
        public Book queryBook(int bId) {
            String sql = "select * from Book where id = " + bId;
            Connection conn = BaseDaoImpl.getConn();//床架连接
            ResultSet rs = null;
            Book book = new Book();
            PreparedStatement psts = null;
            try {
                psts = conn.prepareStatement(sql);
                rs = psts.executeQuery(); // 执行
                book.setId(rs.getInt("id"));
                book.setName(rs.getString("name"));
                book.setCount(rs.getInt("count"));
                book.setType(rs.getString("type"));
                book.setAuthor(rs.getString("author"));
                book.setDiscount(rs.getInt("discount"));
                book.setHasLended(rs.getInt("hasLended"));
                book.setAddress(rs.getString("address"));
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {//关闭
                try {
                    conn.close();
                    psts.close();
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return book;
        }
}

第六部分：完整代码

点击链接即可下载：https://download.csdn.net/download/qq_47471385/85101745

创作挑战赛

新人创作奖励来咯，坚持创作打卡瓜分现金大奖