devbox
代码世界探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
  • 1Android之Adapter用法总结_android setadapter
  • 2报错" href="/blog/article/detail/82574" target="_blank">vue使用scss方法(报错解决方案),及变换主题色_
    当前位置:   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/blog/article/detail/36200
    推荐阅读
    相关标签

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