JSP include指令

合集下载

JSP jspinclude包含动作

JSP <jsp:include>包含动作<jsp:include>动作指令表示在当前的JSP页面中，包含静态或动态资源。

前面已经介绍过include指令，它是在JSP文件被转换成Servlet的时候引入文件，而这里的jsp:include动作不同，插入文件的时间是在页面被请求的时候。

<jsp:include>动作的文件引入时间决定了它的效率要稍微差一点，而且被引用文件不能包含某些JSP代码（例如不能设置HTTP头），但它的灵活性却要好得多。

<jsp:include>动作可以在当前JSP文件中包含txt文件、JSP文件、HTML文件和Servlet文件。

例如：下面对jsp:include标签具体格式中的参数说明如下：●page="{relativeURL | <%= expression %>}该参数为一相对路径，或者是代表相对路径的表达式。

如果路径以“/”开头，那么路径主要是参照JSP应用的上下关系路径。

如果路径是以文件名或目录名开头，那么这个路径就是正在使用JSP文件的当前路径。

●flush="true"注意，这里用户必须使用flush="true"，不能使用false值，默认值为false。

●<jsp:param name="parameterName" value="{parameterValue | …/><jsp:param>子句能用来传递一个或多个参数给动态文件，用户可以在一个页面中使用多个<jsp:param>来传递多个参数。

<jsp:include>和<%@ include %>指令不同的是，<jsp:include>包含的内容可以是动态改变的，它在执行时才确定，而<%@ include %>包含的内容是固定不变的，一经编译，就不能改变。

JSP中include指令和include动作浅析

JSP中include指令和include动作浅析⼀、 JSP⼯作原理JSP⽂件是⼀种Servlet，其⼯作⽅式是先部署源代码后编译为.class⽂件。

JSP会在客户端第⼀次请求JSP⽂件时被编译成Servlet，由Servlet处理客户端的请求。

具体流程如下图：举例说明JSP的编译过程。

客户端第⼀次请求index.jsp⽂件时，Tomcat先将index.jsp转换为标准的java源代码 index_jsp.java（该java⽂件存放在F:\apache-tomcat-7.0.68\work\Catalina\localhost \项⽬名\org\apache\jsp⽬录下），并将index_jsp.java编译成类⽂件index_jsp.class。

该class⽂件便是 JSP对应的Servlet。

编译完成后运⾏class⽂件响应客户端请求。

以后客户端访问index.jsp 时，服务器将不再重新编译JSP⽂件，⽽是直接调⽤index_jsp.class来响应客户端请求。

也就是说，JSP只会在客户端第⼀次请求的时候被编译，因此第⼀次请求会⽐较慢，⽽之后的请求就会速度⽐较快。

⼆、 Include指令Include指令可以在JSP程序中插⼊多个外部⽂件（如：JSP、HTML、java程序，甚⾄是⽂本）。

在转换成Servlet之前，include指令就会将相应的⽂件包含进主⽂件，然后⼀并转换成Servlet，编译⽣成⼀个class⽂件，最后⼀起执⾏。

语法：<%@ include file="relativeURL" %>file属性是include指令的必要属性，⽤于指定包含哪个⽂件。

其中relativeURL为被包含⽂件的路径。

Include指令可以被多次调⽤。

注意：include指令将对应的⽂件包含进主⽂件，等价于代码复制；所以在使⽤include指令时要注意主⽂件与被包含⽂件不能定义相同的变量，也就是要避免变量同名冲突。

jsp：include动作指令与include指令

jsp：include动作指令与include指令include动作指令可以在JSP页⾯中动态包含⼀个⽂件，这与include指令不同，前者可以动态包含⼀个⽂件，⽂件的内容可以是静态的⽂件也可以是动态的脚本，⽽且当包含的动态⽂件被修改的时候JSP引擎可以动态对其进⾏编译更新。

⽽include指令仅仅是把⼀个⽂件简单的包含在⼀个JSP页⾯中，从⽽组合成⼀个⽂件，仅仅是简单的组合作⽤，其功能没有include动作指令强⼤。

includeActon.jsp：<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%><html><head><title>include动作指令使⽤⽰例程序</title></head><body><jsp:include flush="true" page="header.txt"></jsp:include>这是⼀个JSP动作标签include的使⽤⽰例程序。

<jsp:include flush="true" page="footer.jsp"></jsp:include></body></html>header.txt:这⾥⽤include动作指令包含⼀个静态的⽂本⽂件。

footer.jsp:<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%><html><body><%out.print("这⾥⽤include动作指令包含⼀个动态的JSP页⾯！");%></body></html>include.jsp:<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%><html><head><title>include指令使⽤⽰例程序</title></head><body>这是include指令的使⽤⽰例程序。

include与jspinclude区别

<jsp:include/>指令用于在运行时引入另外的资源。
<%@include%>与<jsp:include/>相关区别
1.属性不同说明
include 指令通过 file 属性来指定被包含的页面，该属性不支持任何表达式。如果在 file 属性值中应用了 JSP 表达式，会拋出异常。
<jsp:include> 动作是通过 page 属性来指定被包含页面的，该属性支持 JSP 表达式。
<%@include%>与<jsp:include/>相关区别
3.包含方式不同
include 指令的包含过程为静态包含 <jsp:include> 动作的包含过程为动态包含，通常用来包含那
些经常需要改动的文件。
<%@include%>与<jsp:include/>相关区别
4.对被包含文件的约定不同使用 include 指令包含文件时，因为 JSP 编译器是对主文件和被包含文件进行合成后再翻译，所以对被包含文件有约定。
示例代码
<% String fpath="top.jsp"; %> <%@ include file="<%=fpath%>" %> 该用法将会拋出如下异常：
file "/<%=fpath%>" not fount
<%@include%>与<jsp:include/>相关区别
2.处理方式不同
include 指令编译的文件只有一个使用<jsp:include>指令会编译两个文件

include js用法

include js用法静态include: <%@ inlcude file =”header.jsp” %>此时引入的是静态的jsp文件,它将引入的jsp中的源代码原封不动地附加到当前文件中,所以在jsp程序中使用这个指令的时候file里面的值（即要导入的文件）不能带多余的标签或是与当前jsp文件重复的东西。

例如里面不要包含<html><body>这样的标签，因为是把源代码原封不动的附加过来，所以会与当前的jsp中的这样的标签重复导致出错。

动态include: <jsp:include page=”header.jsp”flush=”true” ></jsp:include>此时引入执行页面或生成的应答文本.jsp:include标签导入一个重用文件的时候，这个文件是经过编译的，通俗点说就是附加这个要导入文件经过编译后的效果，所以可以含有与当前jsp程序中重复的内容，因为在附加过来之前就会被解析掉。

其中flush 表示在读入包含内容之前是否清空任何现有的缓冲区。

2.include页面携带入参<jsp:include page=”header.jsp” flush=”true”><jsp: paramname=”userID”value=”2”/><jsp:include><jsp:param name = "" value="">是将值传给被包含页面（即header.jsp），可通过<%=request.getParameter("userID")%>获取3.两种用法的区别翻译阶段：jsp页面不能原封不动地被传送给浏览器，全部的jsp元素都必须首先由服务器进行处理。

这是通过将jsp 页面转达化成servlet，然后执行这个servlet来结束的。

include指令和include动作的区别

include指令和include动作的区别include指令和include动作都能实现将外部文档包含到JSP文档中的功能，名称也很相似，非常容易混淆。

include指令和include动作到底有什么分别，哪一种方式会更好呢？1.include指令include可以在JSP页面转换成Servlet之前，将JSP代码插入其中。

它的主要优点是功能强大，所包含的代码可以含有总体上影响主页面的JSP构造，比如属性、方法的定义和文档类型的设定。

它的缺点是难于维护只要被包含的页面发生更改，就得更改主页面，这是因为主页面不会自动地查看被包含的页面是否发生更改。

include指令的语法格式如下<%@ include file="Relative Url"%>2.include动作jsp:include动作是在主页面被请求时，将次级页面的输出包含进来。

尽管被包含的页面的输出中不能含有JSP，但这些页面可以是其他资源所产生的结果。

服务器按照正常的方式对指向被包含资源的URL进行解释，因而这个URL可以是Servlet或JSP页面。

服务器以通常的方式运行被包含的页面，将产生的输出放到主页面中，这种方式与RequestDispatcher 类的include方法一致。

它的优点是在被包含的页面发生更改时，无须对主页面做出修改。

它的缺点是所包含的是次级页面的输出，而非次级页面的实际代码，所以在被包含的页面中不能使用任何有可能在整体上影响主页面的JSP构造。

jsp:include动作的完整语法如下<jsp:include page="Relative path to resource" flush="true">其中jsp:include之间不能有空格，page属性指定被包含的页面，这个属性是必需的，是指向某种资源的相对URL。

如果这个相对URL不是以/开头，则将其解释为相对于主页面的路径；如果是以/开头，是这个URL被解释为相对于当前WEB应用的根目录，而不是服务器的根目录，这是因为该URL是由服务器来解释的，不是由用户的浏览器来解释的。

jsp的常用指令有哪些（编译指令动作指令整理）

jsp的常⽤指令有哪些（编译指令动作指令整理）Jsp包含三个编译指令和七个动作指令。

三个编译指令为：page、include、taglib。

七个动作指令为：jsp:forward、jsp:param、jsp:include、jsp:plugin、jsp:useBean、jsp:setProperty、jsp:getProperty。

1、 page指令a. 通常位于jsp页⾯的顶端，同⼀个页⾯可以有多个page指令。

语法格式如下：复制代码代码如下:〈% @page[language="Java"][extends="package.class"][import= "package. class I package. *},…"][session="true I false"][buffer="none I 8kb I size kb" 1[autoFlush="true I false"][isThreadSafe="true I false"][info="text"][errorPage="relativeURL"][contentType="mimeType[ ;charset=characterSet]" I"text/html;charset= "808859-1"][isErrorPage=" true I false"]%〉1)language属性，⼀般情况就是java，代表jsp页⾯使⽤的脚本语⾔。

2)Extends属性，确定 JSP 程序编译时所产⽣的 Java 类，需要继承的⽗类，或者需要实现的接⼝的全限定类名。

1.import属性，⽤来导⼊包，下⾯⼏个包是默认⾃动导⼊的，不需要显式导⼊。

JSP中动态INCLUDE与静态INCLUDE的区别

java面试笔试题:JSP中动态INCLUDE与静态INCLUDE的区别动态INCLUDE用jsp:include动作实现<jsp:include page="" flush="true" />它总是会检查所含文件中的变化,适合用于包含动态页面,并且可以带参数.静态INCLUDE用include伪码实现,定不会检查所含文件的变化,适用于包含静态页面<%@ include file="" %>下面非常详细地解析了有关JSP动态INCLUDE和静态INCLUDE的使用方法及其区别：我们都知道在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),并编译这个servle t.这两步就构成了翻译阶段.由此我们就会知道:jsp页面是把include指令元素所指定的页面的实际内容(也就是代码段)加入到引入它的jsp 页面中,合成一个文件后被jsp容器将它转化成servlet.可以看到这时会产生一个临时class文件和一个java文件.下面举个例子.服务器用tomcat,引入页面的jsp文件叫.被引入的页面叫.这个jsp文件里存放的是一个有关时间的jsp代码,当前的上下文根设为test<head><body><table><tr><td>有关jsp中include的两种用法.敬请关注.</td></tr></table></body></html>在文件中,我们只输出了一行文本" 有关jsp中include的两种用法.敬请关注.",现在让我们先用<%@ include file="" %>这种形式引入这个文件.你想会出现什么问题了吗此时出现了错误提示:HTTP Status 500/(0,0) Page directive: can't have multiple occurrences of contentType以下还有一堆错误,但我们只要看这里就知道问题的所在了.状态码为http 500服务器内部错误.再看下面的提示.在页面中不能指定多个contentType.原因就在这里了.是因为在翻译阶段,文件的代码被原封不动地加入到了页面从而合成一个文件.合成后的文件中就会相同的:<%@ page language="java" contentType="text/html;charset=gb2312"%>这句代码.解决的办法是把文件中的这句删掉.刷新后再请求页面请求在页面显示如下2003年12月10日13:12:40有关jsp中include的两种用法.敬请关注.这时我们还不能发现什么.还是去查看tomcat下的临时文件吧.到那里去看看文件的内容是否已被加入到了文件中.<注.此处的tomcat装在E盘根目录下>目录E:\tomcat\work\Standalone\localhost\test.在这个目录下会看到和两个文件.这里的java文件就是jsp容器将jsp转化成了servlet而得到的这个文件.相对应的这个文件就是编译这个servlet文件产生的类文件了.打开所产生的servlet文件.此时我们会发现,在文件被转化成servlet文件时,在输出的<haed>之间加入了一些不是页面里面的代码,新加入的内容就是里面的代码: 新加入了哪些内容或是否真的加入了新的内容请自己测试去看一下就会一目了然了.在这里不再详述.以上就是我们用<%@ include file=""%>这种形式得到的结果.下面我们换用<jsp:include page="" flush="true"/>也就是将<%@ include file=""%>换成<jsp:include page="" flush="true"/>,然后请求.2003 ê 1210 13:30:13有关jsp中include的两种用法.敬请关注.此时会在页面上看见.我们所引入输出的日期中中文出现了乱码.什么原因是因为include行为元素是在请求处理阶段执行的(此处要对请求处理阶段进行说明一下.Jsp容器除了上面提到的负责将jsp页面转化成servlet外,还负责调用jsp页面实现类以处理每个请求并产生应答.这个阶段我们就称为请求处理阶段.请求处理阶段仅执行类文件).所以在我们作include行为元素引入页面时,实际只是引用了这个文件被转化并被编译后产生的servlet类文件.既如此, 就是作为一个单独的文件在执行后才被文件运行时调用.由于文件中没有指定字符编码.所以出现了乱码.解决办法是在文件中重新把刚才去掉的<%@ page language="java" contentType="text/html;charset=gb2312"%>这行语句加入后刷新重新运行.此时页面显示正确,并跟用include指令正常运行时一样.再查看tomcat下的临时文件会发现.此时多出了一个文件和一个文件.这两个文件得来的方式跟和文件得来的方式一样.再查看一下此时文件的代码会发现.此时只新增加了一句代码:(request, response, "", out, true);它并没有把文件的代码加入到.只是在运行时引入了页面执行后所产生的应答.这意味着我们可以指定任何能够产生应答的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是如何解释的请参考相关资料或书籍.。

jspinclude用法

jspinclude用法JSP（Java Server Pages）是一种用于构建动态网页的技术，它允许将Java代码嵌入到HTML页面中。

在大型的JSP项目中，经常会遇到多个JSP页面之间需要共享一些通用的代码或功能的情况。

为了实现代码的重用和模块化，JSP提供了include指令来引入其他JSP页面的内容。

include指令用于将一个JSP页面的内容嵌入到另一个JSP页面中。

在JSP中，可以使用两种方式来进行include操作：静态包含（static include）和动态包含（dynamic include）。

1. 静态包含（static include）：静态包含是在编译时完成的，使用静态包含时，被引入的页面的内容会包含在包含页面中，一起编译和执行。

可以通过以下方式使用静态包含：```jsp```静态包含的特点是：在编译时，被包含的页面的内容会被复制到包含页面中，在运行时，包含页面和被包含页面是一个整体，共享相同的上下文信息。

静态包含适用于包含一些静态的、不需要动态生成的内容。

在包含页面的任何地方使用include指令，被包含的页面都会在该位置展示。

2. 动态包含（dynamic include）：动态包含是在运行时完成的，使用动态包含时，可以在运行时根据条件来决定是否包含一些页面。

可以通过以下方式使用动态包含：```jsp<jsp:include page="included.jsp"></jsp:include>```动态包含的特点是：在运行时，根据条件将被包含的页面插入到包含页面中。

动态包含可以在包含页面中的任意位置使用，可以在循环中动态判断是否需要包含一些页面。

动态包含适用于根据运行时条件来包含不同的内容。

总结：。

jspinclude用法

jspinclude用法1.静态包含静态包含是指在JSP编译时将被包含的文件的内容直接嵌入到当前JSP文件中。

静态包含的语法如下：其中，filename是要被包含的文件名，可以是相对路径或绝对路径。

静态包含的特点是包含的文件内容会在JSP文件编译时被插入到当前文件中，因此在运行时只剩下一个JSP文件。

这种方式适合用于在多个JSP页面中共享相同的代码块或页面布局，可以提高代码的复用性和可维护性。

2.动态包含动态包含是指在JSP运行时动态地决定要被包含的文件。

动态包含的语法如下：<jsp:include page="filename" [flush="true，false"] [errorPage="url"] [isErrorPage="true，false"] />其中，filename是要被包含的文件名，可以是相对路径或绝对路径。

flush属性表示是否在包含之前刷新缓冲区，默认值为false。

errorPage属性是一个可选属性，用于指定该包含的JSP文件是一个错误页面。

isErrorPage属性表示包含的JSP文件是否是一个错误页面，如果为true，则可以使用内置对象exception和error_page来处理异常。

动态包含和静态包含的最大区别在于，动态包含是在运行时进行的，因此可以根据业务逻辑决定是否包含一些文件。

动态包含的文件可以由用户输入、数据库查询结果或者其他变量来决定。

使用include指令的一般步骤如下：1. 创建两个JSP文件，一个叫做"main.jsp"，另一个叫做"included.jsp"。

2. 在included.jsp文件中填入以下内容：<!DOCTYPE html><html><head><title>included.jsp</title></head><body>This is the included page.</body></html>3. 在main.jsp文件中填入以下内容：<!DOCTYPE html><html><head><title>main.jsp</title></head><body>This is the main page.</body></html>4. 运行main.jsp文件，你会看到main.jsp页面中的内容被显示出来，然后是included.jsp页面中的内容。

JSP之静态include指令、动态Include指令

JSP之静态include指令、动态Include指令（⼀）使⽤静态include指令<%@ page language="java" contentType="text/html; charset=gb2312"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Insert title here</title></head><body><%@include file="scriptlet.jsp" %></body></html>（⼆）使⽤动态Include指令<%@ page language="java" contentType="text/html; charset=ISO-8859-1"pageEncoding="ISO-8859-1"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Insert title here</title></head><body><jsp:include page="scriptlet.jsp" /></body></html>scriptlet.jsp页⾯代码如下：<%@ page language="java" contentType="text/html; charset=gb2312"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Insert title here</title></head><body><%out.write("来⾃scriptlet.jsp");%></body></html>（三）静态导⼊和动态导⼊的区别：（1）静态导⼊（include指令）通过file属性指定被包含的⽂件，并且file属性不⽀持任何表达式；动态导⼊（include动作）通过page属性指定被包含的⽂件，且page属性⽀持JSP表达式；（2）使⽤静态导⼊（include指令）时，被包含的⽂件内容会原封不动的插⼊到包含页中，然后JSP编译器再将合成后的⽂件最终编译成⼀个Java⽂件；使⽤动态导⼊（include动作）包含⽂件时，当该标识被执⾏时，程序会将请求转发（不是请求重定向）到被包含的页⾯，并将执⾏结果输出到浏览器中，然后返回包含页继续执⾏后⾯的代码。

JSP的学习（5）——语法知识三之include指令

JSP的学习（5）——语法知识三之include指令本篇继续来对JSP语法中的JSP指令进⾏学习，在中，已经介绍了JSP指令的书写格式和page指令的详细信息，所以在这⼀篇中我们会对JSP指令中的include指令来进⾏详细的学习。

先来回顾下JSP指令的语法格式：JSP指令： JSP指令是为JSP引擎⽽设计的，JSP指令不产⽣任何可见输出，只是告诉在转换成Servlet的过程中如何处理JSP页⾯中的其余部分。

在JSP 2.0 规范中共定义了三个指令： 1) page指令 2) include指令 3) taglib指令 taglib指令是导⼊标签库的指令，以后会介绍到。

JSP指令格式：<%@指令(如page、include或taglib) 属性1="属性值"属性2="属性值" ... %>例如：<%@ page contentType = "text/html;charset=utf-8"%> 如果⼀个指令有多个属性，这多个属性可以写在⼀个指令中，也可以分开写。

例如：1 <%@page contentType = "text/html;charset=utf-8" %>2 <%@page import = "java.util.Date"%>或者写成： <%@page contentType="text/html;charset=utf-8" import="java.util.Date"%>include指令 include指令⽤于在本JSP中引⼊其他JSP页⾯。

语法格式：<%@include file=”/相对URL” %>其中“file”属性的值为相对于web应⽤下的地址（给服务器的地址，因为由服务器来处理将那些JSP包含进来）。

JSP include指令

JSP include指令
该指命会在JSP编译时，插入一个包含文本或代码的文件。

当使用<%@ include %>指命时，这个包含的过程就当是静态的，与ASP中代码中非常相似。

静态的包含就是指这个被包含的文件，将会被插入到JSP文件中去，这个包含的文件可以是JSP文件、HTML文件、文本文件等。

如果包含的是JSP文件，这个包含的JSP的文件中代码将会被执行。

如果你仅仅只是用include 来包含一个静态文件。

那么这个包含的文件所执行的结果将会插入到JSP文件中放<% @ include %>的地方。

一旦包含文件被执行，那么主JSP文件的过程将会被恢复，继续执行下一行。

文件路径一般使用相对路径，这样如果程序代码文件进行迁移也不会有所影响。

路径如果以“/”开头，则表明使用的是相对JSP服务器应用的根目录的路径；如果直接用文件名或是文件夹名+文件名，则表明是相对本JSP文件当前目录的相对路径。

例如，分别创建一个include_homepage.jsp文件和一个include_subpage.jsp文件，此时在include_homepage文件中包含include_subpage.jsp文件。

详细代码如下：
通过上述代码，可以很容易理解Include_subpage.jsp文件中，只有添加有page 指令的JSP文件，其内容为静态的文本。

而在include_homepage.jsp文件的文本内容后面，添加<%@ include file="include_subpage.jsp"%>语句，来包含子页面，运行效果如图3-1所示。

图3-1 包含文件效果。

jsp三大指令标记，七大动作标记、详解。

jsp三⼤指令标记，七⼤动作标记、详解。

JSP的基本构成JSP页⾯主要由指令标签，注释，嵌⼊Java代码，JSP动作标签，HTML标记语⾔等五个元素组成。

3个指令标签1 、page指令page指令⽤户定义JSP页⾯中的全局属性，Eg:<%@ page attr1=”value1” atrr2=”value2”.......%>page指令对整个页⾯有效，包括静态的包含⽂件，但page指令不能⽤于被动态包含的⽂件，例如使⽤<jsp:include>包含的⽂件。

在⼀个JSP页⾯中可以使⽤多个page指令，但page指令中的属性只能出现⼀次(import属性除外)。

page指令的常⽤属性如下:(1) language属性该属性⽤于设置JSP页⾯使⽤的语⾔，⽬前只⽀持Java语⾔。

例:<%@ page language=”java” %>(2) extends属性该属性⽤于设置JSP页⾯所继承的Java类，JSP和Servlet都可以继承指定的⽗类，但该属性并不常⽤.(3) import属性该属性⽤于设置JSP所导⼊的类包，JSP页⾯可以嵌⼊Java代码⽚段，这些Java代码在调⽤API时需要导⼊相应的类包。

例: <%@page import=”java.util.*” %>(4) pageEncoding属性该属性⽤于定义JSP页⾯的编码格式，指定的⽂件编码格式。

例:<%@ page pageEncoding=”UTF-8” %>(5) contentType属性该属性⽤于设置JSP页⾯的MIME类型和字符编码，浏览器会根据些解释页⾯。

例:<%@ pagecontentType=”text/html;charset=utf-8” %>(6) session属性该属性⽤于定义JSP页⾯是否使⽤session会话对象，其值是boolean类型，默认值为true. Eg:<%@ page session=”true” %>(7) buffer属性该属性⽤于设置out对象所使⽤的缓冲区⼤⼩，默认⼤⼩是8KB,单位只能是8的倍数。

JSP中include指令

引入的文件如果是jsp则应定义为***.jspf文件，如果其他文件可定义为***.inc文件，即include file。

jsp:include是既可以静态包含又可以动态包含，用jsp:include相当于编译两个不同的文件，所以如果被包含文件中仅仅是显示某些东西（例如被包含文件是纯HTML）的话，这种情况下，用jsp:include 和@include来包含文件的效果是一样的，但如果要用 jsp:include来显示被包含文件中定义的变量就不行了。

但是 include 指令：<%@ inlucde page="" %>除了可以引jspf还可以引servlet，要使用引入文件中定义的变量，只能用@include指令。

也就是<%@ include file="one.jsp" %>,但这在一般情况下都不是动态的，是在jsp页面第一次编译时，把它导入的。

而且JSP中@开头的语句都要先于其他语句执行。

第二种解释：＜%@ 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。

include的两种用法

本文详细介绍了JSP中include的两种主要用法，分别是<%@ include file=” ”%>指令元素和<jsp:include page=” ” flush=”true”/>行动元素。当应用程序中的多个页面需要共享相同的内容，如标题、页脚或导航栏时，可以使用include。指令元素在JSP页面被转化成Servlet的阶段，即将指定页面的实际内容融合到引入它的JSP页面中。而行动元素则是在请求处理阶段动态包含其他页面。通过具体例子，展示了如何在Tomcat服务器上使用这两种include方式，并解释了它们之间的主要区别。然而，需要注意的是，这是JSP中的include用法，并非C+函数、类和变量。

include指令和include动作的区别

include指令和include动作的区别include指令和include动作都能实现将外部文档包含到JSP文档中的功能，名称也很相似，非常容易混淆。

include指令和include动作到底有什么分别，哪一种方式会更好呢？1.include指令include可以在JSP页面转换成Servlet之前，将JSP代码插入其中。

它的主要优点是功能强大，所包含的代码可以含有总体上影响主页面的JSP构造，比如属性、方法的定义和文档类型的设定。

它的缺点是难于维护只要被包含的页面发生更改，就得更改主页面，这是因为主页面不会自动地查看被包含的页面是否发生更改。

include指令的语法格式如下<%@ include file="Relative Url"%>2.include动作jsp:include动作是在主页面被请求时，将次级页面的输出包含进来。

尽管被包含的页面的输出中不能含有JSP，但这些页面可以是其他资源所产生的结果。

服务器按照正常的方式对指向被包含资源的URL进行解释，因而这个URL可以是Servlet或JSP页面。

服务器以通常的方式运行被包含的页面，将产生的输出放到主页面中，这种方式与RequestDispatcher 类的include方法一致。

它的优点是在被包含的页面发生更改时，无须对主页面做出修改。

它的缺点是所包含的是次级页面的输出，而非次级页面的实际代码，所以在被包含的页面中不能使用任何有可能在整体上影响主页面的JSP构造。

JSP中动态INCLUDE与静态INCLUDE的区别

java面试笔试题:JSP中动态INCLUDE与静态INCLUDE的区别?[日期：2008-09-15] 来源：作者：志伟动态I NC LU DE用js p:i nc lu de动作实现<js p:i nc lu de pag e="i nc lud ed.js p"fl us h="tr ue"/>它总是会检查所含文件中的变化,适合用于包含动态页面,并且可以带参数.静态I N C LU DE用inc lu de伪码实现,定不会检查所含文件的变化,适用于包含静态页面<%@i nc lu de fil e= "i nc lu ded.ht m"%>下面非常详细地解析了有关JSP动态I NC LU DE和静态I N CLU DE的使用方法及其区别：我们都知道在js p中inc l ude有两种形式,分别是<%@i nc lu de file=""%><js p:i nc lu de p age=""flus h="t rue"/>前者是指令元素、后者是行为元素.具体它们将在何处用?如何用及它们有什么区别?这应该是很多人看到它都会想到的问题.下面一起来看看吧.通常当应用程序中所有的页面的某些部分(例如标题、页脚和导航栏)都相同的时候,我们就可以考虑用inc l ud e.具体在哪些时候用<%@i nc lud e file=""%>,哪些时候用<js p:i nc lu de p age=""flus h="t rue"/>.这种形式.首先要明白的是它们之间的区别.只有了解了它们用法的不同才理解该在何时去用以及如何选择.<%@i nc lu de file=""%>,js p的inc l ude指令元素读入指定页面的内容.并把这些内容和原来的页面融合到一起.(这个过程是在翻译阶段:也就是js p被转化成s e rvlet的阶段进行的.这里对翻译阶段进行一下说明:我们知道,js p页面不能原封不动地被传送给浏览器,所有的js p元素都必须首先由服务器进行处理.这是通过将js p页面转达化成s e rvle t,然后执行这个s ervl et来完成的.服务器需要一个js p容器来处理js p页面.js p容器通常以s e rvlet的形式来实现,这个s e rvl et经过配置,可以处理对js p页面的所有请求.Js p容器负责将js p页面转化成s erv let(称为js p页面实现类?JSP P age im ple me nta tio n c las s),并编译这个s er vlet.这两步就构成了翻译阶段.由此我们就会知道:js p页面是把i nc lu de指令元素所指定的页面的实际内容(也就是代码段)加入到引入它的js p页面中,合成一个文件后被js p容器将它转化成s ervl et.可以看到这时会产生一个临时c las s文件和一个jav a文件.下面举个例子.服务器用to mc at,引入页面的js p文件叫t es t.js p.被引入的页面叫d ate.js p.这个js p文件里存放的是一个有关时间的js p代码,当前的上下文根设为tes t//======d a te.js p的源文件=====//<%@p age lan g uage="java"c o nte ntT yp e="te xt/h t ml;c ha rs et=gb2312"%><%java.ut il.Dat e da te=ne w java.uti l.Date();St ri ng dat e_c n="";St ri ng dat eSt r= "";s witc h(dat e.ge tDay()){c as e 0:d ate_c n="日"; b rea k;c as e 1:d ate_c n="一"; b rea k;c as e 2:d ate_c n="二"; b rea k;c as e 3:d ate_c n="三"; b rea k;c as e 4:d ate_c n="四"; b rea k;c as e 5:d ate_c n="五"; b rea k;c as e 6:d ate_c n="六"; b rea k;}d ateS tr= (1900+dat e.ge tY ear()) + "年"+ (date.ge tM ont h()+1) + "月"+ da te.getDa te() + "日(星期"+ da te_c n+ ")";%>d oc u men t.writ e("<%=da teSt r%>");//======以下是tes t.js p的源文件=============//<%@p age lan g uage="java"c o nte ntT yp e="te xt/h t ml;c ha rs et=gb2312"%><h t ml><h ea d><t itl e>i nc lude的两种用法</t itle><js p:i nc lu de p age="da te.js p"fl us h="t r ue"/><%--@i nc lud e file="da te.js p"%-->//我们在这里用inc l ude的两种不同形式来引入dat e.js p这个文件.<h ea d><t abl e><tr><t d>有关js p中i nc lude的两种用法.敬请关注.</t d></tr></t abl e></h t ml>在tes t.js p文件中,我们只输出了一行文本"有关js p中inc lu de的两种用法.敬请关注.",现在让我们先用<%@i nc lu de fil e="d ate.js p"%>这种形式引入d ate.js p这个文件.你想会出现什么问题了吗?此时出现了错误提示:H TT P Sta tus500?o rg.apac he.jas pe r.Jas pe rE xc ept io n: /dat e.js p(0,0) P age dir ec tive: c an't have m ulti ple oc c u r r enc es o f c ont en tT ype以下还有一堆错误,但我们只要看这里就知道问题的所在了.状态码为htt p500服务器内部错误.再看下面的提示.在d ate.js p页面中不能指定多个c o nte ntT yp e.原因就在这里了.是因为在翻译阶段,date.js p文件的代码被原封不动地加入到了t es t.js p页面从而合成一个文件.合成后的文件中就会相同的:<%@p age lan g uage="java"c o nte ntT yp e="te xt/h t ml;c ha rs et=gb2312"%>这句代码.解决的办法是把d ate.js p文件中的这句删掉.刷新后再请求t es t.js p页面请求tes t.js p在页面显示如下2003年12月10日13:12:40有关js p中i nc lude的两种用法.敬请关注.这时我们还不能发现什么.还是去查看to mc at下的临时文件吧.到那里去看看d ate.js p文件的内容是否已被加入到了tes t.js p文件中.<注.此处的to mc at装在E盘根目录下>目录E:\to mc at\wo rk\S tan dal on e\loc al hos t\tes t.在这个目录下会看到tes t_js p.java和tes t_js p.c l ass两个文件.这里的java文件就是js p容器将js p转化成了s e rvlet而得到的tes t_js p.java这个文件.相对应的tes t_js p.c las s这个文件就是编译tes t_js p.java这个s ervl et文件产生的类文件了.打开所产生的s er vlet文件(tes t_js p.java).此时我们会发现,在t es t.js p文件被转化成s e rvlet文件时,在输出的<hae d>之间加入了一些不是t es t.js p页面里面的代码,新加入的内容就是dat e.js p里面的代码: 新加入了哪些内容或是否真的加入了新的内容请自己测试去看一下就会一目了然了.在这里不再详述.以上就是我们用<%@inc l ude file="dat e.js p"%>这种形式得到的结果.下面我们换用<js p:i nc lu de p age="da e.js p"flus h="t rue"/>也就是将<%@i nc lu de file="da te.js p"%>换成<js p:inc l ude pag e="d ae.js p"fl us h="t r ue"/>,然后请求tes t.js p.2003?ê12??10??13:30:13有关js p中i nc lude的两种用法.敬请关注.此时会在页面上看见.我们所引入d ate.js p输出的日期中中文出现了乱码.什么原因?是因为i nc lu de行为元素是在请求处理阶段执行的(此处要对请求处理阶段进行说明一下.Js p容器除了上面提到的负责将js p页面转化成s e rv let外,还负责调用js p页面实现类以处理每个请求并产生应答.这个阶段我们就称为请求处理阶段.请求处理阶段仅执行类文件).所以在我们作inc lu d e行为元素引入页面时,实际只是引用了d ate.js p这个文件被转化并被编译后产生的s e r vlet类文件.既如此, da te.js p就是作为一个单独的文件在执行后才被tes t.js p文件运行时调用.由于da te.js p文件中没有指定字符编码.所以出现了乱码.解决办法是在da te.js p文件中重新把刚才去掉的<%@p age lan g uage="java"c o nte ntT yp e="te xt/h t ml;c ha rs et=gb2312"%>这行语句加入后刷新重新运行.此时页面显示正确,并跟用i nc lude指令正常运行时一样.再查看t o mc at下的临时文件会发现.此时多出了一个da te_js p.java文件和一个da te_js p.c lass文件.这两个文件得来的方式跟tes t_js p.java和tes t_js p.c l ass文件得来的方式一样.再查看一下此时tes t_js p.java文件的代码会发现.此时只新增加了一句代码:Js pR unt im eLib ra ry.i nc lu de(r eq ues t, res po ns e, "da te.js p", o ut, tr ue);它并没有把d ate.js p文件的代码加入到tes t.js p.只是在运行时引入了da te.js p页面执行后所产生的应答.这意味着我们可以指定任何能够产生应答的Web资源,(例如一个s er vlet或一个js p页面),只要这些资源所产生的类型和js p页面产生的内容类型相同.JSP容器将通过一个内部的函数调用来执行指定的资源.因此,这些被引入的资源可以帮助处理原来的请求,所以这些资源可以访问请求作用域内的所有对象.以及所有原来的请求参数.由于在主页面被请求时,这些页面还没有被引入到主页面中,所以你可以对pa ge属性使用一个请求时属性值,以便根据运行时的情况来决定要引入哪一个页面.还可以添加一些将被引入的页面读取的请求参数.<js p:i nc lu de p age="<%=p ageS elec te dA tRun ti me%>"fl us h="t r ue"><js p:p ar am na me="fits tP ara me r"va lue="fi rs tV alue"><js p:p ar am na me="las tP ara me r"va lue="las tV alue"></js p:i nc lu de>如果修改了被引入的js p页面,那么可以立刻使用该页面的最新版本,这是因为对待被引入的页面的方式与对待由浏览器直接调用的js p页面的方式完全相同.即容器检测页面的变化,并自动进入翻译阶段,以得到页面的最新版本.(注意,i nc lu de行为元素同js p其它元素一样,没有行为体时要以"/"结束.就像下面这样.<js p:i nc lu de p age="<%=p ageS elec te dA tRun ti me%>"fl us h="t r ue"/>)以下是对i nc lu de两种用法的区别主要有两个方面的不同;一:执行时间上:<%@i nc lu de file="r elat iveU RI"%> 是在翻译阶段执行<js p:i nc lu de p age="re lat iveU RI" fl us h="tr ue"/> 在请求处理阶段执行.二:引入内容的不同:<%@i nc lu de file="r elat iveU RI"%>引入静态文本(h tm l,js p),在JSP页面被转化成s ervl et之前和它融和到一起.<js p:i nc lu de p age="re lat iveU RI" fl us h="tr ue"/>引入执行页面或s ervl et所生成的应答文本.另外在两种用法中file和pa ge属性都被解释为一个相对的U RI.如果它以斜杠开头,那么它就是一个环境相关的路径.将根据赋给应用程序的U RI的前缀进行解释,如果它不是以斜杠开头,那么就是页面相关的路径,就根据引入这个文件的页面所在的路径进行解释.更多有关U RL是如何解释的请参考相关资料或书籍.。