一个常见的面试题：说说Servlet的生命周期？
解释：变量的生命周期是指变量是怎么来的，变量又是怎么没得；而这里面说的Servlet的生命周期，既要说Servlet是怎么来的，又要说他是怎么没得，还包括中间的一些过程和状态；
init()方法，Servlet在初始化的过程中，会先调用一次init()方法，程序员就会让咱们自己写的类，重写init,就可以在初始化阶段做一些其他的工作了；
另外在Servlet销毁之前，还会调用一次destory方法，程序员也可以重写destory来做一些幕后工作；
1)Servlet在实例化一次之后进行调用一次init方法；
2)Servlet在每次收到一次请求的时候，调用一次Service方法；
3)在Servlet销毁之前，调用一次destory方法；
1 什么是tomact?
一：背景知识：
我们都知道，HTTP协议是前后端进行交互重要协议；
客户端：浏览器/代码自己进行实现
服务器：代码实现一个服务器，也可以使用现成的服务器，例如tomact
tomact就相当于是一个盒子，里面可以存放很多的webapp网站
二：下载Tomact软件
直接在网上搜索:https://tomact.apache.org;
进入官网之后，我们要使用Tomact 8的版本，Servlet使用的版本要和Tomact使用的版本配套
点击之后，直接下载Core中的第一个选项，zip(pgp,sha512)即可；
Tomact是跑在JDK上面的程序，所以JDK一定要提前配置好，下载Tomact压缩包之后要进行解压缩，文件的具体位置可以放在一个自己喜欢的地方；
我们点击bin中的startup就可以启动Tomact程序了，注意，在以后访问127.0.0.1的时候，一定要确保打开startup，否则会访问失败;
2 Tomact的使用
我们使用tomact的最大作用，就是为了部署一个webapp网站，
1静态页面：纯前端生成的代码，不需要服务器生成数据；
2动态页面：前后端搭配的代码，需要服务器生成数据；
部署静态页面：
1)我们首先来写一个html文件,名字就叫做hello.html，然后把它放到tomact中的webapp中的root里面，这个过程中必须重启tomact,这是在浏览器上面输入的地址是http://127.0.0.1:8080/hello.html 没有打开扩展名的时候文件名叫作hello;
双击html文件，也可以看到页面内容，但是这个过程相当于是用浏览器打开一个本地的文件
部署到tomact中，是通过输入一个URL，通过网络来访问的，别人电脑上部署，咱们也可以访问；
2)我们也可在webapp中，创建出一个目录叫做Java，再把world.html文件放到java里面，此时在访问浏览器,这是访问的路径就是http://127.0.0.1:8080/java/world.html**这里要注意，要是涉及到文件图片的操作，必须把图片的文件粘贴到Java文件里面；这个java也叫做Content-path;**
3 servlet知识和部署动态页面
一：什么是servlet?
Tomact是一组HTTP服务器，所以Tomact开放了一组API可以供程序员来使用，基于Tomact来进行业务开发，这组API就是Servlet;
基于Servlet要做的事情有这些：
1)初始化,允许程序员注册到一个类到Tomact中，让这个类和HTTP一个特定的请求来关联,类似于JS，给按钮来关联一个点击事件
2)进入循环，循环要处理很多很多请求
a)读取HTTP请求，Servlet解析这个字符串，生成一个HttpServletRequest对象;
b)根据请求对象生成一个HTTPServletResponse对象，来表示响应，这个响应的过程就是初始化阶段注册的类里面的代码完成的
c)将HTTPServletResponse转化成HTTP响应返回给浏览器
在这个过程中，我们只需要关注b过程即可，其他的过程，也就是这部分操作，Servlet和Tomact都帮我们实现好了
二：创建项目：
1）创建出一个maven项目：
点击idea中的新创建一个maven项目，配置文件路径和项目名字，文件路径我直接放到桌面上了；
2）引入依赖的Servlet.api的jar包，这样就可以使用HTTP的相关的类了，直接访问http://mvnrepository.com/ 即可；在里面直接搜索Servlet，使用3.1.0的版本即可
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
把这段代码拷贝即可，就是把这些代码放在pom.xml里面，在里面还要写一个额外的<dependencies>标签把这段代码包裹起来
三：编写代码:
1)创建好一个类,注意一定要在main方法下的java目录里面新创建出一个类，这个类必须继承自HttpServlet这样Tomact才会调用到这个类，如果刚才maven的以来下载的不正确，就不会出现HttpServlet这样的一个类，甚至会爆红；
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.Getwriter().write("hello")
}
}
这里面的doGET方法，是HttpServlet父类提供的方法，是重写的方法
这两个方法的参数是HttpServletRequest和HttpServletreponse
这里面的doGet方法就是根据请求计算响应
这里面的doGET方法,不需要我们程序员手动调用,也不需要手动创建出实例，而是Tomact方法自动调用
总结:类是怎么创建实例的,方法是怎么被调用的,我们都不需要关心;
我们还需要把super方法干掉,因为它会返回一个错误的响应
2)根据请求内容，重写里面的doPOST或doGET方法；
其中在方法去里面:resp.getWriter().write("hello");这个操作，就是向HTTP响应的body中，写了一个hello字符串
3）写完代码之后，需要保证当前的类和一个特定的HTTP请求关联起来，也就是说，当前还不知道，发送一个什么样的请求，才可以执行到HelloServlet里面的代码，需要在上面加上@WebServlet("/hello");他是Servlet提供的注解，功能就是把类和特定的HTTP请求进行关联
它是根据HTTP协议中的URL路径进行关联的；也就是说如果我们的Tomact收到了路径为/hello的请求，就会调用到HelloServlet的代码；
如果这个请求是一个GET请求，那么则会调用HelloServlet中的doGet方法；
如果这个请求是一个POST请求，那么则会调用HelloServlet中的doPOST方法；
咱们自己写的代码，都是有一个main方法，程序运行都是从这个方法里面来运行的；但是在Servlet中没有main方法，咱们自己写的代码不是自己调用的，而是Tomacat在合适的时机自动调用的；
四:创建出一些必要的文件和目录
要在main目录里面创建出一个新的目录，叫做webapp,然后再webapp里面创建出一个新的目录，叫做WEB-INF，再从WEB-INF中创建出一个新的文件，叫做web.xml;文件名不要弄错；
把这段代码放到web.xml中
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>Archetype Created Web Application</display-name>
</web-app>
五：打包程序 在当前的代码进行编译，中打成war包，jar包Tomcat是识别不了的；我们使用maven来进行打包；点击package进行双击，或者右边运行
想要达成war包，就要在pom.xml中加上
<packaging>war</packaging>
想要修改war包的名字，就要加上
<build>
<finalName>
要修改的名字 Java100
</finalName>
</build>
这时候打包出来的名字就是java100.war
六：部署程序
直接把war拷贝到Tomact中的webapps中的目录即可，这时候他和ROOT目录是同步的(可以在idea中直接右侧双击war包，open.in,找到文件位置，然后再进行拷贝；最后再点击startup,启动服务器；这时候就会在webapps中解压缩一个同级的目录
七：验证：URL：127.0.0.1：8080/war包的名字不带.war/@webServlet中的路径
4 通过SmartTomact来部署一个动态页面：
点击file中的setting中的Plugings下载SmartTomact
5 部署的常见错误
1）404 少写了content-path,少写了servlet-path,Servletpath和URL写的不匹配，web.xml写错了
2）405 没写doGET或者doPOST方法
3）500 代码中出现了错误
4）出现空白界面：没有写resp.GetWrite().write(),操作；
5) 无法访问此网站：打开startup.bat
6 Servlet的运行原理
一:接受请求
1)在用户浏览器上面输入一个URL，此时浏览器就会构造出一个HTTP请求；
2)这个HTTP请求会经过网络协议栈逐层进行封装成二进制的bit流,最终通过物理层的关键设备转化成光信号电信号，发送出去;
3)这些承载光信号,电信号通过互联网上面的一系列网络设备最终到达目标主机(这个过程也需要网络层和数据链路层的参与)
4)当服务器主机收到光信号，电信号的时候，又会经过网络协议栈进行分用，层层解析最终还原成一个HTTP请求,并交给Tomact进程进行处理;会根据端口号确定进程；
5）Tomact会通过Socket来读取这个请求,它的本质是一个字符串，并会根据HTTP请求的格式来解析这个字符串，根据请求中的Content-path来确定一个web-app，再通过Servlet path来确定一个具体的类，再根据当前的请求的方法(GET,POST)来决定调用这个类的doGET或者doPOST方法;此时我们的doGET和doPOST方法中的第一个参数HttPServletRequest就包含了这个HTTP请求的全部信息;
二:根据请求计算响应
在我们的doGET和doPOST方法中，就执行到了我们自己写的代码，我们自己的代码就会根据请求中的一些信息，来给HttpServletResponse来设置一些属性，例如状态码，header，body等;
三:返回响应:咱们的doGET和doPOST执行完这些方法之后,会自动把HttpServletResponse这个我们刚设置的好的对象转化成一个符合HTTP协议的字符串;通过Socket会把这个响应发出去
在到达应用层时,浏览器也会通过Socket来读到这个字符串，并按照HTTP协议的这个格式来解析这个响应，并且把这个body中的数据按照一定的格式来显示到字符串上面;
Tomcat的伪代码:
class tomact{
//1)先用一个数组class<Servlet> allServletclass来存放所有的被@servlet修饰过的类:
private List<Servlet> instancelist=new Arraylist<>();
public void start(){
//2)遍历这个allServletclass先通过类加载得到所有的类对象,用一个allServletClasses来存储;
Class<Serlvet>[] allServletClasses=......;
for(Class<Servlet> clas:allServletclasses)
{
Servlet ins=clas.newinstance();
instancelist.add(ins);
}
//3)当这些实例被创建好之后，再次遍历instancelist，调用这里面的init方法，来进行一个准备工作;
for(Servlet ins:instancelist)
{
ins.init();
}
4）创建线程池，为了可以使用Tomact来响应多个HTTP请求，所以使用多线程的方式来处理,这个过程就是处理请求返回相应的过程
Servletsocket servletsocket=new ServletSocket(8080);
ExecuteService pool=Exectors.newFixedThreadpool(100);
while(true)
{ //等待接收请求
Socket socket=servletsocket.accept();
pool.execute(new Runnable(){
doHTTPrequest(socket);
});
}
5)当这些实例被销毁之前,在遍历instancelist,调用其中的destory来进行收尾工作;
}
for(Servlet ins:instancelist)
{
ins.destory();
}
}
public static void main()
{
创建出一个Tomact实例，执行start()方法
}
dohttprequest(Socket socket)
{
//这个过程是根据之前学过的HTTP服务器的原理，进行HTTP请求进行解析，和相应的构建；
HttpServletRequest rep=HttpServletRequest.parse(socket);
HttpServletResponse resp=HttpServletRequest.build(socket);
Tomact会根据当前的Contentpath和Servletpath来判断要调用当前那个Servlet的实例方法
通过Service方法，就可以调用到我们之前写的doGET或者doPOST方法；
Servlet ins=findinstance(req.getURL());//得到了当前数组中的类对象
ins.service(req,resp);
}
public void service(HttpServletRequest req,HttpServletResponse resp)
{ String method=req.getMethod();
if(method.equals("GET")
{ doGET(req,resp);}
if(method.equals("POST")
{ doPOST(req,resp):}
service()方法的同等代码如下：
Servlet ins=new HelloServlet();
ins.doGET(req,resp);
7)解析ServletAPI
1.HttpServlet类
常用方法：
如何解决中文乱码问题呢：我们只需要在响应中的header里面加上Content-Type里面注明响应编码UTF-8
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/method")//这里面的关联要加上/，但是ajax构造请求时不需要加/
public class HelloServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//要保证setContentType在write的前面，否则会失效
//设置中文编码
resp.setContentType("text/html;charset=UTF-8");
resp.getWriter().write("我是一个GET请求");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=UTF-8");
resp.getWriter().write("我是一个POST请求");
}
}
我们是在webapp里面创建出一个html文件
<body>
<input type="button" value="发送Get请求" class="button1">
<input type="button" value="发送post请求" class="button2">
<script src="https://code.jquery.com/jquery-3.6.0.min.js"
integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4="
crossorigin="anonymous"></script>
<script>
let buttonget=document.querySelector(".button1");
let buttonpost=document.querySelector(".button2");
buttonget.onclick=function()
{
$.ajax({
type:"GET",//发送请求的类型
url:"method",
success: function(data,status)
{
console.log(data);
console.log(status);
}
})
}
buttonpost.onclick=function()
{ $.ajax({
type: "POST",
url: "method",
body:"request body",
success: function(data,status)
{
console.log(data);
console.log(status);
}
})
}
</script>
</body>
2 HttpServletRequest类
常用的方法：
举一个例子：
http:127.0.0.1:8080/java100_Servlet/hello?a=10&b=20;
1)String getQueryString() 他得到的是一个完整的queryString
2)Enumeration getParameterNames(),他是得到所有queryString中的key值，例如a,b
3)String getParameter(),这是根据key值，得到value的值，例如参数中传入一个a,返回的就是10
4)String[] getParameterValues(String name),这是处理key重复的情况
这几个方法不光可以操作query string,还可以操作x-www-form-urlencoded这个字符串的dody数据
5)Enumeration getheaderNames();//得到的是HOST，Referer之类的东西
6)String getHeader(String name)//例如传入一个HOST，得到具体报文的值
例如现在有一个GET的HTTP请求：
GET/HTTP/1.1
Host:127.0.0.1:8080
User-Agent:xxxxx;
Referer:http://127.0.0.1:8080/login
7) inputStream getInputStream这是先获取到一个流对象，然后就可以得到body的内容了
1） 获取GET请求中的参数
打印HTTPGET请求的报文格式
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;
@WebServlet("/method")
public class HelloServlet1 extends HttpServlet{
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//吧响应中的body放到stringBuider中，来构建一个字符串
StringBuilder stringBuilder=new StringBuilder();
stringBuilder.append(req.getProtocol());//得到版本号和协议信息
//获取请求中的URL部分
stringBuilder.append("<br>");
stringBuilder.append(req.getMethod());
stringBuilder.append("<br>");
stringBuilder.append(req.getRequestURI());
stringBuilder.append("<br>");
stringBuilder.append(req.getContextPath());
stringBuilder.append("<br>");
stringBuilder.append(req.getQueryString());
stringBuilder.append("<br>");
stringBuilder.append("<h3>headers:<h3>");
//获取请求中的报文部分
//获取请求报文中的类型，例如Host
Enumeration<String> headernames=req.getHeaderNames();
while(headernames.hasMoreElements())
{
String headername=headernames.nextElement();
stringBuilder.append(headername+": ");
stringBuilder.append(req.getHeader(headername));
stringBuilder.append("<br>");
}
resp.setContentType("text/html;charset=UTF-8");
resp.getWriter().write(stringBuilder.toString());
}
}
得到HTTP请求中的queryString部分
@WebServlet("/method")
public class HelloServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String userID=req.getParameter("userID");
String classID=req.getParameter("classID");
resp.getWriter().write(String.format("userID=%s classID=%s",userID,classID));
}
@WebServlet("/method")
public class HelloServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String userID=req.getParameter("userID");
String classID=req.getParameter("classID");
resp.getWriter().write(String.format("userID=%s classID=%s",userID,classID));
}
http://127.0.0.1:8080/java200/method?classID=10&userID=20
2）获取POST请求中的参数
一般来说，POST请求中的自定义数据都是放到body中的，通过获取getInputstream对象来得到body中的数据；
POST中的body类型又分为好几种格式
1）application/x-www-form-urlencoded类型，正文格式类似a=10&b=20，这是类似于queryString中的格式；
2）mutlipart/form-data,这种格式比较复杂，是用来提交文件的
3）application/json{
a=10,
b=20,
}
1)获取到第一种类型的body参数，这是和获取到querystring的方法是一样的
获取到第一种类型中的body参数，这是idea中的代码，还需要构建根据ajax或者form表单一个POST请求
@WebServlet("/post")
public class HelloServlet1 extends HttpServlet{
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;utf-8");
String str1=req.getParameter("classID");
String str2=req.getParameter("userID");
resp.getWriter().write(String.format("userID=%s classID=%s",str2,str1));
}
}
<form action="post" method="POST">
<input type="text" name="classID">
<input type="text" name="userID">
<input type="submit" value="提交">
</form>
上面写构造POST请求是通过form表单来构建的，也可以通过ajax的方式来构建；
<input type="button" class="button" value="构建一个post请求">
当我们点击这个按钮的时候，就会触发一个POST请求
<script src="https://code.jquery.com/jquery-3.6.0.min.js"
integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4="
crossorigin="anonymous"></script>
<script>
let button=document.querySelector(".button");
button.onclick=function(){
$.ajax({
type: "POST",
url: "post",
ContentType:"application/x-www-form-urlencoded",//注意这里面的类型要写对
data: "classID=30&userID=20",
success: function(data,status)
{
console.log(data);
console.log(status);
}
});
}
</script>
2）获取第三种方式的body,运用字节流的方式来获取，它的形式是json形式的字符串；
先构造请求，再写服务器idea代码
如果body是json格式，就可以先把整个body这个格式的字符串获取出来，再进行解析；
这个就需要用req.getInputStream()获取到一个字节流对象
咱们先约定一个格式
{ "classID":10,"userID":20},必须要用HTML来构造一个HTTPpost请求，json的字符串本身解析起来是十分复杂的，因为json里面可以进行嵌套，所以我们要使用可以解析json字符串的第三方库；
我们可以直接在中央仓库里面搜索jackson即可；直接用Jackson Databind即可，直接使用2.13.1版本即可；然后把这段代码直接放到pom.xml中；
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.3</version>
</dependency>
解析的java代码如下：
import com.fasterxml.jackson.databind.ObjectMapper;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
//通过这个类来表示解析后的结果
class JsonData{
public int classID;
public int userID;
}
@WebServlet("/post")
public class HelloServlet1 extends HttpServlet{
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1 先把整个body读出来
String Body=readbody(req);
//2当前我们是把body的整体字符串读取出来了，还需要对他进行解析
//3使用jackson解析json的时候,要明确的是要把这个字符串转化成一个什么样的对象，
//我们要把json解析后的结果放到一个类创建的对象中
//还要创建出一个Jackson的核心对象，ObjectMapper,这个类是来自中央仓库的jar包
//解析的过程就是把这个字符串转化成java对象
ObjectMapper mapper=new ObjectMapper();
//开始解析,这里面有两个内容，一个是解析的来源根源是神马，还有解析到一个啥样的类中，最终返回的对象，就是我们刚才创建出来的类的对象
JsonData jsonData=mapper.readValue(Body,JsonData.class);
//其实这个实例创建的过程就相当于把Body也就是JSON字符串成了一个java对象
//打印结果
String result=String.format("classID=%d,userID=%d",jsonData.classID,jsonData.userID);
resp.getWriter().write(result);
}
public String readbody(HttpServletRequest req) throws IOException
{ //读取body需要先通过req getInputStream得到一个流对象，从这个流对象中来读取
InputStream inputStream= req.getInputStream();
//先通过contentLength来得到body中的字节数
int contentlength=req.getContentLength();
//获取body中的字节数，主要是想创建出一个contentLength大小的缓冲区
byte[] arr1=new byte[contentlength];
inputStream.read(arr1);
return new String(arr1,"utf-8");
}
}
创建出一个Body为json格式的POST请求，注意构造json格式的字符串，只能使用ajax的方式来构建；
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<input type="button" class="button" value="构造一个POST请求">
<script src="https://code.jquery.com/jquery-3.6.0.min.js"
integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4="
crossorigin="anonymous"></script>
<script>
let body={
classID:100,
userID:200
}
let button=document.querySelector(".button");
button.onclick=function(){
$.ajax({
type:"POST",
url:"method",
data:JSON.stringify(body),
contentType:"application/json;charset=utf-8",
success:function(data,status)
{
console.log(data);
console.log(status);
}
})}
</script>
</body>
</html>
class JsonData{
public int classID;
public int userID;
}
JsonData jsonData=mapper.readValue(Body,JsonData.class);
{"userID":100,"classID":10}
我们一定要注意到这个过程中的字符串解析的过程；
1）先把JSON格式的字符串转换成一个类似于HashMap的键值对结构,相当于"userID"=>100，
"classID"=>10
2)获取到类对象，要获取到转换结果的类都有哪些属性，以及每个属性的名字，此时就要通过JsonData对象来获取到，里面的属性有两个，一个是userID,一个是classID；
3)拿着JsonData这里面每个属性的名字，去第一部构建出来的哈希表里面查，如果查到了，就赋值制给每一个属性，但是当我们创建出一个JsonData类的时候，需要这里面的成员的名字和JSON里面的字符串的KEY是相匹配的；
小结：我们使用HttpServletRequest****最常用的工作就是获取请求中的参数；
1）query string通过getParameter方法；
2）通过body(application/x-www-form-urlencoded也是用到getParameter方法
3）通过(application/json)的格式，先把整个body读取出来，然后再使用json库来进行解析
上面建立一个HTTP请求，通过部署一个页面来进行建立，或者使用ajax，也可以使用第三方软件，叫做postman
我们直接点击workspaces:想要创建出一个Body格式是JSON的POST请求，点击raw,在最右边选择JSON，在下面的空白处就可以写具体的格式了，这里面的路径不要写错；
3 HttpServletResponse对象的一些方法
1)HttpServletRequest里面的内容是由客户端进行构造的，服务器需要做的事情就是获取到这里面的内容,天生就是用来读的；
2)HttpServletResponse他里面的方法都是带有set字段,他里面的内容，是服务器构造的，是要返回给客户端的
1)void setStatus(int src)他是给相应设置状态码
2)void setHeader(String name,String value)这是设置一个给定名称的header,如果name已经存在，就覆盖掉原来的新值;
3)void addHeader(String name,String value)添加一个带有给的名称和值的header,如果name已经存在，不覆盖旧的值，并列创建出一个新的键值对；
4)void setContentType(String type)设置发送到客户端的相应的内容类型
5)void setCharacterEncoding(String charset)设置发送到客户端的字符编码类型
6)void sendRedirect(String location)使用指定的重定向位置的URL发送临时重定向到客户端
7)Printer getWriter()向body中写一个文本格式数据
8)OutputStream getOutputStream(),向body中写入一个二进制格式的数据
注意：1）对于HTTP响应来说，header中的key并不是唯一的，有些key可以重复出现，最典型的就是Set-Cookie属性
2)如何构造一个重定向相应呢，只需将状态码设成302，在header中设置location就可以了，但是这两个过程都可以用一个方法来代替，就是void setRedirect(String location)即可；
示例一：设置状态码
也就是说让用户输入一个请求，请求在queryString中设置一个参数，就表示相应的状态码，然后再根据用户的输入，返回不同的状态码的响应；
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/status")
public class HelloServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8");
String statusString=req.getParameter("status");
if(statusString==null||statusString.equals(""))
{
resp.getWriter().write("当前你写的querystring中的status参数缺失");
return;
}
resp.setStatus(Integer.parseInt(statusString));
resp.getWriter().write("status:"+statusString);
}
}
示例二：让页面自动刷新的案例：我么可以直接在header中设置一个Refresh,值就是刷新的间隔时间；
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/status")
public class HelloServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8");
//这表示在header设置一个属性为Refresh,参数是1s，表示每隔1s刷新一次
resp.setHeader("Refresh","1");
//直接显示一个时间戳，来观察动态页面的变化
long time=System.currentTimeMillis();
resp.getWriter().write("time :"+time);
}
}
示例三：设置一个重定向代码，就是又让他跳转到一个新的页面，呼叫转移，所以我们希望直接输入路径的时候，就直接跳转到搜狗主页了；
@WebServlet("/status")
public class HelloServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//resp.setStatus(302);
//resp.setHeader("Location","http://www.sougou.com");
//也可以这么写
resp.sendRedirect("http://www.sougou.com");
}
}
版权归原作者 学不会二叉树的小比特 所有， 如有侵权，请联系我们删除。