第三部分_JSP详解续

第二部分遗留了一个问题，就是在server.xml中配置的reloadable="true"的含义？

　　在MyEclipse中对于一个类保存即编译，不用显示地编译，编译之后要求服务器重启，就是reloadable为true的含义。

使用Servlet生成静态页面的流程：

浏览器（客户端）发出请求，服务器（Tomcat）接收请求，调用生成好的class文件，并把执行结果以html代码的形式发送给浏览器（即客户端）。

使用JSP

在webRoot目录下新建一个JSP页面（New->JSP(Advanced Templates)）：test.jsp，在该文件的body标签中添加如下代码：

<body>
    <h1>Hello World</h1>
    <%= new java.util.Date().toLocaleString() %>
    <%System.out.println(new java.util.Date().toLocaleString()); %>
</body>

浏览器中访问http://localhost:8080/test/test.jsp，可以得到和第二部分中的Servlet一样的效果，总结一下就是：Servlet是嵌套了HTML代码的Java类，而JSP是嵌套了一些Java代码的HTML文件，但两者本质上是一样的，Servlet能完成的事情JSP都可以完成，反之亦然。不过是JSP省去了配置web.xml文件这个步骤。

1、表单的使用

为了支持中文，将jsp文件中的pageEncoding置为"UTF-8"，即pageEncoding="UTF-8"。编写代码如下：

<body>
    	<form action="/test/SecondServlet"> 
  	用户：<input type = "text" name = "username" size = "20"><br>
  	密码：<input type = "password" name = "password" size = "20"><br>
  	<input type = "submit" value = "提交">   <input type = "reset" value = "重置">
  	</form>
</body>

下面主要对表单的action做下说明：它表示当点击鼠标提交按钮时提交到哪里。下面我们编写对于SecondServlet这个资源的处理。我们放弃之前纯手工的方式，采用MyEclipse给我们提供的自动化的功能：在com.test.servlet包下面new一个Servlet，命名为SecondServlet，继承方法只保留doGet()和doPost()，点击next，其默认的映射URL为/servlet/SecondServlet，为了方便我们将其更改为/SecondServlet，删掉Display Name和Description，点击finish，切换到web.xml视图，可以看到相应的信息已经如愿添加进来：

<servlet>
	<servlet-name>MyServlet</servlet-name>
	<servlet-class>com.test.servlet.MyServlet</servlet-class>
</servlet>
  <servlet>
    <servlet-name>SecondServlet</servlet-name>
    <servlet-class>com.test.servlet.SecondServlet</servlet-class>
  </servlet>

 
<servlet-mapping>
	<servlet-name>MyServlet</servlet-name>
	<url-pattern>/MyServ</url-pattern>
</servlet-mapping>
  <servlet-mapping>
    <servlet-name>SecondServlet</servlet-name>
    <url-pattern>/SecondServlet</url-pattern>
  </servlet-mapping>

切换到SecondServlet.java文件，其中有很多额外的注释和基础代码，我们将其删掉，形成下面的样子：

package com.test.servlet;

import java.io.IOException;
import java.io.PrintWriter;

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

public class SecondServlet extends HttpServlet
{

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

	}

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

}

下面我们编写代码，使得SecondServlet实现一个功能：将客户在test.jsp中填入的用户名和密码，SecondServlet获取它，并且在一个jsp页面显示出来。如此便完成了一个简单的客户端和服务器端的交互。代码编写如下：

package com.test.servlet;

import java.io.IOException;
import java.io.PrintWriter;

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

public class SecondServlet extends HttpServlet
{

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

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

	public void process(HttpServletRequest request, HttpServletResponse response)
		throws ServletException, IOException
	{
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		
		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		
		out.println("<HTML><HEAD><TITLE>Result</TITLE></HEAD>");
		out.println("<BODY>");
		out.println(username + "<br>");
		out.println(password);
		out.println("</BODY></HTML>");
	}
}

重启Tomcat服务器，浏览器中键入http://localhost:8080/test/test.jsp，输入用户名hello和密码world，页面自动跳转到http://localhost:8080/test/SecondServlet?username=hello&password=world。

此外，表单默认的提交方式是get，当然我们也可以采取post方式:

<form action="/test/SecondServlet" method="post">

这样页面跳转的时候地址栏为：http://localhost:8080/test/SecondServlet，这就是采用get/post提交的表象的区别。

Get与Post的区别

  • 处理方式不一样（协议本身规定的）
  • 处理的方法不一样
  • 地址栏呈现的结果不一样

2、JSP与Servlet的生成方式：

Servlet首先被编译为class文件，然后由服务器调用。

JSP首先被转化为Servlet（Java文件），然后再被编译为class文件，最后由服务器调用处理。

如何验证这一点？进入Tomcat下面的目录：D:\Program Files\apache-tomcat-6.0.44\work\Catalina\localhost\test\org\apache\jsp，可以看到test_jsp.java。

那么既然有了Servlet，为什么需要JSP，这是因为用JSP写的很简单的代码，用Servlet写会变得很复杂，看看test_jsp.java可以很直观的理解这一点。

3、编写稍复杂的Servlet

在com.test.servlet下新建一个servlet，命名为ThirdServlet，建立过程与SecondServlet如出一辙。这时候web.xml中会自动增添相关的配置。ThirdServlet.java源码如下：

package com.test.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Random;

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

public class ThirdServlet extends HttpServlet
{
	private static String[] responses = { "Yes", "No", "Maybe",
			"Later", "It is your call", "Not a chance"};
	
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException
	{
		process(request, response);
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException
	{
		process(request, response);
	}
	public void process(HttpServletRequest request, HttpServletResponse response)
		throws ServletException, IOException
	{
		String reply = generateReply();
		
		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		out.println("<HTML><HEAD><TITLE>Decision Maker</TITLE></HEAD>");
		out.println("<BODY>");
		out.println("<H1>Your answer is: '" + reply + "'<H1>");
		out.println("</BODY></HTML>");
	}
	
	private String generateReply()
	{
		// randomly pick a response
		int  respIndex = new Random().nextInt(responses.length);
		// return the response back to the caller
		return responses[respIndex];
	}
	
}

重启Tomcat，在http://localhost:8080/test/ThirdServlet中不断刷新，会得到随机的显示。

4、用JSP代替SecondServlet

在WebRoot中new一个名为result的jsp，接着对test.jsp中的表单做出更改：

<form action="result.jsp" method="get">

在result.jsp的body中添加如下代码：

<body>
    <%String username = request.getParameter("username");
      String password = request.getParameter("password");
     %>
     username: <%= username %><br>
     password: <%= password %>
 </body>

进入http://localhost:8080/test/test.jsp，填入信息hello、world，自动跳转到http://localhost:8080/test/result.jsp?username=hello&password=world　

几点说明：

  • request和response是JSP中的九个默认对象中的两个，不需要声明，直接可以使用，类比Java中的lang包不需要导入一样，它们使用太频繁，导致这种局面。
  • username: <%= username %>，其中<%= %>是JSP表达式，用脚本的方式也可以： username: <% out.print(username);
  • JSP中倒包：<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>，多个包的话用逗号分隔。

5、巩固JSP表达式

建立third.jsp，<body>标签中的代码如下：

  <body>
  	<%Calendar calendar = Calendar.getInstance(); 
  	int currentHour = calendar.get(Calendar.HOUR_OF_DAY);
  	%>
  	<% if(currentHour < 12){%>
  	Good Morning!
  	<%}else if(currentHour > 12 && currentHour < 18){ %>
  	Good Afternoon!
  	<%}else{ %>
  	Good Evening!
  	<%} %>
  </body>

在浏览器中刷新http://localhost:8080/test/third.jsp，可以得到当前系统时间是早上/中午/晚上。 

JavaServer Pages(JSP)语法及内置对象

  • JSP简介

　　在传统的网页HTML文件（*.htm，*.html）中假如Java程序片段（Scriptlet）和JSP标签，就构成了JSP网页。

　　Java程序片段可以操作数据库、重定向网页以及发送E-mail等，实现建立动态网站所需要的功能。

　　所有程序操作都在服务器端执行，网络上传送给客户端的仅是得到的结果，这样大大降低了对客户浏览器的要求，即使客户浏览器不支持Java，也可以访问JSP网页。

　　JSP文件结构及主要标签

<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="java.util.*" %>
...
<HTML>
	<BODY>
	其他HTML语言
	<%
	   符合Java语法的Java语句
	%>
	其他HTML语言
	
	</BODY>
</HTML>

　　　JSP示例 

　　JSP执行过程

　　JSP示例

  • JSP语法概述

　　JSP原始代码中包含了JSP元素和Template（模板）data两类

　　Template data指的是JSP引擎不处理的部分，即标记<%......%>以外的部分，例如代码中的HTML的内容等，这些数据会直接传送到客户端的浏览器

　　JSP元素则是指将由JSP引擎直接处理的部分，这一部分必须符合Java语法，否则会导致编译错误

　　JSP语法分为三种不同的类型：

　　编译器指令（DIRECTIVE）例如：<%@ page import="java.io.*"%>，编译器指令包括包含指令、页指令和taglib指令，它们包含在<%@ %>卷标里，两个主要的指令是page与include。

　　脚本语法（SCRIPTING）：包括HTML注释（<!--comments-->，这种注释发送到客户端，但不直接显示，在源代码中可以看到）、隐藏注释（<%--comments--%>，不发生到客户端，供程序员查看使用的）、声明、表达式、脚本段

　　动作语法（ACTION）例如：<jsp:forward>，<jsp:getProperty>，<jsp:setProperty>，<jsp:include>和<jsp:useBean>

　　JSP语法格式：<%! declaration;[declaration;]... %>，看下面的实例：

<body>
	<center>
		<%! Data date = new Date(); %>
		<%! int a, b, c; %>
		<% a = 12; b = a; c = a + b; %>
		<font color="blue">
		<%=date.toString()%>
		</font><br>
		<b>a=<%= a %></b><br>
		<b>b=<%= b %></b><br>
		<b>c=<%= c %></b><br>
	</center>
</body>

当然，我们把上面的两个！去掉也不影响执行结果，那么两者的区别在哪里呢？可以通过查看它生成的servlet代码，可以得到结论：带！的变量生成变量的位置是成员变量，不加！就是局部变量　

　　表达式：

　　用于在页面上输出信息，语法格式：<%= expression %>

　　脚本段：

　　JSP语法格式：<% code fragment %>，参见一个jsp实例：

<%@ page language="java" pageEncoding="gb2312"%>
<%! int condition; %>
<html>
	<head>
	<title> test </title>
	</head>
	<body>
<%
	condition = 1;
	switch(condition)
	{
		case 0:
		out.println("You must select condition 0!"+"<br>");
		break;
		case 1:
		out.println("You must select condition 1!"+"<br>");
		break;
		case 2:
		out.println("You must select condition 2!"+"<br>");
		break;
		default:
		out.println("You select not in \"0, 1, 2\", select again!"+"<br>");
		break;
	}
%>
　　　　    </body>
</html>

　　包含指令：

　　include指令：向当前页中插入一个静态文件的内容。JSP语法格式：<%@ include file="realativeURL">，如：

<%--a.jsp包含b.jsp-->
<%@ page language="java" pageEncoding="gb2312"%>
<html>
	<head>
	<title> test </title>
	</head>
	<body bgcolor="white">
	<font color="blue">
	The current date and time are
	<%@ include file="a.jsp" %>
	</font>
	</body>
</html>

<%--b.jsp-->
<%@ page import="java.util.*" %>
<%=new java.util.Date().toLocaleString() %>

　　　Page指令：

　　　Page指令用于定义JSP文件中的全局属性，语法格式：<%@ page [language="java"] [extends="package.class"] [import="{package.class | package.*}, ..."] [session="true | false"] [isThreadSafe="true | false"] [errorPage = "relativeURL"] [contentType = "mimeType[;charset=characterSet]" | "text/html;charset=ISO-8859-1"] [isErrorPage="true | false"] %>，其中重要的属性有：

　　1.language="java"声明脚本语言的种类，目前只能使用"java"

　　2.import="{package.class | package.*},..."需要导入的Java包的列表，这些包作用于程序段，表达式，以及声明。下面的包在JSP编译时已经导入了，所以不需要再指明了：java.lang.* java.servlet.* javax.servlet.jsp.* javax.servlet.http.*

　　3.errorPage="realativeURL"设置处理异常事件的JSP文件

　　4.isErrorPage="true | false"设置此页是否为出错页，如果被设置为true，你就能使用exception对象

　　taglib指令：

　　JSP语法格式：<%@ taglib uri="URIToTagLibrary" prefix="tagPrefix" %>，用于引入定制标签库

　　jsp:forward

<%--a.jsp跳转到b.jsp-->
<%@ page contentType="text/html";charset=gb2312 pageEncoding="gb2312"%>
<html>
	<head>
	<title> test </title>
	</head>
	<body >
		<jsp:forward page="b.jsp">
			<jsp:param name="userName" value="riso"/>
		</jsp:forward>
		<%System.out.println("此段代码不会被执行"); %>
	</body>
</html>

<%--b.jsp-->
<%@ page contentType="text/html";charset=gb2312 pageEncoding="gb2312"%>
<%
	String userName=request.getParameter("userName");
	String outStr="谢谢光临!";
	outStr += useName;
	out.println(outStr);
%>

　　jsp:include

　　包含一个静态或动态文件

<%--a.jsp include b.jsp-->
<%@ page contentType="text/html";charset=gb2312 pageEncoding="gb2312"%>
<html>
	<head>
	<title> test </title>
	</head>
	<body >
		<jsp:include page="b.jsp">
			<jsp:param name="User" value="hello"/>
		</jsp:include>
	</body>
</html>

<%--b.jsp-->
<%
	String username;
	username=request.getParameter("User");
	out.println("Username is"+username+"<br>");
%>
  •  JSP内置对象

　　JSP有以下九种内置对象，包括：request（请求对象），response（响应对象），pageContext（页面上下文对象），session（会话对象），application（应用程序对象），out（输出对象），config（配置对象），page（页面对象），exception（异常对象）。

　　"request"对象代表的是来自客户端的请求，例如我们在form表单中填写的信息等，是最常用的对象。关于它的方法使用较多的是getParameter、getParameterNames和getParameterValues，通过调用这几个方法来获取请求对象中所包含的参数的值。

　　"response"对象代表的是对客户端的响应，也就说可以通过"response"对象来组织发送到客户端的数据。但是由于组织方式比较底层，所以不建议普通读者使用，需要向客户端发送文字时直接使用"out"对象即可。　

　　"session"对象代表服务器与客户端所建立的会话，当需要在不同的JSP页面中保留客户信息的情况下使用，比如在线购物，客户轨迹跟踪等。HTTP是无状态（stateless）协议，Web Server对每一个客户端请求都没有历史记忆，这就导致了session的产生，用来保存客户端状态信息。

　　下面的实例展示session的用法，分别在WebRoot下建立三个jsp文件logon.jsp，logon_session.jsp，check_session.jsp：

<%--logon.jsp-->
<body>
    <form action="logon_session.jsp">
    	姓名
    	<input type="text" name="userName" >
    	<input type="submit" value="提交">
	</form>
</body>

<%--logon_session.jsp-->
 <body>
    <% 
    	String Name = request.getParameter("userName"); 
    	session.setAttribute("LogName", Name); 
    %> 
  	你的名字"<%=Name %>"已经写入session
  	<br>
  	<a href='check_session.jsp'>check</a>
</body>

<%--check_session.jsp-->
<body>
   <%
   	String yourName = (String)session.getAttribute("LogName");
   	if(yourName == null)
   	{
   	%>您还未登录
   	<%
   	}else
   	{
   	%>
   	"<%=yourName %>"已经登录
   	<%
   	} 	
   %>
</body>

　　aplication对象：负责提供应用程序在服务器中运行时的一些全局信息，常用的方法有getMimeType，getRealPath等。

　　应用实例：实现一个网页计数器，随刷新次数递增

<%--用application对象实现网页计数器--%>
<%@ page contentType="text/html;charset=gb2312" pageEncoding="gb2312"%>
<html>
	<head><title>网页计数器</title><head>
<body>
<%  if (application.getAttribute("counter")==null)
	applition.setAttribute("counter","1");
	else{
		String strnum=null;
		strnum=application.getAttribute("counter").toString();
		int icount=0;
		icount=Integer.valueOf(strnum).intValue();
		icount++;
		application.setAttribute("counter",Integer.toString(icount));
		}  %>
您是第<%=application.getAttribute("counter")%>位访问者！
</body>
</html>

因为application是全局对象，所以关闭浏览器后，counter保持递增的值，而将application全部改为session后，那么各个客户端和浏览器之间counter的值互不影响。

　　out对象：代表了向客户端发送数据的对象，与"response"对象不同，通过"out"对象发送的内容将是浏览器需要显示地内容，是文本一级的，可以通过"out"对象直接向客户端写一个由程序动态生成的HTML文件。常用的方法除了print和println之外，还包括clear、clearBuffer、flush、getBufferSize和getRemaining，这是因为"out"对象内部包含了一个缓冲区，所以需要一些对缓冲区进行操作的方法。

　　下面看一个实例：

<%--logon.jsp-->
<body>
<form method="POST" action="post.jsp">
 <p align="center">用户登录 
<p align="center">
用户名：<input type="text" name="User" size="20">       
密码：<input type="password" name="pwd" size="20"><br> <br>   
浏览器类型: <input type="radio" name="radio" value="ie" checked >IE     
 	    <input type="radio" name="radio" value="ns">Netscape <br> 
 资料选项：
  <input type="checkbox" name="check1" value="ON" checked>标题
  <input type="checkbox" name="check2" value="ON">详细 
  <input type="hidden" name="hidden" value="transPara">  
  </p><p align="center">
  <input type="submit" value=" 提交">   
  <input type="reset" value="全部重写"></p>   
</form>
</body>      

<%--post.jsp-->
<body>
<%
	out.println("用户名："+request.getParameter("User")+"<br>");
	out.println("密码："+request.getParameter("pwd")+"<br>");
	out.println("浏览器："+request.getParameter("radio")+"<br>");	
	out.println("标题："+request.getParameter("check1")+"<br>");
	out.println("详细："+request.getParameter("check2")+"<br>");
	out.println("隐含："+request.getParameter("hidden")+"<br>");
	out.println("getContentLength()="+request.getContentLength()+"<br>");	
	out.println("getContentType()="+request.getContentType()+"<br>");
	out.println("getRequestURI()="+request.getRequestURI()+"<br>");
	out.println("getServerPort()="+request.getServerPort()+"<br>");
	out.println("getServerName()="+request.getServerName()+"<br>");
	out.println("getProtocol()="+request.getProtocol()+"<br>");
	out.println("getRemoteAddr()="+request.getRemoteAddr()+"<br>");
	out.println("getHeaderNames()="+request.getHeaderNames()+"<br>");
	out.println("getMethod()="+request.getMethod()+"<br>");
	out.println("getServletPath()="+request.getServletPath()+"<br>");
	out.println("isRequestedSessionIdValid()="+request.isRequestedSessionIdValid()+
              "<br>");
%>
</body>

浏览器运行结果：

 

使用JavaBean

  • 了解JavaBean的概念
  • 了解JavaBean的规范
  • 掌握JSP访问JavaBean的语法
  • 理解JavaBean的四种范围

JavaBean的概念：

　　JavaBean是一种可重复使用、且跨平台的软件组件。JavaBean可分为两种：一种是有用户界面（UI，User Interface）的JavaBean；还有一种是没有用户界面，主要负责处理事务（如数据运算，操纵数据库）的JavaBean。JSP通常访问的是后一种JavBean。

　　JSP与JavaBean搭配使用的优点是：使得HTML与Java程序分离，这样便于维护代码。如果把所有的程序代码都写到JSP网页中，会使得代码繁杂，难以维护；可以降低开发JSP网页人员对Java编程能力的要求；JSP侧重于生成动态网页，事务处理由JavaBean来完成，这样可以充分利用JavaBean组件的可重用性的特点，提高开发网站的效率。

　　JavaBean的特征：

  • JavaBean是一个公共的（public）类
  • JavaBean有一个不带参数的构造方法
  • JavaBean通过setXXX方法设置属性，通过getXXX方法获取属性

 JSP访问JavaBean的语法

  1. 导入JavaBean类，通过<%@ page import %>指令导入，例如<%@ page import="mypack.CounterBean" %>
  2. 声明JavaBean对象，通过<jsp:useBean>标签声明，例如：<jsp:useBean id="myBean" class="mypack.CounterBean" scope="session"/> <jsp:useBean id="myBean_1" class="mypack.CounterBean" scope="session"/>
  3. 访问JavaBean属性，id="beanInstanceName"，大小写敏感。id的值作为引用名。JSP提供了访问JavaBean属性的标签，如果要将JavaBean的某个属性输出到网页上，可以用<jsp:getProperty>标签，例如：<jsp:getProperty name="myBean" property="count">；如果要给JavaBean的某个属性赋值，可以用<jsp:setProperty>标签，例如：<jsp:setProperty name="myBean" property="count" value="0" />

JavaBean的范围

　　scope属性决定了JavaBean对象存在的范围，scope的可选值包括：page（默认值）、request、session、application，这些范围从小到大排列。

  • JavaBean在page范围内：客户每次请求JSP页面时，都会创建一个JavaBean对象。JavaBean对象的有效范围是客户请求访问的当前JSP网页。JavaBean对象在以下两种情况下都会结束生命期：客户请求访问的当前JSP网页通过<forward>标签将请求转发到另一个文件；客户请求访问的当前JSP页面执行完毕并向客户端发回响应。
  • JavaBean在request范围内：客户每次请求访问JSP页面时，都会创建新的JavaBean对象。JavaBean对象的有效范围为：客户请求的当前JSP网页；和当前JSP网页共享同一个客户请求的网页，即当前JSP网页中<%@ include>指令以及<forward>标记包含的其他JSP文件；当所有共享同一个客户请求的JSP页面执行完毕并向客户端发回响应时，JavaBean对象结束生命周期。
  • JavaBean在session范围内：JavaBean对象被创建后，它存在于整个session的生存周期内，同一个session中的JSP文件共享这个JavaBean对象。JavaBean对象作为属性保存在HttpSession对象中，属性名为JavaBean的id，属性值为JavaBean对象。除了可以通过JavaBean的id直接引用JavaBean对象外，也可以通过HttpSession.getAttribute()方法取得JavaBean对象，例如：CounterBean obj=(CounterBean)session.getAttribute("myBean");
  • JavaBean在application范围内：JavaBean在对象被创建后，它存在于整个Web应用得生命周期内，Web应用得所有JSP文件都能共享同一个JavaBean对象。JavaBean对象作为属性保存在application对象中，属性名为JavaBean的id，属性值为JavaBean对象。除了可以通过JavaBean的id直接引用JavaBean对象外，也可以通过application.getAttribute()方法取得JavaBean对象，例如：CounterBean obj=(CounterBean)application.getAttribute("myBean");

一个练习题：为什么JavaBean必须遵守特定的规范，比如对于CounterBean的count属性，必须提供getCount()和setCount()方法，而不能随心所欲的定义为getCOunt()、insertcount()等等其他名字？

答案：当所有JavaBean遵守相同的规范，<jsp:getProperty>和<jsp:setProperty>标记就能自动根据JavaBean的属性来推断出它的get和set访问方法。

下面给出一个关于JavaBean的实例：

package com.test.servlet;

public class Student
{
	private long classNo;

	private String name; 

	private int age;

	private boolean sexy;

	public Student() // 构造函数
	{
		classNo = 970431;
		name = "ZZZl";
		age = 34;
		sexy = true;
	}

	/**
	 * @return 返回 age。
	 */
	public int getAge()
	{
		return age;
	}

	/**
	 * @param age
	 *            要设置的 age。
	 */
	public void setAge(int age)
	{
		this.age = age;
	}

	/**
	 * @return 返回 classNo。
	 */
	public long getClassNo()
	{
		return classNo;
	}

	/**
	 * @param classNo
	 *            要设置的 classNo。
	 */
	public void setClassNo(long classNo)
	{
		this.classNo = classNo;
	}

	/**
	 * @return 返回 name。
	 */
	public String getName()
	{
		return name;
	}

	/**
	 * @param name
	 *            要设置的 name。
	 */
	public void setName(String name)
	{
		this.name = name;
	}

	/**
	 * @return 返回 sexy。
	 */
	public boolean isSexy() // 对于返回值为boolean类型的get方法也可以用is代替
	{
		return sexy;
	}

	/**
	 * @param sexy
	 *            要设置的 sexy。
	 */
	public void setSexy(boolean sexy)
	{
		this.sexy = sexy;
	}
}

<%@ page language="java" pageEncoding="gb2312" %>
<!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">
<html>
<body>  
<%-- 引用自己编写的javaBean生成的bean组件 --%>
<jsp:useBean id="student" scope="application" class="com.test.servlet.Student"/> 
<%=student.getName()%><br>
<% student.setName("cong"); %> 

<%-- 用getProperty动作来返回bean组件的属性值 --%> 
<jsp:getProperty name="student" property="classNo" /> <br>
<jsp:getProperty name="student" property="name" /> <br>
<jsp:getProperty name="student" property="age" /> <br>
<jsp:getProperty name="student" property="sexy" /> <br>
<%-- 取属性值 --%>
<%=student.getClassNo() %> <br>
<%=student.getName() %> <br>
<%=student.getAge() %> <br>
<%=student.isSexy() %> <br>


</body>
</html>

浏览器中输出结果如下：

cong
970431 
cong 
34 
true 
970431 
cong 
34 
true

　　

　

 

posted @ 2015-07-02 21:41  Code_Rush  阅读(324)  评论(0)  编辑  收藏  举报