Request

Request：

request对象和response对象的原理

1. request和response对象是由服务器创建的。我们来使用它们
2. request对象是来获取请求消息，response对象是来设置响应消息

request对象继承体系结构：

ServletRequest – 接口
| 继承
HttpServletRequest – 接口
| 实现
org.apache.catalina.connector.RequestFacade 类(tomcat)

request功能：

获取请求消息数据

• 获取请求行数据

  GET /day14/demo1?name=zhangsan HTTP/1.1
  • 方法：

  1. 获取请求方式 ：GET
     String getMethod()

  2. (*)获取虚拟目录：/day14
     String getContextPath()

  3. 获取Servlet路径: /demo1
     String getServletPath()

  4. 获取get方式请求参数：name=zhangsan
     String getQueryString()

  5. (*)获取请求URI：/day14/demo1
     String getRequestURI() : /day14/demo1
     StringBuffer getRequestURL() :http://localhost/day14/demo1

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

  6. 获取协议及版本：HTTP/1.1
     String getProtocol()

  7. 获取客户机的IP地址：
     String getRemoteAddr()

@WebServlet("/reqdemo01")
public class RequestDemo01 extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse resp) throws ServletException, IOException {

        /*http://localhost:8080/day03/reqdemo01?name=long*/
        // 获取请求方式
        String method = request.getMethod();
        System.out.println(method); // GET

        // 获取虚拟目录
        String contextPath = request.getContextPath();
        System.out.println(contextPath); ///day03

        // 获取servlet 路径
        String servletPath = request.getServletPath();
        System.out.println(servletPath); // /reqdemo01

        // 获取get方式的请求参数
        String queryString = request.getQueryString();
        System.out.println(queryString); //name=long

        // 获取协议及版本
        String protocol = request.getProtocol();
        System.out.println(protocol);  //HTTP/1.1

        // 获取客户端的ip
        String ip = request.getRemoteAddr();
        System.out.println(ip); //0:0:0:0:0:0:0:1

    }
}

• 获取请求头数据

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

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 获取所有的请求头名称  Enumeration迭代器
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()){
            String headerName = headerNames.nextElement();
//            System.out.println(headName);
            String header = request.getHeader(headerName);
            System.out.println(headerName+":"+header);
        }
        
    }

通过agent判断浏览器

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:user-agent
        String agent = request.getHeader("user-agent");
        // 通过agent 判断浏览器的版本
        if (agent.contains("Chrome")){
            // 谷歌
            System.out.println("谷歌来了");
        }else if(agent.contains("Firefox")){
            //火狐
            System.out.println("火狐来了...");
        }
    }

referer 防盗链

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

    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:referer
        String referer = request.getHeader("referer");

        // http://localhost:8080/day03/reqdemo04 直接访问网站，referer = null
        System.out.println(referer); // null

        // 从其他网站过来访问
        //防盗链
        if(referer != null){
            if(referer.contains("day03")){
                System.out.println("正常播放。。");
            }else{
                System.out.println("想看电影吗？来优酷吧...");
            }
        }else {
            System.out.println("正常播放");
        }
    }
}

• 获取请求体数据:

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

    • 获取流对象

      1. BufferedReader getReader()：获取字符输入流，只能操作字符数据
      2. ServletInputStream getInputStream() ：获取字节输入流，可以操作所有类型数据
         在文件上传知识点后讲解

    • 再从流对象中拿数据

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // //获取请求消息体--请求参数

        // 1, 获取字符流
        BufferedReader br = request.getReader();
        // 2，读取数据
        String line = null;
        while ((line = br.readLine())!=null){
            System.out.println(line);
        }
        // username=long&password=123
    }

其他功能：

获取请求参数通用方式： 不论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集合

• 中文乱码问题：
  • get方式：tomcat 8 已经将get方式乱码问题解决了
  • post方式：会乱码
    • 解决：在获取参数前，设置request的编码request.setCharacterEncoding(“utf-8”);

@WebServlet("/reqdemo5")
public class RequestDemo5 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 在接受数据前，设置request的编码格式
        request.setCharacterEncoding("utf-8");

        // 获取用户名和密码
        String username = request.getParameter("username");
        String passwd = request.getParameter("password");
        System.out.println(username+"-->"+passwd);

        // 获取多个值
        String[] habbys = request.getParameterValues("habby");
        for (String habby : habbys){
            System.out.println(habby);
        }

        //获取所有请求参数的名称
        Enumeration<String> names = request.getParameterNames();
        while (names.hasMoreElements()){
            String name = names.nextElement();
            System.out.println(name);
        }


        //获取所有参数的map 集合
        Map<String, String[]> parameterMap = request.getParameterMap();

        Set<String> keySet = parameterMap.keySet();
        for(String name: keySet){
            String[] value = parameterMap.get(name);
            System.out.println(name+":"+ Arrays.asList(value));
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

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

1. 步骤：

   1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
   2. 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response)

2. 特点：

   1. 浏览器地址栏路径不发生变化
   2. 只能转发到当前服务器内部资源中。
   3. 转发是一次请求

共享数据：

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

获取ServletContext：

• ServletContext getServletContext()

案例：用户登录

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

• 开发步骤：

  1. 创建数据库表：

  		CREATE DATABASE day14;
  			USE day14;
  			CREATE TABLE USER(
  			
  				id INT PRIMARY KEY AUTO_INCREMENT,
  				username VARCHAR(32) UNIQUE NOT NULL,
  				PASSWORD VARCHAR(32) NOT NULL
  			);
  

  2. 创建包com.long123.domain,创建类User

  package com.long123.domain;
  
  /**
   * 用户实体类
   */
  public class User {
      private int id;
      private String username;
      private String passwd;
  
      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 getPasswd() {
          return passwd;
      }
  
      public void setPasswd(String passwd) {
          this.passwd = passwd;
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", username='" + username + '\'' +
                  ", passwd='" + passwd + '\'' +
                  '}';
      }
  }
  
  

  3. 创建包com.long123.util,编写工具类JDBCUtils

  package com.long123.util;
  
  import com.alibaba.druid.pool.DruidDataSourceFactory;
  
  import javax.sql.DataSource;
  import java.io.IOException;
  import java.io.InputStream;
  import java.sql.Connection;
  import java.sql.SQLException;
  import java.util.Properties;
  
  /**
   * JDBC 工具类  使用Durid连接池
   */
  public class JDBCUtils {
      private static DataSource ds;
  
      static{
  
          try {
              // 1. 加载配置文件
              Properties pro = new Properties();
              // 使用ClassLoader加载配置文件，获取输入流
              InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
              pro.load(is);
  
              //2.初始化连接池对象
              ds = DruidDataSourceFactory.createDataSource(pro);
          } catch (IOException e) {
              e.printStackTrace();
          } catch (Exception e) {
              e.printStackTrace();
          }
  
      }
  
      /**
       * 获取连接池对象
       */
      public static DataSource getDataSource(){
          return ds;
      }
  
      /**
       * 获取连接池的Connection对象
       */
  
      public static Connection getConnection() throws SQLException {
          return ds.getConnection();
      }
  }
  
  

  4. 创建包com.long123.dao,创建类UserDao,提供login方法

  package com.long123.dao;
  
  import com.long123.domain.User;
  import com.long123.util.JDBCUtils;
  import org.springframework.jdbc.core.BeanPropertyRowMapper;
  import org.springframework.jdbc.core.JdbcTemplate;
  
  /*
  * 操作数据库中user表的类
  * */
  public class UserDao {
  
      // 声明JDBCTemplate对象共用
      private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
      /**
       * 登录方法
       * @param loginUser 只有用户和密码
       * @return user 包含用户的所有信息
       */
      public User login(User loginUser){
          
          try {
              // 1, 编写sql
              String sql = "select * from user where username = ? and passwd = ?";
              // 2, 调用query 方法
              User user = template.queryForObject(sql,
                      new BeanPropertyRowMapper<User>(User.class),
                      loginUser.getUsername(), loginUser.getPasswd());
              System.out.println(user);
              return user;
          }catch (Exception e){
             return null;
          }
  
      }
  }
  

  5. 创建包com.long123.servlet,创建LoginServlet

  package com.long123.Servlet;
  
  import com.long123.dao.UserDao;
  import com.long123.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("/login")
  public class LoginServlet extends HttpServlet {
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  
          //1.设置request 的编码格式
          request.setCharacterEncoding("utf-8");
          // 2. 获取用户名和密码
          String username = request.getParameter("username");
          String password = request.getParameter("password");
  
          // 3.将username 和 password 封装成user对象
          User loginUser = new User();
          loginUser.setUsername(username);
          loginUser.setPasswd(password);
  
  
          // 4. 调用UserDao 的login()
          UserDao userDao = new UserDao();
          User user = userDao.login(loginUser);
  
          // 5. 判断user
          if(user ==null){
              // 登录失败，跳转到失败页面
              request.getRequestDispatcher("/failServlet").forward(request,response);
          }else {
              // 登录成功，存储数据
              request.setAttribute("user",user);
              request.getRequestDispatcher("/sucessServlet").forward(request,response);
  
          }
  
      }
  
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doPost(request,response);
      }
  }
  
  

  6. 编写FailServlet和SuccessServlet类

  package com.long123.Servlet;
  
  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("/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);
      }
  }
  
  

  package com.long123.Servlet;
  
  import com.long123.dao.UserDao;
  import com.long123.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("/login")
  public class LoginServlet extends HttpServlet {
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  
          //1.设置request 的编码格式
          request.setCharacterEncoding("utf-8");
          // 2. 获取用户名和密码
          String username = request.getParameter("username");
          String password = request.getParameter("password");
  
          // 3.将username 和 password 封装成user对象
          User loginUser = new User();
          loginUser.setUsername(username);
          loginUser.setPasswd(password);
  
  
          // 4. 调用UserDao 的login()
          UserDao userDao = new UserDao();
          User user = userDao.login(loginUser);
  
          // 5. 判断user
          if(user ==null){
              // 登录失败，跳转到失败页面
              request.getRequestDispatcher("/failServlet").forward(request,response);
          }else {
              // 登录成功，存储数据
              request.setAttribute("user",user);
              request.getRequestDispatcher("/sucessServlet").forward(request,response);
  
          }
  
      }
  
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doPost(request,response);
      }
  }
  

  7. 编写 login.html ，form表单的action路径的写法
     * 虚拟目录+Servlet的资源路径

  	<!DOCTYPE html>
  	<html lang="en">
  	<head>
  	    <meta charset="UTF-8">
  	    <title>Title</title>
  	</head>
  	<body>
  	    <form action="/day03/login" method="post">
  	        用户名:<input type="text" name="username"> <br>
  	        密码:<input type="password" name="password"><br>
  	
  	        <input type="submit" value="登录">
  	
  	    </form>
  	</body>
  	</html>
  	```
  
  
  

BeanUtils工具类，简化数据封装

• 用于封装JavaBean的

1. JavaBean：标准的Java类

   1. 要求：
      1. 类必须被public修饰
      2. 必须提供空参的构造器
      3. 成员变量必须使用private修饰
      4. 提供公共setter和getter方法
   2. 功能：封装数据

2. 概念：
   成员变量：
   属性：setter和getter方法截取后的产物
   例如：getUsername() --> Username–> username

3. 方法：

   1. setProperty()
   2. getProperty()
   3. populate(Object obj , Map map):将map集合的键值对信息，封装到对应的JavaBean对象中

  /*   // 2. 获取用户名和密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        // 3.将username 和 password 封装成user对象
        User loginUser = new User();
        loginUser.setUsername(username);
        loginUser.setPasswd(password);*/

        // 2.获取所有request 的信息 封装为map  parameterMap
        Map<String, String[]> map = request.getParameterMap();

        // 3. 利用BeanUtils 工具类将对数据进行封装
        //3.1 创建一个空参对象
        User loginUser = new User();

        try {
            // 3.2  利用BeanUtils进行封装
            BeanUtils.populate(loginUser,map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }