JAVA WEB---Requset,Response

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//---------------------------4.Request请求转发-资源共享----------------------------------------
//request.getRequestDispatcher("xxxxx").forward(request, response); 

/*
      一个Servlet可以将用户的请求转发给另一个资源(Servlet,Jsp.html),由另一个资源来产生应答的内容
  
			请求转发: 实现资源的跳转, 服务器内部的跳转. 一次请求 一次响应   ------地址栏不会发生变化-----
				RequestDispatcher rd = request.getRequestDispatcher("xxxxx");//调度器
				rd.forward(request, response);								//实现请求转发
				等价于:
				request.getRequestDispatcher("xxxxx").forward(request, response);  请求转发forward
				
				request.getRequestDispatcher("xxxxx").include(request, response);  请求包含include
				
				
			注意:
			注意1.在请求转发之前, 如果response缓冲区写入了数据但是还没有打给浏览器, 在请求转发时这些数据将会被清空
			注意2.在请求转发之前, 如果response缓冲区写入了数据并且打给了浏览器, 请求转发失败抛出异常!破坏一次请求一次应答
			注意3.请求转发就像方法的调用, 在转发代码之后的代码将会在转发结束后继续执行
			注意4.不能多次转发, 但是可以多重转发
 * 
 */


//浏览器输入http://localhost/day010JavaWebServlet/servlet/Request04
//输出	Request04收到用户请求
//                                没有浏览器显示Request04帮你转发给Request05    
//													注意1:在请求转发之前, 如果response缓冲区写入了数据但是还没有打给浏览器, 在请求转发时这些数据将会被清空
//								    如果在forward之前调用了response.fluseBuffer()，出现异常
//													注意2：在请求转发之前, 如果response缓冲区写入了数据并且打给了浏览器,会导致应答提交, 请求转发失败抛出异常!破坏一次请求一次应答
//		Request05收到请求
//浏览器显示：我是Request05给你的
//		Requesr05执行完毕

//		Request04响应请求完毕

//整个输出发现执行权先给Request04再转发给Request05再还给Request04
//			注意3：请求转发就像方法的调用, 在转发代码之后的代码将会在转发结束后继续执行

public class Request04 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		 System.out.println("Request04收到用户请求");                     //收到用户请求
		 response.getWriter().write("Request04帮你转发给Request05");      //Request04给用户一个请求
		 
		 //注意2：如果在forward之前调用了flushBuffer,会导致应答提交,之后再进行请求转发，会抛出异常 . 破坏一次请求一次应答
		 //response.fluseBuffer();
		 
		 
		 
		 //将请求转发给Request05
		 //获取一个请求的调度器path->转发目标资源的url
		 //不需要在path中携带web应用的路径，因为请求的转发只能在当前web应用内部进行
		 RequestDispatcher rd=request.getRequestDispatcher("/servlet/Request05");
		 
		 
		 //实现请求的转发
		 //注意1. forward时，会清空response缓冲区的所有内容，因此当前Servlet生成的应答内容会被清空，不会发给用户
		 rd.forward(request, response);
		 //注意4：forward只能做一次，多一次会产生异常，不能破坏一次请求一次应答。     不能多次转发, 但是可以多重转发
		// rd.forward(req, resp);
		 
		 
		 System.out.println("Request04响应请求完毕");
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

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 Request05 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		System.out.println("Request05收到请求");
		response.getWriter().write("--------Request05--give-----------");
		System.out.println("Requesr05执行完毕");
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


//---------------------------5.Request请求包含---------------------
//request.getRequestDispatcher("xxxxx").include(request, response);  请求包含include
/*
 * 实现请求包含
			所谓的请求包含指的是服务器内部实现资源合并的效果
			如果浏览器请求ServletA, 在A的内部可以通过
			request.getRequestDispatcher("B的虚拟路径").include(request, response);
			将ServletB包含进来, 这时将由A和B共同处理该请求, B处理的结果将会并入A处理的结果, 一起响应给浏览器
			
			request.getRequestDispatcher("xxxxx").forward(request, response);  请求转发forward
				
			request.getRequestDispatcher("xxxxx").include(request, response);  请求包含include
			
			
			注意:可以包含来自多个组件的应答内容
 */
//浏览器输入http://localhost/day010JavaWebServlet/servlet/Request06
//输出： 浏览器显示:Request06 before include
//		浏览器显示:Request07 include
//		浏览器显示:Request06 after include
public class Request06 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.getWriter().write("Request06 before include");
		request.getRequestDispatcher("/servlet/Request07").include(request, response);
		response.getWriter().write("Request06 after include ");
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

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 Request07 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.getWriter().write("Request07 include ");
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//-----------------------6.Request 作为域对象来使用--------------------------------
/*
 * 作为域对象来使用
			域对象: 一个对象具有可以被看见的范围, 利用这个对象身上的map就可以实现资源的共享, 像这样的对象就称之为域对象
			setAttribute(String name, Object valObj);
			getAttribute(String name);
			removeAttribute(String name);
			getAttributeNames();		

			生命周期: 一次请求开始, 到一次请求结束
			作用范围: 在整个请求链上都可以看见
			主要功能: 在转发时带数据到目的地, Servlet将处理的结果通过request作用域带给jsp
 */
/*
  	Servlet将处理的结果通过request作用域带给jsp
  
  	处理逻辑：
		第一步:Servlet获取用户浏览器传过来的数据
				3.Request获取请求参数 
				Requset.getParameter(String name) --- String 通过name获得值
		
		第二步:Servlet将参数存入Request作用域对象
				6.Request 作为域对象来使用 
				Request.setAttribute(String name, Object valObj); 将参数存入Request对象  
				
		第三步:Servlet携带数据转发到JSP
				4.Request请求转发
				request.getRequestDispatcher("xxxxx").forward(request, response);  调度器.请求转发
		
		第四步:JSP从Requst作用域获取对象
				6.Request 作为域对象来使用 
				Request.getAttribute(String name);    从Request对象取出参数 
			
 */
//浏览器输入localhost/day010JavaWebServlet/servlet/Request08?username="szh"&nickname="SHENZHIHENG"
//输出	浏览器显示:
/*
 * This my Jsp
	
			6.Request 作为域对象来使用 
			从Request对象取出参数 getAttribute(String name);
			姓名:szh
			昵称："SHENZHIHENG"
 */
			
public class Request08 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		//3.获取请求参数 
		//getParameter(String name) --- String 通过name获得值
		String username=request.getParameter("username");
		String nickname=request.getParameter("nickname");
		if(username==null){
			username="游客";
		}
		
		//6.Request 作为域对象来使用  
		//将参数存入Request对象    setAttribute(String name, Object valObj); 
		request.setAttribute("user", username);
		request.setAttribute("nickname", nickname);
		
		//4.Request请求转发
		//request.getRequestDispatcher("xxxxx").forward(request, response);  调度器.请求转发
		request.getRequestDispatcher("/index.jsp").forward(request, response);
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


/*
 * Response
  		概念:代表了服务器给用户的一次应答，一个response对象中封装的是给用户应答的全部信息
  
  ----------------Response上的重要方法----------------------------------------------
		
		设置应答状态码码的方法
			void setStatus(int sc)
	 		void setStatus(int sc, String sm)  
		设置应答头的方法
			void setHeader(String name, String value)    set有就改(更新)，没有就添加
			void setDateHeader(String name, long date)
			void setIntHeader(String name, int value) 

			void addHeader(String name, String value)    add不管有没有都添加新的
			void addDateHeader(String name, long date)
			void addIntHeader(String name, int value)
			
		设置应答内容的方法
			ServletOutputStream getOutputStream()  字节流
			PrintWriter getWriter()      		     字符流
			
	----------------Response上的重要方法------------------------------------------------
	
	
	
	
	----------------1.Response向客户端发送数据 (!!!重点, 特别是乱码问题)--------------------------------------------
			1.1Response.getOutputStream().writer()  字节流
			1.2Response.getWriter().writer() 	      字符流
			    乱码解决:response.setContentType("text/html;charset=xxx");通知浏览器使用utf-8打开服务器发送过去的数据         
			
			
			***字节流发送数据的中文乱码问题
				服务器端指定了用utf-8来发送数据, 浏览器在接受数据时, 如果不指定将使用默认的平台码GBK, 编解码不一致导致乱码. 
			解决方案: 
				response.setHeader("Content-Type", "text/html;charset=utf-8");// 通知浏览器使用utf-8打开服务器发送过去的数据
				response.getOutputStream().write("中国".getBytes("utf-8"));// 指定编码为utf-8
			
			***字符流发送数据的中文乱码问题
				利用字符流发送数据, 底层还是要转成字节. 服务器端如果不手动指定, 服务器默认会使用iso8859-1码表, 由于里面没有中文汉字, 所以服务器端发送给客户端就是一堆乱码, 客户端不管使用什么码表都无法转成正常的字符

				* 服务器会根据getCharacterEncoding()方法返回的编码来发送数据, 如果没有指定, 该方法默认返回iso8859-1

				* 解决方案:
					第一步, 需要指定服务器发送数据使用utf-8
						response.setCharacterEncoding("utf-8"); //通知服务器使用utf-8来发送响应实体中数据
					第二步: 需要指定浏览器在接收数据时也使用同一个编码来打开数据
						response.setHeader("Content-Type", "text/html;charset=utf-8");
						等价于<==>
						response.setContentType("text/html;charset=utf-8");
					
				* 在通知浏览器使用什么编码接受服务器发送的数据时, 服务器很智能, 会使用相同的编码来发送数据, 所以指定服务器以什么编码发送数据的代码可以省略不写


		-----------------------------------------------------------------------------------------------------------------
		|	总结: 不管是字符流还是字节流, 解决乱码问题, 可以用一行代码搞定:											        |
		|		response.setContentType("text/html;charset=xxx");通知浏览器使用utf-8打开服务器发送过去的数据                          |
		 ----------------------------------------------------------------------------------------------------------------
	
	           注意:
			注意1:getOutputStream()和getWriter() 这两个方法是互斥的, 在一次请求当中调用了其中的一个, 就不能再调用另一个!!!

			注意2:在调用完getOutputStream()或getWriter()方法之后, 不需要手动去关闭流, 服务器会自动帮我们去关闭!!!
			
			注意3:这个两个方法获取到的流并不是指向客户端的流, 而是指向response缓冲区的流, 通过流将数据写入response缓冲区, service方法执行结束, 请求回到服务器(web容器), 由服务器(web容器)将数据组织成响应消息打给浏览器!!
	
	
 */

//浏览器输入localhost/day010JavaWebServlet/servlet/Response01
public class Response01 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		//1.1通过response对象输出应答实体内容->字节流     
		//		Response.getOutputStream().write()->字节流
		
				//response.getOutputStream().write("aaa".getBytes());   //输出aaa,  默认两边都使用平台字符集-gbk，所以没有乱码
				//response.getOutputStream().write("中国".getBytes());  	//输出�й�， 服务器默认使用ISO8859-1,浏览器默认使用gbk解码，所以会造成乱码
				
		
		//字节流乱码		
				response.getOutputStream().write("中国".getBytes("utf-8")); //输出涓浗
				//问题:服务器端指定了用utf-8来发送数据, 浏览器在接受数据时, 如果不指定将使用默认的平台码GBK, 编解码不一致导致乱码. 		
				//解决:通知浏览器使用utf-8进行解码
				response.setHeader("content-type", "text/html;charset=utf-8");//输出中国
		
		
		//1.2通过response对象输出应答实体内容->字符流     
		//		Response.getWriter().write()->字符流
		
		
		//字符流乱码
				//问题:利用字符流发送数据, 底层还是要转成字节. 服务器端如果不手动指定, 服务器默认会使用iso8859-1码表,
				//		由于里面没有中文汉字, 所以服务器端发送给客户端就是一堆乱码, 客户端不管使用什么码表都无法转成正常的字符
				//解决:	第一步:需要指定服务器发送数据使用utf-8   
				//		第二步: 需要指定浏览器在接收数据时也使用同一个编码来打开数据
		
		
				// 第一步:需要指定服务器发送数据使用utf-8   
				response.setCharacterEncoding("utf-8");
				// 第二步:需要指定浏览器在接收数据时也使用同一个编码来打开数据注意:同时服务器会自动使用utf-8进行编码
				response.setContentType("text/html;charset=utf-8");
			
				
				response.getWriter().write("中国"); //输出??

			/*乱码总结:
			      注意:在通知浏览器使用什么编码接受服务器发送的数据时, 服务器很智能, 会使用相同的编码来发送数据.
			             所以指定服务器以什么编码发送数据的代码可以省略不写
				 -----------------------------------------------------------------------------------------------------------------
				|	总结: 不管是字符流还是字节流, 解决乱码问题, 可以用一行代码搞定:											         |
				|		response.setContentType("text/html;charset=xxx");通知浏览器使用utf-8打开服务器发送过去的数据                           |
				 ----------------------------------------------------------------------------------------------------------------
			 */
				
				
				//注意1:getOutputStream()和getWriter() 这两个方法是互斥的, 在一次请求当中调用了其中的一个, 就不能再调用另一个!!!
				// response.getWriter().write("aaa");
				// response.getOutputStream().write("aaa".getBytes());出现错误
				
				
				//注意2:在调用完getOutputStream()或getWriter()方法之后, 不需要手动去关闭流, 服务器会自动帮我们去关闭!!!
				
				
				//注意3:实际内容都写入了response对象的缓冲区，
				//		当应答逻辑serive执行结束，web容器会销毁response对象，销毁前会将缓冲区的内容都拿出来，由web容器将应答内容发给客户端浏览器
		
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/*
 * ----------------------2.Response实现重定向 (!!重点)  不带数据-----------------------------------
 			response.setStatus(302);
			response.setHeader("Location", "/Day09/index.jsp");
			这两行代码等价于
			response.sendRedirect("/Day09/index.jsp");
 
 
			重定向的原理就是302+location, 通过设置状态码302和location响应头就可以实现重定向的效果
			response.setStatus(302);
			response.setHeader("Location", "/Day09/index.jsp");
			这两行代码等价于
			response.sendRedirect("/Day09/index.jsp");
			
			重定向：两次请求,两次响应 request对象不是同一个
			第一次请求/响应：浏览器访问指定服务器，服务器发给浏览器302和location
			第二次请求/响应：浏览器收到302和location
							再去指定location访问资源。第二次请求和响应
			
 */
//浏览器输入localhost/day010JavaWebServlet/servlet/Response02
public class Response02 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		System.out.println("Response02收到请求");
		
		//A重定向
		//A1.设置应答状态码为302
		//response.setStatus(302);
		
		
		//A2.添加一个location应答头
		//response.setHeader("Location",request.getContextPath()+"/servlet/Response03");//request.getContextPath()获得当前web应用的虚拟目录名称
		//response.setHeader("Location","https://www.baidu.com");    //这里是访问web服务器之外的资源，上面是访问当前web服务器的资源
																	//后面的https://必须写全
																   //只写www.baidu.com 相对路径(相对于请求重定向文件的路径)  跳转http://localhost/day010JavaWebServlet/servlet/www.baidu.com
																  //只写 /www.baidu.com 绝对路径(绝对有限，相对于当前虚拟主机)跳转http://localhost/www.baidu.com
	     //B重定向
		response.sendRedirect("https://www.baidu.com");
	}
	

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

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 Response03 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.getWriter().write("response from Respon03 not Respon02");
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/*
  -----------3.Response实现定时刷新 (!掌握)-----------------------------------------
			定时刷新是通过Refresh响应头, 可以实现在多少秒之后跳转到另外一个资源
			response.setHeader("Refresh", "3;url=/Day09/index.jsp");
 */


//浏览器输入http://localhost/day010JavaWebServlet/servlet/Response04
public class Response04 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		
		// 解决应答乱码
		response.setContentType("text/html;charset=utf-8");
		//Response04给用户一个应答
		response.getWriter().write("请求成功，3秒后跳转...");
		
		//Response04实现定时刷新
		response.setHeader("refresh","3;url=https:\\www.baidu.com");
		
		
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;
import java.util.Date;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/*
 * ---------4.Response控制浏览器的缓存行为 (!掌握)-------------------------
      由于不同的浏览器的缓存行为可能是不同的, 我们可以在服务器中通过设置响应头来控制浏览器的缓存行为!!
	实际开发中这么写:
	控制不要缓存资源
					response.setHeader("pragma","no-cache");
					response.setHeader("cache-control","no-cache")
					//response.setDateHeader("Expires", -1);	实际开发中不怎么使用
	控制缓存一个资源特定的时长
					response.setDateHeader("Expires",System.currentTimemills()+时长ms)
					response.setHeader("cache-control","max-age=5")   /s
 
 	http1.0	
 			Pragma->控制不缓存
 			Expries->设置缓存时长
 	http1.1
 			Cache-control
 							no-cache  no-cache指的并不是不缓存，指的是不使用过期的缓存内容， 就是每次使用该资源时，都会向服务器验证当前资源是否过期
 							no-store
 							max-age   控制浏览器缓存特定的时长，以浏览器收到的时间为依据
 			
			 优先级 Pragma>cache-control>Expires
 */


public class Response05 extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
	
		//---------------通知浏览器不要缓存---------------------------------------------------
		response.setHeader("pragma", "no-cache");		//HTTP1.0   真的不缓存
		response.setHeader("cache-control", "no-cache");//HTTP1.1  no-cache指的并不是不缓存，指的是不使用过期的缓存内容
														//         就是每次使用该资源时，都会向服务器验证当前资源是否过期
		
		//实际开发中以上两者加起来使用，协议问题
		//response.setDateHeader("Expires", -1);	实际开发中这个不使用
//-------------------------------------------------------------------------------------------------------------------------------		
		
		//----------------控制浏览器缓存特定的时长-------------------------------------------
		//http1.0
		//使用EXpires设定缓存时长，可能因服务器时间和浏览器时间不同步造成问题
		//服务器2:30:00秒   2:30:05秒    ->浏览器2:32:00秒
		response.setDateHeader("Expires", System.currentTimeMillis()+1000*5);//5秒内刷新无效，使用缓存，5秒后刷新有效，存在服务器浏览器时间不同步问题
		
		//http1.1
		//控制浏览器缓存特定的时长
		response.setHeader("Cache-control", "max-age=5");  //max-age=5 相对时间，以浏览器收到的时间为依据，规避服务器和浏览器时间不同步问题
		
		response.getWriter().write(new Date().toLocaleString());
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

package JavaWebServlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;



/*
 * 请求转发/请求重定向/定时刷新都可以实现资源的跳转, 区别是什么呢? 
			
			请求转发: request.getRequestDispatcher("xxxxx").forward(request, response); 
				一次请求,一次响应 request对象是同一个
				地址栏不会发生变化
				只能用于服务器内部的资源跳转, 并且只能是同一应用中的不同资源上进行跳转, 不可用在不同应用和不同服务器中的资源跳转
				
			请求重定向:response.sendRedirect("/Day09/index.jsp");
				两次请求,两次响应 request对象不是同一个
				地址栏会发生变化
				可以用于服务器内部的资源跳转, 也可以用于不同应用和不同服务器之间的资源跳转
				
				重定向：两次请求,两次响应 request对象不是同一个
				第一次请求/响应：浏览器访问指定服务器，服务器发给浏览器302和location
				第二次请求/响应：浏览器收到302和location
								再去指定location访问资源。第二次请求和响应
				
			定时刷新:response.setHeader("refresh","3;url=https:\\www.baidu.com");
				两次请求,两次响应 request对象不是同一个
				地址栏会发生变化
				可以用于服务器内部的资源跳转, 也可以用于不同应用和不同服务器之间的资源跳转
				
				和重定向不同的是, 定时刷新可以在刷新到新的地址之间设置一个时间, 在间隔的这段时间内可以输出文本到浏览器并维系一段时间

				

			那什么时候用哪种方式进行资源的跳转呢?

	*********如果是同一服务器中的同一应用内部的资源跳转:
					~如果需要利用request域在跳转的资源之间传输数据, 只能用请求转发
					
					~如果不想让地址栏发生变化, 只能用请求转发
					~如果需要地址栏发生变化, 只能用重定向或定时刷新
					
					~如果没有什么特殊需求, 三种方式都可以, 但是推荐使用转发(一次请求一次响应), 可以减少请求次数降低服务器的压力.
					
					~如果只是想更新刷新操作, 最好使用重定向或定时刷新, 使用请求转发, 在刷新时会把刚才的操作再做一遍, 可能会导致一些问题, 比如表单重复提交或重复支付订单等
					
					
	********如果是不同服务器或不同应用内部的资源跳转, 只能用重定向或这定时刷新:
					重定向和定时刷新的主要区别在于: 重定向会立即跳转, 而定时刷新可以设置一个时间间隔, 在指定时间后再进行跳转. 
					如果在跳转之前需要输出提示信息(如: 注册成功, xx秒后跳转到xxx)只能用定时刷新, 否则两种方式都可以.
 */


//浏览器输入http://localhost/day010JavaWebServlet/servlet/ZhuanFa_ChongDingXiang_DingShiShuanXin
public class ZhuanFa_ChongDingXiang_DingShiShuanXin extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		System.out.println("收到请求，扣款1000元");
		//注意：如果只是想更新刷新操作, 最好使用重定向或定时刷新,
		//							           使用请求转发, 在刷新时会把刚才的操作再做一遍, 可能会导致一些问题, 比如表单重复提交或重复支付订单等。
		
		//请求转发，在刷新时会把刚才的操作再做一遍
		//request.getRequestDispatcher("/result.jsp").forward(request, response);//用户看到浏览器显示正在支付中，一直刷新界面，后台已经多次扣款成功
		//更新刷新操作, 最好使用重定向或定时刷新
		response.sendRedirect(request.getContextPath()+"/result.jsp"); //用户无论刷新多次，后台只扣款一次
		
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}