2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统

两万字,博主辛辛苦苦给大家写的,在这里求个三连~~。
在这里插入图片描述

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版本。这里附上链接。

驱动包下载链接

三、JDBC五毒神掌

3.1导入驱动包,创建DataBase实例

1、在项目目录中创建一个包,我这里为JDBCtest5,并把下载好的驱动包直接拖动到这个包底下即可。
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第1张图片
接着点击refactor就能在包底下看到自己的驱动包了。
在这里插入图片描述
接着右键点击当前的包,在底下找到add as a library。点击ok。
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第2张图片
这样就算是导驱动包完成了。
在这里插入图片描述
新建一个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+"\t"+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);

这样初步数据就算是准备好了。
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第3张图片
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第4张图片

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图书管理系统

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

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普通用户来展示普通用户的展示方法
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第5张图片

2:使用zjw普通用户来展示普通用户的查看指定书籍方法
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第6张图片
3:使用zjw普通用户来展示普通用户的借阅书籍方法
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第7张图片
4:使用zjw普通用户来展示普通用户的归还书籍方法
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第8张图片
5:使用admin管理员用户来展示管理员用户的归还新增书籍方法
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第9张图片
2w字期末作业这样写,老师看了直说好。MYSQL JDBC编程从0开始,到创建一个图书管理系统_第10张图片

你可能感兴趣的