网站系统jsp模板(jsp网站设计)

　　Web-第十一天 JSP学习

　　JSP 服务器端页面技术

案例：显示商品信息

简单阐述JSP的执行原理

会使用page执行处理JSP编码问题

会使用page执行导入jsp需要使用的类

列举JSP内置对象

列举JSP四大作用域

比较静态包含和动态包含

　　第1章案例一：在JSP的页面中显示商品的信息.1. 需求:

　　数据库中存放了很多商品信息,现在将商品的信息全部显示到页面.

　　2. 相关知识点:1.2.1 JSP概述1.2.1.1 什么是JSP

　　JSP全名是Java Server Pages，它是建立在Servlet规范之上的动态网页开发技术。在JSP文件中，HTML代码与Java代码共同存在，其中，HTML代码用来实现网页中静态内容的显示，Java代码用来实现网页中动态内容的显示。为了与传统HTML有所区别，JSP文件的扩展名为.jsp。

　　JSP技术所开发的Web应用程序是基于Java的，它可以用一种简捷而快速的方法从Java程序生成Web页面，其使用上具有如下几点特征：

跨平台：由于JSP是基于Java语言的，它可以使用Java API，所以它也是跨平台的，可以应用于不同的系统中，如Windows、Linux等。当从一个平台移植到另一个平台时，JSP和JavaBean的代码并不需要重新编译，这是因为Java的字节码是与平台无关的，这也应验了Java语言“一次编译，到处运行”的特点。

业务代码相分离：在使用JSP技术开发Web应用时，可以将界面的开发与应用程序的开发分离开。开发人员使用HTML来设计界面，使用JSP标签和脚本来动态生成页面上的内容。在服务器端，JSP引擎（或容器，本书中指Tomcat）负责解析JSP标签和脚本程序，生成所请求的内容，并将执行结果以HTML页面的形式返回到浏览器。

组件重用：JSP中可以使用JavaBean编写业务组件，也就是使用一个JavaBean类封装业务处理代码或者作为一个数据存储模型，在JSP页面中，甚至在整个项目中，都可以重复使用这个JavaBean，同时，JavaBean也可以应用到其他Java应用程序中。

预编译：预编译就是在用户第一次通过浏览器访问JSP页面时，服务器将对JSP页面代码进行编译，并且仅执行一次编译。编译好的代码将被保存，在用户下一次访问时，会直接执行编译好的代码。这样不仅节约了服务器的CPU资源，还大大的提升了客户端的访问速度。

　　1.2.1.2 编写第一个JSP文件

　　在Eclipse中，创建一个名称为day17的Web项目，然后右击WebContent目录à【new】à【Other】，在弹出的窗口中找到JSP文件，如图1-1所示。

图1-1 创建JSP文件

　　在图1-1中，选择JSP File后，点击【Next】按钮，在新窗口的File name文本框中填写JSP文件名称HelloWorld，如图1-2所示。

图1-2 命名文件

　　填写完图1-2中JSP文件名称后，点击【Next】按钮，进入选择模板窗口，此处采用默认设置，如图1-3所示。

图1-3 选择模板窗口

　　点击图1-3中的【Finish】按钮后，第一个JSP文件就创建成功了。创建后的JSP文件代码如图1-4所示。

图1-4 HelloWorld.jsp

从图1-4中可以看出，新创建的JSP文件与传统的HTML文件几乎没有什么区别，唯一的区别是默认创建时，页面代码最上方多了一条page指令，并且该文件的后缀名是jsp，而不是html，关于page指令会在1.3节中详细讲解，此处了解即可。JSP文件必须发布到Web容器中的某个Web应用中才能查看出效果。在HelloWorld.jsp的<body>元素内添加上文字“My First JSP”并保存后，将day13项目发布到Tomcat中并启动项目，在浏览器地址栏中输入地址“http://localhost:8080/day13/HelloWorld.jsp”，此时浏览器的显示效果如图1-5所示。

图1-5 HelloWorld.jsp文件显示效果

　　从图1-5中可以看出，HelloWorld.jsp中添加的内容已被显示出来，这说明了HTML中的元素可以被JSP容器所解析。实际上，JSP只是在原有的HTML文件中加入了一些具有Java特点的代码，这些代码具有其独有的特点，称为JSP的语法元素。

　　新大头儿子和小头爸爸3：俄罗斯奇遇记

　　主演：刘纯燕 / 董浩 / 鞠萍

　　猫眼电影演出广告

　　购买

　　1.2.1.3 JSP运行原理

　　JSP的工作模式是请求/响应模式，客户端首先发出HTTP请求，JSP程序收到请求后进行处理并返回处理结果。在一个JSP文件第一次被请求时，JSP引擎（容器）把该JSP文件转换成为一个Servlet，而这个引擎本身也是一个Servlet。JSP的运行过程如图1-6所示。

图1-6 JSP的运行原理

　　JSP的运行过程具体如下：

　　（1）客户端发出请求，请求访问JSP文件。

　　（2）JSP容器先将JSP文件转换成一个Java源文件（Java Servlet源程序），在转换过程中，如果发现JSP文件中存在任何语法错误，则中断转换过程，并向服务端和客户端返回出错信息。

　　（3）如果转换成功，则JSP容器将生成的Java源文件编译成相应的字节码文件*.class。该class文件就是一个Servlet，Servlet容器会像处理其他Servlet一样来处理它。

　　为了使同学们更容易理解JSP的运行原理，接下来简单介绍分析一下JSP所生成的Servlet代码。

　　以HelloWorld.jsp为例，当用户第一次访问HelloWorld.jsp页面时，该页面会先被JSP容器转换为一个名称为HelloWorld_jsp.java的源文件，然后将源文件编译为一个名称为HelloWorld_jsp.class字节码文件。如果项目发布在Tomcat的webapps目录中，源文件和.class文件可以在“Tomcat安装目录/work/Catalina/localhost/项目名/org/apache/jsp”下找到，如图1-7所示。

图1-7 JSP文件编译后的文件

　　在图1-7中，地址栏中的路径多出了orgapachejsp，这是由于JSP文件转换成类文件时会带有包名，该包名为org.apache.jsp。从图中还可以看出，HelloWorld.jsp已被转换为源文件和.class文件。打开HelloWorld_jsp.java文件，可查看转换后的源代码，其主要代码如下所示。（以下代码可以快速浏览，确定父类和方法名即可）

　　package org.apache.jsp;

　　...

　　public final class HelloWorld_jspextends org.apache.jasper.runtime.HttpJspBase

　　implements org.apache.jasper.runtime.JspSourceDependent {

　　...

　　public void _jspInit() {

　　_el_expressionfactory = _jspxFactory.getJspApplicationContext(

　　getServletConfig().getServletContext()).getExpressionFactory();

　　_jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());

　　}

　　public void _jspDestroy() {

　　}

　　public void _jspService(final javax.servlet.http.HttpServletRequest request,

　　final javax.servlet.http.HttpServletResponse response)

　　throws java.io.IOException, javax.servlet.ServletException {

　　final javax.servlet.jsp.PageContext pageContext;

　　javax.servlet.http.HttpSession session = null;

　　final javax.servlet.ServletContext application;

　　final javax.servlet.ServletConfig config;

　　javax.servlet.jsp.JspWriter out = null;

　　final java.lang.Object page = this;

　　javax.servlet.jsp.JspWriter _jspx_out = null;

　　javax.servlet.jsp.PageContext _jspx_page_context = null;

　　try {

　　response.setContentType("text/html; charset=UTF-8");

　　pageContext = _jspxFactory.getPageContext(this, request, response,

　　null, true, 8192, true);

　　_jspx_page_context = pageContext;

　　application = pageContext.getServletContext();

　　config = pageContext.getServletConfig();

　　session = pageContext.getSession();

　　out = pageContext.getOut();

　　_jspx_out = out;

　　out.write("rn");

out.write("<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">rn");

out.write("<html>rn");

out.write("<head>rn");

out.write("<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">rn");

out.write("<title>Insert title here</title>rn");

out.write("</head>rn");

out.write("<body>rn");

　　out.write(" My First JSPrn");

out.write("</body>rn");

out.write("</html>");

　　} catch (java.lang.Throwable t) {

　　if (!(t instanceof javax.servlet.jsp.SkipPageException)){

　　out = _jspx_out;

　　if (out != null && out.getBufferSize() != 0)

　　try {

　　if (response.isCommitted()) {

　　out.flush();

　　} else {

　　out.clearBuffer();

　　}

　　} catch (java.io.IOException e) {}

　　if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);

　　else throw new ServletException(t);

　　}

　　} finally {

　　_jspxFactory.releasePageContext(_jspx_page_context);

　　}

　　从上面的代码可以看出，HelloWorld.jsp文件转换后的源文件没有实现Servlet接口，但继承了org.apache.jasper.runtime.HttpJspBase类。在Tomcat源文件中查看HttpJspBase类的源代码，具体如下所示：（以下代码可以快速阅读，确定父类即可）

　　package org.apache.jasper.runtime;

　　...

　　public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {

　　private static final long serialVersionUID = 1L;

　　protected HttpJspBase() {

　　}

　　@Override

　　public final void init(ServletConfig config)

　　throws ServletException

　　{

　　super.init(config);

　　jspInit();

　　_jspInit();

　　}

　　@Override

　　public String getServletInfo() {

　　return Localizer.getMessage("jsp.engine.info");

　　}

　　@Override

　　public final void destroy() {

　　jspDestroy();

　　_jspDestroy();

　　}

　　@Override

　　public final void service(HttpServletRequest request,HttpServletResponse response)

　　throws ServletException, IOException

　　{

　　_jspService(request, response);

　　}

　　@Override

　　public void jspInit() {

　　}

　　public void _jspInit() {

　　}

　　@Override

　　public void jspDestroy() {

　　}

　　protected void _jspDestroy() {

　　}

　　@Override

　　public abstract void _jspService(HttpServletRequest request,

　　HttpServletResponse response)

　　throws ServletException, IOException;

　　}

　　从HttpJspBase源代码中可以看出，HttpJspBase类是HttpServlet的一个子类，由此可见，HelloWorld_jsp类就是一个Servlet。结论：JSP就是Servlet。

　　1.2.2 JSP基本语法

　　在JSP文件中可以嵌套很多内容，例如，JSP的脚本元素和注释等，这些内容的编写都需要遵循一定的语法规范，接下来，本节将针对这些语法进行详细的讲解。

　　1.2.2.1 JSP脚本元素

JSP脚本元素是指嵌套在<%和%>之中的一条或多条Java程序代码。通过JSP脚本元素可以将Java代码嵌入HTML页面中，所有可执行的Java代码，都可以通过JSP脚本来执行。

　　JSP脚本元素主要包含如下三种类型：

JSP lets

JSP声明语句

JSP表达式

　　1. JSP lets

　　JSP lets 是一段代码段。当需要使用Java实现一些复杂操作或控制时，可以使用它。JSP lets的语法格式如下所示：

<% java 代码（变量、方法、语句等）%>

　　在JSP lets中声明的变量是JSP页面的局部变量，调用JSP lets时，会为局部变量分配内存空间，调用结束后，释放局部变量占有的内存空间。

　　2. JSP声明语句

JSP的声明语句用于声明变量和方法，它以“<%!”开始，以“%>”结束，其语法格式如下所示：

<%!

　　定义的变量或方法等

　　在上述语法格式中，被声明的Java代码将被编译到Servlet的_jspService()方法之外，即在JSP声明语句中定义的都是成员方法、成员变量、静态方法、静态变量、静态代码块等。在JSP声明语句中声明的方法在整个JSP页面内有效。

　　在一个JSP页面中可以有多个JSP声明语句，单个声明中的Java语句可以是不完整的，但是多个声明组合后的结果必须是完整的Java语句。接下来，通过一个案例来演示JSP lets和声明语句的使用。

　　在day12项目的WebContent目录下创建一个名称为example01.jsp的文件，在该文件中编写声明语句，如文件1-1所示。

　　文件1-1 example01.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>JSP声明语句</title>

</head>

<%!

　　int a = 1, b = 2; //定义两个变量a,b

<%!

　　public String print() { //定义print方法

　　String str = "javahelp "; //方法内定义的变量str

　　return str;

　　}

<body>

　　out.println(a + b); //输出两个变量的和

　　out.println(print());//调用print()方法，输出其返回值

</body>

</html>

在文件1-1中，首先使用<%!和%>定义了两个变量a、b，以及print()方法，然后使用了<%和%>输出了两个常量的和，以及print()方法中的返回信息。启动项目后，在浏览器地址栏中输入地址“http://localhost:8080/day17/example01.jsp”访问example01.jsp文件，显示效果如图1-8所示。

图1-8 example01.jsp的执行结果

　　从图1-8中可以看到，浏览器中已经显示出了相应的结果。

网站系统jsp模板(jsp网站设计)

需要注意的是，<%!和%>里面定义的变量是成员变量，方法是全局的方法，此处只是声明，也就是定义，变量或方法都没有被调用。<%和%>里面定义的是局部变量，不能定义方法（Java方法中不能再嵌套定义方法），代码块操作可以将结果输出到浏览器。总之，<%!和%>是用来定义成员变量属性和方法的，<%和%>主要是用来输出内容的，因此如果涉及到了成员变量的操作，那么就应该使用<%!和%>，而如果是涉及到了输出内容的时候，就使用<%和%>。

　　3. JSP表达式

JSP表达式（expression）用于将程序数据输出到客户端，它将要输出的变量或者表达式直接封装在以“<%=” 开头和以“%>”结尾的标记中，其基本的语法格式如下所示：

<%= expression %>

在上述语法格式中，JSP表达式中的将“expression”表达式结果输出到浏览器。例如，对example01.jsp文件进行修改，将<body>内的脚本元素修改为表达式，具体如下。

<%=a+b %>

<%=print() %>

　　在浏览器中再次访问example01.jsp页面，同样可以正确输出如图1-8中的显示结果。需要注意的是：

“<%=”和“%>”标记之间插入的是表达式，不能插入语句。

“<%=”是一个完整的符号，“<%”和“=”之间不能有空格。

JSP表达式中的变量或表达式后面不能有分号（;）。

　　1.2.2.2 JSP注释

　　同其他各种编程语言一样，JSP也有自己的注释方式，其基本语法格式如下：

<%-- 注释信息 --%>

　　需要注意的是，Tomcat在将JSP页面编译成Servlet程序时，会忽略JSP页面中被注释的内容，不会将注释信息发送到客户端。接下来，通过一个案例来演示JSP注释的使用。

　　在day12项目的WebContent目录下创建一个名称为example02的JSP页面，如文件1-2所示。

　　文件1-2 example02.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>JSP注释</title>

</head>

<body>

<%-- 这个是JSP注释 --%>

</body>

</html>

　　在上述页面代码中，包含HTML注释和JSP两种注释方式。启动Tomcat服务器，在浏览器的地址栏中输入地址“http://localhost:8080/day17/example02.jsp”访问example02.jsp页面，此时，可以看到example02.jsp页面什么都不显示，接下来在打开的页面中点击鼠标右键，在弹出菜单中选择【查看源文件】选项，结果如图1-9所示。

图1-9 example02.jsp的源代码

从图1-9中可以看出，JSP的注释信息没有显示出来，而只显示出了HTML注释。这是因为在Tomcat编译JSP文件时，会将HTML注释当成普通文本发送到客户端，而JSP页面中格式为“<%-- 注释信息 --%>”的内容则会被忽略，不会发送到客户端。

JSP注释、Java注释、HTML注释对比：

<%-- jsp注释--%>

<%//java注释%>

　　jsp源码

　　java源码

　　html源码

　　jsp注释

　　有

　　无

　　java注释

　　有

　　无

　　html注释

　　有

　　1.2.3 JSP指令

　　为了设置JSP页面中的一些信息，Sun公司提供了JSP指令。 JSP 2.0中共定义了page、include和taglib三种指令，每种指令都定义了各自的属性。接下来，本节将针对page和include指令进行详细的讲解。

　　1.2.3.1 page指令

　　在JSP页面中，经常需要对页面的某些特性进行描述，例如，页面的编码方式，JSP页面采用的语言等，这时，可以通过page指令来实现。page指令的具体语法格式如下所示：

<%@ page 属性名1= "属性值1" 属性名2= "属性值2" ...%>

　　在上面的语法格式中，page用于声明指令名称，属性用来指定JSP页面的某些特性。page指令提供了一系列与JSP页面相关的属性，如表1-1所示。

　　表1-1 page指令的常用属性

属性名称

取值or范围

描述

pageEncoding

　　当前页面

　　指定页面编码格式

contentType

　　有效的文档类型

　　客户端浏览器根据该属性判断文档类型，例如：

　　HTML格式为text/html

　　纯文本格式为text/plain

　　JPG图像为image/jpeg

　　GIF图像为image/gif

　　Word文档为application/msword

buffer

8kb

　　jsp缓存大小

autoFlush

true / false

　　是否自动刷新

errorPage

　　某个JSP页面的相对路径

　　指定一个错误页面，如果该JSP程序抛出一个未捕捉的异常，则转到errorPage指定的页面。errorPage指定页面的isErrorPage属性为true，且内置的exception对象为未捕捉的异常

isErrorPage

true / false

　　指定该页面是否为错误处理页面，如果为true，则该JSP内置有一个Exception对象的exception，可直接使用。默认情况下，isErrorPage的值为false

import

任何包名、类名

　　指定在JSP页面翻译成的Servlet源文件中导入的包或类。import是唯一可以声明多次的page指令属性。一个import属性可以引用多个类，中间用英文逗号隔开。

language

java

　　指明解释该JSP文件时采用的语言，默认为Java

session

true、false

　　指明该JSP内是否内置Session对象，如果为true，则说明内置Session对象，可以直接使用，否则没有内置Session对象。默认情况下，session属性的值为true。需要注意的是，JSP 引擎自动导入以下4个包：

　　java.lang.*

　　javax.servlet.*

　　javax.servlet.jsp.*

　　javax.servlet.http.*

　　表1-1中列举了page指令的常见属性，其中，除了import属性外，其他的属性都只能出现一次，否则会编译失败。需要注意的是，page指令的属性名称都是区分大小写的。

　　下面列举两个使用page指令的示例：

<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%>

<%@ page import="java.awt.*" %>

<%@ page import="java.util.*","java.awt.*"%>

　　上面代码中使用了page指令的language、contentType、pageEncoding和import属性。

　　需要注意的是，page指令对整个页面都有效，而与其书写的位置无关，但是习惯上把page指令写在JSP页面的最前面。

　　1.2.3.2 include指令

　　在实际开发时，有时需要在JSP页面静态包含一个文件，例如HTML文件，文本文件等，这时，可以通过include指令来实现，include指令的具体语法格式如下所示：

<%@ include file="被包含的文件地址"%>

　　include指令只有一个file属性，该属性用来指定插入到JSP页面目标位置的文件资源。

　　为了使读者更好地理解include指令的使用，接下来，通过一个案例来学习include指令的具体用法。

　　在day12项目的WebContent目录下创建两个JSP页面文件date.jsp和include.jsp，在include.jsp文件中使用include指令将date.jsp文件包含其中，具体如文件1-3和文件1-4所示。

　　文件1-3 date.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>

<html>

<head><title>Insert title here</title>

</head>

<body>

<% out.println(new java.util.Date().toLocaleString());%>

</body>

</html>

　　文件1-4 include.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>

<html>

<head>

</head>

<body>

　　欢迎你，现在的时间是：

<%@ include file="/date.jsp"%>

</body>

</html>

　　启动tomcat服务器，在浏览器中访问地址“http://localhost:8080/day17/include.jsp”，浏览器的显示结果如图1-10所示。

　　图1-10 运行结果

　　从图1-10中可以看出，date.jsp文件中用于输出当前日期的语句已显示出来，这说明include指令成功地将date.jsp文件中的代码合并到了include.jsp文件中。

　　关于include指令的具体应用，有很多问题需要注意，接下来，将这些问题进行列举，具体如下：

　　（1）被引入的文件必须遵循JSP语法，其中的内容可以包含静态HTML、JSP脚本元素和JSP指令等普通JSP页面所具有的一切内容。

　　（2）除了指令元素之外，被引入的文件中的其他元素都被转换成相应的Java源代码，然后插入进当前JSP页面所翻译成的Servlet源文件中，插入位置与include指令在当前JSP页面中的位置保持一致。

　　1.2.3.3 taglib指令

　　用于页面中引入标签库的，这个指令会在后面介绍JSTL的时候讲解.

　　1.2.4 JSP内置对象1.2.4.1 内置对象的概述

　　在JSP页面中，有一些对象需要频繁使用，如果每次都重新创建这些对象则会非常麻烦。为了简化Web应用程序的开发，JSP2.0规范中提供了9个隐式（内置）对象，它们是JSP默认创建的，可以直接在JSP页面中使用。这9个隐式对象的名称、类型和描述如表1-2所示。

　　表1-2 JSP隐式对象

名称

类型

描述

　　out

　　javax.servlet.jsp.JspWriter

　　用于页面输出

　　request

　　javax.servlet.http.HttpServletRequest

　　得到用户请求信息，

　　response

　　javax.servlet.http.HttpServletResponse

　　服务器向客户端的回应信息

　　config

　　javax.servlet.ServletConfig

　　服务器配置，可以取得初始化参数

　　session

　　javax.servlet.http.HttpSession

　　用来保存用户的信息

　　application

　　javax.servlet.ServletContext

　　所有用户的共享信息

　　page

　　java.lang.Object

　　指当前页面转换后的Servlet类的实例

　　pageContext

　　javax.servlet.jsp.PageContext

　　JSP的页面容器

　　exception

　　java.lang.Throwable

　　表示JSP页面所发生的异常，在错误页中才起作用

　　在表1-2中，列举了JSP的9个隐式对象及它们各自对应的类型。其中，由于request、response、config、session和application所属的类及其用法在前面的章节都已经讲解过，而page对象在JSP页面中很少被用到。因此，在下面几个小节中，将针对out和pageContext对象进行详细的讲解。

　　1.2.4.2 out对象

　　在JSP页面中，经常需要向客户端发送文本内容，这时，可以使用out对象来实现。out对象是javax.servlet.jsp.JspWriter类的实例对象，它的作用与ServletResponse.getWriter()方法返回的PrintWriter对象非常相似，都是用来向客户端发送文本形式的实体内容。不同的是，out对象的类型为JspWriter，它相当于一种带缓存功能的PrintWriter。接下来，通过一张图来描述JSP页面的out对象与Servlet引擎提供的缓冲区之间的工作关系，具体如图1-11所示。

图1-11 out对象与Servlet引擎的关系

　　从图1-11可以看出，在JSP页面中，通过out隐式对象写入数据相当于将数据插入到JspWriter对象的缓冲区中，只有调用了ServletResponse.getWriter()方法，缓冲区中的数据才能真正写入到Servlet引擎所提供的缓冲区中。为了验证上述说法是否正确，接下来，通过一个具体的案例来演示out对象的使用。

　　在day12项目的WebContent目录下创建一个名称为out的JSP页面，如文件1-5所示。

　　文件1-5 out.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>

<html>

<head>

<title>Insert title here</title>

</head>

<body>

out.println("first line ");

response.getWriter().println("second line ");

</body>

</html>

　　启动Tomcat服务器，在浏览器地址栏中访问“http://localhost:8080/day12/out.jsp”，浏览器的显示结果如图1-12所示。

图1-12 运行结果

　　从图1-12中可以看出，尽管out.println语句位于response.getWriter().println语句之前，但它的输出内容却在后面。由此可以说明，out对象通过print语句写入数据后，直到整个JSP页面结束，out对象中输入缓冲区的数据（即：first line）才真正写入到Serlvet引擎提供的缓冲区中，而response.getWriter().println语句则是直接把内容（即：second line）写入Servlet引擎提供的缓冲区中，Servlet引擎按照缓冲区中的数据存放顺序输出内容。

　　1.2.4.3 pageContext对象

　　在JSP页面中，使用pageContext对象可以获取JSP的其他8个隐式对象。pageContext对象是javax.servlet.jsp.PageContext类的实例对象，它代表当前JSP页面的运行环境，并提供了一系列用于获取其他隐式对象的方法。pageContext对象获取隐式对象的方法如表1-3所示。

　　表1-3 pageContext获取隐式对象的方法

方法名

功能描述

　　JspWriter getOut()

　　用于获取out隐式对象

　　Object getPage()

　　用于获取page隐式对象

　　ServletRequest getRequest()

　　用于获取request隐式对象

　　ServletResponse getResponse()

　　用于获取response隐式对象

　　HttpSession getSession()

　　用于获取session隐式对象

　　Exception getException()

　　用于获取exception隐式对象

ServletConfig getServletConfig()

　　用于获取config隐式对象

　　ServletContext getServletContext()

　　用于获取application隐式对象

　　表1-3中列举了pageContext获取其他隐式对象的方法，这样，当传递一个pageContext对象后，就可以通过这些方法轻松地获取到其他8个隐式对象了。

　　pageContext对象不仅提供了获取隐式对象的方法，还提供了存储数据的功能。pageContext对象存储数据是通过操作属性来实现的，表1-4列举了pageContext操作属性的一系列方法，具体如下：

　　表1-4 pageContext操作属性的相关方法

方法名称

功能描述

　　void setAttribute(String name,Object value,int scope)

　　用于设置pageContext对象的属性

　　Object getAttribute(String name,int scope)

　　用于获取pageContext对象的属性

　　void removeAttribute(String name,int scope)

　　删除指定范围内名称为name的属性

　　void removeAttribute(String name)

　　删除所有范围内名称为name的属性

　　Object findAttribute(String name)

　　从4个域对象中查找名称为name的属性

　　表1-4列举了pageContext对象操作属性的相关方法，其中，参数name指定的是属性名称，参数scope指定的是属性的作用范围。pageContext对象的作用范围有4个值，具体如下：

PageContext.PAGE_SCOPE：表示页面范围

PageContext.REQUEST_SCOPE：表示请求范围

PageContext.SESSION_SCOPE：表示会话范围

PageContext.APPLICATION_SCOPE：表示Web应用程序范围

　　需要注意的是，当使用findAttribute()方法查找名称为name的属性时，会按照page、request、session和application的顺序依次进行查找，如果找到，则返回属性的名称，否则返回null。接下来，通过一个案例来演示pageContext对象的使用。

　　在day12项目的WebContent目录下创建一个名称为pageContext.jsp的页面，编辑后如文件1-7所示。

　　文件1-6 pageContext.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>

<html>

<head>

<title>pageContext</title>

</head>

<body>

　　//获取request对象

　　HttpServletRequest req = (HttpServletRequest) pageContext.getRequest();

　　//设置page范围内属性

　　pageContext.setAttribute("str", "Java",pageContext.PAGE_SCOPE);

　　//设置request范围内属性

　　req.setAttribute("str", "Java Web");

　　//获得的page范围属性

　　String str1 = (String)pageContext.getAttribute("str",pageContext.PAGE_SCOPE);

　　//获得的request范围属性

　　String str2 = (String)pageContext.getAttribute("str",pageContext.REQUEST_SCOPE);

<%="page范围："+str1 %>

<%="request范围："+str2 %>

</body>

</html>

　　在上述代码中，首先使用pageContext获取了request对象，并设置page范围内属性；然后使用获取的request对象设置了request范围内属性，接下来使用pageContext对象获得page和request范围内的相应属性，最后使用JSP表达式输出数据。

　　启动Tomcat服务器，在浏览器的地址栏中输入地址“http://localhost:8080/day17/pageContext.jsp”访问pageContext.jsp页面，浏览器显示的结果如图1-13所示。

　　图1-13 运行结果

　　从图1-13的显示结果可以看出，通过pageContext对象可以获取到request对象，并且还可以获取不同范围内的属性。

　　1.2.5 JSP的四个域范围:

　　PageContext常量名

　　描述

　　作用域名称

　　域对象类型

　　PageScope

　　当前页面中有效

　　pageContext

　　PageContext

　　RequestScope

　　一次请求范围

　　request

　　HttpServletRequest

　　SessionScope

　　一次会话范围

　　session

　　HttpSession

　　ApplicationScope

　　应用范围

　　application

　　ServletContext

page：表示当前页，通常没用。jsp标签底层使用。

request：表示一次请求。通常一次请求就一个页面，但如果使用请求转发，可以涉及多个页面。

session：表示一次会话。可以在多次请求之间共享数据。

application：表示一个web应用(项目)。可以整个web项目共享，多次会话共享数据。

　　1.2.6 JSP动作元素(了解)

　　JSP动作元素用来控制JSP的行为，执行一些常用的JSP页面动作。通过动作元素可以实现使用多行Java代码能够实现的效果，如包含页面文件，实现请求转发等。

1.2.6.1 <jsp:include>动作元素

在JSP页面中，为了把其他资源的输出内容插入到当前JSP页面的输出内容中，JSP技术提供了<jsp:include>动作元素，<jsp:include>动作元素的具体语法格式如下所示：

<jsp:include page="relativeURL" flush="true|false" />

　　在上述语法格式中，page属性用于指定被引入资源的相对路径，flush属性用于指定是否将当前页面的输出内容刷新到客户端，默认情况下，flush属性的值为false。

<jsp:include>包含的原理是将被包含的页面编译处理后将结果包含在页面中。当浏览器第一次请求一个使用<jsp:include>包含其他页面的页面时，Web容器首先会编译被包含的页面，然后将编译处理后的返回结果包含在页面中，之后编译包含页面，最后将两个页面组合的结果回应给浏览器。为了使读者更好地理解<jsp:include>动作元素，接下来，通过一个案例来演示<jsp:include>动作元素的使用，具体如下：

（1）在day12项目的WebContent目录下编写两个JSP文件，分别是included.jsp和dynamicInclude.jsp。其中dynamicInclude.jsp页面用于引入included.jsp页面。included.jsp作为被引入的文件，让它暂停5秒钟后才输出内容，这样，可以方便测试<jsp:include>标签的flush属性。included.jsp的具体代码如文件1-10所示，dynamicInclude.jsp具体代码如文件1-11所示。

　　文件1-7 included.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>include</title>

</head>

<body>

<%Thread.sleep(5000);%>

included.jsp内的中文

</body>

</html>

　　文件1-8 dynamicInclude.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"

　　pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>dynamicInclude page</title>

</head>

<body>

　　dynamicInclude.jsp内的中文

<jsp:include page="included.jsp" flush="true" />

</body>

</html>

　　（2）启动Tomcat服务器，访问地址“http://localhost:8080/day12/dynamicInclude.jsp”后，发现浏览器首先会显示dynamicInclude.jsp页面中的输出内容，等待5秒后，才会显示included.jsp页面的输出内容。说明被引用的资源included.jsp在当前JSP页面输出内容后才被调用。其最后显示结果如图1-14所示。

　　图1-14 dynamicInclude.jsp

（3）修改dynamicInclude.jsp文件，将<jsp:include>动作元素中的flush属性设置为false，刷新浏览器，再次访问地址“http://localhost:8080/day12/dynamicInclude.jsp”，这时，浏览器等待5秒后，将dynamicInclude.jsp和included.jsp页面的输出内容同时显示了出来。由此可见，Tomcat调用被引入的资源included.jsp时，并没有将当前JSP页面中已输出的内容刷新到客户端。

需要注意的是，虽然include指令和<jsp:include>标签都能够包含一个文件，但它们之间有很大的区别，具体如下：

<jsp:include>标签中要引入的资源和当前JSP页面是两个彼此独立的执行实体，即被动态引入的资源必须能够被Web容器独立执行。而include指令只能引入遵循JSP格式的文件，被引入文件与当前JSP文件需要共同合并才能翻译成一个Servlet源文件。

<jsp:include>标签中引入的资源是在运行时才包含的，而且只包含运行结果。而include指令引入的资源是在编译时期包含的，包含的是源代码。

7<jsp:include>标签运行原理与RequestDispatcher.include()方法类似，即被包含的页面不能改变响应状态码或者设置响应头，而include指令没有这方面的限制。

　　1.2.6.2 动态包含和静态包含的区别:

　　3. 案例分析

　　综合案例需要点击“导航条/分类”进行列表信息的展示，本案为了巩固重定向，在首页编写重定向代码直接跳转到ProductFindAllServlet进行查询，在Servlet中调用ProductService获得所有的查询结果，在service中调用ProductDao使用DBUtils进行查询，当查询完数据，在JSP页面进行数据显示。

　　4. 代码实现:

步骤1：创建项目，并导入jar包

步骤2：初始化数据库

　　#创建数据库和表:

　　create database day17_db;

　　#使用

　　use day17_db;

　　#创建商品表

　　CREATE TABLE `product` (

　　`pid` varchar(32) primary key,

　　`pname` varchar(50) DEFAULT NULL,#商品名称

　　`market_price` double DEFAULT NULL,#商场价

　　`shop_price` double DEFAULT NULL,#商城价

　　`pimage` varchar(200) DEFAULT NULL,#商品图片路径

　　`pdate` date DEFAULT NULL,#上架时间

　　`is_hot` int(11) DEFAULT NULL,#是否热门：0=不热门,1=热门

　　`pdesc` varchar(255) DEFAULT NULL,#商品描述

　　`pflag` int(11) DEFAULT 0,#商品标记：0=未下架(默认值),1=已经下架

　　`cid` varchar(32) DEFAULT NULL#分类id

　　) ;

步骤3：导入工具类和c3p0配置文件，并修改数据库

步骤4：编写JavaBean，并提供相应构造方法，以及toString()方法

　　public class Product {

　　private String pid;

　　private String pname;

　　private Double market_price;

　　private Double shop_price;

　　private String pimage;

　　private Date pdate;

　　private Integer is_hot; // 0 不是热门 1：热门

　　private String pdesc;

　　private Integer pflag; // 0 未下架 1：已经下架

　　private String cid;

　　…

　　}

步骤5：dao层实现

　　public class ProductDao {

　　/**

　　* 查询所有商品

　　* @return

public List<Product> findAll(){

　　try {

　　QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

　　String sql = "select * from product";

　　Object[] params = {};

return queryRunner.query(sql, new BeanListHandler<Product>(Product.class), params);

　　throw new RuntimeException(e);

　　}

步骤6：service层实现

　　public class ProductService {

　　/**

　　* 查询所有商品

　　* @return

public List<Product> findAll(){

　　ProductDao productDao = new ProductDao();

　　return productDao.findAll();

　　}

步骤7：首页编写

<%-- 重定向到查询所有servlet --%>

　　response.sendRedirect("/day11_findall/productFindAllServlet");

步骤8：servlet编写

<servlet-name>ProductFindAllServlet</servlet-name>

<servlet-class>cn.com.javahelp.web.servlet.ProductFindAllServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>ProductFindAllServlet</servlet-name>

<url-pattern>/productFindAllServlet</url-pattern>

</servlet-mapping>

　　代码实现

　　public class ProductFindAllServlet extends HttpServlet {

　　public void doGet(HttpServletRequest request, HttpServletResponse response)

　　throws ServletException, IOException {

　　//1 获得数据，并封装（本案例没有）

　　//2 调用service进行查询所有

　　ProductService productService = new ProductService();

List<Product> allProduct = productService.findAll();

　　//3.1 将查询结果存放在request作用域（查询数据当前有效）

　　request.setAttribute("allProduct", allProduct);

　　//3.2 请求转发到jsp（jsp可以使用request作用域的数据）

　　request.getRequestDispatcher("/product_list.jsp").forward(request, response);

　　}

　　…

　　}

步骤9：拷贝jsp页面，显示具体信息

<%-- 列表 start --%>

List<Product> allProduct = (List<Product>)request.getAttribute("allProduct");

　　for(Product p : allProduct){

out.write("<div>");

out.write("<a href='product_info.htm'>");

out.write("<img src='"+p.getPimage()+"' width='170' height='170' style='display: inline-block;'>");

out.write("</a>");

out.write("<a href='product_info.html' style='color:green'>"+p.getPname()+"</a>");

out.write("商城价：¥"+p.getShop_price()+"");

out.write("</div>");

　　}

<%-- 列表 end --%>

　　第2章总结

网站系统jsp模板信息模板源码

1、本网站名称：源码村资源网
2、本站永久网址：https://www.yuanmacun.com
3、本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长进行删除处理。
4、本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5、本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6、本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。
源码村资源网 » 网站系统jsp模板(jsp网站设计)

源码村长

分享到：

源码村长

1 评论

发表评论

源码村长

相关推荐

1 评论

发表评论