BlogJava-Kevin's Java Life-文章分类-编程技巧http://www.blogjava.net/kevin/category/848.html 喝一杯咖啡，生活变得从容和清新zh-cnTue, 27 Feb 2007 12:37:23 GMTTue, 27 Feb 2007 12:37:23 GMT60【转载】JSP中的include的两种用法http://www.blogjava.net/Kevin/articles/34295.htmlKevinKevinWed, 08 Mar 2006 08:48:00 GMThttp://www.blogjava.net/Kevin/articles/34295.htmlhttp://www.blogjava.net/Kevin/comments/34295.htmlhttp://www.blogjava.net/Kevin/articles/34295.html#Feedback0http://www.blogjava.net/Kevin/comments/commentRss/34295.htmlhttp://www.blogjava.net/Kevin/services/trackbacks/34295.html我们都知道在jsp中include有两种形式,分别是
<%@ include file=” ”%>
<jsp:include page=” ” flush=”true”/>
前者是指令元素、后者是行为元素。具体它们将在何处用？如何用及它们有什么区别？这应该是很多人看到它都会想到的问题。下面一起来看看吧。

通常当应用程序中所有的页面的某些部分（例如标题、页脚和导航栏）都相同的时候，我们就可以考虑用include。具体在哪些时候用<%@ include file=” ”%>，哪些时候用
<jsp:include page=” ” flush=”true”/>.这种形式。首先要明白的是它们之间的区别。只有了解了它们用法的不同才理解该在何时去用以及如何选择。
<%@ include file=” ”%>
jsp的include指令元素读入指定页面的内容。并把这些内容和原来的页面融合到一起。（这个过程是在翻译阶段:也就是jsp被转化成servlet的阶段进行的。
这里对翻译阶段进行一下说明:我们知道，jsp页面不能原封不动地被传送给浏览器，所有的jsp元素都必须首先由服务器进行处理。这是通过将jsp页面转达化成servlet，然后执行这个servlet来完成的。服务器需要一个jsp容器来处理jsp页面。jsp容器通常以servlet的形式来实现，这个servlet经过配置，可以处理对jsp页面的所有请求。
Jsp容器负责将jsp页面转化成servlet（称为jsp页面实现类—JSP Page implementation class）,并编译这个servlet。这两步就构成了翻译阶段.
由此我们就会知道：jsp页面是把include指令元素所指定的页面的实际内容（也就是代码段）加入到引入它的jsp页面中,合成一个文件后被jsp容器将它转化成servlet。可以看到这时会产生一个临时class文件和一个java文件。下面举个例子。
服务器用tomcat，引入页面的jsp文件叫test.jsp。被引入的页面叫date.jsp.这个jsp文件里存放的是一个有关时间的jsp代码,当前的上下文根设为test
//======date.jsp的源文件=====//
<%@ page language=”java” contentType="text/html;charset=gb2312"%>
<%
  java.util.Date date=new java.util.Date();
  String date_cn ="";
  String dateStr = "";
  switch(date.getDay())
  {
      case 0:date_cn ="日"; break;
      case 1:date_cn ="一"; break;
      case 2:date_cn ="二"; break;
      case 3:date_cn ="三"; break;
      case 4:date_cn ="四"; break;
      case 5:date_cn ="五"; break;
      case 6:date_cn ="六"; break;
  }
   dateStr = (1900+date.getYear()) + "年" + (date.getMonth()+1) + "月" + date.getDate() + "日(星期" + date_cn + ")";
%>
  document.write("<%=dateStr%>");
//======以下是test.jsp的源文件=============//
<%@ page language=”java” contentType=”text/html;charset=gb2312”%>
<html>
<head>
<title>include的两种用法</title>
<jsp:include page=”date.jsp” flush=”true”/>
<%--@ include file=”date.jsp” %-->
  //我们在这里用include的两种不同形式来引入date.jsp这个文件.
<head>
<body>
<table><tr><td>
有关jsp中include的两种用法.敬请关注。
</td></tr></table>
</body>
</html>在test.jsp文件中，我们只输出了一行文本“ 有关jsp中include的两种用法.敬请关注。”,现在让我们先用<%@ include file=”date.jsp” %>这种形式引入date.jsp这个文件。你想会出现什么问题了吗？此时出现了错误提示：
HTTP Status 500 –
org.apache.jasper.JasperException: /date.jsp(0,0) Page directive: can't have multiple occurrences of contentType

以下还有一堆错误，但我们只要看这里就知道问题的所在了。状态码为http 500服务器内部错误。再看下面的提示。在date.jsp页面中不能指定多个contentType.
原因就在这里了。是因为在翻译阶段,date.jsp文件的代码被原封不动地加入到了test.jsp页面从而合成一个文件。合成后的文件中就会相同的：
<%@ page language=”java” contentType=”text/html;charset=gb2312”%>

这句代码。解决的办法是把date.jsp文件中的这句删掉。刷新后再请求test.jsp页面
请求test.jsp在页面显示如下

2003年12月10日 13:12:40
有关jsp中include的两种用法.敬请关注。


这时我们还不能发现什么。还是去查看tomcat下的临时文件吧。到那里去看看date.jsp文件的内容是否已被加入到了test.jsp文件中。
<注.此处的tomcat装在E盘根目录下>

目录
        E:\tomcat\work\Standalone\localhost\test.

在这个目录下会看到
test_jsp.java和test_jsp.class两个文件。

这里的java文件就是jsp容器将jsp转化成了servlet而得到的test_jsp.java这个文件。
相对应的test_jsp.class这个文件就是编译test_jsp.java这个servlet文件产生的类文件了。打开所产生的servlet文件（test_jsp.java）。此时我们会发现，

在test.jsp文件被转化成servlet文件时，在输出的<haed>之间加入了一些不是test.jsp页面里面的代码,新加入的内容就是date.jsp里面的代码: 新加入了哪些内容或是否真的加入了新的内容请自己测试去看一下就会一目了然了.在这里不再详述.
以上就是我们用<%@ include file=”date.jsp”%>这种形式得到的结果.

下面我们换用<jsp:include page=”dae.jsp” flush=”true”/>也就是将

<%@ include file=”date.jsp”%>换成<jsp:include page=”dae.jsp” flush=”true”/>,然后请求test.jsp.

2003? ê 12??10?? 13:30:13
有关jsp中include的两种用法.敬请关注。


此时会在页面上看见.我们所引入date.jsp输出的日期中中文出现了乱码.什么原因?
是因为include行为元素是在请求处理阶段执行的.(此处要对请求处理阶段进行说明一下.
Jsp容器除了上面提到的负责将jsp页面转化成servlet外,还负责调用jsp页面实现类以处理每个请求并产生应答.这个阶段我们就称为请求处理阶段.请求处理阶段仅执行类文件.)
所以在我们作include行为元素引入页面时,实际只是引用了date.jsp这个文件被转化并被编译后产生的servlet类文件.既如此,date.jsp就是作为一个单独的文件在执行后才被test.jsp文件运行时调用.由于date.jsp文件中没有指定字符编码.所以出现了乱码.解决办法是在date.jsp文件中重新把刚才去掉的

<%@ page language=”java” contentType=”text/html;charset=gb2312”%>

这行语句加入后刷新重新运行.此时页面显示正确,并跟用include指令正常运行时一样.再查看tomcat下的临时文件会发现.此时多出了一个date_jsp.java文件和一个date_jsp.class文件.这两个文件得来的方式跟test_jsp.java和test_jsp.class文件得来的方式一样.再查看一下此时test_jsp.java文件的代码会发现.此时只新增加了一句代码:
JspRuntimeLibrary.include(request, response, "date.jsp", out, true);

它并没有把date.jsp文件的代码加入到test.jsp.
只是在运行时引入了date.jsp页面执行后所产生的应答.这意味着我们可以指定任何能够产生应答的Web资源,(例如一个servlet或一个jsp页面),只要这些资源所产生的类型和jsp页面产生的内容类型相同.JSP容器将通过一个内部的函数调用来执行指定的资源.因此,这些被引入的资源可以帮助处理原来的请求,所以这些资源可以访问请求作用域内的所有对象.以及所有原来的请求参数.

由于在主页面被请求时,这些页面还没有被引入到主页面中,所以你可以对page属性使用一个请求时属性值,以便根据运行时的情况来决定要引入哪一个页面.还可以添加一些将被引入的页面读取的请求参数.

<jsp:include page=”<%=pageSelectedAtRuntime%>” flush=”true” >
<jsp:param name=”fitstParamer” value=”firstValue”>
<jsp:param name=”lastParamer” value=”lastValue”>
</jsp:include>

如果修改了被引入的jsp页面,那么可以立刻使用该页面的最新版本,这是因为对待被引入的页面的方式与对待由浏览器直接调用的jsp页面的方式完全相同.即容器检测页面的变化,并自动进入翻译阶段,以得到页面的最新版本.

(注意,include行为元素同jsp其它元素一样,没有行为体时要以”/”结束.就像下面这样.
<jsp:include page=”<%=pageSelectedAtRuntime%>” flush=”true” />)

 

以下是对include 两种用法的区别

主要有两个方面的不同;

一:执行时间上:

<%@ include file=”relativeURI”%>                   是在翻译阶段执行
<jsp:include page=”relativeURI” flush=”true” />  在请求处理阶段执行.

二:引入内容的不同:

<%@ include file=”relativeURI”%>
引入静态文本(html,jsp),在JSP页面被转化成servlet之前和它融和到一起.

<jsp:include page=”relativeURI” flush=”true” />
引入执行页面或servlet所生成的应答文本.

另外在两种用法中file和page属性都被解释为一个相对的URI.如果它以斜杠开头,那么它就

是一个环境相关的路径.将根据赋给应用程序的URI的前缀进行解释,如果它不是以斜杠开头,那么就是页面相关的路径就根据引入这个文件的页面所在的路径进行解释.更多有关URL是如何解释的请参考相关资料或书籍.



Kevin 2006-03-08 16:48 发表评论
]]>pageEncoding,ContentType以及其他http://www.blogjava.net/Kevin/articles/15970.htmlKevinKevinWed, 19 Oct 2005 09:41:00 GMThttp://www.blogjava.net/Kevin/articles/15970.htmlhttp://www.blogjava.net/Kevin/comments/15970.htmlhttp://www.blogjava.net/Kevin/articles/15970.html#Feedback0http://www.blogjava.net/Kevin/comments/commentRss/15970.htmlhttp://www.blogjava.net/Kevin/services/trackbacks/15970.html
SCWCD Exam Study Kit 对contentType 的敘述
The contentType attribute specifies the MIME type and character encoding of the
output. The default value of the MIME type is text/html; the default value of the
character encoding is ISO-8859-1. The MIME type and character encoding are
separated by a semicolon, as shown here:
<%@ page contentType="text/html;charset=ISO-8859-1" %><%@ page contentType="text/html;charset=ISO-8859-1" %>

This is equivalent to writing the following line in a servlet:
response.setContentType("text/html;charset=ISO-8859-1");

这样是否说明，如果使用SetCharacterEncodingFilter来过滤所有的request的话，就不需要在每个JSP页面加上<% @page>指令了？<%@ page contentType>指令了？

对pageEncoding
The pageEncoding attribute specifies the character encoding of the JSP page. The
default value is ISO-8859-1. The following line illustrates the syntax:
<%@ page pageEncoding="ISO-8859-1" %>


在JSP 2.0 Spec 的JSP.4.1 对pageEncoding的叙述

Describes the character encoding for the JSP page.

For JSP pages in standard syntax, the page character encoding is determined
from the following sources:

• A JSP configuration element page-encoding value whose URL pattern matches
the page.

• The pageEncoding attribute of the page directive of the page. It is a translation-
time error to name different encodings in the pageEncoding attribute of
the page directive of a JSP page and in a JSP configuration element whose
URL pattern matches the page.

• The charset value of the contentType attribute of the page directive. This is
used to determine the page character encoding if neither a JSP configuration
element page-encoding nor the pageEncoding attribute are provided.

• If none of the above is provided, ISO-8859-1 is used as the default character
encoding.

the character encoding for the JSP page是什么意思呢？

这样说就清楚了：pageEncoding是当jsp转译成_jsp.java时使用的encoding。

要了解JSP的乱码问题，最重要的是了解jsp的编译输出流程。
1. 从JSP“翻译”成*_jsp.java，此时JSPC根据pageEncoding来读取JSP（注意是读取），然后把它翻译成统一的utf-8 JAVA源码(.java).。如果pageEncoding设定错了，此时出来的中文已经是乱码了。

2. 从Java源码编译成Java ByteCode，此时JavaC将utf-8编码的Java源码编译成同样utf-8的二进制码(.class).

3. Tomcat或者其他应用服务器载入并执行Java ByteCode，并使用contentType设定的的字符集来输出结果(html页面)。

了解了以上流程，应该对JSP页面的乱码问题有本质的理解了。

以上文字参考：
1. JavaWorld@TW：page指令：contentType VS. pageEncoding
2. Matrix：jsp,db,apache中文乱码的解决方案



Kevin 2005-10-19 17:41 发表评论
]]>拒绝访问http://www.blogjava.net/Kevin/articles/4090.htmlKevinKevinSun, 08 May 2005 11:01:00 GMThttp://www.blogjava.net/Kevin/articles/4090.htmlhttp://www.blogjava.net/Kevin/comments/4090.htmlhttp://www.blogjava.net/Kevin/articles/4090.html#Feedback0http://www.blogjava.net/Kevin/comments/commentRss/4090.htmlhttp://www.blogjava.net/Kevin/services/trackbacks/4090.html

事情起因是一段javascript脚本：
<script language="javascript>
  var url = window.locatin.href;
  //doSomething on "url"
  window.location.href = url;
  //2: window.locatino.replace(url);
</script>

执行这段脚本一般情况下是没有问题的，但是如果连着执行两遍的话，就会弹出“拒绝访问”的警告：error.jpg

更麻烦的是在另一个应用中模拟这种状况却不会发生问题。
关于“拒绝访问”（待续）


Kevin 2005-05-08 19:01 发表评论
]]>Foward与Redirecthttp://www.blogjava.net/Kevin/articles/3216.htmlKevinKevinWed, 13 Apr 2005 06:52:00 GMThttp://www.blogjava.net/Kevin/articles/3216.htmlhttp://www.blogjava.net/Kevin/comments/3216.htmlhttp://www.blogjava.net/Kevin/articles/3216.html#Feedback0http://www.blogjava.net/Kevin/comments/commentRss/3216.htmlhttp://www.blogjava.net/Kevin/services/trackbacks/3216.htmlFoward（转发）
使用：
HttpServletRequest.getRequestDispatcher(URL).forward(request, response)
或者   HttpServletContext.getRequestDispatcher(URL).forward(request, response)
原理：
当使用转发时, JSP容器将使用一个内部的方法来调用目标页面，新的页面继续处理同一个请求，而浏览器将不会知道这个过程。
特点：
浏览器中所显示的URL不会被修改．
由于request并没有中止，所以其中的对象仍然可用．

Redirect（重定向）
使用：
HttpServletResponse.sendRedirect(URL);
原理：
重定向方式的含义是第一个页面通知浏览器发送一个新的页面请求
特点：
当你使用重定向时，浏览器中所显示的URL会变成新页面的URL．
由于重定向方式产生了一个新的请求，所以经过一次重定向后，request内的对象将无法使用。

怎么选择是重定向还是转发呢？通常情况下转发更快，而且能保持request内的对象，所以他是第一选择。但是由于在转发之后，浏览器中URL仍然指向开始页面，此时如果重载当前页面，开始页面将会被重新调用。如果你不想看到这样的情况，则选择重定向。

Kevin 2005-04-13 14:52 发表评论
]]>do...while(false)的妙用http://www.blogjava.net/Kevin/articles/2401.htmlKevinKevinThu, 24 Mar 2005 03:13:00 GMThttp://www.blogjava.net/Kevin/articles/2401.htmlhttp://www.blogjava.net/Kevin/comments/2401.htmlhttp://www.blogjava.net/Kevin/articles/2401.html#Feedback0http://www.blogjava.net/Kevin/comments/commentRss/2401.htmlhttp://www.blogjava.net/Kevin/services/trackbacks/2401.htmlJava自由人看到一篇Blog：do...while(false)的探讨，刚好解决了一直困扰我的一个小麻烦
经常会遇到这样的情况，一大段代码，中间遇到某种情况,比如someObj == null,需要跳出这段代码，但是又不在循环之中，只好处理成这样：
if(someObj != null){
  //doSomething
  
  if(someOther fit someCondition){
    
  }
}
最后造成一大堆括号，写起来不舒服，可读性也很差。

巧用do...while(false)可以解决这个问题，看下面的代码：
function LTrim(s){
  try{
    do{
      if(null==s||s.length<=0)
        break;
      var whitespace=" \t\r\n";
      if(whitespace.indexOf(s.charAt(0))>=0){
        var len=s.length;
        var index;
        for(index=0;index  if(whitespace.indexOf(s.charAt(index))<0)
            break;
        if(index s=s.substring(index);
        else s="";
      }
    }while(false);
  }catch(Ab){
  s="";
  }
  return s;
}


这个函数是用来去掉字符串前端的空白。使用do...while(false)的用意就在于在do{}的过程中可以break，使得函数唯一的出口就是最后一行的return。
嗯，这是一个不错的方法。以后可以采用，避免过多的嵌套括号。
(以上部分摘抄Blog：do...while(false)的探讨)



Kevin 2005-03-24 11:13 发表评论
]]>