• httpservletrequest-创建新会话/更改会话ID（新建servlet报错怎么办?）
• HttpServletRequest
• HttpServletRequest & HttpServletResponse 中 Body 的获取
• HttpServletRequest HttpServletResponse 常见操作
• HttpServletRequest HttpServletResponse 接口详解

httpservletrequest-创建新会话/更改会话ID（新建servlet报错怎么办?）

我正在维护Java Web应用程序。

通过登录代码，它可以通过HttpServletRequest的getSession（）方法从HttpServletRequest中获取一个HttpSession。（它在会话中使用一些值进行认证）

但是，我担心会话固定攻击，因此在使用初始会话后，我想开始一个新会话或更改会话ID。这可能吗？

答案1

Servlet 3.0 API不允许您更改现有会话上的会话ID。通常，为了防止会话固定，您将只想创建一个新的并使旧的无效。

您可以像这样使会话无效

request.getSession(false).invalidate();

然后创建一个新的会话

getSession(true)（也getSession()应该工作）

显然，如果会话中有要保留的数据，则需要将其从第一个会话复制到第二个会话。

请注意，对于会话固定保护，通常认为只对身份验证请求执行此操作即可。但是更高级别的安全性涉及为每个请求都抛弃旧会话并进行新会话。

HttpServletRequest

一、HttpServletRequest

web 客户端发送给 web 服务器的 HTTP 请求消息可以分为三个部分：请求行、请求消息头、消息正文（也叫实体内容）。Servlet 程序通过调用 ServletRequest 对象的方法可以获知客户端的请求信息，以及客户机和服务器的网络环境信息，例如获取客户发送的请求消息的各个部分和客户端 IP 地址。HttpServletRequest 是专用于 HTTP 协议的 ServletRequest 子接口，它用于封装 HTTP 请求消息，增加了获取 HTTP 协议专有的头信息的方法，以及获取 HTTP 请求消息参数的功能。

二、请求消息

1、获取请求行的相关信息

HTTP 请求消息的请求行可以分为三个部分：请求方式、资源路径和 HTTP 协议版本，如：

GET    /project/servlet/RequestURI?parm1=a&parm2=b    HTTP/1.1

RequestLineServlet.java

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class RequestLineServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html; charset=GB2312"); 
        PrintWriter out = response.getWriter();
        
        out.println("getMethod:" + request.getMethod() + "<br>");
        // 返回位于主机和端口之后、参数部分之前的那部分内容
        out.println("getRequestURI:" + request.getRequestURI() + "<br>");
        // 返回参数部分，无参数返回null
        out.println("getQueryString:" + request.getQueryString() + "<br>");
        // 返回协议名和版本号
        out.println("getProtocol:" + request.getProtocol() + "<br>");
        // 返回Web应用程序的路径（虚拟目录），这个路径以“/”开头
        out.println("getContextPath:" + request.getContextPath() + "<br>");
        // 返回servlet映射的路径（web.xml的url-pattern属性）
        out.println("getServletPath:" + request.getServletPath() + "<br>");
    }
}

注：URL 和 URI 的区别，可看 http://www.cnblogs.com/gaojing/archive/2012/02/04/2413626.html

2、获取请求头的信息

ServletRequest 和 HttpServletRequest 接口中定义了若干用于读取 HTTP 请求消息中的头字段的方法，其中的 getHeader 方法是一个通用的方法，可以读取所有的头字段。

（1）、获取所有请求头信息

RequestHeadersServlet.java

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class RequestHeadersServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html; charset=GB2312");
        PrintWriter out = response.getWriter();
        
        Enumeration<?> headerNames = request.getHeaderNames();
        while(headerNames.hasMoreElements()) {
            String headerName = (String)headerNames.nextElement();
            // 同一个请求头名可能出现多次
            Enumeration<?> values = request.getHeaders(headerName);
            while(values.hasMoreElements()) {
                out.println(headerName + ":" + (String)values.nextElement() + "<br>");
            }
        }
    }
}

在浏览器输入访问地址：http://localhost:8888/requestHeadersServlet/servlet/RequestHeadersServlet

现增加一个 html 文件，从它链接到该 Servlet，访问 referer.html：

<a href="servlet/RequestHeadersServlet">referer test</a>

访问 referer.html：

点击超链接，再次访问 RequestHeadersServlet

注意观察：请求消息包含了 referer 请求头。

（2）盗链

关于 “盗链”：http://baike.baidu.com/link?url=UpFE0AJdwVL2ESHqD6aF1N28Zmwi47RwoKzs50NI2t1HKBR6paci_NFhbv78hW-x

为了防止 “盗链”，需要检查请求的来路，只接受本站内的页面链接进来的下载请求，而阻止其他站点的页面链接进来的下载请求。要实现这样功能，就需要检查请求消息的 referer 头字段是否与本站匹配。

DownManagerServlet.java

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
    public class DownManagerServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html; charset=GB2312");
        String referer = request.getHeader("referer");
        String sitePart = "http://" + request.getServerName();
        PrintWriter out = response.getWriter();
        
        // 增加if判断是为了下载请求必须通过本站的下载页面链接进来，也就是防止盗链
        if(referer != null && referer.startsWith(sitePart)) {
            // 处理正当的下载请求，这里只是示意
            out.println("dealing download ...");
        } else {
            // 非法下载请求（即referer为空或不匹配sitePart）跳转到本站的下载说明页
            response.sendRedirect("../down.html");
        }
    }
}

down.html

<a href="servlet/DownManagerServlet">down</a>

在浏览器输入访问地址：localhost:8888/downManagerServlet/servlet/DownManagerServlet

因为请求消息不含 referer 请求头，即 DownManagerServlet 代码中的 referer 为空，跳转到 down.html

点击超链接，再次访问 DownManagerServlet，由于这时的请求消息包含有 referer 请求且值与 DownManagerServlet 位于同一 Web 站点，DownManagerServlet 接受下载请求。

3、获取请求消息的实体内容

以 POST 方式提交 HTML 的 FORM 表单时，其中的表单字段元素信息都将作为 HTTP 消息的实体内容（消息正文）发送给 Web 服务器。对应 HTTP 请求消息的中的实体内容，ServletRequest 以输入流的方式提供给 Servlet 程序读取，ServletRequest 接口中定义了一个 getInputStream 方法来返回这个字节输入流对象。为了方便读取纯文本形式的实体内容，ServletRequest 接口也定义了一个 getReader 方法，以返回一个代表实体内容的字符输入流对象。

getInputStream 与 getReader 方法

• getInputStream 返回输入流对象类型为 ServletInputStream，如果实体内容中包含二进制数据，那么只能使用 getInputStream 方法返回的输入流对象来读取实体内容。

• getReader 则返回一个 BufferedReader 对象。

• 调用了两者任意一个方法后，就不能再调用另一方法。

三、获取请求参数

HttpServletRequest 对象的最基本和最广泛应用就是获取浏览器传递给 Web 服务器的参数信息，这些参数信息既可以是 HTTP 请求消息的请求行中的 URL 地址后的附加信息，又可以是 Post 方式下 application/x-www-form-urlencoded 编码格式的实体内容。那么，如何获取这两种参数？

ServletRequest 和 HttpServletRequest 接口中定义了若干方法，这些方法除了能读取 HTTP 请求消息的请求行的 URL 地址后的附件信息外，还能读取 Post 方式下的 application/x-www-form-urlencoded 编码格式的实体内容。

• getParameter 方法：如果请求消息中没有包含指定名称的参数，该方法返回 null，即 getParameter ("firstname")，不存在这个参数返回 null；如果指定名称的参数存在但没有设置值，返回一个空串；如果包含多个指定名称相同的参数，返回第一个出现的参数值。另外，该方法对参数名大小写敏感。

• getParameterValues 方法：该方法用于获取某个指定名称的所有参数的值，并以一个 String 数组的形式返回这些参数值。如果参数值只有一个，返回的数组的长度就为 1，其中包含的元素值与 getParameter 方法返回的值一样。

• getParameterNames 方法：返回一个包含请求消息中所有参数名的 Enumeration 对象。

• getParameterMap 方法：返回一个将请求消息中所有参数名和值装进 Map 的 Map 对象

问：何为隐藏表单字段？

答：在 form 表单中可以使用隐藏表单字段元素向服务器传递参数信息，浏览器在网页上不会显示出隐藏表单字段元素，但当提交表单时，浏览器会将这个隐藏表单字段元素的 name 属性和 value 属性作为参数传递给 web 服务器。

四、利用请求域属性传递消息

ServletRequest 接口的实现类通常都是采用一个 HashMap 对象来存储某些对象，setAttribute 方法就是向这个 HashMap 对象中增加与某个名称绑定的对象，getAttribute 方法则是根据名称从这个 HashMap 对象中检索对象。这种存储在 ServletRequest 对象中的对象称之为请求域属性。

• setAttribute (String name, Object o)，如果 ServletRequest 对象中已经存在指定名称的属性，若属性值对象为 null 则相当于 removeAttribute，否则即覆盖原来对象。

• getAttribute (String name)，返回指定名称的属性对象。

• removeAttribute (String name)，删除指定名称的属性对象。

• getAttributeNames ()，返回一个包含 ServletRequest 对象中所有属性名的 Enumeration 对象。

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 的常用方法

2、一些区别细节

关于httpservletrequest-创建新会话/更改会话ID和新建servlet报错怎么办?的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于HttpServletRequest、HttpServletRequest & HttpServletResponse 中 Body 的获取、HttpServletRequest HttpServletResponse 常见操作、HttpServletRequest HttpServletResponse 接口详解的相关信息，请在本站寻找。