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，并把下载好的驱动包直接拖动到这个包底下即可。
接着点击refactor就能在包底下看到自己的驱动包了。
接着右键点击当前的包，在底下找到add as a library。点击ok。
这样就算是导驱动包完成了。
新建一个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);
这样初步数据就算是准备好了。
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普通用户来展示普通用户的展示方法
2：使用zjw普通用户来展示普通用户的查看指定书籍方法
3：使用zjw普通用户来展示普通用户的借阅书籍方法
4：使用zjw普通用户来展示普通用户的归还书籍方法
5：使用admin管理员用户来展示管理员用户的归还新增书籍方法
