精华内容
下载资源
问答
  • include静态包含和动态包含的区别
    千次阅读
    2019-03-31 14:36:32

    1. 静态包含使用的是include指令,动态包含使用的是include动态标签。
    ** include指令**:<%@ include file=“需要包含的文件地址” %>
    ** include动态标签**:<jsp:include page=“需要包含的文件地址”></jsp:include>
    2. 静态包含只对源文件进行解析、编译,而动态包含源文件与被包含文件都会进行解 析和编译。
    3. 静态包含一般用于包含html文件,而动态包含一般用于包含jsp文件。
    4. 如果想对被包含的文件进行处理或者操作,那么选择动态包含。因为动态包含会生成解析文件,支持数据交互,无外乎就是servlet之间的数据传递。

    更多相关内容
  • 什么是静态包含?什么是动态包含?两者的区别?的一个简单文档
  • JSP静态包含和动态包含的区别

    千次阅读 2018-09-27 15:19:54
    1、什么是包含?  包含就是Servlet容器将其他Web组件(Jsp、Servlet、Html),将生成的结果包含到自己的结果中。   2、为什么需要包含?  Servlet对象是由Servlet容器创建,Servlet对象的Service()方法是由...

     

    1、什么是包含?

      包含就是Servlet容器将其他Web组件(Jsp、Servlet、Html),将生成的结果包含到自己的结果中。

     

    2、为什么需要包含?

      Servlet对象是由Servlet容器创建,Servlet对象的Service()方法是由servlet容器调用,Servlet之间是不允许相互调用的(Servlet API 2.1以前版本可以)。但又是我们不得不通过多个Servlet组件处理任务,同时方便代码维护管理,提高开发效率。这样就可以需要Servlet转发和包含的技术支持。

     

    3、Jsp页面包含的三种方式

    (a)、include指令
    
        <%@ include file="被包含主组件的绝对URL或相对URL"%>
    
    
    (b)、include标签
        语法一:
        <jsp:include page="被包含主组件的绝对URL或相对URL"/>
        
        语法二:
        <jsp:includepage="login.jsp">
            <jsp:param name="name" value="userName"/>
            <jsp:param name="password" value="userPassword"/>
        </jsp:include>
    
    
    (c)、JSTL标签(不介绍)
    
        <c:import url="http://www.sina.com/index.html"/>

     

    4、包含类型

    包含主要分为静态包含和动态包含,include指令用于静态包含、include标签用于动态包含。无论是静态包含还是动态包含,源组件和被包含的目标组件都共享请求范围内的共享数据。

    • 头部Jsp代码
    <%request.setAttribute("name","LaoYe"); %>
    <%request.setAttribute("age","20"); %>
    
    这是头部 header<b>.jsp</b> 的内容<hr/>
    • 主页Jsp代码
    <!DOCTYPE HTML>
    <html>
      <head>
        <title>首页</title>
      </head>
      <body>
            //静态包含
            <%@ include file="header.jsp" %>
      		
        	这是首页index.jsp内容<br/>
        	
        	Name = ${name}
        	age = ${age}
        	sex = ${sex}
        	
            //动态包含
        	<jsp:include page="footer.jsp"/>
      </body>
    </html>
    • 底部Jsp代码
    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <!DOCTYPE HTML>
    <html>
      <head>
        <title>底部</title>
      </head>
      <body>
        	<hr/>这是底部foot<b>.jsp</b>的内容
        	<%request.setAttribute("sex","男"); %>
      </body>
    </html>
    • 最终结果

    从结果我们可以看出sex的值我在footer.jsp设置了request域的sex值为男,但是最终的输出却为空的字符串,这是因为footer.jsp在最后动态包含时,程序从上往下执行时还未执行到这里,所以无法获取到sex的值。例如将上面的index.jsp稍作修改之后,得到如下结果。

    <!DOCTYPE HTML>
    <html>
      <head>
        <title>首页</title>
      </head>
      <body>
      		
        	这是首页index.jsp内容<br/>
        	
        	Name = ${name}	<br/>
        	age = ${age}	<br/>
        	sex = ${sex}
        	
        	<%@ include file="header.jsp" %>
        	<jsp:include page="footer.jsp"/>
      </body>
    </html>

    最终的结果如下所以,可以看出所有的值均为空字符,所以在包含时我们应该注意一下请求参数的位置

     

    5、编译过程

    运行Servlet容器之后访问页面,Servlet容器会将Jsp源代码编译成Servlet源文件,然后再把它编译成Servlet类。我们打开文件之后可以看到,include指令的静态包含完全的嵌入到了index.jsp页面中,而include标签的动态包含则通过调用JspRuntimeLibrary.include(request, response, "footer.jsp", out, false)方法来解析footer.jsp,如果没有语法错误,则会吧footer.jsp翻译成Servlet源文件,然后再编译Servlet源文件。

     

    在Tomcat的Servlet源文件和Servlet类的文件目录中,存在如下文件

     

    (a)、静态包含

    文件中唯独没有header_jsp.java和header_jsp.class文件,再看上一张图可以发现。静态包含发生在解析JSP源组件阶段,被包含的目标文件中的内容被原封不动的添加到了JSP源组件中,Servlet容器然后再对JSP源组件进行翻译和编译。

    注意:静态包含的目标组件可以为HTML文件或JSP文件,但不允许为Servlet。如果目标组件为JSP文件,那么该JSP文件可以访问再源组件定义的局部变量,因为实际上,JSP源组件和JSP目标组件对应同一个Servlet(即Servlet不能包含另一个Servlet,他们之间只存在调用关系,而不存在包含关系。静态包含中的源组件和目标组件都在同一个Servlet中)。

    在静态包含时,我们应该要注意的一点是,Java代码片段里面不能重复出现相同的变量,否则程序将报错。

    错误提示:

     

    (b)、动态包含

    当客户端首次请求访问index.jsp时,Tomcat解析index.jsp并将它翻译为Servlet源文件。index.jsp中的include标签被翻译为org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "footer.jsp", out, false)。当Servlet容器执行JspRuntimeLibrary.include(...)方法时,会解析index.jsp。如语法无误,则将footer.jsp翻译为Servlet源文件,在编译Servlet源文件。假定无编译错误,将生成Servlet类,再初始化该Servlet并调用它的服务方法。

    当容器执行完JspRuntimeLibrary.include(...)方法后,继续执行index.jsp代表的Servlet的服务方法中的后续代码。

    • 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>
    <html>
      <head>
        <title>首页</title>
      </head>
      <body>
      	<%System.out.println("header_jsp.java编译前");%>
      	<jsp:include page="header.jsp"/>
      	<%System.out.println("header_jsp.java编译后");%>
      </body>
    </html>
    • header.jsp页面
    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <!DOCTYPE HTML>
    <html>
      <head>
        <title>底部</title>
      </head>
      <body>
    	<%System.out.println("header_jsp.java编译中");%>
      </body>
    </html>
    • 最终输出结果

      

     

    6、混合使用静态包含和动态包含

    在我们实际应用中,很少说一个页面只用静态包含或只用动态包含的。而是根基实际情况,对页眉页脚、导航栏之类的静态内容我们就用静态包含,对数据库实时查询、时间戳等动态内容我们就用动态包含。具体情况,具体使用,动静结合,灵活搭配。

     

    7、总结

    1、<%@include file="xxx.jsp"%>为jsp中的编译指令,其文件的包含是发生在jsp向servlet转换的时期,而<jsp:include page="xxx.jsp">是jsp中的动作指令,其文件的包含是发生在编译时期,也就是将java文件编译为class文件的时期 

    2、使用静态包含只会产生一个class文件,而动态包含产生多个class文件 

    3、使用静态包含,包含页面和被包含页面的request对象为同一对象,因为静态包含只是将被包含的页面的内容复制到包含的页面中去;而动态包含包含页面和被包含页面不是同一个页面,被包含的页面的request对象可以取到的参数范围要相对大些,不仅可以取到传递到包含页面的参数,同样也能取得在包含页面向下传递的参数

    4、静态包含一般用于加载进页面显示后就再也不变的东西,比如页眉、背景、标题等等。静态包含不会检查所含文件的变化,把文件包含进来后,被包含文件的修改变化是不会影响已被包含进来的内容的。因为,静态包含发生在编译阶段。比如:a.jsp中使用了语句 <%@ include file="b.jsp"%>,把b.jsp包含了进来,那么在编译a.jsp文件时,会直接把b.jsp文件的内容全部内嵌到a.jsp文件中包含b的语句的位置。然后运行a,显示a页面。也就是说,静态include是先把被包含文件的内容全部复制内嵌到包含文件中,再进行编译运行的。也正是因为要把b包含进a,所以b中的变量等不能与a重复,否则会报错。

    动态包含用于加载经常变化的、要求显示最新版本内容的东西,比如提交时间戳:用户打开博客编辑页面时,有一个时间加载进来了。用户编写完博客,点击提交时,就应该使用/显示提交瞬间的时间而不是打开编辑页面时的那个时间。所以这里要用的就是最新时间。由上面我们知道,静态include是先包含进来,再编译,运行并传回浏览器显示的,所以不能满足我们要求某些部分使用最新内容的要求。那么,我们就要用到动态include。

    动态include与静态include的最大不同在于:包含文件与被包含文件都是先编译执行,再包含。二者的编译阶段是相互独立的,只有在包含文件的include语句处把被包含文件的执行结果包含进来。换言之,包含文件先编译,执行。执行到了include语句的时候才触发被包含文件的编译、执行,并实时把结果包含进来。从而达到获取最新的被包含内容的目的。同样使用a.jsp包含b.jsp的例子:加入a.jsp中动态include了b.jsp。现在,a先编译成servlet类文件,然后运行,当运行到包含b的语句处,引起b的编译,运行,并把b的运行servlet运行结果包含进a。最后a顺利运行完毕,把a的servlet类运行结果输出到浏览器显示。

     综上所述,我们可以一句话辨析静态include与动态include的区别:静态include是编译阶段的代码拼接,动态include是编译后的servlet的运行结果的拼接。

    展开全文
  • JSP之include动态包含与静态包含

    千次阅读 2018-10-04 10:15:13
    另一种是标签包含,也就是动态包含。 静态包含:&lt;%@include file="包含文件"%&gt; 静态包含的方式会直接将包含文件的代码融入到主文件的include指令处,然后对主文件进行编译、运行。所以,...

    include 有两种包含方式,一种是指令包含,也就是静态包含;另一种是标签包含,也就是动态包含。

    静态包含:<%@include file="包含文件"%>

    静态包含的方式会直接将包含文件的代码融入到主文件的include指令处,然后对主文件进行编译、运行。所以,静态包含只会生成主文件jsp对应的一个java文件。

    示例:

    test.jsp:

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    
    <head>
        <title>练习</title>
        <script src="http://apps.bdimg.com/libs/jquery/1.6.4/jquery.js"></script>
    </head>
    <body>
    <%
        int x=5;
    %>
    <%@include file="test2.jsp"%>
    </body>
    </html>

    test2.jsp :

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
    </head>
    <body>
    <%
        int a=6;
    %>
    <%=x%>
    
    </body>
    </html>

    启动tomcat访问test1.jsp运行结果:

    5

    work目录下生成的文件(发现只对test.jsp进行了编译):

    打开test_jsp.java(其中一个部分代码):

     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\n");
          out.write("<html>\r\n");
          out.write("\r\n");
          out.write("<head>\r\n");
          out.write("    <title>练习</title>\r\n");
          out.write("    <script src=\"http://apps.bdimg.com/libs/jquery/1.6.4/jquery.js\"></script>\r\n");
          out.write("\r\n");
          out.write("</head>\r\n");
          out.write("<body>\r\n");
    
        int x=5;
    
          out.write('\r');
          out.write('\n');
          out.write("\r\n");
          out.write("\r\n");
          out.write("<html>\r\n");
          out.write("<head>\r\n");
          out.write("\r\n");
          out.write("</head>\r\n");
          out.write("<body>\r\n");
    
        int a=6;
    
          out.write('\r');
          out.write('\n');
          out.print(x);
          out.write("\r\n");
          out.write("\r\n");
          out.write("</body>\r\n");
          out.write("</html>\r\n");
          out.write("\r\n");
          out.write("</body>\r\n");
          out.write("</html>\r\n");
          out.write("\r\n");

    可以看到,两个jsp文件融为一个被编译了。所以,这两个jsp文件不能有冲突的地方。比如test.jsp文件定义了int x=5,在test2.jsp文件就不能再定义int x。jsp开头的page指令内容也要一致,不能有冲突,否则也会报错。

    另外,这两个jsp文件既然可以看成是一个合体的jsp文件,那么服务器传递过来的参数(比如request)它们就都能接收的到。

     

    动态包含:<jsp:include page=" 包含文件">

    动态包含的方式不是先把两个jsp文件的代码融合再编译,而是执行到了include语句的时候才触发包含文件的编译、执行,并把执行的结果包含进来。所以,这里会产生两个java文件。由于两个jsp文件是相互独立编译运行的,所以它们的变量是不共享的。

    示例:

    test.jsp:

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    
    <head>
        <title>练习</title>
        <script src="http://apps.bdimg.com/libs/jquery/1.6.4/jquery.js"></script>
    </head>
    <body>
    <%
        int x=5;
    %>
    <jsp:include page="test2.jsp"></jsp:include>
    </body>
    </html>

    test2.jsp:

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
    </head>
    <body>
    <%
        int a=6;
    %>
    <%=x%>
    
    </body>
    </html>

    访问test.jsp运行结果:

    由于在test.jsp中定义的变量x在test2.jsp中是访问不到的,所以抛出异常。于是,我们把test2.jsp中的x改成a,再运行,看看work目录下生成的文件:

    打开test_jsp.java:

        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\n");
          out.write("<html>\r\n");
          out.write("\r\n");
          out.write("<head>\r\n");
          out.write("    <title>练习</title>\r\n");
          out.write("    <script src=\"http://apps.bdimg.com/libs/jquery/1.6.4/jquery.js\"></script>\r\n");
          out.write("</head>\r\n");
          out.write("<body>\r\n");
    
        int x=5;
    
          out.write('\r');
          out.write('\n');
          org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "test2.jsp", out, false);
          out.write("\r\n");
          out.write("</body>\r\n");
          out.write("</html>\r\n");
          out.write("\r\n");

    可以看到,是直接用了include()方法将test2.jsp文件执行的返回结果包含进来,并且这里将request和response都作为参数传递给了test2.jsp,所以这两个jsp文件同样都能接收到来自服务器传递过来的参数(比如request)。

    再打开test2_java.jsp(内容完全就是对test2.jsp的编译):

    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\n");
          out.write("\r\n");
          out.write("<html>\r\n");
          out.write("<head>\r\n");
          out.write("</head>\r\n");
          out.write("<body>\r\n");
    
        int a=6;
    
          out.write('\r');
          out.write('\n');
          out.print(a);
          out.write("\r\n");
          out.write("\r\n");
          out.write("</body>\r\n");
          out.write("</html>\r\n");

     

    使用总结:

    静态包含执行效率会更快,但是有可能发生变量冲突的问题。另外使用静态包含如果包含的文件发生了变化的话,所有包含它的servlet都要重新编译更新,这是一个很大的代价。通常情况下使用动态包含比较多。对页眉页脚、导航栏之类的静态内容我们就用静态包含,对数据库实时查询、时间戳等动态内容我们就用动态包含。

     

    参考博客:https://www.cnblogs.com/ygj0930/p/6044676.html

                      https://blog.csdn.net/jdjdndhj/article/details/52704308

    展开全文
  • 二、静态包含和动态包含2.1 语法格式2.2 过程2.2.1静态包含过程2.2.1动态包含过程三、两者的主要区别 前言 JSP全称Java Server Pages,是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。 一、...


    前言

    JSP全称Java Server Pages,是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。


    一、include指令是什么?

    JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分,会被同时编译执行。

    根据指令的不同分为两种:

    • 1 静态包含
    • 2 动态包含

    二、静态包含和动态包含

    2.1 语法格式

    1.静态包含

    <%@ include file="文件相对 url 地址" %> 
    

    2.动态包含

    1 <jsp:include page="文件相对 url 地址" />
    2 <jsp:include page="文件相对 url 地址"></jsp:include>
    

    2.2 过程

    2.2.1静态包含过程

    在这里插入图片描述
    分为以下三步:

    1. 将被包含的 jsp文件1 放入 jsp文件2 中
    2. 将文件2 放入服务器解析
    3. 生成一个.java 文件

    如下图所示:
    文件1 为content.jsp
    在这里插入图片描述

    文件2 为static.jsp
    在这里插入图片描述
    可见文件2中有文件1 ,文件1是被包含的文件。

    通过apache-tomcat-9.0.22\work\Catalina\localhost\Jsp_02\org\apache\jsp路径可以找到static文件,只有一个.java文件
    在这里插入图片描述
    查看static_jsp.java源代码。下图可见 确实将 文件1的内容复制到文件2
    在这里插入图片描述

    2.2.1动态包含过程

    在这里插入图片描述
    分为以下五步:

    1. 将被包含的 jsp文件1 直接放入服务器解析
    2. 生成文件1.java文件
    3. 将文件1的结果放入文件2中
    4. 再将文件2 放入服务器解析
    5. 生成一个文件2.java 文件

    如下图所示:
    文件1 还是content
    文件2:
    在这里插入图片描述
    根据时间,可以看出content.java先生成。
    在这里插入图片描述
    查看dynamic_jsp.java源代码。通过下图可以看到,是直接用了include()方法

    	org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, url , out, false);
    

    将content.jsp文件执行的返回结果包含进来。
    且将request和response传递给了content.jsp,由此可见动态包含的一个关键特点:可以用来传递参数。
    在这里插入图片描述

    三、两者的主要区别

    过程是最主要的区别,除了以上之外,还有一下的区别(主要是2 3 传递参数和url地址的区别)。

    1 	<jsp:include>是动态包含
    	而<%@ include%>是静态包含。		
    2	动态包含可以给被包含的页面传递参数。	
    	静态包含不能给被包含的页面传递参数。
    3	动态包含的地址可以是变量。
    	静态包含的地址是常量。
    4	<jsp:include page=“file” flush=“true” />它总是会检查所含文件中的变化。
    	而<%@include file=“file”%>不会检查所含文件的变化,适用于包含静态页面。
    

    展开全文
  • 静态包含和动态包含的区别

    千次阅读 2017-03-16 21:42:09
    静态包含 vs 动态包含的区别? 1) 语法不同 静态包含语法: 动态包含语法:  2)参数传递不同 静态包含不能向被包含页面传递参数 动态包含可以使用jsp:param标签向被包含页面传递参数 ...
  • 静态包含是通过JSP的include指令包含页面,动态包含是通过JSP标准动作&lt;jsp:include&gt;包含页面。 静态包含是编译时包含,如果包含的页面不存在则会产生编译错误,而且两个页面的"contentType"...
  • 静态包含:include指令 ...include指令的具体语法格式如下所示: <%@ include file="被包含的文件地址"%> 注意:插入的文件一般不以"/"开头,而是使用...动态包含:<jsp:include>动作元素 在JSP页面中,...
  • JSP包含有两种方式:静态包含和动态包含。下面我们将通过JSP运行的特点(转换为servlet再执行)来比较二者的区别。一、静态包含 我们先写一个正常的小项目,来看下静态包含是如何运行的。测试一:top.jsp页面: ...
  • 静态包含和动态包含的区别 静态包含... 动态包含在翻译的时候,每个JSP文件都翻译成了对应Servlet,在程 序运行加载到JVM中的时候动态合并 动态包含可以传递参数 如何选择:如果需要传递参数就必须选择动态包含...
  • JSP中静态包含和动态包含的区别?

    千次阅读 2016-04-23 16:01:43
    动态包含: 2.静态包含时,包含页面和被包含页面中的html.head,body等标签总共只有出现一次,否则会报错;而动态包含不会。 3.静态包含不会检查所包含文件中的变化;但是动态包含,可以检查所含文件中的变化,并且...
  • 动态包含()

    千次阅读 2016-07-01 15:48:15
    动态包含()  使用指令可以完成动态包含的操作,与使用JSP指令中的include实现的静态包含不同,动态包含语句可以自动区分被包含的页面是静态还是动态。 如果被包含的页面是静态页面,则与静态包含相同,把文件...
  • include静态包含和动态包含

    千次阅读 2017-11-01 21:42:31
    include静态包含index3.jsp <!-- 静态包含jsp --> <!-- 把 head.jsp(只能是片段)当成文本内容包含到index3.jsp页面内部, tomcat翻译时,只会产生一个index3_jsp.class文件 --> </body>include/head.jsp去掉七
  • 动态包含:&lt;jsp:include page="被包含页面"flush="true"&gt;。下面以一个例子来说明如何使用包含。 实例: 项目文件树: header.jsp文件中内容:1234567&lt;html&gt; ...
  • 这篇文章主要介绍了JSP页面的动态包含和静态包含示例及介绍,本文讲解了它们的区别并给出了相应例子,需要的朋友可以参考下 一、静态包含 本文介绍JSP静态包含语句,即使用JSP的include指令来完成的包含操作。 ...
  • JSP中的动态包含和静态包含的区别

    千次阅读 2013-01-17 09:11:09
     (2)动态包含:。 2. 包含时间  (1)静态包含:JSP程序被翻译成Servlet之前包含;  (2)动态包含:JSP程序运行时包含。 3. 逻辑性  (1)静态包含:包含文件和被包含文件在逻辑上是统一的;  (2)...
  • jsp中静态包含跟动态包含的区别

    千次阅读 2018-06-28 17:17:27
    在jsp当中经常需要嵌套其他的jsp页面,以提高代码利用率跟工作效率。常用的jsp嵌套包括静态包含跟动态包含两种方式,那这两种方式有啥区别呢。下面这张图很好的解释了两者的区别:...
  • jsp中静态包含 vs 动态包含的区别?

    千次阅读 2017-07-27 16:39:50
    1) 语法不同 ...动态包含语法:  2)参数传递不同 静态包含不能向被包含页面传递参数 动态包含可以向被包含页面传递参数 3)原理不同 静态包含: 先合并再翻译 动态包含: 先翻译再合并
  • JSP中的动态包含和静态包含

    千次阅读 2016-03-05 10:04:50
    JSP动态导入<jsp:include file=""> :所谓的动态包含指,当请求被包含页面时, 先处理被包含页面,然后将 被包含页面的处理结果 插入到当前页面中的jsp:include位置。 适用于经常变化的被包含页面。 ...
  • 一、静态包含指令 1、两个jsp页面的应该保持一致 2、不能通过fileurl向被包含的jsp页面传递参数,因为此静态包含是发生在jsp页面转换为servlet的转换期间,此时的参数是服务器端设置的死的参数,完全没有经过...
  • include:静态包含和动态包含

    千次阅读 2010-11-13 10:26:00
    include指令分为静态包含和动态包含,下面一一消化……静态包含:相当于被包含页面直接放到包含页来,然后再进行编译执行。语法:file="路径名" %>动态包含:被包含页先进行执行后才放到包含页。其中分为两种,一种...
  • jsp中静态包含和动态包含的区别

    千次阅读 2017-01-03 23:49:00
    一、静态包含指令 1、两个jsp页面的应该保持一致 2、不能通过fileurl向被包含的jsp页面传递参数,因为此静态包含是发生在jsp页面转换为servlet的转换期间,此时的参数是服务器端设置的死的参数,完全没有经过...
  • 动态包含与静态包含的区别

    千次阅读 2013-08-09 17:32:37
    当上段的代码如果使用来包含include.jsp的时候。由于局部变量X而冲突出错!动态包含则没有出错, 动态包含是先处理后包含的方式,包含的是处理后的结果,故优先使用动态包含
  • 在今天编写项目时遇到一个问题,是关于Thinkphp不支持include动态包含的问题。在网上遍寻答案才找到了一个比较简单且完美的解决方案。其实这个问题在编写过程中很容易遇到,模板头部会包含不同用户的信息,但是...
  • 测试Jsp 静态包含和动态包含

    千次阅读 2013-03-10 20:05:19
    动态包含是指在请求包含页面的时候遇到动态包含指令将请求转到被包含页面,这时去编译被包含页面。   测试项目   静态包含 Header.jsp Insert title here I'm Header Content.jsp He
  • 2.include动作(动态包含) 静态包含:<%@include file="demo.jsp"% > 将include的文件直接解析到当前页面。弊端:例如当前界面与引用的文件不能有重名等。 如下面的a变量,在demo.jsp中也定义了a变量。静态...
  • JSP的动态包含和静态包含详解

    千次阅读 2007-10-25 17:46:00
    jsp中有两种包含模式,一种是,这种叫静态包含,另一种是 ,这叫做动态包含. 静态包含是直接把要包含的页面原样嵌入总的页面后再统一编译,而动态包含总的页面和要嵌入的页面是分开编译的. 现在看到这两种包含的意义了...
  • JSP中的静态包含和动态包含

    千次阅读 热门讨论 2013-09-11 10:56:45
    接触过asp.net的都知道它里面有母版这么一种东东,而jsp又... file="被包含页面"%>和动态包含:。下面以一个例子来说明如何使用包含。 实例: 项目文件树: header.jsp文件中内容: Insert title here This i

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,469,325
精华内容 587,730
关键字:

动态包含