基于Java Web的图书管理系统

àì夳堔傛蜴生んèń 2023-09-28 11:52 158阅读 0赞

##  ##

**目录**

1.系统简要概述

2.系统主要用到的数据库表

3.主要功能

管理员：

用户：

3.1管理员功能

3.11登录

3.12添加学生

3.13查看学生

3.14删除学生

3.15添加书籍

3.16查看书籍

3.2用户端功能

3.2.1登录

3.2.2注册

3.2.3查询图书

3.2.4借阅书籍

3.2.5借阅信息查询

3.2.6还书

3.2.7我的基本信息

4.代码部分

4.1 dao类

adminDao

BookDao

BorrowDao

studentDao

4.2 Servlet类

userlojinServlet

adminlojinServlet

managebookservlet

managestudentservlet

4.3javaBean类

admin

student

book

4.4filter（过滤器类）

loginfilter

characterfilter

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

## 1.系统简要概述 ##

所用的思想是在MVC模式下进行开发，主要涉及到的内容有：JSP、javaBean、Servlet、JDBC、以及前端css、js，从具体实施来看主要涉及到的知识有：对jsp主要内置对象的熟练使用。例如，request请求、response响应、session会话、以及利用cookie来进行免登录，EL表达式，JSTL标签,Filter过滤器，Listener监视器，前端的灵活使用等。

## 2.系统主要用到的数据库表 ##

**admins(****管理员****)****表****管理员相关信息**

![c6c2a29f09be4f1f937c210f25b5a95a.png][]

**Books(****图书****)****表****记录图书相关信息**

![95e9dcbd354441e1a633416142c3127e.png][]

**Students****（学生）表****记录学生相关信息**

![8329c2c845be4f939c99ca92e145215d.png][]

**Borrows(****借书****)****表****记录借阅相关信息**

![6b46d8ad70a945a7913bd1f14f49568c.png][]

## 3.主要功能 ##

此次系统分为两个板块，管理员和用户。管理员主要进行用户和图书的增删改查，用户则进行借还操作。

下面简述两者主要功能及实现方法，具体可见后文详解。

#### **管理员**： ####

**增加学生、删除学生、查看学生、添加图书、修改图书、删除图书、查看图书**

对学生的增删查，主要是在ManageStudent.Servlet里面进行。另外有专门处理学生的数据库类Student.Dao,首先增加和查看功能，直接利用前端提交的post请求，通过method字段在servlet里执行相对应的方法，将结果最终呈现在jsp页面中。至于删除的功能则是利用前端提交的get请求，将学生信息绑定在服务器前台,在后端通过request获取到相应数据，执行删除的方法。

对图书的增删改查类似以上机制，主要是在ManageBook.Servlet里面进行。同理也有Book.Dao,增删基本同添加学生一致。查看这里涉及到分页查看的机制，分页查看利用limit限制条件，对每次浏览的记录分条处理。通过后端每次传输的页值，将结果存储到session会话中，在jsp页面里，通过获取存储的对象输出到浏览器中。至于修改同查看一样，只不过这里，要将原先数据存到文本框内，需要通过get请求，将绑定的数据存储到会话中，然后重定向要修改的页面，中间借用EL表达式比较简洁。

#### **用户：** ####

**查看图书、借书、借阅信息查看、还书、查看个人信息**

当用户登录成功后，在左边功能框可查看所有图书信息，也可以查看具体类别的图书，这里主要是在userchoise.Servlet里面执行，当用户点击具体某类图书时，会将图书类别传输到服务器端，在servlet里面通过request获取类别，然后调用Book.Dao里面的方法将结果进行封装，在show.jsp页面里通过获取图书对象进行显示。每条图书信息后面附有借书操作功能，主要在Borrow.servlet里面进行，通过get机制将用户信息和图书信息上传到服务器，在servlet里面获取，然后利用Bean来声名对象，对借阅书籍进行更改，同时通过调用borrow.Dao，对图书信息数量进一步修改。

借阅信息的查看可直接在相应jsp里面，根据用户信息调用相应的Dao方法，来获取借阅书籍信息显示当浏览器上。在借阅信息里面可对图书进行归还操作，主要使用return.Servlet，在前端通过get机制，将学生信息和书籍信息上传到服务器端。在后端通过request获取，然后借用borrow.Dao，里面的方法对书籍数量进一步修改。查看个人信息比较见到，直接通过session会话，将事先绑定好的用户信息，直接读取，显示在相应页面中。

### 3.1管理员功能 ###

管理员主要管理学生和图书，在其项目里面有managestudent.servlet和managebook.servlet两个主要的servlet类。通过前端提供不同的请求来响应对应servlet里面的方法。

#### 3.11登录 ####

首先是管理员需要登录验证，判断数据库中是否有管理员账号相关信息。此次开发中，管理员账号为事先在数据库中录入，不支持注册和记住密码。管理员登录，需要请求adminlogin.servlet处理登录信息，如下（账号：admin 密码：admin）：

![dc6466823b5147bc945ae8ce2b4c8624.png][]

图1- 1 管理员登录页面

若输入错误密码，则会提示密码错误重新登录（账号：admin 密码：123456）：

![b48af1bb6ae94b9e946489f39f201847.png][]

图1- 2 管理员登录错误页面

#### 3.12添加学生 ####

添加学生功能，主要涉及到 student.dao（主要对学生进行数据库操纵，jdbc代码），student.bean(封装保存学生的基本信息)，managestudent.servlet(用来后端操作控制添加学生信息的功能)以及addstusent.jsp（添加学生信息的前端页面）。添加信息的时候注意每项信息不能为空、以及添加的学生信息原数据库中是否有信息等需要在servlet里面做出判断。核心就是student.dao里面的连接数据库操纵语言，以及managestudent.servlet里面的对信息进行控制封装。如下：

![1da1465cd9e64547b29f48819ffdb33e.png][]

图1-3 addstudent.jsp

#### 3.13查看学生 ####

查看学生功能是将数据库中的所有学生信息，展现在前端页面。这里主要涉及到studentDao、managestudent.servlet、student.javabean、showstudent.jsp等，在这里另外增加了一个分页查看的功能，主要思想就是在数据库里查询的时候将其分割，limit（beginpage，pagesize），然后通过查询的所有记录count/pagesize，得出总共的页数,然后在pageservlet里面，整理，最后输出到前端页面。

![d612b1149b424607a9f6da3978e4c2ff.png][]

#### 3.14删除学生 ####

管理员可以删除选中的学生，主要是利用前端绑定的机制，在get模式下，绑定用户的信息，通过前端传入的值，在后端进行相应的处理，在数据库中进行删除学生。所涉及到的类和前面几乎一致，不再重述。

![0e6fcec9ccf54b00b5fe868a9413c288.png][]

#### 3.15添加书籍 ####

添加书籍类似添加学生，book.javabean（存有图书信息），managebook.Servlet(图书管理的servlet)，以及对应的jsp页面.

![17fb201582b546cdb1fbfc60c1721907.png][]

#### 3.16查看书籍 ####

管理员可查看所有图书信息。

![9f9ece0b40fc48c88c00fc38e24845e0.png][]

在show\_book.jsp里面同时包含修改和删除图书的功能。两个方法对应不同的链接，跳转到相应的servlet中，在处理更改的时候需要用到重定向方法，将原先存到session中的数据，重定向到一个页面进行修改，同时该页面，要保留原有的信息，可以使用EL表达式来进行处理。

![2a021f22229c434c9d33608a6913af29.png][]

### 3.2用户端功能 ###

#### 3.2.1登录 ####

用户登录页面同管理员登录页面一致，且在同一个jsp里，分两个form表单完成。在用户登录界面增加了注册、和记住密码的功能。首先看登录功能，用户输入账号和密码，前端将数据提交到后端的userloginServlet来进行处理，通过后端的处理与数据库中的结果作比较。验证登录是否成功，下图为登录成功界面。

在用户进行登录的时候有一个复选框，为记住密码的操作。当用户点击记住密码的时候，下次登录不用在输入账号密码，直接点击登录即可。这是利用cookie的机制，通过创建cookie，将账号信息保存到硬盘中。此次系统设计的cookie时间为三天。具体效果如下:

![07dc374ae6af450fbc0c3ead3021395d.png][]

![adb5b82ceba54a3d9533700b3eb7e73b.png][]

![7ef1602dda8140da85d4712e93b05d74.png][]

![b100d4d1f2ea4528a65a1a287dc00198.png][]

#### 3.2.2注册 ####

注册功能同管理员添加学生一致，只不过这个注册会跳转到userloginsrvlet里面进行处理。结合数据库往里边添加数据，同时也会对，信息是否填写完整，以及原有数据库里面是否有数据做出判断。

![22ac1d8dd4a2411f98aae80ceaed5f3d.png][]

#### 3.2.3查询图书 ####

等用户登录成功后，即可看到左面功能栏里面的功能，最上面的就是查看所有图书功能，接下来的一系列则是根据图书类别进行查看图书，方便用户浏览，快速查找结果。里面的一些显示功能主要是，利用超链接的target，来将查询的结果输出到，showBook.jsp页面上。

![76b1d590c60445898c09508e40368de4.png][]

![f8e3115ad9c246a6b92bfc725cae906b.png][]

#### 3.2.4借阅书籍 ####

每个书籍后面附有借书操作的功能，借阅实现的方法主要是，利用前端绑定机制，将用户的信息，和图书信息整合到一块，后端来进行获取。

当borrowservlet，接收到用户信息和图书信息后，通过studentBean,bookBean以及borrowBean，来对借阅功能进行封装处理，这时需要borrowdao来进行数据库的读写操作。

在这里设置每位用户最大借阅量为10本，所以在servlet里面，做出判断借阅量是否大于最大借阅书籍量。来响应用户是否还能继续借阅。若能借阅的话，则通过后台，处理Bean数据，用户借阅量发生变化，图书量也发生变化。

![07dbea35d3734b08bdd4c73de005f2c0.png][]

#### 3.2.5借阅信息查询 ####

借阅信息查询这个页面中，可以显示所有借的图书信息，并且在这个页面附有还书的功能，借阅信息主要是利用BorrowServlet和BorrowDAO里面根据用户信息，来获取当前用户下共计的借阅量。

![9b119e8ea0e84fd488f0f595448d404b.png][]

#### 3.2.6还书 ####

还书对应的则是returnservlet,根据用户信息，以及图书信息，来做出合理的判断，在通过BorrowDao,里面的数据库操作对借书量，图书量数据上做出相应的改变。

![7624642dec674f5db29c5f8c2f50e8cf.png][]

#### 3.2.7我的基本信息 ####

在我的基本信息里面可以查看除密码以外的所有信息，包括当前借阅量，可借图书量等。具体实施为通过后台数据库将个人信息展现到页面上。

![a49061d7a51f48b491c239ac34d5d826.png][]

## 4.代码部分 ##

### 4.1 dao类 ###

#### adminDao ####

package com.demo.dao;
    import com.demo.javabean.*;
    import java.sql.SQLException;
    
    public class AdminDAO {
    	DBAccess db ;
    	public boolean valid(String username, String password) {
    		boolean isValid = false;
    		db=new DBAccess();
    		if(db.createConn()) {
    			try {
    				String sql="select * from admins where admin=? and password=?";
    				db.pre=db.getConn().prepareStatement(sql);
    				db.pre.setString(1, username);
    				db.pre.setString(2, password);
    				db.setRs(db.pre.executeQuery());
    				if(db.getRs().next()){
    					isValid=true;
    				}
    			}catch (Exception e) {
    				// TODO: handle exception
    			}finally {
    				db.closeRs();
    				try {
    					db.pre.close();
    				} catch (SQLException e) {
    					// TODO 自动生成的 catch 块
    					e.printStackTrace();
    				}
    				db.closeConn();
    			}
    		}
    		return isValid ;
    	}
    	public boolean isExist(String username) {
    		boolean isExist = false;
    		db = new DBAccess();
    		if(db.createConn()) {
    			try {
    				String sql="select * from admins where admin=?";
    				db.pre=db.getConn().prepareStatement(sql);
    				db.pre.setString(1,username );
    				db.setRs(db.pre.executeQuery());
    				if(db.getRs().next()){
    					isExist=true;
    				}
    			} catch (Exception e) {
    				// TODO: handle exception
    			}
    			finally {
    				db.closeRs();
    				if(db.pre!=null){
    					try {
    						db.pre.close();
    					} catch (Exception e2) {
    						// TODO: handle exception
    					}
    				}
    				db.closeConn();
    			}
    		}
    		return isExist;
    	}
    }

#### BookDao ####

package com.demo.dao;
    import com.demo.javabean.*;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    
    
    public class BookDAO  {
    	DBAccess db;
    	private Books book;
    	public ArrayList<Books> getAllBooks() throws Exception{
    		db=new DBAccess();
    
    		//db.setSql("SELECT * FROM books");
    		ArrayList<Books> books = new ArrayList<Books>();
    
    		if(db.createConn()){
    			//db.query(sql);
    			String sql= "SELECT * FROM books";
    			db.query(sql);
    
    
    			while(db.getRs().next()){
    				book = this.assemble(db.getRs());
    				books.add(book);
    			}
    		}
    		db.closeRs();
    		db.closeStm();
    		db.closeConn();
    		return books;
    	}
    
    
    	public ArrayList<Books> getBooksByCategory(String category) throws Exception{//在这里进行分页判断
    
    		ArrayList<Books> books = new ArrayList<Books>();
    		DBAccess db=new DBAccess();
    		java.sql.PreparedStatement pre = null;
    		if(db.createConn()){
    			//db.query(sql);
    			String sql = "select * from books where category = ? ";
    			pre=db.getConn().prepareStatement(sql);
    			pre.setString(1, category);
    			//pre.setInt(2, (page-1)*Students.PAGE_SIZE);
    			//pre.setInt(3, Students.PAGE_SIZE);
    			db.setRs(pre.executeQuery());
    			while(db.getRs().next()){
    				book = this.assemble(db.getRs());
    				books.add(book);
    			}
    		}
    		db.closeRs();
    		db.closeStm();
    		pre.close();
    		db.closeConn();
    		int a=books.size();
    		System.out.println(a);
    		return books;
    	}
    
    
    	public void addBook(String name,String author,String intro,String amount,String category) throws Exception{
    		// boolean flag = false;
    		DBAccess db = new DBAccess();
    		if(db.createConn()){
    			String sql = "insert into books(name,author,intro,amount,category) values('"+name+"','"+author+"','"+intro+"','"+amount+"','"+category+"')";
    			db.update(sql);
    			db.closeStm();
    			db.closeConn();
    		}
    	}
    	public boolean delbook(String name)throws Exception{//删除书籍
    		DBAccess db = new DBAccess();
    		boolean flag=false;
    		if(db.createConn()){
    			//db.setSql("delete from books where name = ?");
    			String sql="delete from books where name = ?";
    			db.pre=db.getConn().prepareStatement(sql);
    			db.pre.setString(1, name);
    			if(db.pre.executeUpdate()>0)flag=true;
    			//String sql = "delete from books where name = '"+name+"'";
    			//db.update(sql);
    			//db.closeStm();
    			//db.closeConn();
    		}
    		db.closeRs();
    		db.closeStm();
    		db.pre.close();
    		db.closeConn();
    		return flag;
    	}
    	public boolean isExist(String name) {
    		boolean isExist = false;
    		DBAccess db = new DBAccess();
    		if(db.createConn()) {
    			String sql = "select * from books where name='"+name+"'";
    			db.query(sql);
    			if(db.next()) {
    				isExist = true;
    			}
    			db.closeRs();
    			db.closeStm();
    			db.closeConn();
    		}
    		return isExist;
    	}
    
    
    
    
    	public boolean updateBook(Books book) throws Exception{//借还更新 主要书籍数量
    		boolean flag = false;
    		DBAccess db=new DBAccess();
    		String sql = "UPDATE books SET amount=? WHERE id=?";
    		java.sql.PreparedStatement pre=null;
    		if(db.createConn()){
    			pre=db.getConn().prepareStatement(sql);
    
    			//conn = OpenConnection.getConnection();
    			// ps = conn.prepareStatement(sql_str);
    
    			pre.setInt(1,book.getAmount());
    			pre.setInt(2,book.getId());
    
    			if(pre.executeUpdate() > 0) flag = true;
    		}
    		db.closeRs();
    		db.closeStm();
    		pre.close();
    		db.closeConn();
    		// this.release();
    		// OpenConnection.closeConnection(conn);
    
    		return flag;
    	}
    	public boolean updateBook2(Books book) throws Exception{//修改更新 修改图书信息
    		boolean flag = false;
    		DBAccess db=new DBAccess();
    		//db.setSql("UPDATE books SET name=?,author=?,amount=?,category=? where id=?");
    
    		if(db.createConn()){
    			String sql="UPDATE books SET name=?,author=?,amount=?,category=? where id=?";
    			db.pre=db.getConn().prepareStatement(sql);
    			db.pre.setString(1, book.getName());
    			db.pre.setString(2, book.getAuthor());
    			db.pre.setInt(3, book.getAmount());
    			db.pre.setString(4, book.getCategory());
    			db.pre.setInt(5, book.getId());
    			if(db.pre.executeUpdate() > 0) flag = true;
    		}
    		db.closeRs();
    		db.closeStm();
    		db.pre.close();
    		db.closeConn();
    		return flag;
    	}
    
    
    
    	public Books getBookById(int id) throws Exception{
    		DBAccess db=new DBAccess();
    		String sql = "SELECT * FROM books WHERE id = ?";
    		java.sql.PreparedStatement pre=null;
    		if(db.createConn()){
    			pre=db.getConn().prepareStatement(sql);
    
    			// conn = OpenConnection.getConnection();
    			// ps = conn.prepareStatement(sql_str);
    			pre.setInt(1,id);
    			db.setRs(pre.executeQuery());
    
    			if (db.getRs().next()) book = this.assemble(db.getRs());
    		}
    		db.closeRs();
    		db.closeStm();
    		pre.close();
    		db.closeConn();
    		//this.release();
    		// OpenConnection.closeConnection(conn);
    		return book;
    
    	}
    
    
    	public Books assemble(ResultSet rs) throws Exception{
    		book = new Books();
    		book.setId(rs.getInt("id"));
    		book.setName(rs.getString("name"));
    		book.setAuthor(rs.getString("author"));
    		book.setIntro(rs.getString("intro"));
    		book.setAmount(rs.getInt("amount"));
    		book.setCategory(rs.getString("category"));
    		return book;
    	}
    	public ArrayList<Books> findAll(Integer page){//分页查询信息
    		DBAccess  db=new DBAccess();
    		ArrayList<Books> list=new ArrayList<Books>();
    		try {
    			if(db.createConn()){
    				String sql="select  * from books limit ?,? ";
    				db.pre=db.getConn().prepareStatement(sql);
    				db.pre.setInt(1, (page-1)*Students.PAGE_SIZE);
    				db.pre.setInt(2, Students.PAGE_SIZE);
    				db.setRs(db.pre.executeQuery());
    				while(db.getRs().next()){
    					Books book=new Books();
    					book.setId(db.getRs().getInt("id"));
    					book.setName(db.getRs().getString("name"));
    					book.setAuthor(db.getRs().getString("author"));
    					book.setCategory(db.getRs().getString("category"));
    					book.setAmount(db.getRs().getInt("amount"));
    					list.add(book);
    				}
    				db.closeRs();
    				db.pre.close();
    				db.closeConn();
    			}
    		} catch( SQLException e) {
    			e.printStackTrace();
    		}
    		return list;
    	}
    	public ArrayList<Books> getBooksByCategory(String category,Integer page) throws Exception{//在这里进行分页判断(学生端)
    
    		ArrayList<Books> books = new ArrayList<Books>();
    		DBAccess db=new DBAccess();
    		java.sql.PreparedStatement pre = null;
    		if(db.createConn()){
    			//db.query(sql);
    			String sql = "select * from books where category = ? limit ?,?";
    			pre=db.getConn().prepareStatement(sql);
    			pre.setString(1, category);
    			pre.setInt(2, (page-1)*Students.PAGE_SIZE);
    			pre.setInt(3, Students.PAGE_SIZE);
    			db.setRs(pre.executeQuery());
    			while(db.getRs().next()){
    				book = this.assemble(db.getRs());
    				books.add(book);
    			}
    		}
    		db.closeRs();
    		db.closeStm();
    		pre.close();
    		db.closeConn();
    		int a=books.size();
    		System.out.println(a);
    		return books;
    	}
    	public int countPage(String singal){//查询记录总数
    		DBAccess  db=new DBAccess();
    		int count=0;
    		try {
    			if(db.createConn()){
    				String sql;
    				if(!"1".equals(singal)){
    					sql="select count(*) from books where category=?";
    					db.pre=db.getConn().prepareStatement(sql);
    					db.pre.setString(1, singal);
    					db.setRs(db.pre.executeQuery());
    				}
    				else {
    					sql="select count(*) from books";
    					db.pre=db.getConn().prepareStatement(sql);
    					db.setRs(db.pre.executeQuery());
    				}
    				if(db.getRs().next()){
    					count=db.getRs().getInt(1);
    				}
    			}
    		} catch( SQLException e) {
    			e.printStackTrace();
    		}
    		finally {
    			db.closeRs();
    			try {
    				if(db.pre!=null){
    					db.pre.close();
    				}
    			} catch (Exception e2) {
    				// TODO: handle exception
    			}
    			db.closeConn();
    		}
    		return count;
    	}
    }

#### BorrowDao ####

package com.demo.dao;
    
    import com.demo.javabean.*;
    
    import java.sql.ResultSet;
    import java.util.ArrayList;
    
    import com.demo.javabean.DBAccess;
    
    public class BorrowDAO  {
    
        private Borrows borrow = null;
        public ArrayList<Borrows> getAllBorrows() throws Exception{
        DBAccess db=new DBAccess();
        java.sql.PreparedStatement pre=null;
           String sql = "SELECT * FROM borrows";
            ArrayList<Borrows> borrows = new ArrayList<Borrows>();
            //conn = OpenConnection.getConnection();
           // ps = conn.prepareStatement(sql_str);
            //rs = ps.executeQuery();
    if(db.createConn()){
    	pre=db.getConn().prepareStatement(sql);
    	db.setRs(pre.executeQuery());
    	//db.query(sql);
            while(db.getRs().next()) {
                borrow = this.assemble(db.getRs());
                borrows.add(borrow);
            }
    }
    
            //this.release();
    db.closeRs();
    db.closeStm();
    db.closeConn();
           // OpenConnection.closeConnection(conn);
            return borrows;
        }
    
    
        public ArrayList<Borrows> getBorrowsBySId(int s_id) throws Exception{
            ArrayList<Borrows> borrows = new ArrayList<Borrows>();
            DBAccess db=new DBAccess();
            java.sql.PreparedStatement pre=null;
           String sql = "SELECT * FROM borrows WHERE s_id = ?";
           if(db.createConn()){
        	   pre=db.getConn().prepareStatement(sql);
        	   pre.setInt(1, s_id);
        	   db.setRs(pre.executeQuery());
            while (db.getRs().next()){
                borrow = this.assemble(db.getRs());
                borrows.add(borrow);
            }
           }
           db.closeRs();
           db.closeStm();
           pre.close();
           db.closeConn();
            return borrows;
        }
    
    
        public boolean addBorrows(Borrows borrow) throws Exception{
            boolean flag = false;
            DBAccess db=new DBAccess();
            java.sql.PreparedStatement pre=null;
            String sql = "INSERT INTO borrows VALUES(?,?,?)";
            if(db.createConn()){
            pre=db.getConn().prepareStatement(sql);
            
           // conn = OpenConnection.getConnection();
           // ps = conn.prepareStatement(sql_str);
            pre.setInt(1,borrow.getS_id());
            pre.setInt(2,borrow.getB_id());
            pre.setInt(3,borrow.getAmount());
            if(pre.executeUpdate() > 0)  flag = true;
            }
            //this.release();
            db.closeRs();
            pre.close();
            db.closeConn();
            //OpenConnection.closeConnection(conn);
    
            return flag;
    
        }
    
    
        public boolean deleteBorrow(Borrows borrow) throws Exception{
            boolean flag = false;
            DBAccess db=new DBAccess();
            java.sql.PreparedStatement pre=null;
            String sql = "DELETE FROM borrows WHERE s_id = ? AND b_id = ? AND amount = ?";
            if(db.createConn()){
            pre=db.getConn().prepareStatement(sql);
            
            	
            //conn = OpenConnection.getConnection();
            //ps =conn.prepareStatement(sql_str);
    
            pre.setInt(1,borrow.getS_id());
            pre.setInt(2,borrow.getB_id());
            pre.setInt(3,borrow.getAmount());
            if(pre.executeUpdate() > 0) flag = true;
            }
            return flag;
        }
    
    
    
        public Borrows getBorrowById(int s_id, int b_id) throws Exception{
        	DBAccess db=new DBAccess();
            String sql = "SELECT * FROM borrows WHERE s_id = ? AND b_id = ?";
            java.sql.PreparedStatement pre=null;
            if(db.createConn()){
            pre=db.getConn().prepareStatement(sql);
            
    
            //conn = OpenConnection.getConnection();
            //ps = conn.prepareStatement(sql_str);
            pre.setInt(1,s_id);
            pre.setInt(2,b_id);
    
            //rs = ps.executeQuery();
            db.setRs(pre.executeQuery());
            if(db.getRs().next()) borrow = this.assemble(db.getRs());
            }
            db.closeRs();
            db.closeStm();
            pre.close();
            db.closeConn();
           // this.release();
           // OpenConnection.closeConnection(conn);
            return borrow;
    
    
        }
    
    
       public boolean updateBorrow(Borrows borrow) throws  Exception{
            boolean flag = false;
            DBAccess db=new DBAccess();
            String sql = "UPDATE borrows SET amount = ? WHERE s_id = ? AND b_id = ?";
            java.sql.PreparedStatement pre=null;
            if(db.createConn()){
            pre=db.getConn().prepareStatement(sql);
            
            //conn = OpenConnection.getConnection();
           // ps = conn.prepareStatement(sql_str);
            pre.setInt(1,borrow.getAmount());
            pre.setInt(2,borrow.getS_id());
            pre.setInt(3,borrow.getB_id());
    
            if(pre.executeUpdate() > 0) flag = true;
            }
            db.closeRs();
            db.closeStm();
            pre.close();
            db.closeConn();
            //this.release();
            //OpenConnection.closeConnection(conn);
    
            return flag;
        }
    
    
    
        public Borrows assemble(ResultSet rs) throws Exception{
            borrow = new Borrows();
    
            borrow.setS_id(rs.getInt("s_id"));
            borrow.setB_id(rs.getInt("b_id"));
            borrow.setAmount(rs.getInt("amount"));
    
            return borrow;
        }
    
    }

#### studentDao ####

package com.demo.dao;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import com.demo.javabean.*;
    
    /**
    *@author:FQX
    *@version：2022年3月28日下午7:43:34
    *类说明
    */
    public class StudentDAO {
    	DBAccess db;
    	public boolean valid(String username, String password) {
    		boolean isValid = false;
    		//DBAccess db = new DBAccess();
    		db = new DBAccess();
    		if(db.createConn()) {
    			//String sql = "select * from students where user='"+username+"' and password='"+password+"'";
    			//db.setSql("select * from students where user='"+username+"' and password='"+password+"'");
    			String sql="select * from students where user= ? and password= ?";
    			try {											//这里引用prepareStatement是为了防止SQL注入
    				db.pre=db.getConn().prepareStatement(sql);
    				db.pre.setString(1, username);
    				db.pre.setString(2, password);
    				db.setRs(db.pre.executeQuery());
    				if(db.getRs().next()){
    					isValid=true;
    				}
    			} catch (SQLException e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    			finally {
    				db.closeRs();
    				if(db.pre!=null)
    					try {
    						db.pre.close();
    					} catch (SQLException e) {
    						// TODO 自动生成的 catch 块
    						e.printStackTrace();
    					}
    				db.closeConn();
    			}
    			//db.query(sql);
    			//		db.query(db.getSql());
    			//		if(db.next()) {
    			//			isValid = true;
    			//		}
    			//		db.closeRs();
    			//		db.closeStm();
    			//		db.closeConn();
    		}
    		return isValid ;
    	}
    	public boolean isExist(String username) {
    		boolean isExist = false;
    		db = new DBAccess();
    		if(db.createConn()) {
    			//String sql = "select * from students where user='"+username+"'";
    			//db.setSql("select * from students where user='"+username+"'");
    			String sql="select * from students where user=?";
    			try {
    				db.pre=db.getConn().prepareStatement(sql);
    				db.pre.setString(1, username);
    				db.setRs(db.pre.executeQuery());
    				if(db.getRs().next()){
    					isExist=true;
    				}
    			} catch (SQLException e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    			finally {
    				db.closeRs();
    				if(db.pre!=null){
    					try {
    						db.pre.close();
    					} catch (Exception e2) {
    						// TODO: handle exception
    					}
    					db.closeConn();
    				}
    			}
    			//db.query(sql);
    			//			db.query(db.getSql());
    			//			if(db.next()) {
    			//				isExist = true;
    			//			}
    			//			db.closeRs();
    			//			db.closeStm();
    			//			db.closeConn();
    		}
    		return isExist;
    	}
    	public boolean add(Students student) throws Exception{//添加
    		boolean flag = false;
    		db=new DBAccess();
    		String sql = "INSERT INTO students(user,password,department,grade,classes,email,amount) VALUES(?,?,?,?,?,?,?)";
    		if(db.createConn()){
    			db.pre=db.getConn().prepareStatement(sql);
    			db.pre.setString(1,student.getUser());
    			db. pre.setString(2,student.getPassword());
    			db.pre.setString(3,student.getDepartment());
    			db.pre.setString(4,student.getGrade());
    			db. pre.setString(5,student.getClasses());
    			db.pre.setString(6,student.getEmail());
    			db.pre.setInt(7,student.getAmount());
    			if(db.pre.executeUpdate() > 0) flag = true;
    		}
    		db.closeRs();
    		db.closeStm();
    		db.pre.close();
    		db.closeConn();
    		return flag;
    	}
    
    	public void del(String usename){//删除
    		DBAccess db = new DBAccess();
    		if(db.createConn()) {
    			String sql = "delete from students where user = '"+usename+"'";
    			db.update(sql);
    			db.closeStm();
    			db.closeConn();
    		}
    	}
    	private Students student = null;
    	public ArrayList<Students>getAllStudents() throws Exception{
    		DBAccess db = new DBAccess();
    		ArrayList<Students> students = new ArrayList<Students>();
    		String sql = "SELECT * FROM students";
    		if(db.createConn()){
    			db.query(sql);
    			while(db.getRs().next()){
    				student = this.assemble(db.getRs());
    				students.add(student);
    			}
    			db.closeStm();
    			db.closeRs();
    			db.closeConn();
    		}
    		return students;
    	}
    	public Students assemble(ResultSet rs) throws Exception{
    		student = new Students();
    		student.setId(rs.getInt("id"));
    		student.setUser(rs.getString("user"));
    		student.setPassword(rs.getString("password"));
    		student.setDepartment(rs.getString("department"));
    		student.setGrade(rs.getString("grade"));
    		student.setClasses(rs.getString("classes"));
    		student.setEmail(rs.getString("email"));
    		student.setAmount(rs.getInt("amount"));
    		return student;
    	}
    
    	public boolean delStudentByName(String user) throws Exception{//删除
    		DBAccess db=new DBAccess();
    		boolean flag = false;
    		String sql="DELETE FROM students WHERE user = ?";
    		if(db.createConn()){
    			db.pre=db.getConn().prepareStatement(sql);
    			db.pre.setString(1, user);
    			if(db.pre.executeUpdate()>0)flag=true;
    		}
    		db.closeConn();
    		db.closeStm();
    		db.pre.close();
    		db.closeRs();
    		return flag;
    	}
    
    	public Students getStudentById(int id) throws Exception{
    		DBAccess db=new DBAccess();
    		String sql = "SELECT * FROM students WHERE id = ?";
    		java.sql.PreparedStatement pre=null;
    		if(db.createConn()){
    			pre=db.getConn().prepareStatement(sql);
    			pre.setInt(1, id);
    			db.setRs(pre.executeQuery());
    			//conn = OpenConnection.getConnection();
    			//ps = conn.prepareStatement(sql_str);
    			//ps.setInt(1,id);
    			// rs = ps.executeQuery();
    			if (db.getRs().next()) student = this.assemble(db.getRs());
    		}
    		db.closeRs();
    		db.closeStm();
    		pre.close();
    		db.closeConn();
    		//this.release();
    		//OpenConnection.closeConnection(conn);
    		return student;
    	}
    	public boolean updateStudent(Students student) throws Exception{
    		boolean flag = false;
    		DBAccess db=new DBAccess();
    		String sql = "update students set amount = ? where id = ?";
    		java.sql.PreparedStatement pre=null;
    		if(db.createConn()){
    			pre=db.getConn().prepareStatement(sql);
    
    			//conn = OpenConnection.getConnection();
    			// ps = conn.prepareStatement(sql_str);
    			pre.setInt(1,student.getAmount());
    			pre.setInt(2,student.getId());
    
    			if(pre.executeUpdate() > 0) flag = true;
    		}
    		//this.release();
    		//OpenConnection.closeConnection(conn);
    		db.closeRs();
    		pre.close();
    		db.closeStm();
    		db.closeConn();
    		return flag;
    	}
    	public Students getStudentByName(String name) throws Exception{
    		DBAccess  db=new DBAccess();
    		String sql = "SELECT * FROM students WHERE user = ?";
    		java.sql.PreparedStatement pre=null;
    		if(db.createConn()){
    			pre=db.getConn().prepareStatement(sql);
    			pre.setString(1, name);
    			db.setRs(pre.executeQuery());
    
    			// conn = OpenConnection.getConnection();
    			//ps = conn.prepareStatement(sql_str);
    			//ps.setString(1,name);
    			// rs = ps.executeQuery();
    
    			if(db.getRs().next()) 
    			student = this.assemble(db.getRs());
    		}
    		db.closeRs();
    		db.closeStm();
    		pre.close();
    		db.closeConn();
    		//this.release();
    		// OpenConnection.closeConnection(conn);
    		return student;
    	}
    	public ArrayList<Students> findAll(Integer page){//分页查询信息
    		DBAccess  db=new DBAccess();
    		ArrayList<Students> list=new ArrayList<Students>();
    		
    		try {
    			if(db.createConn()){
    				String sql="select  * from students limit ?,? ";
    				db.pre=db.getConn().prepareStatement(sql);
    				db.pre.setInt(1, (page-1)*Students.PAGE_SIZE);
    				db.pre.setInt(2, Students.PAGE_SIZE);
    				db.setRs(db.pre.executeQuery());
    				while(db.getRs().next()){
    					Students stu=new Students();
    					stu.setUser(db.getRs().getString("user"));
    					stu.setPassword(db.getRs().getString("password"));
    					stu.setDepartment(db.getRs().getString("department"));
    					stu.setGrade(db.getRs().getString("grade"));
    					stu.setClasses(db.getRs().getString("classes"));
    					stu.setEmail(db.getRs().getString("email"));
    					stu.setAmount(db.getRs().getInt("amount"));
    					list.add(stu);
    				}
    				db.closeRs();
    				db.pre.close();
    				db.closeConn();
    			}
    		} catch( SQLException e) {
    			e.printStackTrace();
    		}
    		return list;
    	}
    	public int countPage(){//查询记录总数
    		DBAccess  db=new DBAccess();
    		int count=0;
    		try {
    			if(db.createConn()){
    				String sql="select count(*) from students  ";
    				db.pre=db.getConn().prepareStatement(sql);
    				db.setRs(db.pre.executeQuery());
    				if(db.getRs().next()){
    					count=db.getRs().getInt(1);
    				}
    			}
    		} catch( SQLException e) {
    			e.printStackTrace();
    		}
    		finally {
    			db.closeRs();
    			try {
    				if(db.pre!=null){
    					db.pre.close();
    				}
    			} catch (Exception e2) {
    				// TODO: handle exception
    			}
    			db.closeConn();
    		}
    		return count;
    	}
    }

### 4.2 Servlet类 ###

#### userlojinServlet ####

package com.demo.servlet;
    import com.demo.dao.AdminDAO;
    import com.demo.dao.StudentDAO;
    import com.demo.javabean.*;
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.*;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.io.UnsupportedEncodingException;
    import java.sql.SQLException;
    
    
    public class UserLoginServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    	@Override
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		String method = (String)request.getParameter("method");
    		if(method==null) {
    			PrintWriter out = response.getWriter();
    			out.println("invalid request!");
    		} else if(method.equals("login")) {
    			try {
    				Login(request, response);
    			} catch (Exception e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    		}
    		else if(method.equals("register")) {
    			try {
    				Register(request, response);
    			} catch (Exception e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    		}
    		else if(method.equals("logout")){
    			Logout(request,response);
    		}
    	}
    	//用户登录
    	protected void Login(HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		//request.setCharacterEncoding("utf-8");
    		//response.setCharacterEncoding("utf-8");
    		//response.setContentType("text/html;charset=utf-8");
        	PrintWriter out = response.getWriter();
    		String a_user = request.getParameter("user");
    		String a_password = request.getParameter("password");
    		System.out.println(a_user);
    		String rem=request.getParameter("remember");
    		HttpSession session = request.getSession();
    		StudentDAO a_dao=new StudentDAO();
    		if ("".equals(a_user) ||"".equals(a_password)) {
    			//System.out.println("登录失败，账号或密码不能为空！");
    			//response.sendRedirect("login.jsp");
    			out.println("<script>" +
    					"alert('登录失败，账号或密码不能为空!!!');" +
    					"window.location.href = \"login.jsp\";" +
    					"</script>");
    			return;
    		}
    		else if(a_dao.isExist(a_user)){
    			Students student=a_dao.getStudentByName(a_user);
    			session.setAttribute("student", student);
    			if(a_dao.valid(a_user, a_password)){
    				session.setAttribute("a_user", a_user);
    				user user=new user();
    				session.setAttribute("user",user);
    				if("1".equals(rem)){
    					//创建2个Cookie
    					Cookie namecookie=new Cookie("username", a_user);
    					//设置Cookie的有效期为三天
    					namecookie.setMaxAge(60*60*24*3);
    					Cookie pwdcookie=new Cookie("password", a_password);
    					pwdcookie.setMaxAge(60*60*24*3);
    					response.addCookie(namecookie);
    					response.addCookie(pwdcookie);
    				}
    				//response.sendRedirect(request.getContextPath()+"/user.jsp");
    				//System.out.println("登录成功！");
    				out.println("<script>" +
    						"alert('登录成功!!!');" +
    						"window.location.href = \"user.jsp\";" +
    						"</script>");
    			}
    			else {
    				//System.out.println("登录失败2，密码错误！");
    				//response.sendRedirect(request.getContextPath()+"/login.jsp");
    				out.println("<script>" +
    						"alert('登录失败，密码错误!!!');" +
    						"window.location.href = \"login.jsp\";" +
    						"</script>");
    			}
    		}
    		else {
    			//System.out.println("登录失败3，用户名不存在！");
    			//response.sendRedirect(request.getContextPath()+"/login.jsp");
    			out.println("<script>" +
    					"alert('登录失败，用户名不存在!!!');" +
    					"window.location.href = \"login.jsp\";" +
    					"</script>");
    	}
    	}
    	//用户退出
    	protected void Logout(HttpServletRequest request,
    			HttpServletResponse response) throws ServletException, IOException {
    		HttpSession session = request.getSession();
    		session.removeAttribute("a_user");
    		session.removeAttribute("user");
    		response.sendRedirect("login.jsp");
    	}
    	//用户注册
    	protected void Register(HttpServletRequest request, HttpServletResponse response) throws IOException,ServletException
    	{
    		//request.setCharacterEncoding("utf-8");
    		//response.setCharacterEncoding("utf-8");
    		//response.setContentType("text/html;charset=utf-8");
        	PrintWriter out = response.getWriter();
    		String user =  request.getParameter("user");
    		String password = request.getParameter("password");
    		String repwd= request.getParameter("repwd");
    		String department =  request.getParameter("department");
    		String grade =  request.getParameter("grade");
    		String classes = request.getParameter("classes");
    		String email =  request.getParameter("email");
    		if ("".equals(user) ||"".equals(password) || "".equals(repwd) || !password.equals(repwd)||"".equals(department)||"".equals(grade)||"".equals(classes)||"".equals(email)) {
    			//response.sendRedirect("reg.jsp");
    			out.println("<script>" +
    					"alert('注册失败，信息不全!!!');" +
    					"window.location.href = \"reg.jsp\";" +
    					"</script>");
    			
    			return;
    		}else{
    			Students student = null;
    			StudentDAO a_dao = new StudentDAO();
    			boolean isExist =a_dao.isExist(user);
    			if(isExist){
    				//System.out.println("'此学号已注册过，请重试!");
    				//response.sendRedirect("reg.jsp");
    				out.println("<script>" +
    						"alert('此学号已注册过，请重试!!!');" +
    						"window.location.href = \"reg.jsp\";" +
    						"</script>");
    
    			}else{
    				student = new Students();
    				student.setUser(user);
    				student.setPassword(password);
    				student.setDepartment(department);
    				student.setGrade(grade);
    				student.setClasses(classes);
    				student.setEmail(email);
    				student.setAmount(0);
    				try {
    					if(a_dao.add(student)){
    						student = a_dao.getStudentByName(student.getUser());
    						request.getSession().setAttribute("student",student);
    						//System.out.println("注册成功，即将跳转到主界面!");
    						//response.sendRedirect("login.jsp");
    						out.println("<script>" +
    								"alert('注册成功，即将跳转到主界面!!!');" +
    								"window.location.href = \"login.jsp\";" +
    								"</script>");
    						return;
    					}
    				} catch (Exception e) {
    					// TODO 自动生成的 catch 块
    					e.printStackTrace();
    				}
    
    			}
    		}
    	}
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		//req.setCharacterEncoding("utf-8");
    		this.doGet(req, resp);
    	}
    
    }

#### adminlojinServlet ####

package com.demo.servlet;
    
    import java.io.*;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import com.demo. dao.AdminDAO;
    import com.demo.javabean.*;
    
    
    public class AdminLoginServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        	String method = (String)req.getParameter("method");
        	if(method==null) {
    			PrintWriter out = resp.getWriter();
    			out.println("invalid request!");
    		} else if(method.equals("login")) {
    			Login(req, resp);
    		}
        }
        //管理员登录
        protected void Login(HttpServletRequest request,
    			HttpServletResponse response) throws ServletException, IOException {
        	//request.setCharacterEncoding("utf-8");
        	//response.setCharacterEncoding("utf-8");
    		//response.setContentType("text/html;charset=utf-8");
        	PrintWriter out = response.getWriter();
            String a_user =request.getParameter("a_user");
            String a_password = request.getParameter("a_password");
            //HttpSession session = request.getSession();
            AdminDAO a_dao = new AdminDAO();
           //String admin = null;
            if ( a_user .equals("") ||a_password .equals("")) {
            	//System.out.println("登录失败");
    			//response.sendRedirect("login.jsp");//重定向
            	out.println("<script>" +
    					"alert('登录失败，用户名或密码不能为空!!!');" +
    					"window.location.href = \"login.jsp\";" +
    					"</script>");
    			return;
    		}
            boolean isValid =  a_dao.valid(a_user, a_password);
    		if (isValid) {
    			HttpSession session = request.getSession();
    			session.setAttribute("a_user", a_user);
    			out.println("<script>" +
    					"alert('登录成功!!!');" +
    					"window.location.href = \"admin.jsp\";" +
    					"</script>");
    			//response.sendRedirect("admin.jsp");//重定向
    			return;
    		}
    		else {
    			//System.out.println("登录失败");
    			//response.sendRedirect("login.jsp");//重定向
    			out.println("<script>" +
    					"alert('登录失败，密码不正确!!!');" +
    					"window.location.href = \"login.jsp\";" +
    					"</script>");
    			return;
    		}
    	}
    //    protected void Logout(HttpServletRequest request,
    //			HttpServletResponse response) throws ServletException, IOException {
    //		HttpSession session = request.getSession();
    //		session.removeAttribute("a_user");
    //		response.sendRedirect("login.jsp");
    //	}
    //        
    
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    }

#### managebookservlet ####

package com.demo.servlet;
    
    import com.demo.dao.BookDAO;
    import com.demo.javabean.*;
    
    import javax.security.auth.message.callback.PrivateKeyCallback.Request;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.io.UnsupportedEncodingException;
    
    
    public class ManageBookServlet extends HttpServlet {
    	@Override
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    	//	HttpSession session=request.getSession();
    //		if(session!=null&&session.getAttribute("a_user1")!=null){
    //			String action = (String)request.getParameter("action");
    //			if(action==null) {
    //				PrintWriter out = response.getWriter();
    //				out.println("invalid request!");
    //			} else if(action.equals("addbook")) {
    //				AddBook(request, response);
    //			}
    //			else if(action.equals("delbook")) {
    //				DelBook(request, response);
    //			}
    //			else if(action.equals("updatebook")) {
    //				UpdateBook(request, response);
    //			}
    //			else if(action.equals("update")) {
    //				Update(request, response);
    //			}
    //		}
    //		else {
    //			response.sendRedirect("login.jsp");
    //		}
    		String action = (String)request.getParameter("action");
    		if(action==null) {
    		PrintWriter out = response.getWriter();
    		out.println("invalid request!");
    	} else if(action.equals("addbook")) {
    		AddBook(request, response);
    	}
    	else if(action.equals("delbook")) {
    		DelBook(request, response);
    	}
    	else if(action.equals("updatebook")) {
    		UpdateBook(request, response);
    	}
    	else if(action.equals("update")) {
    		Update(request, response);
    	}
    	}
    
    	//更新图书
    	private void Update(HttpServletRequest req, HttpServletResponse resp) throws ServletException,IOException{
    		// TODO 自动生成的方法存根
    		//req.setCharacterEncoding("utf-8");
    		//resp.setCharacterEncoding("utf-8");
    		//resp.setContentType("text/html;charset=utf-8");
    		Integer sid = Integer.parseInt(req.getParameter("sid"));
    		BookDAO b_dao=new BookDAO();
    		String page="";
    		try {
    			Books book=b_dao.getBookById(sid);
    			req.setAttribute("book", book);
    			req.getRequestDispatcher("admin/update_book.jsp").forward(req, resp);
    		} catch (Exception e) {
    			//page="error.jsp";
    			//TODO 自动生成的 catch 块
    			e.printStackTrace();
    		}
    		//        finally{
    		//        	page="admin/update_book.jsp";
    		//        }
    		//        req.getRequestDispatcher(page).forward(req, resp);
    	}
    	private void UpdateBook(HttpServletRequest req, HttpServletResponse resp)throws ServletException,IOException {//修改图书信息
    		// TODO 自动生成的方法存根
    		//req.setCharacterEncoding("utf-8");
    		//resp.setCharacterEncoding("utf-8");
    		//resp.setContentType("text/html;charset=utf-8");
    		PrintWriter out=resp.getWriter();
    		String sid=req.getParameter("sid");
    		String name=req.getParameter("name");
    		String author=req.getParameter("author");
    		String amount = req.getParameter("amount");
    		String category = req.getParameter("category");
    		BookDAO b_dao=new BookDAO();
    		Books book=new Books();
    		if(name != "" && author != "" && amount != "" && category != ""){
    			book.setName(name);
    			book.setAuthor(author);
    			book.setAmount(Integer.parseInt(amount));
    			book.setCategory(category);
    			book.setId(Integer.parseInt(sid));
    			try {
    				if(b_dao.updateBook2(book)){
    					//System.out.println("修改书籍成功！");
    					//resp.sendRedirect("PageServlet.do?method=showBook");
    					out.println("<script>alert('修改书籍成功!');" +
    							"window.location.href = \"PageServlet.do?method=showBook\";" +
    							"</script>");
    					return;
    				}
    				else
    					//System.out.println("修改书籍失败！内容不能为空");
    					out.println("<script>alert('修改书籍失败！内容不能为空');" +
    							"window.location.href = \"PageServlet.do?method=showBook\";" +
    							"</script>");
    
    			} catch (Exception e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    		}else
    			//System.out.println("修改书籍失败！");
    		//resp.sendRedirect("");
    			out.println("<script>alert('修改书籍失败！');" +
    					"window.location.href = \"PageServlet.do?method=showBook\";" +
    					"</script>");
    
    	}
    
    	//删除图书
    	private void DelBook(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException {
    		// TODO 自动生成的方法存根
    		//request.setCharacterEncoding("utf-8");
    		//response.setCharacterEncoding("utf-8");
    		//response.setContentType("text/html;charset=utf-8");
    		PrintWriter out=response.getWriter();
    		String name=request.getParameter("name");
    		BookDAO b_dao = new BookDAO();
    		if(name!=null){
    			try {
    				if(b_dao.delbook(name)){
    					//System.out.println("删除书籍成功！");
    					//response.sendRedirect("PageServlet.do?method=showBook");
    					//return;
    					out.println("<script>alert('删除书籍成功！');" +
    							"window.location.href = \"PageServlet.do?method=showBook\";" +
    							"</script>");
    					return;
    				}
    				else 
    					//System.out.println("删除书籍失败！");
    				//response.sendRedirect("admin/del_book.jsp");
    					out.println("<script>alert('删除书籍失败！');" +
    							"window.location.href = \"admin/del_book.jsp\";" +
    							"</script>");
    
    			} catch (Exception e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    		}
    		else{
    			//System.out.println("删除图书失败！无此图书");
    			//response.sendRedirect("admin/del_book.jsp");
    			out.println("<script>alert('删除书籍失败！');" +
    					"window.location.href = \"admin/del_book.jsp\";" +
    					"</script>");
    		}
    	}
    
    	//添加图书
    	private void AddBook(HttpServletRequest req, HttpServletResponse resp)throws ServletException,IOException {
    		// TODO 自动生成的方法存根
    		//req.setCharacterEncoding("utf-8");
    		//resp.setCharacterEncoding("utf-8");
    		//resp.setContentType("text/html;charset=utf-8");
    		PrintWriter out=resp.getWriter();
    		String name = req.getParameter("name");
    		String author = req.getParameter("author");
    		String amount = req.getParameter("amount");
    		String category = req.getParameter("category");
    		String intro="暂未介绍";
    		BookDAO b_dao = new BookDAO();
    		Books book = null;
    		if(name != "" && author != "" && amount != "" && category != ""){
    			book = new Books();
    			book.setName(name);
    			book.setAuthor(author);
    			book.setIntro("暂未介绍");
    			book.setAmount(Integer.parseInt(amount));
    			book.setCategory(category);
    			//PrintWriter out = resp.getWriter();
    			try {
    				b_dao.addBook(name, author, intro, amount, category);
    				//System.out.println("添加书籍成功！");
    				//resp.sendRedirect("admin/reg_book.jsp");
    				out.println("<script>alert('添加书籍成功!');" +
    						"window.location.href = \"admin/reg_book.jsp\";" +
    						"</script>");
    			} catch (Exception e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    
    		}else{
    			//System.out.println("添加书籍失败！其他原因");
    			//resp.sendRedirect("admin/reg_book.jsp");
    			out.println("<script>alert('添加书籍失败!！其他原因');" +
    					"window.location.href = \"admin/reg_book.jsp\";" +
    					"</script>");
    		}
    
    	}
    
    
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		//req.setCharacterEncoding("utf-8");
    		doGet(req,resp);
    
    	}
    }

#### managestudentservlet ####

package com.demo.servlet;
    
    import com.demo.dao.StudentDAO;
    import com.demo.javabean.*;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    
    public class ManageStudentServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    //    	HttpSession session=request.getSession();
    //    	if(session!=null&&session.getAttribute("a_user1")!=null){
    //    	String action = (String)request.getParameter("action");
    //    	if(action==null) {
    //			PrintWriter out = response.getWriter();
    //			out.println("invalid request!");
    //		} else if(action.equals("addstudent")) {
    //			AddStudent(request, response);
    //		}
    //		else if(action.equals("delstudent")) {
    //			DelStudent(request, response);
    //		}
    //		else if(action.equals("showstudent")){
    //			ShowStudent(request,response);
    //		}
    //    	}
    //    	else {
    //			response.sendRedirect("login.jsp");
    //		}
        	String action = (String)request.getParameter("action");
        	if(action==null) {
    			PrintWriter out = response.getWriter();
    			out.println("invalid request!");
    		} else if(action.equals("addstudent")) {
    			AddStudent(request, response);
    		}
    		else if(action.equals("delstudent")) {
    			DelStudent(request, response);
    		}
    		else if(action.equals("showstudent")){
    			ShowStudent(request,response);
    		}
        }
            private void ShowStudent(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException{
    		// TODO 自动生成的方法存根
    		//request.setCharacterEncoding("utf-8");
    		String user=request.getParameter("user");
    		StudentDAO studao=new StudentDAO();
    		Students student=new Students();
    		try {
    			student=studao.getStudentByName(user);
    			request.setAttribute("student", student);
    			
    		} catch (Exception e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    		}
    		request.getRequestDispatcher("admin/show_student.jsp").forward(request, response);
    	}
    		private void DelStudent(HttpServletRequest req, HttpServletResponse resp)throws ServletException,IOException {
            	req.setCharacterEncoding("utf-8");
            	resp.setCharacterEncoding("utf-8");
            	resp.setContentType("text/html;charset=utf-8");
            	PrintWriter out=resp.getWriter();
            	String user=req.getParameter("user");
            	StudentDAO s_dao = new StudentDAO();
            	if(user!=null){
            		 System.out.println(user);
            		try {
    					if(s_dao.delStudentByName(user)){
    						// System.out.println("删除成功！");
    						 //resp.sendRedirect("PageServlet.do?method=showStudent");
    						out.println("<script>alert('删除成功！');"
    						 +"window.location.href=\"PageServlet.do?method=showStudent\";"+"</script>");
    						 return;
    					}
    					else
    						//System.out.println("删除失败！");
    					//resp.sendRedirect("admin/del_student.jsp");
    						out.println("<script>alert('删除失败！');"
    								 +"window.location.href=\"admin/del_student.jsp\";"+"</script>");
    				} catch (Exception e) {
    					// TODO 自动生成的 catch 块
    					e.printStackTrace();
    				}
            	}
                 else{
                  	//System.out.println("删除失败，无此账号！");
                  	//resp.sendRedirect("admin/del_student.jsp");
                	 out.println("<script>alert('删除失败，无此账号！');"
    						 +"window.location.href=\"admin/del_student.jsp\";"+"</script>");
                    }			
            }
    
    		// TODO 自动生成的方法存根
    		
    		private void AddStudent(HttpServletRequest req, HttpServletResponse resp) throws ServletException,IOException {
    		// TODO 自动生成的方法存根
    		//req.setCharacterEncoding("utf-8");
    		//resp.setCharacterEncoding("utf-8");
    		//resp.setContentType("text/html;charset=utf-8");
    		PrintWriter out=resp.getWriter();
            String user=req.getParameter("user");
            String password = req.getParameter("password");
            String relpwd=req.getParameter("relpwd");
            String department=req.getParameter("department");
            String grade = req.getParameter("grade");
            String classes=req.getParameter("classes");
            String email = req.getParameter("email");
            String admin=req.getParameter("admin");
            if ("".equals(user) || "".equals(password) ||"".equals(relpwd) || !password.equals(relpwd)||"".equals(department)||"".equals(grade)||"".equals(classes)||"".equals(email)) {
    			//resp.sendRedirect("admin/add_student.jsp");
    			//System.out.println("信息不全");
            	out.println("<script>alert('添加失败，信息不全!');" +
    					"window.location.href = \"admin/add_student.jsp\";" +
    					"</script>");
    			return;
    		}else{
            StudentDAO a_dao = new StudentDAO();
            Students student=new Students();
    		boolean isExist =a_dao.isExist(user);
    		if(isExist){
    			//System.out.println("此学号已注册！");
    			//resp.sendRedirect("admin/add_student.jsp");
    			out.println("<script>alert('此学号已注册！');" +
    					"window.location.href = \"admin/add_student.jsp\";" +
    					"</script>");
    		}
    		else{
    			 student = new Students();
    	            student.setUser(user);
    	            student.setPassword(password);
    	            student.setDepartment(department);
    	            student.setGrade(grade);
    	            student.setClasses(classes);;
    	            student.setEmail(email);
    	            student.setAmount(0);
    	            try {
    					if(a_dao.add(student)){
    						student = a_dao.getStudentByName(student.getUser());
    					    req.getSession().setAttribute("student",student);
    					//System.out.println("添加成功!");
    					//resp.sendRedirect("");
    					    out.println("<script>alert('添加成功！');" +
    								"window.location.href = \"admin/add_student.jsp\";" +
    								"</script>");
    					return;
    }
    				} catch (Exception e) {
    					// TODO 自动生成的 catch 块
    					e.printStackTrace();
    				}
    
    		}
    		}
    	}
    		
    
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        	//req.setCharacterEncoding("utf-8");
            doGet(req,resp);
        }
    }

### javaBean类 ###

#### admin ####

package com.demo.javabean;
    
    public class Admins {
    
        private int id;                     //定义管理员的id序号
        private String admin;               //登录账号
        private String password;            //密码
        private String realname;            //真实姓名
        private String phone;               //电话号码
        private String email;               //邮箱
        private String address;             //地址
    
        //获取管理员的id序号
        public int getId() {
            return id;
        }
    
        //设置管理员的id序号
        public void setId(int id) {
            this.id = id;
        }
    
        //获取管理员的账号
        public String getAdmin() {
            return admin;
        }
    
        //设置管理员的账号
        public void setAdmin(String admin) {
            this.admin = admin;
        }
    
        //获取管理员的密码
        public String getPassword() {
            return password;
        }
    
        //设置管理员的密码
        public void setPassword(String password) {
            this.password = password;
        }
    
        //获取管理员的真实姓名
        public String getRealname() {
            return realname;
        }
    
        //设置管理员的真实姓名
        public void setRealname(String realname) {
            this.realname = realname;
        }
    
        //获取管理员的电话
        public String getPhone() {
            return phone;
        }
    
        //设置管理员的电话号码
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        //获得管理员的邮箱地址
        public String getEmail() {
            return email;
        }
    
        //设置管理员的邮箱地址
        public void setEmail(String email) {
            this.email = email;
        }
    
        //获取管理员的地址
        public String getAddress() {
            return address;
        }
    
        //设置管理员的地址
        public void setAddress(String address) {
            this.address = address;
        }
    }

#### student ####

package com.demo.javabean;
    
    public class Students {
    	public static final int PAGE_SIZE=5;
        private int id;
        private String user;
        private String password;
       private String department;
        private String grade;
        private String classes;
        private String email;
        private int amount;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getUser() {
            return user;
        }
    
        public void setUser(String user) {
            this.user = user;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getDepartment() {
            return department;
        }
    
        public void setDepartment(String department) {
            this.department = department;
        }
    
        public String getGrade() {
            return grade;
        }
    
        public void setGrade(String grade) {
            this.grade = grade;
        }
    
        public String getClasses() {
            return classes;
        }
    
        public void setClasses(String classes) {
            this.classes = classes;
        }
    
        public String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        public int getAmount() {
            return amount;
        }
    
        public void setAmount(int amount) {
            this.amount = amount;
        }
    }

#### book ####

package com.demo.javabean;
    
    public class Books {
    	private static final long serialVersionUID = 1L;
    	public static final int PAGE_SIZE=5;
        private int id;
        private String name;
        private String author;
        private String intro;
        private int amount;
        private String category;
    
        //取得图书的id序号
        public int getId() {
            return id;
        }
    
        //设置图书的id序号
        public void setId(int id) {
            this.id = id;
        }
    
        //获取图书的名字
        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 String getIntro() {
            return intro;
        }
    
        //设置图书的简介
        public void setIntro(String intro) {
            this.intro = intro;
        }
    
        //获取图书的数量
        public int getAmount() {
            return amount;
        }
    
        //设置图书的数量
        public void setAmount(int amount) {
            this.amount = amount;
        }
    
        //获取图书的类别
        public String getCategory() {
            return category;
        }
    
        //设置图书的类别
        public void setCategory(String category) {
            this.category = category;
        }
    }

### filter（过滤器类） ###

#### loginfilter ####

package com.demo.filter;
    
    import java.io.IOException;
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    
    public class LoginFilter implements Filter {//对登录进行验证过滤
    
    	@Override
    	public void destroy() {
    		// TODO 自动生成的方法存根
    		
    	}
    
    	@Override
    	public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
    			throws IOException, ServletException {
    		// TODO 自动生成的方法存根
    		HttpServletRequest request=(HttpServletRequest) req;
    		HttpServletResponse response=(HttpServletResponse)resp;
    		HttpSession session=request.getSession(false);
    		if(session!=null&&session.getAttribute("a_user")!=null){
    			//继续往下走
    			chain.doFilter(request, response);
    		}
    		else {
    			response.sendRedirect("login.jsp");
    		}
    		}
    	
    
    	@Override
    	public void init(FilterConfig arg0) throws ServletException {
    		// TODO 自动生成的方法存根
    		
    	}
    
    }

#### characterfilter ####

package com.demo.filter;
    import java.io.IOException;
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    
    public class CharacterFilter implements Filter {//对字符乱码问题进行过滤
    
    	@Override
    	public void destroy() {
    		// TODO 自动生成的方法存根
    		
    	}
    
    	@Override
    	public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
    			throws IOException, ServletException {
    		// TODO 自动生成的方法存根
    		HttpServletRequest request=(HttpServletRequest)req;
    		HttpServletResponse response=(HttpServletResponse) resp;
    		request.setCharacterEncoding("utf-8");
    		response.setCharacterEncoding("utf-8");
    		response.setContentType("text/html;charset=utf-8");
    		//继续执行
    		chain.doFilter(request, response);
    	}
    
    	@Override
    	public void init(FilterConfig arg0) throws ServletException {
    		// TODO 自动生成的方法存根
    		
    	}
    
    }

。。。因代码量较多，就不一一粘贴，有兴趣的友友可以交流。

[c6c2a29f09be4f1f937c210f25b5a95a.png]: https://img-blog.csdnimg.cn/c6c2a29f09be4f1f937c210f25b5a95a.png
[95e9dcbd354441e1a633416142c3127e.png]: https://img-blog.csdnimg.cn/95e9dcbd354441e1a633416142c3127e.png
[8329c2c845be4f939c99ca92e145215d.png]: https://img-blog.csdnimg.cn/8329c2c845be4f939c99ca92e145215d.png
[6b46d8ad70a945a7913bd1f14f49568c.png]: https://img-blog.csdnimg.cn/6b46d8ad70a945a7913bd1f14f49568c.png
[dc6466823b5147bc945ae8ce2b4c8624.png]: https://img-blog.csdnimg.cn/dc6466823b5147bc945ae8ce2b4c8624.png
[b48af1bb6ae94b9e946489f39f201847.png]: https://img-blog.csdnimg.cn/b48af1bb6ae94b9e946489f39f201847.png
[1da1465cd9e64547b29f48819ffdb33e.png]: https://img-blog.csdnimg.cn/1da1465cd9e64547b29f48819ffdb33e.png
[d612b1149b424607a9f6da3978e4c2ff.png]: https://img-blog.csdnimg.cn/d612b1149b424607a9f6da3978e4c2ff.png
[0e6fcec9ccf54b00b5fe868a9413c288.png]: https://img-blog.csdnimg.cn/0e6fcec9ccf54b00b5fe868a9413c288.png
[17fb201582b546cdb1fbfc60c1721907.png]: https://img-blog.csdnimg.cn/17fb201582b546cdb1fbfc60c1721907.png
[9f9ece0b40fc48c88c00fc38e24845e0.png]: https://img-blog.csdnimg.cn/9f9ece0b40fc48c88c00fc38e24845e0.png
[2a021f22229c434c9d33608a6913af29.png]: https://img-blog.csdnimg.cn/2a021f22229c434c9d33608a6913af29.png
[07dc374ae6af450fbc0c3ead3021395d.png]: https://img-blog.csdnimg.cn/07dc374ae6af450fbc0c3ead3021395d.png
[adb5b82ceba54a3d9533700b3eb7e73b.png]: https://img-blog.csdnimg.cn/adb5b82ceba54a3d9533700b3eb7e73b.png
[7ef1602dda8140da85d4712e93b05d74.png]: https://img-blog.csdnimg.cn/7ef1602dda8140da85d4712e93b05d74.png
[b100d4d1f2ea4528a65a1a287dc00198.png]: https://img-blog.csdnimg.cn/b100d4d1f2ea4528a65a1a287dc00198.png
[22ac1d8dd4a2411f98aae80ceaed5f3d.png]: https://img-blog.csdnimg.cn/22ac1d8dd4a2411f98aae80ceaed5f3d.png
[76b1d590c60445898c09508e40368de4.png]: https://img-blog.csdnimg.cn/76b1d590c60445898c09508e40368de4.png
[f8e3115ad9c246a6b92bfc725cae906b.png]: https://img-blog.csdnimg.cn/f8e3115ad9c246a6b92bfc725cae906b.png
[07dbea35d3734b08bdd4c73de005f2c0.png]: https://img-blog.csdnimg.cn/07dbea35d3734b08bdd4c73de005f2c0.png
[9b119e8ea0e84fd488f0f595448d404b.png]: https://img-blog.csdnimg.cn/9b119e8ea0e84fd488f0f595448d404b.png
[7624642dec674f5db29c5f8c2f50e8cf.png]: https://img-blog.csdnimg.cn/7624642dec674f5db29c5f8c2f50e8cf.png
[a49061d7a51f48b491c239ac34d5d826.png]: https://img-blog.csdnimg.cn/a49061d7a51f48b491c239ac34d5d826.png