【图书管理系统】Servlet+JSP+MySql 实现的一个前后端 javaweb项目（内附源 ...

源码分享在文末！

文章目录

• 前言
  
• 一、项目技术
  
• 二、开发环境和工具
  
• 三、项目成品演示
  
• 四、项目讲解
  
• 五、源码展示
  
• 总结
  

---

前言

学习完Javaweb的知识后做了个项目练练手，我选择了经典而且比较简单的图书管理系统。
最近有时间，整理了一下，分享给大家，希望能够帮到你！
一、项目技术

• 基于B/S结构
  
• 前端: HTML+CSS+JS +JQuery
  
• 后端: Servlet+JSP+MySql
  

二、开发环境和工具

• 操作系统: win8/win10
  
• JDK: 8.0
  
• 开发工具: Intellij IDEA2020.1 旗舰版
  
• 服务器: Tomcat8.0
  
• 数据库工具:mysql5.5 +Navicat Premium 12
  

开发工具我也为大家打包好了，关注文末的公众号，回复“Java全家桶”即可获得
三、项目成品演示


四、项目讲解

技术介绍

• JSP: JavaServer Pages是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。
  
• Apache: Apache是世界使用排名第一的Web服务器软件。
  
• Ajax：Asynchronous Javascript And XML（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术。通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。
  
• C3P0:数据库连接池
  
• OSI：Open System Interconnect 开放系统互连参考模型。
  
• MVC：Model View Controller ，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码。
  
• DBUtils：Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。
  

工作原理：
浏览器和服务器通过http协议来建立连接的。浏览器经过http的请求协议将用户想要的信息传到web服务器。
然后，web服务器会干一件事，判断页面是静态还是动态。
如果是静态，web服务器就直接将用户想要的信息通过响应封装好了之后再返回给浏览器；
如果是动态，web服务器会将接收到的内容传递给web容器，web容器再将内容传给Servlet，（那么web容器是怎么将内容传给servlet的呢？分析：web容器在将信息传递给servlet的时候必须到web.xml的配置文件中去找到Servlet的url-pattern路径），在找到servlet后，web容器再启动一个servlet线程，然后再返回给web容器，web容器在将信息封装好传给web服务器，web服务器再将得到的信息解析后，通过响应封装好了，在传递到浏览器。
如下图所示

数据库表及其关系

项目结构展示

• 后端
  
  
• 前端
  
  

五、源码展示

书籍实体类

1. /**
2. * 书的实体类:注意外键
3. * 1.DBUtil无法生成表以外的数据
4. * 2.外键的实体对象没有数据，需要后期手动添加biz(业务去实现)
5. */
6. public class Book implements Serializable {
8.   private long id;
9.   //外键号
10.   private long typeId;
11.   private String name;
12.   private double price;
13.   private String desc;
14.   private String pic;
15.   private String publish;
16.   private String author;
17.   private long stock;
18.   private String address;
20.   //外键对应的实体对象
21.   private Type  type;
23.   public Type getType() {
24.     return type;
25.   }
27.   public void setType(Type type) {
28.     this.type = type;
29.   }
31.   public long getId() {
32.     return id;
33.   }
35.   public void setId(long id) {
36.     this.id = id;
37.   }
40.   public long getTypeId() {
41.     return typeId;
42.   }
44.   public void setTypeId(long typeId) {
45.     this.typeId = typeId;
46.   }
49.   public String getName() {
50.     return name;
51.   }
53.   public void setName(String name) {
54.     this.name = name;
55.   }
58.   public double getPrice() {
59.     return price;
60.   }
62.   public void setPrice(double price) {
63.     this.price = price;
64.   }
67.   public String getDesc() {
68.     return desc;
69.   }
71.   public void setDesc(String desc) {
72.     this.desc = desc;
73.   }
76.   public String getPic() {
77.     return pic;
78.   }
80.   public void setPic(String pic) {
81.     this.pic = pic;
82.   }
85.   public String getPublish() {
86.     return publish;
87.   }
89.   public void setPublish(String publish) {
90.     this.publish = publish;
91.   }
94.   public String getAuthor() {
95.     return author;
96.   }
98.   public void setAuthor(String author) {
99.     this.author = author;
100.   }
103.   public long getStock() {
104.     return stock;
105.   }
107.   public void setStock(long stock) {
108.     this.stock = stock;
109.   }
112.   public String getAddress() {
113.     return address;
114.   }
116.   public void setAddress(String address) {
117.     this.address = address;
118.   }
120.   @Override
121.   public String toString() {
122.     return "Book{" +
123.             "id=" + id +
124.             ", typeId=" + typeId +
125.             ", name='" + name + '\'' +
126.             ", price=" + price +
127.             ", desc='" + desc + '\'' +
128.             ", pic='" + pic + '\'' +
129.             ", publish='" + publish + '\'' +
130.             ", author='" + author + '\'' +
131.             ", stock=" + stock +
132.             ", address='" + address + '\'' +
133.             ", type=" + type +
134.             '}';
135.   }
136. }

复制代码

书籍的Servlet层

1. @WebServlet("/book.let")
2. public class BookServlet extends HttpServlet {
3.     BookBiz bookBiz = new BookBiz();
4.     @Override
5.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
6.         doPost(req, resp);
7.     }
9.     /**
10.      * /book.let?type=add 添加图片
11.      * /book.let?type=modifypre&id=xx 修改前准备
12.      * /book.let?type=modify 修改
13.      * /book.let?type=remove&id=xx 删除
14.      * /book.let?type=query&pageIndex=1 分页查询-请求转发
15.      * /book.let?type=details&id=xx 展示书籍详细信息
16.      * /book.let?type=doajax&name=xx 根据图书名对应的图书信息
17.      * @param req
18.      * @param resp
19.      * @throws ServletException
20.      * @throws IOException
21.      */
22.     @Override
23.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
25.         req.setCharacterEncoding("utf-8");
26.         resp.setContentType("text/html;charset=utf-8");
27.         PrintWriter out = resp.getWriter();
28.         //验证用户是否登录
29.         HttpSession session = req.getSession();
30.         if(session.getAttribute("user") == null) {
31.             out.println("");
32.             return;
33.         }
34.         String type = req.getParameter("type");
35.         switch (type) {
36.             case "add":
37.                 try {
38.                     add(req, resp, out);
39.                 } catch (Exception e) {
40.                     e.printStackTrace();
41.                     resp.sendError(500, e.getMessage());
42.                 }
43.                 break;
44.             case "modifypre":
45.                 ///book.let?type=modifypre&id=xx 修改前准备
46.                 long bookId = Long.parseLong(req.getParameter("id"));
47.                 Book book = bookBiz.getById(bookId);
48.                 req.setAttribute("book", book);
49.                 req.getRequestDispatcher("book_modify.jsp").forward(req,resp);
50.                 break;
51.             case "modify":
52.                 try {
53.                     modify(req, resp,out);
54.                 } catch (Exception e) {
55.                     e.printStackTrace();
56.                 }
57.                 break;
58.             case "remove":
59.                 //1.获取删除书籍id
60.                 long id = Long.parseLong(req.getParameter("id"));
61.                 //2.调用biz层删除
62.                 try {
63.                     int count = bookBiz.remove(id);
64.                     //3.提示+跳转到查询的servlet -out对象
65.                     if(count > 0) {
66.                         out.println("");
67.                     }else{
68.                         out.println("");
69.                     }
70.                 } catch (Exception e) {
71.                     //e.printStackTrace();
72.                     out.println("");
73.                 }
74.             case "query":
75.                 query(req, resp);
76.                 break;
77.             case "details":
78.                 details(req, resp,out);
79.                 break;
80.             case "doajax":
81.                 String name = req.getParameter("name");
82.                 Book book1 = bookBiz.getByName(name);
83.                 if(book1 == null) {
84.                     out.print("{}");//null的json对象
85.                 }else{
86.                     out.print(JSON.toJSONString(book1));
87.                 }
88.                 break;
89.             default:
90.                 out.println("404");
91.         }
92.     }
94.     /**
95.      * 修改图书信息
96.      * @param req
97.      * @param resp
98.      * @param out
99.      */
100.     private void modify(HttpServletRequest req, HttpServletResponse resp, PrintWriter out) throws Exception {
101.         //1.创建磁盘工厂-临时存储文件磁盘-
102.         DiskFileItemFactory factory = new DiskFileItemFactory();
103.         //1.1设置大小
104.         factory.setSizeThreshold(1024*9);
105.         //1.2临时仓库
106.         File file = new File("c:\\temp");
107.         if(!file.exists()) {
108.             file.mkdir();//创建文件夹
109.         }
110.         factory.setRepository(file);
111.         //2.文件上传+表单数据
112.         ServletFileUpload fileUpload = new ServletFileUpload(factory);
113.         //3.将请求解析为一个个FileItem(文件+表单元素)
114.         List<FileItem> fileItems = fileUpload.parseRequest(req);
115.         //4.遍历FileItem
116.         Book book = new Book();
117.         for(FileItem item : fileItems) {
118.             if(item.isFormField()) {
119.                 //4.1表单：获取表单元素（元素名称与用户填写对应值）
120.                 String name = item.getFieldName();
121.                 String value = item.getString("utf-8");//防止乱码
122.                 switch(name) {
123.                     case "id":
124.                         book.setId(Long.parseLong(value));
125.                         break;
126.                     case "pic":
127.                         book.setPic(value);
128.                         break;
129.                     case "typeId":
130.                         book.setTypeId(Long.parseLong(value));
131.                         break;
132.                     case "name":
133.                         book.setName(value);
134.                         break;
135.                     case "price":
136.                         book.setPrice(Double.parseDouble(value));
137.                         break;
138.                     case "desc":
139.                         book.setDesc(value);
140.                         break;
141.                     case "publish":
142.                         book.setPublish(value);
143.                         break;
144.                     case "author":
145.                         book.setAuthor(value);
146.                         break;
147.                     case "stock":
148.                         book.setStock(Long.parseLong(value));
149.                         break;
150.                     case "address":
151.                         book.setAddress(value);
152.                         break;
153.                 }
154.             }else{
155.                 //4.2文件：图片的文件名,用户不选择图片时，fileName的数据为""
156.                 String fileName = item.getName();
157.                 if(fileName.trim().length() > 0) {
158.                     //避免文件替换（名称重复）来使用：当前系统时间.png
159.                     //4.2.1获取文件后缀名（文件类型）
160.                     String filterName = fileName.substring(fileName.lastIndexOf("."));
161.                     //4.2.1修改文件名 20220312545412245.png
162.                     fileName = DateHelper.getImageName() + filterName;
163.                     //文件上传之后保存到哪里
164.                     // 文件读写需要实际路径：虚拟路径对应的实际路径
165.                     String path = req.getServletContext().getRealPath("/Images/cover");
166.                     String filePath = path + "/" + fileName;
167.                     String dbPath = "Images/cover/" + fileName;
168.                     book.setPic(dbPath);
169.                     //4.3保存文件
170.                     item.write(new File(filePath));
171.                 }
172.             }
173.         }
175.         //5.将信息保存到数据库
176.         int count = bookBiz.modify(book);
177.         if(count > 0) {
178.             out.println("");
179.         }else {
180.             out.println("");
181.         }
182.     }
184.     /**
185.      * 查看图书详情
186.      * /book.let?type=details&id=xx 展示书籍详细信息
187.      * @param req
188.      * @param resp
189.      */
190.     private void details(HttpServletRequest req, HttpServletResponse resp, PrintWriter out) throws ServletException, IOException {
191.         //1.获取图书编号
192.         long id = Long.parseLong(req.getParameter("id"));
193.         //2.根据编号获取图书对象
194.         Book book = bookBiz.getById(id);
195.         //3.将对象保存到request
196.         req.setAttribute("book", book);
197.         //4.请求转发到jsp页面
198.         req.getRequestDispatcher("book_details.jsp").forward(req, resp);
199.     }
201.     /**
202.      * 查询
203.      * /book.let?type=query&pageIndex=1 分页查询-请求转发
204.      * 页数：
205.      * 当前页码：pageIndex=1
206.      * 信息存储：request 使用请求转发从servlet-->jsp
207.      * @param req
208.      * @param resp
209.      */
210.     private void query(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
211.         //1.获取信息：页数，页码，信息
212.         int pageSize = 3;
213.         int pageCount = bookBiz.getPageCount(pageSize);
214.         int pageIndex = Integer.parseInt(req.getParameter("pageIndex"));
215.         if(pageIndex < 1) {
216.             pageIndex = 1;
217.         }
218.         if(pageIndex > pageCount) {
219.             pageIndex = pageCount;
220.         }
221.         List<Book> books = bookBiz.getByPage(pageIndex, pageSize);
223.         //2.存
224.         req.setAttribute("pageCount",pageCount);
225.         req.setAttribute("books", books);
226.         //3.请求转发到jsp
227.         req.getRequestDispatcher("book_list.jsp?pageIndex="+pageIndex).forward(req,resp);
228.     }
230.     /**
231.      * 添加书籍
232.      * 1.multipart/form-data:与之前不同：
233.      * 之前：获取表单元素 req.getParameter()
234.      * 2.文件上传：图片文件从浏览器端保存到服务器端（第三方FileUpload+io）
235.      * 3.路径问题：
236.      *  3.1图片本地路径：实际路径
237.      *  3.2项目发布之后图片路径url：虚拟路径（存在服务器中）
238.      * @param req
239.      * @param resp
240.      * @param out
241.      */
242.     private void add(HttpServletRequest req, HttpServletResponse resp, PrintWriter out) throws Exception {
243.         //1.创建磁盘工厂-临时存储文件磁盘-
244.         DiskFileItemFactory factory = new DiskFileItemFactory();
245.         //1.1设置大小
246.         factory.setSizeThreshold(1024*9);
247.         //1.2临时仓库
248.         File file = new File("c:\\temp");
249.         if(!file.exists()) {
250.             file.mkdir();//创建文件夹
251.         }
252.         factory.setRepository(file);
253.         //2.文件上传+表单数据
254.         ServletFileUpload fileUpload = new ServletFileUpload(factory);
255.         //3.将请求解析为一个个FileItem(文件+表单元素)
256.         List<FileItem> fileItems = fileUpload.parseRequest(req);
257.         //4.遍历FileItem
258.         Book book = new Book();
259.         for(FileItem item : fileItems) {
260.             if(item.isFormField()) {
261.                 //4.1表单：获取表单元素（元素名称与用户填写对应值）
262.                 String name = item.getFieldName();
263.                 String value = item.getString("utf-8");//防止乱码
264.                 switch(name) {
265.                     case "typeId":
266.                         book.setTypeId(Long.parseLong(value));
267.                         break;
268.                     case "name":
269.                         book.setName(value);
270.                         break;
271.                     case "price":
272.                         book.setPrice(Double.parseDouble(value));
273.                         break;
274.                     case "desc":
275.                         book.setDesc(value);
276.                         break;
277.                     case "publish":
278.                         book.setPublish(value);
279.                         break;
280.                     case "author":
281.                         book.setAuthor(value);
282.                         break;
283.                     case "stock":
284.                         book.setStock(Long.parseLong(value));
285.                         break;
286.                     case "address":
287.                         book.setAddress(value);
288.                         break;
289.                 }
290.             }else{
291.                 //4.2文件：图片的文件名
292.                 String fileName = item.getName();
293.                 //避免文件替换（名称重复）来使用：当前系统时间.png
294.                 //4.2.1获取文件后缀名（文件类型）
295.                 String filterName = fileName.substring(fileName.lastIndexOf("."));
296.                 //4.2.1修改文件名 20220312545412245.png
297.                 fileName = DateHelper.getImageName() + filterName;
298.                 //文件上传之后保存到哪里
299.                 // 文件读写需要实际路径：虚拟路径对应的实际路径
300.                 String path = req.getServletContext().getRealPath("/Images/cover");
301.                 String filePath = path + "/" + fileName;
302.                 String dbPath = "Images/cover/" + fileName;
303.                 book.setPic(dbPath);
304.                 //4.3保存文件
305.                 item.write(new File(filePath));
306.             }
307.         }
309.         //5.将信息保存到数据库
310.         int count = bookBiz.add(book);
311.         if(count > 0) {
312.             out.println("");
313.         }else {
314.             out.println("");
315.         }
316.     }
317. }

复制代码

书籍的biz层

1. public class BookBiz {
2.     //BookDao对象
3.     BookDao bookDao = new BookDao();
5.     /**
6.      * 根据类型编号获得书籍
7.      * @param typeId
8.      * @return
9.      */
10.     public List<Book> getBooksByTypeId(long typeId) {
11.         try {
12.             return bookDao.getBooksByTypeId(typeId);
13.         } catch (SQLException throwables) {
14.             throwables.printStackTrace();
15.             return null;
16.         }
17.     }
19.     /**
20.      * 根据书籍信息来添加书本
21.      * @param typeId
22.      * @param name
23.      * @param price
24.      * @param desc
25.      * @param pic
26.      * @param publish
27.      * @param author
28.      * @param stock
29.      * @param address
30.      * @return
31.      */
32.     public int add(long typeId, String name, Double price, String desc, String pic, String publish, String author, long stock, String address) {
33.         int count = 0;
34.         try {
35.             count = bookDao.add(typeId, name, price, desc, pic, publish, author, stock, address);
36.         } catch (SQLException throwables) {
37.             throwables.printStackTrace();
38.         }
39.         return count;
40.     }
42.     /**
43.      * 如果用户使用对象的方式来添加书籍
44.      * @param book
45.      * @return
46.      */
47.     public int add(Book book) {
48.         return add(book.getTypeId(), book.getName(), book.getPrice(), book.getDesc(), book.getPic(), book.getPublish(), book.getAuthor(), book.getStock(), book.getAddress());
49.     }
50.     public int modify(Book book) {
51.         return modify(book.getId(),book.getTypeId(), book.getName(), book.getPrice(), book.getDesc(), book.getPic(), book.getPublish(), book.getAuthor(), book.getStock(), book.getAddress());
52.     }
53.     public int modify(long id, long typeId, String name, Double price, String desc, String pic, String publish, String author, long stock, String address) {
54.         int count = 0;
55.         try {
56.             count = bookDao.modify(id, typeId, name, price, desc, pic, publish, author, stock, address);
57.         } catch (SQLException throwables) {
58.             throwables.printStackTrace();
59.         }
60.         return count;
61.     }
62.     public int remove(long id) throws Exception {
63.         //1.判断id是否存在外键，存在无法删除
64.         RecordDao recordDao = new RecordDao();
65.         //2.删除
66.         int count = 0;
67.         try {
68.             List<Record> records = recordDao.getRecordByBookId(id);
69.             if(records.size() > 0) {
70.                 throw new Exception("删除的书籍有子信息，删除失败");
71.             }
72.             count = bookDao.remove(id);
73.         } catch (SQLException throwables) {
74.             throwables.printStackTrace();
75.         }
76.         return count;
77.     }
79.     /**
80.      * 12:03
81.      * @param pageIndex
82.      * @param pageSize
83.      * @return
84.      */
85.     public List<Book> getByPage(int pageIndex, int pageSize) {
86.         TypeDao typeDao = new TypeDao();
87.         List<Book> books = null;
88.         try {
89.             books = bookDao.getByPage(pageIndex, pageSize);
90.             //处理type对象的数据问题
91.             for(Book book : books) {
92.                 long typeId = book.getTypeId();
93.                 //根据typeId来寻找对应的type
94.                 Type type = typeDao.getById(typeId);
95.                 //设置type属性
96.                 book.setType(type);
97.             }
98.         } catch (SQLException throwables) {
99.             throwables.printStackTrace();
100.         }
101.         return books;
102.     }
103.     public Book getByName(String bookName) {
104.         Book book = null;
105.         try {
106.             book = bookDao.getByName(bookName);
107.         } catch (SQLException throwables) {
108.             throwables.printStackTrace();
109.         }
110.         return book;
111.     }
112.     public Book getById(long id) {
113.         Book book = null;
114.         TypeDao typeDao = new TypeDao();
115.         try {
116.             book = bookDao.getById(id);
117.             long TypeId =  book.getTypeId();
118.             Type type = typeDao.getById(TypeId);
119.             book.setType(type);
120.         } catch (SQLException throwables) {
121.             throwables.printStackTrace();
122.         }
123.         return book;
124.     }
126.     /**
127.      * 由行数算页数
128.      * @return
129.      */
130.     public int getPageCount(int pageSize) {
131.         int pagecount = 0;
132.         try {
133.             //1.获取行数
134.             int rowcount = bookDao.getCount();
135.             //2.根据行数得到页数-，每页多少条
136.             pagecount = (rowcount - 1) / pageSize + 1;
137.         } catch (SQLException throwables) {
138.             throwables.printStackTrace();
139.         }
140.         return pagecount;
141.     }
142. }

复制代码

书籍的dao层

1. public class BookDao {
2.     QueryRunner runner = new QueryRunner();
4.     /**
5.      * 根据类型查询对应的书籍信息
6.      *
7.      * @param typeId
8.      * @return
9.      * @throws SQLException
10.      */
11.     public List<Book> getBooksByTypeId(long typeId) throws SQLException {
12.         Connection conn = DBHelper.getConnection();
13.         String sql = "select * from book where typeId = ?";
14.         List<Book> books = runner.query(conn, sql, new BeanListHandler<Book>(Book.class), typeId);
15.         DBHelper.close(conn);
16.         return books;
17.     }
19.     /**
20.      * 添加
21.      *
22.      * @return
23.      */
24.     public int add(long typeId, String name, Double price, String desc, String pic, String publish, String author, long stock, String address) throws SQLException {
25.         Connection conn = DBHelper.getConnection();
26.         String sql = "insert into book(typeId,`name`,price,`desc`,pic,publish,author,stock,address) values(?,?,?,?,?,?,?,?,?)";
27.         int count = runner.update(conn, sql, typeId, name, price, desc, pic, publish, author, stock, address);
28.         DBHelper.close(conn);
29.         return count;
30.     }
32.     public int modify(long id, long typeId, String name, Double price, String desc, String pic, String publish, String author, long stock, String address) throws SQLException {
33.         Connection conn = DBHelper.getConnection();
34.         String sql = "update book set typeId=?,`name`=?,price=?,`desc`=?,pic=?,publish=?,author=?,stock=?,address=? where id=?";
35.         int count = runner.update(conn, sql, typeId, name, price, desc, pic, publish, author, stock, address, id);
36.         DBHelper.close(conn);
37.         return count;
38.     }
40.     public int remove(long id) throws SQLException {
41.         Connection conn = DBHelper.getConnection();
42.         String sql = "delete from book where id = ?";
43.         int count = runner.update(conn, sql, id);
44.         DBHelper.close(conn);
45.         return count;
46.     }
48.     /**
49.      * 分页查询
50.      * @param pageIndex 第几页开始
51.      * @param pageSize 每一页有多少行
52.      * @return 当前页信息
53.      * @throws SQLException
54.      */
55.     public List<Book> getByPage(int pageIndex, int pageSize) throws SQLException {
56.         Connection conn = DBHelper.getConnection();
57.         String sql = "select * from book limit ?,?";
58.         int offset = (pageIndex - 1) * pageSize;
59.         List<Book> books= runner.query(conn, sql, new BeanListHandler<Book>(Book.class), offset, pageSize);
60.         DBHelper.close(conn);
61.         return books;
62.     }
64.     public Book getById(long id) throws SQLException {
65.         Connection conn = DBHelper.getConnection();
66.         String sql = "select * from book where id = ?";
67.         Book book = runner.query(conn, sql, new BeanHandler<Book>(Book.class), id);
68.         DBHelper.close(conn);
69.         return book;
70.     }
72.     /**
73.      * 根据书籍名字查Book对象
74.      * @param bookName
75.      * @return
76.      * @throws SQLException
77.      */
78.     public Book getByName(String bookName) throws SQLException {
79.         Connection conn = DBHelper.getConnection();
80.         String sql = "select * from book where name = ?";
81.         Book book = runner.query(conn, sql, new BeanHandler<Book>(Book.class), bookName);
82.         DBHelper.close(conn);
83.         return book;
84.     }
86.     /**
87.      * 获取书籍数量
88.      * @return
89.      * @throws SQLException
90.      */
91.     public int getCount() throws SQLException {
92.         Connection conn = DBHelper.getConnection();
93.         String sql = "select count(id) from book";
94.         Object data = runner.query(conn, sql, new ScalarHandler<>());
95.         int count = (int)(long)data;
96.         return count;
97.     }
99.     /**
100.      * 修改书籍数量
101.      * @param id
102.      * @param amount 大于0，加一本---小于0，减一本
103.      * @return
104.      * @throws SQLException
105.      */
106.     public int modify(long id, int amount) throws SQLException {
107.         Connection conn = DBHelper.getConnection();
108.         String sql = "update book set stock=stock + ? where id=?";
109.         int count = runner.update(conn, sql,amount, id);
110.         DBHelper.close(conn);
111.         return count;
112.     }
114.     public static void main(String[] args) {
115.         try {
116.             Book book = new BookDao().getById(2);
117.             System.out.println(book);
118.         } catch (SQLException throwables) {
119.             throwables.printStackTrace();
120.         }
121.     }
122. }
124. /**
125. * dao层只负责与数据库相关的基本工作
126. * biz层负责业务的事情
127. */

复制代码

总结

由于源码太多了，无法全部发出来，我已经把它上传了大家可以下载用来学习。
下载地址：图书管理系统
大家对源码有什么疑问也可以私聊我,我帮你解决！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！