如果您对JavaEE之HttpServletRequest感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解JavaEE之HttpServletRequest的各种细节，此外还有关于HttpSer

如果您对JavaEE之HttpServletRequest感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解JavaEE之HttpServletRequest的各种细节，此外还有关于HttpServletRequest & HttpServletResponse 中 Body 的获取、HttpServletRequest HttpServletResponse 常见操作、HttpServletRequest HttpServletResponse 接口详解、HttpServletRequest HttpServletResponse 注意事项的实用技巧。

本文目录一览：

• JavaEE之HttpServletRequest
• HttpServletRequest & HttpServletResponse 中 Body 的获取
• HttpServletRequest HttpServletResponse 常见操作
• HttpServletRequest HttpServletResponse 接口详解
• HttpServletRequest HttpServletResponse 注意事项

JavaEE之HttpServletRequest

HttpServletRequest

//要下载的这个文件的类型--客户端会通过文件的MIME类型去区分类型
response.setContentType(
getServletContext().getMimeType(filename));
//告知客户端文件的打开方式（下载）
response.setHeader("Content-Disposition","attachment;"
+ "filname="+filename);

HttpServletRequest概述

我们在创建Servlet时会覆盖service()方法，或doGet()/doPost(),这些方法都有两个参数，一个为代表请求的request和代表响应response。

service方法中的request的类型是ServletRequest，而doGet/doPost方法的request的类型是HttpServletRequest，HttpServletRequest是ServletRequest的子接口，功能和方法更加强大，今天我们学习HttpServletRequest。

 

request的运行流程

 

通过抓包工具抓取Http请求

因为request代表请求，所以我们可以通过该对象分别获得Http请求的请求行，请         求头和请求体

 

通过request获得请求行

获得客户端的请求方式：String getMethod()

获得请求的资源：

String getRequestURI()

StringBuffer getRequestURL()

String getContextPath() ---web应用的名称

String getQueryString() ---- get提交url地址后的参数字符串

username=zhangsan&password=123

 

注意：request获得客户机（客户端）的一些信息

request.getRemoteAddr() --- 获得访问的客户端IP地址

 

通过request获得请求头

long getDateHeader(String name)

String getHeader(String name)

Enumeration getHeaderNames()

Enumeration getHeaders(String name)

int getIntHeader(String name)

 

referer头的作用：执行该此访问的的来源

做防盗链

 

通过request获得请求体

请求体中的内容是通过post提交的请求参数，格式是：

username=zhangsan&password=123&hobby=football&hobby=basketball

key ---------------------- value

username                                   [zhangsan]

password                           [123]

hobby                                          [football，basketball]

                                  

 

以上面参数为例，通过一下方法获得请求参数：

String getParameter(String name)

String[] getParameterValues(String name)

Enumeration getParameterNames()

Map<String,String[]> getParameterMap()

 

 

      注意：get请求方式的请求参数 上述的方法一样可以获得

 

      解决post提交方式的乱码：request.setCharacterEncoding("UTF-8");

      解决get提交的方式的乱码：

            parameter = new String(parameter.getbytes("iso8859-1"),"utf-8");

 

request的其他功能

request是一个域对象

request对象也是一个存储数据的区域对象，所以也具有如下方法：

setAttribute(String name, Object o)

getAttribute(String name)

removeAttribute(String name)

 

注意：request域的作用范围：一次请求中

request完成请求转发

获得请求转发器----path是转发的地址

RequestDispatcher getRequestDispatcher(String path)

通过转发器对象转发

requestDispathcer.forward(ServletRequest request, ServletResponse response)           

            注意：ServletContext域与Request域的生命周期比较？

         ServletContext：

            创建：服务器启动

            销毁：服务器关闭

            域的作用范围：整个web应用

         request：

            创建：访问时创建request

            销毁：响应结束request销毁

            域的作用范围：一次请求中

 

            注意：转发与重定向的区别？

         1）重定向两次请求，转发一次请求

         2）重定向地址栏的地址变化，转发地址不变

         3）重新定向可以访问外部网站 转发只能访问内部资源

         4）转发的性能要优于重定向

                   

            注意：客户端地址与服务器端地址的写法？

         客户端地址：

            是客户端去访问服务器的地址，服务器外部的地址，特点：写上web应用名      称

           

            直接输入地址：

            重定向

       

         服务器端地址：

                  服务器内部资源的跳转的地址，特点：不需要写web应用的名称转发

 

 

总结：

request获得行的内容

      request.getMethod()

      request.getRequestURI()

      request.getRequestURL()

      request.getContextPath()

      request.getRemoteAddr()

request获得头的内容

      request.getHeader(name)

request获得体（请求参数）

      String request.getParameter(name)

      Map<String,String[]> request.getParameterMap();

      String[] request.getParameterValues(name);

      注意：客户端发送的参数 到服务器端都是字符串

 

      获得中文乱码的解决：

         post:request.setCharacterEncoding(“UTF-8”);

         get:

parameter = new String(parameter.getBytes(“iso8859-1”),”UTF-8”);

 

request转发和域

      request.getRequestDispatcher(转发的地址).forward(req,resp);

      request.setAttribute(name,value)

      request.getAttribute(name)

 

HttpServletRequest & HttpServletResponse 中 Body 的获取

获取 HttpServletRequest 中的请求体

    HttpServletRequest#getInputStream() 获取到请求的输入流，从该输入流中可以读取到请求体。不过这个流在被我们的代码 read 过后，之后的代码就会报错，因为流已经被我们读取过了 ， 尝试使用 mark() , reset() 也是不行的，会抛出异常。可以通过将 HttpServletRequest 对象包装一层的方式来实现这个功能。

package org.hepeng.commons.http;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.apache.commons.io.IOUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 
 * @author he peng
 * @date 2018/9/11
 */
public class BodyCachingHttpServletRequestWrapper extends HttpServletRequestWrapper {


    private byte[] body;
    private ServletInputStreamWrapper inputStreamWrapper;

    public BodyCachingHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        this.body = IOUtils.toByteArray(request.getInputStream());
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(this.body);
        this.inputStreamWrapper = new ServletInputStreamWrapper(byteArrayInputStream);
        resetInputStream();
    }

    private void resetInputStream() {
        this.inputStreamWrapper.setInputStream(new ByteArrayInputStream(this.body != null ? this.body : new byte[0]));
    }

    public byte[] getBody() {
        return body;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return this.inputStreamWrapper;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.inputStreamWrapper));
    }


    @Data
    @AllArgsConstructor
    private static class ServletInputStreamWrapper extends ServletInputStream {

        private InputStream inputStream;

        @Override
        public boolean isFinished() {
            return true;
        }

        @Override
        public boolean isReady() {
            return false;
        }

        @Override
        public void setReadListener(ReadListener readListener) {

        }

        @Override
        public int read() throws IOException {
            return this.inputStream.read();
        }
    }
}

 

获取 HttpServletResponse 中的响应体

    通过使用 ByteArrayOutputStream 将原 HttpSevletResponse 进行一层包装就可以实现。ByteArrayOutputStream 是将数据写入到它内部的缓冲区中，这样我们就可以获取到这个数据了。

package org.hepeng.commons.http;

import lombok.AllArgsConstructor;
import lombok.Data;

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * @author he peng
 * @date 2018/10/1
 */
public class BodyCachingHttpServletResponseWrapper extends HttpServletResponseWrapper {

    private ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    private HttpServletResponse response;

    public BodyCachingHttpServletResponseWrapper(HttpServletResponse response) {
        super(response);
        this.response = response;
    }

    public byte[] getBody() {
        return byteArrayOutputStream.toByteArray();
    }

    @Override
    public ServletOutputStream getOutputStream() {
        return new ServletOutputStreamWrapper(this.byteArrayOutputStream , this.response);
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        return new PrintWriter(new OutputStreamWriter(this.byteArrayOutputStream , this.response.getCharacterEncoding()));
    }


    @Data
    @AllArgsConstructor
    private static class ServletOutputStreamWrapper extends ServletOutputStream {

        private ByteArrayOutputStream outputStream;
        private HttpServletResponse response;

        @Override
        public boolean isReady() {
            return true;
        }

        @Override
        public void setWriteListener(WriteListener listener) {

        }

        @Override
        public void write(int b) throws IOException {
            this.outputStream.write(b);
        }

        @Override
        public void flush() throws IOException {
            if (! this.response.isCommitted()) {
                byte[] body = this.outputStream.toByteArray();
                ServletOutputStream outputStream = this.response.getOutputStream();
                outputStream.write(body);
                outputStream.flush();
            }
        }
    }
}

flush() 函数是必须提供的 ，否则流中的数据无法响应到客户端 ， ByteArrayOutputStream 没有实现 flush() 。像 SpringMVC 这类框架会去调用这个响应输出流中的 flush() 函数 ，而且有可能在出现多次调用的情况，多次调用会产生问题使得客户端得到错误的数据，比如这样的 ：

{"errorCode":30001,"errorMsg":"用户未认证","token":null,"entity":null}{"errorCode":30001,"errorMsg":"用户未认证","token":null,"entity":null}  ，出现这种情况就说明 flush() 被调用了两次。所以需要在这里判断一下 HttpServletResponse#isCommitted()  。

获取请求体、相应体的包装类在 Filter 中的使用

package org.hepeng.commons.http.filter;

import com.tepin.commons.http.BodyCachingHttpServletRequestWrapper;
import com.tepin.commons.http.BodyCachingHttpServletResponseWrapper;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author he peng
 * @date 2018/10/2
 */
public class DemoFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        BodyCachingHttpServletRequestWrapper requestWrapper =
                new BodyCachingHttpServletRequestWrapper((HttpServletRequest) request);

        byte[] requestBody = requestWrapper.getBody();

        // TODO do something
        BodyCachingHttpServletResponseWrapper responseWrapper =
                new BodyCachingHttpServletResponseWrapper((HttpServletResponse) response);

        chain.doFilter(requestWrapper , responseWrapper);

        byte[] responseBody = responseWrapper.getBody();
        // TODO do something

    }

    @Override
    public void destroy() {

    }
}

 

HttpServletRequest HttpServletResponse 常见操作

一，HttpServletResponse 

   response.getWriter().write("<h1>response</h1>");以字符流的方式写数据

   response.getOutputStream().write("response"):以字节流的方式写数据

   response.setCharacterEncoding("utf-8"):设定响应数据为utf-8,字符流

   response.setHeader("Content-Type","text/html;charset=utf-8”):设置页面编码

   response.setContentType("text/html;charset=UTF-8");"):解决响应数据乱码

二，HttpServletRequest  获取客户机信息

   getRequestURL():获取资源请求完整路径

   getRequestURI():获取资源部分路径

   getQueryString ():方法返回请求行中的参数部分。

   getRemoteAddr():获取发出请求客户机的IP

   getRemotePort():获取发出请求客户机的端口

   getRemoteHost():获取发出请求客户机名称

   getLocalAddr():返回web服务器的IP

   getLocalName():返回web服务器主机名

   getMethod():返回客户机请求方式

三，request获取头信息

   request.getHeader(name);//获取单个请求头name对应的value值

   request.getHeaders("Accept-Encoding");//获取多个同名请求头对应的一组value值，因此返回枚举类型数据

   request.getHeaderNames();//获取请求头的所有name值,返回的数据也是一个枚举类型的数据，将枚举中的元素依次遍历出来，根据name获取对应的value值，即可得到Http请求头的所有信息

具体操作：

/**
* 获取头信息
*/
String headValue = request.getHeader("Accept-Encoding");//获取单个请求头name对应的value值
System.out.println(headValue);

Enumeration e = request.getHeaders("Accept-Encoding");//获取多个同名请求头对应的一组value值，因此返回枚举类型数据
/**
* 将数据遍历出来
*/
while(e.hasMoreElements()){
//遍历枚举中存储的每一个元素
String value = (String)e.nextElement();
System.out.println(value);//将值输出
}

/**
* 获取所有请求头信息
*/
Enumeration er = request.getHeaderNames();//获取请求头的所有name值
while(er.hasMoreElements()){
String name =(String) er.nextElement();
String value = request.getHeader(name);
System.out.println(name+"="+value);
}

四，获取客户端请求参数

getParameter(name):获取指定名称的参数值。这是最为常用的方法之一。
getParameterValues（String name）:获取指定名称参数的所有值数组。它适用于一个参数名对应多个值的情况。如页面表单中的复选框，多选列表提交的值。
getParameterNames():返回一个包含请求消息中的所有参数名的Enumeration对象。通过遍历这个Enumeration对象，就可以获取请求消息中所有的参数名
getParameterMap():返回一个保存了请求消息中的所有参数名和值的Map对象。Map对象的key是字符串类型的参数名，value是这个参数所对应的Object类型的值数组。

五，各种路径获取

request.getRealPath() 这个方法已经不推荐使用了，代替方法是：

request.getSession().getServletContext().getRealPath()

request.getSession().getServletContext().getRealPath("/"); 获取Web项目的全路径

request.getContextPath()，返回的是项目的根目录，项目放在Tomcat的ROOT下就为空，本地中如果没有配置Application context，也会返回空,反之配置了就返回配置的值

ps:Java中读取配置文件方式

String realPath = getServletContext().getRealPath(path);

InputStreamReader reader =new InputStreamReader(new FileInputStream(realPath),"utf-8");

方式二：采用ResourceBundle类读取配置信息

优点是：可以以完全限定类名的方式加载资源后，直接的读取出来，且可以在非Web应用中读取资源文件。
缺点：只能加载类classes下面的资源文件，且只能读取.properties文件。

/**
     * 获取指定.properties配置文件中所以的数据
     * @param propertyName
     *        调用方式：
     *            1.配置文件放在resource源包下，不用加后缀
     *              PropertiesUtil.getAllMessage("message");
     *            2.放在包里面的
     *              PropertiesUtil.getAllMessage("com.test.message");
     * @return
     */
    public static List<String> getAllMessage(String propertyName) { // 获得资源包 ResourceBundle rb = ResourceBundle.getBundle(propertyName.trim()); // 通过资源包拿到所有的key Enumeration<String> allKey = rb.getKeys(); // 遍历key 得到 value List<String> valList = new ArrayList<String>(); while (allKey.hasMoreElements()) { String key = allKey.nextElement(); String value = (String) rb.getString(key); valList.add(value); } return valList; }

方式三：采用ClassLoader方式进行读取配置信息

优点是：可以在非Web应用中读取配置资源信息，可以读取任意的资源文件信息。
缺点：只能加载类classes下面的资源文件。

 /**获取的是classes路径下的文件
     * 优点是：可以在非Web应用中读取配置资源信息，可以读取任意的资源文件信息
     * 缺点：只能加载类classes下面的资源文件。
     * 如果要加上路径的话：com/test/servlet/jdbc_connection.properties
     */
    private static void use_classLoador(){ //获取文件流 InputStream is=TestJava.class.getClassLoader().getResourceAsStream("message.properties"); //获取文件的位置 String filePath=TestJava.class.getClassLoader().getResource("message.properties").getFile(); System.out.println(filePath); }

方法四：getResouceAsStream

XmlParserHandler.class.getResourceAsStream 与 classloader 的不同之处在于使用的是当前类的相对路径。

方法五：PropertiesLoaderUtils 工具类

Spring 提供的 PropertiesLoaderUtils 允许您直接通过基于类路径的文件地址加载属性资源。
最大的好处就是：实时加载配置文件，修改后立即生效，不必重启。

   private static void springUtil(){ Properties props = new Properties(); while(true){ try { props=PropertiesLoaderUtils.loadAllProperties("message.properties"); for(Object key:props.keySet()){ System.out.print(key+":"); System.out.println(props.get(key)); } } catch (IOException e) { System.out.println(e.getMessage()); } try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } } }

参考：

https://www.jianshu.com/p/efdd1a526939

HttpServletRequest HttpServletResponse 接口详解

 

 

HttpServletRequest 接口最常用的方法就是获得请求中的参数，这些参数一般是客户端表单中的数据。同时，HttpServletRequest 接口可以获取由客户端传送的名称，也可以获取产生请求并且接收请求的服务器端主机名及 IP 地址，还可以获取客户端正在使用的通信协议等信息。下表是接口 HttpServletRequest 的常用方法。

说明：HttpServletRequest 接口提供了很多的方法。

接口 HttpServletRequest 的常用方法

在 Servlet 中，当服务器响应客户端的一个请求时，就要用到 HttpServletResponse 接口。设置响应的类型可以使用 setContentType () 方法。发送字符数据，可以使用 getWriter () 返回一个对象。下表是接口 HttpServletResponse 的常用方法。

接口 HttpServletResponse 的常用方法

方    法	说    明
addCookie(Cookie cookie)	将指定的 Cookie 加入到当前的响应中
addHeader(String name,String value)	将指定的名字和值加入到响应的头信息中
containsHeader(String name)	返回一个布尔值，判断响应的头部是否被设置
encodeURL(String url)	编码指定的 URL
sendError(int sc)	使用指定状态码发送一个错误到客户端
sendRedirect(String location)	发送一个临时的响应到客户端
setDateHeader(String name,long date)	将给出的名字和日期设置响应的头部
setHeader(String name,String value)	将给出的名字和值设置响应的头部
setStatus(int sc)	给当前响应设置状态码
setContentType(String ContentType)	设置响应的 MIME 类型

2、一些区别细节

HttpServletRequest HttpServletResponse 注意事项

HttpServletRequest

（1）request.getParameter () 取得是通过容器的实现来取得通过类似 post，get 等方式传入的数据，request.setAttribute () 和 getAttribute () 只是在 web 容器内部流转，仅仅是请求处理阶段。

（2）request.getParameter () 方法传递的数据，会从 Web 客户端传到 Web 服务器端，代表 HTTP 请求数据。request.getParameter () 方法返回 String 类型的数据。 （3）request.getQueryString () 取得的是传递的字符串，注意不是 json 数据，是字符串也就是传统的传参方式，@RequestParam 获取的参数也是传统的传参方式才能被获取到

HttpServletResponse

（1）调用 response.getOutputStream () 方法可现实字节流数据的输出

（2）requonse.getWriter () 方法时可实现文本字符串数据输出

（3）response.addHeader ("Content-Disposition", "attachment; filename=" + new String (fileName.getBytes (),"ISO-8859-1")); 下载文件，new String 那个是防止下载的文件名乱码，因为 tomcat 的编码是 iso-8859-1 的。

关于JavaEE之HttpServletRequest的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于HttpServletRequest & HttpServletResponse 中 Body 的获取、HttpServletRequest HttpServletResponse 常见操作、HttpServletRequest HttpServletResponse 接口详解、HttpServletRequest HttpServletResponse 注意事项的相关知识，请在本站寻找。

本文标签：

• JavaEE
• HttpRequest
• servlet
• Web开发