第一章 Servlet概述
动态网站特点：
交互性 自动更新 随机性
目前被广泛应用的三种动态网站技术：PHP ASP JSP
B/S架构
在动态网站技术中，一般使用浏览器作为客户端，客户在浏览器中发出请求，Web服务器得到请求后查找资源，然后向客户返回一个结果；
servlet特点：
高效 方便 功能强大 良好的移植性
servlet生命周期的3个方法：
init（）
service（）
destroy（）
Servlet生命周期阶段：
装载Servlet
创建Servlet
初始化
服务
销毁
request.setCharacterEncoding（“GBK”）；HttpServletRequest的getParameter(“参数名称”)获取表单、URL参数值
HttpServletResponse的getWriter()获取向客户端发送信息的输出流
HttpServletRequest的getHeader(“报头名称”)获取相关报头信息
Servlet处理请求数据
编写Servlet处理用户提交的表单数据
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class LoginServlet extends HttpServlet {
public LoginServlet() {
super();
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 将输入转换为中文
request.setCharacterEncoding("GBK");
// 设置输出为中文
response.setContentType("text/html;charset=GBK");
// 获取输出流
PrintWriter out = response.getWriter();
// 获取表单数据
String pass = request.getParameter("password");
String user = request.getParameter("loginName");
if ("admin".equals(user) && "123456".equals(pass)) {
out.println("登录成功!");
} else {
out.println("登录失败!");
}
}
}
设置响应报头，实现动态时钟
import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class DateServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException { // 获得一个向客户发送数据的输出流：
response.setContentType("text/html; charset=GBK");// 设置响应的MIME类型。
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<body>");
response.setHeader("Refresh", "1"); // 设置Refresh 的值。
out.println("现在时间是:");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
out.println("<br/>" + sdf.format(new Date()));
out.println("</body>");
out.println("</html>");
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}
}
重定向和请求转发是Servlet处理完数据后进行页面跳转的两种主要方式
请求转发是指将请求再转发到另一资源，此过程依然在同一个请求范围内，转发后浏览器地址内容不变
请求转发使用RequestDispatcher接口中的forward（）方法实现，该方法可以把请求转发到另外一个资源，并让该资源对浏览器的请求进行响应
RequestDispatcher rd =request.getRequestDispatcher(path);
rd.forward(request,response);重定向
重定向是指页面重新定位到某个新地址，之前得请求失效，且跳转后浏览器地址栏内容将变为新的指定地址
重定向是通过HttpServletResponse对象的sendRedirect()来实现
response.sendRedirect(request.getContextPath()+"/myservlet")
两者区别：转发和重定向都可以是浏览器获得另外一个URL所指向的资源，区别是转发共享同一个请求对象，而重定向不共享同一个请求对象
第二章 Servlet会话跟踪
会话跟踪技术：
Cookie技术
Session技术
URL重写技术
隐藏表单域
Cookie的安全机制
Cookie不会以任何方式在客户端被执行
浏览器会限制来自同一个网站的Cookie数目
单个Cookie的长度是有限制的
浏览器限制了最多可以接受的Cookie数目
Cookie的创建使用
Cookie userCookie =new Cookie("uName",username);
response.addCookie(userCookie);
Cookie[] cookies=request.getCookies();
使用Cookie保存用户名和密码，当用户再次登录时，在相应的文本显示上次登陆时输入的信息
public class LoginServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String cookieName = "userName";
String cookiePwd = "pwd";
// 获得所有cookie
Cookie[] cookies = request.getCookies();
String userName = "";
String pwd = "";
String isChecked = "";
// 如果cookie数组不为null，说明曾经设置过
// 也就是曾经登录过，那么取出上次登录的用户名，密码
if (cookies != null) {
// 如果曾经设置过cookie，checkbox状态应该是checked
isChecked = "checked";
for (int i = 0; i < cookies.length; i++) {
// 取出登录名
if (cookies[i].getName().equals(cookieName)) {
userName = cookies[i].getValue();
}
// 取出密码
if (cookies[i].getName().equals(cookiePwd)) {
pwd = cookies[i].getValue();
}
}
}
response.setContentType("text/html;charset=GBK");
PrintWriter out = response.getWriter();
out.println("<HTML>\n");
out.println("<HEAD><TITLE>登录</TITLE></HEAD>\n");
out.println("<BODY>\n");
out.println("<CENTER>\n");
out.println(" <FORM ACTION='CookieTest'" + " METHOD='POST'>\n");
out.println("姓名：<INPUT TYPE='TEXT'" + " NAME='UserName' VALUE='"
+ userName + "'><BR>\n");
out.println("密码：<INPUT TYPE='PASSWORD' NAME='Pwd' VALUE='" + pwd
+ "'><BR>\n");
out.println("保存用户名和密码<INPUT TYPE='CHECKBOX'"
+ "NAME='SaveCookie' VALUE='Yes' " + isChecked + ">\n");
out.println(" <BR>\n");
out.println(" <INPUT TYPE=\"SUBMIT\">\n");
out.println(" </FORM>\n");
out.println("</CENTER>\n");
out.println("</BODY>\n");
out.println("</HTML>\n");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
public class CookieTest extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie userCookie = new Cookie("userName", request
.getParameter("UserName"));
Cookie pwdCookie = new Cookie("pwd", request.getParameter("Pwd"));
if (request.getParameter("SaveCookie") != null
&& request.getParameter("SaveCookie").equals("Yes")) {
userCookie.setMaxAge(7 * 24 * 60 * 60);
pwdCookie.setMaxAge(7 * 24 * 60 * 60);
} else {
//删除Cookie
userCookie.setMaxAge(0);
pwdCookie.setMaxAge(0);
}
response.addCookie(userCookie);
response.addCookie(pwdCookie);
PrintWriter out = response.getWriter();
out.println("Welcome," + request.getParameter("UserName"));
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
session的创建
HttpSessionsession=request.getSession();
或
HttpSessionsession=request.getSession(true);session的生命周期
1、客户端向服务器第一次发送请求的时候，request中并无SessionID。
2、此时服务器会创建一个Session对象，并分配一个SessionID。Serssion对象保存在服务器端，此时为新建状态，调用session.isNew()返回true。
3、当服务器端处理完毕后，会将SessionID通过response对象传回到客户端，浏览器负责保存到当前进程中。
4、当客户端再次发送请求时，会同时将SessionID发送给服务器。
5、服务器根据传递过来的SessionID将这次请求（request）与保存在服务器端的Session对象联系起来。此时Session已不处于新建状态，调用session.isNew()返回false。
6、循环执行过程3-5，直到Session超时或销毁。
session的使用
session.setAttribute("uName",username);
String username=(String)session.getAttribute("uName");
session.invalidate();Session演示用户在初始化页面输入一个值，单击提交按钮进入第一个Servlet。第一个servlet将输入的值分别保存到request和session，在第二个servlet从request和session对象中提取信息并显示
public class FirstServlet extends HttpServlet {
public FirstServlet() {
super();
}
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
//设置请求的编码字符为GBK
request.setCharacterEncoding("GBK");
//设置响应的文本类型为html,编码字符为GBK
response.setContentType("text/html; charset=GBK");
PrintWriter out = response.getWriter();
//获取表单数据
String str = request.getParameter("count");
request.setAttribute("request_param", str);
HttpSession session = request.getSession();
session.setAttribute("session_param", str);
//out.println("<a href='s2'>下一页</a>");
out.println("<a href="+response.encodeURL("s2")+">下一页</a>");
}
}
//获取表单数据
String str = request.getParameter("count");
request.setAttribute("request_param", str);
HttpSession session = request.getSession();
session.setAttribute("session_param", str);
public class SecondeServlet extends HttpServlet {
public SecondeServlet() {
super();
}
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
Object obj = request.getAttribute("request_param");
String request_param = null;
if (obj != null) {
request_param = obj.toString();
} else {
request_param = "null";
}
HttpSession session = request.getSession();
Object obj2 = session.getAttribute("session_param");
String session_param = null;
if (obj2 != null) {
session_param = obj2.toString();
} else {
session_param = "null";
}
response.setContentType("text/html; charset=GBK");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<body >");
out.println("<h2>请求对象中的参数是 :" + request_param + "</h2>");
out.println("<h2>Session对象中的参数是 :" + session_param
+ "</h2></body></html>");
}
}
ServletContext接口
// 获得ServletContext对象
ServletContext ctx = this.getServletContext();
// 获得web.xml中设置的初始化参数
String serverName = ctx.getInitParameter("serverName");
String dbInstance = ctx.getInitParameter("dbInstance");
String userName = ctx.getInitParameter("userName");
String password = ctx.getInitParameter("userPwd");
ServletContext的生命周期
1.新Servlet容器启动的时候，服务器端会创建一个ServletContext对象；
2.在容器运行期间ServletContext对象一直存在；
3.当容器停止时，ServletContext的生命周期结束。
ServletConfig接口
ServletConfig sc = getServletConfig();
name = sc.getInitParameter("userName ");HttpSession、 ServletContext使用getAttribute()和setAttribute()方法读写数据
关闭浏览器、调用Session的invalidate()方法或者等待Session超时都可以使Session失效
第三章 JSP基础
JSP与Servlet的比较如下：
JSP是一种服务器端脚本语言，它降低了Servlet的使用难度。JSP在本质上就是Servlet 。
JSP提供了Servlet能够实现的所有功能，实际上JSP是首先被翻译成Servlet后才编译并运行的，所以JSP几乎拥有Servlet的所有优点。
与Servlet相比，JSP更加适合制作动态页面，因为单纯使用Servlet开发动态页面是相当繁琐的。
JSP特点
简单快捷
动态内容的生成和显示相分离
组件重用
易于部署、升级和维护
JSP执行原理
客户端发出请求
容器接受请求后，检索对应的JSP页面，如果JSP页面第一次被请求，则容器将其翻译成一个Java文件，即Servlet
容器将翻译后的Servlet源代码编译形成字节码，即.class文件，并加载到内存执行
最后把执行结果发送回客户端
JSP文件基本元素组成
JSP指令
JSP声明
JSP表达式
JSP脚本
JSP动作
JSP注释
ØJSP的执行过程需要经过翻译、编译、执行三个步骤
ØJSP指令用来向JSP容器提供编译信息
ØJSP声明用于在JSP中定义变量和方法
ØJSP表达式用于将Java表达式的运行结果输出在页面中
ØJSP脚本用于在JSP页面中插入Java代码
ØJSP提供了很多动作标签实现特定的功能
JSP输出100以内的质数
<%
int m,i,j;
boolean f;
for(i=2;i<=100;i++) {
f=true;
m=(int)Math.sqrt(i);
for(j=2;j<=m;j++)
if(i%j==0) {
f=false;break;
} }
if (f)
out.print(i+" ");
%>第四章 JSP指令和动作
page指令 import session errorpage buffer autoFlush
include指令
taglib指令
JavaBean
可重用
升级方便
不依赖于平台
非可视化的JavaBean可分为
业务Bean
数据Bean
JavaBean实际上就是一种满足特定要求的Java类：
是一个公有类，含有公有的无参构造方法；
属性私有；
属性具有公有的get和set方法。
<jsp:useBean>
<jsp:useBean id="name" class="className" scope="scope" />
或
<jsp:useBean id="name" type="className" scope="scope" />
<jsp:setProperty>
<jsp:setProperty name="id" property="属性名" value="值"/>
或
<jsp:setProperty name="id" property="属性名" param="参数名"/>
<jsp:getProperty>
<jsp:getProperty name="user" propery="name"/>
使用useBean标准动作创建该类的对象，并使setProperty标准动作将登陆表单中的信息保存到该对象中，同时使用getProperty动作显示信息
<%@ page language="java" contentType="text/html; charset=GBK"%>
<html>
<head>
<title>用户登录</title>
</head>
<body>
<form method="POST" name="f1" action="showbean.jsp">
<p align="left">用户名:<input type="text" name="loginName" size="20"></p>
<p align="left">密 码:<input type="password" name="password"
size="20"></p>
<p align="left"><input type="submit" value="提交"> <input
type="reset" value="重置"></p>
</form>
</body>
</html><%@ page language="java" contentType="text/html; charset=GBK"%>
<html>
<head>
<title>JSP动作</title>
</head>
<body>
<jsp:useBean id="user" class="com.dh.ch04.model.UserBean" scope="request"/>
<jsp:setProperty property="name" name="user" param="loginName"/>
<jsp:setProperty property="pwd" name="user" param="password"/>
用户名：<jsp:getProperty property="name" name="user"/><br/>
密码：<jsp:getProperty property="pwd" name="user"/>
</body>
</html><jsp:include>
<jsp:include page="被包含文件的URL"%>
<jsp:forward>和<jsp:param>
<jsp:forward page="URL地址"/>
<jsp:param name="参数名" value="值"/>
JavaBean需要满足公有类、公有无参构造方法、私有属性、属性对应的get/set方法几个要求
useBean标准动作用来查找或者实例化一个JavaBean
setProperty标准动作用于设置JavaBean中的属性值
getProperty动作用于访问一个bean的属性并将其输出
include标准动作用于在JSP页面动态包含其他页面
forward标准动作用于将请求转发到另一个资源
param标准动作用于为其他动作标签提供附加参数信息，该动作可以与<jsp:include>、<jsp:forward>等一起使用
include指令和include标准动作的区别
在servlet中，可以include另外一个资源，其一是静态Include另一种是动态Include
静态Include是JSP指令标记
<%@include file="head.htm"%>其中file可以是HTML文件、Servlet文件或者另外一个JSP文件
动态Include
<jsp:include page="bottom.html"%>include 标准动作用于JSP页面，动态包含其他页面，该动态的功能和JSP的include指令类似
区别在于include指令是在编译时完成包含，是静态包含，而include标准动作是在运行时完成包含，是动态包含
第五章 JSP内置对象
out
常用方法有print()、println()和write()
void clear()：清除缓冲区的内容，如果缓冲区已经被刷出（flush），将抛出IOException ；
void clearBuffer()：清除缓冲区的当前内容，和clear()方法不同，即使缓冲区已经flush，也不会发生异常；
void flush()：输出缓冲区中的内容；
void close()：关闭输出流，清除所有内容。
request
信息显示页面
<%@ page language="java" contentType="text/html; charset=GBK"%>
<html>
<head>
<title>信息显示</title>
</head>
<body>
<%
request.setCharacterEncoding("GBK");
String name = request.getParameter("name");
String sex = request.getParameter("sex");
String xueli = request.getParameter("xueli");
String[] channels = request.getParameterValues("channel");
%>
您输入的注册信息
<br />
<%
out.print("姓名：" + name + "<br/>");
out.print("性别：" + sex + "<br/>");
out.print("学历：" + xueli + "<br/>");
if (channels != null) {
out.print("渠道：");
for (int i = 0; i < channels.length; i++) {
out.print(channels[i] + " ");
}
}
%>
</body>
</html>String getParameter(String name)：根据参数名称得到单一参数值；
String[] getParameterValues(String name)：根据参数名称得到一组参数值；
void setAttribute(String name, Object value)：以名/值的方式存储数据；
Object getAttribute(String name)：根据名称得到存储的数据。
response
void setContentType(String name)：设置响应内容的类型和字符编码；
void sendRedirect(String url)：重定向到指定的URL资源。
<%
response.setContentType("text/html;charset=GBK");
response.sendRedirect("response2.jsp");
%>
session
void setAttribute(String name, Object value)：以名/值的方式存储数据；
Object getAttribute(String name)：根据名称得到存储的数据。
session.setAttribute("name", "haier");
String name = (String)session.getAttribute("name");
application
void setAttribute(String name, Object value)：以名/值的方式存储数据；
Object getAttribute(String name)：根据名称得到存储的数据。
application.setAttribute("number", 1);
Integer i = (Integer) application.getAttribute("number");
page
<%@ page language="java" contentType="text/html; charset=GBK"
info="测试page对象"%>
<html>
<body>
<%=((HttpJspPage)page).getServletInfo()%>
</body>
</html>pageContext
void setAttribute(String name, Object value)：以名/值方式存储数据
Object getAttribute(String name)：根据名称得到存储的数据
void setAttribute(String name, Object value)：以名/值方式存储数据
Object getAttribute(String name)：根据名称得到存储的数据
pageContext、Session和Application的区别如下：
pageContext访问范围是当前JSP页面，所以计数始终为1；
session访问范围是当前会话，所以当刷新页面时，计数不断变化，但新打开一个窗口时，会新建一个会话，所以计数又从1开始；
application访问范围是整个应用程序，所以计数不断变化。
config
exception
JSP中有9个内置对象，无须定义，可以直接使用
out对象是一个输出流，用于将信息输出到网页中
request对象封装了当前请求信息，可以存取数据
response对象封装了当前响应信息
session对象表示当前会话，可以存取数据
application对象表示整个应用程序，可以存取数据
pageContext对象表示当前JSP页面，可以存取数据
JSP的4种作用范围分别使用pageContext、request、session、application来表示，它们都具有getAttribute()和setAttribute()方法
在servlet的doGet()和doPost()方法，如何得到JSP内置对象 out request response session application 分别对应的对象？
out :PrintWriter out = response.getWriter();
Servlet:可直接使用
session:HttpSession session=request.getSession();
application:ServletConfig.getServletContext();
ServletContext application =this.getServletContext();
第六章 EL和JSTL
可访问JSP的内置对象
简化了JavaBean的访问方式
简化了对集合的访问方式
可以通过关系、逻辑和算数运算符进行运算
条件输出
EL使用
<jsp:useBean id="person" class="com.haiersoft.entity.Person"
scope="request" />
<jsp:setProperty name="person" property="name" value="zhangsan" />
<jsp:setProperty name="person" property="age" value="25" />
姓名：${person.name}
<br />
年龄：${person.age}
JSTL优点
针对JSP开发中频繁使用的功能提供了简单易用的标签，从而简化了jsp开发
作为JSP规范，以统一的方式减少了JSP中的Java代码数量，力图提供一个无脚本环境，
在应用程序服务器之间提供了一致的接口，最大程度地提高了web应用在各应用服务器之间的可移植性
在JSP页面中使用标签库，需要使用taglib指令导入，格式如下：
<%@taglib uri="标签库uri路径" prefix="前缀名"%>
核心标签库（通用标签 条件标签 迭代标签 URL标签）
国际化输出标签库（I18N标签库）
XML标签库
SQL标签库
EL函数库
通用标签：
<c:out>
<c:set>
<c:remove>
<c:catch>
条件标签：
<c:if>
<c:choose>
<c:when>
<c:otherwise>
迭代标签
<c:forEach>
<c:forTokens>
URL标签
<c:import>
<c:redirect>
<c:url>
18N标签有：
<fmt:setLocale>、<fmt:bundle>、
<fmt:setBundle>、<fmt:message>、
<fmt:formatNumber>、<fmt:formatDate>
EL函数主要提供了对字符串处理的功能，此外还可以利用EL函数获取集合的大小
第七章：监听和过滤
监听器（Listener）可以监听客户端的请求、服务器端的操作。监听器可以在事件发生时自动执行操作。
上下文监听器执行流程
1.Web应用启动的时候，contextInitialized()方法进行初始化；
2.如果在Application范围内添加一个属性，将会触发ServletContextAttributeEvent事件，通过AttributeAdded()方法进行处理；
3.如果在Application的范围内修改属性值，将会触发ServletContextAttributeEvent事件，通过AttributeReplaced()方法进行处理；
4.如果在Application的范围内删除一个属性，将会触发ServletContextAttributeEvent事件，通过AttributeRemoved()方法进行处理；
5.Web应用关闭时，contextDestroyed()方法进行卸载。
过滤器：
实现过滤器的步骤如下：
1.创建一个实现Filter接口的类，并且实现接口中的init()、doFilter()和destroy()三个方法；
2.在doFilter()方法中编写过滤的任务代码；
3.调用FilterChain参数的doFilter()方法；
4.在web.xml注册这个Filter，以及其将过滤的页面。
Servlet上下文监听接口有ServletContextListener和 ServletContextAttributesListener。
Session会话的监听接口有：HttpSessionListener、 HttpSessionActivationListener、HttpSessionBindingListener和 HttpSessionAttributeListener。
请求对象的监听接口有ServletRequestListener和 ServletRequestAttributeListener。
过滤器类必须实现Filter接口。
doFilter()方法是Filter类的核心方法。
FilterChain（过滤器链）表示资源请求调用时过滤器的链表
第八章 Ajax基础
AJAX（Asynchronous JavaScript And XML，异步JavaScript和XML）是一种运用JavaScript和XML在浏览器和服务器之间传输数据的技术
AJAX的优点如下
异步请求
局部刷新
减轻服务器压力
增强用户体验
AJAX并不是一项全新的技术，而是整合了几种现有的技术
JavaScript
XML
CSS
DOM
XMLHttpRequest对象的运行周期经过以下几个过程 ：
1.创建
2.初始化请求
3.发送请求
4.接收数据
5.解析数据
6.完成
AJAX是异步、无刷新的网站技术
AJAX主要包括JavaScript、CSS、DOM、XML和XMLHttpRequest
XMLHttpRequest对象可以进行异步数据读取
使用XMLHttpRequest对象的属性、方法进行编程实现动态无刷新效果
使用AJAX技术时，通常使用XML或JSON格式来封装结构化的数据
request方法：
Request
1>获取请求的基本信息
1>获取请求的url和uri
2>获取url后面的请求参数部分的字符串
3>获取请求方式
4>获取主机名,IP地址
5>获取 Contexpath
String url = request.getRequestURL().toString();
System.out.println(url);
String uri = request.getRequestURI().toString();
System.out.println(uri);
String params = request.getQueryString();
System.out.println(params);
String method = request.getMethod();
System.out.println(method);
String addr = request.getRemoteHost() + request.getRemotePort() + request.getRemoteAddr() +
"==user=" + request.getRemoteUser();
System.out.println("addr: " + addr);
String contextPath = request.getContextPath();
response.sendRedirect(contextPath + "/index.jsp");2.获取请求参数
Map<String, String[]> params = request.getParameterMap();
for (String name : params.keySet()) {
String value = request.getParameter(name);
System.out.println("name=" + name + ", value=" + value);
}解决请求乱码问题:
request.setCharacterEncoding("Utf-8");
如果上面的代码只能解决POST的乱码问题, 则可以自行进行解码操作
String userName = request.getParameter("username");
userName = new String(userName.getBytes("ISO8859-1"), "UTF-8");前段使用 UTF-8 进行编码, 传输到服务器, 服务器可以使用 ISO8859-1 解码得到UTF-8编码后的码值, 然后通过new String(bytes, charset)的方式进行解码.
3.设置和获取域属性
Object attr = request.getAttribute("attr");
request.setAttribute("key", "value");
request.removeAttribute("attr");
Enumeration<String> attributeNames = request.getAttributeNames();一般我们的应用是servlet处理数据, 将处理好的数据放到request域中,然后带到jsp页面上进行展示操作.
请求转发与请求包含
请求转发:
request.getRequestDispatcher("/DispatcherTest2").forward(request, response);
或
this.getServletContext().getRequestDispatcher("/DispatcherTest2").forward(request, response);
Response
response.getOutputStream().write("中国".getBytes("utf-8"));
response.getWriter().write("北京");
response.setCharacterEncoding("utf-8");
response.setHeader("Content-Type", "text/html;charset=utf-8");
response.setContentType("text/html;charset=utf-8");
1.Servlet实现
response.setContentType("text/html;charset=utf-8");
response.getWriter().write("恭喜您注册成功, 3秒后回到主页");
response.setHeader("Refresh", "3;url=OutServlet");
2.html实现
<meta charset="UTF-8">
<meta http-equiv="Refresh" content="3; url=index.jsp" >
<title>Insert title here</title>
</head>
<body>
恭喜您注册成功, 3秒后回到主页....
</body>5)控制浏览器是否缓存
response.setIntHeader("Expires", -1);
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Pragma", "no-cache");
response.getWriter().write(new Date().toLocaleString());6)实现请求重定向
response.sendRedirect(this.getServletContext().getContextPath());
扫一扫
713
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
