request对象和response对象

• request对象和response对象原理
• request对象继承体系
• request功能
• • 获取请求消息数据
  • • 获取请求行数据
    • 获取请求头数据
    • 获取请求体数据
  • 其他功能
  • • 获取请求参数
    • • 获取请求参数通用方法
      • 中文乱码问题
      • 请求转发
      • • 步骤
        • 特点
      • 共享数据
      • • 域对象
      • 获取servletContext

request对象和response对象原理

1. 浏览器发送请求（携带请求消息）
2. tomcat服务器根据请求url中的资源路径，创建对应的servlet的对象
3. tomcat会创建request和response对象，request对象封装请求消息数据。
4. tomcat将request和response两个对象传递给service对象，并且调用service方法。
5. 程序员可以通过request对象获取请求消息数据，通过response对象设置相应消息数据
6. 服务器在对浏览器做出相应之前，会从response对象中拿程序员设置的相应消息数据。
7. 服务器对浏览器做出响应（携带响应数据）

request对象继承体系

servletRequest–接口
|继承
HttpServletRequest–接口
|实现
org.apache.catalina.connector.RequestFacade–实现类

request功能

获取请求消息数据

获取请求行数据

格式：
/GET /day14/demo6?name=zhangsan HTTP/1.1
方法：
获取请求方法：GET：String getMethod()
获取虚拟目录：/day14：String geiContextPath()
获取servlet的路径：/demo6：String getServletPath()
获取get方式请求参数：name=zhangsan：String getQueryString()
获取请求的URI ： /day14/demo6：String getRequestURI()：StringBuffer getRequestURL()
获取版本协议：HTTP/1.1：String getProtocol（）
获取客户机的IP地址：String getRemoteAddr()

@WebServlet("/requestServletDemo1")
public class requestServletDemo1 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*
        1 获取请求方法：GET：String getMethod()
        2 获取虚拟目录：/day14：String geiContextPath()
        3 获取servlet的路径：/demo6：String getServletPath()
        4 获取get方式请求参数：name=zhangsan：String getQueryString()
        5 获取请求的URI ： /day14/demo6：String getRequestURI()：StringBuffer getRequestURL()
        6 获取版本协议：HTTP/1.1：String getProtocol（）
        7 获取客户机的IP地址：String getRemoteAddr()
        * */
        //1 获取请求方法：GET：String getMethod()
        String method = req.getMethod();
        System.out.println(method);
        // 2 获取虚拟目录：/day14：String geiContextPath()
        String contextPath = req.getContextPath();
        System.out.println(contextPath);
        //3 获取servlet的路径：/demo6：String getServletPath()
        String servletPath = req.getServletPath();
        System.out.println(servletPath);
        //4 获取get方式请求参数：name=zhangsan：String getQueryString()
        String queryString = req.getQueryString();
        System.out.println(queryString);
        //5 获取请求的URI ： /day14/demo6：String getRequestURI()：StringBuffer getRequestURL()
        String requestURI = req.getRequestURI();
        System.out.println(requestURI);
        StringBuffer requestURL = req.getRequestURL();
        System.out.println(requestURL);
        //6 获取版本协议：HTTP/1.1：String getProtocol（）
        String protocol = req.getProtocol();
        System.out.println(protocol);
        //7 获取客户机的IP地址：String getRemoteAddr()
        String remoteAddr = req.getRemoteAddr();
        System.out.println(remoteAddr);
    }
}

获取请求头数据

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

@WebServlet("/requestServletDemo2")
public class requestServletDemo2 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*
        1.String getHeader(String name):通过请求头的名称获取请求头的值
        2.Enumeration<String\> getHeaderNames（）：获取所有的请求头名称
        * */
        //1 Enumeration<String\> getHeaderNames（）：获取所有的请求头名称
        Enumeration<String> headerNames = req.getHeaderNames();
        // 2 String getHeader(String name):通过请求头的名称获取请求头的值
        while (headerNames.hasMoreElements()){
            String s = headerNames.nextElement();
            String header = req.getHeader(s);
            System.out.println( s+":"+header);
        }

    }
}

@WebServlet("/requestServletDemo3")
public class requestServletDemo3 extends HttpServlet {

    private String header;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }

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

        String header = req.getHeader("user-agent");
        if (header.contains("Chrome")){
            System.out.println("谷歌来了");
        }else if (header.contains("Firefo")){
            System.out.println("火狐来了");
        }
        String referer = req.getHeader("referer");
        System.out.println(referer);
        //防盗链
        if (referer!=null){
            if (referer.contains("/day14")){
                resp.setContentType("text/html;charset=utf-8");
                resp.getWriter().write("正常的链接");
            }else {
                resp.setContentType("text/html;charset=utf-8");
                resp.getWriter().write("不是正常的链接");
            }
        }else {
            resp.setContentType("text/html;charset=utf-8");
            resp.getWriter().write("不是正常的链接");
        }


    }
}

获取请求体数据

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

1. 获取流对象
   BufferedReader getReader():获取字符输入流，只能操作字符数据
   ServletInputStream getInputStream（）:获取字节输入流，可以操作所有类型的数据
2. 再从流对象中获取数据

@WebServlet("/requestServletDemo4")
public class requestServletDemo4 extends HttpServlet {

    private String header;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取请求消息体
        BufferedReader reader = req.getReader();
        String line = null;
        while ((line = reader.readLine()) != null){
            System.out.println(line);
        }
    }

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

        String header = req.getHeader("user-agent");
        if (header.contains("Chrome")){
            System.out.println("谷歌来了");
        }else if (header.contains("Firefo")){
            System.out.println("火狐来了");
        }
        String referer = req.getHeader("referer");
        System.out.println(referer);
        //防盗链
        if (referer!=null){
            if (referer.contains("/day14")){
                resp.setContentType("text/html;charset=utf-8");
                resp.getWriter().write("正常的链接");
            }else {
                resp.setContentType("text/html;charset=utf-8");
                resp.getWriter().write("不是正常的链接");
            }
        }else {
            resp.setContentType("text/html;charset=utf-8");
            resp.getWriter().write("不是正常的链接");
        }


    }
}

其他功能

获取请求参数

获取请求参数通用方法

1. String getParameter（String name）:根据参数名称获取参数
2. String[] getParameterValus（String name）:根据参数名称获取参数值的数组
3. Enumeration<String> getParameterValus（）:获取所有请求的参数名称
4. Map<String,String[]>:获取所有参数的map集合

@WebServlet("/requestServletDemo5")
public class requestServletDemo5 extends HttpServlet {

    private String header;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取请求消息体


        System.out.println("String getParameter（String name）:根据参数名称获取参数-----------------------------------");
        String username = req.getParameter("username");
        System.out.println("post");
        System.out.println(username);


        System.out.println("String[] getParameterValus（String name）:根据参数名称获取参数值的数组-------------------------");
        String[] hobbies = req.getParameterValues("hobby");
        for (String hobby : hobbies) {
            System.out.println(hobby);
        }


        System.out.println("Enumeration<String> getParameterValus（）:获取所有请求的参数名称-------------------------");
        Enumeration<String> parameterNames = req.getParameterNames();
        while (parameterNames.hasMoreElements()){
            System.out.println(parameterNames.nextElement());
        }


        System.out.println("Map<String,String[]>:获取所有参数的map集合-------------------------");
        Map<String, String[]> parameterMap = req.getParameterMap();
        Set<String> strings = parameterMap.keySet();
        for (String string : strings) {
            String[] strings1 = parameterMap.get(string);
            for (String s : strings1) {
                System.out.println(s);
            }
        }
    }

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

        this.doPost(req,resp);
    }
}

中文乱码问题

req.setCharacterEncoding(“utf-8”);

请求转发

概念：一种在服务器内部的资源调整方式

步骤

1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher（String path）
2. 使用RequestDispatcher对象进行转发：forward（ServletReq request，ServletResponse response）

特点

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

共享数据

域对象

概念：一个有作用范围的对象，可以在范围内共享数据
request域：代表一次请求的范围，一般用于转发的多个资源中共享数据
方法：

1. setAtrribute(String name ,Object obj):存储数据
2. Object setAtrribute（String name）：通过键获取值
3. removeAtrribute（String name）：通过键移除

@WebServlet("/requestServletDemo6")
public class requestServletDemo6 extends HttpServlet {

    private String header;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("demo6被访问了。。。");
        /*RequestDispatcher requestDispatcher = req.getRequestDispatcher("/requestServletDemo7");
        requestDispatcher.forward(req,resp);*/

        //存储数据到req中
        req.setAttribute("msg","hello");
        req.getRequestDispatcher("/requestServletDemo7").forward(req,resp);
    }

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

        this.doPost(req,resp);
    }
}

@WebServlet("/requestServletDemo7")
public class requestServletDemo7 extends HttpServlet {

    private String header;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object msg = req.getAttribute("msg");
        System.out.println(msg);
        System.out.println("demo7被访问了。。。");
    }

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

        this.doPost(req,resp);
    }
}

获取servletContext

@WebServlet("/requestServletDemo8")
public class requestServletDemo8 extends HttpServlet {

    private String header;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = req.getServletContext();
        System.out.println(servletContext);
    }

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

        this.doPost(req,resp);
    }
}