Jsp/Servlet复习笔记-----第6章 JSP基础

depravedangel

浏览: 466479 次
性别:
来自: 南京

最近访客更多访客>>

wyx065747

Allanallan

defineconst

zzy_001

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

前后台代码衔接研究

JSP Servlet 嵌入式 Web 应用服务器

6.1 JSP 简介
6.1.1 JSP的需求和优点

生成内容与表示相分离：
虽然JSP的实质是Servlet,但与Servlet相比，内容生成与表示相分离是JSP的一个优点，这是Servlet无法解决的。
Servlet用out.println()一句一句地输出，比如下面的一段简单程序

Out.println(“html”);…………………

当整个网页内容非常多且复杂的时候，就会有很多out.println()输出HTML标记。这样写起程序来会很烦和容易出错。JSP则很好地解决了这个问题，JSP将内容的动态生成与静态表示很好地分离了开来。例如，在JSP代码中，HTML标记都由静态内容来表示，而不用Java代码去输出，这样就将HTML标记和Java程序动态输出的内容分开了。这样就可以有利于美工去美化网页，而不必去关注Java代码，也有助于Java 编程人员不必关注于网页的美化，而只关注于自己的Java代码。
强调可重用组件：
可重用组件是一个程序，它可以为多个子程序（如JavaBean）使用。Web程序员可以共享和交换JavaBean。JavaBean使得可以在JSP页面中执行复杂的功能。例如,JavaBean Calender可以用于显示当前日期和时间。Web应用程序的所有网页都可以使用此JavaBean Calender。基于此组件的方法有助于重用现有程序和加速开发过程。
JSP还在JSP文件中使用其他JSP或HTML文件，这些文件被视为远程资源。JSP提供include指令，通过该指令可以在JSP页面中插入远程资源的内容。Include指令将文件内容替换。
简化页面开发：
JSP使得对脚本怨言不是很了解的Web开发人员也可以设计页面。例如，jsp:useBean标签用于指定在JSP页面中使用的JavaBean。程序员可以使用JSP提供的标准标签来生成动态内容。
JSP提供的标准标签分别如下：
— 访问和实例化JavaBean组件
— 设置或检索Bean属性
— 下载Applet
— 执行其他功能，如检索服务器上的表中难于编码且耗时的行
如果JSP中的现有标准标签不能用于执行所需的功能，则程序员可以创建标签，这些标签称为自定义标签。使用JSP的taglib指令可以创建自定义标签。
JSP允许使用开发工具，如Macromedia Dreamweaver 和 Eclipse。使用这些工具可以简化和加速Web开发过程。
6.1.2 对JSP的误解
6.1.3 JSP的基本语法JSP页面里有什么元素呢？基本的JSP页面包含HTML标签和JSP标签。

<%@ page import="java.util.*"%> 
<%@ page contentType%> 
<%@ page import="java.io.*,java.sql.*"%> 
<html><head><title>JSP</title></head><body> 
<!-- HTML注释，此注释内容会发送到客户端 --> 
  <%!                                            <% 
         // 全局变量、类、方法                      // 可以使用JAVA的单行注释 
        // 不加！表示局部变量                       /* 
        int i = 0 ;                                              多行注释 
   %>                                                       */ 
  <%=++i%>                                 %> 
<%=new Date()%> 
<%--  JSP中使用的注释 
接收传递过来的参数，并进行打印输出 
使用如下方法： 
  request.getParameter("参数名称") ; 
  此方法返回String类型 
  getParameter方法定义： 
  public String getParameter("参数") ; 
--%> 
<% 
// 接收参数 
String name = request.getParameter("uname") ; 
%> 
<h1><%=name%></h1> 
<h1><%=request.getParameter("uname")%></h1> 
</body></html>

<%@page contentType="text/html; charset=GBK" 
language="java" import="java.util.Calendar"%>
<%!
String getHello(String name) {
return "Hi," + name + "!";
}
%>
<%Calendar now = Calendar.getInstance();%>
<html>
<head>
<title>JSP 页面构成</title>
</head>
<body>
<h1 align="center">JSP页面构成</h1>

<%=getHello("朋友")%><%if (now.get(Calendar.AM_PM) == Calendar.AM) {%>
早上好!
<%} else {%>
下午好!
<%}%>
<br>
<br>
<jsp:include flush="false" page="welcome.jsp">
<jsp:param name="str" value="参数"/>
</jsp:include>
</body>
</html>

如果把它们细分，JSP页面由以下元素构成：
— 静态内容
— 指令
— 表达式
— Scriptlet
— 声明
— 动作
— 注释

静态内容

属于静态的内容有：

<title>JSP 页面构成</title>
</head>
<body>
<h1 align="center">JSP页面构成</h1>

这些静态内容是JSP页面中的静态文本，它基本上是HTML文本，与Java和JSP语法无关。
指令
JSP指令有很多，JSP指令一般以”<%@ “开始，以“%>”结束。

<%@page contentType="text/html; charset=GBK" 
language="java" import="java.util.Calendar"%>

表达式
JSP表达式以“<%=“开始，以”%>”结束。

<%=getHello("朋友")%>

Scriptlet
Scriptlet是嵌在页面里的一段Java代码，以“<%“开始，以”%>“结束，中间是Java代码，所以也有人称Scriptlet为代码片段。

<%if (now.get(Calendar.AM_PM) == Calendar.AM) {%>
<%} else {%>
<%}%>

声明
JSP声明用于定义JSP页面中的变量和方法。它以“<%!”开始，以“%>“结束。

<%!
String getHello(String name) {
return "Hi," + name + "!";
}
%>

动作
JSP动作允许在页面间转移控制权。JSP动作也有很多，它基本上是以“<jsp:动作名>“开始，以“</jsp:动作名>“结束。

<jsp:include flush="false" page="welcome.jsp">
<jsp:param name="str" value="参数"/>
</jsp:include>

注释
注释的格式有两种：

这种注释以““结束，中间是注释的内容，它可以在客户端通过查看源代码看到它。
<%-- 这也是注释,但客户端不能查看到 --%>
这种注释以“<%--“开始，以”--%>“结束，中间是注释的内容，在客户端查看源代码时将看不到它。

6.1.4 JSP的执行过程
JSP页面的执行过程如图所示：

（1）客户端发出请求
（2）Web容器将JSP转译成Servlet的源代码
（3）Web容器将产生的源代码经过编译
（4）Web容器加载编译后的代码并执行
（5）把执行结果响应至客户端
可以看出JSP的实质就是一个Servlet。在转换和编译JSP页面之后，会创建一个Servlet。此时开始Servlet的生命周期。在Servlet的生命周期中，JSP引擎（Web容器）会加载和创建Servlet类的实例。调用jpsInit方法以初始化Servlet类。JSP引擎调用jspService方法，并将请求和响应对象传递给jspService方法。
6.1.5在MyEclipse中开发JSP 应用程序

6.2 JSP 脚本和指令的使用
6.2.1 简介
上一小节提到JSP页面的构成元素有：静态内容、 JSP指令、表达式、Scriptlet、声明、JSP动作和注释。但仅仅是提到了它们在JSP页面中是以何种形式表现的，没有讲述如何使用它们。本节将讲述其中的JSP指令和脚本元素的使用（由于都是在一定的格式里嵌入Java代码，因而经常把“表达式、Scriplet、声明”都称为脚本元素），这是非常基础和重要的内容，学会了，将会对学会JSP编程打下坚实的基础。

6.2.2 JSP 脚本元素
使用JSP脚本元素可将Java代码嵌入JSP页面里，使JSP将静态内容与动态内容分离开来（静态内容指刷新网页后绝对不会发生变化的内容，动态内容指刷新网页后可能会发生变化的内容）。
JSP脚本元素用于生成动态内容。JSP页面由3个脚本元素组成，既表达式、Scriptlet和声明。这些脚本元素如图所示。

表达式
表达式是对数据的表示，系统将其作为一个值进行计算和显示。例如在数学中，（5+2）或（5x2）+ (8-5)都是表达式。
JSP采用了类似的概念，使用JSP表达式将数据输出到HTML页面。JSP表达式的基本语法如下：
<%= Java表达式 %>
提示：JSP表达式后面不能加分号。
下面来看一个例子，利用JSP表达式输出一些内容到JSP页面上

<%@page contentType="text/html;charset=gb2312"%>
<html>
<head>
<title>JSP表达式</title>
</head>
<body>
<h1>JSP表达式</h1>
<b>PI的值：</b>
<%=Math.PI %><br/>
<b>100,99中最大的值 :</b>
<%=Math.max(100,99) %><br/>
<b>100,99中最小的值 :</b>
<%=Math.min(100,99) %><br/>
<b>3+2-5的值 :</b>
<%=3+2-5 %><br/>
<b>(3+2)==5的值 :</b>
<%=(3+2)==5 %><br/>
<b>(3+2)!=5的值 :</b>
<%=(3+2)!=5 %><br/>
</body>
</html>

Scriptlet
JSP Scriptlet就是在“<%...%>”里嵌入Java代码。它在形式上与表达式的区别就是在“<%...%>”里没有“=”，而且中间是一段Java代码，不是表达式，每条Java语句要以分号结尾。
JSP Scriptlet的基本语法如下：
<% Java代码 %>
下面举一个例子来看看怎么使用JSP Scriptlet,如示例所示，其中使用Scriptlet以直角三角形的形式显示1-9之间的数字。

<html>
<head>
<title>以直角三角形的形式显示数字</title>
</head>
<body>
<h1>以直角三角形的形式显示数字</h1>
<%
for(int i=1;i<10;i++)
{
for(int j=1;j<=i;j++)
{
out.println(j);
}
out.println("<br/>");
}
%>
</body>
</html>

提示：out.print()和out.println()可用来在JSP页面中输出数据，out是JSP的内置对象。将在下节中讲述。现在知道怎么用即可。out.println("<br/>")，输出一个HTML标记“<br/>”来达到换行的效果。
JAVA与HTML代码分离：

<html>
<head>
	<title>JSP</title>
</head>
<body>
<%
	// 打印9×9的表格
	out.println("<table border=\"1\">") ;
	for(int i=0;i<9;i++)
	{
		out.println("<tr>") ;
		for(int j=0;j<9;j++)
		{
			out.println("<td>"+i*j+"</td>") ;
		}
		out.println("</tr>") ;
	}
	out.println("</table>") ;
%>
</body>
</html>
---------------------------------------------------------------------------------
html><head><title>JSP</title></head><body>                    <html><head><title>JSP</title></head>
<%                                                                                     <body>
// 接收参数                                                                         <!-- HTML与服务器交互的主要途径是表单 -->
     String t_row = request.getParameter("rownum") ;                     输入表格的行数与列数，进行表格打印操作
     String t_col = request.getParameter("colnum") ;                <form action="printTable03.jsp" method="get">
                                                                                            行数：<input type="text" name="rownum"><br>
// 将字符串变为整数                                                              列数：<input type="text" name="colnum"><br>
     int row = 0 ;                                                                          <input type="submit" value="打印">
     int col = 0 ;                                                                           </form></body></html>
     try {
          row = Integer.parseInt(t_row) ;
          col = Integer.parseInt(t_col) ;
     } catch(Exception e) {
%>
            Input Error!!!
<% } %>
<table border="1">
<%
       // 打印9×9的表格
      for(int i=0;i<row;i++)  {
%>
         <tr>
<%
                for(int j=0;j<col;j++)  {
%>
                           <td><%=i*j%></td>
<%           }     %>
       </tr>
<%  }   %>
</table></body></html>

声明
JSP声明允许用户定义插入Servlet中的变量、方法等。使用JSP声明并结合Scriptlet与表达式可以显示输出结果。一个声明标签可用于定义多个变量或方法。
JSP声明的基本语法如下：
<%! Java 变量，方法等 %>
下面举一个例子来看看怎么使用JSP声明，如示例所示。

6.2.3 JSP 指令
上面学习了JSP页面的脚本元素：表达式、Scriptlet和声明。下面接着学习JSP页面元素中的JSP指令。
JSP指令控制对整个页面的处理。指令可以确定要导入的包以及要实现的接口，可以引入其他的文件，可以使用JSP标签等。
JSP目前的指令有3种，即page、include和taglib，如图所示：

JSP指令语法如下：
<%@ 指令名属性1="属性值1" 属性2="属性值2"...属性 n="属性值n"%>
page指令
page指令位于JSP页面的开头部分。顾名思义，paga指令主要用于设置页面的各种属性。例如，可以指定编写JSP页面所使用的语言，以及要导入的包等。
JSP页面可以包含任意数量的page指令，page指令一般置于页面的顶部。
page指令的语法如下：
<%@ page属性1="属性值1" 属性2="属性值2"...属性 n="属性值n" %>
page指令基本的属性如下：
<%@ page contentType="text/html;charset=gb2312"%>，处理中文乱码
—language：定义编写Scriptlet、声明和表达式所使用的脚本语言。默认情况下将使用Java语言。
language属性的语法如下：
<%@ page language="语言种类"%>
例如，<%@ page language="java"%>,表示的是页面所使用的语言为Java。
—import：将需要的包或类引入到JSP页面中。默认情况下，如果未指定包，则将导入java.lang.*、javax.servlet.*和javax.servlet.jsp.*包。
import属性的语法如下：
<%@ page import="包或类的路径"%>
例如，<%@ page import="java.util.*"%>，表示此JSP页面引入了java.util包。
— buffer：以千字节为单位指定缓冲区的大小。缓冲区用于存储客户端请求，其默认值为8KB。
buffer属性的语法如下：
<%@ page buffer="size in kb"%>
例如，<%@ page buffer="10kb"%>，表示此JSP页面的缓冲区大小为10KB。
—errorPage：设置该JSP页面的错误处理页面URL，处理当前页面中引发但未捕获到的异常。
errorPage属性的语法如下：
<%@ page errorPage="错误处理页面的URL"%>
例如，<%@ page errorPage="/error.jsp"%>，表示此JSP页面的错误处理页面是根目录下的error.jsp。
— isErrorPage：表示该页面是否为错误处理页面。
isErrorPage属性的语法如下：
<%@ page isErrorPage="true|false"%>
例如，<%@ page isErrorPage="true"%>，表示此JSP页面是一个错误处理的页面，可以对一些错误或异常做处理。
这里用一个代码片段来看看page指令的用法：

include指令
include指令用于在运行时将HTML文件或JSP页面嵌入到另一个JSP页面。
include指令的语法如下：
<%@ include file="文件名"%>
例如，<%@ include file="head.jsp"%>，表示此JSP页面将把head.jsp的内容嵌入进来。
include指令只支持file属性，该属性指定要在编译时嵌入的文件的名称。页面的名称应当在编译是已知，文件的内容将嵌入include指令所在的JSP页面。其用法参见代码片段：

<html>
<head>
<title>Include指令测试页面</title>
</head>
<body>
<%@  include  file="/test.html"%>
</body>
</html>

代码片段中的include指令将根目录下的test.html文件嵌入到了该JSP页面。
嵌入一个页面，往往是为了重用这个页面，而不必在每个页面上写一些相同的代码。例如，在很多JSP页面中都要在页面顶部显示同样的图片，这时就不必每个页面都去包含这些图片，而是单独写一个文件来完成此项任务，然后在其他JSP页面中include这个文件即可。
示例就演示了这个过程，先用head.jsp里把要引入的图片引入到页面，然后再在example.jsp页面中把head.jsp嵌入进去。

<html>
<head>
<title></title>
</head>

<body>
<table width="760" border="0" align="center" cellpadding="0" cellspacing="0">
  <tr>
    <td width="224" align="right"><img alt="" src="image/head1.gif" width="203" height="96"/></td>
    <td width="536" align="left"><img alt=""  src="image/head2.jpg" width="555" height="96"/></td>
  </tr>
</table>
</body>
</html>

<%@page language="java"%>
<%@include file="head.jsp"%>
<html>
<head>
<title></title>
</head>
<body>
<br>
<br>
<h4 align="center">你好，欢迎来到The sky of darkness！</h4>
</body>
</html>

<%@ include file = “”%>：可以包含任意文件：
*.txt *.jsp *.sky
包含的是文件的内容
注意：include语句可以包含任何内容，但是在有一个JSP页面中，只能有一组<html>、<head>、<body>
原则：在开发中被包含的文件，只写显示部分的HTML代码，主体代码不要出现。
包含的时候不区分文件名称后缀，只是将内容包含进来

<%-- 使用此语句处理显示中的乱码 --%>
<%@page contentType="text/html;charset=gb2312"%>
<html>
<head>
	<title>include demo</title>
</head>
<body>
<%@include file="incl.jsp"%>
<%@include file="incl.txt"%>
<%@include file="incl. sky "%>
</body>
</html>

taglib指令
tablib指令的作用是在JSP页面中，将标签库描述符文件（TLD）引入到该页面中，并设置前缀，利用标签的前缀去使用标签库描述符文件中的标签。标签描述符文件为XML格式，包含一系列标签说明，它的文件后缀名是.tld。
taglib指令的语法如下：
<%@ taglib uri="标签库描述符号文件" prefix="前缀名"%>
例如，<%@ taglib uri="/mytaglib.tld" prefix="mytags"%>,在代码片段中，JSP容器在根目录中搜索标签库描述符文件mytaglib.tld，并设置前缀名：mytags(这个是自己定义的)。可以利用前缀mytags在JSP页面中使用标签，比如代码片段：
<mytags:tag1 attrl="a" attr2="b"...>
标签（包括自定义标签和核心库标签）的使用将在以后的章节里会讲到，这里只需要明白JSP使用taglib指令可以把标签库描述符文件引入JSP页面即可。

6.3 JSP隐式对象
6.3.1隐式对象概述
JSP隐式对象是Web容器加载的一组类的实例，它不像一般的Java对象那样用“new”去获取实例，而是可以直接在JSP页面使用的对象。
JSP提供的隐式对象分为4个主要类别，如图所示：

6.3.2输入和输出对象
输入和输出隐式对象是JSP页面非常常用的对象。输入和输出隐式对象有request、response和out。
request对象
request对象表示客户端的请求，包含了所有的请求信息。例如，请求的来源，Cookies和客户端请求相关的数据等。
可以在JSP页面中直接使用request对象，通过它的方法来获取请求的相关数据。request的方法有很多，下面列出几个常用的方法。
— String getParameter(String name)：根据页面表单组件名称获取请求页面提交数据。例如，在jsp1.jsp中有一个输入用户名称的文本框，它的名称是“username”，它提交请求到页面jsp2.jsp，那么在jsp2.jsp中可以利用语句request.getParameter("username")来获取用户输入的用户名。
— String[] getParameterValues(String name)：获取页面请求中一个表单组件对应多个值时的用户的请求数据。例如，在jsp1.jsp中有一个关于爱好选择的复选框，用户可以选择多项内容，复选框的名称都是“like”，它提交请求到页面jsp2.jsp，那么在jsp2.jsp中可以利用语句request.getParameterValues("like")来获取用户选择的多个爱好。
下面举个例子来说明这两个常用方法的使用：

request实际上是服务器接收客户端信息的，接收信息之后，作进一步处理
getParameter：接收请求参数
之所以出现问号，根本原因，就是次文字不在正常编码范围之内
GBK>GB2312
GBK是中文编码，GB2312是简体中文编码

<html>
<body>
	<form action="demo02.jsp" method="post">
		用户名：<input type="text" name="uname">
		<input type="submit" value="提交">
	</form>
</body>
</html>

<%@ page contentType="text/html;charset=gbk"%>
<html>
<body>
<%
	// 接收内容
	/*
	String name = request.getParameter("uname") ;
	byte[] b = name.getBytes("ISO8859-1") ;
	name = new String(b) ;
	*/
	// String name = new String(request.getParameter("uname").getBytes("ISO8859-1")) ;
	request.setCharacterEncoding("GBK") ;
	String name = request.getParameter("uname") ;
%>
<h1>输入内容为：<%=name%></h1>
</body>
</html>

J2EE中乱码是最大的问题——做到国际通用
处理中文：
 对所有的数据进行再编码：ISO8859-1编码
new String(request .getParameter(“name”).getBytes(“ISO8859-1”))
getBytes（）方法定义：
public byte[] getBytes("encoding")
再将byte数组重新变为字符串
 设置统一字符编码:

public void setCharacterEncoding(java.lang.String env)
              throws java.io.UnsupportedEncodingException
request.setCharacterEncoding(“GB2312”)

如果传递的内容是数组（复选框、下拉列表选项）
使用public java.lang.String[] getParameterValues(java.lang.String name)

<html>
<body>
	<form action="demo04.jsp" method="post">
		用户名：<input type="text" name="uname"><br>
		兴趣：
		<input type="checkbox" name="inst" value="篮球">篮球
		<input type="checkbox" name="inst" value="游泳">游泳
		<input type="checkbox" name="inst" value="唱歌">唱歌
		<input type="checkbox" name="inst" value="跳舞">跳舞
		<input type="checkbox" name="inst" value="看书">看书
		<br>
		<input type="submit" value="提交">
	</form>
</body>
</html>
<%@ page contentType="text/html;charset=gbk"%>
<html>
<body>
<%
	// 接收内容
	request.setCharacterEncoding("GBK") ;
	String name = request.getParameter("uname") ;
	String inst[] = request.getParameterValues("inst") ;
%>
<h1>用户名为：<%=name%></h1>
<h1>兴趣为：
<%
	for(int i=0;i<inst.length;i++)
	{
%>
		<%=inst[i]%>、
<%
	}
%>
</h1>
</body>
</html>

取得数组：

 
String [] inst = request .getParameterValues(“inst”);
for(i<inst.length)  <%=inst[i]%>

# getParameterNames 包 java.util.Enumeration
功能：取得客户端所与请求的参数

   Enumeration enu = request.getParameterNames()
   while(enu.hasMoreElements()){
		String  name =(String)enu.nextElement();
        if(name.startsWith(“**”)){
           String temp[] = request.getParameterValues(name);
           for(i<temp.length)  <%=temp[i]%>
        }else
          <%=request.getParameter(name)%>
}

<html>
<body>
	<form action="demo08.jsp" method="post">
		用户名：<input type="text" name="uname"><br>
		密码：<input type="password" name="upass"><br>
		兴趣：
		<input type="checkbox" name="**inst" value="篮球">篮球
		<input type="checkbox" name="**inst" value="游泳">游泳
		<input type="checkbox" name="**inst" value="唱歌">唱歌
		<input type="checkbox" name="**inst" value="跳舞">跳舞
		<input type="checkbox" name="**inst" value="看书">看书
		<br>
		<input type="submit" value="提交">
	</form>
</body>
</html>

<%@ page contentType="text/html;charset=gbk"%>
<%@ page import="java.util.*"%>
<html>
<body>
<%
	// 接收内容
	request.setCharacterEncoding("GBK") ;
	Enumeration enu = request.getParameterNames() ;
%>
<%
	while(enu.hasMoreElements())
	{
		String name = (String)enu.nextElement() ;
		if(name.startsWith("**"))
		{
			String temp[] = request.getParameterValues(name) ;
%>
			<h1><%=name%> -->
<%
			for(int i=0;i<temp.length;i++)
			{
%>
				<%=temp[i]%>、
<%
			}
%>
			</h1>
<%
		}
		else
		{
%>
			<h1><%=name%> --> <%=request.getParameter(name)%></h1>
<%
		}
	}
%>
</h1>
</body>
</html>

取得客户端IP地址：

<%@ page contentType="text/html;charset=gbk"%>
<%@ page import="java.util.*"%>
<html>
<body>
<h1><%=request.getRemoteAddr()%></h1>
</body>
</html>

总结：
只要是客户端信息，在服务器端都可以通过request对象取得

response对象
response隐式对象处理JSP生成的响应，然后将响应结果发送给客户端。response的方法有很多，下面列出几个常用的方法。
— void setContentType(String name)：设置作为响应生成的内容的类型和字符编码。
— void sendRedirect(String name)：发送一个响应给浏览器，指示其应请求另一个URL。
举例：

request对象服务器端接收客户端的请求内容的
所属的接口：javax.servlet.http. HttpServletRequest
HttpServletRequest是ServletRequest接口的子接口
而ServletRequest也只有唯一的一个子接口——HttpServletRequest
主要原因，现在的J2EE的WEB程序主要以HTTP协议为主要通讯协议
Response对象是服务器端回应客户端的请求
所属的接口：javax.servlet.http. HttpServletResponse
HttpServletResponse是ServletRespons接口的子接口
而ServletRespons也只有唯一的一个子接口——HttpServletResponse
主要原因，现在的J2EE的WEB程序主要以HTTP协议为主要通讯协议

主要功能：
 设置头信息：
最有用的一个头信息：refresh刷新
response.setHeader(“refresh”,”1”)//1秒刷新一次
response.setHeader(“refresh”,”3；URL=页面名称”)//3秒后跳转到URL

<%@page contentType="text/html;charset=gb2312"%>
<%!
	// 此处为全局变量，初始化一次
	int i = 0 ;
%>
<%
	// 一秒种刷新一次，每次使i自增
	response.setHeader("refresh","2;URL=responseDemo02.jsp") ;
%>
<h1><%=i++%></h1>
两秒后跳转到欢迎页！！！<br>
如果没有跳转，请按<a href="responseDemo02.jsp">这里</a>！！！

<%@page contentType="text/html;charset=gb2312"%>
<h1>欢迎光临：responseDemo02.jsp</h1>

	重定向：
response.sendRedirect(URL)
<%@page contentType="text/html;charset=gb2312"%>
<h1>欢迎光临：responseDemo03.jsp</h1>
<%
	System.out.println("** 跳转之前...") ;
%>
<%
	// 进行跳转
	response.sendRedirect("responseDemo04.jsp?id=mldn") ;
%>
<!--jsp:forward page="responseDemo04.jsp"/-->
<%
	System.out.println("** 跳转之后...") ;
%>
----------------------------------------------
<%@page contentType="text/html;charset=gb2312"%>
<h1>欢迎光临：responseDemo04.jsp</h1>
<h1>Hello ：<%=request.getParameter("id")%></h1>

out对象
out对象表示输出流，此输出流将作为请求的响应发送到客户端。out对象前几章已经用得很多了，它的常用方法有print()、println()和write()，这3个方法都用于向页面输出数据。
代码演示如何使用print()方法和write()方法显示输出结果。

<html>
<body>
<%
out.print("Welcome to the sky of darkness!!!");
out.write("Welcome to the sky of darkness!!!");
%>
</body>
</html>

开发中的原则：
HTML代码与JAVA代码分离，如果要输出内容，尽量使用<%=%>
要用用<%=%>完全代替<%out.print();%>

6.3.3作用域通信对象
session对象
session对象表示用户的会话状况，用此项机制可以轻易识别每一个用户，能保存和跟踪用户的会话状态。例如，购物车最常使用session的概念，当用户把商品放入购物车时，它再去添加另外的商品到购物车时，原先选购的商品仍然在购物车内，而且用户不用反复去做身份验证。但如果用户关闭Web浏览器，则会终止会话。
session对象存储有关用户会话的所有信息。session对象用于在应用程序的网页之间跳转时，存储有关会话的信息。
session对象最常用的方法如下：
— void setAttribute(String name, Object value)：以名称/值的方式，将一个对象的值存放到session中。
— void getAttribute(String name)：根据名称去获取session中存放的对象的值。
举例：

session属于Http协议范畴之内的对象，所以只有唯一的一个http包下有此接口，没有任何继承关系。
用户只要一连接到服务器，则立刻分配一个session给用户
 在服务器上，通过session来分别不同的用户sessionID：连接到服务器上的任何用户都会被分配唯一的ID
sessionID是由服务器统一管理的，人为不能控制
方法：session.getId()
长度：32 session.getId().length()
<h1>SESSIONID : <%=session.getId()%></h1>
<h1>SESSIONID LENGTH : <%=session.getId().length()%></h1>

判断是否是新的sessionpublic boolean isNew()

<%@page contentType="text/html;charset=gb2312"%>
<%
	if(session.isNew())
	{
%>
<h1>欢迎光临本页！！！</h1>
<%
	}
	else
	{
%>
<h1>您不是新的session</h1>
<%
	}
%>

通过session判断用户是否登陆过
 设置属性：public void setAttribute(String name, Object value)
 取得属性：public Object getAttribute(String name)

<%@page contentType="text/html;charset=gb2312"%>
<form action="login.jsp" method="post">
	用户名：<input type="text" name="uname"><br>
	密码：<input type="text" name="upass"><br>
	<input type="submit" value="登陆">
</form>

<%
	// 判断是否有请求内容
	// 在自提交的页面中，必须对程序第一次运行做出处理
	if(request.getParameter("uname")!=null&&request.getParameter("upass")!=null)
	{
		// 第一次的时候，并不能取得请求的参数
		String name = request.getParameter("uname") ;
		String password = request.getParameter("upass") ;
		// System.out.println(name) ;
		// System.out.println(password) ;
		if("darkness".equals(name)&&"sky".equals(password))
		{
			// 表示登陆成功
			// 通过flag属性判断用户是否已经登陆
			session.setAttribute("flag","ok") ;
			// 跳转到welcome.jsp
			response.sendRedirect("welcome.jsp") ;
		}
		else
		{
			// 登陆失败，打印错误
	%>
			<h3>登陆失败！！！</h3>
	<%
		}
	}
%>

<%@page contentType="text/html;charset=gb2312"%>
<%--
	用户必须先登陆之后，才能访问此页面
	如果用户没有登陆，则提示用户回去重新登陆
--%>
<%
	if(session.getAttribute("flag")!=null)
	{
		// session被设置过，正常登陆过
%>
<h1>欢迎光临本页！！！</h1>
<h2><a href="logout.jsp">注销</a></h2>
<%
	}
	else
	{
		// 两秒后跳转到login.jsp页面之中
		response.setHeader("refresh","2;URL=login.jsp") ;
%>
<h1>您还未登陆，请先登陆！！！</h1>
<%
	}
%>

 用户注销：让用户的session失效
public void invalidate()

<%@page contentType="text/html;charset=gb2312"%>
<%
	// ʹsessionʧЧ
	session.invalidate() ;
%>
<a href="welcome.jsp">welcome.jsp</a>

 取得session的创建时间：
long l = session.getCreationTime()
java.util.Date data = new Date(l)
 取得用户最后操作的时间
long l2 = session.getLastAccessedTime()
用户在线时间：<%=(l2-l)/1000%>

<%@page contentType="text/html;charset=gb2312"%>
<%@page import="java.util.*"%>
<%
	long l = session.getCreationTime() ;
	long l2 = session.getLastAccessedTime() ;
%>
<h1>session CREATE : <%=new Date(l)%></h1>
<h1>session last access: <%=new Date(l2)%></h1>
<h1><%=(l2-l)/1000%></h1>

Session将信息保存在服务器上，而cookie保存在客户端上
开发原则：尽量少向session中保存信息

application对象
application对象的作用范围比session更大，不仅仅是在同一个窗口，而是作用于整个应用程序，所有的客户端窗口都可以共享该对象。它从服务器启动开始就存在，直到服务器关闭为止。
application对象最常用的方法如下：
— void setAttribute(String name, Object value)：以名称/值的方式，将一个对象的值存放到application中。
— void getAttribute(String name)：根据名称去获取application中存放的对象的值。

Application 对象主要作用就是保存公共信息的：
 属性操作的三个方法：
setAttribute()、getAttribute()、removeAttribute()

application属于 javax.servlet.ServletContext包下
如何得到当前WEB工作目录------次目录不是固定的
<%=application.getRealPath(“/”)%>
<h1><%=this.getServletContext().getRealPath("/")%></h1>

Application是在服务器中保持的只有一个实例的对象
在开发中往往使用getServletContext()方法代替application
<%=getServletContext().getRealPath(“/”)%>
所有的Web处理程序，有一个Web容器的支持，此方法是由容器调用的this.getServletContext()

pageContext对象
pageContext对象使用户可以访问页面作用域中定义的所有隐式对象。pageContext对象提供方法以访问隐式对象在页面上定义的所有属性。它的作用范围仅仅在页面内。
pageContext对象最常用的方法如下：
— void setAttribute(String name, Object value)：以名称/值的方式，将一个对象的值存放到pageContext中。
— void getAttribute(String name)：根据名称去获取pageContext中存放的对象的值。
这两个方法的使用与session、application类似，这里就不再举例说明。下面举一个例子来区别pageContext，session，application这3个对象作用范围的区别。

<%@ page language="java" %>
<%
if(pageContext.getAttribute("pageCount")==null) {
   pageContext.setAttribute("pageCount", new Integer(0));
}
if (session.getAttribute("sessionCount")==null) {
   session.setAttribute("sessionCount",new Integer(0));
}
if (application.getAttribute("appCount")==null) {
   application.setAttribute("appCount",new Integer(0));
}
%>

<%
    Integer count = (Integer)pageContext.getAttribute("pageCount");
    pageContext.setAttribute("pageCount", new Integer(count.intValue()+1));

    Integer count2 = (Integer)session.getAttribute("sessionCount");
    session.setAttribute("sessionCount",new Integer(count2.intValue()+1));

    Integer count3 = (Integer)application.getAttribute("appCount");
    application.setAttribute("appCount",new Integer(count3.intValue()+1));
%>

<html>
  <body>
<div align="center">使用 session、application 和 pageContext 对象显示会话计数

</div>
<form name="form1" method="post" action="">
  <table width="400" border="0" align="center">
    <tr>
      <td width="116"><b>页面计数:</b></td>
      <td width="168"><%= pageContext.getAttribute("pageCount")%></td>
    </tr>
    <tr>
      <td width="116"><b>会话计数 </b></td>
      <td width="168"><%= session.getAttribute("sessionCount")%></td>
    </tr>
    <tr>
      <td width="116"><b>应用程序计数</b></td>
      <td width="168"><%= application.getAttribute("appCount")%></td>
    </tr>
    <tr>
      <td width="116"><b>时间</b></td>
      <td width="168"><%=  new java.sql.Time(System.currentTimeMillis()) %></td>
    </tr>
  </table>
</form>
<h1>&nbsp;</h1>

<b> </b>
</BODY>
</HTML>

6.3.4 Servlet 对象
在JSP页面的执行过程中，每个JSP页面都会生成一个Servlet。Servlet对象提供方法和变量以访问为JSP页面创建的Servlet的所有信息。page和config就是这样的Servlet对象。
page对象
page对象提供对网页上定义的所有对象的访问。page对象表示页面本身，它市java.lang.Object类的一个实例。为JSP页面创建的Servlet类定义变量和方法，这些变量和方法包含页面的信息。使用page对象可以访问所有这些变量和方法。
page对象的用法见代码。不过，page对象很少在JSP中使用，一般使用前面学过的page指令即可。

<%@  page  info="我的信息"  contentType="text/html;charset=gb2312"%>
<html>
<body>
   <%=((javax.servlet.jsp.HttpJspPage)page).getServletInfo()%>
</body>
</html>

config对象
config对象存储Servlet的一些初始化信息，与page对象一样都会很少用到。config对象上javax.servlet.ServletConfig接口的一个实例，ServletConfig接口提供方法以检索Servlet初始化参数。config对象表示编译JSP页面的Servlet初始化数据的配置。
代码片段演示了config对象的用法：
String propertyFile
= (String)config.getInitParameter("PropertyFile");
在这段代码中，“PropertyFile”是在web.xml中的初始化数据配置的参数名。
Config对象与Web安全性
在J2EE中安全性体现：WEB-INF文件夹
如果能够将一个页面放到WEB-INF文件夹，安全性就能够的到提高
但是不能访问，如果要访问，只有一种方法：
在WEB-INF目录下有个 web.xml文件
Web.xml属于整个Web站点的配置文件

<servlet>
   在web.xml文件内部起作用，与servlet-mapping关联
  <servlet-name>darkness</servlet-name>
   找到jsp的路径，此路径一般都保存在WEB-INF之中
  <jsp-file>/WEB-INF/sky.jsp</jsp-file>
</servlet>
<servlet-mappint>
   在web.xml文件内部起作用，与servlet-name完全一致
   <servlet-name>darkness</servlet-name>
   网页上输入的实际路径地址
   <url-pattern>/sky</url-pattern>
</servlet-mapping>

此文件一旦被修改，则要重新启动服务器，服务器启动时将读取此文件

要使用config对象的前提：JSP页面必须在web.xm中配置

<servlet>
  <servlet-name>darkness</servlet-name>
  <jsp-file>/WEB-INF/sky.jsp</jsp-file>
  <init-param>
     <param-name>darksky</param-name>
     <param-value>cloud</param-value>
</init-param>
<init-param>
     <param-name>darksky</param-name>
     <param-value>cloud</param-value>
</init-param>

</servlet>
<servlet-mappint>
    <servlet-name>darkness</servlet-name>
   <url-pattern>/sky</url-pattern>
</servlet-mapping>

如果要取得这些初始化参数，必须通过映射名称进行访问JSP页面，才可能取得初始化参数，就通过config对象取得
它属于javax.servlet.ServletConfig包下。
取得初始化参数的方法：getInitParameter(java.lang.String name)

<%=config.getInitParameter(“darksky”)%>
<h1>Hello Boy !!!</h1>
<h1><%=config.getInitParameter("uname")%></h1>
<h1><%=config.getInitParameter("upass")%></h1>

public java.util.Enumeration getInitParameterNames()：得到所有配置参数
通过此种功能，可以将数据库连接的一些信息写在配置文件之中-----JDBC程序

6.3.5错误对象
JSP页面执行后，会在网页上显示内容。如果在执行JSP的过程中发生错误，JSP页面的执行就会终止。错误对象用于处理JSP页面中的错误。
错误对象只提供了一个称为exception的错误对象，利用exception对象处理执行过程中引发的异常。
JSP中page指令的isErrorPage属性用于指定错误页面。应该在错误页面上创建exception对象的实例，此实例用于捕获导致控制权传输到当前错误处理页面的错误。
代码演示了page指令和exception对象的用法。

<%@  page  isErrorPage="true"%>
<html>
<head>
<title>JSP隐式对象</title>
</head>
<body>
<h1> JSP隐式对象：异常</h1>
已检测到以下错误：<br/>
<b><%=exception%></b><br/>
<%exception.printStackTrace(out);%>
</body>
</html>

在代码片段中，isErrorPage属性设置为true，这表示该页面为错误页面。JSP表达式（<%=exception%>）用于创建exception对象的实例。printStackTrace()方法用于显示异常的堆栈跟踪，out对象作为参数提供给printStackTrace（）方法，该方法将显示堆栈跟踪信息。

小知识：
默认首页如何设置：
   Tomcat服务器默认首页的名称是：index.html,index.htm,index.jsp
修改web.xml文件
<welcome-file-list>
       <welcome-file>default.html</welcome-file>
</welcome-file-list>

JSP内置对象分类
 与Servlet有关的隐含对象
—page(java.lang.Object)作用域：page
—config(javax.servlet.ServletContext)作用域：page
 与Input/Output有关的隐含对象
—out (javax.servlet.jsp.JspWriter) 作用域：page
—request (javax.servlet.http.HttpServletRequest)作用域：request
—response (javax.servet.http.HttpServletResponse) 作用域：page
 JSP执行时，提供有关Context的隐含对象
—session (javax.servlet.http.HttpSession) 作用域：session
—application (javax.servlet.ServletContext) 作用域：application
—pageContext (javax.servlet.jsp.PageContext) 作用域：page
 与Error有关的隐含对象
—exception (java.lang.Throwable) 作用域：page

JSP中属性的保存范围
 在JSP中可以采用下面方法设置和取得属性：
Public void setAttribute(String name , Object value) 属性值可以为任意对象
Public Object getAttribute(String name)
 在一个页面范围内：page
 在一次服务器请求范围内：request 必须使用服务器端跳转<jsp:forward/>
                       应用点：MVC、Struts、Webwork
 在一次会话范围内：session
   主要功能：验证用户是否登陆
 在一个应用服务器范围内：application
Application的应用：在线人员统计、在线人员名单列表
如果能使用request就不要使用session，如果能使用session就不要使用application

6.4 JSP综合应用实例
   6.5 本章小结