devbox
代码世界探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java连接数据库实现图书馆管理系统（详细教程）_java连接数据库图书管理系统

作者：代码世界探险家 | 2023-12-27 21:01:19

赞

踩

java连接数据库图书管理系统

该功能用到的软件为 IDEA 、Navicat 、云服务器（非必须）

源码下载

https://www.aliyundrive.com/s/UTz8pNxobGK

一、建立数据库

在自己的服务器或者电脑本机安装数据库系统，本次系统演示的数据库版本为5.6。

1.创建图书管理数据库library 字符集为：utf8 -utf8_general_ci


<code class="language-plaintext hljs">/*
 Navicat Premium Data Transfer

 Source Server         : local
 Source Server Type    : MySQL
 Source Server Version : 50739
 Source Host           : 121.37.205.242:3306
 Source Schema         : library

 Target Server Type    : MySQL
 Target Server Version : 50739
 File Encoding         : 65001

 Date: 31/01/2023 11:23:05
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for amerce
-- ----------------------------
DROP TABLE IF EXISTS `amerce`;
CREATE TABLE `amerce`  (
  `rnumber` char(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '读者编号',
  `rname` varchar(35) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '读者名字',
  `bnumber` int(11) DEFAULT NULL COMMENT '图书编号',
  `bname` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '图书名称',
  `quantity` int(11) DEFAULT 0 COMMENT '数量',
  `bstime` datetime(0) DEFAULT NULL COMMENT '还书和借书时间',
  `money` int(11) DEFAULT NULL COMMENT '罚款金额'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '罚款信息表' ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for books
-- ----------------------------
DROP TABLE IF EXISTS `books`;
CREATE TABLE `books`  (
  `number` int(11) NOT NULL AUTO_INCREMENT COMMENT '图书编号',
  `name` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '图书名称',
  `category` int(11) DEFAULT NULL COMMENT '图书类别',
  `author` varchar(35) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '作者',
  `press` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '出版社',
  `pdate` date DEFAULT NULL COMMENT '出版日期',
  `wdate` datetime(0) DEFAULT NULL COMMENT '入库日期',
  `books` int(11) DEFAULT NULL COMMENT '库存总数量',
  `extant` int(11) DEFAULT 0 COMMENT '现存数量',
  PRIMARY KEY (`number`) USING BTREE,
  UNIQUE INDEX `books_name`(`name`) USING BTREE,
  INDEX `books_category`(`category`) USING BTREE,
  CONSTRAINT `books_category` FOREIGN KEY (`category`) REFERENCES `category` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 214 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '图书信息表' ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for borrow
-- ----------------------------
DROP TABLE IF EXISTS `borrow`;
CREATE TABLE `borrow`  (
  `rnumber` char(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '读者编号',
  `bnumber` int(11) DEFAULT NULL COMMENT '图书编号',
  `quantity` int(11) DEFAULT 1 COMMENT '数量',
  `btime` datetime(0) DEFAULT NULL COMMENT '借书时间'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '借书信息表' ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for category
-- ----------------------------
DROP TABLE IF EXISTS `category`;
CREATE TABLE `category`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '类别ID',
  `name` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '类别名称',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 51 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '图书类别表' ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for reader
-- ----------------------------
DROP TABLE IF EXISTS `reader`;
CREATE TABLE `reader`  (
  `number` char(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '学号',
  `name` varchar(35) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '读者名字',
  `sex` varchar(4) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `kind` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '读者种类',
  `rdate` datetime(0) DEFAULT NULL COMMENT '登记时间',
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`number`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '读者信息表' ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for still
-- ----------------------------
DROP TABLE IF EXISTS `still`;
CREATE TABLE `still`  (
  `rnumber` char(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '读者编号',
  `bnumber` int(11) NOT NULL COMMENT '图书编号',
  `quantity` int(11) DEFAULT 1 COMMENT '数量',
  `stime` datetime(0) DEFAULT NULL COMMENT '还书时间'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '还书信息表' ROW_FORMAT = Compact;

-- ----------------------------
-- View structure for view_aa
-- ----------------------------
DROP VIEW IF EXISTS `view_aa`;
CREATE ALGORITHM = UNDEFINED DEFINER = `root`@`localhost` SQL SECURITY DEFINER VIEW `view_aa` AS select `b`.`rnumber` AS `rnumber`,`r`.`name` AS `rname`,`b`.`bnumber` AS `bnumber`,`bs`.`name` AS `bname`,`b`.`btime` AS `bstime` from ((`borrow` `b` join `books` `bs`) join `reader` `r`) where ((`b`.`rnumber` = `r`.`number`) and (`b`.`bnumber` = `bs`.`number`));

-- ----------------------------
-- Procedure structure for Bookreturn
-- ----------------------------
DROP PROCEDURE IF EXISTS `Bookreturn`;
delimiter ;;
CREATE DEFINER=`root`@`localhost` PROCEDURE `Bookreturn`(in Borrowid char(20),in bookid int ,quant int)
begin
    declare cone int default 0;
    set cone =(select quantity from borrow
    where rnumber =Borrowid and bnumber=bookid and quantity>0
    ORDER BY btime limit 1)-quant;
    
    -- 向还书表插入信息
    INSERT INTO still(rnumber,bnumber,quantity,stime)
    VALUES(Borrowid,bookid,quant,now());
    -- 图书表数量+还书的数量
    update books set extant=extant+quant
    where number=bookid ;
    -- 还书后减去对应的数量
    update borrow set quantity=quantity-quant
    where rnumber =Borrowid and bnumber=bookid
    ORDER BY btime limit 1;    
    -- while循环，如果借书表数值为负数，则循环减去正数的数值
    WHILE cone<0 DO
        set cone=cone+1;
        update borrow set quantity =quantity-1
        where quantity>0 and rnumber =Borrowid and bnumber=bookid
        ORDER BY btime limit 1;
        update borrow set quantity=quantity+1
        WHERE quantity<0 and rnumber =Borrowid and bnumber=bookid
        ORDER BY btime limit 1;
    END WHILE;
    -- 把等于0的数值删除
    delete from borrow 
    where quantity=0;    
end
;;
delimiter ;

-- ----------------------------
-- Procedure structure for Borrowbooks
-- ----------------------------
DROP PROCEDURE IF EXISTS `Borrowbooks`;
delimiter ;;
CREATE DEFINER=`root`@`localhost` PROCEDURE `Borrowbooks`(Borrowid char(20),bookid int ,quant int)
begin
    INSERT INTO borrow(rnumber,bnumber,quantity,btime)
    VALUES(Borrowid,bookid,quant,now());
--     update borrow set quantity=quantity+quant WHERE Borrowid=rnumber and bookid=bnumber;
    update books set extant=extant-quant
    where number=bookid;
end
;;
delimiter ;

-- ----------------------------
-- Procedure structure for Insertbooks
-- ----------------------------
DROP PROCEDURE IF EXISTS `Insertbooks`;
delimiter ;;
CREATE DEFINER=`root`@`localhost` PROCEDURE `Insertbooks`(b varchar(40),c int ,d varchar(35),e varchar(40),f date,h int)
begin
    INSERT INTO books (number,`name`,category,author,press,pdate,wdate,books) 
    VALUES (null,b,c,d,e,f,now(),h) ON DUPLICATE KEY UPDATE books=books+h;
    update books set extant = extant+h where `name`= b;
end
;;
delimiter ;

-- ----------------------------
-- Procedure structure for proc_2
-- ----------------------------
DROP PROCEDURE IF EXISTS `proc_2`;
delimiter ;;
CREATE DEFINER=`root`@`localhost` PROCEDURE `proc_2`()
BEGIN
             drop view if exists view_aa;
             create view view_aa as
             select b.rnumber,r.`name` rname,b.bnumber,bs.`name` bname,b.btime as bstime from borrow b,books bs,reader  r
             where b.rnumber=r.number and b.bnumber=bs.number;

             insert into amerce(rnumber,rname,bnumber,bname,money,bstime)         
             select rnumber,rname,bnumber,bname,count(*) as money,bstime from view_aa;
    end
;;
delimiter ;

-- ----------------------------
-- Procedure structure for repayment
-- ----------------------------
DROP PROCEDURE IF EXISTS `repayment`;
delimiter ;;
CREATE DEFINER=`root`@`%` PROCEDURE `repayment`(rnum char(20),bnum int ,quant int)
begin        
    declare cone int default 0;
        -- 减去对应的数量
    update amerce set quantity=quantity-quant
    where rnumber = rnum and bnumber = bnum
    ORDER BY bstime limit 1;
    -- 把负数赋值给cone
    select quantity into cone from amerce where quantity<0;    
    -- while循环，如果cone为负数，则循环减去正数的数值
    WHILE cone<0 DO
        set cone=cone+1;

        -- 钱数 money-(money/quantity)
         update amerce set money=money-(money/quantity)
        where quantity>0 and rnumber = rnum and bnumber = bnum
        ORDER BY bstime limit 1;
        -- 正数 -1
        update amerce set quantity =quantity-1
        where quantity>0 and rnumber = rnum and bnumber = bnum
        ORDER BY bstime limit 1;
        -- 负数 +1
        update amerce set quantity=quantity+1
        WHERE quantity<0 and rnumber = rnum and bnumber = bnum
        ORDER BY bstime limit 1;
    END WHILE;
    -- 把等于0的数值删除
    delete from amerce where quantity=0;
end
;;
delimiter ;

-- ----------------------------
-- Procedure structure for updateMyTest
-- ----------------------------
DROP PROCEDURE IF EXISTS `updateMyTest`;
delimiter ;;
CREATE DEFINER=`root`@`localhost` PROCEDURE `updateMyTest`(quant int)
BEGIN 
    declare cone int default 0;
    set cone =(select quantity from borrow
    where quantity>0
    ORDER BY btime limit 1)-quant;
    SELECT * from borrow where quantity=cone;
    
--     WHILE cone<0 DO
--         set cone=cone+1;
--         update borrow set quantity =quantity-1
--         where quantity>0
--         ORDER BY btime limit 1;
--         update borrow set quantity=quantity+1
--         WHERE quantity<0
--         ORDER BY btime limit 1;
--     END WHILE;
    
end
;;
delimiter ;

-- ----------------------------
-- Triggers structure for table still
-- ----------------------------
DROP TRIGGER IF EXISTS `trigger_still_amerce`;
delimiter ;;
CREATE DEFINER = `root`@`localhost` TRIGGER `trigger_still_amerce` BEFORE INSERT ON `still` FOR EACH ROW -- 行级触发器
BEGIN
        replace into amerce(rnumber,rname,bnumber,bname,quantity,bstime,money)    
        select borrow.rnumber rnumber,reader.name rname,
        borrow.bnumber bnumber,books.name bname,
        borrow.quantity quantity,reader.rdate bstime,
        0.1*datediff(now(),borrow.btime)-30 money
        from borrow,reader,books
        where borrow.rnumber=reader.number and borrow.bnumber=books.number
        and datediff(now(),borrow.btime)>=30
        and books.number=borrow.bnumber;    
END
;;
delimiter ;

SET FOREIGN_KEY_CHECKS = 1;
</code>

2.设计好将要使用的sql语句

视图、存储过程和触发器，在上面创建数据库的时候建好了，下面是一下视图、存储过程和触发器的创建语句。


<code class="language-plaintext hljs">-- 1、添加图书表书籍 -- 完成
CREATE UNIQUE index books_name on books(name);

delimiter //
create procedure Insertbooks(b varchar(40),c int ,d varchar(35),e varchar(40),f date,h int)
begin
    INSERT INTO books (number,`name`,category,author,press,pdate,wdate,books) 
    VALUES (null,b,c,d,e,f,now(),h) ON DUPLICATE KEY UPDATE books=books+h;
    update books set extant = extant+h where `name`= b;
end; //
delimiter ;

call Insertbooks('白鹿原','1','张三','人民出版社','2022-1-9','7');

-- 2、添加图书类别信息 -- 完成
INSERT INTO category()
VALUES(1,'话剧');

-- 3、添加读者信息 -- 完成
INSERT INTO reader(number,name,sex,kind,rdate)
VALUES('20215101020051','翠花','女','学生',now());

-- 4、读者借书 -- 完成
delimiter //
create procedure Borrowbooks(Borrowid char(20),bookid int ,quant int)
begin
    INSERT INTO borrow(rnumber,bnumber,quantity,btime)
    VALUES(Borrowid,bookid,quant,now());
--     update borrow set quantity=quantity+quant WHERE Borrowid=rnumber and bookid=bnumber;
    update books set extant=extant-quant
    where number=bookid;
end ; //
delimiter ;

Call Borrowbooks('20215101020051','203','50');

-- 5、读者还书 -- 完成
delimiter //
create procedure Bookreturn(in Borrowid char(20),in bookid int ,quant int)
begin
    declare cone int default 0;
    set cone =(select quantity from borrow
    where rnumber =Borrowid and bnumber=bookid and quantity>0
    ORDER BY btime limit 1)-quant;    
    -- 向还书表插入信息
    INSERT INTO still(rnumber,bnumber,quantity,stime)
    VALUES(Borrowid,bookid,quant,now());
    -- 图书表数量+还书的数量
    update books set extant=extant+quant
    where number=bookid ;
    -- 还书后减去对应的数量
    update borrow set quantity=quantity-quant
    where rnumber =Borrowid and bnumber=bookid
    ORDER BY btime limit 1;    
    -- while循环，如果借书表数值为负数，则循环减去正数的数值
    WHILE cone<0 DO
        set cone=cone+1;
        update borrow set quantity =quantity-1
        where quantity>0 and rnumber =Borrowid and bnumber=bookid
        ORDER BY btime limit 1;
        update borrow set quantity=quantity+1
        WHERE quantity<0 and rnumber =Borrowid and bnumber=bookid
        ORDER BY btime limit 1;
    END WHILE;
    -- 把等于0的数值删除
    delete from borrow 
    where quantity=0;    
end ; //
delimiter ;

Call Bookreturn('20215101020051','203','5');
drop procedure Borrowbooks;
drop TRIGGER trigger_still_amerce;

-- 6、读者还书时超过30天罚款 -- 完成
-- 设置还书的时候触发，往罚款表插入数据
delimiter //
CREATE TRIGGER trigger_still_amerce
BEFORE INSERT ON still FOR  EACH  ROW   -- 行级触发器
BEGIN
        replace into amerce(rnumber,rname,bnumber,bname,quantity,bstime,money)    
        select borrow.rnumber rnumber,reader.name rname,
        borrow.bnumber bnumber,books.name bname,
        borrow.quantity quantity,reader.rdate bstime,
        0.1*datediff(now(),borrow.btime)-30 money
        from borrow,reader,books
        where borrow.rnumber=reader.number and borrow.bnumber=books.number
        and datediff(now(),borrow.btime)>=30
        and books.number=borrow.bnumber;    
END; //
delimiter ;
show TRIGGERS;


-- 7、图书废弃 -- 完成
update books set books=books-1,extant=extant-1 where number='202';
-- 8、图书下架 -- 完成
delete from books where number='202';
</code>

3.创建项目

在IEDA中新建一个空项目 library

创建软件包 Module

创建三个类， JavaOK、JavaTest、JDBCUtils 。JavaOK=>运行语句 ， JavaTest=> 存放方法 ， JOBCUtils =>存放方法

4.导入mysql包（必要）

下载包：mysql网站：MySQL :: Download Connector/J

下拉选择Platform Independent

下载mysql-connector-j-8.0.32.tar.gz

点击Download下载

点击No thanks, just start my download.//不登陆下载

解压后就可以看到mysql-connector-j-8.0.32.jar，只有3m大小

或者可以在阿里云盘下载

Java连接数据库实现图书馆...系统（详细教程）阿里云盘分享

在IEDA中导入刚刚下载的包：

文件-项目结构-模块-点击加号-1.JAR或目录-上传刚刚下载的jar包

导包工作完成，接下来可以正式编写代码了

5.测试连接数据库

先来一个简单的测试，看是否能成功连接

  1.  
  2. package com.moyida.linkage;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5.  
  6. public class test {
  7.     public static void main(String[] args) {
  8.         Connection con;
  9. // 
  10.         String url = "jdbc:mysql://localhost:3306/library";
  11.         String user = "root";
  12.         String password = "root";
  13.         try {
  14.             //连接数据库,获得连接对象
  15.             con = DriverManager.getConnection(url, user, password);
  16.             if (!con.isClosed())
  17.                 System.out.println("成功连接数据库");
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.             System.out.println("连接失败");
  21.         }
  22.     }
  23. }

运行栏显示”成功连接数据库“则表示连接成功了

如果显示”连接失败“，则没有连接成功，检查上述的步骤是否遗漏

测试完后可以将代码删除

6.JOBCUtili 页面

里边存入释放资源的方法

  1.  
  2.  //释放资源
  3.     public static void close(Connection connection, Statement statement, ResultSet resultSet) {
  4.         try {
  5.             if (resultSet != null) {
  6.                 resultSet.close();
  7.                 resultSet = null;
  8.             }
  9.             if (statement != null) {
  10.                 statement.close();
  11.                 statement = null;
  12.             }
  13.             if (connection != null) {
  14.                 connection.close();
  15.                 connection = null;
  16.             }
  17.         } catch (SQLException e) {
  18.             e.printStackTrace();
  19.         }
  20.  
  21.     }

7.JavaTest 页面

这里先写好数据库连接方法，修改的时候数据库的时候只要修改一处就好了

ip地址修改成自己的

  1.  
  2.     static final String DB_URL = "jdbc:mysql://localhost:3306/library";
  3.     static final String USER = "root"; //账号
  4.     static final String PASS = "root"; //密码

这里为了省事儿，我把JavaTest页面的所有代码都放到这里

把IP地址和账号密码给成自己的就可以用了，根据方法可以看出连接数据库和执行sql语句的原理，用上面的main方法可以测试这些方法的可行性。

  1.  
  2. package com.moyida.linkage;
  3. import java.lang.constant.Constable;
  4. import java.sql.*;
  5. public class JavaTest {
  6.     public static void main(String[] args) {
  7.         //查询用户信息
  8. //        query_data("20215154515454", "456");
  9.         //查询登录信息
  10. //        System.out.println(UserType("20215154515454", "456"));
  11.         //插入书籍到图书信息表
  12. //        System.out.println("书名，类别，作者，出版社，出版日期，数量");
  13. //        AddBooks("高原", "1", "小儿", "中华出版社", "2022-1-9", "5");
  14.         //添加类别
  15. //        AddCategories(5, "神话类");
  16.         //3、添加读者信息
  17. //        AddReaders("20544545446546", "劳务", "女", "2", "1112222");
  18.         //4、读者借书
  19. //        Call Borrowbooks('20215101020051','203','3');
  20. //        BorrowBooks("20215101020051","203","3");
  21.         //5、读者还书
  22. //        AlsoBook("20215101020051","203","2");
  23.         //-- 7、图书废弃
  24.         //update books set books=books-1,extant=extant-1 where number='202';
  25. //        BooksAbandoned("203");
  26.         //-- 8、图书下架
  27.         //delete from books where number='202';
  28. //        Undercarriage("203");
  29.         //查询图书信息
  30. //        System.out.println(BookInformation("205"));
  31. //        AllBookInformation();
  32.         //欠费查询
  33. //        System.out.println(ArrearageTable("20215101020051", "203"));
  34.         //删除罚款账单
  35. //        repayment("20215154515454","210");
  36.         //查询读者信息表有无该账号
  37. //        System.out.println(ReaderTable("2021510102005"));
  38.          // 打印读者信息
  39. //        PrintReader("20215101024620");
  40.     }
  41.  
  42.     static final String DB_URL = "jdbc:mysql://localhost:3306/library";
  43.     static final String USER = "root";
  44.     static final String PASS = "root";
  45.  
  46.     /**
  47.      * 图书下架
  48.      *
  49.      * @param number
  50.      * @return
  51.      */
  52.     public static boolean Undercarriage(String number) {
  53.         Connection conn = null;
  54.         Statement stmt = null;
  55.         try {
  56.             //连接数据库,获得连接对象
  57.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  58.             //创建执行环境
  59.             stmt = conn.createStatement();
  60.             //执行sql语句，得到结果集 resultSet
  61.             String sql = "delete from books where number='" + number + "'";
  62.             System.out.println(sql);
  63.             int resultSet = stmt.executeUpdate(sql);
  64.         } catch (Exception e) {
  65.             e.printStackTrace();
  66.         }//释放资源
  67.         finally {
  68.             JDBCUtils.close(conn, stmt, null);
  69.         }
  70.         return false;
  71.     }
  72.  
  73.     /**
  74.      * 图书废弃
  75.      *
  76.      * @param number
  77.      * @return
  78.      */
  79.     public static String BooksAbandoned(String number) {
  80.         Connection connection = null;
  81.         Statement statement = null;
  82.         try {
  83.             //连接数据库,获得连接对象
  84.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  85.             //创建执行环境
  86.             statement = connection.createStatement();
  87.             //执行sql语句，得到结果集 resultSet
  88.             String sql = "update books set books=books-1,extant=extant-1 where number='" + number + "'";
  89.             int resultSet = statement.executeUpdate(sql);
  90.         } catch (Exception e) {
  91.             e.printStackTrace();
  92.         }//释放资源
  93.         finally {
  94.             JDBCUtils.close(connection, statement, null);
  95.         }
  96.         return number;
  97.     }
  98.  
  99.  
  100.     /**
  101.      * 读者还书
  102.      *
  103.      * @param rnumber  读者编号
  104.      * @param bnumber  图书编号
  105.      * @param quantity 数量
  106.      */
  107.     static void AlsoBook(String rnumber, String bnumber, String quantity) {
  108.         Connection connection = null;
  109.         Statement statement = null;
  110.         try {
  111.             //连接数据库,获得连接对象
  112.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  113.             //创建执行环境
  114.             statement = connection.createStatement();
  115.             //执行sql语句，得到结果集 resultSet
  116.             String sql = "Call Bookreturn(" + "'" + rnumber + "'" + "," + "'" + bnumber + "'" + "," + "'" + quantity + "'" + ")";
  117.             System.out.println(sql);
  118.             int resultSet = statement.executeUpdate(sql);
  119.         } catch (Exception e) {
  120.             e.printStackTrace();
  121.         }//释放资源
  122.         finally {
  123.             JDBCUtils.close(connection, statement, null);
  124.         }
  125.     }
  126.  
  127.  
  128.     /**
  129.      * 欠费罚款查询
  130.      *
  131.      * @param rnumber
  132.      * @param bnumber
  133.      * @return
  134.      */
  135.     public static String ArrearageTable(String rnumber, String bnumber) {
  136.         Connection connection = null;
  137.         Statement statement = null;
  138.         try {
  139.             //连接数据库,获得连接对象
  140.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  141.             //创建执行环境
  142.             statement = connection.createStatement();
  143.             //执行sql语句，得到结果集 resultSet
  144.             String sql = "SELECT sum(money) as arrearage FROM amerce  WHERE rnumber =" + rnumber + " and bnumber= " + bnumber + " ORDER BY quantity";
  145.             ResultSet resultSet = statement.executeQuery(sql);
  146.             while (resultSet.next()) {
  147.                 String a = resultSet.getString("arrearage");
  148.                 return a;
  149.             }
  150.             // 完成后关闭
  151.             resultSet.close();
  152.             statement.close();
  153.             connection.close();
  154.         } catch (SQLException se) {
  155.             // 处理 JDBC 错误
  156.             se.printStackTrace();
  157.         } catch (Exception e) {
  158.             // 处理 Class.forName 错误
  159.             e.printStackTrace();
  160.         } finally {
  161.             // 关闭资源
  162.             try {
  163.                 if (statement != null) statement.close();
  164.             } catch (SQLException se2) {
  165.             }// 什么都不做
  166.             try {
  167.                 if (connection != null) connection.close();
  168.             } catch (SQLException se) {
  169.                 se.printStackTrace();
  170.             }
  171.         }
  172.         return null;
  173.     }
  174.  
  175.     /**
  176.      * 通过学号打印借书信息表
  177.      *
  178.      * @param rnumber 读者编号
  179.      */
  180.     public static void NumberBookTable(String rnumber) {
  181.         Connection conn = null;
  182.         Statement stmt = null;
  183.         try {
  184.             //连接数据库,获得连接对象
  185.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  186.  
  187.             //创建执行环境
  188.             stmt = conn.createStatement();
  189.             String sql = "SELECT * FROM borrow WHERE rnumber =" + rnumber;
  190.             ResultSet rs = stmt.executeQuery(sql);
  191.             while (rs.next()) {
  192.                 System.out.print(rs.getString("rnumber"));
  193.                 System.out.print("\t ,");
  194.                 System.out.print(rs.getString("bnumber"));
  195.                 System.out.print("\t ,");
  196.                 System.out.print(rs.getString("quantity"));
  197.                 System.out.print("\t ,");
  198.                 System.out.println(rs.getString("btime"));
  199.             }
  200.             // 完成后关闭
  201.             rs.close();
  202.             stmt.close();
  203.             conn.close();
  204.         } catch (SQLException se) {
  205.             // 处理 JDBC 错误
  206.             se.printStackTrace();
  207.         } catch (Exception e) {
  208.             // 处理 Class.forName 错误
  209.             e.printStackTrace();
  210.         } finally {
  211.             // 关闭资源
  212.             try {
  213.                 if (stmt != null) stmt.close();
  214.             } catch (SQLException se2) {
  215.             }// 什么都不做
  216.             try {
  217.                 if (conn != null) conn.close();
  218.             } catch (SQLException se) {
  219.                 se.printStackTrace();
  220.             }
  221.         }
  222.  
  223.     }
  224.  
  225.     /**
  226.      * 打印借书信息表
  227.      *
  228.      * @param rnumber 读者编号
  229.      * @param bnumber 书籍编号
  230.      */
  231.     public static void BookTable(String rnumber, String bnumber) {
  232.         Connection conn = null;
  233.         Statement stmt = null;
  234.         try {
  235.             //连接数据库,获得连接对象
  236.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  237.  
  238.             //创建执行环境
  239.             stmt = conn.createStatement();
  240.             String sql = "SELECT * FROM borrow WHERE rnumber =" + rnumber + " and bnumber= " + bnumber;
  241.             ResultSet rs = stmt.executeQuery(sql);
  242.             while (rs.next()) {
  243.                 System.out.print(rs.getString("rnumber"));
  244.                 System.out.print("\t ,");
  245.                 System.out.print(rs.getString("bnumber"));
  246.                 System.out.print("\t ,");
  247.                 System.out.print(rs.getString("quantity"));
  248.                 System.out.print("\t ,");
  249.                 System.out.println(rs.getString("btime"));
  250.             }
  251.             // 完成后关闭
  252.             rs.close();
  253.             stmt.close();
  254.             conn.close();
  255.         } catch (SQLException se) {
  256.             // 处理 JDBC 错误
  257.             se.printStackTrace();
  258.         } catch (Exception e) {
  259.             // 处理 Class.forName 错误
  260.             e.printStackTrace();
  261.         } finally {
  262.             // 关闭资源
  263.             try {
  264.                 if (stmt != null) stmt.close();
  265.             } catch (SQLException se2) {
  266.             }// 什么都不做
  267.             try {
  268.                 if (conn != null) conn.close();
  269.             } catch (SQLException se) {
  270.                 se.printStackTrace();
  271.             }
  272.         }
  273.     }
  274.  
  275.  
  276.     /**
  277.      * 删除罚款账单
  278.      *
  279.      * @param rnumber
  280.      * @param bnumber
  281.      */
  282.     //delete amerce WHERE rnumber='20215154515454' and bnumber='210'
  283.     public static void repayment(String rnumber, String bnumber) {
  284.         Connection connection = null;
  285.         Statement statement = null;
  286.         try {
  287.             //连接数据库,获得连接对象
  288.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  289.             //创建执行环境
  290.             statement = connection.createStatement();
  291.             //执行sql语句，得到结果集 resultSet
  292.             String sql = "delete from amerce WHERE rnumber=" + rnumber + " and bnumber=" + bnumber;
  293.             int resultSet = statement.executeUpdate(sql);
  294.         } catch (Exception e) {
  295.             e.printStackTrace();
  296.         }//释放资源
  297.         finally {
  298.             JDBCUtils.close(connection, statement, null);
  299.         }
  300.  
  301.     }
  302.  
  303.     /**
  304.      * 读者借书
  305.      *
  306.      * @param rnumber 读者编号
  307.      */
  308.     public static void BorrowBooks(String rnumber, String bnumber, String quantity) {
  309.         Connection connection = null;
  310.         Statement statement = null;
  311.         try {
  312.             //连接数据库,获得连接对象
  313.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  314.             //创建执行环境
  315.             statement = connection.createStatement();
  316.             //执行sql语句，得到结果集 resultSet
  317.             String sql = "Call Borrowbooks(" + "'" + rnumber + "'" + "," + "'" + bnumber + "'" + "," + "'" + quantity + "'" + ")";
  318.             System.out.println(sql);
  319.             int resultSet = statement.executeUpdate(sql);
  320.         } catch (Exception e) {
  321.             e.printStackTrace();
  322.         }//释放资源
  323.         finally {
  324.             JDBCUtils.close(connection, statement, null);
  325.         }
  326.  
  327.     }
  328.  
  329.     /**
  330.      * 添加读者信息（注册）
  331.      *
  332.      * @param number
  333.      * @param name
  334.      * @param sex
  335.      * @param kind
  336.      * @param password
  337.      */
  338.     public static void AddReaders(String number, String name, String sex, String kind, String password) {
  339.         Connection connection = null;
  340.         Statement statement = null;
  341.         try {
  342.             //连接数据库,获得连接对象
  343.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  344.             //创建执行环境
  345.             statement = connection.createStatement();
  346.             //执行sql语句，得到结果集 resultSet
  347.             //      // INSERT INTO reader(number,name,sex,kind,rdate) VALUES('20215101020051','翠花','女','学生',now(),password);
  348.             String sql = "INSERT INTO reader VALUES(" + "'" + number + "'" + "," + "'" + name + "'" + "," + "'" + sex + "'" + "," + "'" + kind + "'" + "," + "now()" + "," + "'" + password + "'" + ")";
  349.             int resultSet = statement.executeUpdate(sql);
  350.         } catch (Exception e) {
  351.             e.printStackTrace();
  352.         }//释放资源
  353.         finally {
  354.             JDBCUtils.close(connection, statement, null);
  355.         }
  356.     }
  357.  
  358.     /**
  359.      * 2、添加图书类别信息
  360.      *
  361.      * @param id
  362.      * @param name
  363.      * @return
  364.      */
  365.     public static String AddCategories(int id, String name) {
  366.         Connection connection = null;
  367.         Statement statement = null;
  368.         ResultSet resultSet = null;
  369.         try {
  370.             //连接数据库,获得连接对象
  371.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  372.             //创建执行环境
  373.             statement = connection.createStatement();
  374.             //执行sql语句，得到结果集 resultSet
  375.             String sql = "INSERT INTO category() VALUES(" + id + "," + "'" + name + "'" + ")";
  376.             resultSet = statement.executeQuery(sql);
  377. //            int resultSet = statement.executeUpdate(sql);
  378.             // 完成后关闭
  379.             resultSet.close();
  380.             statement.close();
  381.             connection.close();
  382.         } catch (Exception e) {
  383.             e.printStackTrace();
  384.         }//释放资源
  385.         finally {
  386.             JDBCUtils.close(connection, statement, resultSet);
  387.         }
  388.         return name;
  389.     }
  390.  
  391.     /**
  392.      * 添加书籍到图书信息表
  393.      *
  394.      * @param name     图书名称
  395.      * @param category 图书类别
  396.      * @param author   作者
  397.      * @param press    出版社
  398.      * @param pdate    出版日期
  399.      * @param quantity 要存的数量
  400.      * @return
  401.      */
  402.     public static String AddBooks(String name, String category, String author, String press, String pdate, String quantity) {
  403.         Connection connection = null;
  404.         ResultSet resultSet = null;
  405.         Statement statement = null;
  406.         try {
  407.             //连接数据库,获得连接对象
  408.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  409.             //创建执行环境
  410.             statement = connection.createStatement();
  411.             //执行sql语句，得到结果集 resultSet
  412.             String sql = "call Insertbooks(" + "'" + name + "'" + "," + "'" + category + "'" + "," + "'" + author + "'" + "," + "'" + press + "'" + "," + "'" + pdate + "'" + "," + "'" + quantity + "'" + ")";
  413.             resultSet = statement.executeQuery(sql);
  414.             // 完成后关闭
  415.             resultSet.close();
  416.             statement.close();
  417.             connection.close();
  418.         } catch (Exception e) {
  419.             //错误处理
  420.             e.printStackTrace();
  421.         }//释放资源
  422.         finally {
  423.             JDBCUtils.close(connection, statement, resultSet);
  424.         }
  425.  
  426.         return name;
  427.     }
  428.  
  429.     /**
  430.      * 查询所有图书信息
  431.      *
  432.      * @return 返回值
  433.      */
  434.     public static void AllBookInformation() {
  435.         Connection conn = null;
  436.         Statement stmt = null;
  437.         try {
  438.             //连接数据库,获得连接对象
  439.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  440.             //创建执行环境
  441.             stmt = conn.createStatement();
  442.  
  443.             String sql = "SELECT * FROM books";
  444.             ResultSet rs = stmt.executeQuery(sql);
  445.             System.out.println("图书编号  图书名称 图书类别 作者 出版社 出版日期 入库日期 库存总数量 现存数量");
  446.             while (rs.next()) {
  447.                 System.out.print(rs.getString("number") + "\t");
  448.                 System.out.print(rs.getString("name") + "\t");
  449.                 System.out.print(rs.getString("category") + "\t");
  450.                 System.out.print(rs.getString("author") + "\t");
  451.                 System.out.print(rs.getString("press") + "\t");
  452.                 System.out.print(rs.getString("pdate") + "\t");
  453.                 System.out.print(rs.getString("wdate") + "\t");
  454.                 System.out.print(rs.getString("books") + "\t");
  455.                 System.out.println(rs.getString("extant"));
  456.             }
  457.             // 完成后关闭
  458.             rs.close();
  459.             stmt.close();
  460.             conn.close();
  461.         } catch (SQLException se) {
  462.             // 处理 JDBC 错误
  463.             se.printStackTrace();
  464.         } catch (Exception e) {
  465.             // 处理 Class.forName 错误
  466.             e.printStackTrace();
  467.         } finally {
  468.             // 关闭资源
  469.             try {
  470.                 if (stmt != null) stmt.close();
  471.             } catch (SQLException se2) {
  472.             }// 什么都不做
  473.             try {
  474.                 if (conn != null) conn.close();
  475.             } catch (SQLException se) {
  476.                 se.printStackTrace();
  477.             }
  478.         }
  479.     }
  480.     /**
  481.      * 打印读者信息
  482.      */
  483.     public static void PrintReader(String number){
  484.         Connection conn = null;
  485.         Statement stmt = null;
  486.         try {
  487.             //连接数据库,获得连接对象
  488.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  489.             //创建执行环境
  490.             stmt = conn.createStatement();
  491.             String sql = "SELECT * FROM reader WHERE number =" + number;
  492.             ResultSet rs = stmt.executeQuery(sql);
  493.             while (rs.next()) {
  494.                 System.out.print(rs.getString("number")+"\t");
  495.                 System.out.print(rs.getString("name")+"\t");
  496.                 System.out.print(rs.getString("sex")+"\t");
  497.                 System.out.print(rs.getString("kind")+"\t");
  498.                 System.out.print(rs.getString("rdate")+"\t");
  499.                 System.out.println(rs.getString("password"));
  500.             }
  501.             // 完成后关闭
  502.             rs.close();
  503.             stmt.close();
  504.             conn.close();
  505.         } catch (SQLException se) {
  506.             // 处理 JDBC 错误
  507.             se.printStackTrace();
  508.         } catch (Exception e) {
  509.             // 处理 Class.forName 错误
  510.             e.printStackTrace();
  511.         } finally {
  512.             // 关闭资源
  513.             try {
  514.                 if (stmt != null) stmt.close();
  515.             } catch (SQLException se2) {
  516.             }// 什么都不做
  517.             try {
  518.                 if (conn != null) conn.close();
  519.             } catch (SQLException se) {
  520.                 se.printStackTrace();
  521.             }
  522.         }
  523.  
  524.     }
  525.  
  526.     /**
  527.      * 查询读者信息表有无该账号
  528.      *
  529.      * @return
  530.      */
  531.     public static Constable ReaderTable(String number) {
  532.         Connection conn = null;
  533.         Statement stmt = null;
  534.         try {
  535.             //连接数据库,获得连接对象
  536.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  537.             //创建执行环境
  538.             stmt = conn.createStatement();
  539.             String sql = "select number from reader where number=" + number;
  540.             ResultSet rs = stmt.executeQuery(sql);
  541.             if (rs.next()) {
  542.                 return false;
  543.             }
  544.             // 完成后关闭
  545.             rs.close();
  546.             stmt.close();
  547.             conn.close();
  548.         } catch (SQLException se) {
  549.             // 处理 JDBC 错误
  550.             se.printStackTrace();
  551.         } catch (Exception e) {
  552.             // 处理 Class.forName 错误
  553.             e.printStackTrace();
  554.         } finally {
  555.             // 关闭资源
  556.             try {
  557.                 if (stmt != null) stmt.close();
  558.             } catch (SQLException se2) {
  559.             }// 什么都不做
  560.             try {
  561.                 if (conn != null) conn.close();
  562.             } catch (SQLException se) {
  563.                 se.printStackTrace();
  564.             }
  565.         }
  566.         return null;
  567.     }
  568.  
  569.     /**
  570.      * 查询图书信息
  571.      *
  572.      * @param number 输入的密码
  573.      * @return 返回值
  574.      */
  575.     public static String BookInformation(String number) {
  576.         Connection conn = null;
  577.         Statement stmt = null;
  578.         try {
  579.             //连接数据库,获得连接对象
  580.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  581.             //创建执行环境
  582.             stmt = conn.createStatement();
  583.             String sql = "SELECT * FROM books WHERE number =" + number;
  584.             ResultSet rs = stmt.executeQuery(sql);
  585.             while (rs.next()) {
  586.                 String a = rs.getString("number");
  587.                 String a1 = ("\t");
  588.                 String b = rs.getString("name");
  589.                 String b1 = ("\t");
  590.                 String c = rs.getString("category");
  591.                 String c1 = ("\t");
  592.                 String d = rs.getString("author");
  593.                 String d1 = ("\t");
  594.                 String e = rs.getString("press");
  595.                 String e1 = ("\t");
  596.                 String f = rs.getString("pdate");
  597.                 String f1 = ("\t");
  598.                 String g = rs.getString("wdate");
  599.                 String g1 = ("\t");
  600.                 String h = rs.getString("books");
  601.                 String h1 = ("\t");
  602.                 String i = rs.getString("extant");
  603.                 return a + a1 + b + b1 + c + c1 + d + d1 + e + e1 + f + f1 + g + g1 + h + h1 + i;
  604.             }
  605.             // 完成后关闭
  606.             rs.close();
  607.             stmt.close();
  608.             conn.close();
  609.         } catch (SQLException se) {
  610.             // 处理 JDBC 错误
  611.             se.printStackTrace();
  612.         } catch (Exception e) {
  613.             // 处理 Class.forName 错误
  614.             e.printStackTrace();
  615.         } finally {
  616.             // 关闭资源
  617.             try {
  618.                 if (stmt != null) stmt.close();
  619.             } catch (SQLException se2) {
  620.             }// 什么都不做
  621.             try {
  622.                 if (conn != null) conn.close();
  623.             } catch (SQLException se) {
  624.                 se.printStackTrace();
  625.             }
  626.         }
  627.         return null;
  628.     }
  629.  
  630.     /**
  631.      * 查询学生表信息
  632.      *
  633.      * @param number   输入的账号
  634.      * @param password 输入的密码
  635.      * @return 返回值
  636.      */
  637.     public static void query_data(String number, String password) {
  638.         Connection conn = null;
  639.         Statement stmt = null;
  640.         try {
  641.             //连接数据库,获得连接对象
  642.             conn = DriverManager.getConnection(DB_URL, USER, PASS);
  643.  
  644.             //创建执行环境
  645.             stmt = conn.createStatement();
  646.             String sql = "select * from reader where number= " + "'" + number + "'" + " and password=" + "'" + password + "'";
  647.             ResultSet rs = stmt.executeQuery(sql);
  648.             while (rs.next()) {
  649.                 String a = rs.getString("number");
  650.                 String a1 = ("\t");
  651.                 String b = rs.getString("name");
  652.                 String b1 = ("\t");
  653.                 String c = rs.getString("sex");
  654.                 String c1 = ("\t");
  655.                 String d = rs.getString("kind");
  656.                 String d1 = ("\t");
  657.                 String e = rs.getString("rdate");
  658.                 String e1 = ("\t");
  659.                 String f = rs.getString("password");
  660.                 System.out.println(a + a1 + b + b1 + c + c1 + d + e + d1 + f);
  661.             }
  662.             // 完成后关闭
  663.             rs.close();
  664.             stmt.close();
  665.             conn.close();
  666.         } catch (SQLException se) {
  667.             // 处理 JDBC 错误
  668.             se.printStackTrace();
  669.         } catch (Exception e) {
  670.             // 处理 Class.forName 错误
  671.             e.printStackTrace();
  672.         } finally {
  673.             // 关闭资源
  674.             try {
  675.                 if (stmt != null) stmt.close();
  676.             } catch (SQLException se2) {
  677.             }// 什么都不做
  678.             try {
  679.                 if (conn != null) conn.close();
  680.             } catch (SQLException se) {
  681.                 se.printStackTrace();
  682.             }
  683.         }
  684.     }
  685.  
  686.     /**
  687.      * 判断用户类型，登录账号，返回1表示老师，返回2表示学生，返回null表示查无此人
  688.      *
  689.      * @param number 输入的学号
  690.      * @return 返回值
  691.      */
  692.     public static String UserType(String number, String password) {
  693.         Connection connection = null;
  694.         Statement statement = null;
  695.         try {
  696.             //连接数据库,获得连接对象
  697.             connection = DriverManager.getConnection(DB_URL, USER, PASS);
  698.             //创建执行环境
  699.             statement = connection.createStatement();
  700.             //执行sql语句，得到结果集 resultSet
  701.             String sql = "select kind from reader where number= " + "'" + number + "'" + " and password=" + "'" + password + "'";
  702.             ResultSet resultSet = statement.executeQuery(sql);
  703.             while (resultSet.next()) {
  704.                 String a = resultSet.getString("kind");
  705.                 return a;
  706.             }
  707.             // 完成后关闭
  708.             resultSet.close();
  709.             statement.close();
  710.             connection.close();
  711.         } catch (SQLException se) {
  712.             // 处理 JDBC 错误
  713.             se.printStackTrace();
  714.         } catch (Exception e) {
  715.             // 处理 Class.forName 错误
  716.             e.printStackTrace();
  717.         } finally {
  718.             // 关闭资源
  719.             try {
  720.                 if (statement != null) statement.close();
  721.             } catch (SQLException se2) {
  722.             }// 什么都不做
  723.             try {
  724.                 if (connection != null) connection.close();
  725.             } catch (SQLException se) {
  726.                 se.printStackTrace();
  727.             }
  728.         }
  729.         return null;//这样可以使得调用方无需检查结果是否为null
  730.     }
  731. }

8.JavaOK 页面

JavaOK是运行调用JavaTest和JOBCUtili方法的主页面，在这个类运行可以实现系统的管理，这个系统仍有不少的bug没修复，但是可以正常跑起来了，可以根据自己的理解，把代码经行完善和修复

下面是JavaOK页面的代码

  1.  
  2. package com.moyida.linkage;
  3. import java.lang.constant.Constable;
  4. import java.util.Scanner;
  5.  
  6. public class JavaOk {
  7.     public static void main(String[] args) {
  8.         Scanner sc = new Scanner(System.in);
  9.         while (true) {
  10.             System.out.println("=============首页==============");
  11.             System.out.println("1、登录");
  12.             System.out.println("2、注册");
  13.             int reg = sc.nextInt();
  14.             switch (reg) {
  15.                 case 1:
  16.                     //登录
  17.                     while (true) {
  18.                         System.out.println("=============登陆页面==============");
  19.                         System.out.println("请您输入账号");
  20.                         String acc = sc.next();
  21.                         System.out.println("请您输入密码");
  22.                         String pass = sc.next();
  23.                         String sum = JavaTest.UserType(acc, pass);
  24.                         if (sum == null) {
  25.                             System.out.println("对不起，查无此人,请重新输入");
  26.                             break;
  27.                         }
  28. //                        int a = Integer.parseInt(sum);
  29. //                        String a=sum;
  30.                         //判断用户类型，登录账号，返回1表示老师，返回2表示学生，返回null表示查无此人
  31.                         System.out.println("返回的数据是" + sum);
  32.                         switch (sum) {
  33.                             case "1":
  34.                                 System.out.println("欢迎管理员登录");
  35.                                 conservator(sc);
  36.                                 break;
  37.                             case "2":
  38.                                 System.out.println("欢迎学生登录");
  39.                                 operate(sc, acc);
  40.                                 break;
  41.                             default:
  42.                                 System.out.println("对不起，查无此人");
  43.                                 break;
  44.                         }
  45.                         break;
  46.                     }
  47.                 case 2:
  48.                     //注册
  49.                     Register(sc);
  50.                     break;
  51.                 default:
  52.                     System.out.println("您输入的命令错误，请重新输入！");
  53.                     break;
  54.             }
  55.         }
  56.     }
  57.  
  58.     /**
  59.      * 注册
  60.      *
  61.      * @param sc
  62.      */
  63.     private static void Register(Scanner sc) {
  64.         System.out.println("=============注册页面==============");
  65.         System.out.println("请输入要注册的账号（学号）");
  66.         String number = sc.next();
  67.         //查询数据库中有无该账号
  68.         Constable aaa = JavaTest.ReaderTable(number);
  69.         if (aaa == null) {
  70.             //没有账号，可以进行
  71.             System.out.println("请输入您的名字");
  72.             String name = sc.next();
  73.             System.out.println("请输入您的性别");
  74.             String sex = sc.next();
  75.             System.out.println("请输入您的类型  学生 2/管理员 1");
  76.             int kind = sc.nextInt();
  77.             System.out.println("请输入您的登录密码：");
  78.             String pass = sc.next();
  79.             //调用注册方法
  80.             JavaTest.AddReaders(number, name, sex, String.valueOf(kind), pass);
  81.             System.out.println("注册成功！");
  82.             //打印注册信息
  83.             System.out.println("您的注册信息如下：");
  84.             JavaTest.PrintReader(number);
  85.         }else {
  86.             System.out.println("该账号已注册!");
  87.         }
  88.  
  89.     }
  90.  
  91.     /**
  92.      * 管理员操作页面
  93.      *
  94.      * @param sc
  95.      */
  96.     private static void conservator(Scanner sc) {
  97.         while (true) {
  98.             System.out.println("=============操作页面==============");
  99.             System.out.println("0、退出");
  100.             System.out.println("1、添加图书表书籍");
  101.             System.out.println("2、添加图书类别信息");
  102.             System.out.println("3、图书废弃");
  103.             System.out.println("4、图书下架");
  104.             System.out.println("5、查询全部图书信息");
  105.             int i = sc.nextInt();
  106.             switch (i) {
  107.                 case 0:
  108.                     System.out.println("已退出账号，欢迎再次登录！");
  109.                     return;
  110.                 case 1:
  111.                     System.out.println("=============添加书籍页面==============");
  112.                     System.out.println("图书名称");
  113.                     String name = sc.next();
  114.                     System.out.println("图书类别");
  115.                     String category = sc.next();
  116.                     System.out.println("作者");
  117.                     String author = sc.next();
  118.                     System.out.println("出版社");
  119.                     String press = sc.next();
  120.                     System.out.println("出版日期");
  121.                     String pdate = sc.next();
  122.                     System.out.println("要存的数量");
  123.                     String quantity = sc.next();
  124.                     String charu = JavaTest.AddBooks(name, category, author, press, pdate, quantity);
  125.                     System.out.println("添加成功");
  126.                     break;
  127.                 case 2:
  128.                     System.out.println("=============添加图书类别页面==============");
  129.                     System.out.println("输入类别编号");
  130.                     int leibie = sc.nextInt();
  131.                     System.out.println("输入类别名称");
  132.                     String name1 = sc.next();
  133.                     JavaTest.AddCategories(leibie, name1);
  134.                     System.out.println("添加成功");
  135.                     break;
  136.                 case 3:
  137.                     System.out.println("=============图书废弃页面==============");
  138.                     System.out.println("请输入要废弃图书的图书编号");
  139.                     String reduce = sc.next();
  140.                     System.out.println("您要废除的书籍是：");
  141.                     System.out.println(JavaTest.BookInformation(reduce));
  142.                     System.out.println("是否确认废除y/n");
  143.                     String rs = sc.next();
  144.                     switch (rs) {
  145.                         case "y":
  146.                             //可以废除
  147.                             String ff = JavaTest.BooksAbandoned(reduce);
  148.                             System.out.println(JavaTest.BookInformation(reduce));
  149.                             System.out.println("废弃成功，该图书减一");
  150.                             break;
  151.                         default:
  152.                             System.out.println("您取消废除，当前书籍继续保留~");
  153.                     }
  154.  
  155.                     break;
  156.                 case 4:
  157.                     System.out.println("=============图书下架页面==============");
  158.                     System.out.println("请输入要下架图书的图书编号");
  159.                     String reduce1 = sc.next();
  160.                     System.out.println("您要下架的书籍是：");
  161.                     System.out.println(JavaTest.BookInformation(reduce1));
  162.                     System.out.println("是否确认把该图书下架y/n");
  163.                     String rs1 = sc.next();
  164.                     switch (rs1) {
  165.                         case "y":
  166.                             //可以废除
  167.                             String ff = JavaTest.BooksAbandoned(reduce1);
  168.                             System.out.println(JavaTest.Undercarriage(reduce1));
  169.                             System.out.println("下架成功，图书已从图书系统中去除");
  170.                             break;
  171.                         default:
  172.                             System.out.println("您取消废除，当前书籍继续保留~");
  173.                     }
  174.                     break;
  175.                 case 5:
  176.                     //查看所有书籍
  177.                     JavaTest.AllBookInformation();
  178.                     break;
  179.                 default:
  180.                     System.out.println("输入错误！");
  181.                     break;
  182.             }
  183.         }
  184.     }
  185.  
  186.     /**
  187.      * 学生操作页面
  188.      *
  189.      * @param sc
  190.      */
  191.     private static void operate(Scanner sc, String acc) {
  192.         while (true) {
  193.             System.out.println("=============学生操作页面==============");
  194.             System.out.println("0、退出");
  195.             System.out.println("1、查看所有书籍");
  196.             System.out.println("2、借书");
  197.             System.out.println("3、还书");
  198.             String student = sc.next();
  199.             switch (student) {
  200.                 case "0":
  201.                     System.out.println("已退出账号，欢迎再次登录！");
  202.                     return;
  203.                 case "1":
  204.                     //查看所有书籍
  205.                     JavaTest.AllBookInformation();
  206.                     break;
  207.                 case "2":
  208.                     //借书
  209.                     //                public static boolean BorrowBooks(String rnumber, String bnumber, String quantity) {
  210.                     System.out.println("请输入要借的书籍编号");
  211.                     String Borrow = sc.next();
  212.                     System.out.println("您要借的书籍是：");
  213.                     System.out.println(JavaTest.BookInformation(Borrow));
  214.                     System.out.println("是否借该图书？y/n");
  215.                     String rs1 = sc.next();
  216.                     switch (rs1) {
  217.                         case "y":
  218.                             //可以借书
  219.                             System.out.println("您要借几本书？");
  220.                             String books = sc.next();
  221.                             JavaTest.BorrowBooks(acc, Borrow, books);
  222.                             System.out.println("借书完成，您的借书信息如下");
  223.                             //打印借书信息
  224.                             JavaTest.BookTable(acc, Borrow);
  225.                             System.out.println("");
  226.                             break;
  227.                         default:
  228.                             System.out.println("您取消借书操作，欢迎再次使用！");
  229.                     }
  230.                     break;
  231.                 case "3":
  232.                     //还书
  233.                     System.out.println("您可以还的书籍如下");
  234.                     JavaTest.NumberBookTable(acc);
  235.                     System.out.println("");
  236.                     System.out.println("请输入要还的书籍编号");
  237.                     String AlsoBook = sc.next();
  238.                     System.out.println("您要还的书籍是：");
  239.                     //打印借书信息
  240.                     JavaTest.BookTable(acc, AlsoBook);
  241.                     //再次确定归还
  242.                     System.out.println("是否还该图书？y/n");
  243.                     String rs2 = sc.next();
  244.                     switch (rs2) {
  245.                         case "y":
  246.                             //可以还书
  247.                             System.out.println("您要还此编号的几本书？");
  248.                             String books = sc.next();
  249.                             // 还书
  250.                             JavaTest.AlsoBook(acc, AlsoBook, books);
  251.                             //查询欠费账单有没有欠费
  252.                             String bill = JavaTest.ArrearageTable(acc, AlsoBook);
  253.                             if (bill == null) {
  254.                                 //可以了
  255.                                 System.out.println("还书完成，您还有此类书籍尚为归还");
  256.                                 //打印借书信息
  257.                                 JavaTest.BookTable(acc, AlsoBook);
  258.                                 break;
  259.                             } else {
  260.                                 //钱没还
  261.                                 while (true) {
  262.                                     System.out.println("您欠费的金额是" + bill);
  263.                                     System.out.println("如已支付，请输入内容：支付完成");
  264.                                     String ff = sc.next();
  265.                                     String dd = "支付完成";
  266.                                     if (ff.equals(dd)) {
  267.                                         //删除欠费账单
  268.                                         JavaTest.repayment(acc, AlsoBook);
  269.                                         //打印借书信息
  270.                                         System.out.println("还书完成，您还有此类书籍尚为归还");
  271.                                         //打印借书信息
  272.                                         JavaTest.BookTable(acc, AlsoBook);
  273.                                         break;
  274.                                     } else {
  275.                                         System.out.println("支付失败，请完成支付");
  276.                                     }
  277.                                 }
  278.                             }
  279.                     }
  280.             }
  281.         }
  282.  
  283.     }
  284. }

9.运行

在IEDA的JavaOK页面，右键点击运行，就可以使用了。

10.资料

我在阿里云盘中存有该系统程序的源代码，可提供下载学习使用。

阿里网盘 链接

Java连接数据库实现图书馆...系统（详细教程）阿里云盘分享

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/36200
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号