javaWeb核心技术02--Servlet(Servlet-HTTP)

Servlet：server applet

相关知识

• 概念：运行在服务器端的小程序
• Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。
• 将来我们自定义一个类，实现Servlet接口，复写方法。

快速入门

1. 创建JavaEE项目 创建项目选择web application/配置好tomcat和servlet
2. 定义一个类，实现Servlet接口
   • public class ServletDemo1 implements Servlet
3. 实现接口中的抽象方法
4. 配置Servlet
   • 在web.xml中配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>demo1</servlet-name>
        <servlet-class>cn.jwang.web.servlet.ServletDemo1</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo1</servlet-name>
        <url-pattern>/demo1</url-pattern>
    </servlet-mapping>
</web-app>

5. 执行原理：
   1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
   2. 查找web.xml文件，是否有对应的<url-pattern>标签体内容。
   3. 如果有，则在找到对应的<servlet-class>全类名
   4. tomcat会将字节码文件加载进内存，并且创建其对象
   5. 调用其方法

Servlet中的生命周期方法：

1. 被创建：执行init方法，只执行一次
   • Servlet什么时候被创建？
     • 默认情况下，第一次被访问时，Servlet被创建
     • 可以配置执行Servlet的创建时机。
       • 在 标签下配置
         1. 第一次被访问时，创建
            • <load-on-startup>的值为负数
         2. 在服务器启动时，创建
            • <load-on-startup>的值为0或正整数

* Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的
    * 多个用户同时访问时，可能存在线程安全问题。
    * 解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要修改值

2. 提供服务：执行service方法，执行多次
   • 每次访问Servlet时，Service方法都会被调用一次。
3. 被销毁：执行destroy方法，只执行一次
   • Servlet被销毁时执行。服务器关闭时，Servlet被销毁
   • 只有服务器正常关闭时，才会执行destroy方法。
   • destroy方法在Servlet被销毁之前执行，一般用于释放资源

Servlet3.0：

• 好处：

  • 支持注解配置。可以不需要web.xml了。

• 步骤：

  1. 创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml
  2. 定义一个类，实现Servlet接口
  3. 复写方法
  4. 在类上使用@WebServlet注解，进行配置
     • @WebServlet(“资源路径即URL访问的最后名”)

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {
    String name() default "";
	//相当于<Servlet-name>
    String[] value() default {};
	//代表urlPatterns()属性配置
    String[] urlPatterns() default {};
	//相当于<url-pattern>
    int loadOnStartup() default -1;
	//相当于<load-on-startup>
    WebInitParam[] initParams() default {};

    boolean asyncSupported() default false;

    String smallIcon() default "";

    String largeIcon() default "";

    String description() default "";

    String displayName() default "";
}

Servlet体系结构

• Servlet 接口 – GenericServlet抽象类–HttpServlet抽象类
• GenericServlet抽象类
  • 将Servlet接口中其他方法做了空实现，只将Service方法作为抽象
  • 定义Servlet类时，可以继承GenericServlet实现Service方法即可
    • service方法：1.获取数据（需要判断请求方式String str = req.getMethod()是get还是post）—HttpServlet
• HttpServlet（建议使用）：对http协议的一种封装，简化操作
  • 定义类继承HttpServlet方法
  • 其中定义了 doGet(){}.doPost(){}方法，只需要覆写这两个就行

Servlet相关配置

• urlpartten：servlet配置的访问路径
• 一个servlet可以定义多个URL路径 @WebServlet({"/demo4","/demo04"})
• 路径定义规则: 1. /xxx 2. /xxx/xx 3.*.do

HTTP

概念

• Hyper Text Transfer Protocol 超文本传输协议
• 传输协议：定义了，客户端和服务端通信时，发送数据的格式
  • 特点：
    • 基于TCP/IP的高级协议
    • http默认端口号为80
    • 基于请求响应模型的（一次请求对应一次响应）
    • 无状态协议：每次请求间相互独立，不能交互数据
• 历史版本
• 1.0: 每一次请求都会建立一个新的连接
• 1.1: 复用连接，缓存支持较好

请求消息数据格式（servletRequest对象）

• 请求消息：客户端发送给服务器端的数据

  • 数据格式：
    1. 请求行
    2. 请求头
    3. 请求空行
    4. 请求体

• 请求行

  • 格式：请求方式 请求URL 请求协议/版本。GET /login.html HTTP/1.1
  • 请求方式：HTTP协议中有7种请求方式，常用有2种
    • GET：请求参数在请求行中,在URL后 请求URL长度限制 不安全
    • POST：请求参数在请求体中 请求的URL长度没有限制 相对安全

• 请求头: 浏览器客户端告知服务器端个人信息

  • 格式：请求头名称：请求头值
  • 创建请求头参数：
    • User-Agent：浏览器告诉服务器，访问使用的浏览器版本信息，可以在服务器端获取该头的信息，解决浏览器兼容问题
    • Referer：告诉服务器，当前请求从哪里来 Referer: http://localhost:8080/login.html
      • 防止盗链 可以使用该referer字符串判断该连接是否是从目标连接来
      • 统计 从百度/搜狐等点击进来的人有多少

• 请求空行

• 空行

• 请求体（正文）

  • 封装POST请求消息的请求参数

响应消息数据格式

• 响应消息：服务器端发送给客户端的数据
  1. 响应行
     1. 组成：协议/版本 响应状态码 状态码描述
     2. 响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态。
        1. 状态码都是3位数字
        2. 分类：
           1. 1xx：服务器就收客户端消息，但没有接受完成，等待一段时间后，发送1xx多状态码
           2. 2xx：成功。代表：200
           3. 3xx：重定向。代表：302(重定向)，304(访问缓存)
           4. 4xx：客户端错误。
              • 404（请求路径没有对应的资源）
              • 405：请求方式没有对应的doXxx方法
           5. 5xx：服务器端错误。代表：500(服务器内部出现异常
  2. 响应头：
     1. 格式：头名称： 值
     2. 常见的响应头：
        1. Content-Type：服务器告诉客户端本次响应体数据格式以及编码格式
        2. Content-disposition：服务器告诉客户端以什么格式打开响应体数据
           • 值：
             • in-line:默认值,在当前页面内打开
             • attachment;filename=xxx：以附件形式打开响应体。文件下载
  3. 响应空行
  4. 响应体:传输的数据

• 响应字符串格式

HTTP/1.1 200 OK
Content-Type: text/html;charset=UTF-8
Content-Length: 101
Date: Wed, 06 Jun 2018 07:08:42 GMT
	
<html>
	<head>
	<title>$Title$</title>
	</head>
	<body>
 		hello , response
	</body>
</html>

Request：

service方法

• public void service(ServletRequest servletRequest, ServletResponse servletResponse)
  • tomcat服务器会根据请求url中的资源路径，创建对应的ServletDemo1的对象
  • tomcat服务器，会创建request和response对象，request对象中封装请求消息数据
  • tomcat将request和response两个对象传递给service方法，并且调用该方法
  • 程序员可以通过request对象获取请求消息数据，通过response对象设置响应消息数据
  • 服务器在给浏览器作出响应之前，会从response对象中拿程序猿设置的响应消息数据

request对象和response对象的原理

• request和response对象是由服务器创建的。我们来使用它们
• request对象是来获取请求消息，response对象是来设置响应消息
• request对象继承体系结构：ServletRequest接口继承HttpServletRequest接口实现org.apache.catalina.connector.RequestFacade 类(tomcat)

request功能

获取请求消息数据

同一个IDEA中启动两个servlet需要重新创建一个tomcat，设置不同的端口和名字

1. 获取请求行数据

   • GET /jwang/demo1?name=zhangsan HTTP/1.1

   • 方法：

     1. 获取请求方式 ：GET

        • String getMethod()

     2. 获取虚拟目录：/jwang（常用）

        • String getContextPath()

     3. 获取Servlet路径: /demo1

        • String getServletPath()

     4. 获取get方式请求参数：name=zhangsan

        • String getQueryString()

     5. 获取请求URI：/jwang/demo1（常用）

        • String getRequestURI():/jwang/demo1

        • StringBuffer getRequestURL():http://localhost/jwang/demo1

        • URL:统一资源定位符 ： http://localhost/day14/demo1 中华人民共和国

        • URI：统一资源标识符 : /day14/demo1 共和国

     6. 获取协议及版本：HTTP/1.1

        • String getProtocol()

     7. 获取客户机的IP地址：

        • String getRemoteAddr()

2. 获取请求头数据(常用)

   • 方法：
     • (*)String getHeader(String name):通过请求头的名称获取请求头的值
     • Enumeration getHeaderNames():获取所有的请求头名称

3. 获取请求体数据:

   • 请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数

   • 步骤：

     1. 获取流对象

        • BufferedReader getReader()：获取字符输入流，只能操作字符数据
        • ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据

     2. 再从流对象中拿数据

Response功能

功能：设置响应消息

1. 设置响应行
   1. 格式：HTTP/1.1 200 ok
   2. 设置状态码：setStatus(int sc)
2. 设置响应头：setHeader(String name, String value)
3. 设置响应体：
   • 使用步骤：
     1. 获取输出流
        • 字符输出流：PrintWriter getWriter()
        • 字节输出流：ServletOutputStream getOutputStream()
     2. 使用输出流，将数据输出到客户端浏览器

案例：

完成重定向

• 重定向：资源跳转的方式
• 重定向的特点:redirect
  1. 地址栏发生变化
  2. 重定向可以访问其他站点(服务器)的资源
  3. 重定向是两次请求。不能使用request对象来共享数据
• 转发的特点：forward
  1. 转发地址栏路径不变
  2. 转发只能访问当前服务器下的资源
  3. 转发是一次请求，可以使用request对象来共享数据
• 路径写法：
  1. 路径分类
     1. 相对路径：通过相对路径不可以确定唯一资源
        • 如：./index.html
        • 不以/开头，以.开头路径
        • 规则：找到当前资源和目标资源之间的相对位置关系
          • ./：当前目录
          • ../:后退一级目录
          • 当前资源：http://localhost/jwang/location.html
          • 目标资源：http://localhost/jwang/responseDemo2
          • 相对路径：./responseDemo2(./可不写，默认)
     2. 绝对路径：通过绝对路径可以确定唯一资源
        • 如：http://localhost/jwang/responseDemo2 –> /day15/responseDemo2
        • 以/开头的路径
        • 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出
          • 给客户端浏览器使用：需要加虚拟目录(项目的访问路径)
            • 建议虚拟目录动态获取：request.getContextPath()
            • <a> , <form> 重定向…
          • 给服务器使用：不需要加虚拟目录
            • 转发路径

//1. 设置状态码为302
response.setStatus(302);
//2.设置响应头location
response.setHeader("location","/jwang/responseDemo2");


//简单的重定向方法
response.sendRedirect("/jwang/responseDemo2");

response.sendRedirect("http://www.baidu.com")

服务器输出字符数据到浏览器

• 步骤：

  1. 获取字符输出流
  2. 输出数据

• 注意：

  • 乱码问题：
    1. PrintWriter pw = response.getWriter();获取的流的默认编码是ISO-8859-1
    2. 设置该流的默认编码
       • response.setCharacterEncoding(“utf-8”)
    3. 告诉浏览器响应体使用的编码
       • response.setHeader(“content-type”, “text/html;charset=utf-8”);(可以不用2的设置)
    4. 简单的形式，设置编码，是在获取流之前设置
       • response.setContentType(“text/html;charset=utf-8”);

服务器输出字节数据到浏览器

• 步骤：
  1. 获取字节输出流
  2. 输出数据

final ServletOutputStream outputStream = 
				response.getOutputStream();
outputStream.write("hello".getBytes("utf-8"));

验证码

1. 本质：图片
2. 目的：防止恶意表单注册

@WebServlet("/ServletCheckcode")
public class ServletCheckcode extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //1.创建一个对象，在内存中存图片（验证码图片对象）
        int width = 100;
        int height = 50;
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        //2.美化图片
        //2.1填充背景颜色
        Graphics g = image.getGraphics(); //画笔
        g.setColor(Color.PINK); //画笔颜色
        g.fillRect(0,0,width,height);

        //2.2边框
        g.setColor(Color.BLUE);
        g.drawRect(0,0,width-1, height-1);
        //2.3字
        String str = "AQZWSXEDCRFVTGBYHNUJMIKLOPqaxswedcvfrtgbyhnuj0123456789";
        //生产随机角标
        Random ran = new Random();

        for (int i = 0; i < 4; i++) {

            final int index = ran.nextInt(str.length());

            char ch = str.charAt(index);

            g.setColor(Color.BLACK);
            g.drawString(ch+"", width/4*i, height/2);
        }

        //2.4随机线条
        //随机坐标
        for (int i = 0; i < 6; i++) {
            final int x1 = ran.nextInt(width);
            final int x2 = ran.nextInt(width);

            final int y1 = ran.nextInt(height);
            final int y2 = ran.nextInt(height);
            g.setColor(Color.GREEN);
            g.drawLine(x1,y1,x2,y2);
        }

        //2。将图片输出到页面显示
        ImageIO.write(image, "jpg", response.getOutputStream());
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        this.doPost(request,response);
    }
}

</head>
<body>

    <img id = "checkcode" src="/jwang/ServletCheckcode" />
    <a id = "change" href="">看不清换。。。。</a>


    <script>
        window.onload = function () {

            //1.获取图片对象
            var img =  document.getElementById("checkcode");
            //2.绑定单击事件
            img.onclick = function () {
                //地址后加时间戳,使用其不使用缓存
                var date = new Date().getTime();

                img.src = "/jwang/ServletCheckcode?"+date;
            }
        }
    </script>
</body>

ServletContext对象：

基础

1. 概念：代表整个web应用，可以和程序的容器(服务器)来通信

2. 获取：

   1. 通过request对象获取 request.getServletContext();
   2. 通过HttpServlet获取 this.getServletContext();

3. 功能：

   1. 获取MIME类型：
      • MIME类型:在互联网通信过程中定义的一种文件数据类型
        • 格式： 大类型/小类型 text/html image/jpeg
      • 获取：String getMimeType(String file)
   2. 域对象：共享数据
      1. setAttribute(String name,Object value)
      2. getAttribute(String name)
      3. removeAttribute(String name)
         • ServletContext对象范围：所有用户所有请求的数据

4. 获取文件的真实(服务器)路径

   1. 方法：String getRealPath(String path)
      • String b = context.getRealPath(“/b.txt”);//web目录下资源访问
      • String c = context.getRealPath(“/WEB-INF/c.txt”);//WEB-INF目录下的资源访问
      • String a = context.getRealPath(“/WEB-INF/classes/a.txt”);//src目录下的资源访问

案例：文件下载

需求

1. 页面显示超链接
2. 点击超链接后弹出下载提示框
3. 完成图片文件下载

分析：

1. 超链接指向的资源如果能够被浏览器解析，则在浏览器中展示，如果不能解析，则弹出下载提示框。不满足需求
2. 任何资源都必须弹出下载提示框
3. 使用响应头设置资源的打开方式：
   • content-disposition:attachment;filename=xxx

步骤：

1. 定义页面，编辑超链接href属性，指向Servlet，传递资源名称参数filename
2. 定义Servlet
   1. 获取文件名称
   2. 使用字节输入流加载文件进内存(真实路径)
   3. 指定response的响应头：
      • content-disposition:attachment;filename=xxx
   4. 将数据写出到response输出流

• 问题：
  • 中文文件问题
    • 解决思路：
      1. 获取客户端使用的浏览器版本信息
      2. 根据不同的版本信息，设置filename的编码方式不同

@WebServlet("/downloadServlet")
public class DownloadServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取请求参数，文件名称
        String filename = request.getParameter("filename");
        //2.使用字节输入流加载文件进内存
        //2.1找到文件服务器路径
        ServletContext servletContext = this.getServletContext();
        String realPath = servletContext.getRealPath("/img/" + filename);
        //2.2用字节流关联
        FileInputStream fis = new FileInputStream(realPath);

        //3.设置response的响应头
        //3.1设置响应头类型：content-type
        String mimeType = servletContext.getMimeType(filename);//获取文件的mime类型
        response.setHeader("content-type",mimeType);
        //3.2设置响应头打开方式:content-disposition

        //解决中文文件名问题
        //1.获取user-agent请求头、
        String agent = request.getHeader("user-agent");
        //2.使用工具类方法编码文件名即可
        filename = DownLoadUtils.getFileName(agent, filename);

        response.setHeader("content-disposition","attachment;filename="+filename);
        //4.将输入流的数据写出到输出流中
        ServletOutputStream sos = response.getOutputStream();
        byte[] buff = new byte[1024 * 8];
        int len = 0;
        while((len = fis.read(buff)) != -1){
            sos.write(buff,0,len);
        }

        fis.close();


    }

//工具类
public class DownLoadUtils {

    public static String getFileName(String agent, String filename) throws UnsupportedEncodingException {
        if (agent.contains("MSIE")) {
            // IE浏览器
            filename = URLEncoder.encode(filename, "utf-8");
            filename = filename.replace("+", " ");
        } else if (agent.contains("Firefox")) {
            // 火狐浏览器
            BASE64Encoder base64Encoder = new BASE64Encoder();
            filename = "=?utf-8?B?" + base64Encoder.encode(filename.getBytes("utf-8")) + "?=";
        } else {
            // 其它浏览器
            filename = URLEncoder.encode(filename, "utf-8");
        }
        return filename;
    }
}

其他功能

1. 获取请求参数通用方式：不论get还是post请求方式都可以使用下列方法来获取请求参数
   1. String getParameter(String name):根据参数名称获取参数值username=zs&password=123
   2. String[] getParameterValues(String name):根据参数名称获取参数值的数组 hobby=xx&hobby=game
   3. Enumeration getParameterNames():获取所有请求的参数名称
   4. Map<String,String[]> getParameterMap():获取所有参数的map集合
   5. 中文乱码问题：
      • get方式：tomcat 8 已经将get方式乱码问题解决了
      • post方式：会乱码
        • 解决：在获取参数前，设置request的编码request.setCharacterEncoding(“utf-8”);

2. 请求转发：一种在服务器内部的资源跳转方式

   1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)

   2. 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response)

   3. 特点：

      1. 浏览器地址栏路径不发生变化
      2. 只能转发到当前服务器内部资源中。
      3. 转发是一次请求(请求是同一个,属于一次请求的作用范围)

3. 共享数据：

   • 域对象：一个有作用范围的对象，可以在范围内共享数据
   • request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据
   • 方法：
     1. void setAttribute(String name,Object obj):存储数据
     2. Object getAttitude(String name):通过键获取值
     3. void removeAttribute(String name):通过键移除键值对

4. 获取ServletContext：

   • ServletContext getServletContext()

案例：用户登录

用户登录案例需求：

1. 编写login.html登录页面 username & password 两个输入框
2. 使用Druid数据库连接池技术,操作mysql，userlogin数据库中user表
3. 使用JdbcTemplate技术封装JDBC
4. 登录成功跳转到SuccessServlet展示：登录成功！用户名,欢迎您
5. 登录失败跳转到FailServlet展示：登录失败，用户名或密码错误

分析

• 开发步骤

1. 创建项目，导入html页面，配置文件，jar包
2. 创建数据库环境
CREATE DATABASE userlogin;
USE userlogin;
CREATE TABLE USER(
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(32) UNIQUE NOT NULL,
PASSWORD VARCHAR(32) NOT NULL
);

3. 创建包cn.itcast.domain,创建类User

package cn.jwang.domain;

			/**
			 * 用户的实体类
			 */
public class User {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

4. 创建包cn.itcast.util,编写工具类JDBCUtils
/**
 * JDBC工具类 使用Druid连接池
 */
public class JDBCUtils {
    private static DataSource ds;

    static {

        try {
            //1.加载配置文件
            final Properties properties = new Properties();
            //使用classloader加载配置文件，获取字节输入流
            final InputStream resourceAsStream = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            properties.load(resourceAsStream);

            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //2。初始化连接池




    }
    /**
     * 获取连接池对象
     * @return
     */
    public static DataSource getDataSource(){
        return ds;
    }

    /**
     * 获取连接connection对象
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
}

5. 创建包cn.itcast.dao,创建类UserDao,提供login方法
			
package cn.jwang.dao;

import cn.jwang.domain.User;
import cn.jwang.util.JDBCUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * 操作数据库中User表
 */

public class UserDao {

    //申明JDBCTemplate对象共用
    private final JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    /**
     * 登陆方法
     * @param loginUser 只有用户名和密码
     * @return 包含用户全部数据
     */
    public User login(User loginUser) {
        try {
            //编写sql
            String sql = "select * from user where username = ? and password = ?";
            //调用query方法
            final User user = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class),
                    loginUser.getUsername(), loginUser.getPassword());
            return user;
        } catch (DataAccessException e){
            e.printStackTrace();
            return null;
        }
    }
}
		
6. 编写cn.itcast.web.servlet.LoginServlet类
package cn.jwang.servlet;

import cn.jwang.dao.UserDao;
import cn.jwang.domain.User;

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 java.io.IOException;

@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }


    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码和获取请求参数
        request.setCharacterEncoding("utf-8");
        final String username = request.getParameter("username");
        final String password = request.getParameter("password");

        //封装user对象
        User loginuser = new User();
        loginuser.setUsername(username);
        loginuser.setPassword(password);

        //调用userdao的login方法，进行数据库操作，查询用户是否存在
        UserDao dao = new UserDao();
        final User user = dao.login(loginuser);

        if (user == null) {
            //用户不存在，登陆失败，转接
            request.getRequestDispatcher("/failServlet").forward(request, response);
        } else {
            //存储user对象的数据信息，并转发
            request.setAttribute("user", user);
            request.getRequestDispatcher("/successServlet").forward(request, response);

        }

    }
}

7. 编写FailServlet和SuccessServlet类
package cn.jwang.servlet;

import cn.jwang.domain.User;

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 java.io.IOException;

@WebServlet("/successServlet")
public class successServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html;charset=utf-8");
        final User user = (User)request.getAttribute("user");
        if(user != null){
            response.getWriter().write("用户"+user.getUsername()+"您好");
        }


    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        this.doPost(request, response);
    }
}	


@WebServlet("/failServlet")
public class failServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html;charset=utf-8");

        response.getWriter().write("登陆失败，用户名或者密码错误");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        this.doPost(request,response);
    }
}

8. login.html中form表单的action路径的写法

   • 虚拟目录+Servlet的资源路径

9. BeanUtils工具类，简化数据封装 用于封装JavaBean的(一般放在domain中)

   1. JavaBean：标准的Java类 功能：封装数据
      1. 类必须被public修饰
      2. 必须提供空参的构造器
      3. 成员变量必须使用private修饰
      4. 提供公共setter和getter方法
   2. 概念：
      • 成员变量：方法的
      • 属性：setter和getter方法截取后的产物
        • 例如：getUsername() –> Username–> username
   3. 方法：
      1. setProperty()：设置属性值
      2. getProperty()：获取属性值
      3. populate(Object obj , Map map):将map集合的键值对信息，封装到对应的JavaBean对象中

//获取所有请求参数
        final Map<String, String[]> map = request.getParameterMap();
        //创建uer对象
        User loginuser = new User();

        //使用Apache的BeanUtils进行封装
        try {
            BeanUtils.populate(loginuser, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }