1. logic:empty和logic:notEmpty
   logic:empty标签判断脚本变量是否为null，是否是一个空的字符串(长度为0)，是否是一个空的collection或map(调用isEmpty()方法来判断)。logic:notEmpty标签类似。
   

   <logic:empty name="myBean">    The bean is missing  </logic:empty>  <logic:notEmpty name="myBean">    The bean is not missing  </logic:notEmpty>

   上段代码表示当一个名为myBean的bean在所有的scope中都不存在时，输出The bean is missing；存在的话输出The bean is not missing。
   此标签有三个属性：name、property和scope。
   
2. logic:equal, logic:notEqual, logic:lessThan, logic:greaterThan,logic:lessEqual, and logic:greaterEqual
   这堆logic:*equal*标签从名字上就能知道意思，它们使用起来有些笨拙。
   有如下属性：name、property、scope、value、cookie、header、parameter。
   

   <logic:equal name="bean" property="doubleProperty" value="<%= doub1 %>">     equal  </logic:equal>  <logic:greaterEqual name="bean" property="doubleProperty" value="<%= doub1 %>">     greaterEqual  </logic:greaterEqual>

   
   
3. logic:present和logic:notPresent
   检查header、request parameter、cookie、JavaBean或JavaBean propertie是否存在且不等于null。另外还可以检查当前用户的身份，使用属性user和role。
   其它的属性有：name、property、scope、cookie、header、parameter。
   

   <logic:notPresent name="myBean"  property="prop"  scope="page">  The bean property bean.prop is present  </logic:notPresent>

   上段代码检查在page作用域内名为myBean的bean是否有一个prop属性。
   
4. logic:match和logic:notMatch
   比较两字符串是否相等，可以比较字符串的开始的、结尾的或其中的某个部分。
   location属性：指定从某个位置开始进行比较。
   其它的属性有：name、property、scope、value、cookie、header、parameter。
   下面的例子是检查浏览器类型：
   

   <logic:match header="User-Agent" value="Mozilla">   Mozilla!  </logic:match>  <logic:notMatch header="User-Agent" value="Mozilla">   Not Mozilla :(  </logic:notMatch>

   
   检查bean属性是否匹配"hello world"字符串：
   

   <logic:match name="bean" property="stringProperty" value="hello world">   Hello World!  </logic:match>  <logic:notMatch name="bean" property="stringProperty" value="hello world">   I'm so sad and lonely.  </logic:notMatch>

   
   检查名为"name"的请求参数是否是"xyz"的子字符串，但是子字符串必须从"xyz"的索引位置1开始(也就是说子字符串必须是"y"或"yz")：
   

   <logic:match parameter="name"  value="xyz"  location="1">       The parameter name is a sub-string of the string xyz from index 1  </logic:match>

二.) 循环类型

logic:iterate
重复嵌套在此标签体内的指定集合的元素，集合必须为如下类型：array 、Collection(包括ArrayList和Vector）、Enumeration、Iterator、Map(包括HashMap、Hashtable和TreeMap)。例如：

<logic:iterate id="employee" name="department" property="employees" scope= "request"> …  <bean:write name="employee" property="username" /> …  <bean:write name="employee" property="name" /> …  <bean:write name="employee" property="phone" /> …  </logic:iterate>

上面的代码迭代了一个employee的集合，是department属性employees的一个集合，作用域为request。

为了输出第五个到第十个employee，需要使用length和offset属性：

<logic:iterate id="employee" name="department" property="employees" scope= "request" length="10" offset="5"> …  <bean:write name="employee" property="username" /> …  <bean:write name="employee" property="name" /> …  <bean:write name="employee" property="phone" /> …  </logic:iterate>

 你可以定义一个变量保存当前的索引值：      

<ol>  <logic:iterate id="element" name="bean" property="stringArray" indexId="index">  <li>  <em>  <bean:write name="element"/>  </em>&nbsp;  [<bean:write name="index"/>]</li>  </logic:iterate>  </ol>

三.) 转发/重定向类型

logic:forward和logic:redirect
logic:forward标签和jsp:forward标签和相似，但它可以使用global forward中的一个ActionForward： 

<logic:forward name="login" /> ----------------------------------------------------------------------------------------------------------------------------------  与上面相关的global forward中的代码：  <global-forwards>  <forward name="login" path="/loginForm.jsp"/>  </global-forwards>

logic:redirect标签和上面的标签类似，但它默认调用的方法是response.sendRedirect()，取代了上面的requestDispatcher.forward()。最大的不同是它支持所有html:link标签的属性，所以你能够指定request参数：

<logic:redirect name="login" paramId="employeeId" paramName="employee" property="id" />

作为一个Java Web开发人员，你可能已经对Web应用程序的目录结构很熟悉了（见图1）。在WEB-INF/classes目录下放置了servlet类，在WEB-INF/lib下是Java档案文件，如HTML和图片文件的静态资源直接放在应用程序目录下（或者在应用程序目录下的任何子目录中）。例如，所有图片文件都放在图片目录中（见图1）。JSP页面也放在应用程序目录中。

图1. 一个 Servlet/JSP 应用程序的目录结构

幸运的是，放在WEB-INF目录下的资源是安全的。用户不可以简单地在浏览器的Location或Address中输入一个URL来调用它。

这就是为什么许多程序员都把他们的资源文件（如果它们是和应用程序放在一起的话）放在WEB-INF目录中的原因。WEB-INF之外的任何资源都可以通过输入URL来查看。HTML文件和JSP文件一般都会被调用，所以它们通常存储在WEB-INF之外。

然而，你可能想限制对WEB-INF目录之外的文件的访问。你可以用三种方法：通过运用referer HTTP request header（是“referer”，不是“referrer”）；通过检查用户的session对象中的一个属性；或者通过将那些资源放在WEB-INF中，并在适当的时候参照它们。下面是运用这三种方法的指南。

运用Referer HTTP Request Header
Referer HTTP request header指定了一个URI (Uniform Resource Identifier)，该URI包含链接到被请求资源的页面的地址。例如，下面是对一个叫做myPage1.jsp的JSP页面的请求，该页面来自一个叫做Login.jsp的文件：

http://domainName/appName/Login.jsp

如果直接在Web浏览器的Address或Location中输入URL来调用myPage1.jsp，就不会有一个referer header。

下面的例子运用了一个叫做DisplayRequestHeaders.jsp的JSP页面：

<%@ page import="java.util.Enumeration" %> <% Enumeration headers = request.getHeaderNames(); while (headers.hasMoreElements()) { String header = (String) headers.nextElement(); out.println(header + ":" + request.getHeader(header) + "<br>"); } %>

如果你直接将URL输入到浏览器的Address或Location来调用这个页面，结果如下：

accept:*/* accept-language:en-us accept-encoding:gzip, deflate user-agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705) host:localhost:8080?connection:Keep-Alive cookie:JSESSIONID=65D28447DFE4F58D1D806EAA933E9DD7

然而，如果通过点击另一个页面（如Login.jsp）中的一个链接来请求DisplayRequestHeaders.jsp，你可以看到如下的结果：

accept:image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-excel, application/msword, application/vnd.ms-powerpoint, */* referer:http://localhost:8080/myJSPApp/Login.jsp accept-language:en-us accept-encoding:gzip, deflate user-agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705) host:localhost:8080 connection:Keep-Alive cookie:JSESSIONID=65D28447DFE4F58D1D806EAA933E9DD7

注意两者的主要区别是在第二个结果中出现了referer header。因此，如果你的应用程序规定，当你直接将URL输入到浏览器的Location或Address中来调用一个资源时，你不能看到这个资源（在这个例子中，就是myPage1.jsp），那么你可以把这个代码添加到myPage1.jsp的顶部：

if (request.getHeader("referer")==null) response.sendRedirect(somewhereElse);

其中somewhereElse是你想让用户进入的页面的URL。

或者，如果你想确信资源来自一个特定的URL，可以在前面的代码后面添加下面的代码：

if (request.getHeader("referer")==null) response.sendRedirect(somewhereElse); if (request.getHeader("referer")!=aURL) response.sendRedirect(somewhereElse);

然而，你需要注意，运用referer header只适合于简单的控制流管理。因为它依赖于来自用户的request headers，所以它并不是100%的安全。了解socket programming的聪明的用户常常可以确信有一个包含期望值的referer header。

检查一个Session对象的属性
另一种限制对一个特定页面的访问的方法就是通过检查用户的session对象中出现的一个特定的属性。例如，如果你想让ABC.jsp页面只能被登录后的用户看到，你可以在用户成功登录后，在用户session对象中设置一个叫做loggedIn的属性。然后在ABC.jsp页面的顶部，你可以查看loggedIn属性是否出现在用户的session对象中：

<% if (session.getAttribute("loggedIn")==null) { %> <jsp:forward page="Login.jsp"/> <% } else { %> display the page content here.

这种方法的缺点是你在每一页都需要额外的代码，而且还有另外的维护工作。更重要的是，受限制的页面需要参预session管理，而这正是你在一些应用程序中可能想避免的事情。

在WEB-INF目录下存储资源
在你不想让用户调用你的JSP页面时，第三种方法——将资源放在WEB-INF下——会很有用。实现Model 2结构的应用程序和Struts应用程序运用JSP页面作为Model-View-Controller中的View。这些JSP页面并不打算让用户从浏览器直接调用。作为替代，它们从控制器servlet内部来调用。对这些应用程序来说，将JSP页面放在WEB-INF目录外——就像许多程序员所做的那样——需要你添加额外的代码来限制对这些资源的直接访问。

另一方面，把它们放在WEB-INF中可以保证它们只能从那个应用程序的一个servlet来访问。但如果你决定把JSP页面存在WEB-INF中，你就需要知道如何参照这些页面。幸运的是，这并不难。做法如下。

通过运用一个RequestDispatcher对象，一个servlet可以包含（include）或转送（forward）一个JSP页面。下面的例子forward并include一个叫做Included.jsp的JSP页面：

RequestDispatcher rd = request.getRequestDispatcher("/WEB- INF/Included.jsp"); rd.forward(request, response);

但有时侯，你需要显示的是HTML文件，而不是JSP页面。在一些Web容器（containers）中，前面代码中的request dispatchers并不能用于静态的资源（如果静态资源不在WEB-INF下，它可以用）。对这些资源来说，你可以运用javax.servlet.ServletContext接口的getResourceAsStream方法。该方法的定义如下：

public java.io.InputStream getResourceAsStream(java.lang.String path)

要运用这个方法，你需要把一个路径传送到你想包含的静态资源。该方法返回一个InputStream。然后，你可以用InputStream的read方法来得到静态资源的内容。

例如，下面的这个JSP页面包含一个叫做getResourceContent的函数，你可以用它以字符串形式返回一个静态资源的内容：

<%@ page import="java.io.InputStream"%> <%! public String getResourceContent(InputStream in) { if (in==null) return null; StringBuffer sb = new StringBuffer(2048); try { int i = in.read(); while (i != -1) { sb.append((char)i); i = in.read(); } in.close(); } catch (Exception e) { } return sb.toString(); } %> <html> <head> <title> </title> </head> <body> <br> <% String path = "/WEB-INF/header.html"; InputStream in = application.getResourceAsStream(path); out.println(getResourceContent(in)); %> </body> </html>

注意，在JSP页面中，应用程序暗示的对象代表ServletContext对象。

该JSP页面显示了如何包含位于WEB-INF目录中的header.html文件的内容。如果你把header.html文件放在这儿，它就不能直接从浏览器调用。

通过运用一些缓冲策略，你可以优化JSP页面中的getResourceContent方法。在这里，我只是解释了得到放在WEB-INF目录下的一个静态资源的内容的方法。

你可以从一个servlet内部，也可以从一个JSP页面运用getResourceContent方法。从一个JSP页面，你可以运用指示符include，如下面的代码所示：

<%@ include file="/WEB-INF/header.html" %>

现在你应该了解了：你有三种不同的方法来保护你的资源，以及如何实现这些方法。

关于客户端重定向，你可以用Refresh metatag或JavaScript。下面我分别讲述这两种方法。

运用Refresh Metatag
Metatags比JavaScript容易。在一个页面已经显示了一段时间后，你可以用它们来把用户从这个页面引导开：

<META HTTP-EQUIV="Refresh" CONTENT="t;URL=differentURL">

t是在重定向前，浏览器将等待的秒数。

例如，下面的脚本在页面显示了三秒后，将浏览器重定向到http://www.brainysoftware.com。

<HTML> <HEAD> <TITLE>Client side redirection using the meta tag </TITLE> <META HTTP-EQUIV="Refresh" CONTENT="3;URL=http://www.brainysoftware.com"> </HEAD> <BODY> You will be redirected in 3 seconds. For now, relax and enjoy. </BODY> </HTML>

当t=0时，不会出现延迟。

该技术可以用于Netscape Navigator 3及更高版本，Internet Explorer 4及更高版本。

运用JavaScript
在运用metatag时，你的局限性很大，因为一些老的浏览器读不懂它。如果你担心这个问题，那么你可以用JavaScript。然而，如果用户浏览器不支持JavaScript，你还是会有问题。

要用JavaScript进行客户端重定向，运用定位对象（location object）：

<SCRIPT LANGUAGE="JavaScript"> location=differentURL </SCRIPT>

differentURL是浏览器被重新定向到的新的URL。下面的例子显示如何运用定位对象来重定向：

<HTML> <HEAD> <TITLE>Client-side redirection using JavaScript</TITLE> <SCRIPT LANGUAGE="JavaScript"> location='http://www.brainysoftware.com'; </SCRIPT> </HEAD> <BODY> You will be redirected to another page. For now, enjoy and relax. </BODY> </HTML>

同运用metatags一样，你可以用JavaScript来延迟重定向。运用setTimeout方法来实现这一点：

setTimeout("location='differentURL'", t);

t是用户被重定向到differentURL前的毫秒数。

下面的代码在5秒后将用户重定向到www.brainysoftware.com：

<HTML> <HEAD> <TITLE>Client-side redirection using JavaScript</TITLE> <SCRIPT LANGUAGE="JavaScript"> setTimeout("location= 'http://www.brainysoftware.com'", 5000); </SCRIPT> </HEAD> <BODY> Hello, you will be redirected in 5 seconds. Start counting now... </BODY> </HTML>

该技术可以用于Netscape Navigator 2及更高版本，Internet Explorer 3及更高版本。

预见不成功的重定向
每种技术都有缺点。metatags不能用于老的浏览器，如果浏览器不支持JavaScript，那么JavaScript就不能用。

所以在重定向用户时，你常常要预料到失败的情况。当自动的重定向失败时，用户必须点击一个链接，使他或她可以进入期望的地址。所以需要常发送这个链接，如下例所示：

<HTML> <HEAD> <TITLE>When redirection fails . . . </TITLE> <SCRIPT LANGUAGE="JavaScript"> setTimeout("location= 'http://www.brainysoftware.com'", 5000); </SCRIPT> </HEAD> <BODY> Click <A HREF="RedirectionURL">here</A> if you do not get redirected in 5 seconds. </BODY> </HTML>

重定向可以在服务器端进行，也可以在客户端（浏览器）进行。因为在servlet/JSP页面上有服务器端的代码，所以可以在服务器端进行重定向。客户端的重定向可以通过发送JavaScript代码或者传送到浏览器的HTML页面的元数据来完成。现在，让我们来看看两个服务器端重定向的技巧。

在servlet/JSP编程中，服务器端重定向可以通过下面两个方法来实现：运用javax.servlet.RequestDispatcher接口的forward方法，或者运用javax.servlet.http.HttpServletResponse接口的sendRedirect方法。

运用RequestDispatcher接口的Forward方法
要运用RequestDispatcher接口的forward方法，首先要得到一个RequestDispatcher对象。servlet技术提供了三种方式来得到它：

1. 通过运用javax.servlet.ServletContext接口的getRequestDispatcher方法，将一个包含路径的String传递给其它资源。该路径是相对于ServletContext的根路径的。

2. 通过运用javax.servlet.ServletRequest接口的getRequestDispatcher方法，将一个包含路径的String传递到其它资源。该路径是相对于当前的HTTP请求的。

3. 通过运用javax.servlet.ServletContext接口的getNamedDispatcher方法，传递一个包含其它资源名字的String。

在得到RequestDispatcher对象后，运用forward方法就很容易了。forward方法的定义如下：

public void forward(javax.servlet.ServletRequest request, javax.servlet.ServletResponse response) throws javax.servlet.ServletException, java.io.IOException

但要注意，你只有在客户端没有输出时才可以调用forward方法。如果当前页面的缓冲区（buffer）不是空的，那么你在调用forward方法前必须先清空缓冲区。否则，会抛出一个IllegalStateException。forward方法也可以用来将请求发送到一个静态的页面。
       

servlet/JSP的初学者在尝试得到一个RequestDispatcher对象时，常感到困惑，这是因为ServletContext接口的getRequestDispatcher方法和ServletRequest接口的getRequestDispatcher方法有很大的不同。接着阅读本文你就可以得到一些技巧来避免将这两者混淆在一起了。

在运用RequestDispatcher对象的forward方法来将一个控件从一个叫做ABCServlet的servlet传递到另一个叫做XYZServlet的servlet时，最简单的方法就是把ABCServlet和XYZServlet的类文件放在同一个目录中。通过这种方法，你就可以从URL http://domain/VirtualDir/servlet/ABCServlet来调用ABCServlet，从URL http://domain/VirtualDir/servlet/XYZServlet来调用XYZServlet了。然后运用forward方法就很简单了。你可以从ServletRequest接口运用getRequestDispatcher ,传递第二个servlet的名字。在ABCServlet中，你可以写下面的代码：

RequestDispatcher rd = request.getRequestDispatcher("SecondServlet"); rd.forward(request, response);

你不需要在XYZServlet前放 / 符号。这种方法是最简单的，因为你根本不需要担心两个servlets的路径。

稍复杂的方法就是把下面这个String传递到ServletRequest的getRequestDispatcher：

"/servlet/XYZServlet"

如果你必须调用一个从ServletContext的getRequestDispatcher得到的RequestDispatcher对象的forward方法，你需要将“/VirtualDir/servlet/XYZServlet”作为路径参数来传递，如下：

RequestDispatcher rd = getServletContext().getRequestDispatcher( "/servlet/XYZServlet"); rd.forward(request, response);

要运用getNamedDispatcher方法，你的代码就会变成：

RequestDispatcher rd = getServletContext().getNamedDispatcher( "XYZServlet"); rd.forward(request, response);

在运用getNamedDispatcher方法时，你必须在部署描述符中注册第二个servlet。下面是个例子：

<web-app> <servlet> <servlet-name>ABCServlet</servlet-name> <servlet-class>ABCServlet</servlet-class> </servlet> <servlet> <servlet-name>XYZServlet</servlet-name> <servlet-class>XYZServlet</servlet-class> </servlet> </web-app>

如果你改变了所含的servlet，你需要重新启动Web container以使改变生效。这是因为所包含的servlet从来都不是直接调用的。一旦加载了所包含的servlet，它的时间戳（time stamp）就不会改变了。

如果你从一个JSP页面发送控件，你也可以用<jsp:forward>执行元素，它会终止当前JSP页面的执行，并将控件传递到另一个资源。它的语法如下：

<jsp:forward page="relativeURL"/>

例如，在JSP页面被解析后，<jsp:forward page=”OtherPage.jsp”/>在结果servlet中就转换成了下面的代码：

pageContext.forward("OtherPage.jsp");

运用HttpServletResponse接口的sendRedirect方法
sendRedirect方法比forward方法要容易。其定义如下：

public void sendRedirect(java.lang.String location) throws java.iio.IOException

该方法把一个命令发送到浏览器，让浏览器对在location中指定的URL提出请求。该方法可以接受绝对的或相对的URLs。如果传递到该方法的参数是一个相对的URL，那么Web container在将它发送到客户端前会把它转换成一个绝对的URL。如果地址是相对的，没有一个’/’，那么Web container就认为它是相对于当前的请求URI的。

例如，你可以用下面的代码将用户重定向到www.brainysoftware.com:

response.sendRedirect(http://www.brainysoftware.com);

你应该运用哪种技巧？
为了编写最有效的代码，你应该了解这两种重定向技巧的不同。forward方法是在Web container内部工作的。sendRedirect方法需要到客户端的一个往返。所以forward方法比sendRedirect要快。但是，运用forward方法有局限性，你只能重定向到同一个Web应用程序中的一个资源。而sendRedirect方法可以让你重定向到任何URL。结论：如果可以解决你的问题，那么就用forward方法。只有当你不能用forward方法时才运用sendRedirect方法。