MYSQL JDBC图书管理系统

迈不过友情╰ 2023-09-28 17:39 1阅读 0赞

**两万字，博主辛辛苦苦给大家写的，在这里求个三连~~。**  
![在这里插入图片描述][7bb0c4527d104770bf79f177ebf68ff9.png]

### JDBC编程 ###

*  一、JDBC简介
 *  二、准备工作
 *  三、JDBC五毒神掌
 *   *   *  3.1导入驱动包，创建DataBase实例
 *  四、加入SQL版的数据库
 *   *   *  4.1系统功能汇总
         *  4.2 数据库准备
         *  4.3构造和数据库相关的实体类
         *  4.4封装数据库的相关操作
         *   *   *  1：封装好和数据库建立链接的操作
                 *  2：封装好针对书籍表的增删查改操作
                 *   *  2.1:新增书籍：
                     *  2.2：查看所有书籍：
                     *  2.3:根据名字查找书籍
                     *  2.4:删除书籍
                     *  2.5:借书
                     *  2.6 还书
                 *  3：封装好针对用户表的增删查改操作
         *  4.5 Operation操作包
         *   *   *  4.5.1 AddOperation
                 *  4.5.2 BorrowOperation
                 *  4.5.3 DelOperation
                 *  4.5.4 DisplayOperation
                 *  4.5.5 ExitOperation
                 *  4.5.6 FindOperation
                 *  4.5.7 IOperation
                 *  4.5.8 ReturnOperation
         *  4.6 Main
     *  五、最终效果

# 一、JDBC简介 #

即Java Database Connectivity，Java和数据库链接。是一种可以执行SQL语句的API。JDBC 是一种规范，它提供了一套完整的接口，允许便携式访问到底层数据库，因此可以用 Java 编写不同类型的可执行文件

--------------------

# 二、准备工作 #

> 工欲善其事必先利其器，在开始MYSQL JDBC编程之前，我们做一些准备工作。

编程语言：Java

数据库：MYSQL

数据库驱动包：不同的数据库需要导不同的数据包，并且数据库的版本也需要和驱动包的版本在大版本下相同，小版本可忽略。例如MYSQL用的5.x.x版本的那么对应的驱动包也应该是5.x.x。我这里为8.xx版本。这里附上链接。

[驱动包下载链接][Link 1]

# 三、JDBC五毒神掌 #

### 3.1导入驱动包，创建DataBase实例 ###

1、在项目目录中创建一个包，我这里为JDBCtest5，并把下载好的驱动包直接拖动到这个包底下即可。  
![在这里插入图片描述][9ef65af341b4431486082347cb249c1e.png]  
接着点击refactor就能在包底下看到自己的驱动包了。  
![在这里插入图片描述][2cdc9bfd85b244d1bbcd5abea51b9c1e.png]  
接着右键点击当前的包，在底下找到add as a library。点击ok。  
![在这里插入图片描述][615bfb31df89416185f518f163ac5c00.png]  
这样就算是导驱动包完成了。  
![在这里插入图片描述][60ceae96b397406d8e6baa807397b680.png]  
新建一个Java.class文件。我这里是JDBC0925。在这个文件里先创建出main函数出来。然后  
开始创建DataSource实例。同时给这个DataScoure设置参数，分别是URL，User,Password。  
这里用了向下转型，把父类实例使用一个子类引用指向。还需要把DataSource转回成MysqlDatasource才能设置URL，用户名和密码。

DataScoure顾名思义就是描述了数据的来源，当我们根据自己的URL，账户名，和密码创建一个datasource实例时，就为连接数据库做了一步准备工作。

//1、创建DataSource实例
            DataSource dataSource = new MysqlDataSource();
            ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/java_100?characterEncoding=utf8&useSSL=false");
            ((MysqlDataSource)dataSource).setUser("root");
            ((MysqlDataSource)dataSource).setPassword(" ");

那问题来了，向下转型这么麻烦，那不转型行不行？  
答案是完全可以的！但是如果直接写成不写转型的场景，这时如果要更换数据库的话，代码的改动就是非常大的。

2、和数据库建立连接。

//2、和数据库建立连接
            Connection connection = dataSource.getConnection();

3、构造SQL语句  
在JDBC中SQL是一个字符串，要想让数据库识别并执行SQL语句，还需要把这个字符串类型的SQL转成PrepareStatement对象。这个preparestatement对象可以帮我们动态的构造出SQL同时也能进行一些检查。  
这里我的sql语句为查询学生表的所有信息。

//3、构造SQL
            String sql="select * from student";
            PreparedStatement statement=connection.prepareStatement(sql);

4、执行SQL语句  
statement提供了两个系列的execute，一个是executeUpdate，它用来进行增加、删除、修改。返回int表示能影响到多少行。  
另一个是executeQuery。用于进行查找，我这里是查找，所以用的是Query。查找还需要一个结果集合resultSet。返回一个结果集，相当一个表格。

//4、执行SQL
            ResultSet resultSet=statement.executeQuery();
    
    
    //遍历结果集合
            //先取出结果中的每一行，再取出每一行中需要列即可。
            //这个遍历的代码很像迭代器
            while (resultSet.next()){
                int id=resultSet.getInt("id");
                String name=resultSet.getString("name");
                System.out.println(id+"	"+name);
            }

5、释放相关资源

哪些是相关资源？为什么要释放他们？释放资源的时候需要注意什么？  
相关资源都包含了connection、statement、resultSet。如果不关闭像这样的相关资源。就可能会导致资源泄漏。这一点和C语言的malloc很像。如果不关闭连接。当前这个connection对象只有的内存，以及内部持有的socket文件描述符都难以释放。这时候也会造成类似于内存泄漏的情况。  
释放资源的顺序需要和创建的顺序相反。我们创建的顺序是connection、statement、resultSet。所以关闭顺序就应该如下代码中那样。

//5、释放相关资源
            resultSet.close();
            statement.close();
            connection.close();

# 四、加入SQL版的数据库 #

如果这样就想学会JDBC，我猜你是哈士奇思考小问题。  
汪想！  
为了让读者更好的掌握JDBC编程，接下来我将向你演示mysql的图书管理系统。

### 4.1系统功能汇总 ###

图书管理系统：  
1、能够表示每本书的信息。包含书的序号、书名、作者、价格、类型。  
2、能够表示用户信息，这里分为两种，管理员和普通用户  
3、针对以上两种用户提供不同的操作：  
普通用户：查看书籍列表，查找指定书籍、借阅书籍、归还书籍  
管理员用户：查看书籍列表、新增书籍、删除书籍、

### 4.2 数据库准备 ###

1、书籍表：

create table book(
    bookid int primary key auto_increment,
    name varchar(20),
    author varchar(20),
    --  钱是小数但是小数的浮点数在计算机中难以精确存储，float、double都是无法精确表示的
    -- decimal类型可以精确表示小数但是效率大大降低
    -- 办法：还是用int 但是单位是分而不是元
    
    price  int,
    type varchar(20),
    isBrrowed int 
    );

2、用户表:

drop table if exists user;
    create table user(
    userId int  primary key auto_increment,
    username varchar(20),
    password varchar(20),
    --isAdmin为1时，代表管理员，为0代表普通用户
    isAdmin int
    );

先插入一些数据：

-- 插入一些数据
    insert into book values(null,'西游记','吴承恩',10000,'古典小说',0);
    insert into book values(null,'三国演义','罗贯中',10000,'古典小说',0);
    insert into book values(null,'水浒传','施耐庵',10000,'古典小说',0);
    insert into book values(null,'金瓶梅','兰陵笑笑生',10000,'古典小说',0);
    
    -- 插入一些用户
    insert into user values(null,'admin','123',1);
    insert into user values(null,'zjw','123',0);

这样初步数据就算是准备好了。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16]  
![请添加图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 1]

### 4.3构造和数据库相关的实体类 ###

数据库中的实体：用户，书籍  
所以在Java代码里也需要对应的用户类，书籍类。

书籍类代码如下：

package jdbcBook;
    
    //使用这个类表示一本书
    /*+-----------+-------------+------+-----+---------+----------------+
         | Field     | Type        | Null | Key | Default | Extra          |
         +-----------+-------------+------+-----+---------+----------------+
         | bookid    | int         | NO   | PRI | NULL    | auto_increment |
         | name      | varchar(20) | YES  |     | NULL    |                |
         | author    | varchar(20) | YES  |     | NULL    |                |
         | price     | int         | YES  |     | NULL    |                |
         | type      | varchar(20) | YES  |     | NULL    |                |
         | isBrrowed | int         | YES  |     | NULL    |                |
         +-----------+-------------+------+-----+---------+----------------+*/
    public class book {
        private  int bookId;
        private  String name;
        private String author;
        private int price;
        private String  type;
        private  int isBorrowed;
    
        public int getBookId() {
            return bookId;
        }
    
        public void setBookId(int bookId) {
            this.bookId = bookId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public int getIsBrrowed() {
            return isBrrowed;
        }
    
        public void setIsBorrowed(int isBorrowed) {
            this.isBorrowed = isBorrowed;
        }
    
        @Override
        public String toString() {
            return "book{" +
                    "bookId=" + bookId +
                    ", name='" + name + ''' +
                    ", author='" + author + ''' +
                    ", price=" + price +
                    ", type='" + type + ''' +
                    ", isBrrowed=" + isBrrowed +
                    '}';
        }
    }

用户类：

package jdbcBook;
    //使用这个类表示用户
    /*+----------+-------------+------+-----+---------+----------------+
     | Field    | Type        | Null | Key | Default | Extra          |
     +----------+-------------+------+-----+---------+----------------+
     | userId   | int         | NO   | PRI | NULL    | auto_increment |
     | username | varchar(20) | YES  |     | NULL    |                |
     | password | varchar(20) | YES  |     | NULL    |                |
     | isAdmin  | int         | YES  |     | NULL    |                |
     +----------+-------------+------+-----+---------+----------------+*/
    // 针对此处的isAdmin，用两个不同的子类来区分
    // 原因是不同的身份，管理员和用户，他们支持的方法是不同的
    
    import Operations.IOperation;
    
    abstract public class User {
        private int userId;
        private  String userName;
        private String password;
    
        //包含一个数组，里面存放的就是支持的操作
        //针对不同用户，分别设置不同操作
       IOperation[]operations;
    //普通用户和管理员看到的菜单也不一样
        //抽象方法不能有方法体，要求子类重写这个抽象方法
        //抽象类不能被实例化，只能被继承
        //如果一个方法是抽象方法，那么它必须存在于抽象类中
    
      abstract public int menu();
    
        public int getUserId() {
            return userId;
        }
    
        public void setUserId(int userId) {
            this.userId = userId;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "userId=" + userId +
                    ", userName='" + userName + ''' +
                    ", password='" + password + ''' +
                    '}';
        }
    }

管理员类：

package jdbcBook;
    
    import Operations.*;
    
    import java.util.Scanner;
    
    public class Admin extends User{
        public Admin(){
            this.operations=new IOperation[]{
                    new ExitOperation(),
                    new DisplayOperation(),
                    new FindOperation(),
                    new AddOperation(),
                    new DelOperation(),
            };
        }
        //打印管理员的菜单
        @Override
        public int menu(){
            System.out.println("~~~~~~~~~~~~~");
            System.out.println("欢迎欢迎 "+this.getUserName()+"管理员用户");
            System.out.println("请选择要进行的操作");
            System.out.println("1、查看书籍列表");
            System.out.println("2、查看指定书籍");
            System.out.println("3、新增书籍");
            System.out.println("4、删除书籍");
            System.out.println("0、退出系统");
            Scanner scanner=new Scanner(System.in);
            int choice=scanner.nextInt();
            return choice;
    
        }
    }

普通用户：

package jdbcBook;
    
    import Operations.*;
    
    import java.util.Scanner;
    
    public class NormalUser extends User{
        public  NormalUser(){
            //初始化OPERATIONS
            this.operations=new IOperation[]{
                    new ExitOperation(),
                    new DisplayOperation(),
                    new FindOperation(),
                    new BorrowOperation(),
                    new ReturnOperation(),
            };
        }
        //打印普通用户的菜单
        @Override
        public  int menu(){
            System.out.println("~~~~~~~~~~~~~");
            System.out.println("欢迎欢迎"+this.getUserName());
            System.out.println("请选择要进行的操作");
            System.out.println("1、查看书籍列表");
            System.out.println("2、查看指定书籍");
            System.out.println("3、借阅书籍");
            System.out.println("4、归还书籍");
            System.out.println("0、退出系统");
            Scanner scanner=new Scanner(System.in);
            int choice=scanner.nextInt();
            return choice;
        }
    }

上面的代码和我之前写过了纯Java版图书管理系统非常相似，几乎完全相同。不熟悉的同学可以去看看。这里附上链接  
[Java图书管理系统][Java]

> 以上四个类就是图书管理系统的基准类。接下来开始封装数据库的相关操作。

### 4.4封装数据库的相关操作 ###

从下面开始就和纯Java版本的不同了，现在写一些JDBC相关的代码，让程序通过这些代码，来完成对应数据表的增删查改。实现的具体步骤

##### 1：封装好和数据库建立链接的操作 #####

1):我们单独的创建一个类DButil来完成这样的操作  
还记得上面的JBDC五毒神掌吗？不记得的话看看下面的代码在熟悉一下。  
我们期望此处定义的URL,USERNAME,PASSWORD都是常量。所以我们用private，static，final来修饰他们。防止再修改。

//设置URL
        private static final String URL="jdbc:mysql://127.0.0.1:3306/bookmanager?characterEncoding=utf8&useSSL=false";
        //数据库用户名
        private static  final String USERNAME="root";
        //数据库密码
        private  static  final String PASSWORD=" ";

（1）创建Datasource实例，在创建之前我们希望它和上面的用户名、密码、URL一样是常量，只被创建一次。所以我们也给它加上static修饰符。

//加上static之后，DataSource就变成了类属性。和实例无关，只和类相关。
    //类属性，就是在类被创建出来的时候，才会被创建。
    //啥时候创建类？ 类加载阶段，但对于类来说，一个类也只是被加载一次而已。
    // 实例属性是在每个实例被创建出来的时候都会被创建
    
    
      private static   DataSource dataSource=new MysqlDataSource ();

（2）链接数据库  
我们期望的是就算不 创建DBUtil实例也能直接链接数据库，所以我们不用构造方法的形式链接数据库，而是用静态代码块。

//静态代码块
        static {
            ((MysqlDataSource)dataSource).setUrl (URL);
            ((MysqlDataSource)dataSource).setUser (USERNAME);
            ((MysqlDataSource)dataSource).setPassword (PASSWORD);
        }

在提供一个静态方法来链接

//这个方法也设计成static，这样不用创建DBUtil实例，也能调用这个方法
        public  static Connection getConnection() throws SQLException {
           return  dataSource.getConnection ();
        }

用完了之后，释放资源。  
顺序采用后申请，先关闭。

}
         //释放资源
        public  void close(Connection connection, PreparedStatement statement, ResultSet resultSet)  {
            if(resultSet!=null){
                try {
                    resultSet.close ();
                }catch (SQLException e){
                    e.printStackTrace ();
                }
            }
            if(statement!=null){
                try {
                    statement.close ();
                }catch (SQLException e){
                    e.printStackTrace ();
                }
            }
            if(connection!=null){
                try {
                    connection.close ();
                }catch (SQLException e){
                    e.printStackTrace ();
                }
            }
        }

**怕大家漏掉哪部分代码，我这里附上完整的代码**

import com.mysql.cj.jdbc.MysqlDataSource;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    //使用这个类，封装和数据库建立链接的操作
    public class DBUtil {
        //设置URL
        private static final String URL="jdbc:mysql://127.0.0.1:3306/bookmanager?characterEncoding=utf8&useSSL=false";
        //数据库用户名
        private static  final String USERNAME="root";
        //数据库密码
        private  static  final String PASSWORD=" ";
        //1、创建DataSource实例
        //加上static之后，DataSource就变成了类属性。和实例无关，只和类相关。
        //类属性，就是在类被创建出来的时候，才会被创建。
        //啥时候创建类？ 类加载阶段，但对于类来说，一个类也只是被加载一次而已。
        // 实例属性是在每个实例被创建出来的时候都会被创建
        private static   DataSource dataSource=new MysqlDataSource ();
        //使用一个构造方法，来设置Datasource进行属性，行不行?  不行。构造方法就需要实例对象了，但我们不想要这样
        //静态代码块
        static {
            ((MysqlDataSource)dataSource).setUrl (URL);
            ((MysqlDataSource)dataSource).setUser (USERNAME);
            ((MysqlDataSource)dataSource).setPassword (PASSWORD);
        }
        //提供一个方法来建立链接
        //这个方法也设计成static，这样不用创建DBUtil实例，也能调用这个方法
        public  static Connection getConnection() throws SQLException {
           return  dataSource.getConnection ();
        }
         //释放资源
        public  void close(Connection connection, PreparedStatement statement, ResultSet resultSet)  {
            if(resultSet!=null){
                try {
                    resultSet.close ();
                }catch (SQLException e){
                    e.printStackTrace ();
                }
            }
            if(statement!=null){
                try {
                    statement.close ();
                }catch (SQLException e){
                    e.printStackTrace ();
                }
            }
            if(connection!=null){
                try {
                    connection.close ();
                }catch (SQLException e){
                    e.printStackTrace ();
                }
            }
        }
    }

##### 2：封装好针对书籍表的增删查改操作 #####

这里我将其命名为BookDao，这是一种常用的命名习惯

###### 2.1:新增书籍： ######

//1、新增书籍
        public boolean add (book book) {
    //把book对象插入到数据库的BOOK表中
            Connection connection = null;
            PreparedStatement statement = null;
            try {
                //1、建立数据库链接
                connection = DBUtil.getConnection ();
                //2、拼装sql语句
                String sql = "insert into book values(null,?,?,?,?,?)";
                statement = connection.prepareStatement (sql);
                statement.setString (1, book.getName ());
                statement.setString (2, book.getAuthor ());
                statement.setInt (3, book.getPrice ());
                statement.setString (4, book.getType ());
                statement.setInt (5, book.getIsBorrowed ());
                //3、执行sql
                int ret = statement.executeUpdate ();
                if (ret != 1) {
                    //如果插入失败返回false。
                    return false;
                }
                return true;
            } catch (SQLException e) {
                e.printStackTrace ();
            } finally {
                DBUtil.close (connection, statement, null);
            }
            return false;
        }

###### 2.2：查看所有书籍： ######

//2、查看所有书籍
        public List<book> selectAll () {
            List<book> books = new ArrayList<> ();
            //获取数据库表中的所有书籍记录
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet resultSet = null;
            try {
                //1、先和数据库建立链接
                connection = DBUtil.getConnection ();
                //2、拼接SQL
                String sql = "select * from book";
                statement = connection.prepareStatement (sql);
                //3、执行SQL
                resultSet = statement.executeQuery ();
                //4、遍历结果集合
                while (resultSet.next ()) {
                    //取出当前行的这些列，构造出一个book对象来
                    book book = new book ();
                    book.setBookId (resultSet.getInt ("bookid"));
                    book.setName (resultSet.getString ("name"));
                    book.setAuthor (resultSet.getString ("author"));
                    book.setPrice (resultSet.getInt ("price"));
                    book.setType (resultSet.getString ("type"));
                    book.setIsBrrowed (resultSet.getInt ("isBrrowed"));
                    books.add (book);
                }
            } catch (SQLException e) {
                e.printStackTrace ();
            } finally {
                DBUtil.close (connection, statement, resultSet);
            }
            return books;
        }

###### 2.3:根据名字查找书籍 ######

//3、根据名字找书籍
        public List<book> selectByName (String name) {
            List<book> books = new ArrayList<> ();
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet resultSet = null;
            try {
                //1、先和数据库建立连接
                connection = DBUtil.getConnection ();
                //2、拼装SQL语句
                String sql = "select * from book where name= ?";
                statement = connection.prepareStatement (sql);
                statement.setString (1, name);
                //3、执行SQL
                resultSet = statement.executeQuery ();
                //4、遍历结果集合
                while (resultSet.next ()) {
                    book book = new book ();
                    book.setBookId (resultSet.getInt ("bookid"));
                    book.setName (resultSet.getString ("name"));
                    book.setAuthor (resultSet.getString ("author"));
                    book.setPrice (resultSet.getInt ("price"));
                    book.setType (resultSet.getString ("type"));
                    book.setIsBrrowed (resultSet.getInt ("isBrrowed"));
                    books.add (book);
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace ();
            } finally {
                DBUtil.close (connection, statement, resultSet);
            }
            return books;
        }

###### 2.4:删除书籍 ######

//4、删除书籍
        public boolean delete (int bookId) {
            Connection connection = null;
            PreparedStatement statement = null;
            try {
                //1、建立链接
                connection = DBUtil.getConnection ();
                //2、拼装SQL
                String sql = "delete from book where bookid= ?";
                statement = connection.prepareStatement (sql);
                statement.setInt (1, bookId);
                //3、执行SQL
                int ret = statement.executeUpdate ();
                if (ret != 1) {
                    return false;
                }
                return true;
            } catch (SQLException throwables) {
                throwables.printStackTrace ();
            } finally {
                DBUtil.close (connection, statement, null);
            }
            return false;
        }

###### 2.5:借书 ######

//5、借书
        public boolean borrowBook (int bookId) {
            Connection connection = null;
            PreparedStatement statement1 = null;
            PreparedStatement statement2 = null;
            ResultSet resultSet = null;
            try {
                //1、和数据库建立链接
                connection = DBUtil.getConnection ();
                //从这里开始先进性查找书
                //2、拼装SQL
                //如果当前这里面的isBorrowed已经是1了，还能借吗？
                //如果这本书不存在还能借吗？
                //所以这里先查找，确实这本书存不存在，有没有被借出，再说别的
                String sql = "select * from book where bookid= ?";
                statement1 = connection.prepareStatement (sql);
                statement1.setInt (1, bookId);
                //3、执行SQL
                resultSet = statement1.executeQuery ();
                //4、遍历结果，预期结果是1条或者是0
                if (resultSet.next ()) {
                    //因此这里只要if判断即可
                    boolean isBorrowed = (resultSet.getInt ("isBrrowed") == 1);
                    if (isBorrowed) {
                        System.out.println ("书已经借出！借不了哦 bookId=" + bookId);
                        return false;
                    }
                } else {
                    //到这里说明书不存在
                    System.out.println ("书不存在，借不了哦 bookId=" + bookId);
                    return false;
                }
                //接下来才是真正的借书
                //5、拼装SQL
                sql = "update book set isBrrowed =1 where bookid = ?";
                statement2 = connection.prepareStatement (sql);
                statement2.setInt (1, bookId);
                //6、执行SQL
                int ret = statement2.executeUpdate ();
                if (ret != 1) {
                    return false;
                }
                return true;
            } catch (SQLException throwables) {
                throwables.printStackTrace ();
            } finally {
                if (resultSet != null) {
                    try {
                        resultSet.close ();
                    } catch (SQLException e) {
                        e.printStackTrace ();
                    }
                }
                if (statement2 != null) {
                    try {
                        statement2.close ();
                    } catch (SQLException e) {
                        e.printStackTrace ();
                    }
                }
                if (statement1 != null) {
                    try {
                        statement1.close ();
                    } catch (SQLException e) {
                        e.printStackTrace ();
                    }
                }
            }
            return false;
        }

###### 2.6 还书 ######

//6、还书
        public boolean returnBook (int bookId) throws SQLException {
            Connection connection = null;
            PreparedStatement statement1 = null;
            PreparedStatement statement2 = null;
            ResultSet resultSet = null;
            try {
                connection = DBUtil.getConnection ();
                String sql = "select * from book where bookid = ?";
                statement1 = connection.prepareStatement (sql);
                statement1.setInt (1, bookId);
                resultSet = statement1.executeQuery ();
                if (resultSet.next ()) {
                    //查询到书了
                    boolean isBorrowed = (resultSet.getInt ("isBrrowed") == 1);
                    if (!isBorrowed) {
                        System.out.println ("书没有借出，不用还 bookid=" + bookId);
                        return false;
                    } else {
                        //书不存在
                        System.out.println ("书不存在 bookid=" + bookId);
                    }
                    //修改书的状态
                    sql = "update book set isBrrowed = 0 where bookid = ?";
                    statement2=connection.prepareStatement (sql);
                    statement2.setInt (1, bookId);
                    int ret=statement2.executeUpdate ();
                    if(ret!=1){
                        return  false;
                    }
                    return true;
                }
            }catch (SQLException e){
                e.printStackTrace ();
            }finally {
                if (resultSet != null) {
                    try {
                        resultSet.close ();
                    } catch (SQLException e) {
                        e.printStackTrace ();
                    }
                }
                if (statement2 != null) {
                    try {
                        statement2.close ();
                    } catch (SQLException e) {
                        e.printStackTrace ();
                    }
                }
                if (statement1 != null) {
                    try {
                        statement1.close ();
                    } catch (SQLException e) {
                        e.printStackTrace ();
                    }
                }
            }
            return  false;
            }
        }

##### 3：封装好针对用户表的增删查改操作 #####

还是和上面的相似，这里命名为UserDao

> 主要实现针对用户名找密码这样的逻辑

import jdbcBook.Admin;
    import jdbcBook.DBUtil;
    import jdbcBook.NormalUser;
    import jdbcBook.User;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class UserDao {
        //主要实现针对用户名找密码这样的逻辑
        //用户名是唯一的，只能查到结果是1或者是0
        //应该给这行加上unique约束
        public  User selectByName(String name){
            Connection connection=null;
            PreparedStatement statement=null;
            ResultSet resultSet=null;
            try {
                connection= DBUtil.getConnection ();
                String sql="select * from user where username= ?";
                statement=connection.prepareStatement (sql);
                statement.setString (1, name);
                resultSet=statement.executeQuery ();
                if(resultSet.next ()){
                    //存在用户名 就返回一个具体的对象
                    //需要根据当前user是否是管理员，决定返回一个admin的还是normalUser
                    boolean isAdmin=resultSet.getInt ("isAdmin")==1;
                    User user=null;
                    if(isAdmin){
                        user=new Admin ();
                    }else {
                        user=new NormalUser ();
                    }
                    user.setUserId (resultSet.getInt ("userId"));
                    user.setUserName (resultSet.getString ("username"));
                    user.setPassword (resultSet.getString ("password"));
                    return user;
                }
            } catch (SQLException e) {
                e.printStackTrace ();
            }finally {
                DBUtil.close (connection, statement, resultSet);
            }
            return  null;
        }
    }

### 4.5 Operation操作包 ###

上面的bookDao和userDao都是针对数据库的，我们再在针对java代码写一次，只不过这一遍只需要调用之前写好的就行。比较方便

##### 4.5.1 AddOperation #####

package Operations;
    
    import java.util.Scanner;
    import jdbcBook.BookDao;
    import jdbcBook.book;
    import java.awt.print.Book;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class AddOperation implements IOperation{
        @Override
        public void work(){
            System.out.println ("新增书籍");
            Scanner scanner=new Scanner (System.in);
            System.out.println ("请输入书名");
            String bookName=scanner.next ();
            System.out.println ("请输入作者");
            String author=scanner.next ();
            System.out.println ("请输入价格");
            int price=scanner.nextInt ();
            System.out.println ("请输入类别");
            String type=scanner.next ();
            book book=new book ();
            book.setName (bookName);
            book.setPrice (price);
            book.setAuthor (author);
            book.setType (type);
            BookDao bookDao=new BookDao ();
            boolean ret=bookDao.add (book);
            if(ret){
                System.out.println ("新增书籍成功");
            }else {
                System.out.println ("新增书籍失败");
            }
        }
    }

##### 4.5.2 BorrowOperation #####

package Operations;
    
    import jdbcBook.BookDao;
    
    import java.util.Scanner;
    
    public class BorrowOperation implements  IOperation{
        @Override
        public void work() {
            System.out.println ("借阅书籍");
            Scanner scanner=new Scanner (System.in);
            System.out.println ("请输入要借阅的书籍id");
            int bookID=scanner.nextInt ();
            BookDao bookDao=new BookDao ();
            boolean ret=bookDao.borrowBook (bookID);
            if(ret)
            {
                System.out.println ("成功");
            }else {
                System.out.println ("失败");
            }
        }
    }

##### 4.5.3 DelOperation #####

package Operations;
    
    import jdbcBook.BookDao;
    
    import java.util.Scanner;
    
    public class DelOperation implements  IOperation{
        @Override
        public void work() {
            System.out.println ("删除书籍");
            Scanner scanner=new Scanner (System.in);
            System.out.println ("请输入要删除的id ：");
            int bookid=scanner.nextInt ();
            BookDao bookDao=new BookDao ();
            boolean ret=bookDao.delete (bookid);
            if(ret){
                System.out.println ("删除成功");
            }else {
                System.out.println ("删除失败");
            }
        }
    }

##### 4.5.4 DisplayOperation #####

package Operations;
    
    import jdbcBook.BookDao;
    import jdbcBook.book;
    import java.util.List;
    
    public class DisplayOperation implements IOperation{
        @Override
        public void work() {
            System.out.println ("展现所有书籍");
            BookDao bookDao=new BookDao();
            List<book>  books=bookDao.selectAll ();
            for (book book:books) {
                System.out.println (book);
            }
            System.out.println ("这就是所有书了");
        }
    }

##### 4.5.5 ExitOperation #####

package Operations;
    
    public class ExitOperation  implements  IOperation{
        @Override
        public void work(){
            System.out.println ("退出程序");
            System.exit (0);
        }
    }

##### 4.5.6 FindOperation #####

package Operations;
    
    import jdbcBook.BookDao;
    import jdbcBook.book;
    import java.awt.print.Book;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class FindOperation implements IOperation{
        @Override
        public void work() {
            System.out.println ("根据名字找想要的书籍");
            System.out.println ("请输入要查找的书名: ");
            Scanner scanner=new Scanner (System.in);
            String bookName=scanner.next ();
            BookDao bookDao=new BookDao ();
            List<book> bookList=bookDao.selectByName (bookName);
            for (book book:bookList) {
                System.out.println (book);
            }
            System.out.println ("查找完毕");
        }
    }

##### 4.5.7 IOperation #####

这是一个接口，上面的哪些操作都实现了它

package Operations;
    
    import java.sql.SQLException;
    
    public interface IOperation {
        void  work() throws SQLException;
    }

##### 4.5.8 ReturnOperation #####

package Operations;
    
    import jdbcBook.BookDao;
    
    import java.sql.SQLException;
    import java.util.Scanner;
    
    public class ReturnOperation implements  IOperation{
        @Override
        public  void work() throws SQLException {
            System.out.println ("归还书籍");
            Scanner scanner=new Scanner (System.in);
            System.out.println ("请输入要借阅的书籍id");
            int bookID=scanner.nextInt ();
            BookDao bookDao=new BookDao ();
           boolean ret=bookDao.returnBook (bookID);
            if(ret)
            {
                System.out.println ("成功");
            }else {
                System.out.println ("失败");
            }
        }
        }

### 4.6 Main ###

> 这是整个程序运行的骨干。所有的东西都由它调度。  
> 在这里模拟实现一个登陆环节。

import jdbcBook.User;
    
    import java.sql.SQLException;
    import java.util.Scanner;
    
    public class Main {
        public static void main (String[] args) throws SQLException {
        //通过login登陆
            User user=login();
            while (true){
                int choice=user.menu ();
                user.doOperation(choice);
            }
        }
        private  static  User login(){
            Scanner scanner=new Scanner (System.in);
            System.out.println ("请输入用户名");
            String username=scanner.next ();
            System.out.println ("请输入密码");
            String password=scanner.next ();
            //2、从数据库根据用户名来查密码对不对
            UserDao userDao=new UserDao ();
            User user=userDao.selectByName (username);
            if(user==null){
                //不存在
                System.out.println ("登陆失败，用户不存在");
                //退出程序
                System.exit (1);
            }
            if(!user.getPassword ().equals (password)){
                //密码不对
                System.out.println ("登陆失败，密码不对");
                System.exit (1);
            }
            return  user;
        }
    }

## 五、最终效果 ##

功夫不负有心人，能看到这里的，一定都是非常爱学习的同学。那我们就一起来看看最后的结果把。

1：使用zjw普通用户来展示普通用户的展示方法  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 2]

2：使用zjw普通用户来展示普通用户的查看指定书籍方法  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
3：使用zjw普通用户来展示普通用户的借阅书籍方法  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
4：使用zjw普通用户来展示普通用户的归还书籍方法  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
5：使用admin管理员用户来展示管理员用户的归还新增书籍方法  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 6]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 7]

先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦

[7bb0c4527d104770bf79f177ebf68ff9.png]: https://img-blog.csdnimg.cn/7bb0c4527d104770bf79f177ebf68ff9.png
[Link 1]: https://mvnrepository.com/artifact/mysql/mysql-connector-java
[9ef65af341b4431486082347cb249c1e.png]: https://img-blog.csdnimg.cn/9ef65af341b4431486082347cb249c1e.png
[2cdc9bfd85b244d1bbcd5abea51b9c1e.png]: https://img-blog.csdnimg.cn/2cdc9bfd85b244d1bbcd5abea51b9c1e.png
[615bfb31df89416185f518f163ac5c00.png]: https://img-blog.csdnimg.cn/615bfb31df89416185f518f163ac5c00.png
[60ceae96b397406d8e6baa807397b680.png]: https://img-blog.csdnimg.cn/60ceae96b397406d8e6baa807397b680.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/8624696bbf5d419a85d3753f0aaf01ce.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/189391bcc774442ca5708222466fae34.bmp?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[Java]: https://blog.csdn.net/guankunkunwd/article/details/120412778
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/dfd803daa77b4a17be161d3cbe82e0a4.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/ba7b4f90bc334b41b14b927b0333d8da.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/a23743c623a34232876f227bc99da61d.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://img-blog.csdnimg.cn/2516d046eb8d4753a640fe73fe66d478.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 6]: https://img-blog.csdnimg.cn/c184d2701e8c4a0899c464f145757afc.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATVIuU0VFRUtT_size_20_color_FFFFFF_t_70_g_se_x_16 7]: https://img-blog.csdnimg.cn/ca50c2bd2c5a426492dd2a7d85198403.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATVIuU0VFRUtT,size_20,color_FFFFFF,t_70,g_se,x_16