include指令和include动作标识的区别
2020-12-20 10:12:41
动作标记 include 的作用是将JSP文件、HTML网页文件或其他文本文件动态嵌入到当前的JSP网页中，该指令有以下两种格式：
```
<jsp:include page="文件的URL"/>
```
或
```
<jsp:include page="文件的URL">
子标记
<jsp"include/>
```
JSP的动作标识用于向当前页面中包含其他的文件。被包含的文件可以是动态文件也可以是静态文件。

使用include指令，可以通过该指令在JSP页面中包含另一个JSP页面。不过该指令是动态包含（被包含文件中的所有内容会原封不动的包含到JSP页面中）最终生成一个文件，在包含和被包含文件中，不能有相同变量名。

两者的区别：
1.include指令通过file属性来指定被包含的文件，并且file属性不支持任何表达式。include动作标识用page属性来指定被包含文件，page支持jsp表达式。
更多相关内容
jsp中两种包含关系(include动作和include指令)的区别
2019-05-24 01:39:16

NULL 博文链接：https://lionkingzw-hotmail-com.iteye.com/blog/341279

收起

浅谈JSP中include指令与include动作标识的区别

千次阅读 2018-05-30 08:53:47

我们都知道在JSP中include有两种形式,分别是＜%@ include file=” ”%＞＜jsp:include page=” ” flush=”true”/＞前者是指令元素，后者是动作元素。具体它们将在何处用？如何用及它们有什么区别？这应该是很多人...

JSP中主要包含三大指令，分别是page，include，taglib。本篇主要提及include指令。

include指令使用格式：<%@ include file="文件的绝对路径或相对路径"%>

file属性：指定被包含的文件，该属性不支持任何表达式，也不允许通过如下的方式来传递参数。

<%@ include file="welcome.jsp?name=Tom"%>下面用法将会抛出异常，也是不允许的：

<% String path="login.jsp";%>

<%@ include file="<%=path%>"%>

如果该属性值以”/“开头，那么指定的是一个绝对路径，将在当前应用的根目录下查找文件；如果是以文件名称或文件夹名开头，那么指定的是一个相对路径，将在当前页面的目录下查找文件。

JSP中常用的动作标识有<jsp:include>、<jsp:forward>、<jsp:useBean>、<jsp:setProperty>、<jsp:getProperty>、<jsp:fallback>、<jsp:pugin>。本篇主要提及<jsp:include>动作标识。

<jsp:include>动作标识使用格式：<jsp:include page="被包含文件的路径" flush="true|false"/>

或者向被包含的动态页面中传递参数：

<jsp:include page="被包含文件的路径" flush="true|false"><jsp:param name="参数名称" value="参数值"/></jsp:include>

page属性：和include指令的file属性一样。

flush属性：表示当输出缓冲区满时，是否清空缓冲区。该属性值为boolean类型，默认值为false，通常情况下设为true。

处理方式不同：使用include指令，被包含的文件的内容会原封不动地插入到包含页中使用该指令地位置，然后JSP编译器再对这个合成地文件进行编译最终编译成的文件只有一个。使用include动作标识，该标识被执行时，程序会将请求转发到（注意是转发而不是请求重定向）被包含的页面，并将执行结果输出到浏览器中，然后返回包含页继续执行后面的代码。服务器执行的是两个文件，JSP编译器会分别对这两个文件进行编译。注：]请求转发，存储在request对象中的信息会被保留并被带到目标页面中；请求重定向，重新生成一个request请求，将该请求重定向到指定的URL，所以事先存储在request对象中的信息都不存在了。

包含方式不同：include指令，静态包含，最终服务器执行的是将两个文件合成后由JSP编译器编译成的一个class文件，若改变被包含的文件，则主文件的代码就发生了改变，服务器会重新编译主文件。include动作标识，动态包含，通常用来包含那些经常需要改动的文件。服务器执行的是两个文件，被包含文件的改动不会影响到主文件，服务器不需要对主文件进行重新编译，只需要重新编译被包含的文件即可，而只有当<jsp:include>动作标识被执行时，使用该标识时，目标文件才会被编译。

约定不同：include指令的约定index.jsp文件的部分代码

1 <%@ page language="java" contentType="text/html; charset=UTF-8"%>
2 <%@ include file="top.jsp" %>

top.jsp文件的部分代码

1 <%@ page language="java" contentType="text/html; charset=GB2312"%>

访问index.jsp将会出现异常

<jsp:include>动作标识，无需遵循这样的约定，不会出现异常

1 <%@ page language="java" contentType="text/html; charset=GB2312"%>
2 <jsp:include page="top.jsp"/>

——————————————————————————————————————————————————————

关于include指令和include动作指令的介绍见JSP基本语法(三)

首先，我们来看一下include指令所包含的内容与当前页面是一个整体是什么意思。

我们在Tomcat安装目录下的webapps文件夹下新建一个文件夹includeTEST，在这里进行一些实验。

在includeTEST文件夹下新建一个include.jsp：

<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%>

<html>
  <head><title>include</title></head>
  <body>
    现在是：<%@ include file="date.jsp" %>
  </body>
</html>

在这个JSP页面中，我们用include指令静态包含了date.jsp，接下来我们就新建一个date.jsp放在和include.jsp相同的目录下/webapps/includeTEST/

date.jsp

<% 
  Date date = new Date();
%>

<%=
  date.toString()   
%>

接下来启动Tomcat，打开浏览器输入

localhost:8080/includeTEST/include.jsp

能够正常显示出当前时间。然后我们到Tomcat安装目录下的

\work\Catalina\localhost\includeTESTorg\apache\jsp

中去查找include.jsp页面生成的对应的java文件，事实上我们会在这个目录下找到inlucde_jsp.java以及include_jsp.class，没有date_jsp.java相关的文件，说明include.jsp页面包括静态包含的date.jsp，一起只生成了一个文件，include_jsp.java截取如下：

      out.write("\r\n");
      out.write("\r\n");
      out.write("<html>\r\n");
      out.write("  <head><title>JSP-welcome</title></head>\r\n");
      out.write("  <body>\r\n");
      out.write("    现在是：");

  Date date = new Date();

      out.write("\r\n");
      out.write("\r\n");
      out.print(
  date.toString()

我们发现，在该include_jsp.java文件中，new了一个Date对象，然后进行打印输出，也就是直接将date.jsp中的内容合进来，生成了同一个文件。

作为对比，我们同样在includeTEST/下新建一个includeAction.jsp，我们这次试用jsp的include动作指令来包含date.jsp：

<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%>

<html>
  <head><title>includeAction</title></head>
  <body>
    现在是：<jsp:include page="date.jsp"/>
  </body>
</html>

此时，我们打开浏览器输入

localhost:8080/includeTEST/includeAction.jsp

出现了错误！

error

错误信息：

org.apache.jasper.JasperException: Unable to compile class for JSP: 

An error occurred at line: 2 in the jsp file: /date.jsp
Date cannot be resolved to a type
1: <% 
2:   Date date = new Date();
3: %>
4: 
5: <%=

错误原因很简单，Date不能识别！但是使用<%@ include file="date.jsp" %>时可以识别，为什么此处<jsp:include page="date.jsp"/>就不能识别？！

原因就在于那句话：include标签会把包含的部分和当前页面生成同一个整体！于是Date就被头部的<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%>中的import=”java.util.*”引进来了。但是使用<jsp:include page="date.jsp"/>生成的是两个单独的实体，于是在date.jsp这个独立的实体中，Date将无法识别！

这时候我们再次打开以下目录：

\work\Catalina\localhost\includeTESTorg\apache\jsp

会发现，当前目录下生成了

在这里我们看到了date_jsp.java，includeAction_jsp.java以及includeAction_jsp.class文件。生成了includeAction对应的class文件，说明includeAction.jsp页面可以正常编译执行。再次说明，includeAction.jsp和date.jsp是两个单独的实体！同时，由于includeAction.jsp能够生成class文件，也说明了date_jsp.java的编译执行起码是在includeAction执行之后才进行的，实际上是执行到

    现在是：<jsp:include page="date.jsp"/>

对应的语句的时候，date.jsp才第一次被请求。但是编译出错。

接下来我们做以下修改，我们把date.jsp做以下修改并另存为date1.jap:

<%@ page language="java" import="java.util.*" contentType="text/html;charset=gb2312"%>

<% 
  Date date = new Date();
%>

<%=
  date.toString()   
%>

再次在浏览器输入

localhost:8080/includeTEST/includeAction.jsp

此时，时间可以打印出来了！关于中文乱码问题我们暂时不管。

再次进入

\work\Catalina\localhost\includeTESTorg\apache\jsp

此时生成了对应的date1_jsp.java以及date1_jsp.class文件：

最后我们用打开includeAction_jsp.java，部分代码如下:

      out.write("\r\n");
      out.write("\r\n");
      out.write("<html>\r\n");
      out.write("  <head><title>includeAction</title></head>\r\n");
      out.write("  <body>\r\n");
      out.write("    现在是：");
      org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "date1.jsp", out, false);
      out.write("\r\n");
      out.write("  </body>\r\n");
      out.write("</html>");

这里我们可以清楚地看到，对date1.jsp的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是由服务器来解释的，不是由用户的浏览器来解释的。像下面这行代码，是由用户的浏览器进行解释的，因此会按照相对于服务器的根目录进行解释。
flush属性是一个可选的次级属性，默认值为false，它指定在将页面包含进来之前是否应该清空主页面的输出流。
   注意：在JSP1.1中，flush是必需的属性，而且聚会只能是true。
3.两者的区别和比较
   jsp:include动作和include指令之间的根本性的不同在于它们被调用的时间。jsp:include动作在请求期间被激活，而include指令在页面转换期间被激活。
   两者之间的差异决定着它们在使用上的区别。使用include指令的页面要比使用jsp:include动作的页面难于维护。前面已经说过，使用JSP指令，如果包含的JSP页面发生变化，那么用到这个页面的所有页面都需要手动更新。在JSP服务器的相关规范中并没要求能够检测出包含的文件什么时候发生改变，实际上大多数服务器页都有去实现这种机制。这样就会导致十分严重的维护问题，需要记住所有包含某一个页面的其他页面，或者重新编译所有的页面，以使更改能够生效。在这点上，jsp:include就体现出了十分巨大的优势，它在每次请求时重新把资源包含进来。在实现文件包含上，应该尽可能地使用jsp:include动作。
   jsp:include动作直比于include指令在维护上有着明显优势，而include指令仍然能够得以存在，自然在其他方面有特殊的优势。这个优势就是include指令的功能更强大，执行速度也稍快。include指令允许所包含的文件中含有影响主页面的JSP代码，比如响应报送的设置和属性方法的定义。以下表格就是两种包含方式的对比:

include指令

jsp:include动作

语法格式

<%@ include file=”..”%>

<jsp:include page=”..”>

发生作用的时间

页面转换期间

请求期间

包含的内容

文件的实际内容

页面的输出

转换成的Servlet

主页面和包含页面转换为一个Servlet

主页面和包含页面转换为独立的Servlet

影响主页面

可以

不可以

include指令

jsp:include动作

发生更改时是否需要显式更改主页面

需要

不需要

编译时间

较慢－资源必须被解析

较快

执行时间

稍快

较慢－每次资源必须被解析

灵活性

较差－页面名称固定

更好－页面可以动态指定

了解到jsp:include动作和include指令各自的功能和区别，在使用时，就可以通过考虑各方面的因素，来决定使用哪一种方式。尽管各自都有一定的优缺点，在实际使用中，还是应优先考虑使用jsp:include动作，这是因为它在代码维护上的优势远胜过其在功能上的不足。

收起

展开全文

jsp

include指令与include动作标识的区别
千次阅读 2018-10-18 15:21:10

JSP中主要包含三大指令，分别是page，include，taglib。本篇主要提及include指令。 include指令使用格式：<%@ include file=“文件的绝对路径或相对路径”%> file属性：指定被包含的文件，该属性不...

JSP中主要包含三大指令，分别是page，include，taglib。本篇主要提及include指令。

include指令使用格式：<%@ include file=“文件的绝对路径或相对路径”%>

file属性：指定被包含的文件，该属性不支持任何表达式，也不允许通过如下的方式来传递参数。

<%@ include file=“welcome.jsp?name=Tom”%>下面用法将会抛出异常，也是不允许的：

<% String path=“login.jsp”;%>

<%@ include file="<%=path%>"%>

如果该属性值以”/“开头，那么指定的是一个绝对路径，将在当前应用的根目录下查找文件；如果是以文件名称或文件夹名开头，那么指定的是一个相对路径，将在当前页面的目录下查找文件。

JSP中常用的动作标识有jsp:include、jsp:forward、jsp:useBean、jsp:setProperty、jsp:getProperty、jsp:fallback、jsp:pugin。本篇主要提及jsp:include动作标识。

jsp:include动作标识使用格式：<jsp:include page=“被包含文件的路径” flush=“true|false”/>

或者向被包含的动态页面中传递参数：

<jsp:include page=“被包含文件的路径” flush=“true|false”><jsp:param name=“参数名称” value=“参数值”/></jsp:include>

page属性：和include指令的file属性一样。

flush属性：表示当输出缓冲区满时，是否清空缓冲区。该属性值为boolean类型，默认值为false，通常情况下设为true。

处理方式不同：使用include指令，被包含的文件的内容会原封不动地插入到包含页中使用该指令地位置，然后JSP编译器再对这个合成地文件进行编译最终编译成的文件只有一个。使用include动作标识，该标识被执行时，程序会将请求转发到（注意是转发而不是请求重定向）被包含的页面，并将执行结果输出到浏览器中，然后返回包含页继续执行后面的代码。服务器执行的是两个文件，JSP编译器会分别对这两个文件进行编译。注：]请求转发，存储在request对象中的信息会被保留并被带到目标页面中；请求重定向，重新生成一个request请求，将该请求重定向到指定的URL，所以事先存储在request对象中的信息都不存在了。

包含方式不同：include指令，静态包含，最终服务器执行的是将两个文件合成后由JSP编译器编译成的一个class文件，若改变被包含的文件，则主文件的代码就发生了改变，服务器会重新编译主文件。include动作标识，动态包含，通常用来包含那些经常需要改动的文件。服务器执行的是两个文件，被包含文件的改动不会影响到主文件，服务器不需要对主文件进行重新编译，只需要重新编译被包含的文件即可，而只有当jsp:include动作标识被执行时，使用该标识时，目标文件才会被编译。

约定不同：include指令的约定index.jsp文件的部分代码

1 <%@ page language=“java” contentType=“text/html; charset=UTF-8”%>
2 <%@ include file=“top.jsp” %>
top.jsp文件的部分代码

1 <%@ page language=“java” contentType=“text/html; charset=GB2312”%>
访问index.jsp将会出现异常

jsp:include动作标识，无需遵循这样的约定，不会出现异常

1 <%@ page language=“java” contentType=“text/html; charset=GB2312”%>
2 <jsp:include page=“top.jsp”/>

本篇转载自博客园用户：52Hz；

收起

展开全文

JSP中include指令和include动作的区别

千次阅读 2018-09-05 13:09:06

2.include动作语法格式: 1)<jsp:include page="文件的URL"/> 2)<jsp:include page="文件的URL">  <jsp:p

1.include指令

语法格式:<%@include file="文件的URL" %>

2.include动作

语法格式:
1)<jsp:include page="文件的URL"/>

2)<jsp:include page="文件的URL">
    <!--param子标记如下-->
     <jsp:param value="" name=""/>
  </jsp:include>

下面来讲一下include指令和include动作的区别:

	include指令	include动作
语法格式	<%@include file="文件的URL" %>	1)<jsp:include page="文件的URL"/> 2)<jsp:include page="文件的URL"> <!--param子标记如下--> <jsp:param value="" name=""/> </jsp:include>
处理方式	在转化成Servlet之前,就把子页面包含进主页面,然后一起转成Servlet,编译生成一个字节码文件这一点可以通过源码看出他是直接合并的	在访问该JSP页面的时候才处理该文件,这一点也不难从源码中看出 PS:类似于方法request.getRequestDispatcher(String arg0).forword(request,response);
执行速度	因为是和主页面编译完成的,页面执行速度肯定是比较快的	因为在访问该子页面才可以编译该页面所以执行稍慢
灵活性	include指令比较依赖主页面上的逻辑和语法格式,灵活性较差	include动作有自己独立的逻辑和语法格式,加上param动作标记处理文件灵活性较好 PS:感觉include动作比较符合面向对象的设计模式中的单一职责原则(高内聚,低耦合)
可维护性	因为主页面或者是子页面的一点改动都有可能影响到子页面或者主页面中的内容,需要改动的地方就会很多,所以维护性较差	有自己独立的逻辑和语法格式,主页面的改动或者是子页面的改动不会相互影响

最后附上include指令和include动作的源码(更容易理解):

1.include指令(做了标记应该不难看出):

1)index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'index.jsp' starting page</title>
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
  </head>
  
  <body>
	<%@include file="Time.jsp" %>
  </body>
</html>

2)Time.jsp

<%@page import="java.text.SimpleDateFormat"%>
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>

    
    <title>My JSP 'Time.jsp' starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->

  </head>
  
  <body>
 	看这边,我是一个include动作啊啊啊啊.....
  </body>
</html>

主页面对应生成的Servletindex_jsp.java:

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/7.0.90
 * Generated at: 2018-09-05 05:02:03 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;
import java.text.SimpleDateFormat;
import java.util.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  static {
    _jspx_dependants = new java.util.HashMap<java.lang.String,java.lang.Long>(1);
    _jspx_dependants.put("/Time.jsp", Long.valueOf(1536123717332L));
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  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('\r');
      out.write('\n');

String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("    <base href=\"");
      out.print(basePath);
      out.write("\">\r\n");
      out.write("    \r\n");
      out.write("    <title>My JSP 'index.jsp' starting page</title>\r\n");
      out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"expires\" content=\"0\">    \r\n");
      out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");
      out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");
      out.write("\t<!--\r\n");
      out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");
      out.write("\t-->\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("\t");
      out.write("\r\n");
      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("\r\n");
      out.write("    \r\n");
      out.write("    <title>My JSP 'Time.jsp' starting page</title>\r\n");
      out.write("    \r\n");
      out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"expires\" content=\"0\">    \r\n");
      out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");
      out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");
      out.write("\t<!--\r\n");
      out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");
      out.write("\t-->\r\n");
      out.write("\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write(" \t看这边,我是一个include动作啊啊啊啊.....\r\n");
      out.write("  </body>\r\n");
      out.write("</html>\r\n");
      out.write("\r\n");
      out.write("  </body>\r\n");
      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);
    }
  }
}

改为include动作:

对印生成的index_jsp.java

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/7.0.90
 * Generated at: 2018-09-05 05:07:30 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  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('\r');
      out.write('\n');

String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

      out.write("\r\n");
      out.write("\r\n");
      out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
      out.write("<html>\r\n");
      out.write("  <head>\r\n");
      out.write("    <base href=\"");
      out.print(basePath);
      out.write("\">\r\n");
      out.write("    \r\n");
      out.write("    <title>My JSP 'index.jsp' starting page</title>\r\n");
      out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");
      out.write("\t<meta http-equiv=\"expires\" content=\"0\">    \r\n");
      out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");
      out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");
      out.write("\t<!--\r\n");
      out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");
      out.write("\t-->\r\n");
      out.write("  </head>\r\n");
      out.write("  \r\n");
      out.write("  <body>\r\n");
      out.write("\t");
      org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "Time.jsp", out, false);
      out.write("\r\n");
      out.write("  </body>\r\n");
      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);
    }
  }
}

总结

Include指令是“先包含，后编译”，在编译时主文件已经包含被include的文件内容（即源代码）；
Include动作是“先运行，后包含”，在运行时主文件才包含被include的文件运行结果。

参考博客

收起

展开全文

include 指令和 include 动作的区别
2020-03-17 23:54:55

include 指令和 include 动作的区别首先，include指令标记的作用就是将JSP文件、HTML网页文件或者其他文本文件静态嵌入到当前的JSP网页中。该指令的语法格式是：<%@include file=“文件的URL”%>。动作标记...

收起

jsp
简析include指令和include动作
2017-12-23 23:02:29

前言在日常开发中，我们项目中的页面都会有一些共同的页面头或者页面脚，这些通过的页面内容，如果每个页面都要自己去写，显然有点多余，（虽然大家都不会去写，...答案肯定是有的，就是通过jsp页面中的include指令和

收起
include指令和include动作的区别
2017-09-27 22:07:59

include指令是编译阶段的指令，即include所包含的文件的内容是编译的时候插入到JSP文件中，JSP引擎在判断JSP页面未被修改，否则视为已被修改。由于被包含的文件是在编译时才插入的，因此如果只修改了include文件内容...

收起

jsp
jsp:include指令和include动作的区别
2020-03-24 22:23:05

include指令和include动作的区别相同点不同点相同点（1）include指令和include动作都能实现将外部文档包含到JSP文档中的功能。不同点（1）激活时间不同，include动作和include指令之间的根本性的不同在于它们被...

收起
include动作标记、param动作标记和forward动作标记
千次阅读 2018-12-25 00:41:48

include动作标记一、基本信息 1、作用：指明当前JSP页面执行阶段所需包含的其他文件。注意：与include指令是不一样的，因为，include指令是在编译阶段完成文件的嵌入，而这里，是在执行的时候嵌入所需要的文件...

收起
编辑写三个jsp页面，include动作标记的用法
千次阅读 2021-09-14 17:51:31

main.jsp使用include动作标记加载circle.jsp和ladder.jsp页面。circle.jsp页面可以计算并显示圆的面积，ladder.jsp页面可以计算并显示梯形的面积。当circle.jsp 和ladder.jsp被加载时获取main.jsp页面include动作...

收起

html jsp
JavaWeb中include指令和include动作
2020-04-15 15:43:11

%@include file=“header.jsp”%> <%–动作的包含–%> <jsp:include page=“footer.jsp?i=<%=i%>>”></jsp:include> 指令的包含和动作的包含的区别： 1.指令的包含在编译时就会包含...

收起

java
jsp的include动作jsp:include和include指令是否可以包含Servlet路径！
千次阅读 2018-05-04 01:35:29

jsp的include动作可以传递参数，而include指令不能传递参数，这就是2者最大的区别，至于网上大篇幅的说什么动态包含和静态包含，我都懒得理，没一点实际的意义！看如下代码 jsp，include动作如下： ...

收起

servlet路径
JSP中include指令与include动作有什么区别？
2019-08-21 18:38:40

1.定义： include指令： <%@ include file = "test....include动作： <jsp:include page = "test.jsp" flush = "true" > <jsp:param name = "name" value = "value" /> </jsp:include> 2...

收起

JSP
jsp中include指令和include动作的区别
千次阅读 2018-12-13 22:46:36

2.include动作：<jsp：include page =“jspInclude.jsp”> </ jsp：include> 二，处理方式不同 1.include指令：将被包含的文件原封不动的插入包含文件，JSP引擎对其同一编译...

收起
移动应用服务器端开发（基于JSP技术）-2017 JSP动作元素 JSP指令元素 - include动作——实验报告.doc
2020-10-18 18:12:05

JSP指令元素 - include动作 PAGE 3 实训实验报告实训(实验)项目: 在JSP页面中使用include动作 实验目的学会在JSP页面中使用include动作 实训实验设计器材步骤结论简介 <jsp:include>动作标签用于包含其他子...

收起
JSP中include指令与include动作标识的区别
千次阅读 2019-03-25 11:12:57

JSP中主要包含三大指令，分别是page，...JSP中常用的动作标识有<jsp:include>、<jsp:forward>、<jsp:useBean>、<jsp:setProperty>、<jsp:getProperty>、<jsp:fallback>、<...

收起
学习笔记：include指令和include动作的区别 -- include动作和forward动作比较
2018-08-10 20:50:41

<%@ include file =".." ...%>和<jsp:include>...1、静态引入jsp文件：jsp指令元素 ...%@ include file="...2、动态引入jsp文件：jsp标准动作 <jsp：include page=...

收起
JSP——简单叙述include指令标记和include动作标记的不同
千次阅读 2019-04-03 13:27:18

（1）include指令标记: 把被包含的文件的内容放于包含文件中组成一个文件后编译运行. ...（2）include动作标记: 把被包含的文件的运行结果放于包含文件运行产生的结果中，这2个文件各自编译运行. ...

收起
include指令与include动作之间的异同
千次阅读 2018-01-17 13:14:02

include动作：" flush="flush" /> (其中flush属性为当缓冲区满时是否清空，SUN公司在JSP1.1标准中规定使用时必须将flush设置为true) a)嵌入内容：指令嵌入的是文本或页面，只能是静态的；动作可以嵌入Servlet，...

收起
做一个通过include指令包含文件，通过include动作包含文件。
2019-12-21 15:14:47

首先要知道include指令和include动作的区别，因为他两至少名称很相似，容易混淆。 ①先来看一下include指令： include可以在jsp页面转换成servlet之前，将jsp代码插入其中。它的格式必须要知道： <%@include ...

收起
include指令与include动作比较
2018-11-16 11:16:47

include动作 语法格式 <%@ include file="…" %> <jsp:include page="…" > 发生作用的时间页面转换期间请求期间包含的内容文件的实际内容（代码） ...

收起

jsp java
Jsp 中 include 指令和 include 动作的区别
千次阅读 2017-10-29 22:38:36

include指令与动作的区别：（1）include 指令只能引入遵循 JSP 格式的文件，被引入的文件与当前 JSP 文件需要共同合并后才能翻译成一个 Servlet 源文件，最终编译的文件只有一个；动作要引入的资源和当前 ...

收起
jsp:include动作和include指令的区别，请举例？
2018-12-07 08:39:25

4.jsp:include动作和<%@ include的区别：马克-to-win：include指令把被包含的文件揉进来一起编译。include动作不是。它是在请求时，将输出结果包含进来。例 4.4.1jsp2.jsp:<%! String name="mark-to-win"; %&...

收起

jsp 马克java社区
实验说明JSP中include指令和include动作指令的区别
千次阅读 2016-03-13 16:41:41

关于include指令和include动作指令的介绍见JSP基本语法(三)首先，我们来看一下include指令所包含的内容与当前页面是一个整体是什么意思。我们在Tomcat安装目录下的webapps文件夹下新建一个文件夹includeTEST，在这里...

收起

jsp

jsp中两种包含关系(include动作和include指令)的区别

浅谈JSP中include指令与include动作标识的区别

include指令与include动作标识的区别

JSP中include指令和include动作的区别

1.include指令

2.include动作

下面来讲一下include指令和include动作的区别:

include指令

include动作

语法格式

处理方式

执行速度

灵活性

可维护性

最后附上include指令和include动作的源码(更容易理解):

总结

Include指令是“先包含，后编译”，在编译时主文件已经包含被include的文件内容（即源代码）；
Include动作是“先运行，后包含”，在运行时主文件才包含被include的文件运行结果。

include 指令和 include 动作的区别

简析include指令和include动作

include指令和include动作的区别

jsp:include指令和include动作的区别

include动作标记、param动作标记和forward动作标记

编辑写三个jsp页面，include动作标记的用法

JavaWeb中include指令和include动作

jsp的include动作jsp:include和include指令是否可以包含Servlet路径！

JSP中include指令与include动作有什么区别？

jsp中include指令和include动作的区别

移动应用服务器端开发（基于JSP技术）-2017 JSP动作元素 JSP指令元素 - include动作——实验报告.doc

JSP中include指令与include动作标识的区别

学习笔记：include指令和include动作的区别 -- include动作和forward动作比较

JSP——简单叙述include指令标记和include动作标记的不同

include指令与include动作之间的异同

做一个通过include指令包含文件，通过include动作包含文件。

include指令与include动作比较

Jsp 中 include 指令和 include 动作的区别

jsp:include动作和include指令的区别，请举例？

实验说明JSP中include指令和include动作指令的区别

include动作

jsp中两种包含关系(include动作和include指令)的区别

浅谈JSP中include指令与include动作标识的区别

include指令与include动作标识的区别

JSP中include指令和include动作的区别

1.include指令

2.include动作

下面来讲一下include指令和include动作的区别:

include指令

include动作

语法格式

处理方式

执行速度

灵活性

可维护性

最后附上include指令和include动作的源码(更容易理解):

总结

Include指令是“先包含，后编译”，在编译时主文件已经包含被include的文件内容（即源代码）； Include动作是“先运行，后包含”，在运行时主文件才包含被include的文件运行结果。

include 指令和 include 动作的区别

简析include指令和include动作

include指令和include动作的区别

jsp:include指令和include动作的区别

include动作标记、param动作标记和forward动作标记

编辑写三个jsp页面，include动作标记的用法

JavaWeb中include指令和include动作

jsp的include动作jsp:include和include指令是否可以包含Servlet路径！

JSP中include指令与include动作有什么区别？

jsp中include指令和include动作的区别

移动应用服务器端开发（基于JSP技术）-2017 JSP动作元素 JSP指令元素 - include动作——实验报告.doc

JSP中include指令与include动作标识的区别

学习笔记：include指令和include动作的区别 -- include动作和forward动作比较

JSP——简单叙述include指令标记和include动作标记的不同

include指令与include动作之间的异同

做一个通过include指令包含文件，通过include动作包含文件。

include指令与include动作比较

Jsp 中 include 指令和 include 动作的区别

jsp:include动作和include指令的区别，请举例？

实验说明JSP中include指令和include动作指令的区别

include动作

Include指令是“先包含，后编译”，在编译时主文件已经包含被include的文件内容（即源代码）；
Include动作是“先运行，后包含”，在运行时主文件才包含被include的文件运行结果。