devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA图书管理系统完整代码实现（连接MYSQL数据库）_java图书管理系统数据的关联

作者：我家自动化 | 2024-06-22 22:12:47

赞

踩

java图书管理系统数据的关联

1.系统功能

本系统是控制台版java图书管理系统，实现了用户的注册登录，用户管理员的登录，图书管理员的登录，用户可以购买图书和查看图书购买记录，用户管理员可以对用户信息进行增删查改，图书管理员可以查看图书信息，以及上架新的图书和修改图书库存。

本系统中存在的已知bug已解决，如遇到到其它bug请在评论区留言告知。

2.系统简要演示

3.数据库表的创建

新建数据库lib_dtb，然后在桌面建立lib_dtb.sql文件，写入以下sq语句，然后点击lib_dtb数据库中的表右键运行该sql文件，数据库表即导入成功，数据库成功创建。

  1. /*
  2.  Navicat Premium Data Transfer
  4.  Source Server         : MySql
  5.  Source Server Type    : MySQL
  6.  Source Server Version : 80036
  7.  Source Host           : localhost:3306
  8.  Source Schema         : lib_dtb
  10.  Target Server Type    : MySQL
  11.  Target Server Version : 80036
  12.  File Encoding         : 65001
  14.  Date: 17/05/2024 23:00:29
  15. */
  16.  
  17. SET NAMES utf8mb4;
  18. SET FOREIGN_KEY_CHECKS = 0;
  19.  
  20. -- ----------------------------
  21. -- Table structure for admin
  22. -- ----------------------------
  23. DROP TABLE IF EXISTS `admin`;
  24. CREATE TABLE `admin`  (
  25.   `id` int UNSIGNED NOT NULL AUTO_INCREMENT,
  26.   `username` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  27.   `password` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  28.   PRIMARY KEY (`id`) USING BTREE,
  29.   UNIQUE INDEX `username`(`username` ASC) USING BTREE
  30. ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '管理员' ROW_FORMAT = Dynamic;
  31.  
  32. -- ----------------------------
  33. -- Records of admin
  34. -- ----------------------------
  35. INSERT INTO `admin` VALUES (1, 'admin', '123456');
  36.  
  37. -- ----------------------------
  38. -- Table structure for buy_table
  39. -- ----------------------------
  40. DROP TABLE IF EXISTS `buy_table`;
  41. CREATE TABLE `buy_table`  (
  42.   `name` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '用户姓名',
  43.   `library` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '图书名字',
  44.   `buy_time` datetime NOT NULL COMMENT '购买时间'
  45. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '用户购买图书记录表' ROW_FORMAT = Dynamic;
  46.  
  47. -- ----------------------------
  48. -- Records of buy_table
  49. -- ----------------------------
  50. INSERT INTO `buy_table` VALUES ('zs', '平凡世界', '2024-04-15 22:20:02');
  51. INSERT INTO `buy_table` VALUES ('zs', '平凡世界', '2024-04-16 23:25:57');
  52. INSERT INTO `buy_table` VALUES ('zs', '平凡世界', '2024-04-18 18:24:22');
  53.  
  54. -- ----------------------------
  55. -- Table structure for libadmin
  56. -- ----------------------------
  57. DROP TABLE IF EXISTS `libadmin`;
  58. CREATE TABLE `libadmin`  (
  59.   `id` int UNSIGNED NOT NULL AUTO_INCREMENT,
  60.   `username` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  61.   `password` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  62.   PRIMARY KEY (`id`) USING BTREE
  63. ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '图书管理员' ROW_FORMAT = Dynamic;
  64.  
  65. -- ----------------------------
  66. -- Records of libadmin
  67. -- ----------------------------
  68. INSERT INTO `libadmin` VALUES (1, 'admin', '654321');
  69.  
  70. -- ----------------------------
  71. -- Table structure for library
  72. -- ----------------------------
  73. DROP TABLE IF EXISTS `library`;
  74. CREATE TABLE `library`  (
  75.   `id` int UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键id',
  76.   `name` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '图书名字',
  77.   `author` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '作者',
  78.   `price` decimal(5, 2) NOT NULL COMMENT '图书价格，可以保留两位小数，总共5位',
  79.   `count` int UNSIGNED NOT NULL COMMENT '图书数量',
  80.   `Shelf_time` datetime NOT NULL,
  81.   PRIMARY KEY (`id`) USING BTREE
  82. ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '图书表' ROW_FORMAT = Dynamic;
  83.  
  84. -- ----------------------------
  85. -- Records of library
  86. -- ----------------------------
  87. INSERT INTO `library` VALUES (1, '平凡世界', '路遥', 46.00, 0, '2024-04-15 22:02:59');
  88.  
  89. -- ----------------------------
  90. -- Table structure for user
  91. -- ----------------------------
  92. DROP TABLE IF EXISTS `user`;
  93. CREATE TABLE `user`  (
  94.   `id` int UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键id',
  95.   `username` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '用户名，唯一',
  96.   `password` varchar(15) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '密码',
  97.   PRIMARY KEY (`id`) USING BTREE,
  98.   UNIQUE INDEX `username`(`username` ASC) USING BTREE
  99. ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;
  100.  
  101. -- ----------------------------
  102. -- Records of user
  103. -- ----------------------------
  104. INSERT INTO `user` VALUES (1, 'zs', '20021015');
  105. INSERT INTO `user` VALUES (2, 'lisi', '111');
  106.  
  107. SET FOREIGN_KEY_CHECKS = 1;

4.建立数据库连接

导入jar包，首先建立一个lib文件夹，然后将jar包复制粘贴进去，在右键选择add as library

5.系统包结构如下

6.代码实现

Connect.java
  1. package com.java.main.sqlConnect;
  2.  
  3. import java.sql.*;
  4.  
  5. /*
  6. 数据库的连接
  7.  */
  8. public class Connect {
  9.     //查询表中的数据
  10.     public static ResultSet queryAll(String sql) throws ClassNotFoundException, SQLException {
  11.         Class.forName("com.mysql.cj.jdbc.Driver");
  12.         Connection rt = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/lib_dtb", "root", "你的数据库密码");
  13.         Statement st = rt.createStatement();
  14.         ResultSet rs = st.executeQuery(sql);
  15.         return rs;
  16.     }
  17.  
  18.     //添加数据，删除数据，修改数据
  19.     public static void edit(String sql) throws ClassNotFoundException, SQLException {
  20.         Class.forName("com.mysql.cj.jdbc.Driver");
  21.         Connection rt = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/lib_dtb", "root", "你的数据库密码");
  22.         Statement st = rt.createStatement();
  23.         st.executeUpdate(sql);
  24.     }
  25. }
UserBuy.java
  1. package com.java.main.buyJavaBean;
  2.  
  3.  
  4. /*
  5. 购买记录javabean
  6.  */
  7. public class UserBuy {
  8.     private String name;
  9.     private String libraryName;
  10.     private String buyTime;
  11.  
  12.     public UserBuy() {
  13.     }
  14.  
  15.     public UserBuy(String name, String libraryName, String buyTime) {
  16.         this.name = name;
  17.         this.libraryName = libraryName;
  18.         this.buyTime = buyTime;
  19.     }
  20.  
  21.     public String getName() {
  22.         return name;
  23.     }
  24.  
  25.     public void setName(String name) {
  26.         this.name = name;
  27.     }
  28.  
  29.     public String getLibraryName() {
  30.         return libraryName;
  31.     }
  32.  
  33.     public void setLibraryName(String libraryName) {
  34.         this.libraryName = libraryName;
  35.     }
  36.  
  37.     public String getBuyTime() {
  38.         return buyTime;
  39.     }
  40.  
  41.     public void setBuyTime(String buyTime) {
  42.         this.buyTime = buyTime;
  43.     }
  44.  
  45.     @Override
  46.     public String toString() {
  47.         return "UserBuy{" +
  48.                 "name='" + name + '\'' +
  49.                 ", libraryName='" + libraryName + '\'' +
  50.                 ", buyTime='" + buyTime + '\'' +
  51.                 '}';
  52.     }
  53. }
Library.java
  1. package com.java.main.libraryJavaBean;
  2.  
  3. /*
  4. 图书javabean
  5.  */
  6. public class Library {
  7.     private Integer id;
  8.     private String name;
  9.     private String author;
  10.     private Double price;
  11.     private Integer count;
  12.     private String time;
  13.  
  14.     public Library() {
  15.     }
  16.  
  17.     public Library(Integer id, String name, String author, Double price, Integer count, String time) {
  18.         this.id = id;
  19.         this.name = name;
  20.         this.author = author;
  21.         this.price = price;
  22.         this.count = count;
  23.         this.time = time;
  24.     }
  25.  
  26.     public Integer getId() {
  27.         return id;
  28.     }
  29.  
  30.     public void setId(Integer id) {
  31.         this.id = id;
  32.     }
  33.  
  34.     public String getName() {
  35.         return name;
  36.     }
  37.  
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  41.  
  42.     public String getAuthor() {
  43.         return author;
  44.     }
  45.  
  46.     public void setAuthor(String author) {
  47.         this.author = author;
  48.     }
  49.  
  50.     public Double getPrice() {
  51.         return price;
  52.     }
  53.  
  54.     public void setPrice(Double price) {
  55.         this.price = price;
  56.     }
  57.  
  58.     public Integer getCount() {
  59.         return count;
  60.     }
  61.  
  62.     public void setCount(Integer count) {
  63.         this.count = count;
  64.     }
  65.  
  66.     public String getTime() {
  67.         return time;
  68.     }
  69.  
  70.     public void setTime(String time) {
  71.         this.time = time;
  72.     }
  73.     @Override
  74.     public String toString() {
  75.         return "Library{" +
  76.                 "id=" + id +
  77.                 ", name='" + name + '\'' +
  78.                 ", author='" + author + '\'' +
  79.                 ", price=" + price +
  80.                 ", count=" + count +
  81.                 ", time='" + time + '\'' +
  82.                 '}';
  83.     }
  84. }
Admin.java
  1. package com.java.main.perponJavaBean;
  2.  
  3. /*
  4. 管理员javabean
  5.  */
  6.  
  7. public class Admin extends User {
  8.     public Admin() {
  9.     }
  10.  
  11.     public Admin(Integer id, String username, String password) {
  12.         super(id, username, password);
  13.     }
  14. }
User.java
  1. package com.java.main.perponJavaBean;
  2.  
  3. /*
  4. 用户javabean
  5.  */
  6. public class User {
  7.     private Integer id;
  8.     private String username;
  9.     private String password;
  10.  
  11.     public User() {
  12.     }
  13.  
  14.     public User(Integer id, String username, String password) {
  15.         this.id = id;
  16.         this.username = username;
  17.         this.password = password;
  18.     }
  19.  
  20.     public Integer getId() {
  21.         return id;
  22.     }
  23.  
  24.     public void setId(Integer id) {
  25.         this.id = id;
  26.     }
  27.  
  28.     public String getUsername() {
  29.         return username;
  30.     }
  31.  
  32.     public void setUsername(String username) {
  33.         this.username = username;
  34.     }
  35.  
  36.     public String getPassword() {
  37.         return password;
  38.     }
  39.  
  40.     public void setPassword(String password) {
  41.         this.password = password;
  42.     }
  43.  
  44.     @Override
  45.     public String toString() {
  46.         return "User{" +
  47.                 "id=" + id +
  48.                 ", username='" + username + '\'' +
  49.                 ", password='" + password + '\'' +
  50.                 '}';
  51.     }
  52. }
AppRun.java
  1. package com.java.main.Screen;
  2.  
  3. import com.java.main.perponJavaBean.Admin;
  4. import com.java.main.perponJavaBean.User;
  5. import com.java.main.sqlConnect.Connect;
  6. import com.java.main.utils.CodeUtil;
  7.  
  8. import javax.swing.*;
  9. import java.sql.ResultSet;
  10. import java.sql.SQLException;
  11. import java.util.ArrayList;
  12. import java.util.Scanner;
  13.  
  14. /**
  15.  * @author leiGood浮生若梦
  16.  * @since 2024-06-13 星期四 18:41:29
  17.  * 用户注册登录
  18.  * 管理员登录
  19.  */
  20. public class AppRun {
  21.     public AppRun() {
  22.         System.out.println("=======================图书管理=======================");
  23.         System.out.println("=====================欢迎您的到来！====================");
  24.         System.out.println("=====================长风破浪会有时，==================");
  25.         System.out.println("=====================直挂云帆济沧海。==================");
  26.     }
  27.  
  28.     private static ArrayList<User> list = new ArrayList<>();
  29.  
  30.     public static void main(String[] args) throws SQLException, ClassNotFoundException {
  31.         new AppRun();
  32.         //存储用户集合
  33.         list = new ArrayList<User>();
  34.         //用户管理员
  35.         ArrayList<Admin> UserAdmin = new ArrayList<>();
  36.         //图书管理员
  37.         ArrayList<Admin> libraryAdmin = new ArrayList<>();
  38.         //获取数据库中的用户
  39.         ResultSet rs1 = Connect.queryAll("select  * from user");
  40.         while (rs1.next()) {
  41.             Integer id = rs1.getInt("id");
  42.             String username = rs1.getString("username");
  43.             String password = rs1.getString("password");
  44.             list.add(new User(id, username, password));
  45.         }
  46.         //获取用户管理员
  47.         ResultSet rs2 = Connect.queryAll("select  * from admin");
  48.         while (rs2.next()) {
  49.             Integer id = rs2.getInt("id");
  50.             String username = rs2.getString("username");
  51.             String password = rs2.getString("password");
  52.             UserAdmin.add(new Admin(id, username, password));
  53.         }
  54.         //获取图书管理员
  55.         ResultSet rs3 = Connect.queryAll("select * from libAdmin");
  56.         Scanner sc = new Scanner(System.in);
  57.         while (rs3.next()) {
  58.             Integer id = rs3.getInt("id");
  59.             String username = rs3.getString("username");
  60.             String password = rs3.getString("password");
  61.             libraryAdmin.add(new Admin(id, username, password));
  62.         }
  63.         rs3.close();
  64.         rs2.close();
  65.         rs1.close();
  66.         while (true) {
  67.             System.out.println("请输入您的选择：1.登录 2注册  3用户管理管理员登录  4图书管理管理员登录 5退出");
  68.             String numStr = sc.nextLine();
  69.             try {
  70.                 int num = Integer.parseInt(numStr);
  71.                 switch (num) {
  72.                     case 1:
  73.                         Login(list);
  74.                         break;
  75.                     case 2:
  76.                         Register(list);
  77.                         break;
  78.                     case 3:
  79.                         UserAdminLogin(UserAdmin);
  80.                         break;
  81.                     case 4:
  82.                         LibraryAdminLogin(libraryAdmin);
  83.                         break;
  84.                     case 5:
  85.                         System.exit(WindowConstants.EXIT_ON_CLOSE);
  86.                         break;
  87.                     default:
  88.                         System.out.println("没有这个选项");
  89.                         break;
  90.                 }
  91.             } catch (Exception e) {
  92.                 System.out.println("请输入数字，不能输入其它字符");
  93.             }
  94.         }
  95.     }
  96.  
  97.     //图书管理员登录
  98.     private static void LibraryAdminLogin(ArrayList<Admin> libraryAdmin) throws SQLException, ClassNotFoundException {
  99.         Scanner sc = new Scanner(System.in);
  100.         while (true) {
  101.             System.out.println("请输入图书管理员账号");
  102.             String username = sc.nextLine();
  103.             int index = getLibraAdminIndex(libraryAdmin, username);
  104.             if (index >= 0) {
  105.                 System.out.println("请输入图书管理员密码");
  106.                 String pwd = sc.nextLine();
  107.                 if (pwd.equals(libraryAdmin.get(index).getPassword())) {
  108.                     System.out.println("登陆成功！");
  109.                     com.java.main.Screen.LibraryAdmin.main();
  110.                     break;
  111.                 } else {
  112.                     System.out.println("密码输入错误，请重新输入~");
  113.                 }
  114.             } else {
  115.                 System.out.println("图书管理员账号不存在~");
  116.             }
  117.         }
  118.     }
  119.  
  120.     //用户管理员登录
  121.     private static void UserAdminLogin(ArrayList<Admin> UserAdminList) throws SQLException, ClassNotFoundException {
  122.         Scanner sc = new Scanner(System.in);
  123.         while (true) {
  124.             System.out.println("请输入用户管理员账号");
  125.             String username = sc.nextLine();
  126.             System.out.println("请输入用户管理员密码");
  127.             String pwd = sc.nextLine();
  128.             int adminIndex = getAdminIndex(UserAdminList, username);
  129.             if (adminIndex >= 0) {
  130.                 if (UserAdminList.get(adminIndex).getUsername().equals(username) &&
  131.                         UserAdminList.get(adminIndex).getPassword().equals(pwd)) {
  132.                     System.out.println("登录成功！");
  133.                     UserAdmin.main();
  134.                     break;
  135.                 } else {
  136.                     System.out.println("密码输入错误！");
  137.                 }
  138.             } else {
  139.                 System.out.println("该用户管理员账号不存在！");
  140.             }
  141.         }
  142.     }
  143.  
  144.     //注册操作
  145.     private static void Register(ArrayList<User> list) throws SQLException, ClassNotFoundException {
  146.         while (true) {
  147.             Scanner sc = new Scanner(System.in);
  148.             System.out.println("请输入用户名：");
  149.             String username = sc.next();
  150.             //判断用户名是否存在
  151.             int index = getIndex(list, username);
  152.             if (index < 0) {
  153.                 //用户名不存在，可以执行注册
  154.                 System.out.println("请输入密码：");
  155.                 String pwd1 = sc.next();
  156.                 System.out.println("请再次输入密码：");
  157.                 String pwd2 = sc.next();
  158.                 if (pwd2.equals(pwd1)) {
  159.                     //两次密码输入一致
  160.                     String sql = "insert into user(username,password) values('" + username + "','" + pwd2 + "')";
  161.                     Connect.edit(sql);
  162.                     System.out.println("注册成功！");
  163.                     //刷新用户集合中的数据，在次进行查询获取用户数据
  164.                     //获取数据库中的用户
  165.                     ResultSet rs1 = Connect.queryAll("select  * from user");
  166.                     while (rs1.next()) {
  167.                         Integer id = rs1.getInt("id");
  168.                         String uname = rs1.getString("username");
  169.                         String password = rs1.getString("password");
  170.                         list.add(new User(id, uname, password));
  171.                     }
  172.                     break;
  173.                 } else {
  174.                     //两次密码输入不一致
  175.                     System.out.println("两次密码输入不一致，请重新输入！");
  176.                 }
  177.             } else {
  178.                 System.out.println("用户名已经存在，请重新输入~");
  179.             }
  180.         }
  181.     }
  182.  
  183.     //登录操作
  184.     private static void Login(ArrayList<User> list) throws SQLException, ClassNotFoundException {
  185.         Scanner sc = new Scanner(System.in);
  186.         while (true) {
  187.             System.out.println("请输入用户名：");
  188.             String username = sc.nextLine();
  189.             //判断用户名是否存在
  190.             int index = getIndex(list, username);
  191.             if (index >= 0) {
  192.                 //用户名存在，执行下一步输入密码操作
  193.                 System.out.println("请输入密码：");
  194.                 String password = sc.nextLine();
  195.                 if (password.equals(list.get(index).getPassword())) {
  196.                     String codeStr = CodeUtil.getCode();
  197.                     System.out.println("当前验证码为：" + codeStr);
  198.                     System.out.println("请输入验证码：");
  199.                     String code = sc.nextLine();
  200.                     if (code.equalsIgnoreCase(codeStr)) {
  201.                         //密码输入正确
  202.                         System.out.println("登陆成功！");
  203.                         //传递用户登录的用户名
  204.                         new UserBuyLibrary(username).main();
  205.                         break;
  206.                     } else {
  207.                         System.out.println("验证码输入错误，请重新输入");
  208.                     }
  209.                 } else {
  210.                     System.out.println("密码输入错误，请重新输入");
  211.                 }
  212.             } else {
  213.                 //用户名不存在
  214.                 System.out.println("用户名未注册，请注册后再来使用~");
  215.                 break;
  216.             }
  217.         }
  218.     }
  219.  
  220.     //判断用户在登录或者注册时用户名是否存在，存在返回对应的索引，否则返回-1
  221.     public static int getIndex(ArrayList<User> list, String username) {
  222.         for (int i = 0; i < list.size(); i++) {
  223.             if (username.equals(list.get(i).getUsername())) {
  224.                 //存在
  225.                 return i;
  226.             }
  227.         }
  228.         //不存在
  229.         return -1;
  230.     }
  231.  
  232.     //判断用户管理员登录
  233.     public static int getAdminIndex(ArrayList<Admin> list, String username) {
  234.         for (int i = 0; i < list.size(); i++) {
  235.             if (username.equals(list.get(i).getUsername())) {
  236.                 //存在
  237.                 return i;
  238.             }
  239.         }
  240.         //不存在
  241.         return -1;
  242.     }
  243.  
  244.     //判断图书管理员登录
  245.     public static int getLibraAdminIndex(ArrayList<Admin> list, String username) {
  246.         for (int i = 0; i < list.size(); i++) {
  247.             if (username.equals(list.get(i).getUsername())) {
  248.                 //存在
  249.                 return i;
  250.             }
  251.         }
  252.         //不存在
  253.         return -1;
  254.     }
  255. }
LibraryAdmin.java
  1. package com.java.main.Screen;
  2.  
  3. import com.java.main.libraryJavaBean.Library;
  4. import com.java.main.sqlConnect.Connect;
  5.  
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.Timestamp;
  9. import java.text.SimpleDateFormat;
  10. import java.util.ArrayList;
  11. import java.util.Date;
  12. import java.util.Scanner;
  13.  
  14. /*
  15. 图书管理员操作代码
  16.  */
  17. public class LibraryAdmin {
  18.     public LibraryAdmin() throws SQLException, ClassNotFoundException {
  19.         //获取图书库存为0的书籍
  20.         ResultSet rs = Connect.queryAll("select * from library where count='0'");
  21.         while (rs.next()) {
  22.             System.out.println("========================图书" + rs.getString("name") + "的库存为0了，请增加库存！！！" +
  23.                     "========================");
  24.         }
  25.         rs.close();
  26.     }
  27.  
  28.     public static void main() throws SQLException, ClassNotFoundException {
  29.         new LibraryAdmin();
  30.         Scanner sc = new Scanner(System.in);
  31.         //图书集合
  32.         ArrayList<Library> list = new ArrayList<>();
  33.         ResultSet rs = Connect.queryAll("select * from library");
  34.         while (rs.next()) {
  35.             Integer id = rs.getInt("id");
  36.             String libraryName = rs.getString("name");
  37.             String authorName = rs.getString("author");
  38.             Double price = rs.getDouble("price");
  39.             Integer count = rs.getInt("count");
  40.             //获取上架时间
  41.             Timestamp shelf_time = rs.getTimestamp("Shelf_time");
  42.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  43.             String time = sdf.format(shelf_time);
  44.             list.add(new Library(id, libraryName, authorName, price, count, time));
  45.         }
  46.         rs.close();
  47.         System.out.println("请输入你的选择：1查看所有图书信息 2增加图书 3修改图书库存 4退出");
  48.         String numStr = sc.nextLine();
  49.         try {
  50.             switch (Integer.parseInt(numStr)) {
  51.                 case 1:
  52.                     LookForInfo(list);
  53.                     break;
  54.                 case 2:
  55.                     InsertBook(list);
  56.                     break;
  57.                 case 3:
  58.                     EditBook(list);
  59.                     break;
  60.                 case 4:
  61.                     new AppRun();
  62.                     break;
  63.                 default:
  64.                     System.out.println("没有这个选项~");
  65.                     break;
  66.             }
  67.         } catch (Exception e) {
  68.             System.out.println("请输入数字！不能输入其它字符~");
  69.         }
  70.     }
  71.  
  72.     //修改图书库存
  73.     private static void EditBook(ArrayList<Library> list) throws SQLException, ClassNotFoundException {
  74.         Scanner sc = new Scanner(System.in);
  75.         while (true) {
  76.             System.out.println("请输入要修改图书库存的图书名字：");
  77.             String name = sc.nextLine();
  78.             int index = getResult(list, name);
  79.             if (index >= 0) {
  80.                 //存在
  81.                 System.out.println("请输入增加的库存数量：");
  82.                 Integer count1 = sc.nextInt();
  83.                 Integer count2 = list.get(index).getCount();
  84.                 Integer count = count1 + count2;
  85.                 String sql = "update library set count='" + count + "' where name='" + name + "'";
  86.                 Connect.edit(sql);
  87.                 System.out.println("库存添加成功！");
  88.                 main();
  89.                 break;
  90.             } else {
  91.                 System.out.println("不存在该图书！请重新输入~");
  92.             }
  93.         }
  94.     }
  95.  
  96.     //增加图书
  97.     private static void InsertBook(ArrayList<Library> list) throws SQLException, ClassNotFoundException {
  98.         Scanner sc = new Scanner(System.in);
  99.         System.out.println("请输入要增加的图书名：");
  100.         String name = sc.next();
  101.         System.out.println("请输入作者名：");
  102.         String author = sc.next();
  103.         System.out.println("请输入价格：");
  104.         Double price = sc.nextDouble();
  105.         System.out.println("请输入图书数量：");
  106.         Integer count = sc.nextInt();
  107.         //获取上架时间
  108.         Date d = new Date();
  109.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  110.         String time = sdf.format(d);
  111.         String sql = " insert into library(name, author, price, count, Shelf_time) values('" + name + "','" + author + "','" +
  112.                 price + "','" + count + "','" + time + "')";
  113.         Connect.edit(sql);
  114.         System.out.println("添加成功！");
  115.         main();
  116.     }
  117.  
  118.     //查询图书信息
  119.     private static void LookForInfo(ArrayList<Library> list) throws SQLException, ClassNotFoundException {
  120.         System.out.println("图书信息如下：");
  121.         for (Library library : list) {
  122.             System.out.println("图书编号：" + library.getId() + " 图书名字：《" + library.getName() + " 》 图书作者：" + library.getAuthor()
  123.                     + " 图书价格：" + library.getPrice() + " 图书库存" + library.getCount() + " 图书上架时间：" + library.getTime());
  124.         }
  125.         main();
  126.     }
  127.  
  128.     //判断图书是否存在
  129.     public static Integer getResult(ArrayList<Library> list, String name) {
  130.         for (int i = 0; i < list.size(); i++) {
  131.             if (name.equals(list.get(i).getName())) {
  132.                 //存在
  133.                 return i;
  134.             }
  135.         }
  136.         return -1;
  137.     }
  138. }
UserAdmin.java
  1. package com.java.main.Screen;
  2.  
  3. import com.java.main.perponJavaBean.User;
  4. import com.java.main.sqlConnect.Connect;
  5.  
  6. import javax.swing.*;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.util.ArrayList;
  10. import java.util.Scanner;
  11. import java.util.function.Consumer;
  12.  
  13. /*
  14. 用户管理员
  15. 实现对用户信息的增删查改
  16.  */
  17. public class UserAdmin {
  18.     public static void main() throws SQLException, ClassNotFoundException {
  19.         Scanner sc = new Scanner(System.in);
  20.         //用户信息
  21.         ArrayList<User> list = new ArrayList<>();
  22.         String sql = "select * from user";
  23.         //连接数据库
  24.         ResultSet rs = Connect.queryAll(sql);
  25.         while (rs.next()) {
  26.             list.add(new User(rs.getInt("id"), rs.getString("username"), rs.getString("password")));
  27.         }
  28.         rs.close();
  29.         System.out.println("请输入你的选择：1查看用户信息 2删除用户信息 3修改用户信息 4增加用户信息 5退出");
  30.         String numStr = sc.nextLine();
  31.         try {
  32.             int num = Integer.parseInt(numStr);
  33.             switch (num) {
  34.                 case 1:
  35.                     LookUser(list);
  36.                     break;
  37.                 case 2:
  38.                     Delete(list);
  39.                     break;
  40.                 case 3:
  41.                     UpdateUser(list);
  42.                     break;
  43.                 case 4:
  44.                     InsertUser(list);
  45.                     break;
  46.                 case 5:
  47.                     System.exit(WindowConstants.EXIT_ON_CLOSE);
  48.                     break;
  49.                 default:
  50.                     System.out.println("没有这个选项！");
  51.                     main();
  52.                     break;
  53.             }
  54.         } catch (Exception e) {
  55.             System.out.println("请输入数字！");
  56.             main();
  57.         }
  58.     }
  59.  
  60.     //修改用户信息
  61.     private static void UpdateUser(ArrayList<User> list) throws SQLException, ClassNotFoundException {
  62.         Scanner sc = new Scanner(System.in);
  63.         while (true) {
  64.             System.out.println("请输入要修改的用户id：");
  65.             int id = sc.nextInt();
  66.             boolean flag = getResult(list, id);
  67.             if (flag) {
  68.                 //输入的id存在
  69.                 System.out.println("请输入修改后的用户名：");
  70.                 String username = sc.next();
  71.                 System.out.println("请修改后的密码：");
  72.                 String pwd = sc.next();
  73.                 String sql = "update user set username='" + username + "',password='" + pwd + "' where id=" + id;
  74.                 Connect.edit(sql);
  75.                 System.out.println("用户信息修改成功！");
  76.                 main();
  77.                 break;
  78.             } else {
  79.                 System.out.println("输入的用户id在数据库中不存在，请重新输入~");
  80.             }
  81.         }
  82.     }
  83.  
  84.     //增加用户信息
  85.     private static void InsertUser(ArrayList<User> list) throws SQLException, ClassNotFoundException {
  86.         Scanner sc = new Scanner(System.in);
  87.         while (true) {
  88.             System.out.println("请输入用户名：");
  89.             String username = sc.nextLine();
  90.             boolean flag = getUserFlag(list, username);
  91.             if (!flag) {
  92.                 //输入的用户名在数据库不存在，执行增加操作
  93.                 System.out.println("请输入密码：");
  94.                 String pwd = sc.nextLine();
  95.                 String sql = "insert into user(username,password) values('" + username + "','" + pwd + "')";
  96.                 Connect.edit(sql);
  97.                 System.out.println("添加成功！");
  98.                 main();
  99.                 break;
  100.             } else {
  101.                 System.out.println("输入的用户名在数据库中已经存在，请重新输入！");
  102.             }
  103.         }
  104.     }
  105.  
  106.     //删除用户信息
  107.     private static void Delete(ArrayList<User> list) throws SQLException, ClassNotFoundException {
  108.         Scanner sc = new Scanner(System.in);
  109.         while (true) {
  110.             System.out.println("请输入你要删除的用户id");
  111.             int id = sc.nextInt();
  112.             boolean flag = getResult(list, id);
  113.             if (flag) {
  114.                 //id存在
  115.                 String sql = "delete from user where id=" + id;
  116.                 Connect.edit(sql);
  117.                 System.out.println("删除成功！");
  118.                 main();
  119.                 break;
  120.             } else {
  121.                 //id不存在
  122.                 System.out.println("输入的用户id不存在，请重新输入");
  123.             }
  124.         }
  125.  
  126.     }
  127.  
  128.     //查看用户信息
  129.     private static void LookUser(ArrayList<User> list) throws SQLException, ClassNotFoundException {
  130.         //遍历用户集合
  131.         System.out.println("用户信息如下");
  132.         list.forEach(new Consumer<User>() {
  133.             @Override
  134.             public void accept(User user) {
  135.                 System.out.println(user.getId() + " " + user.getUsername() + " " + user.getPassword());
  136.             }
  137.         });
  138.         UserAdmin.main();
  139.     }
  140.  
  141.     //在删除用户信息的时候，判断用户输入的id是否存在
  142.     public static boolean getResult(ArrayList<User> list, int id) {
  143.         for (int i = 0; i < list.size(); i++) {
  144.             if (list.get(i).getId() == id) {
  145.                 //存在
  146.                 return true;
  147.             }
  148.         }
  149.         //不存在
  150.         return false;
  151.     }
  152.  
  153.     //查询输入的用户名是否存在
  154.     private static boolean getUserFlag(ArrayList<User> list, String username) {
  155.         for (int i = 0; i < list.size(); i++) {
  156.             if (username.equals(list.get(i).getUsername())) {
  157.                 //用户名存在
  158.                 return true;
  159.             }
  160.         }
  161.         //不存在
  162.         return false;
  163.     }
  164. }
UserBuyLibrary.java
  1. package com.java.main.Screen;
  2.  
  3. import com.java.main.buyJavaBean.UserBuy;
  4. import com.java.main.libraryJavaBean.Library;
  5. import com.java.main.sqlConnect.Connect;
  6.  
  7. import javax.swing.*;
  8. import java.sql.*;
  9. import java.text.SimpleDateFormat;
  10. import java.util.ArrayList;
  11. import java.util.Date;
  12. import java.util.Scanner;
  13. import java.util.function.Consumer;
  14.  
  15. /*
  16. 用户进行图书购买查询操作代码
  17.  */
  18. public class UserBuyLibrary {
  19.     private static String name;
  20.  
  21.     public UserBuyLibrary(String name) {
  22.         this.name = name;
  23.         System.out.println("欢迎来到图书商城");
  24.         System.out.println("当前的登录用户:" + name);
  25.     }
  26.  
  27.     public static void main() throws SQLException, ClassNotFoundException {
  28.         //创建图书集合
  29.         ArrayList<Library> list = new ArrayList<>();
  30.         //用户购买记录
  31.         ArrayList<UserBuy> buyList = new ArrayList<>();
  32.         //连接数据库 将图书信息添加到集合中
  33.         ResultSet rs1 = Connect.queryAll("select * from library");
  34.         while (rs1.next()) {
  35.             Integer id = rs1.getInt("id");
  36.             String libraryName = rs1.getString("name");
  37.             String authorName = rs1.getString("author");
  38.             Double price = rs1.getDouble("price");
  39.             Integer count = rs1.getInt("count");
  40.             //获取上架时间
  41.             Timestamp shelf_time = rs1.getTimestamp("Shelf_time");
  42.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  43.             String time = sdf.format(shelf_time);
  44.             list.add(new Library(id, libraryName, authorName, price, count, time));
  45.         }
  46.         rs1.close();
  47.         //获取用户购买记录
  48.         String sql = "select * from buy_table";
  49.         ResultSet rs2 = Connect.queryAll(sql);
  50.         while (rs2.next()) {
  51.             Timestamp buyTime = rs2.getTimestamp("buy_time");
  52.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  53.             String time = sdf.format(buyTime);
  54.             buyList.add(new UserBuy(rs2.getString("name"), rs2.getString("library"), time));
  55.         }
  56.         rs2.close();
  57.         Scanner sc = new Scanner(System.in);
  58.         System.out.println("请输入你的选择 1.查看所有图书信息 2.购买书籍 3.查询购买记录 4.退出");
  59.         try {
  60.             int num = sc.nextInt();
  61.             switch (num) {
  62.                 case 1:
  63.                     LookForLibraryInfo(list);
  64.                     break;
  65.                 case 2:
  66.                     BuyBook(list);
  67.                     break;
  68.                 case 3:
  69.                     FindBuy(buyList);
  70.                     break;
  71.                 case 4:
  72.                     System.exit(WindowConstants.EXIT_ON_CLOSE);
  73.                     break;
  74.                 default:
  75.                     System.out.println("没有这个选项");
  76.                     main();
  77.                     break;
  78.             }
  79.         } catch (Exception e) {
  80.             System.out.println("请输入数字，不能输入其它字符~");
  81.             main();
  82.         }
  83.     }
  84.  
  85.     //查询当前用户购买的图书信息
  86.     private static void FindBuy(ArrayList<UserBuy> buyList) throws SQLException, ClassNotFoundException {
  87.         System.out.println("购买记录如下所示：");
  88.         int index = getBuyIndex(buyList, name);
  89.         if (index >= 0) {
  90.             buyList.stream().forEach(userBuy -> System.out.println("用户" + userBuy.getName() + "于" + userBuy.getBuyTime() + "购买了" + userBuy.getLibraryName()));
  91.         } else {
  92.             System.out.println("您还没有购买任何书籍");
  93.         }
  94.         main();
  95.     }
  96.  
  97.     //购买书籍
  98.     private static void BuyBook(ArrayList<Library> list) throws SQLException, ClassNotFoundException {
  99.         Scanner sc = new Scanner(System.in);
  100.         while (true) {
  101.             System.out.println("请输入你要购买的图书名字");
  102.             String libraryName = sc.next();
  103.             int index = getIndex(list, libraryName);
  104.             if (index >= 0) {
  105.                 //图书存在
  106.                 //判断图书数量是否大于0
  107.                 Integer count = list.get(index).getCount();
  108.                 if (count > 0) {
  109.                     //图书有剩余容量
  110.                     System.out.println("请输入购买数量：");
  111.                     Integer amount = sc.nextInt();
  112.                     //判断购买数量是否在图书库存范围内
  113.                     if (amount > 0 && amount <= list.get(index).getCount()) {
  114.                         //在库存范围内
  115.                         //获取剩余书籍数量
  116.                         Integer remainingCount = list.get(index).getCount() - amount;
  117.                         //更新数据库
  118.                         String sql = "update library set count='" + remainingCount + "'where name='" + libraryName + "'";
  119.                         Connect.edit(sql);
  120.                         System.out.println("购买成功！");
  121.                         //获取当前购买时间
  122.                         Date d = new Date();
  123.                         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  124.                         String datetime = sdf.format(d);
  125.                         //将用户名和图书名字插入数据库中
  126.                         Connect.edit("insert into buy_table values ('" + name + "','" + libraryName + "','" + datetime + "')");
  127.                         main();
  128.                         break;
  129.                     } else {
  130.                         System.out.println("超出库存范围，请重新输入~");
  131.                     }
  132.                 } else {
  133.                     //图书已经卖完了
  134.                     System.out.println("很抱歉，图书已经卖完了，请买别的书籍吧~");
  135.                 }
  136.             } else {
  137.                 System.out.println("不存在该书籍！请重新输入~");
  138.             }
  139.         }
  140.     }
  141.  
  142.     //查询书籍
  143.     private static void LookForLibraryInfo(ArrayList<Library> list) throws SQLException, ClassNotFoundException {
  144.         System.out.println("图书信息如下：");
  145.         list.stream().forEach(new Consumer<Library>() {
  146.             @Override
  147.             public void accept(Library library) {
  148.                 System.out.println("图书编号：" + library.getId() + " 图书名字： 《" + library.getName() + "》 图书作者：" + library.getAuthor()
  149.                         + " 图书价格：" + library.getPrice() + " 图书库存" + library.getCount() + " 图书上架时间：" + library.getTime());
  150.             }
  151.         });
  152.         main();
  153.     }
  154.  
  155.     //判断图书名字在集合在是否存在
  156.     public static int getIndex(ArrayList<Library> list, String name) {
  157.         for (int i = 0; i < list.size(); i++) {
  158.             if (name.equals(list.get(i).getName())) {
  159.                 return i;
  160.             }
  161.         }
  162.         return -1;
  163.     }
  164.  
  165.     //判断用户在是否存在在购买集合中
  166.     private static int getBuyIndex(ArrayList<UserBuy> buyList, String name) {
  167.         for (int i = 0; i < buyList.size(); i++) {
  168.             if (name.equals(buyList.get(i).getName())) {
  169.                 return i;
  170.             }
  171.         }
  172.         return -1;
  173.     }
  174. }
CodeUtil.java
  1. package com.java.main.utils;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Random;
  5.  
  6. /*
  7. 验证码
  8.  */
  9. public class CodeUtil {
  10.     public static String getCode() {
  11.         ArrayList<Character> list = new ArrayList<>();
  12.         for (int i = 0; i < 26; i++) {
  13.             list.add((char) ('a' + i));
  14.         }
  15.         for (int i = 0; i < 26; i++) {
  16.             list.add((char) ('A' + i));
  17.         }
  18.         StringBuilder sb = new StringBuilder();
  19.         for (int i = 0; i < 4; i++) {
  20.             int index = new Random().nextInt(list.size());
  21.             sb.append(list.get(index));
  22.         }
  23.         for (int i = 0; i < 2; i++) {
  24.             int number = new Random().nextInt(10);
  25.             sb.append(number);
  26.         }
  27.         return sb.toString();
  28.     }
  29. }

7.Gitee

Java控制台图书管理系统: 本系统是Java控制台图书管理系统，实现了用户的注册登录，用户管理员的登录，图书管理员的登录，用户可以购买图书和查看图书购买记录，用户管理员可以对用户信息进行增删查改，图书管理员可以查看图书信息，以及上架新的图书和修改图书库存。icon-default.png?t=N7T8https://gitee.com/ouyanlei/consoleLibrarySystem.git

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

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

  

闽ICP备14008679号