以上就是给各位分享HttpServletRequest对象(一),其中也会对servlet对象进行解释,同时本文还将给你拓展HttpServletRequest&HttpServletResponse
以上就是给各位分享HttpServletRequest对象(一),其中也会对servlet 对象进行解释,同时本文还将给你拓展HttpServletRequest & HttpServletResponse 中 Body 的获取、HttpServletRequest HttpServletResponse 常见操作、HttpServletRequest HttpServletResponse 接口详解、HttpServletRequest HttpServletResponse 注意事项等相关知识,如果能碰巧解决你现在面临的问题,别忘了关注本站,现在开始吧!
本文目录一览:- HttpServletRequest对象(一)(servlet 对象)
- HttpServletRequest & HttpServletResponse 中 Body 的获取
- HttpServletRequest HttpServletResponse 常见操作
- HttpServletRequest HttpServletResponse 接口详解
- HttpServletRequest HttpServletResponse 注意事项
HttpServletRequest对象(一)(servlet 对象)
javaweb学习总结(十)——HttpServletRequest对象(一)
一、HttpServletRequest介绍
HttpServletRequest对象代表客户端的请求,当客户端通过HTTP协议访问服务器时,HTTP请求头中的所有信息都封装在这个对象中,通过这个对象提供的方法,可以获得客户端请求的所有信息。
二、Request常用方法
2.1、获得客户机信息
getRequestURL方法返回客户端发出请求时的完整URL。
getRequestURI方法返回请求行中的资源名部分。
getQueryString 方法返回请求行中的参数部分。
getPathInfo方法返回请求URL中的额外路径信息。额外路径信息是请求URL中的位于Servlet的路径之后和查询参数之前的内容,它以“/”开头。
getRemoteAddr方法返回发出请求的客户机的IP地址。
getRemoteHost方法返回发出请求的客户机的完整主机名。
getRemotePort方法返回客户机所使用的网络端口号。
getLocalAddr方法返回WEB服务器的IP地址。
getLocalName方法返回WEB服务器的主机名。
范例:通过request对象获取客户端请求信息
package gacl.request.study;
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;
/**
* @author gacl
* 通过request对象获取客户端请求信息
*/
public class RequestDemo01 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 1.获得客户机信息
*/
String requestUrl = request.getRequestURL().toString();//得到请求的URL地址
String requestUri = request.getRequestURI();//得到请求的资源
String queryString = request.getQueryString();//得到请求的URL地址中附带的参数
String remoteAddr = request.getRemoteAddr();//得到来访者的IP地址
String remoteHost = request.getRemoteHost();
int remotePort = request.getRemotePort();
String remoteUser = request.getRemoteUser();
String method = request.getMethod();//得到请求URL地址时使用的方法
String pathInfo = request.getPathInfo();
String localAddr = request.getLocalAddr();//获取WEB服务器的IP地址
String localName = request.getLocalName();//获取WEB服务器的主机名
response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
//通过设置响应头控制浏览器以UTF-8的编码显示数据,如果不加这句话,那么浏览器显示的将是乱码
response.setHeader("content-type", "text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.write("获取到的客户机信息如下:");
out.write("<hr/>");
out.write("请求的URL地址:"+requestUrl);
out.write("<br/>");
out.write("请求的资源:"+requestUri);
out.write("<br/>");
out.write("请求的URL地址中附带的参数:"+queryString);
out.write("<br/>");
out.write("来访者的IP地址:"+remoteAddr);
out.write("<br/>");
out.write("来访者的主机名:"+remoteHost);
out.write("<br/>");
out.write("使用的端口号:"+remotePort);
out.write("<br/>");
out.write("remoteUser:"+remoteUser);
out.write("<br/>");
out.write("请求使用的方法:"+method);
out.write("<br/>");
out.write("pathInfo:"+pathInfo);
out.write("<br/>");
out.write("localAddr:"+localAddr);
out.write("<br/>");
out.write("localName:"+localName);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
运行结果:
2.2、获得客户机请求头
getHeader(string name)方法:String
getHeaders(String name)方法:Enumeration
getHeaderNames()方法
范例:通过request对象获取客户端请求头信息
package gacl.request.study;
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;
/**
* @author gacl
* 获取客户端请求头信息
* 客户端请求头:
*
*/
public class RequestDemo02 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
//通过设置响应头控制浏览器以UTF-8的编码显示数据
response.setHeader("content-type", "text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
Enumeration<String> reqHeadInfos = request.getHeaderNames();//获取所有的请求头
out.write("获取到的客户端所有的请求头信息如下:");
out.write("<hr/>");
while (reqHeadInfos.hasMoreElements()) {
String headName = (String) reqHeadInfos.nextElement();
String headValue = request.getHeader(headName);//根据请求头的名字获取对应的请求头的值
out.write(headName+":"+headValue);
out.write("<br/>");
}
out.write("<br/>");
out.write("获取到的客户端Accept-Encoding请求头的值:");
out.write("<hr/>");
String value = request.getHeader("Accept-Encoding");//获取Accept-Encoding请求头对应的值
out.write(value);
Enumeration<String> e = request.getHeaders("Accept-Encoding");
while (e.hasMoreElements()) {
String string = (String) e.nextElement();
System.out.println(string);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
运行结果如下:
2.3、获得客户机请求参数(客户端提交的数据)
- getParameter(String)方法(常用)
- getParameterValues(String name)方法(常用)
- getParameterNames()方法(不常用)
- getParameterMap()方法(编写框架时常用)
比如现在有如下的form表单
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Html的Form表单元素</title>
</head>
<fieldset>
<legend>Html的Form表单元素</legend>
<!--form表单的action属性规定当提交表单时,向何处发送表单数据,method属性指明表单的提交方式,分为get和post,默认为get-->
<form action="${pageContext.request.contextPath}/servlet/RequestDemo03" method="post">
<!--输入文本框,SIZE表示显示长度,maxlength表示最多输入长度-->
编 号(文本框):
<input type="text" name="userid" value="NO." size="2" maxlength="2"><br>
<!--输入文本框,通过value指定其显示的默认值-->
用户名(文本框):<input type="text" name="username" value="请输入用户名"><br>
<!--密码框,其中所有输入的内容都以密文的形式显示-->
密 码(密码框):
<!-- 表示的是一个空格-->
<input type="password" name="userpass" value="请输入密码"><br>
<!--单选按钮,通过checked指定默认选中,名称必须一样,其中value为真正需要的内容-->
性 别(单选框):
<input type="radio" name="sex" value="男" checked>男
<input type="radio" name="sex" value="女">女<br>
<!--下拉列表框,通过<option>元素指定下拉的选项-->
部 门(下拉框):
<select name="dept">
<option value="技术部">技术部</option>
<option value="销售部" SELECTED>销售部</option>
<option value="财务部">财务部</option>
</select><br>
<!--复选框,可以同时选择多个选项,名称必须一样,其中value为真正需要的内容-->
兴 趣(复选框):
<input type="checkbox" name="inst" value="唱歌">唱歌
<input type="checkbox" name="inst" value="游泳">游泳
<input type="checkbox" name="inst" value="跳舞">跳舞
<input type="checkbox" name="inst" value="编程" checked>编程
<input type="checkbox" name="inst" value="上网">上网
<br>
<!--大文本输入框,宽度为34列,高度为5行-->
说 明(文本域):
<textarea name="note" cols="34" rows="5">
</textarea>
<br>
<!--隐藏域,在页面上无法看到,专门用来传递参数或者保存参数-->
<input type="hidden" name="hiddenField" value="hiddenvalue"/>
<!--提交表单按钮,当点击提交后,所有填写的表单内容都会被传输到服务器端-->
<input type="submit" value="提交(提交按钮)">
<!--重置表单按钮,当点击重置后,所有表单恢复原始显示内容-->
<input type="reset" value="重置(重置按钮)">
</form>
<!--表单结束-->
</fieldset>
</body>
<!--完结标记-->
</html>
<!--完结标记-->
在Form表单中填写数据,然后提交到RequestDemo03这个Servlet进行处理,填写的表单数据如下:
在服务器端使用getParameter方法和getParameterValues方法接收表单参数,代码如下:
package gacl.request.study;
import java.io.IOException;
import java.text.MessageFormat;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 获取客户端通过Form表单提交上来的参数
*/
public class RequestDemo03 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//客户端是以UTF-8编码提交表单数据的,所以需要设置服务器端以UTF-8的编码进行接收,否则对于中文数据就会产生乱码
request.setCharacterEncoding("UTF-8");
/**
* 编 号(文本框):
<input type="text" name="userid" value="NO." size="2" maxlength="2">
*/
String userid = request.getParameter("userid");//获取填写的编号,userid是文本框的名字,<input type="text" name="userid">
/**
* 用户名(文本框):<input type="text" name="username" value="请输入用户名">
*/
String username = request.getParameter("username");//获取填写的用户名
/**
* 密 码(密码框):<input type="password" name="userpass" value="请输入密码">
*/
String userpass = request.getParameter("userpass");//获取填写的密码
String sex = request.getParameter("sex");//获取选中的性别
String dept = request.getParameter("dept");//获取选中的部门
//获取选中的兴趣,因为可以选中多个值,所以获取到的值是一个字符串数组,因此需要使用getParameterValues方法来获取
String[] insts = request.getParameterValues("inst");
String note = request.getParameter("note");//获取填写的说明信息
String hiddenField = request.getParameter("hiddenField");//获取隐藏域的内容
String instStr="";
/**
* 获取数组数据的技巧,可以避免insts数组为null时引发的空指针异常错误!
*/
for (int i = 0; insts!=null && i < insts.length; i++) {
if (i == insts.length-1) {
instStr+=insts[i];
}else {
instStr+=insts[i]+",";
}
}
String htmlStr = "<table>" +
"<tr><td>填写的编号:</td><td>{0}</td></tr>" +
"<tr><td>填写的用户名:</td><td>{1}</td></tr>" +
"<tr><td>填写的密码:</td><td>{2}</td></tr>" +
"<tr><td>选中的性别:</td><td>{3}</td></tr>" +
"<tr><td>选中的部门:</td><td>{4}</td></tr>" +
"<tr><td>选中的兴趣:</td><td>{5}</td></tr>" +
"<tr><td>填写的说明:</td><td>{6}</td></tr>" +
"<tr><td>隐藏域的内容:</td><td>{7}</td></tr>" +
"</table>";
htmlStr = MessageFormat.format(htmlStr, userid,username,userpass,sex,dept,instStr,note,hiddenField);
response.setCharacterEncoding("UTF-8");//设置服务器端以UTF-8编码输出数据到客户端
response.setContentType("text/html;charset=UTF-8");//设置客户端浏览器以UTF-8编码解析数据
response.getWriter().write(htmlStr);//输出htmlStr里面的内容到客户端浏览器显示
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
运行结果如下:
在服务器端使用getParameterNames方法接收表单参数,代码如下:
Enumeration<String> paramNames = request.getParameterNames();//获取所有的参数名
while (paramNames.hasMoreElements()) {
String name = paramNames.nextElement();//得到参数名
String value = request.getParameter(name);//通过参数名获取对应的值
System.out.println(MessageFormat.format("{0}={1}", name,value));
}
运行结果如下:
在服务器端使用getParameterMap方法接收表单参数,代码如下:
//request对象封装的参数是以Map的形式存储的
Map<String, String[]> paramMap = request.getParameterMap();
for(Map.Entry<String, String[]> entry :paramMap.entrySet()){
String paramName = entry.getKey();
String paramValue = "";
String[] paramValueArr = entry.getValue();
for (int i = 0; paramValueArr!=null && i < paramValueArr.length; i++) {
if (i == paramValueArr.length-1) {
paramValue+=paramValueArr[i];
}else {
paramValue+=paramValueArr[i]+",";
}
}
System.out.println(MessageFormat.format("{0}={1}", paramName,paramValue));
}
运行结果如下:
三、request接收表单提交中文参数乱码问题
3.1、以POST方式提交表单中文参数的乱码问题
例如有如下的form表单页面:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>request接收中文参数乱码问题</title>
</head>
<body>
<form action="<%=request.getContextPath()%>/servlet/RequestDemo04" method="post">
用户名:<input type="text" name="userName"/>
<input type="submit" value="post方式提交表单">
</form>
</body>
</html>
此时在服务器端接收中文参数时就会出现中文乱码,如下所示:
3.2、post方式提交中文数据乱码产生的原因和解决办法
可以看到,之所以会产生乱码,就是因为服务器和客户端沟通的编码不一致造成的,因此解决的办法是:在客户端和服务器之间设置一个统一的编码,之后就按照此编码进行数据的传输和接收。
由于客户端是以UTF-8字符编码将表单数据传输到服务器端的,因此服务器也需要设置以UTF-8字符编码进行接收,要想完成此操作,服务器可以直接使用从ServletRequest接口继承而来的"setCharacterEncoding(charset)"方法进行统一的编码设置。修改后的代码如下:
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 客户端是以UTF-8编码传输数据到服务器端的,所以需要设置服务器端以UTF-8的编码进行接收,否则对于中文数据就会产生乱码
*/
request.setCharacterEncoding("UTF-8");
String userName = request.getParameter("userName");
System.out.println("userName:"+userName);
}
使用request.setCharacterEncoding("UTF-8");设置服务器以UTF-8的编码接收数据后,此时就不会产生中文乱码问题了,如下所示:
3.3、以GET方式提交表单中文参数的乱码问题
例如有如下的form表单页面:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>request接收中文参数乱码问题</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/servlet/RequestDemo04" method="get">
姓名:<input type="text" name="name"/>
<input type="submit" value="get方式提交表单">
</form>
</body>
</html>
此时在服务器端接收中文参数时就会出现中文乱码,如下所示:
那么这个中文乱码问题又该如何解决呢,是否可以通过request.setCharacterEncoding("UTF-8");设置服务器以UTF-8的编码进行接收这种方式来解决中文乱码问题呢,注意,对于以get方式传输的中文数据,通过request.setCharacterEncoding("UTF-8");这种方式是解决不了中文乱码问题,如下所示:
3.4、get方式提交中文数据乱码产生的原因和解决办法
对于以get方式传输的数据,request即使设置了以指定的编码接收数据也是无效的(至于为什么无效我也没有弄明白),默认的还是使用ISO8859-1这个字符编码来接收数据,客户端以UTF-8的编码传输数据到服务器端,而服务器端的request对象使用的是ISO8859-1这个字符编码来接收数据,服务器和客户端沟通的编码不一致因此才会产生中文乱码的。解决办法:在接收到数据后,先获取request对象以ISO8859-1字符编码接收到的原始数据的字节数组,然后通过字节数组以指定的编码构建字符串,解决乱码问题。代码如下:
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
*
* 对于以get方式传输的数据,request即使设置了以指定的编码接收数据也是无效的,默认的还是使用ISO8859-1这个字符编码来接收数据
*/
String name = request.getParameter("name");//接收数据
name =new String(name.getBytes("ISO8859-1"), "UTF-8") ;//获取request对象以ISO8859-1字符编码接收到的原始数据的字节数组,然后通过字节数组以指定的编码构建字符串,解决乱码问题
System.out.println("name:"+name);
}
运行结果如下:
3.5、以超链接形式传递中文参数的乱码问题
客户端想传输数据到服务器,可以通过表单提交的形式,也可以通过超链接后面加参数的形式,例如:
<a href="${pageContext.request.contextPath}/servlet/RequestDemo05?userName=gacl&name=徐达沛">点击</a>
点击超链接,数据是以get的方式传输到服务器的,所以接收中文数据时也会产生中文乱码问题,而解决中文乱码问题的方式与上述的以get方式提交表单中文数据乱码处理问题的方式一致,
如下所示:
1 String name = request.getParameter("name");
2 name =new String(name.getBytes("ISO8859-1"), "UTF-8");
另外,需要提的一点就是URL地址后面如果跟了中文数据,那么中文参数最好使用URL编码进行处理,如下所示:
<a href="${pageContext.request.contextPath}/servlet/RequestDemo05?userName=gacl&name=<%=URLEncoder.encode("徐达沛", "UTF-8")%>">点击</a>
3.6、提交中文数据乱码问题总结
1、如果提交方式为post,想不乱码,只需要在服务器端设置request对象的编码即可,客户端以哪种编码提交的,服务器端的request对象就以对应的编码接收,比如客户端是以UTF-8编码提交的,那么服务器端request对象就以UTF-8编码接收(request.setCharacterEncoding("UTF-8"))
2、如果提交方式为get,设置request对象的编码是无效的,request对象还是以默认的ISO8859-1编码接收数据,因此要想不乱码,只能在接收到数据后再手工转换,步骤如下:
1).获取获取客户端提交上来的数据,得到的是乱码字符串,data="???è?????"
String data = request.getParameter("paramName");
2).查找ISO8859-1码表,得到客户机提交的原始数据的字节数组
byte[] source = data.getBytes("ISO8859-1");
3).通过字节数组以指定的编码构建字符串,解决乱码
data = new String(source, "UTF-8");
通过字节数组以指定的编码构建字符串,这里指定的编码是根据客户端那边提交数据时使用的字符编码来定的,如果是GB2312,那么就设置成data = new String(source, "GB2312"),如果是UTF-8,那么就设置成data = new String(source, "UTF-8")
四、Request对象实现请求转发
4.1、请求转发的基本概念
请求转发:指一个web资源收到客户端请求后,通知服务器去调用另外一个web资源进行处理。
请求转发的应用场景:MVC设计模式
在Servlet中实现请求转发的两种方式:
1、通过ServletContext的getRequestDispatcher(String path)方法,该方法返回一个RequestDispatcher对象,调用这个对象的forward方法可以实现请求转发。
例如:将请求转发的test.jsp页面
1 RequestDispatcher reqDispatcher =this.getServletContext().getRequestDispatcher("/test.jsp");
2 reqDispatcher.forward(request, response);
2、通过request对象提供的getRequestDispatche(String path)方法,该方法返回一个RequestDispatcher对象,调用这个对象的forward方法可以实现请求转发。
例如:将请求转发的test.jsp页面
1 request.getRequestDispatcher("/test.jsp").forward(request, response);
request对象同时也是一个域对象(Map容器),开发人员通过request对象在实现转发时,把数据通过request对象带给其它web资源处理。
例如:请求RequestDemo06 Servlet,RequestDemo06将请求转发到test.jsp页面
package gacl.request.study;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class RequestDemo06 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String data="大家好,我是孤傲苍狼,我正在总结JavaWeb";
/**
* 将数据存放到request对象中,此时把request对象当作一个Map容器来使用
*/
request.setAttribute("data", data);
//客户端访问RequestDemo06这个Servlet后,RequestDemo06通知服务器将请求转发(forward)到test.jsp页面进行处理
request.getRequestDispatcher("/test.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
test.jsp页面代码如下:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Request对象实现请求转发</title>
</head>
<body>
使用普通方式取出存储在request对象中的数据:
<h3><%=(String)request.getAttribute("data")%></h3>
使用EL表达式取出存储在request对象中的数据:
<h3>${data}</h3>
</body>
</html>
运行结果如下:
request对象作为一个域对象(Map容器)使用时,主要是通过以下的四个方法来操作
- setAttribute(String name,Object o)方法,将数据作为request对象的一个属性存放到request对象中,例如:request.setAttribute("data", data);
- getAttribute(String name)方法,获取request对象的name属性的属性值,例如:request.getAttribute("data")
- removeAttribute(String name)方法,移除request对象的name属性,例如:request.removeAttribute("data")
- getAttributeNames方法,获取request对象的所有属性名,返回的是一个,例如:Enumeration<String> attrNames = request.getAttributeNames();
4.2、请求重定向和请求转发的区别
一个web资源收到客户端请求后,通知服务器去调用另外一个web资源进行处理,称之为请求转发/307。
一个web资源收到客户端请求后,通知浏览器去访问另外一个web资源进行处理,称之为请求重定向/302。
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中读取配置文件方式
方式一:采用ServletContext读取,读取配置文件的realpath,然后通过文件流读取出来。
因为是用 ServletContext读取文件路径,所以配置文件可以放入在 WEB-INF的 classes目录中,也可以在 应用层级及 WEB-INF的目录中。文件存放位置具体在eclipse工程中的表现是: 可以放在src下面,也可放在web-info及webroot下面等。
因为是读取出路径后,用文件流进行读取的,所以可以读取任意的配置文件包括xml和properties。 缺点:不能在servlet外面应用读取配置信息。
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 的常用方法
方 法 |
说 明 |
getAttributeNames() |
返回当前请求的所有属性的名字集合 |
getAttribute(String name) |
返回 name 指定的属性值 |
getCookies() |
返回客户端发送的 Cookie |
getsession() |
返回和客户端相关的 session,如果没有给客户端分配 session,则返回 null |
getsession(boolean create) |
返回和客户端相关的 session,如果没有给客户端分配 session,则创建一个 session 并返回 |
getParameter(String name) |
获取请求中的参数,该参数是由 name 指定的 |
getParameterValues(String name) |
返回请求中的参数值,该参数值是由 name 指定的 |
getCharacterEncoding() |
返回请求的字符编码方式 |
getContentLength() |
返回请求体的有效长度 |
getInputStream() |
获取请求的输入流中的数据 |
getMethod() |
获取发送请求的方式,如 get、post |
getParameterNames() |
获取请求中所有参数的名字 |
getProtocol() |
获取请求所使用的协议名称 |
getReader() |
获取请求体的数据流 |
getRemoteAddr() |
获取客户端的 IP 地址 |
getRemoteHost() |
获取客户端的名字 |
getServerName() |
返回接受请求的服务器的名字 |
getServerPath() |
获取请求的文件的路径 |
HttpServletResponse
在 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、一些区别细节
javax.servlet.http.HttpServletRequest
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 的。
关于HttpServletRequest对象(一)和servlet 对象的问题我们已经讲解完毕,感谢您的阅读,如果还想了解更多关于HttpServletRequest & HttpServletResponse 中 Body 的获取、HttpServletRequest HttpServletResponse 常见操作、HttpServletRequest HttpServletResponse 接口详解、HttpServletRequest HttpServletResponse 注意事项等相关内容,可以在本站寻找。
本文标签: