Java web Request对象

发表于 | 分类于 |

Request对象

1. request对象和response对象的原理

1571781571159

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

2. request对象继承体系结构：

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

1571781863668

3. request功能：获取请求消息数据

  1. 获取请求行数据
1
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&age=18
  • String getQueryString()
    • 获取的请求参数之间用&分割

  1. (*)获取请求URI：/day14/demo1

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

  • String getProtocol()
  • 不在HttpServletRequest中，在父类ServletRequest中
  1. 获取客户机的IP地址：
  • String getRemoteAddr()
  1. 获取请求头数据

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

1
2
3
4
5
6
7
8
9
10
11
12
13
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据
        //1.获取所有请求头名称
        Enumeration<String> headerNames = request.getHeaderNames();
        //2.遍历
        while(headerNames.hasMoreElements()){
            String name = headerNames.nextElement();
            //根据名称获取请求头的值
            String value = request.getHeader(name);
            System.out.println(name+"---"+value);
        }

    }

也可以直接获取指定的请求头。

1
2
3
4
5
6
7
8
9
10
11
12
13
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请求头防盗链。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:referer

        String referer = request.getHeader("referer");
        System.out.println(referer); //http://localhost/day14/login.html

        //防盗链
        if(referer != null ){
            if(referer.contains("/day14")){
                //正常访问
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("播放电影....");
            }else{
                //盗链
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("想看电影吗？来优酷吧...");
            }
        }

    }
  1. 获取请求体数据:

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

步骤：

  1. 获取流对象
    *  BufferedReader getReader()：**获取字符输入流，只能操作字符数据**（BufferedReader 高效，带有缓冲区，有readline()）
    • ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
  2. 再从流对象中拿数据
1
2
3
4
5
6
7
8
9
10
11
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);
        }

    }

4. request其他功能

  1. 获取请求参数通用方式：不论get还是post请求方式都可以使用下列方法来获取请求参数

    • String getParameter(String name):根据参数名称获取参数值 username=zs&password=123

    • String[] getParameterValues(String name):根据参数名称获取参数值的数组 hobby=xx&hobby=game

    • Enumeration getParameterNames():获取所有请求的参数名

    • Map<String,String[]> getParameterMap():获取所有参数的map集合

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              //post 获取请求参数
              //根据参数名称获取参数值
              System.out.println("-------------------"+"getParameter");
              String username = request.getParameter("username");
              System.out.println(username);

              //根据参数名称获取参数值的数组
              System.out.println("-------------------"+"getParameterValues");
              String[] hobbies = request.getParameterValues("hobby");
              for (String hobby:hobbies){
                  System.out.println(hobby);
              }

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

              // 获取所有参数的map集合
              System.out.println("-------------------"+"getParameterMap");
              Map<String, String[]> parameterMap = request.getParameterMap();
              //遍历
              Set<String> keyset = parameterMap.keySet();
              for (String name : keyset) {
                  
                  //获取键获取值
                  String[] values = parameterMap.get(name);
                  System.out.println(name);
                  for (String value : values) {
                      System.out.println(value);
                  }
                  System.out.println("-----------------");
              }
          }
5. 中文乱码问题：

get方式：tomcat 8 已经将get方式乱码问题解决了

post方式：会乱码

* 解决：在获取参数前，设置request的编码


1
request.setCharacterEncoding("utf-8");

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

    1. 通过request对象获取请求转发器对象：

      1
      RequestDispatcher getRequestDispatcher(String path)
2. 使用RequestDispatcher对象来进行转发：

    
1
forward(ServletRequest request, ServletResponse response)



3. 特点：

    
1
request.getRequestDispatcher("/requestDemo9").forward(request,response);



    - **浏览器地址栏路径不发生变化**

    - 只能转发到当前服务器内部资源中，不能访问外部资源

    - 转发是一次请求

  1. 共享数据：

    1571836019853

    域对象：一个有作用范围的对象，可以在范围内共享数据

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

5. 用户登录案例

5.1 用户登录案例需求：

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

5.2 分析

1571855003927

5.3 开发步骤

  1. 创建项目，导入html页面，配置文件，jar包

druid数据库连接池druid.properties

1
2
3
4
5
6
7
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///day14
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000

配置jar包

1571855407540

  1. 创建数据库环境
1
2
3
4
5
6
7
8
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
		);
  1. 创建包cn.app.domain,创建类User
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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 + '\'' +
                '}';
    }
}
  1. 创建包cn.app.dao,创建类UserDao，提供login方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import cn.app.domain.User;
import cn.app.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 JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 登录方法
     * @param loginUser 只有用户名和密码
     * @return user包含用户全部数据,没有查询到，返回null
     */
    public User login(User loginUser){
        try {
            //1.编写sql
            String sql = "select * from user where username = ? and password = ?";
            //2.调用query方法
            User user = template.queryForObject(sql,
                    new BeanPropertyRowMapper<User>(User.class),
                    loginUser.getUsername(), loginUser.getPassword());
            return user;
        } catch (DataAccessException e) {
            e.printStackTrace();//记录日志
            return null; // 没有查询到user对象，返回null
        }
    }
}
  1. 创建包cn.app.util,编写工具类JDBCUtils
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
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();
    }
}
  1. 创建包cn.app.test,创建类UserDaoTest,测试login方法是否正确
1
2
3
4
5
6
7
8
9
10
11
12
13
public class UserDaoTest {
    @Test
    public void testLogin(){
        User loginuser = new User();
        loginuser.setUsername("super");
        loginuser.setPassword("123");

        UserDao dao = new UserDao();
        User user = dao.login(loginuser);

        System.out.println(user);
    }
}
  1. 编写cn.itcast.web.servlet.LoginServlet类，完成登录逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import cn.itcast.dao.UserDao;
import cn.itcast.domain.User;
import org.apache.commons.beanutils.BeanUtils;

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;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.设置编码
        req.setCharacterEncoding("utf-8");
       //2.获取请求参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        //3.封装user对象
        User loginUser = new User();
        loginUser.setUsername(username);
        loginUser.setPassword(password);
    
        //4.调用UserDao的login方法
        UserDao dao = new UserDao();
        User user = dao.login(loginUser);

        //5.判断user
        if(user == null){
            //登录失败
            req.getRequestDispatcher("/failServlet").forward(req,resp);
        }else{
            //登录成功
            //存储数据
            req.setAttribute("user",user);
            //转发
            req.getRequestDispatcher("/successServlet").forward(req,resp);
        }

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}
  1. 编写FailServlet和SuccessServlet类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import cn.itcast.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 {
        //获取request域中共享的user对象
        User user = (User) request.getAttribute("user");

        if(user != null){
            //给页面写一句话

            //设置编码
            response.setContentType("text/html;charset=utf-8");
            //输出
            response.getWriter().write("登录成功！"+user.getUsername()+",欢迎您");
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}
  1. login.html中form表单的action路径的写法

虚拟目录+Servlet的资源路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/day14/loginServlet" method="post">
        用户名:<input type="text" name="username"> <br>
        密码:<input type="password" name="password"><br>
        <input type="submit" value="登录">
    </form>
</body>
</html>
  1. BeanUtils工具类，简化数据封装
1
2
3
4
5
6
7
8
9
10
11
12
//2.获取所有请求参数
      Map<String, String[]> map = req.getParameterMap();
      //3.创建User对象
      User loginUser = new User();
      //3.2使用BeanUtils封装
      try {
          BeanUtils.populate(loginUser,map);
      } catch (IllegalAccessException e) {
          e.printStackTrace();
      } catch (InvocationTargetException e) {
          e.printStackTrace();
      }

6. BeanUtils工具类（用于封装JavaBean）

6.1 JavaBean

JavaBean：标准的Java类

要求：

  1. 类必须被public修饰
  2. 必须提供空参的构造器
  3. 成员变量必须使用private修饰
  4. 提供公共setter和getter方法

功能：封装数据

6.2 成员变量和属性

成员变量：private int name;
属性：setter和getter方法截取后的产物

  • 例如：getUsername() –> Username–> username

6.3 方法

  1. setProperty() // 操作的是属性 set和get方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class BeanUtilsTest {

        @Test
        public void test(){

            User user = new User();
            try {
                BeanUtils.setProperty(user,"haha","male");
                System.out.println(user);

                String gender = BeanUtils.getProperty(user, "haha");
                System.out.println(gender);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
    }

  2. getProperty()

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

0%