Web常用对象HttpServletRequest 和HttpServletResponse
请求和常用对象:
请求的方式:(访问服务器的方式)
要访问服务器首先需要由客户端主动发出请求，在实际的操作中，我们可以 通过多种方式向服务器发起请求。根据不同的场景需求，使用不同的请求方式可 以达到不同的效果
共有六种方式:
1 地址栏输入:
在浏览器地址栏直接输入要访问的地址即可，此种方式可以看做是访问服务 器的起始操作。
http://ip:port/path
2 超链接:
使用超链接也可以向服务器发出请求
<a href=”http://www.shsxt.com”>百度</a>
3 Form 表单:
当需要向服务器发送请求，并且传输一些用户输入的数据时，我们优先选择form 表单的方式发起请求
4 ajax:
通过 ajax 发起的请求，属于异步请求，能实现局部刷新的效果，是一种比 较常用的请求方式。
通过 jQuery 中的 ajax(),get(),post(),getJSON()等方法都能发送请求
5 请求转发:
通过服务器内部将请求进行一次转发，可以请求到其他资源
6 重定向
服务器通过给定一个新资源的地址，响应会客户端后，客户端自动再次发送 一个请求到新资源的地址
HttpServletRequest:对象
介绍:
HttpServletRequest 对象：
主要作用是用来接收客户端发送过来的请求信息，
例如：请求的参数，发送的头信息等都属于客户端发来的信息， service()方法中 形参接收的是 HttpServletRequest 接口的实例化对象，
表示该对象主要应用在 HTTP 协议上，该对象是由 Tomcat 封装好传递过来。
HttpServletRequest 是 ServletRequest 的子接口，ServletRequest 只有一个 子接口，就是 HttpServletRequest 。既然只有一个子接口为什么不将两个接口合?
从长远上讲：现在主要用的协议是 HTTP 协议，但以后可能出现更多新的 协议。若以后想要支持这种新协议，只需要直接继承 ServletRequest 接口就行了
在 HttpServletRequest 接口中，定义的方法很多，但都是围绕接收客户端参 数的。但是怎么拿到该对象呢？不需要，直接在 Service 方法中由容器传入过来， 而我们需要做的就是取出对象中的数据，进行分析、处理
常用方法:
获取请求头:
获取客户端请求参数:
import java.io.IOException;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 实现Servlet
* 1、新建普通class类
* 2、继承HttpServlet类
* 3、重写service()方法
* 4、配置web.xml
*
*
* 常用方法
* @author sun
*
*/
@SuppressWarnings("serial") // 抑制警告
public class Servlet01 extends HttpServlet {
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("Servlet01...");
// 常用方法
// 获取请求的完整路径 （从http开始，到问号"?"结束）
String url = request.getRequestURL() + "";
System.out.println("获取请求的完整路径： " + url);
// 获取请求的部分路径（从站点名开始，到问号"?"结束）
String uri = request.getRequestURI();
System.out.println("获取请求的部分路径： " + uri);
// 获取请求的参数字符串 （从问号"?"开始，到最后）
String queryString = request.getQueryString();
System.out.println("获取请求的参数字符串： " + queryString);
// 获取请求方式 （GET/POST）
String method = request.getMethod();
System.out.println("获取请求方式： " + method);
// 获取站点名
String contextPath = request.getContextPath();
System.out.println("获取站点名： " + contextPath);
// 获取协议版本
String protocol = request.getProtocol();
System.out.println("获取协议版本: " + protocol);
// 获取指定名称的请求头的值 (key不区分大小写)
String host = request.getHeader("host");
System.out.println("Host： " + host);
// 获取所有请求头名称的枚举集合
Enumeration<String> enumerations = request.getHeaderNames();
while (enumerations.hasMoreElements()) {
String string = (String) enumerations.nextElement();
System.out.println(string);
}
// !!!!!! 获取指定名称的参数值
String uname = request.getParameter("uname");
System.out.println(uname);
}
}
请求乱码解决 :
由于现在的 request 属于接收客户端的参数，所以必然有其默认的语言编码， 主要是由于在解析过程中默认使用的编码方式为 ISO-8859-1(此编码不支持中 文)，所以解析时一定会出现乱码。要想解决这种乱码问题，需要设置 request 中 的编码方式，告诉服务器以何种方式来解析数据。或者在接收到乱码数据以后， 再通过相应的编码格式还
get()请求在 Tomcat 8.0及以上不会乱码 7.0及以下都会乱码(post()请求在Tomcat8.0及以上以及7.0在及以下都会乱码)
方法二: 一次只能设置一个值,对get post都有效
但是如果本身不乱码得话,用了这个方法就会发生乱码
具体看代码:
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 请求乱码解决
* request 属于接收客户端的参数，所以必然有其默认的语言编码，主要是由于在解析过程中默认使用的编码方式为 ISO-8859-1(此编码不支持中文)，所以解析时一定会出现乱码。
* 要想解决这种乱码问题，需要设置 request 中的编码方式，告诉服务器以何种方式来解析数据。或者在接收到乱码数据以后，再通过相应的编码格式还原。
*
* POST请求：Tomcat8及以上和Tomcat7及以下版本都会乱码
* GET请求：Tomcat8及以上不会乱码，Tomcat7及以下会乱码
*
* 方案一：
* 设置请求的编码 （只针对于POST请求有效,必须在接收所有的数据之前设定）
* request.setCharacterEncoding("UTF-8");
*
* 方案二：
* new String(request.getParameter("参数名").getBytes("ISO-8859-1"),"UTF-8");
* 无论是GET请求还是POST请求都适用。一次只能处理一个参数
*
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet02 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet02...");
/*方案一*/
// 设置请求的编码（只针对于POST请求有效,必须在接收所有的数据之前设定）
// req.setCharacterEncoding("UTF-8");
// 接收前台传递的参数
//String uname = req.getParameter("uname");
// System.out.println(uname);
/*方案二*/
// new String(request.getParameter("参数名").getBytes("ISO-8859-1"),"UTF-8");
String uname = new String(req.getParameter("uname").getBytes("ISO-8859-1"),"UTF-8");
System.out.println(uname);
}
}
重点: 请求转发:(服务器的行为)
请求转发，是一种服务器的行为，当客户端请求到达后，服务器进行转发， 此时会将请求对象进行保存，地址栏中的 URL 地址不会改变，得到响应后，服 务器端再将响应发送给客户端，从始至终只有一个请求发出。实现方式如下，达到多个资源协同响应的效果
req.getRequestDispatcher().forward();
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 请求转发
请求转发，是一种服务器的行为.
当客户端请求到达后，服务器进行转发，此时会将请求对象进行保存，地址栏中的 URL 地址不会改变
得到响应后，服务器端再将响应发送给客户端，从始至终只有一个请求发出。
实现方式如下，达到多个资源协同响应的效果
request.getRequestDispatcher("请求的地址").forward(request,response);
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet03 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet03....");
// 接收参数
String name = req.getParameter("uname");
System.out.println("Servlet03... name:" + name);
// 请求转发
req.getRequestDispatcher("ser04").forward(req, resp);
}
}
@SuppressWarnings("serial")
public class Servlet04 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet04....");
// 接收参数
System.out.println("Servlet04... name：" + req.getParameter("uname"));
}
}
5 request 作为域对象
通过该对象可以在一个请求中传递数据，作用范围：在一次请求中有效，即 服务器跳转有效。
request.setAttribute()：设置域对象内容；request.getAttribute(String name): 获取域对象内容；request.removeAttribute(String name): 删除域对象内容。
request 域对象中的数据在一次请求中有效，则经过请求转发，request 域 中的数据依然 存在，则在请求转发的过程中可以通过 request 来传输/共享数
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* request作为域对象
通过该对象可以在一个请求中传递数据，作用范围：在一次请求中有效，即服务器跳转有效。
request.setAttribute()：设置域对象内容；
request.getAttribute(String name):获取域对象内容；
request.removeAttribute(String name): 删除域对象内容。
request 域对象中的数据在一次请求中有效，则经过请求转发，request 域中的数据依然 存在，则在请求转发的过程中可以通过 request 来传输/共享数据。
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet05 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet05....");
// 设置request域对象
req.setAttribute("user", "zhangsan");
req.setAttribute("user2", "aa");
req.setAttribute("user3", "bb");
req.setAttribute("user4", "cc");
// 移除域对象
req.removeAttribute("user2");
// 获取域对象的值
String user = (String) req.getAttribute("user");
System.out.println(user);
String user2 = "lisi";
// 请求转发跳转到index.jsp
req.getRequestDispatcher("index.jsp").forward(req, resp);
}
}
HttpServletResponse 对象
介绍:
Web 服务器收到客户端的 http 请求，会针对每一次请求，分别创建一个用 于代表请求的 request 对象和代表响应的 response 对象。
request 和 response 对象代表请求和响应：获取客户端数据，需要通过 request 对象；向客户端输出数据，需要通过 response 对象。
HttpServletResponse 的主要功能用于服务器对客户端的请求进行响应，将 Web 服务器处理后的结果返回给客户端。service()方法中形参接收的是 HttpServletResponse 接口的实例化对象，这个对象中封装了向客户端发送数据、 发送响应头，发送响应状态码的方法。
常用方法:
3. 刷新和页面自动跳转
所有头信息都是随着请求和回应自动发送到服务器端（客户端），在 response 中一个比 较常用的头信息就是刷新的指令，可以完成定时刷新的功能。
resp.setHeader(“refresh”,“2”);
对于刷新的头信息，除了定时的功能外，还具备了定时跳转的功能，可以让 一个页面定时跳转到一个指定的页面。(已经注册成功，两秒后跳转到登陆页面)
response.setHeader(“refresh”,“3;URL=ok.html”);
但是这种跳转不是万能的，有时候根本就无法进行跳转操作，返回后刷新不 会跳转；对于这种定时跳转的头信息，也可以采用 HTML 的方式进行设置，HTML 本身也可以设 置头信息。(客户端跳转)
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 常用方法
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet01 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet01...");
// 添加响应头
// resp.addHeader("name", "admin");
// 设置错误状态码及说明
// resp.sendError(404, "由于颜值过低，无法访问！");
// 三秒钟后跳转到百度官网
// resp.setHeader("refresh", "3;url=http://www.shsxt.com");
// 每隔2秒刷新一次
resp.setHeader("refresh", "2");
}
}
- 数据响应
接收到客户端请求后，可以通过 HttpServletResponse 对象直接进行响应， 响应时需要获取输出流，有两种形式 getWriter()获取字符流(只能响应回字符)； getOutputStream()获取字节流(能响应一切数据)。响应回的数据到客户端被浏览 器解析。
注意：两者不能同时使用。
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 响应数据
* 接收到客户端请求后，可以通过 HttpServletResponse 对象直接进行响应，响应时需要获取输出流，
* 有两种形式
* getWriter()获取字符流(只能响应回字符)；
* getOutputStream()获取字节流(能响应一切数据)。
* 响应回的数据到客户端被浏览器解析。
* 注意：两者不能同时使用。
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet02 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet02...");
// 设置响应类型及编码格式
resp.setContentType("text/html;charset=UTF-8");
// getWriter()获取字符流(只能响应回字符)；
//PrintWriter writer = resp.getWriter();
//writer.write("<h4>Hello Servlet</h4>");
//writer.close();
// getOutputStream()获取字节流(能响应一切数据)。
//OutputStream outputStream = resp.getOutputStream();
//outputStream.write("<h4>Hello MyServlet</h4>".getBytes());
//outputStream.close()
String form = "<form action='ser02' method='get'>"
+ "<div class='form-group'><label for='uname'>名称</label>"
+ " <input type='text' class='form-control' name='uname' placeholder='请输入名称'>"
+ "</div> <div class='form-group'> <label for='upwd'>密码</label> "
+ " <input type='password' class='form-control' name='upwd' placeholder='请输入密码'> </div>"
+ " <button type='submit' >提交</button> </form>";
resp.getWriter().write(form);
resp.getWriter().close();
}
}
乱码解决
我们会发现在上述的响应中，如果我们响应的内容中含有中文，则有可能出 现乱码。这是因为服务器响应的数据也会经过网络传输，服务器端有一种编码方 式，在客户端也存在一种编码方式，当两端使用的编码方式不同时则出现乱码。
getWriter()的字符乱码
对于 getWriter()获取到的字符流，响应中文必定出乱码，由于服务器端在进 行编码时默认会使用 ISO-8859-1 格式的编码，该编码方式并不支持中文。所以要解决该种乱码只能在服务器端告知服务器使用一种能够支持中文的编码格式， 比如我们通常用的“UTF-8”
resp.setCharacterEncoding(“UTF-8”);，此时还只完成了 一半的工作，要保证数据正确显示，还需要指定客户端的解码方式 resp.setHeader(“content-type”, “text/html;charset=UTF-8”);，和服务器一致。两端 指定编码后，乱码就解决了。一句话：保证发送端和接收端的编码一致
以上两端编码的指定也可以使用一句替代，同时指定服务器和客户端
resp.setContentType(“text/html;charset=utf-8”);
getOutputStream()字节乱码
对于 getOutputStream()方式获取到的字节流，响应中文时，由于本身就是 传输的字节， 所以此时可能出现乱码，也可能正确显示，这就看人品了_。当 服务器端给的字节恰好和客户端使用的编码方式一致时则文本正确显示，否则出现乱码。无论如何我们都应该准确掌握服务器和客户端使用的是那种编码格式， 以确保数据正确显示。指定客户端和服务器使用的编码方式一致即可 。
resp.setHeader(“content-type”, “text/html;charset=UTF-8”);。
同样也可以使用一句替代
resp.setContentType(“text/html;charset=utf-8”);
总结：要想解决响应的乱码，只需要保证使用支持中文的编码格式。并且保 证服务器端 和客户端使用相同的编码方式即可
import java.io.IOException;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* 乱码解决
如果响应的内容中含有中文，则有可能出现乱码。
这是因为服务器响应的数据也会经过网络传输，服务器端有一种编码方式，在客户端也存在一种编码方式，当两端使用的编码方式不同时则出现乱码。
getWriter()的字符乱码
对于 getWriter()获取到的字符流，响应中文必定出乱码，由于服务器端在进行编码时默认会使用 ISO-8859-1 格式的编码，该编码方式并不支持中文。
所以要解决该种乱码只能在服务器端告知服务器使用一种能够支持中文的编码格式，
比如我们通常用的“UTF-8” resp.setCharacterEncoding("UTF-8");，
此时还只完成了一半的工作，要保证数据正确显示，还需要指定客户端的解码方式
resp.setHeader("content-type", "text/html;charset=UTF-8");，
和服务器一致。两端指定编码后，乱码就解决了。
一句话：保证发送端和接收端的编码一致
getOutputStream()字节乱码
对于 getOutputStream()方式获取到的字节流，响应中文时，由于本身就是传输的字节， 所以此时可能出现乱码，也可能正确显示，这就看人品了^_^。
当服务器端给的字节恰好和客户端使用的编码方式一致时则文本正确显示，否则出现乱码。
无论如何我们都应该准确掌握服务器和客户端使用的是那种编码格式，以确保数据正确显示。指定客户端和服务器使用的编码方式一致即可 。
总结：
乱码的原因：
1、客户端和服务端编码不一致
2、编码不支持中文
解决方案：
保证客户端和服务端编码一致且支持中文
response.setContentType("text/html;charset=UTF-8");
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet03 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet03...");
/* 设置客服端和服务端的编码一致，并支持中文*/
// 设置服务端的编码
//resp.setCharacterEncoding("UTF-8");
// 设置客户端的编码
//resp.setHeader("content-type", "text/html;charset=UTF-8");
// 使用一句代码代替上面两句
resp.setContentType("text/html;charset=UTF-8"); // 设置响应类型及编码格式
// getWriter()获取字符流(只能响应回字符)；
/*PrintWriter writer = resp.getWriter();
writer.write("<h4>你好</h4>");
writer.close();*/
// getOutputStream()获取字节流(能响应一切数据)。
OutputStream outputStream = resp.getOutputStream();
outputStream.write("<h4>你好</h4>".getBytes());
outputStream.close();
}
}
响应图片:
在学习 HTML 的时候我们知道使用的方式可以显示图 片。但有的时候我们并不知道(或不能确定)图片的路径，需要通过请求服务器资 源动态地响应图片给客户端。这种方式和文件拷贝的理念是一致的，客户端请求 服务器的资源，在服务端获取到真实的图片资源，通过输入流读取到内存，然后通过输出流写出到客户端即可。
值得注意的是，在客户端解析资源时默认是以文本（text/html）的形式，当 响应图片时 需要指定响应头信息，告知客户端响应内容为图片形式，使用一种 叫做 MIME 类型的东西来指定。MIME 类型见 Tomcat 的 web.xml 文件
定义某一个扩展名和某一个 MIME Type 做对应，包 含两个子元素：
扩展名的名称
MIME 格式
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* 响应图片
*
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet04 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("响应图片...");
// 设置响应类型
resp.setContentType("image/jpeg");
// 得到项目在服务器中的真实路径
String path = req.getServletContext().getRealPath("/");
// 得到图片的存放路径
String filePath = path + "/WEB-INF/jay.jpg";
// 通过路径得到file对象
File file = new File(filePath);
// 判断文件是否存在并且是一个标准文件
if (file.exists() && file.isFile()) {
// 得到输出流
ServletOutputStream out = resp.getOutputStream();
// 得到file对象的输入流
InputStream in = new FileInputStream(file);
// 输出
byte[] car = new byte[1024];
int len = 0;
while((len = in.read(car)) != -1) {
out.write(car, 0, len);
}
// 关闭资源
out.flush(); // 刷新流
in.close();
out.close();
} else {
System.out.println("文件不存在！");
}
System.out.println(path);
}
}
重定向跳转
重定向是一种服务器指导，客户端的行为。客户端发出第一个请求，被服务 器接收，经过处理服务器进行响应，与此同时，服务器给客户端一个地址（下次 请求的地址 resp.sendRedirect(“url”);），当客户端接收到响应后，立刻、马上、自动根据服务器 给的地址进行请求的发送第二个请求，服务器接收请求并作出 响应，重定向完成。从描述中可以看出重定向当中有两个请求存在，并且属于客 户端行为。实现方式如下
请求转发和重定向比:
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* 重定向
*
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet05 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet05...");
// 接收参数
String uname = req.getParameter("uname");
System.out.println("Servlet05 uname： " + uname);
// 设置request域对象
req.setAttribute("num", 1);
// 重定向
resp.sendRedirect("ser06");
}
}
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* 重定向
*
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet06 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet06...");
// 接收参数
String uname = req.getParameter("uname");
System.out.println("Servlet06 uname： " + uname);
// 获取域对象的值
System.out.println(req.getAttribute("num"));
}
}
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* 请求转发
* 1、只有一次请求，request作用域中的数据可以共享
* 2、浏览器地址栏不发生改变
* 3、服务端行为
* 4、跳转的绝对地址可以定位到站点名后
* 只能请求转发到当前项目下的资源
*
*
* 重定向的区别
* 1、有两次请求，request作用域中的数据不可以共享
* 2、浏览器地址栏发生改变
* 3、客户端行为
* 4、跳转的绝对地址可以定位到http://后面
* 重定向可以定位到任意资源
*
*
* 请求转发和重定向不能同时使用
*
*
* 路径问题
* 相对路径
* 路径的前面不要加任何符号，一般情况下代表的是: "http://localhost:8080/站点名/"
* 绝对路径
* 1、以http://开头的，完整的绝对路径，可以跨域，可以访问任何资源
* 2、以"/"开头，只能访问当前项目下的资源
*
* 请求转发和重定向的"/"代表的含义：
* 1、请求转发（服务端跳转）："http://localhost:8080/站点名/"
* 2、重定向（客户端跳转）："http://localhost:8080/"
*
* 客户端跳转：
* 表单提交、超链接跳转、地址栏直接收入、重定向
* 服务端跳转：
* 请求转发
*
* @author sun
*
*/
@SuppressWarnings("serial")
public class Servlet07 extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Servlet07...");
// 请求转发
// req.getRequestDispatcher("index.html").forward(req, resp); // OK
// req.getRequestDispatcher("/index.html").forward(req, resp); // OK
// req.getRequestDispatcher("s03/index.html").forward(req, resp); // No HTTP Status 404 - /s03/s03/index.html
// req.getRequestDispatcher("/s03/index.html").forward(req, resp); // No HTTP Status 404 - /s03/s03/index.html
// req.getRequestDispatcher("http://localhost:8080/s03/index.html").forward(req, resp); // No HTTP Status 404 - /s03/http://localhost:8080/s03/index.html
// req.getRequestDispatcher("http://www.shsxt.com").forward(req, resp); // No HTTP Status 404 - /s03/http://www.shsxt.com
// 重定向
// resp.sendRedirect("index.html"); // OK
// resp.sendRedirect("/index.html"); // No http://localhost:8080/index.html
// resp.sendRedirect("s03/index.html"); // No HTTP Status 404 - /s03/s03/index.html
// resp.sendRedirect("/s03/index.html"); OK
// resp.sendRedirect("http://localhost:8080/s03/index.html");
resp.sendRedirect("http://www.shsxt.com");
}
}
跟路径:
http://localhost:8080/站点名
请求转发:(有没有/)
都是 http://localhost:8080/站点名
重定向:
有 /:http://localhost:8080
无 /:http://localhost:8080/站点名