学习记录05 --- 自学servlet写一个简单的增删改查的后端

之前学会了java如何连接数据库，一直很想学学servlet

今天就来满足下自己，写个完整的增删改查

首先新建一个javaee的项目，但idea不同，需要在WEB-INF中新建2个文件夹

classes用来存放编译后的class文件，lib用来导入jar包

首先将mysql的架包给复制到lib，并且导入，这些简单操作就不写出来了

那么之前的jdbc写的类可以拿过来用了

 1 package org.lanqiao.jdbc;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.Statement;
 7 
 8 
 9 public class Jdbc {
10     static String url = "jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf-8";
11     static String user = "root";
12     static String pwd = "123456";
13 
14     //定义成全局变量方便关闭
15     static Connection conn;
16     static Statement stt;
17 
18     //连接数据库
19     public static void connetcDatabase() throws Exception {
20         //导入驱动类
21         Class.forName("com.mysql.jdbc.Driver");
22         //创建连接对象
23         conn = DriverManager.getConnection(url,user,pwd);
24 
25     }
26 
27     //数据库查询操作
28     public static ResultSet executeQueryDatabase(String sql) throws Exception {
29         //调用连接数据库方法连接数据库
30         connetcDatabase();
31         //创建命令行
32         stt = conn.createStatement();
33         //执行sql语句
34         ResultSet result = stt.executeQuery(sql);
35         //返回操作结果
36         return result;
37     }
38 
39     //数据库增删改操作
40     public static int executeUpdateDatabase(String sql) throws Exception {
41         //调用连接数据库方法连接数据库
42         connetcDatabase();
43         //创建命令行
44         stt = conn.createStatement();
45         //执行sql语句
46         int line = stt.executeUpdate(sql);
47         //返回影响行数
48         return line;
49     }
50 
51     //关闭数据库连接
52     public static void closeDatabase() throws Exception {
53         //关闭数据库连接
54         conn.close();
55         stt.close();
56     }
57 
58 }

那么，数据库连接就完成了，先不急着弄servlet和dao，先把javabean给弄好

先理清下数据库中表的字段有多少个

id、name、pwd、age、address、sex、classid

总共7个，那么创建的javabead也要对应这7个

package org.lanqiao.bean;

public class Student {
    private int id;
    private String name;
    private String pwd;
    private int age;
    private String address;
    private String sex;
    private int classid;

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", sex='" + sex + '\'' +
                ", classid=" + classid +
                '}';
    }

    public Student() {}

    public Student(int id, String name, String pwd, int age, String address, String sex, int classid) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
        this.age = age;
        this.address = address;
        this.sex = sex;
        this.classid = classid;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setClassid(int classid) {
        this.classid = classid;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public String getSex() {
        return sex;
    }

    public int getClassid() {
        return classid;
    }
}

那么javabean写好了，我们先来把dao里面对数据库的操作都写好，然后再创建servlet

写增删改查之前先不急，我们用静态导包的方式，把JDBC类给导过来，方便使用

同时，还得把javabean给导进来

import static org.lanqiao.jdbc.Jdbc.*;
import org.lanqiao.bean.Student;

这样，我们直接调用方法即可使用了

先来写查询，但写查询之前，先写一个获取所有学生信息并且封装成一个集合的方法

 1 //获取所有学生的信息，并返回一个集合
 2     public List<Student> getStudentAllInfo() throws Exception {
 3         //新建一个集合，用来存放所有学生的信息
 4         List<Student> list = new ArrayList<Student>();
 5         //SQL语句
 6         String sql = "select * from student";
 7         //调用数据库查询方法，并返回结果
 8         ResultSet result = executeQueryDatabase(sql);
 9         //开始遍历结果
10         while(result.next()) {
11             //临时建立一个Student的对象进行存放数据
12             Student info = new Student();
13             //把数据库的数据存取到本地
14             info.setId(result.getInt("id"));
15             info.setName(result.getString("name"));
16             info.setPwd(result.getString("pwd"));
17             info.setAge(result.getInt("age"));
18             info.setAddress(result.getString("address"));
19             info.setSex(result.getString("sex"));
20             info.setClassid(result.getInt("classid"));
21             //把临时数据添加到集合里
22             list.add(info);
23         }
24         //调用方法关闭数据库连接
25         closeDatabase();
26         //返回存取了所有学生信息的集合
27         return list;
28     }

 接下来我们再来写查询的方法，需要的是把数据封装成json格式

这里需要一个一个叫做Gson的架包，这里提供下下载地址

http://repo1.maven.org/maven2/com/google/code/gson/gson/

可能国内的网络访问这个会很慢，需要魔法上网

那么，借助Gson，我们很容易就能把一个集合对象转换成json了

 1 //查询出学生信息，封装成json格式并返回
 2     public String selectStudentInfo() throws Exception {
 3         //存放错误代码,0表示成功，1表示失败
 4         int error_code;
 5         //调用方法获取所有学生信息
 6         List<Student> list = getStudentAllInfo();
 7         //判断集合对象是否又数据
 8         if(list.size()>0)
 9             error_code = 0;
10         else
11             error_code = 1;
12         //创建Gson对象
13         Gson gson = new Gson();
14         //创建一个字符串变量存放json格式数据
15         String json = "{\"error_code\":\""+error_code+"\",\"data\":["+gson.toJson(list)+"]}";
16         //返回给servlet处理
17         return json;
18     }

到这里查询也基本上完成了，接下来写添加操作

添加操作要比查询操作简单的多了，只需要注意sql语句不要出问题

 1 //添加学生信息
 2     public String insertStudentInfo(Student info) throws Exception {
 3         //存放错误代码，0表示成功，1表示失败
 4         int error_code;
 5         //SQL语句
 6         String sql = "insert into student(name,pwd,age,address,sex,calssid) values('"+info.getName()+"','"+info.getPwd()+"',"+info.getAge()+",'"+info.getAddress()+"','"+info.getSex()+"',"+info.getClassid()+")";
 7         //调用数据库增删改方法，并返回受影响行数
 8         int line = executeUpdateDatabase(sql);
 9         //调用方法关闭数据库连接
10         closeDatabase();
11         //判断是否成功
12         if(line>0)
13             error_code = 0;
14         else
15             error_code = 1;
16         //存放json格式的错误代码
17         String json = "{\"error_code\":\""+error_code+"\"}";
18         //返回错误代码
19         return json;
20     }

剩下的修改和删除跟添加相比没太大的区别，只是删除传过来的参数只需要id就可以了，最大的区别就是sql语句不一样了

 1 //删除学生信息
 2     public String deleteStudentInfo(int id) throws Exception {
 3         //存放错误代码，0表示成功，1表示失败
 4         int error_code;
 5         //SQL语句
 6         String sql = "delete from student where id="+id;
 7         //调用数据库增删改方法，并返回受影响行数
 8         int line = executeUpdateDatabase(sql);
 9         //调用方法关闭数据库连接
10         closeDatabase();
11         //判断是否成功
12         if(line>0)
13             error_code = 0;
14         else
15             error_code = 1;
16         //存放json格式的错误代码
17         String json = "{\"error_code\":\""+error_code+"\"}";
18         //返回错误代码
19         return json;
20     }
21 
22     //修改学生信息
23     public String updateStudentInfo(Student info) throws Exception {
24         //存放错误代码，0表示成功，1表示失败
25         int error_code;
26         //SQL语句
27         String sql = "update student set name='"+info.getName()+"',pwd='"+info.getPwd()+"',age="+info.getAge()+",address='"+info.getAddress()+"',sex='"+info.getSex()+"',classid="+info.getClassid()+" where id="+info.getId();
28         //调用数据库增删改方法，并返回受影响行数
29         int line = executeUpdateDatabase(sql);
30         //调用方法关闭数据库连接
31         closeDatabase();
32         //判断是否成功
33         if(line>0)
34             error_code = 0;
35         else
36             error_code = 1;
37         //存放json格式的错误代码
38         String json = "{\"error_code\":\""+error_code+"\"}";
39         //返回错误代码
40         return json;
41     }

那么到这里，所有的dao里面的最基本的增删改查操作到这里写完了，附上dao里面的所有代码

  1 package org.lanqiao.dao;
  2 
  3 import static org.lanqiao.jdbc.Jdbc.*;
  4 
  5 import com.google.gson.Gson;
  6 import org.lanqiao.bean.Student;
  7 
  8 import java.sql.ResultSet;
  9 import java.util.ArrayList;
 10 import java.util.List;
 11 
 12 public class Dao {
 13 
 14     //获取所有学生的信息，并返回一个集合
 15     public List<Student> getStudentAllInfo() throws Exception {
 16         //新建一个集合，用来存放所有学生的信息
 17         List<Student> list = new ArrayList<Student>();
 18         //SQL语句
 19         String sql = "select * from student";
 20         //调用数据库查询方法，并返回结果
 21         ResultSet result = executeQueryDatabase(sql);
 22         //开始遍历结果
 23         while(result.next()) {
 24             //临时建立一个Student的对象进行存放数据
 25             Student info = new Student();
 26             //把数据库的数据存取到本地
 27             info.setId(result.getInt("id"));
 28             info.setName(result.getString("name"));
 29             info.setPwd(result.getString("pwd"));
 30             info.setAge(result.getInt("age"));
 31             info.setAddress(result.getString("address"));
 32             info.setSex(result.getString("sex"));
 33             info.setClassid(result.getInt("classid"));
 34             //把临时数据添加到集合里
 35             list.add(info);
 36         }
 37         //调用方法关闭数据库连接
 38         closeDatabase();
 39         //返回存取了所有学生信息的集合
 40         return list;
 41     }
 42 
 43     //查询出学生信息，封装成json格式并返回
 44     public String selectStudentInfo() throws Exception {
 45         //存放错误代码,0表示成功，1表示失败
 46         int error_code;
 47         //调用方法获取所有学生信息
 48         List<Student> list = getStudentAllInfo();
 49         //判断集合对象是否又数据
 50         if(list.size()>0)
 51             error_code = 0;
 52         else
 53             error_code = 1;
 54         //创建Gson对象
 55         Gson gson = new Gson();
 56         //创建一个字符串变量存放json格式数据
 57         String json = "{\"error_code\":\""+error_code+"\",\"data\":["+gson.toJson(list)+"]}";
 58         //返回给servlet处理
 59         return json;
 60     }
 61 
 62     //添加学生信息
 63     public String insertStudentInfo(Student info) throws Exception {
 64         //存放错误代码，0表示成功，1表示失败
 65         int error_code;
 66         //SQL语句
 67         String sql = "insert into student(name,pwd,age,address,sex,calssid) values('"+info.getName()+"','"+info.getPwd()+"',"+info.getAge()+",'"+info.getAddress()+"','"+info.getSex()+"',"+info.getClassid()+")";
 68         //调用数据库增删改方法，并返回受影响行数
 69         int line = executeUpdateDatabase(sql);
 70         //调用方法关闭数据库连接
 71         closeDatabase();
 72         //判断是否成功
 73         if(line>0)
 74             error_code = 0;
 75         else
 76             error_code = 1;
 77         //存放json格式的错误代码
 78         String json = "{\"error_code\":\""+error_code+"\"}";
 79         //返回错误代码
 80         return json;
 81     }
 82 
 83     //删除学生信息
 84     public String deleteStudentInfo(int id) throws Exception {
 85         //存放错误代码，0表示成功，1表示失败
 86         int error_code;
 87         //SQL语句
 88         String sql = "delete from student where id="+id;
 89         //调用数据库增删改方法，并返回受影响行数
 90         int line = executeUpdateDatabase(sql);
 91         //调用方法关闭数据库连接
 92         closeDatabase();
 93         //判断是否成功
 94         if(line>0)
 95             error_code = 0;
 96         else
 97             error_code = 1;
 98         //存放json格式的错误代码
 99         String json = "{\"error_code\":\""+error_code+"\"}";
100         //返回错误代码
101         return json;
102     }
103 
104     //修改学生信息
105     public String updateStudentInfo(Student info) throws Exception {
106         //存放错误代码，0表示成功，1表示失败
107         int error_code;
108         //SQL语句
109         String sql = "update student set name='"+info.getName()+"',pwd='"+info.getPwd()+"',age="+info.getAge()+",address='"+info.getAddress()+"',sex='"+info.getSex()+"',classid="+info.getClassid()+" where id="+info.getId();
110         //调用数据库增删改方法，并返回受影响行数
111         int line = executeUpdateDatabase(sql);
112         //调用方法关闭数据库连接
113         closeDatabase();
114         //判断是否成功
115         if(line>0)
116             error_code = 0;
117         else
118             error_code = 1;
119         //存放json格式的错误代码
120         String json = "{\"error_code\":\""+error_code+"\"}";
121         //返回错误代码
122         return json;
123     }
124 }

接下来写servlet，先写查询的servlet

为了方便，直接再get方法里面调用post方法，这样可以同时支持get和post两种方式

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //直接调用post方法，这样可以支持get和post两种
        doPost(request,response);
    }

然后不管怎么样，先设置好编码格式

//设置编码格式
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");

这样就防止出现乱码的问题了，接着我们把查询的servlet给完成

 1 package org.lanqiao.servlet;
 2 
 3 import org.lanqiao.dao.Dao;
 4 
 5 import javax.servlet.ServletException;
 6 import javax.servlet.annotation.WebServlet;
 7 import javax.servlet.http.HttpServlet;
 8 import javax.servlet.http.HttpServletRequest;
 9 import javax.servlet.http.HttpServletResponse;
10 import java.io.IOException;
11 import java.io.PrintWriter;
12 
13 @WebServlet(name = "getStudentInfoAll")
14 public class getStudentInfoAll extends HttpServlet {
15     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
16         //设置编码格式
17         request.setCharacterEncoding("utf-8");
18         response.setCharacterEncoding("utf-8");
19         //创建一个dao的对象
20         Dao dao = new Dao();
21         //创建一个字符串变量进行接受json数据
22         String json = null;
23         try {
24             //接收处理过的json格式
25             json = dao.selectStudentInfo();
26         } catch (Exception e) {
27             e.printStackTrace();
28         }
29         //创建一个PrintWriter对象，向页面写内容
30         PrintWriter out=response.getWriter();
31         //把json写到页面上
32         out.println(json);
33     }
34 
35     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
36         //直接调用post方法，这样可以支持get和post两种
37         doPost(request,response);
38     }
39 }

接下来写添加的servlet，前面还是一样的操作，设置编码啥的，这些不管写啥都是要先写上去，确保没问题

 1 package org.lanqiao.servlet;
 2 
 3 import org.lanqiao.bean.Student;
 4 import org.lanqiao.dao.Dao;
 5 
 6 import javax.servlet.ServletException;
 7 import javax.servlet.annotation.WebServlet;
 8 import javax.servlet.http.HttpServlet;
 9 import javax.servlet.http.HttpServletRequest;
10 import javax.servlet.http.HttpServletResponse;
11 import java.io.IOException;
12 import java.io.PrintWriter;
13 
14 @WebServlet(name = "insertStudentInfo")
15 public class insertStudentInfo extends HttpServlet {
16     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
17         //设置编码格式
18         request.setCharacterEncoding("utf-8");
19         response.setCharacterEncoding("utf-8");
20         //获取前端传过来的参数
21         String name = request.getParameter("name");
22         String pwd = request.getParameter("pwd");
23         int age = Integer.parseInt(request.getParameter("age"));
24         String address = request.getParameter("address");
25         String sex = request.getParameter("sex");
26         int classid = Integer.parseInt(request.getParameter("classid"));
27         //创建一个Student对象存放数据
28         Student info = new Student(0,name,pwd,age,address,sex,classid);
29         //创建一个dao对象
30         Dao dao = new Dao();
31         //新建一个字符串变量准备接受json
32         String json = null;
33         try {
34             //调用方法插入学生信息，并接受错误代码
35             json = dao.insertStudentInfo(info);
36         } catch (Exception e) {
37             e.printStackTrace();
38         }
39         //创建一个PrintWriter对象，向页面写内容
40         PrintWriter out=response.getWriter();
41         //把json写到页面上
42         out.println(json);
43     }
44 
45     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
46         //直接调用post方法，这样可以支持get和post两种
47         doPost(request,response);
48     }
49 }

删除的servlet

 1 package org.lanqiao.servlet;
 2 
 3 import org.lanqiao.dao.Dao;
 4 
 5 import javax.servlet.ServletException;
 6 import javax.servlet.annotation.WebServlet;
 7 import javax.servlet.http.HttpServlet;
 8 import javax.servlet.http.HttpServletRequest;
 9 import javax.servlet.http.HttpServletResponse;
10 import java.io.IOException;
11 import java.io.PrintWriter;
12 
13 @WebServlet(name = "deleteStudentInfoById")
14 public class deleteStudentInfoById extends HttpServlet {
15     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
16         //设置编码格式
17         request.setCharacterEncoding("utf-8");
18         response.setCharacterEncoding("utf-8");
19         //获取到要删除的学生信息的id
20         int id = Integer.parseInt(request.getParameter("id"));
21         //创建一个dao的对象
22         Dao dao = new Dao();
23         //创建一个字符串变量进行接受json数据
24         String json = null;
25         try {
26             //调用方法删除学生信息，并返回错误代码
27             json = dao.deleteStudentInfo(id);
28         } catch (Exception e) {
29             e.printStackTrace();
30         }
31         //创建一个PrintWriter对象，向页面写内容
32         PrintWriter out=response.getWriter();
33         //把json写到页面上
34         out.println(json);
35     }
36 
37     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
38         //直接调用post方法，这样可以支持get和post两种
39         doPost(request,response);
40     }
41 }

修改的servlet

 1 package org.lanqiao.servlet;
 2 
 3 import org.lanqiao.bean.Student;
 4 import org.lanqiao.dao.Dao;
 5 
 6 import javax.servlet.ServletException;
 7 import javax.servlet.annotation.WebServlet;
 8 import javax.servlet.http.HttpServlet;
 9 import javax.servlet.http.HttpServletRequest;
10 import javax.servlet.http.HttpServletResponse;
11 import java.io.IOException;
12 import java.io.PrintWriter;
13 
14 @WebServlet(name = "updateStudentInfoById")
15 public class updateStudentInfoById extends HttpServlet {
16     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
17         //设置编码格式
18         request.setCharacterEncoding("utf-8");
19         response.setCharacterEncoding("utf-8");
20         //获取前端传过来的参数
21         int id = Integer.parseInt(request.getParameter("id"));
22         String name = request.getParameter("name");
23         String pwd = request.getParameter("pwd");
24         int age = Integer.parseInt(request.getParameter("age"));
25         String address = request.getParameter("address");
26         String sex = request.getParameter("sex");
27         int classid = Integer.parseInt(request.getParameter("classid"));
28         //创建一个Student对象存放数据
29         Student info = new Student(id,name,pwd,age,address,sex,classid);
30         //创建一个dao对象
31         Dao dao = new Dao();
32         //新建一个字符串变量准备接受json
33         String json = null;
34         try {
35             //调用方法修改学生信息，并接受错误代码
36             json = dao.updateStudentInfo(info);
37         } catch (Exception e) {
38             e.printStackTrace();
39         }
40         //创建一个PrintWriter对象，向页面写内容
41         PrintWriter out=response.getWriter();
42         //把json写到页面上
43         out.println(json);
44     }
45 
46     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
47         //直接调用post方法，这样可以支持get和post两种
48         doPost(request,response);
49     }
50 }

那么这个简单的增删改查的后端也就写好了，我们部署到Tomcat上面试试有没有问题

结果让我意想不到的是，idea上面部署没那么容易，折腾到现在也有点累了，尝试了很多方法一直部署不上，以后再做测试吧