JSP的静态包含和动态包含详细讲解 （一）

最新推荐文章于 2020-04-23 15:40:50 发布
最新推荐文章于 2020-04-23 15:40:50 发布
阅读量2w 收藏 23
点赞数 10
分类专栏： web开发技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdjdndhj/article/details/52704308
版权

JSP包含有两种方式：静态包含和动态包含。下面我们将通过JSP运行的特点（转换为servlet再执行）来比较二者的区别。


一、静态包含  <%@include file=“url”%>

 我们先写一个正常的小项目，来看下静态包含是如何运行的。

测试一：

top.jsp页面：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>top</title>
</head>
<body>
	<h2>这是TOP页面</h2>
</body>
</html>

footer.jsp页面：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>footer</title>
</head>
<body>
	<h2>脚页</h2>
</body>
</html>

index.jsp页面：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>首页</title>
</head>
<body>
	
	<%@include file="top.jsp"%>
	<h1>这是首页</h1>
	<%@include file="footer.jsp"%>
</body>
</html>

在index页面中使用的是静态包含，将top和footer两个页面包含进来，现在运行一下，看临时文件夹中会产生几个Java文件

wKiom1fr1arSanRQAACGc9TPk10382.png-wh_50

从这可以看出，运行这个项目只会生成一个Java文件，说明运行这个项目相当于只运行一个页面，点开Java文件看源码：

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/7.0.41
 * Generated at: 2016-09-28 14:18:14 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.*;

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>(2);
    _jspx_dependants.put("/top.jsp", Long.valueOf(1475071806944L));
    _jspx_dependants.put("/footer.jsp", Long.valueOf(1475071854827L));
  }

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

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

  public void _jspInit() {
    _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
    _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
  }

  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\n");
      out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
      out.write("<title>首页</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("\t");
      out.print(request.getContextPath() );
      out.write('\r');
      out.write('\n');
      out.write('	');
      out.write("\r\n");
      out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
      out.write("<title>top</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("\t<h2>这是TOP页面</h2>\r\n");
      out.write("</body>\r\n");
      out.write("</html>");
      out.write("\r\n");
      out.write("\t<h1>这是首页</h1>\r\n");
      out.write("\t");
      out.write("\r\n");
      out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
      out.write("<title>footer</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
      out.write("\t<h2>脚页</h2>\r\n");
      out.write("</body>\r\n");
      out.write("</html>");
      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 { 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);
    }
  }
}

从这个源码可以看出，index是将两个JSP文件先包含进来，再运行。


结论1：静态包含是先将页面代码包含进来，再运行。


测试2：

    结论1中得出，静态包含是先包含代码进来再运行，既然先包含代码，那么包含的代码之间会有冲突吗？下面我们再测试一下，包含的页面之间代码是否会冲突。只要让代码产生冲突，最简单的就是让JSP的指令不一样就可以了。下面我们就只改动top.jsp页面代码，将指令中的编码格式改一下：

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GBK">
<title>footer</title>
</head>
<body>
	<h2>脚页</h2>
</body>
</html>


重新运行index.jsp页面：

wKiom1fr14ThLCg3AAClByvsC34896.png-wh_50

运行之后会发现报错了，报错的信息是：

/footer.jsp (line: 1, column: 2) Page directive: illegal to have multiple occurrences of contentType with different values (old: text/html; charset=UTF-8, new: text/html; charset=GBK)

结论2：因为静态包含是先将页面代码包含进来，再运行，所以页面之间相同标签属性配置不同的话会有冲突。至少两个jsp页面的<%@page contentType=“text/html；charset=utf-8”%>应该保持一致。同理，包含的jsp页面与被包含的jsp页面最好没有重复的html标签。否则会发生覆盖现象。


测试3：

    静态包含时，能否传递参数呢？这种时候传递参数，一般大家都会想到地址传参：<%@include file="top.jsp?i=9"%>，这样是否能正常运行呢？答案是不能！！！因为此时的页面是直接被包含进来的，这样设置参数传递是没有任何意义的。甚至是不能通过编译！


测试4：

    既然是直接把代码包含进来，那么服务器通过响应请求传递过来的参数，是否能够被两个页面共用呢？下面写一个简单的地址传参进行验证。

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<a href="index.jsp?i=9">首页</a>
</body>
</html>

在其单个页面中输出该i值，看是否能输出9：

wKioL1fr2_ny1_NyAAAb4-9D3DQ749.png-wh_50


结论3：三个页面都能通过request接收到test.jsp页面传来的值，说明这三个或页面是共享一个request的。

    


关于JSP动态包含，请阅读 JSP的静态包含和动态包含详细讲解 （二）


CSDN博客地址：http://blog.csdn.net/jdjdndhj 欢迎关注！

本文出自 “程序猿的故事” 博客，转载请与作者联系！

AProMonkey
关注
专栏目录
javaweb--jsp-include静态包含、动态包含
刘向阳的博客
09-07 629
include静态包含 格式： <%@include file="要包含的页面地址"%> 特点： 1.将内容进行了直接的替换 2.静态包含只会生成一个源码文件，最终的内容全部在_JspService方法体中(源码文件中) 3.不能出现同名变量 4.运行效率高一点点，耦合性较高，不够灵活 代码： <html> <head> <title>include静态包含</title> </head> <body> &lt
JSP之include动态包含与静态包含
a631278993的博客
11-08 1153
转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/6044676.html　 　JSP中，include是一个经常用到的标签。当应用程序中所有的页面的某些部分(如标题、页脚和导航栏)都相同的时候,我们就可以考虑用include。但是相同的部分有静态的（装载进页面显示后再也不变的），有动态的（装载进页面后还会改变，如：随时间改变、随用户行为改变等）。那...
JSP的动态包含与静态包含
积累与坚持
09-20 170
使用 &lt;%@include...%&gt; 静态包含 简单的理解就是你可以认为 这两个页面代码是写在同一个页面里。使用 &lt;jsp:include...&gt; 动态包含 当 向这个页面发出请求 后。会转发到 include 的那个页面去执行。 执行完了后又接着执行本页面余下的代码。   &lt;%@ include file=""%&gt;指令在编写代码...
JSP静态包含和动态包含的区别
ACodeBird
07-16 188
1.静态包含：是将两个jsp页面合并到一起再翻译成servlet,然后再运行 2.动态包含：是将1.jsp翻译成servlet，然后运行到动态包含的代码再去找2.jsp，将2.jsp翻译成serlvet再编译运行 总结：静态包含就是先引入页面再运行；动态包含是需要时才引入页面 ...
jsp 静态包含和动态包含区别
91奔跑的蜗牛
12-20 678
静态包含：&lt;%@include file="被包含页面"%&gt; 动态包含：&lt;jsp:include page="被包含页面"flush="true"&gt; 区别： 静态包含，最后只生成一个字节码文件。 如： A.jsp 静态包含 B.jsp，C.jsp ，编译后只生成 A_jsp.class的字节码。 也就是说，静态包含在转换成为java文件的时候将包含文件的内容“复制...
java-jsp技术讲解
最新发布
04-10
- **易于维护：**JSP使得动态内容和静态内容分离，便于维护。 - **强大的功能扩展：**借助于Java的强大功能，JSP可以实现复杂的业务逻辑。 - **与HTML和XML集成：**JSP可以很好地与HTML和XML集成，提供丰富的展示...
Java面试精华：深入理解静态内嵌类、JSP动态与静态包含、断言与GC
而静态INCLUDE则是一次性包含，不会检查文件变化，适合包含静态页面。 然后，讲解了Java中的assert关键字在软件开发中的应用。assertion是一种断言机制，用于在开发和测试阶段确保程序的基本正确性，通过检查布尔...
深入讲解JSP 2.0下的动态内容缓存技术.pdf
11-25
这样，每次请求都会有一个新的计数器值，但其他静态内容则从缓存中获取，从而实现了动态和静态内容的结合。 总的来说，JSP 2.0的动态内容缓存技术通过自定义标签和EL API提供了灵活的缓存解决方案，能够在提高性能...
JSP入门：静态网页与动态环境搭建详解
JSP是Java用于构建动态网页的技术，它允许在服务器端嵌入Java代码，从而实现页面内容的动态生成，增强了网页的交互性和响应能力。 章节首先定义了静态网页的概念，静态网页是由HTML标记语言编写的，内容固定不变，...
JSP中静态包含和动态包含的区别
Sam_geek的博客
01-03 520
转自：http://blog.csdn.net/anxinliu2011/article/details/7515618 动态包含与静态包含的区别 1.动态包含用的元素是page，而且有两种形式。静态包含用的是file,只有一种形式。 2.生成的文件不同，静态的包含是将两个jsp文件二合一，生成一个以包含页面命名的servlet和class文件，动态包含的两个jsp文件各自生成自
JSP中静态包含与动态包含的区别
Coldzerace的博客
03-26 387
静态包含 includeinclude 是包含页面的指令，属于静态页面引入。页面引入的好处在于：可以把多个页面共同的部分抽象出来定义。&lt;%@include file="head.jsp" %&gt; &lt;h1&gt;content&lt;/h1&gt; &lt;%@include file="foot.jsp" %&gt;动态包含&lt;jsp:include /&gt;&amp
浅谈jsp静态包含和动态包含
Alyssa_xiong的博客
09-03 980
静态包含和动态包含 静态包含（属于指令） 定义：在jsp编译时插入一个包含文本或者代码的文件（不识别被包含的文件是静态的页面还是动态的页面），这个过程是 静态的，而包含的文件可以是jsp文件，HTML等，先包含，然后再将全部代码一起处理 语法：<%@ include file="要包含的文件路径"%>这个是属于指令，属于jsp语法范畴 动态包含（属于标签） 定义：...
Java解析JSP表达式
+e的专栏
01-09 2191
最近系统中希望可以动态解析用户传入的变量，在调研了一下决定JSP表达式是一个非常合适的选择，并且支持嵌套。所以对如何在JAVA中提供并解析标准的JSP表达式做一下总结。 在解析时使用了以下两个包： commons-el commons-el 1.0
JSP 学习笔记
吴杨的博客
04-13 5767
目录目录 JSP 基础语法 页码指令page 文件包含指令include 引用标签库指令taglib 代码片段 JSP 表达式 巧用注释 HTML 注释 JSP 动态注释 JSP 动作标识 包含外部文件的动作标识 请求转发的动作标签 设置参数的自动作标识动作标识 JSP 内置对象 页面请求对象request 获取请求参数 获取表单提交信息 解决中文乱码问题在作用域中管理属性 获取cookie 显示国
静态包含和动态包含
monchhichl123的博客
07-02 421
JSP静态导入（JSP指令标记include） JSP页面第一次被请求时，会被JSP引擎转译成Servlet的Java文件，然后再被编译成字节码文件执行。JSP指令标记为JSP页面转译提供整个页面的相关信息。 include指令用于在JSP页面静态插入一个文件，被插入的文件可以是JSP页面、HTML页面、文本文件或一段Java代码。使用了include指令的JSP页面在...
JavaWeb学习心得之JSP指令
寒风中的信
10-27 364
一、JSP指令概述        JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何输出，而只是告诉引擎如何处理JSP页面中的其余部分。        JSP定义了3个指令：page、include和taglib。        基本语法： 举例： 注意：如果有多个属性，可以写在一个指令中，也可以分开写。 二、Page指令        作用：pag
javaweb之jsp指令
weixin_40273144的博客
04-23 327
1.JSP指令简介 JSP指令是为JSP引擎设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。 在JSP 2.0规范中共定义了三个指令：page指令，Include指令，taglib指令。 JSP指令的基本语法格式：<%@ 指令 属性名="值" %> 例如： <%@ page contentType="text/html;charse...
JavaWeb 动态页面技术之 jsp
young_1004的博客
08-05 957
JSP技术 1.jsp脚本和注释     jsp脚本：         1）&lt;%java代码%&gt;——&gt;内部的 java 代码翻译到 service 方法内部。         2）&lt;%=java变量或表达式&gt;——&gt;会被翻译成 service 方法内部 out.print()。         3)  &lt;%! java代码%&gt;——&gt;...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值