1、servet 执行过程:
public class FristServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.getWriter().write("this is first servlet！");
}
}<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name></display-name>
<!-- 配置一个servlet -->
<!-- servlet的配置 -->
<servlet>
<!-- servlet的内部名称，自定义。尽量有意义 -->
<servlet-name>FirstServlet</servlet-name>
<!-- servlet的类全名： 包名+简单类名 -->
<servlet-class>gz.itcast.a_servlet.FirstServlet</servlet-class>
</servlet>
<!-- servlet的映射配置 -->
<servlet-mapping>
<!-- servlet的内部名称，一定要和上面的内部名称保持一致！！ -->
<servlet-name>FirstServlet</servlet-name>
<!-- servlet的映射路径（访问servlet的名称） -->
<url-pattern>/first</url-pattern>
</servlet-mapping>
</web-app>由于客户端是通过URL地址访问web服务器中的资源，所以Servlet程序若想被外界访问，必须把servlet程序映射到一个URL地址上，这个工作在web.xml文件中使用<servlet>元素和<servlet-mapping>元素完成。 <servlet>元素用于注册Servlet，它包含有两个主要的子元素：<servlet-name>和<servlet-class>，分别用于设置Servlet的注册名称和Servlet的完整类名。 一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径，它包含有两个子元素：<servlet-name>和<url-pattern>，分别用于指定Servlet的注册名称和Servlet的对外访问路径。
访问URL： http://localhost:8080/day10/first 前提： tomcat服务器启动时，首先加载webapps中的每个web应用的web.xml配置文件。 http://: http协议 localhost： 到本地的hosts文件中查找是否存在该域名对应的IP地址 8080： 找到tomcat服务器 /day10 在tomcat的webapps目录下找 day10的目录 /first 资源名称。 1）在day10的web.xml中查找是否有匹配的url-pattern的内容（/first） 2）如果找到匹配的url-pattern,则使用当前servlet-name的名称到web.xml文件中查询是否相同名称的servlet配置 3）如果找到，则取出对应的servlet配置信息中的servlet-class内容：
字符串： gz.itcast.a_servlet.FirstServlet 通过反射： a）构造FirstServlet的对象 b）然后调用FirstServlet里面的方法
2、Servlet的映射路径 (如何的匹配):
<servlet-mapping>
<!-- servlet的内部名称，一定要和上面的内部名称保持一致！！ -->
<servlet-name>FirstServlet</servlet-name>
<!-- servlet的映射路径（访问servlet的名称） -->
<url-pattern>/first</url-pattern>
</servlet-mapping>url-pattern 浏览器输入 精确匹配 /first http://localhost:8080/day10/first /itcast/demo1 http://localhost:8080/day10/itcast/demo1 模糊匹配 /*（尽量不要写） http://localhost:8080/day10/任意路径 /itcast/* http://localhost:8080/day10/itcast/任意路径 *.后缀名 http://localhost:8080/day10/任意路径.do(这是一个确定的后缀名) *.do *.action *.html(伪静态)注意：
1）url-pattern要么以 / 开头，要么以*开头。 例如， itcast是非法路径。
2）不能同时使用两种模糊匹配，例如 /itcast/*.do是非法路径
3）当有输入的URL有多个servlet同时被匹配的情况下：
3.1 精确匹配优先。（长的最像优先被匹配）
3.2 以后缀名结尾的模糊url-pattern优先级最低！！！
（如果路径以/*则会导致静态资源加载不到）
例：对于如下的一些映射关系：
Servlet1 映射到 /abc/*
Servlet2 映射到 /*
Servlet3 映射到 /abc
Servlet4 映射到 *.do
问题：
当请求URL为“/abc/a.html”，“/abc/*”和“/*”都匹配，哪个servlet响应
Servlet引擎将调用Servlet1。
当请求URL为“/abc”时，“/abc/*”和“/abc”都匹配，哪个servlet响应
Servlet引擎将调用Servlet3。
当请求URL为“/abc/a.do”时，“/abc/*”和“*.do”都匹配，哪个servlet响应
Servlet引擎将调用Servlet1。
当请求URL为“/a.do”时，“/*”和“*.do”都匹配，哪个servlet响应
Servlet引擎将调用Servlet2。
当请求URL为“/xxx/yyy/a.do”时，“/*”和“*.do”都匹配，哪个servlet响应
Servlet引擎将调用Servlet2。
3 servlet缺省路径
servlet的缺省路径（<url-pattern>/</url-pattern>）是在tomcat服务器内置的一个路径。该路径对应的是一个DefaultServlet（缺省Servlet）。这个缺省的Servlet的作用是用于解析web应用的静态资源文件（比如根目录下的.html文件）。 tomcat里面内置的路径 <servlet-mapping> <servlet-name>default</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> 问题： URL输入http://localhost:8080/day10/index.html 如何读取文件？？？？ 1）到当前day10应用下的web.xml文件查找是否有匹配的url-pattern。 2）如果没有匹配的url-pattern，则交给tomcat的内置的DefaultServlet处理 3）DefaultServlet程序到day10应用的根目录下查找是存在一个名称为index.html的静态文件。 4）如果找到该文件，则读取该文件内容，返回给浏览器。 5）如果找不到该文件，则返回404错误页面。 结论： 先找动态资源，再找静态资源。
4 Sevlet的生命周期（重点）
import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
public class LifeDemo extends HttpServlet {
/**
* 1.构造方法
*/
public LifeDemo(){
System.out.println("1.servlet对象被创建了。");
}
/**
* 2.init方法
*/
@Override
public void init(ServletConfig config) throws ServletException {
System.out.println("2.init方法被调用");
}
/**
* 3.service方法
*/
@Override
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {
System.out.println("3.service方法被调用");
}
/**
* 4.destroy方法
*/
@Override
public void destroy() {
System.out.println("4.servlet对象销毁了");
}
}测试： 1.servlet对象被创建了。 2.init方法被调用 3.service方法被调用 3.service方法被调用 3.service方法被调用 3.service方法被调用 4.servlet对象销毁了 2017-12-12 21:11:37 org.apache.catalina.startup.HostConfig checkResources 信息: Reloading context [/day10_12.12] 1.servlet对象被创建了。 2.init方法被调用 3.service方法被调用 3.service方法被调用
构造方法： 创建servlet对象的时候调用。默认情况下，第一次访问servlet的时候创建servlet对象只调用1次。证明servlet对象在tomcat是单实例的。 init方法： 创建完servlet对象的时候调用。只调用1次。 service方法： 每次发出请求时调用。调用n次。（请求几次发送几次） destroy方法： 销毁servlet对象的时候调用。停止服务器或者重新部署web应用时销毁servlet对象。只调用1次。再打开的时候又重新构造）
1、针对客户端的多次Servlet请求，通常情况下，服务器只会创建一个Servlet实例对象，也就是说Servlet实例对象一旦创建，它就会驻留在内存中，为后续的其它请求服务，直至web容器退出，servlet实例对象才会销毁。 2、在Servlet的整个生命周期内，Servlet的init方法只被调用一次。而对一个Servlet的每次访问请求都导致Servlet引擎调用一次servlet的service方法。对于每次访问请求，Servlet引擎都会创建一个新的HttpServletRequest请求对象和一个新的HttpServletResponse响应对象，然后将这两个对象作为参数传递给它调用的Servlet的service()方法，service方法再根据请求方式分别调用doXXX方法。
4.3 伪代码演示servlet的生命周期
Tomtcat内部代码运行： 1）通过映射找到到servlet-class的内容，字符串： gz.itcast.a_servlet.FirstServlet 2）通过反射构造FirstServlet对象 2.1 得到字节码对象 Class clazz = class.forName("gz.itcast.a_servlet.FirstServlet"); 2.2 调用无参数的构造方法来构造对象 Object obj = clazz.newInstance(); ---1.servlet的构造方法被调用 3）创建ServletConfig对象，通过反射调用init方法 3.1 得到方法对象 Method m = clazz.getDeclareMethod("init",ServletConfig.class); 3.2 调用方法 m.invoke(obj,config); --2.servlet的init方法被调用 4）创建request，response对象，通过反射调用service方法 4.1 得到方法对象 Methodm m =clazz.getDeclareMethod("service",HttpServletRequest.class,HttpServletResponse.class); 4.2 调用方法 m.invoke(obj,request,response); --3.servlet的service方法被调用 5）当tomcat服务器停止或web应用重新部署，通过反射调用destroy方法 5.1 得到方法对象 Method m = clazz.getDeclareMethod("destroy",null); 5.2 调用方法 m.invoke(obj,null); --4.servlet的destroy方法被调用
4.4 用时序图来演示servlet的生命周期
5 Servlet的自动加载
默认情况下，第一次访问servlet的时候创建servlet对象。如果servlet的构造方法或init方法中执行了比较多的逻辑代码，那么导致用户第一次访问sevrlet的时候比较慢。
改变servlet创建对象的时机： 提前到加载web应用的时候！！！
在servlet的配置信息中，加上一个<load-on-startup>即可！！
<servlet>
<servlet-name>LifeDemo</servlet-name>
<servlet-class>gz.itcast.c_life.LifeDemo</servlet-class>
<!-- 让servlet对象自动加载 -->
<load-on-startup>1</load-on-startup> 注意： 整数值越大，创建优先级越低！！
</servlet>7 有参的init方法和无参的init方法
初始化的时间，有参的构造方法里面包含调用无参的构造方法，重写了有参的构造方法只会调用有参的构造方法，无参的构造方法不会调用，所以无参的构造方法是给开发者进行覆盖的，只用写无参的构造方法
public class InitDemo extends HttpServlet {
// 有参数的init方法
//该方法是servlet的生命周期方法，一定会被tomcat服务器调用
// 注意：如果要编写初始代码，不需要覆盖有参数的init方法
/*@Override
public void init(ServletConfig config) throws ServletException {
System.out.println("有参数的init方法");
}*/
/**
* 无参数的init方法
* 该方法是servlet的编写初始化代码的方法。是Sun公司设计出来专门给开发者进行覆盖，然后在里面编写servlet的初始逻辑代码的方法。
*/
@Override
public void init() throws ServletException {
System.out.println("无参数的init方法");
}
}8 Servlet的多线程并发问题
当多个客户端并发访问同一个Servlet时，web服务器会为每一个客户端的访问请求创建一个线程，并在这个线程上调用Servlet的service方法，因此service方法内如果访问了同一个资源的话，就有可能引发线程安全问题。
注意： servlet对象在tomcat服务器是单实例多线程的。
因为servlet是多线程的，所以当多个servlet的线程同时访问了servlet的共享数据，如成员变量，可能会引发线程安全问题。
解决办法：
1）把使用到共享数据的代码块进行同步（使用synchronized关键字进行同步）
2）建议在servlet类中尽量不要使用成员变量。如果确实要使用成员，必须同步。而且尽量缩小同步代码块的范围。（哪里使用到了成员变量，就同步哪里！！），以避免因为同步而导致并发效率降低。
public class TheradDemo extends HttpServlet {
int count = 1;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=utf-8");
synchronized (TheradDemo.class) {//锁对象必须唯一。建议使用类对象
response.getWriter().write("你现在是当前网站的第"+count+"个访客"); //线程1执行完 ， 线程2执行
//线程1还没有执行count++
count++;
}
}
}
9、ServletConfig对象
Servlet学习： HttpServletRequest 请求对象：获取请求信息 HttpServletResponse 响应对象： 设置响应对象 ServletConfig对象 servlet配置对象 ServletContext对象； servlet的上下文对象
普通的读取文件：
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
File file = new File("d:/a.txt");
//读取里面的内容
BufferedReader br = new BufferedReader(new FileReader(file));
String str = null;
while((str = br.readLine())!=null){
System.out.println(str);
}
}现在直接从servlet读取信息:
<servlet>
<servlet-name>ConfigDemo</servlet-name>
<servlet-class>gz.itcast.f_config.ConfigDemo</servlet-class>
<!-- 初始参数： 这些参数会在加载web应用的时候，封装到ServletConfig对象中 --> *****************
<init-param>
<param-name>path</param-name>
<param-value>d:/a.txt</param-value>
</init-param>
</servlet>public class ConfigDemo extends HttpServlet {
private ServletConfig config;
//1）tomcat服务器把这些参数会在加载web应用的时候，封装到ServletConfig对象中
// 2）tomcat服务器调用init方法传入ServletConfig对象
@Override
public void init(ServletConfig config) throws ServletException {
this.config = config;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
String phth = config.getInitParameter("path");
File file = new File(phth);
//读取里面的内容
BufferedReader br = new BufferedReader(new FileReader(file));
String str = null;
while((str = br.readLine())!=null){
System.out.println(str);
}
}
}init (ServletConfig config)throw ServletException在调用init方法之前创建了ServletConfig
Tomact 服务器一启动就会加载。xml里面的信息，把<init-param>封装到ServletConfig里面，所以得到对象： 直接从有参数的init方法中得到！！！
9.1 作用 ServletConfig对象: 主要是用于加载servlet的初始化参数。在一个web应用可以存在多个ServletConfig对象（一个Servlet对应一个ServletConfig对象） 9.2 对象创建和得到 创建时机： 在创建完servlet对象之后，在调用init方法之前创建。 得到对象： 直接从有参数的init方法中得到！！！**************************** ServletConfig的API： java.lang.String getInitParameter(java.lang.String name) 根据参数名获取参数值 java.util.Enumeration getInitParameterNames() 获取所有参数 ServletContext getServletContext() 得到servlet上下文对象 java.lang.String getServletName() 得到servlet的名称init属于HttpServlet类里面继承的GennericServlet：
GennericServlet里面也有一个init方法：
GennericServlet里面也有一个成员变量：private transient ServletConfig config;
public void init (ServletConfig config)throw ServletException{
this.config = config;
this.init();
}
tomcat首先把一堆：
<init-param>
<param-name>path</param-name>
<param-value>d:/a.txt</param-value>
</init-param>
信息封装到init的ServletConfig config里面，再赋值给GennericServlet里面定义的成员变量的config
GennericServlet里面还有这个方法：
public ServletConfig getServletConfig(){
return config;//返回的就是那个成员变量
}
然后直接通过：this.getServletConfig().getInitParameter("path");就可以调用了
所以上面的两段代码GenericServlet已经写了，我们无需编写！！
public class ConfigDemo1 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
String phth = this.getServletConfig().getInitParameter("path");
File file = new File(phth);
//读取里面的内容
BufferedReader br = new BufferedReader(new FileReader(file));
String str = null;
while((str = br.readLine())!=null){
System.out.println(str);
}
} <init-param>
<param-name>path</param-name>
<param-value>d:/a.txt</param-value>
</init-param>
<init-param>
<param-name>BBB</param-name>
<param-value>BBB'value</param-value>
</init-param>
<init-param>
<param-name>CCC</param-name>
<param-value>CCC'value</param-value>
</init-param>public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
String phth = this.getServletConfig().getInitParameter("path");
File file = new File(phth);
//读取里面的内容
BufferedReader br = new BufferedReader(new FileReader(file));
String str = null;
while((str = br.readLine())!=null){
System.out.println(str);
}
//查询当前servlet的所有初始化参数 Enumeration是一个迭代器
Enumeration<String> enums = this.getServletConfig().getInitParameterNames();
System.out.println(enums.hasMoreElements());
while(enums.hasMoreElements()){
String paramName = enums.nextElement(); //得到参数的名字
String paramValue = this.getServletConfig().getInitParameter(paramName);//得到参数的值
System.out.println(paramName+"="+paramValue);
}
//得到servlet的名称
String servletName = this.getServletConfig().getServletName();
System.out.println(servletName);
}aaaaaaaaaa
true
BBB=BBB'value
path=d:/a.txt
CCC=CCC'value
ConfigDemo1
10 ServletContext对象(封装所有的web.xml信息)
10.1 引入
ServletContext对象 ,叫做Servlet的上下文对象。表示一个当前的web应用环境。一个web应用中只有一个ServletContext对象。10.2 对象创建和得到
创建时机：加载web应用时创建ServletContext对象。
得到对象： 从ServletConfig对象的getServletContext方法得到
我们设计：
创建ServletConfig对象
public void init( ServletConfig config，ServletContext context ){ 多了一个参数
得到ServletConfig对象
得到ServletContext对象；
}
但是Sun公司设计的是：
1）创建ServletContext对象 ServletContext context = new ServletContext() //（1）加载完.xml之后创建ServletContext和ServletConfig
2）创建ServletConfig对象 ServetConfig config = new ServletConfig();
config.setServletContxt(context); //（2）将context塞到config里面
class ServletConfig{
ServletContext context;
public ServletContext getServletContxt(){
return contxt;
}
}
public void init( ServletConfig config ){
得到ServletConfig对象
//（3）从ServletConfig对象中得到ServletContext对象
SerlvetContext context = config.getServletContext();
}
10.3 ServletContext对象的核心API(作用):
java.lang.String getContextPath() --得到当前web应用的路径 java.lang.String getInitParameter(java.lang.String name) --得到web应用的初始化参数 java.util.Enumeration getInitParameterNames() void setAttribute(java.lang.String name, java.lang.Object object) --域对象有关的方法 java.lang.Object getAttribute(java.lang.String name) void removeAttribute(java.lang.String name) RequestDispatcher getRequestDispatcher(java.lang.String path) --转发（类似于重定向） java.lang.String getRealPath(java.lang.String path) --得到web应用的资源文件 java.io.InputStream getResourceAsStream(java.lang.String path)
10.4 得到web应用路径
java.lang.String getContextPath() 用在请求重定向的资源名称中
getServletContext()里面的源码的GennricServlet.class里面有：
直接返回getServletConfig().getServletContext()
public ServletContext getServletContext(){
return getServletConfig().getServletContext();
}public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//1.得到ServletContext对象
//ServletContext context = this.getServletConfig().getServletContext();
ServletContext context = this.getServletContext(); //（推荐使用）
//2.得到web应用路径 /day10 ， web应用路径：部署到tomcat服务器上运行的web应用名称（项目的名称）
String contextPath = context.getContextPath();
System.out.println(contextPath);
}改变一个部署过的项目的名称： Refactor--->Rename....改完之后再部署--》但是发现tomcat服务器里面并没有你刚改过的项目名字，还是你以前的项目的名字，web应用路径名字还没有改。 还要继续改----》要部署的名字：在项目的名字右键Properties----》MyEclipse----->Web---->改变Web Context-root上面的名称再部署就好啦(里面的斜杠不要去掉)
而在请求重定向的时候：
response.sendRedirect("day10/index.html");
但是当项目的名称改的话，里面的day10也是要改的，如果使用contextPath就不要用改了
response.sendRedirect(contextPath+"/index.html");
config只能访问具体的.xml里面的具体的参数
context 可以得到里面所有的.xml参数
10.5得到web应用的初始化参数（全局）
java.lang.String getInitParameter(java.lang.String name) --得到web应用的初始化参数 java.util.Enumeration getInitParameterNames() web应用参数可以让当前web应用的所有servlet获取！！！
配置文件的区域是在所有的<web-app>的里面在所有的<Servlet>外边配置
<!-- 配置web应用参数 全局的参数 -->
<context-param>
<param-name>AAA</param-name>
<param-value>AAA's value</param-value>
</context-param>
<context-param>
<param-name>BBB</param-name>
<param-value>BBB's value</param-value>
</context-param>
<context-param>
<param-name>CCC</param-name>
<param-value>CCC's value</param-value>
</context-param>public class ContxtDemo2 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ServletContext context = this.getServletContext();
System.out.println("参数" + context.getInitParameter("AAA"));
Enumeration<String> enums = context.getInitParameterNames();
while(enums.hasMoreElements()){
String paraname = enums.nextElement();
String paravalue = context.getInitParameter(paraname);
System.out.println(paraname + "="+paravalue);
}
}
}10.6域对象有关的方法
域对象：作用是用于保存数据，获取数据。可以在不同的动态资源之间共享数据。 保存数据：void setAttribute(java.lang.String name, java.lang.Object object) 获取数据： java.lang.Object getAttribute(java.lang.String name) 删除数据： void removeAttribute(java.lang.String name) ServletContext域对象：作用范围在整个web应用中有效！！！ 所有域对象： HttpServletRequet 域对象 ServletContext域对象 HttpSession 域对象 PageContext域对象保存数据：
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//得到域对象
ServletContext context = this.getServletContext();
//把数据保存到域对象中，存的数据要有名字，存的是字符串
context.setAttribute("name","reic");
System.out.println("数据保存成功！！");
}public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//得到域对象
ServletContext context = this.getServletContext();
//从域对象中取出数据，返回一个对象，强转为一个字符串
String name = (String)context.getAttribute("name");
System.out.println("name=" + name);
} 先访问保存数据，在访问读取数据，保存之后多次访问都直接访问到数据，后面的name=reic是多次访问的结果 输出结果： 数据保存成功！！ name=reic name=reic name=reic 它们得到的域对象都是同一个对象
保存对象数据： 在student和ContextDemo6 里面的context是同一个对象，就像是设置同一个账户，在这个账户里面存，在这个账户里面取。
public class ContextDemo5 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//得到域对象
ServletContext context = this.getServletContext();
//保存信息到域对象中
context.setAttribute("student",new Student("jacky",20));
System.out.println("保存成功。。。。");
}
class Student{
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(String name, int age) {
super();
this.name=name;
this.age = age;
}
@Override
public String toString() {
return "student [name=" + name + ", age=" + age + "]";
}
}
}public class ContextDemo6 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//得到域对象 两个是一个对象
ServletContext context = this.getServletContext();
//从域对象中取出数据
Student student = (Student)context.getAttribute("student");
System.out.println(student);
}
}输出： 保存成功。。。。 student [name=jacky, age=20]
10.7 转发：
RequestDispatcher getRequestDispatcher(java.lang.String path)
跳转到index.html页面：
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//转发
RequestDispatcher rd = this.getServletContext().getRequestDispatcher("/index.html");
rd.forward(request, response);
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//重定向
response.sendRedirect("/day10_12.12/index.html");
}http://localhost:8080/day10_12.12/ForwardDemo1 转发
http://localhost:8080/day10_12.12/index.html //重定向
一个web资源收到客户端请求后，通知服务器去调用另外一个web资源进行处理，称之为请求转发。
一个web资源收到客户端请求后，通知浏览器去访问另外一个web资源，称之为请求重定向。
RequestDispatcher.forward方法只能将请求转发给同一个WEB应用中的组件；而HttpServletResponse.sendRedirect 方法还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。
如果传递给HttpServletResponse.sendRedirect 方法的相对URL以“/”开头，它是相对于整个WEB站点的根目录；如果创建RequestDispatcher对象时指定的相对URL以“/”开头，它是相对于当前WEB应用程序的根目录。
调用HttpServletResponse.sendRedirect方法重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；调用RequestDispatcher.forward 方法的请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。
HttpServletResponse.sendRedirect方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的访问请求；RequestDispatcher.forward方法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。
RequestDispatcher.forward方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；而HttpServletResponse.sendRedirect方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。
public class ForwardDemo1 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setAttribute("name", "reose");
RequestDispatcher rd = this.getServletContext().getRequestDispatcher("/GetDataServlet");
rd.forward(request, response);
}
}public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//保存数据到request域对象
request.setAttribute("name", "rose");
//重定向
/**
* 注意：可以跳转到web应用内，或其他web应用，甚至其他外部域名。
*/
response.sendRedirect("/day10_12.12/GetDataServlet");
}public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 从request域对象中获取数据
*/
String name = (String)request.getAttribute("name");
System.out.println("name="+name);
}
分别请求：转发和重定向
输出：
name=reose
name=null
1）转发 a）地址栏不会改变 b）转发只能转发到当前web应用内的资源 （就是这个项目之内的资源） c）可以在转发过程中，可以把数据保存到request域对象中 2）重定向 a）地址栏会改变，变成重定向到地址。 b）重定向可以跳转到当前web应用，或其他web应用，甚至是外部域名网站。 c）不能再重定向的过程，把数据保存到request中。 结论： 如果要使用request域对象进行数据共享，只能用转发技术！！！
转发过程：
客户浏览器发送http请求,web服务器接受此请求,调用内部的一个方法在容器内部完成请求处理和转发动作,将目标资源发送给客户;在这里，转发的路径必须是同一个web容器下的url，其不能转向到其他的web路径上去，中间传递的是自己的容器内的request。
在客户浏览器路径栏显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。
重定向过程：
客户端发送一个请求到服务器端，服务器匹配Servlet，这都和请求转发一样。Servlet处理完之后调用了sendRedirect()这个方法，这个方法是response方法。所以，当这个Servlet处理完后，看到response.sendRedirect()方法，立即向客户端返回个响应，
响应行告诉客户端你必须再重新发送一个请求，去访问student_list.jsp，紧接着客户端收到这个请求后，立刻发出一个新的请求，去请求student_list.jsp,在这两个请求互不干扰、相互独立，在前面request里面setAttribute()的任何东西，在后面的request里面都获得不了。因此，在sendRedirect()里面是两个请求，两个响应。
Forward是在服务器端的跳转，就是客户端一个请求给服务器，服务器直接将请求相关参数的信息原封不动的传递到该服务器的其他jsp或Servlet去处理。而sendRedirect()是客户端的跳转，服务器会返回客户端一个响应报头和新的URL地址，原来的参数信息如果服务器没有特殊处理就不存在了，浏览器会访问新的URL所指向的Servlet或jsp，这可能不是原来服务器上的webService了。
三、重定向与转发的区别：
1.重定向是在客户端完成的，转发是在服务器完成的，转发的速度快，重定向速度慢；
2.转发只访问一次服务器，重定向访问两次服务器，所以相比较而言，转发对于服服务器的压力更小；
3.转发只能将请求转发给同一个web应用中的组件，重定向还可以重定向到其他网站；4、转发地址栏没有变化，重定向地址栏有变化；
5.转发 "/"的根目录是当前web应用下的根目录，而重定向是整个web站点的根目录，如代码中，同样跳转到GetDataServlet界面，但重定向却要在前面加上项目名；6.RequestDispatcher.forward方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程.而HttpServletResponse.sendRedirect方法调用者与被调用者使用各自的request对象和 response对象，它们属于两个独立的访问请求和响应过程。
重定向与转发的区别，通俗的来讲，打个比方：张三找李四借钱，李四没有钱，李四让张三自己去找王五借，这是重定向；张三找李四借钱，李四虽然没有钱，但李四从王五那借来钱，然后再借给张三，这是转发。补充：
Interface HttpServletResponse里面
从界面javax.servlet.servletresponse继承的方法：getWriter,
java.io.PrintWriter getWriter()
throws java.io.IOException
返回：
一个PrintWriter对象可以返回字符数据到客户端
void write(String s)
写入字符串。
意思就是将写入的字符串发送到客户端
扫一扫
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
