目录
4.3javaBean类
4.4filter（过滤器类）
所用的思想是在MVC模式下进行开发，主要涉及到的内容有：JSP、javaBean、Servlet、JDBC、以及前端css、js，从具体实施来看主要涉及到的知识有：对jsp主要内置对象的熟练使用。例如，request请求、response响应、session会话、以及利用cookie来进行免登录，EL表达式，JSTL标签,Filter过滤器，Listener监视器，前端的灵活使用等。
admins(管理员)表 管理员相关信息
Books(图书)表 记录图书相关信息
Students（学生）表 记录学生相关信息
Borrows(借书)表 记录借阅相关信息
此次系统分为两个板块，管理员和用户。管理员主要进行用户和图书的增删改查，用户则进行借还操作。
下面简述两者主要功能及实现方法，具体可见后文详解。
增加学生、删除学生、查看学生、添加图书、修改图书、删除图书、查看图书
对学生的增删查，主要是在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会话，将事先绑定好的用户信息，直接读取，显示在相应页面中。
管理员主要管理学生和图书，在其项目里面有managestudent.servlet和managebook.servlet两个主要的servlet类。通过前端提供不同的请求来响应对应servlet里面的方法。
首先是管理员需要登录验证，判断数据库中是否有管理员账号相关信息。此次开发中，管理员账号为事先在数据库中录入，不支持注册和记住密码。管理员登录，需要请求adminlogin.servlet处理登录信息，如下（账号：admin 密码：admin）：
图1- 1 管理员登录页面
若输入错误密码，则会提示密码错误重新登录（账号：admin 密码：123456）：
图1- 2 管理员登录错误页面
添加学生功能，主要涉及到 student.dao（主要对学生进行数据库操纵，jdbc代码），student.bean(封装保存学生的基本信息)，managestudent.servlet(用来后端操作控制添加学生信息的功能)以及addstusent.jsp（添加学生信息的前端页面）。添加信息的时候注意每项信息不能为空、以及添加的学生信息原数据库中是否有信息等需要在servlet里面做出判断。核心就是student.dao里面的连接数据库操纵语言，以及managestudent.servlet里面的对信息进行控制封装。如下：
图1-3 addstudent.jsp
查看学生功能是将数据库中的所有学生信息，展现在前端页面。这里主要涉及到studentDao、managestudent.servlet、student.javabean、showstudent.jsp等，在这里另外增加了一个分页查看的功能，主要思想就是在数据库里查询的时候将其分割，limit（beginpage，pagesize），然后通过查询的所有记录count/pagesize，得出总共的页数,然后在pageservlet里面，整理，最后输出到前端页面。
管理员可以删除选中的学生，主要是利用前端绑定的机制，在get模式下，绑定用户的信息，通过前端传入的值，在后端进行相应的处理，在数据库中进行删除学生。所涉及到的类和前面几乎一致，不再重述。
添加书籍类似添加学生，book.javabean（存有图书信息），managebook.Servlet(图书管理的servlet)，以及对应的jsp页面.
管理员可查看所有图书信息。
在show_book.jsp里面同时包含修改和删除图书的功能。两个方法对应不同的链接，跳转到相应的servlet中，在处理更改的时候需要用到重定向方法，将原先存到session中的数据，重定向到一个页面进行修改，同时该页面，要保留原有的信息，可以使用EL表达式来进行处理。
用户登录页面同管理员登录页面一致，且在同一个jsp里，分两个form表单完成。在用户登录界面增加了注册、和记住密码的功能。首先看登录功能，用户输入账号和密码，前端将数据提交到后端的userloginServlet来进行处理，通过后端的处理与数据库中的结果作比较。验证登录是否成功，下图为登录成功界面。
在用户进行登录的时候有一个复选框，为记住密码的操作。当用户点击记住密码的时候，下次登录不用在输入账号密码，直接点击登录即可。这是利用cookie的机制，通过创建cookie，将账号信息保存到硬盘中。此次系统设计的cookie时间为三天。具体效果如下:
注册功能同管理员添加学生一致，只不过这个注册会跳转到userloginsrvlet里面进行处理。结合数据库往里边添加数据，同时也会对，信息是否填写完整，以及原有数据库里面是否有数据做出判断。
等用户登录成功后，即可看到左面功能栏里面的功能，最上面的就是查看所有图书功能，接下来的一系列则是根据图书类别进行查看图书，方便用户浏览，快速查找结果。里面的一些显示功能主要是，利用超链接的target，来将查询的结果输出到，showBook.jsp页面上。
每个书籍后面附有借书操作的功能，借阅实现的方法主要是，利用前端绑定机制，将用户的信息，和图书信息整合到一块，后端来进行获取。
当borrowservlet，接收到用户信息和图书信息后，通过studentBean,bookBean以及borrowBean，来对借阅功能进行封装处理，这时需要borrowdao来进行数据库的读写操作。
在这里设置每位用户最大借阅量为10本，所以在servlet里面，做出判断借阅量是否大于最大借阅书籍量。来响应用户是否还能继续借阅。若能借阅的话，则通过后台，处理Bean数据，用户借阅量发生变化，图书量也发生变化。
借阅信息查询这个页面中，可以显示所有借的图书信息，并且在这个页面附有还书的功能，借阅信息主要是利用BorrowServlet和BorrowDAO里面根据用户信息，来获取当前用户下共计的借阅量。
还书对应的则是returnservlet,根据用户信息，以及图书信息，来做出合理的判断，在通过BorrowDao,里面的数据库操作对借书量，图书量数据上做出相应的改变。
在我的基本信息里面可以查看除密码以外的所有信息，包括当前借阅量，可借图书量等。具体实施为通过后台数据库将个人信息展现到页面上。
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;
}
}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;
}
}
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;
}
}
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;
}
}
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);
}
}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);
}
}
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);
}
}
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);
}
}
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;
}
}
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;
}
}
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;
}
}
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 自动生成的方法存根
}
}
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 自动生成的方法存根
}
}
。。。因代码量较多，就不一一粘贴，有兴趣的友友可以交流。
我正在使用i18n从头开始构建一个多语言网络应用程序，虽然我自己可以处理一大堆yml文件，但我说的语言(非常)有限，最终我想寻求外部帮助帮助。我想知道这里是否有人在使用UI插件/gem(与django上的django-rosetta不同)来处理多个翻译器，其中一些翻译器不愿意或无法处理存储库中的100多个文件，处理语言数据。谢谢&问候，安德拉斯(如果您已经在rubyonrails-talk上遇到了这个问题，我们深表歉意) 最佳答案 有一个rails3branchofthetolkgem在github上。您可以通过在Gemfi
我安装了ruby版本管理器，并将RVM安装的ruby实现设置为默认值，这样'哪个ruby'显示'~/.rvm/ruby-1.8.6-p383/bin/ruby'但是当我在emacs中打开inf-ruby缓冲区时，它使用安装在/usr/bin中的ruby。有没有办法让emacs像shell一样尊重ruby的路径？谢谢! 最佳答案 我创建了一个emacs扩展来将rvm集成到emacs中。如果您有兴趣，可以在这里获取:http://github.com/senny/rvm.el
是否有简单的方法来更改默认ISO格式(yyyy-mm-dd)的ActiveAdmin日期过滤器显示格式？ 最佳答案 您可以像这样为日期选择器提供额外的选项，而不是覆盖js:=f.input:my_date,as::datepicker,datepicker_options:{dateFormat:"mm/dd/yy"} 关于ruby-on-rails-事件管理员日期过滤器日期格式自定义，我们在StackOverflow上找到一个类似的问题： https://s
导读：随着叮咚买菜业务的发展，不同的业务场景对数据分析提出了不同的需求，他们希望引入一款实时OLAP数据库，构建一个灵活的多维实时查询和分析的平台，统一数据的接入和查询方案，解决各业务线对数据高效实时查询和精细化运营的需求。经过调研选型，最终引入ApacheDoris作为最终的OLAP分析引擎，Doris作为核心的OLAP引擎支持复杂地分析操作、提供多维的数据视图，在叮咚买菜数十个业务场景中广泛应用。作者｜叮咚买菜资深数据工程师韩青叮咚买菜创立于2017年5月，是一家专注美好食物的创业公司。叮咚买菜专注吃的事业，为满足更多人“想吃什么”而努力，通过美好食材的供应、美好滋味的开发以及美食品牌的孵
电脑0x0000001A蓝屏错误怎么U盘重装系统教学分享。有用户电脑开机之后遇到了系统蓝屏的情况。系统蓝屏问题很多时候都是系统bug，只有通过重装系统来进行解决。那么蓝屏问题如何通过U盘重装新系统来解决呢？来看看以下的详细操作方法教学吧。 准备工作： 1、U盘一个（尽量使用8G以上的U盘）。 2、一台正常联网可使用的电脑。 3、ghost或ISO系统镜像文件（Win10系统下载_Win10专业版_windows10正式版下载-系统之家）。 4、在本页面下载U盘启动盘制作工具：系统之家U盘启动工具。 U盘启动盘制作步骤： 注意：制作期间，U盘会被格式化，因此U盘中的重要文件请注
在应用开发中，有时候我们需要获取系统的设备信息，用于数据上报和行为分析。那在鸿蒙系统中，我们应该怎么去获取设备的系统信息呢，比如说获取手机的系统版本号、手机的制造商、手机型号等数据。1、获取方式这里分为两种情况，一种是设备信息的获取，一种是系统信息的获取。1.1、获取设备信息获取设备信息，鸿蒙的SDK包为我们提供了DeviceInfo类，通过该类的一些静态方法，可以获取设备信息，DeviceInfo类的包路径为：ohos.system.DeviceInfo.具体的方法如下：ModifierandTypeMethodDescriptionstatic StringgetAbiList()Obt
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
需求：要创建虚拟机，就需要给他提供一个虚拟的磁盘，我们就在/opt目录下创建一个10G大小的raw格式的虚拟磁盘CentOS-7-x86_64.raw命令格式：qemu-imgcreate-f磁盘格式磁盘名称磁盘大小qemu-imgcreate-f磁盘格式-o?1.创建磁盘qemu-imgcreate-fraw/opt/CentOS-7-x86_64.raw10G执行效果#ls/opt/CentOS-7-x86_64.raw2.安装虚拟机使用virt-install命令，基于我们提供的系统镜像和虚拟磁盘来创建一个虚拟机，另外在创建虚拟机之前，提前打开vnc客户端，在创建虚拟机的时候，通过vnc
我想用这两种语言中的任何一种(最好是ruby)制作一个窗口管理器。老实说，除了我需要加载某种X模块外，我不知道从哪里开始。因此，如果有人有线索，如果您能指出正确的方向，那就太好了。谢谢 最佳答案 XCB，X的下一代API使用XML格式定义X协议(protocol)，并使用脚本生成特定语言绑定(bind)。它在概念上与SWIG类似，只是它描述的不是CAPI，而是X协议(protocol)。目前，C和Python存在绑定(bind)。理论上，Ruby端口只是编写一个从XML协议(protocol)定义语言到Ruby的翻译器的问题。生
因为我现在正在做一些时间测量，我想知道是否可以在不使用Benchmark类或命令行实用程序time的情况下测量用户时间或系统时间。使用Time类只显示挂钟时间，而不显示系统和用户时间，但是我正在寻找具有相同灵active的解决方案，例如time=TimeUtility.now#somecodeuser,system,real=TimeUtility.now-time原因是我有点不喜欢Benchmark，因为它不能只返回数字(编辑:我错了-它可以。请参阅下面的答案。)。当然，我可以解析输出，但感觉不对。*NIX系统的time实用程序也应该可以解决我的问题，但我想知道是否已经在Ruby中实