Request对象_从request 获取调用者

在这里插入图片描述

Request对象

请求对象的常用获取方法(请求行:7)

一共是7种,重点掌握前两个

 //1.获取请求的方式： GET和POST
        String method = req.getMethod();
        System.out.println("请求的方式是："+method);
        //2.获取当前应用发布的名称非常重要
        String path = req.getContextPath();
        System.out.println("当前应用的发布名称是："+path);
        //3.获取请求资源的URL
        String url = req.getRequestURL().toString();
        System.out.println("请求资源URL是："+url);
        //4.获取请求资源URI
        String uri = req.getRequestURI();
        System.out.println("请求资源URI是："+uri);
        //5.获取使用的协议
        String protocol = req.getProtocol();
        System.out.println("使用的协议是："+protocol);
        //6.获取来访者信息
        String remoteAddr = req.getRemoteAddr();
        int remotePort = req.getRemotePort();
        System.out.println("获取来访者信息：来访者主机，由于我是自己访问自己，
        所以主机地址也是自己的电脑地址。"+remoteAddr+"，来访者的端口是，每次都是不一样  "+remotePort);
        //7.获取本地信息
        String localAddr = req.getLocalAddr();
        int localPort = req.getLocalPort();
        System.out.println("获取本地信息，就是获取服务器的信息。也是因为只有一台电脑，自己访问自己，所以来访者ip和本地ip是一样的："+localAddr+",本地端口，指的就是服务器提供的对外访问端口，他是固定的，就是tomcat的端口："+localPort);
    
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

请求消息头的获取(5种)

请求消息头获取的相关方法：
     *      String getHeader(String name)
     *      作用；
     *          根据消息头名称，获取值。返回的是一个值。
     *
     *      Enumeration<String> getHeaders(String name);
     *      作用：
     *          根据消息头名称，获取值。返回的是一组值。（消息头值的枚举）
     *
     *      getIntHeader(String name);
     *      作用：
     *          根据消息头名称，获取消息头的值，转成int类型
     *
     *      getDateHeader(String name);
     *      作用：
     *          根据消息头名称，获取消息头的值，转成long类型(含义是日期时间的毫秒值)
     *
     *      getHeaderNames()
     *      作用：
     *          返回消息头名称的枚举
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

练习

//1.根据消息头名称，获取消息头的值
        String value = req.getHeader("Connection");
        System.out.println("取到的消息头Connection的值是："+value);
        //2.获取所有消息头名称的枚举
        Enumeration<String> headerNames = req.getHeaderNames();
        //3.遍历枚举
        while (headerNames.hasMoreElements()){
            //取出消息头
            String headerName = headerNames.nextElement();
            //根据名称获取值
            String headerValue = req.getHeader(headerName);
            System.out.println("取到的消息头名称是："+headerName+"，消息头的值是："+headerValue);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

请求参数的获取(4种)

 请求参数获取的相关方法：
     *      根据参数名称获取参数的值：(用于单选)
     *              String getParameter(String name);
     *              其中参数名称就是请求参数key的部分。在表单提交时，就是表单元素name属性的值。
     *      根据参数名称获取参数的值：(用于多选)
     *              此方法对应的是一个名称有多个值的情况
     *              String[] getParameterValues(String name);
     *      获取请求参数名称的枚举
     *              此方法获取的是所有请求参数的key。
     *              Enumeration<String> getParameterNames();
     *       获取请求参数名称和值的对应关系（map)
     *              此方法返回的是请求参数的map，map的key是参数名称，map的value是参数的值
     *              Map<String,String[]> getParameterMap();
1
2
3
4
5
6
7
8
9
10
11
12
13

解决中文乱码问题

@Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决请求参数中文乱码问题
        req.setCharacterEncoding("UTF-8");
        //1.根据参数名称获取值
        String username = req.getParameter("username");
        String age = req.getParameter("age");
        String gender = req.getParameter("gender");
        String address = req.getParameter("address");
        String[] hobby = req.getParameterValues("hobby");
        System.out.println(username);//字符串的的直接输出就可以
        System.out.println( Arrays.toString(hobby));//数组的要调用toString方法输出
       
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

------------------------------------------

所以引出下个问题,怎么封装起来呢?

准备工作

1.导入Lombok依赖

 <dependency>
    <groupId>org.project.lombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>

  </dependency>
1
2
3
4
5
6

2.安装lombok

setting----->Plugins-------->MArketplace----->lombok
1

3.idea设置注解开发支持

setting---->Annotation Processors---->g勾选上(Enable annotation processing)
1

问题:为什么要引入Lombok

这个依赖就是方便我们不用再写(构造方法,get和set方法,toString方法啦)
只需要在类名前写

@Data //生成get/set方法
@AllArgsConstructor  //生成全参构造
@NoArgsConstructor   //生成无参构造
@ToString           //生成tostring方法
1
2
3
4
5
6
7

请求参数的封装

第一步:在页面做一个表单

<h3>请求参数相关</h3>
<form action="/requestDemo3" method="post">
    用户名：<input type="text" name="username"><br/>
    年龄：<input type="text" name="age"><br/>
    性别：<input type="radio" name="gender" value="male">男
          <input type="radio" name="gender" value="female">女<br/>
    住址：<select name="address">
                <option>请选择</option>
                <option value="bj">北京</option>
                <option value="sh">上海</option>
                <option value="tj">天津</option>
          </select><br/>
    爱好：<input type="checkbox" name="hobby" value="smoke">抽烟
          <input type="checkbox" name="hobby" value="drink">喝酒
          <input type="checkbox" name="hobby" value="hair">烫头<br/>

    <input type="submit" value="提交">
</form>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

第二步:创建User实体类

@Data //生成get/set方法
@AllArgsConstructor  //生成全参构造
@NoArgsConstructor   //生成无参构造
@ToString           //生成tostring方法
public class User implements Serializable {//注意implements Serializable为固定写法

    private String username;
    private Integer age;
    private String gender;
    private String address;
    private String[] hobby;
}
1
2
3
4
5
6
7
8
9
10
11
12

第三步:Demo类service()中进行参数封装

@Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决请求参数中文乱码问题
        req.setCharacterEncoding("UTF-8");
        //1.根据参数名称获取值
        String username = req.getParameter("username");
        String age = req.getParameter("age");
        String gender = req.getParameter("gender");
        String address = req.getParameter("address");
        String[] hobby = req.getParameterValues("hobby");
        
        //两种方法
        //System.out.println(username+","+age+","+gender+","+address+","+ Arrays.toString(hobby));
        //2.创建要封装的对象
        User user = new User();
        user.setUsername(username);
        user.setAge(Integer.parseInt(age));
        user.setGender(gender);
        user.setAddress(address);
        user.setHobby(hobby);
        //3.输出
        System.out.println("封装好的对象是："+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

输出一个表单就写这么多代码,以后数据多了还不累死,这怎么办呢

新第三步:准备工作(引入依赖)

<!--导入beanutils的坐标-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.8.3</version>
        </dependency>
1
2
3
4
5
6

新第三步:利用beanutils自动封装

 @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决请求参数中文乱码问题
        req.setCharacterEncoding("UTF-8");
        //1.创建要封装的对象
        User user = new User();
        try{
            //2.把请求参数的map封装到user对象中
            BeanUtils.populate(user,req.getParameterMap());
        }catch (Exception e){
            e.printStackTrace();
        }
        //3.输出
        System.out.println("封装好的对象是："+user);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

------------------------------------------

用流读取请求正文(请求体)

第一步:在页面做一个表单,用于获取信息(略)

第二步:引入hutool依赖

 <dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.6.4</version>

  </dependency>
1
2
3
4
5
6

第二步:demo进行读取

@WebServlet("/requestDemo4")
public class RequestDemo4 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.获取请求对象的字节输入流
        ServletInputStream in = req.getInputStream();
        //2.流的操作
//        int len = 0;
//        byte[] bytes = new byte[1024];
//        while((len = in.read(bytes))!=-1){
//            System.out.println("用流读取到的请求正文："+new String(bytes,0,len));
//        }

        String str = IoUtil.read(in, "UTF-8");
        System.out.println("用流读到的请求正文是："+str);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

问题:为什么要引入hutool依赖?

------------------------------------------

请求转发

第一个servlet

@WebServlet("/requestDemo5")
public class RequestDemo5 extends HttpServlet {
    
@Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
        //1.获取转发对象
        RequestDispatcher dispatcher = req.getRequestDispatcher("/requestDemo6");//参数写的就是转发的目的地
        //2.真正完成转发
        dispatcher.forward(req,resp);
        
       
    }
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第二个servlet

@WebServlet("/requestDemo6")
public class RequestDemo6 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
        System.out.println("他们早就结婚啦");
    }
}
1
2
3
4
5
6
7
8
9

 获取请求转发对象：
     *         getRequestDispatcher(转发的目的地)方法
     *  参数的写法：
     *        写的是请求资源URI。
     *        他既支持转发到Servlet，也支持转发到页面（html,jsp都行）
     *  细节：
     *      转发的目的地只能支持当前应用下的资源，而不能前往应用外部的资源，
     *      但是转发的目的地可以是WEB-INF目录（这个目录通过浏览器时不能直接访问的，但是转发可以）
     *
1
2
3
4
5
6
7
8
9

请求转发的特点:

1. 地址栏不发生改变
2. 只能转发到服务器内部资源
3. 转发是一次请求

共享数据(重点)

request域对象的使用

- Request是一个域对象，可以存储数据，一般用于在一次请求之间进行数据共享
- 常见方法：
  void   setAttribute(String name, Object value)	   向request域放入数据 
  Object getAttribute(String name)                   根据name从向request域获取数据
  void   removeAttribute(String name)                根据name从request域删除数据 
1
2
3
4
5

 * 请求对象的使用
 *      请求转发：
 *          就是一次服务器内部的资源之间的跳转。
 *      涉及的方法
 *          RequestDispatcher getRequestDispatcher();  请求分发对象
 *          RequestDispatcher对象有一个方法：
 *              forward(请求,响应); 转发方法
 *      请求转发的数据共享：
 *          在servlet规范中有4个共享区域：
 *               请求共享区域
 *               会话共享区域
 *               页面共享区域
 *               应用共享区域
 *          请求共享区域：
 *               他是利用请求对象来完成数据共享。
 *               作用范围：
 *                   一次请求和请求转发之间可以实现数据共享。
 *          面试常问：
 *              你知道Servlet规范中四大域吗？
 *              四大域：
 *                  应用域，会话域，请求域和页面域。
 *          数据共享涉及的方法：
 *              存入共享区域
 *                  setAttribute(String name,Object value);
 *              从共享区域获取
 *                  Object getAttribute(String name);
 *              从共享区域移除
 *                 void removeAttribute(String name);
 *              获取共享区域中的所有名称
 *                 Enumeration<String> getAttributeNames();
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

第一个servlet

 @WebServlet("/requestDemo4")
public class RequestDemo4 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("RequestDemo4接收到了请求，但是解决不了，需要转发到RequestDemo5的Servlet处理");
        //存入请求共享区域
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("隔壁老王");
        list.add("test");
        req.setAttribute("names",list);

        //1.获取请求分发对象
        RequestDispatcher dispatcher = req.getRequestDispatcher("/requestDemo5");
        //此处的参数写的是转发的目的地址、URI就行。
        //2.完成转发
        dispatcher.forward(req,resp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第二个servlet

@WebServlet("/requestDemo5")
public class RequestDemo5 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("RequestDemo5接收到了转发的操作");
        //从请求共享区域中获取
        List<String> names = (List<String>) req.getAttribute("names");
        //输出共享区域的内容
        System.out.println("RequestDemo5得到的共享数据是："+names);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

request对象生命周期

1. 何时创建：Tomcat接收到一个请求，在调用service方法之前创建request对象
2. 何时销毁：当一个请求离开服务器(响应回到浏览器)的时候，Tomcat就会销毁这个对象
3. 作用范围：一次请求中
1
2
3

pServletResponse resp) throws ServletException, IOException {
System.out.println(“RequestDemo5接收到了转发的操作”);
//从请求共享区域中获取
List names = (List) req.getAttribute(“names”);
//输出共享区域的内容
System.out.println(“RequestDemo5得到的共享数据是：”+names);
}
}

### request对象生命周期

> ```markdown
> 1. 何时创建：Tomcat接收到一个请求，在调用service方法之前创建request对象
> 2. 何时销毁：当一个请求离开服务器(响应回到浏览器)的时候，Tomcat就会销毁这个对象
> 3. 作用范围：一次请求中
> ```

1
2
3
4
5
6
7
8
9