JavaWeb从入门到精通！第二天！(Servlet)

一、Servlet

1. Java Servlet

Java Servlet 是服务端的一个技术，是对服务器的一种小型可插拔的扩充，用于提高服务器性能，由于使用 Java 语言编写，所以可以跨平台，Servlet 的内部以多线程的方式提供服务，所以不必对每个请求都去创建一个 Servlet 来处理，利用多线程方式一个Servlet就可以给多个请求服务，效率非常高。

2. 开发 Servlet 的方法

要开发自定义的 Servlet，需要继承 javax.servlet.GenericServlet(原生的Servlet) 或 javax.servlet.http.HttpServlet(基于http的Servlet)，然后重写父类方法来实现自定义 Servlet，其中GenericServlet 是 HttpServlet 的父类。

2.1 通过继承 GenericServlet 实现自定义 Servlet

2.1.1 eclipse 操作

2.1.2 源码

package com.edu.ctrl;

import java.io.IOException;
import javax.servlet.GenericServlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;

/**
 * @WebServlet("/userServlet")：该注解的作用是指定该 Servlet 的 URL 地址，跟访问 JSP 页面类似，访问该 Servlet 
 * 的完整 URL 地址就是：http://localhost:8080/javaweb2/userServlet
 */
@WebServlet("/userServlet")
public class UserServlet extends GenericServlet {
    private static final long serialVersionUID = 1L;
       
    //UserServlet 的默认构造函数，Web 服务器在创建该 Servlet 实例的时候调用(不是程序员手工调用的)
    public UserServlet() {
       System.out.println("UserServlet 的默认构造函数被调用");
    }

    /**
     * 以下方都是该 Servlet 的生命周期方法，由Web服务器自动调用，不是程序员手动调用的
     * init()：UserServlet 的初始化方法，可以完成初始化，该方法是在客户端第一次请求 UserServlet 的时候由服务器调用一次，
     * 后续请求就不再调用了，而方法的参数 config 就是 JSP 的内置对象 config
     */
    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
        System.out.println("UserServlet 的 init() 方法");
    }

    /**
     * service()：Servlet 的核心服务方法，当客户端请求该 Servlet 的时候，例如发送 GET 或 POST 请求到该 Servlet 的时候，
     * Web 服务器就会调用该 service() 方法来响应客户端请求。
     * 该方法工作在多线程的环境中，其参数 request 和 response 表示原生的请求和响应对象，不是 HttpServletRequest 和 
     * HttpServletResponse
     */
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        System.out.println("UserServlet 的 service() 方法");
        System.out.println(this);//this 指当前 UserServlet 实例本身
        System.out.println("当前线程：" + Thread.currentThread().getName());
    }
    
    //当 UserServlet 被销毁的时候自动调用的方法
    public void destroy() {
        // TODO Auto-generated method stub
        System.out.println("UserServlet 的 destroy() 方法");
    }

}

2.1.3 测试查看结果

从上面执行结果可知，默认情况下，我们启动服务器的时候，服务器并没有调用 Servlet 的默认构造方法来产生实例。

然后我们第一次请求该页面：

后续再发多次请求：

从上面分析可知，默认情况下，该 Servlet 的实例是在客户端第一请求它的时候由 Tomcat 服务器创建，并且init()也是在客户端第一次请求该Servlet时被调用一次，以后请求就不在调用。

service() 是在客户端每一次请求的时候都会被 Tomcat 调用一次，来响应客户端请求，并且可以发现Servlet是单例多线程的组件，所以，Servlet 中最好不要包含成员变量，因为可能会有多线程安全问题。

然后我们修改该 Servlet 再保存，那么应用会重新加载 Servlet，destroy() 方法就被调用了，查看控制台信息：

2.1.4 Servlet的生命周期图：

2.2 通过继承 HttpServlet 实现自定义 Servlet

javax.servlet.http.HttpServlet 继承于 GenericServlet，我们平时去继承 HttpServlet 来自定义 Servlet 的方式用的比较多。

有两种方式来定义：

2.2.1 通过注解的方式来定义

HttpUserServlet：

package com.edu.ctrl;

import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @WebServlet("/httpUserServlet")：该注解的作用是指定该 Servlet 的 URL 地址，跟访问 JSP 页面类似，访问该 Servlet 
 * 的完整 URL 地址就是：http://localhost:8080/javaweb2/httpUserServlet
 * initParams：用于定义初始化参数，其中包含了 @WebInitParam 注解组成的数组，代表每一个初始化参数，可以通过 init() 方法
 * 的 config 对象读取
 */
@WebServlet(value = "/httpUserServlet", initParams = {@WebInitParam(name = "param", value = "注解式的初始化参数")})
public class HttpUserServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    
    //HttpUserServlet 的默认构造函数，默认情况下是客户端第一次请求该 Servlet 的时候由服务器调用一次
    public HttpUserServlet() {
        super();
        // TODO Auto-generated constructor stub
        System.out.println("HttpUserServlet 的默认构造函数");
    }

    /**
     * 该 Servlet 的初始化方法，也是客户端第一次请求该 Servlet 的时候由服务器调用一次，完成初始化工作，
     * 其参数 config 用于读取初始化参数
     */
    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
        System.out.println("HttpUserServlet 的 init() 方法");
        String value = config.getInitParameter("param");
        System.out.println("初始化参数：" + value);
    }

    /**
     * 每次 HttpUserServlet 收到客户端的 GET 请求的时候，该方法被 Web 服务器调用一次，其参数 request 和 response 分别
     * 表示请求和响应对象，它们和 JSP 中的 request 和 response 是同一个对象。
     * 同时 HttpUserServlet 也是单例多线程的
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        System.out.println("HttpUserServlet 的 doGet() 方法");
        System.out.println(this);//this 指当前 HttpUserServlet 实例本身
        System.out.println("当前线程:" + Thread.currentThread().getName());
    }

    /**
     * 每次 HttpUserServlet 收到客户端的 POST 请求的时候，该方法被 Web 服务器调用一次，其参数 request 和 response 分别
     * 表示请求和响应对象，它们和 JSP 中的 request 和 response 是同一个对象。
     * 同时 HttpUserServlet 也是单例多线程的
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        System.out.println("HttpUserServlet 的 doPost() 方法");
        System.out.println(this);//this 指当前 HttpUserServlet 实例本身
        System.out.println("当前线程:" + Thread.currentThread().getName());
    }

    //当HttpUserServlet 被销毁的时候调用的方法
    public void destroy() {
        // TODO Auto-generated method stub
        System.out.println("HttpUserServlet 的 destroy() 方法");
    }
}

form.jsp：由于 URL 地址输入，以及超链接点击都是属于 get 请求，我们写一个表单来做 post 请求

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>form</title>
</head>
<body>
    <form action="httpUserServlet" method="post">
        <input type="submit" value="提交">
    </form>
</body>
</html>

测试：

启动服务器的时候没有创建该Servlet：

然后在浏览器地址栏输入URL地址发送GET请求：

工作流程和 GenericServlet 类似，只是这里是 doGet() 方法来响应客户端请求的。

然后我们使用表单发送 POST 请求：

工作流程和 GenericServlet 也类似，只是是 doPost 方法来响应

可以看出，基于 HttpServlet 的自定义 Servle t也是一个单例多线程的组件，它通过它的 doGet() 和 doPost() 方法来响应客户端的 GET 和 POST 请求。

2.2.2 通过 web.xml(部署描述文件)配置文件来配置 Servlet

注意：注解方式和 web.xml 方式配置 Servlet 只能二选一

第一步：在工程上右键：

第二步：删除 HttpUserServlet 的注解配置，然后在 web.xml 中配置：

测试：

过程和注解方式一样，从运行的日志信息可以看出，Servlet 默认情况下是在用户第一次发送请求之后才去实例化和初始化，而不是在服务器启动时就实例化，这样可以节约内存，但是第一次响应客户端请求的速度变慢了，属于时间换空间。当然我们也可以将其配置成服务器启动时就实例化。

然后 HttpServle t除了有 doGet() 和 doPost() 方法之外，还有如下方法对应 HTTP 的不同请求方式：

doGet()：处理 GET 请求，doPost()：处理 POST 请求，doPut()：处理 PUT 请求，doDelete()：处理 DELETE 请求，doHead()：处理 HEAD 请求，doOptions()：处理 OPTIONS 请求，doTrace()：处理 TRACE 请求。

2.2.2.1 初始化参数

Servlet 实例在没有处理任何请求之前，init() 方法会被调用一次，来完成该 Servlet 的初始化工作，该方法包含的参数就是初始化参数，初始化参数可以在web.xml中配置：

示例：web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>javaweb2</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
  <!– 配置 HttpUserServlet –>
  <servlet>
      <!– 配置该Servlet 的名称，名称随意 –>
      <servlet-name>HttpUserServlet</servlet-name>
      <!– 配置该 Servlet 的完整类名 –>
      <servlet-class>com.edu.ctrl.HttpUserServlet</servlet-class>
      <!– 初始化参数 –>
      <init-param>
          <!– 参数名 –>
          <param-name>param1</param-name>
          <!– 参数值 –>
          <param-value>在 web.xml 中配置的初始化参数1</param-value>
      </init-param>
      <!– 初始化参数 –>
      <init-param>
          <!– 参数名 –>
          <param-name>param2</param-name>
          <!– 参数值 –>
          <param-value>在 web.xml 中配置的初始化参数2</param-value>
      </init-param>
  </servlet>
  <!– 配置 HttpUserServlet 的 URL 地址映射 –>
  <servlet-mapping>
      <!– 配置该Servlet 的名称，名称需要和上面的一致 –>
      <servlet-name>HttpUserServlet</servlet-name>
      <!– 配置 HttpUserServlet 部署到 Tomcat 的URL 地址，完整地址：http://localhost:8080/javaweb2/httpUserServlet  –>
      <url-pattern>/httpUserServlet</url-pattern>
  </servlet-mapping>
</web-app>

然后在 HttpUserServlet 的 init() 方法中读取：

请求该Servlet 看一下：

2.2.2.2 启动装入优先级

启动装入优先级是指 Servlet容器(Tomcat服务器) 在启动的时候加载 Servlet 的优先顺序，我们可以在 web.xml 中配置来指明启动装入优先级，值越小，优先级越高，启动的时候越靠前。

示例：web.xml

测试：启动服务器，但是不去请求 HttpUserServlet：

可以看出，我们把启动优先级设置为 1 的时候，在服务器启动的时候，还没有发出第一次请求到该 Servle t的时候，该 Servlet 就已经被实例化和初始化，这样属于空间换时间，即我们第一次去请求该 Servlet 的时候速度加快了。

3. Servlet 的请求和响应

3.1 上面的 GenericServlet 的 service() 方法包含两个参数：

3.2 ServletRequest 对象

表示原生的请求对象，当 Servlet 接收到一个请求时，由 Servlet 容器(Tomcat服务器)创建 request 对象并传递给service() 方法参数。

3.2.1 常用方法：

1. public int getContentLength()：获取请求数据部分的长度

2. pubic String getContentType()：获取 MIME 类型

3. public String getParamter(String name)：获取请求参数/表单参数

4. public String[] getParamterValues(String name)：获取请求参数值组成的数组。

5. public String getRemoteAddr()：获取远程主机IP地址

6. public String getServerName()：获取Servlet容器（Tomcat服务器）的名称

7. public int getServerPort()：返回服务器监听的端口号

3.3 HttpServletRequest 对象

表示 request 对象，HttpServlet 的 doGet() 和 doPost() 方法都包含这个参数，这个参数也是当 HttpServlet 接收到客户端请求的时候由 Servlet 容器创建并传递给 doGet() 和 doPost() 方法参数。其中 HttpServletRequest 继承于 ServletRequest，并且还扩展了一些方法：

3.3.1 常用方法

1. public String getAuthType()：返回客户端采用的身份验证方案（如BASIC或SSL）

2. public Cookie[] getCookies()：返回Cookie组成的数组

3. public String getHeader(String name)：返回请求头的值

4. public Enumeration getHeaders(String name)：返回请求头组成的数组

5. public long getDateHeader(String name),public int getIntHeader(String name)：读取指定的请求头的值，分别转换为Date和int类型

6. public String getRequestURI()：返回请求的URI地址

7. public StringBuffer getRequestURL()：返回请求的URL地址

8. public String getServletPath()：返回正在被调用的Servlet路径

9. public String getContextPath()：获取工程上下文路径

10. public String getMethod()：获取请求的方式，GET，POST或PUT等等

示例：HttpUserServlet.java

package com.edu.ctrl;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HttpUserServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    
    //HttpUserServlet 的默认构造函数，默认情况下是客户端第一次请求该 Servlet 的时候由服务器调用一次
    public HttpUserServlet() {
        super();
        // TODO Auto-generated constructor stub
        System.out.println("HttpUserServlet 的默认构造函数");
    }

    /**
     * 该 Servlet 的初始化方法，也是客户端第一次请求该 Servlet 的时候由服务器调用一次，完成初始化工作，
     * 其参数 config 用于读取初始化参数
     */
    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
        System.out.println("HttpUserServlet 的 init() 方法");
    }

    /**
     * 每次 HttpUserServlet 收到客户端的 GET 请求的时候，该方法被 Web 服务器调用一次，其参数 request 和 response 分别
     * 表示请求和响应对象，它们和 JSP 中的 request 和 response 是同一个对象。
     * 同时 HttpUserServlet 也是单例多线程的
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        //获取 out 对象
        PrintWriter out = response.getWriter();
        String requestURI = request.getRequestURI();
        out.println("requestURI:" + requestURI);
        StringBuffer requestURL = request.getRequestURL();
        out.println("requestURL:" + requestURL);
        String servletPath = request.getServletPath();
        out.println("servletPath:" + servletPath);
        String contextPath = request.getContextPath();
        out.println("contextPath:" + contextPath);
    }

    /**
     * 每次 HttpUserServlet 收到客户端的 POST 请求的时候，该方法被 Web 服务器调用一次，其参数 request 和 response 分别
     * 表示请求和响应对象，它们和 JSP 中的 request 和 response 是同一个对象。
     * 同时 HttpUserServlet 也是单例多线程的
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

    //当HttpUserServlet 被销毁的时候调用的方法
    public void destroy() {
        // TODO Auto-generated method stub
    }
}
 

web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>javaweb2</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
  <!– 配置 HttpUserServlet –>
  <servlet>
      <!– 配置该Servlet 的名称，名称随意 –>
      <servlet-name>HttpUserServlet</servlet-name>
      <!– 配置该 Servlet 的完整类名 –>
      <servlet-class>com.edu.ctrl.HttpUserServlet</servlet-class>
    <!– 启动装入优先级为 1，是一个比较小的数，优先级就比较高 –>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <!– 配置 HttpUserServlet 的 URL 地址映射 –>
  <servlet-mapping>
      <!– 配置该Servlet 的名称，名称需要和上面的一致 –>
      <servlet-name>HttpUserServlet</servlet-name>
      <!– 配置 HttpUserServlet 部署到 Tomcat 的URL 地址，完整地址：http://localhost:8080/javaweb2/httpUserServlet  –>
      <url-pattern>/httpUserServlet</url-pattern>
  </servlet-mapping>
</web-app>

测试：直接请求 HttpUserServlet：

3.4 ServletResponse 对象

表示原生的响应对象，也是由 Servlet 容器自动赋值的

3.4.1 常用方法

1. public String getContentType()：获取响应头的MIME类型

2. public String getCharacterEncoding()：获取响应的字符编码

3. public void setContentType(String type)：设置响应头的MIME类型以及字符编码

3.5 HttpServletResponse 对象

即 response 对象，继承于 ServletResponse

3.5.1 常用的方法

1. public void addCookie(Cookie cookie)：添加一个Cookie

2. public void sendError(int sc)：按照指定的状态码返回一个出错消息给客户端

3. public void sendError(int sc, String message)：按照指定的状态码和出错信息返回一个出错消息给客户端

常见的状态码：

4. public void sendRedirect(String location)：重定向

5. public void setHeader(String name,String value)：设置响应头

6. pubic void setStatus(int sc)：设置状态码，例如：response.setStatus(response.SC_OK);

7. public void flushBuffer()：刷新缓冲区

8. public void int getBufferSize()：获取缓冲区大小

9. public void setBufferSize()：设置缓冲区大小

示例：改进之后的登录

1. 创建数据库表

2. 创建 JavaBean，要求 JavaBean 的属性名要和表的字段同名，因为后面我们的工具类 DbHelper 要用到反射

package com.edu.beans;

public class User {
    private int id;
    private String name;
    private String pwd;
    private int age;
    private String sex;
    
    public User() {
        // TODO Auto-generated constructor stub
    }

    public User(String name, String pwd, int age, String sex) {
        super();
        this.name = name;
        this.pwd = pwd;
        this.age = age;
        this.sex = sex;
    }

    public User(int id, String name, String pwd, int age, String sex) {
        super();
        this.id = id;
        this.name = name;
        this.pwd = pwd;
        this.age = age;
        this.sex = sex;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

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

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", pwd=" + pwd + ", age=" + age + ", sex=" + sex + "]";
    }
}
 

3. 给 Web 工程导入 mysql 驱动，我们需要将 mysql 的驱动拷贝到 Web 工程的 WEB-INF/lib 目录，因为Web 工程在运行的时候会去 WEB-INF/lib 目录中去找第三方的 jar 包，所以必须要放在 WEB-INF/lib 目录中。

eclipse 会自动将 WEB-INF/lib 目录中的 jar 包添加到工程构建路径中，不要自己去添加

3. 拷贝之前写的 ConnectionFactory 以及 DbHelper 工具类到当前工程中：

5. 登录页面 login.jsp：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
    <%–
        我们给表单请求的 Servlet 的 URL 地址后拼接一个请求参数 action=login 来指明当前的请求是登录请求，同理，
        其他的请求(例如查询用户请求，删除用户请求等等），也可以用这种方式来请求该 Servlet，由于 Servlet 是单例多线程的，
        我们可以使用一个 Servlet 来响应用户的不同请求，而不是每个不同的请求都去创建一个 Servlet 来处理。
        注意：如果 form 的 action 属性附加了请求参数，则 method 不能使 get，因为要报错，只能是 post
     –%>
    <form action="httpUserServlet?action=login" method="post">
        <%–表单元素，我们的请求参数就是这些表单元素的值 –%>
        姓名：<input type="text" name="name"> <br>
        密码：<input type="password" name="pwd"> <br>
        <br>
        <input type="submit" value="登录">
    </form>
    <div style="color:red;"><%=session.getAttribute("errormsg")==null ?"":session.getAttribute("errormsg")%></div>
    <%–刷新页面时，不能再显示出错信息，这里就是将 session 域的出错信息删除 –%>
    <%session.removeAttribute("errormsg"); %>
</body>
</html>

6. 创建 HttpUserServlet：

package com.edu.ctrl;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.edu.beans.User;
import com.edu.utils.DbHelper;

@WebServlet("/httpUserServlet")
public class HttpUserServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    
    //HttpUserServlet 的默认构造函数，默认情况下是客户端第一次请求该 Servlet 的时候由服务器调用一次
    public HttpUserServlet() {
        super();  
    }

    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
    
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doPost(request, response);    //客户端如果发 GET 请求，也去请求 doPost()
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        //设置字符编码
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        //获取前端页面发送过来的 action 请求参数来判断是哪一种请求
        String action = request.getParameter("action");
        switch (action) {
            case "login": {//处理登录请求
                 //获取表单参数
                 String name = request.getParameter("name");
                 String pwd = request.getParameter("pwd");
                 String sql = "select * from users where name=? and pwd=?";
                 User user = DbHelper.getBean(User.class, sql, name, pwd);
                 if(user == null) { //没找到记录，登录失败
                     //往session域中放入errormsg信息
                     request.getSession().setAttribute("errormsg", "用户名或密码错误，请重新登录!");
                     //重定向到登录页
                     response.sendRedirect("login.jsp");
                 }else { //否则就登录成功
                     //登录成功就将用户的所有信息查询出来通过表格显示
                     String sql2 = "select * from users";
                     List<User> users = DbHelper.getList(User.class, sql2, null);
                     //将users放入session域
                     request.getSession().setAttribute("users", users);
                     request.getSession().setAttribute("name", user.getName());//在放入登录成功的用户名
                     //重定向到主页显示用户信息
                     response.sendRedirect("index.jsp");
                }
                break;
            }
            case "getusers": {//处理获取用户信息请求
                
            }
            break;
            case "insertuser": {//处理录入用户信息请求
                
            }
            break;
            case "deleteuser": {//处理删除用户信息
                
            }
            break;
            case "updateuser": {//处理更新用户信息请求
                
            }
            break;
            default:
                break;
        }
    }

    //当HttpUserServlet 被销毁的时候调用的方法
    public void destroy() {
        // TODO Auto-generated method stub
    }
}

7. index.jsp：

 <%@page import="com.edu.beans.User"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>主页</title>
</head>
<body>   
 <h1>欢迎回来：<%=session.getAttribute("name") %></h1>
 <h3>所有用户信息：</h3>
 <table border="1" cellpadding="0" cellspacing="0"> 
     <tr>
         <th>编号</th>
         <th>姓名</th>
         <th>密码</th>
         <th>年龄</th>
         <th>性别</th>
         <th>操作</th>
     </tr>
     <%
         List<User> users = (List<User>)session.getAttribute("users");
         for(User user : users){
     %>
         <tr>
             <td><%=user.getId() %></td>
             <td><%=user.getName() %></td>
             <td><%=user.getPwd() %></td>
             <td><%=user.getAge() %></td>
             <td><%=user.getSex() %></td>
             <td>
                 <a href="">删除</a>
                 <a href="">更新</a>
             </td>
         </tr>
     <%      
         }
     %>
 </table>
</body>
</html>

8. 测试：

先测试登录失败：

然后以正确用户密码登录：