<jsp:include>和<%@include%>的区别

最新推荐文章于 2021-06-29 11:28:19 发布
最新推荐文章于 2021-06-29 11:28:19 发布
阅读量597 收藏 1
点赞数
分类专栏： 寻觅不同 文章标签： include 静态包含 动态包含 jsp 区别

<jsp:include> ：动态包含

第一种情况（<jsp:include>包含的是html文件）：

DynamicInclude.jsp:

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <html>  
  3.          <head>  
  4.                    <title>动态包含</title>  
  5.          </head>  
  6.          <bodystylebodystyle="background-color:lightblue">  
  7.    
  8.                    <jsp:include page="header.html"flush="true"/><!--动态包含-->  
  9.    
  10.                    <tablebordertableborder="1" align="center">  
  11.                             <tr>  
  12.                                      <td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>  
  13.                             </tr>  
  14.                             <tr>  
  15.                                      <td>a</td><td>b</td><td>c</td><td>d</td>  
  16.                             </tr>  
  17.                    </table>  
  18.          </body>  
  19. </html>  


Header.html ：

[html]  view plain  copy
  1. <h2styleh2style="font-family:arial;color:red;font-size:25px;text-align:center">  
  2.          动态包含的标题(HTML)  
  3. </h2>  

运行之后，只生成一个servlet，和上面的代码对应如下：

[java]  view plain  copy
  1. out.write("\r\n");  
  2. out.write("<html>\r\n");  
  3. out.write("\t<head>\r\n");  
  4. out.write("\t\t<title>动态包含</title>\r\n");  
  5. out.write("\t</head>\r\n");  
  6. out.write("\t<bodystyle=\"background-color:lightblue\">\r\n");  
  7. out.write("\r\n");  
  8. out.write("\t\t");  
  9. <span style="color:#ff0000;">org.apache.jasper.runtime.JspRuntimeLibrary.include(request,response, "header.html", out, true);</span>  
  10. out.write("<!--动态包含-->\r\n");  
  11. out.write("\r\n");  
  12. out.write("\t\t<table border=\"1\"align=\"center\">\r\n");  
  13. out.write("\t\t\t<tr>\r\n");  
  14. out.write("\t\t\t\t<td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>\r\n");  
  15. out.write("\t\t\t</tr>\r\n");  
  16. out.write("\t\t\t<tr>\r\n");  
  17. out.write("\t\t\t\t<td>a</td><td>b</td><td>c</td><td>d</td>\r\n");  
  18. out.write("\t\t\t</tr>\r\n");  
  19. out.write("\t\t</table>\r\n");  
  20. out.write("\t</body>\r\n");  
  21. out.write("</html>");  

第二种情况（<jsp:include>包含的是jsp文件）：

DynamicInclude.jsp:

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <html>  
  3.          <head>  
  4.                    <title>动态包含</title>  
  5.          </head>  
  6.          <bodystylebodystyle="background-color:lightblue">  
  7.    
  8.                    <jsp:include page="header.jsp"flush="true"/><!--动态包含-->  
  9.    
  10.                    <tablebordertableborder="1" align="center">  
  11.                             <tr>  
  12.                                      <td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>  
  13.                             </tr>  
  14.                             <tr>  
  15.                                      <td>a</td><td>b</td><td>c</td><td>d</td>  
  16.                             </tr>  
  17.                    </table>  
  18.          </body>  
  19. </html>  

Header.jsp ：

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <html>  
  3.          <body>  
  4.                    <h2styleh2style="font-family:arial;color:red;font-size:25px;text-align:center">  
  5.                             动态包含的标题(JSP)  
  6.                    </h2>  
  7.          </body>  
  8. </html>  

运行之后，生成了两个servlet：DynamicInclude_jsp.Java和header_jsp.java，这也是为什么 Header.jsp中要写上<%@page contentType="text/html;charset=gb2312"%>和完整的<html></html>和<body></body>，而Header.html不用写的原因。因为前者两个.jsp文件是两个相互独立的整体，它们之间的关系是通过request和reponse来发生的，而后者只是简单的嵌套。两个servlet对应的代码如下：


DynamicInclude_jsp.java：

[html]  view plain  copy
  1. out.write("\r\n");  
  2. out.write("<html>\r\n");  
  3. out.write("\t<head>\r\n");  
  4. out.write("\t\t<title>动态包含</title>\r\n");  
  5. out.write("\t</head>\r\n");  
  6. out.write("\t<bodystylebodystyle=\"background-color:lightblue\">\r\n");  
  7. out.write("\r\n");  
  8. out.write("\t\t");  
  9. <span style="color:#ff0000;">org.apache.jasper.runtime.JspRuntimeLibrary.include(request,response, "header.jsp", out, true);</span>  
  10. out.write("<!--动态包含-->\r\n");  
  11. out.write("\r\n");  
  12. out.write("\t\t<table border=\"1\"align=\"center\">\r\n");  
  13. out.write("\t\t\t<tr>\r\n");  
  14. out.write("\t\t\t\t<td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>\r\n");  
  15. out.write("\t\t\t</tr>\r\n");  
  16. out.write("\t\t\t<tr>\r\n");  
  17. out.write("\t\t\t\t<td>a</td><td>b</td><td>c</td><td>d</td>\r\n");  
  18. out.write("\t\t\t</tr>\r\n");  
  19. out.write("\t\t</table>\r\n");  
  20. out.write("\t</body>\r\n");  
  21. out.write("</html>");  


header_jsp.java:    

[html]  view plain  copy
  1. out.write("\r\n");  
  2. out.write("<html>\r\n");  
  3. out.write("\t<body>\r\n");  
  4. out.write("\t\t<h2 style=\"font-family:arial;color:red;font-size:25px;text-align:center\">\r\n");  
  5. out.write("\t\t\t动态包含的标题(JSP)\r\n");  
  6. out.write("\t\t</h2>\r\n");  
  7. out.write("\t</body>\r\n");  
  8. out.write("</html>");  


<%@include%>：静态包含

第一种情况：<%@include%>包含的是jsp文件。

StaticInclude.jsp:

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <html>  
  3.          <head>  
  4.                    <title>静态包含</title>  
  5.          </head>  
  6.          <bodystylebodystyle="background-color:lightblue">  
  7.    
  8.                    <%@include file="header.jsp"%><!--静态包含-->  
  9.                    <tablebordertableborder="1" align="center">  
  10.                             <tr>  
  11.                                      <td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>  
  12.                             </tr>  
  13.                             <tr>  
  14.                                      <td>a</td><td>b</td><td>c</td><td>d</td>  
  15.                             </tr>  
  16.                    </table>  
  17.          </body>  
  18. </html>  

header.jsp:

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <h2styleh2style="font-family:arial;color:red;font-size:25px;text-align:center">  
  3.          静态包含的标题(JSP)  
  4. </h2>  

运行之后，只生成一个servlet，和上面的代码对应如下：

[html]  view plain  copy
  1. out.write("\r\n");  
  2. out.write("<html>\r\n");  
  3. out.write("\t<head>\r\n");  
  4. out.write("\t\t<title>静态包含</title>\r\n");  
  5. out.write("\t</head>\r\n");  
  6. out.write("\t<body style=\"background-color:lightblue\">\r\n");  
  7. out.write("\r\n");  
  8. out.write("\t\t");  
  9. out.write("\r\n");  
  10. <span style="color:#ff0000;">out.write("<h2styleh2style=\"font-family:arial;color:red;font-size:25px;text-align:center\">\r\n");  
  11. out.write("\t静态包含的标题(JSP)\r\n");  
  12. out.write("</h2>");</span>  
  13. out.write("<!--静态包含-->\r\n");  
  14. out.write("\t\t<table border=\"1\"align=\"center\">\r\n");  
  15. out.write("\t\t\t<tr>\r\n");  
  16. out.write("\t\t\t\t<td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>\r\n");  
  17. out.write("\t\t\t</tr>\r\n");  
  18.  out.write("\t\t\t<tr>\r\n");  
  19. out.write("\t\t\t\t<td>a</td><td>b</td><td>c</td><td>d</td>\r\n");  
  20. out.write("\t\t\t</tr>\r\n");  
  21. out.write("\t\t</table>\r\n");  
  22. out.write("\t</body>\r\n");  
  23. out.write("</html>");  

第二种情况：<%@include%>包含的是html文件。

StaticInclude.jsp:

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <html>  
  3.          <head>  
  4.                    <title>静态包含</title>  
  5.          </head>  
  6.          <bodystylebodystyle="background-color:lightblue">  
  7.    
  8.                    <%@include file="header.html"%><!--静态包含-->  
  9.                    <tablebordertableborder="1" align="center">  
  10.                             <tr>  
  11.                                      <td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>  
  12.                             </tr>  
  13.                             <tr>  
  14.                                      <td>a</td><td>b</td><td>c</td><td>d</td>  
  15.                             </tr>  
  16.                    </table>  
  17.          </body>  
  18. </html>  

header.html:

[html]  view plain  copy
  1. <%@pagecontentType="text/html;charset=gb2312"%>  
  2. <h2styleh2style="font-family:arial;color:red;font-size:25px;text-align:center">  
  3.          静态包含的标题(HTML)  
  4. </h2>  


运行之后，也是只生成一个servlet，和上面的代码对应如下：

[html]  view plain  copy
  1. out.write("\r\n");  
  2. out.write("<html>\r\n");  
  3. out.write("\t<head>\r\n");  
  4. out.write("\t\t<title>静态包含</title>\r\n");  
  5. out.write("\t</head>\r\n");  
  6. out.write("\t<bodystylebodystyle=\"background-color:lightblue\">\r\n");  
  7. out.write("\r\n");  
  8. out.write("\t\t");  
  9. out.write("\r\n");  
  10. <span style="color:#ff0000;">out.write("<h2styleh2style=\"font-family:arial;color:red;font-size:25px;text-align:center\">\r\n");  
  11. out.write("\t静态包含的标题(HTML)\r\n");  
  12. out.write("</h2>");</span>  
  13. out.write("<!--静态包含-->\r\n");  
  14. out.write("\t\t<table border=\"1\"align=\"center\">\r\n");  
  15. out.write("\t\t\t<tr>\r\n");  
  16. out.write("\t\t\t\t<td>姓名</td><td>性别</td><td>年龄</td><td>爱好</td>\r\n");  
  17. out.write("\t\t\t</tr>\r\n");  
  18. out.write("\t\t\t<tr>\r\n");  
  19. out.write("\t\t\t\t<td>a</td><td>b</td><td>c</td><td>d</td>\r\n");  
  20. out.write("\t\t\t</tr>\r\n");  
  21. out.write("\t\t</table>\r\n");  
  22. out.write("\t</body>\r\n");  
  23. out.write("</html>");  

由上可以总结出：

对于静态包含，<%@include%>，中包含的文件，只是简单的嵌入到主文件中，就是在jsp页面转化成Servlet时才嵌入到主文件中，因为运行的结果是只生成了一个Servlet。

而对于动态包含<jsp:incude>，如果被包含文件是动态的，那么就会生成两个Servlet，也就是被包含文件也要经过jsp引擎编译执行生成一个Servlet，两个Servlet通过request和reponse进行通信。如果被包含的文件是静态的，那么这种情况和<%@include>就很相似，只生成了一个Servlet，但是他们之间没有进行简单的嵌入，而依然是通过request和reponse进行的通信。


租房请下载：房东直租APP
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
<%@include%>和<jsp:include>的区别
dnxyhwx的专栏
03-15 1062
1、作用阶段： 是在翻译阶段（将JSP页面转换成servlet的阶段），JSP的include指令会读入指定的页面中的内容，并将这些内容和原来的页面融合在一起，最后生成一个servlet。  这个指令是在请求处理阶段而不是在翻译阶段执行的，该行为并不是要引入指定页面的实际内容，它将引入执行该引入页面后所产生的应答，这意味着你可以指定任何能够产生文本应答的web资源，动态引入资源，最后分别
Java Web 实验四 掌握<jsp:include>动作的使用
最新发布
01-22
问题描述: 网上购物系统，商品包括mp3和mp4两项...中使用jsp:include动作包括了选购商品信息item.jsp文件。 实现步骤： 1.创建 index.jsp文件; 2.创建order.jsp文件; 3.创建item.jsp文件； 4.运行结果并完成实验报告。
<%@include...> 与<jsp:include....>指令的区别
Java Learning
06-05 1849
一、include指令:    在翻译阶段（将JSP页面转换成servlet的阶段），include会读入指定的页面中的内容，并将这些内容和原来的页面融合在一起        引入的页面可以只包含静态内容（例如HTML），也可以是一个普通的JSP页面。主页面和引入的页面融和在一起（引入的页面只是最为普通的文本进行融合，并不对动态内容求值），融合后的完整页面再被整体的转换为一个servl
<jsp:include>跟<%@include%>的区别
wintertwinkle
04-08 958
是动作元素，用来包含静态和动态的文件，如果被包含的是TXT这种静态的文件，那么只是单纯地加到JSP页面中，不会进行任何处理。如果被包含的文件是JSP或者包含JS的HTML文件，就会先进行处理，然后将处理后的结果加到JSP页面中。 是指令元素，用来包含静态和动态的文件，不同的是，不管被包含的是静态的或者动态的文件，都是先加到JSP页面中，然后随JSP编译进行处理。 简而言之： 先处
<%@include>和 <jsp:include>的区别
anwenzhao0749的博客
09-28 451
1,<%@includefile=””%>是在翻译阶段执行<jsp:include page="page.jsp"/>在请求处理阶段执行.2,静态引入是指令标签，动态引入是行为标签。3，动态引入生成两个java文件，静态引入只生成一个java文件4，动态引入可以传递参数，静态引入不能传递参数。5，静态引入被引入的页面发生改变所有的页面都得重...
JSP中include指令和include行为的区别
01-08
 jsp:include page=” ” flush=”true”/> 前者是指令元素、后者是行为元素。具体它们将在何处用？如何用及它们有什么区别？这应该是很多人看到它都会想到的问题。下面一起来看看吧。 通常当应用程序中所有的...
jsp:include与include实探
05-29
NULL 博文链接：https://dreamzhong.iteye.com/blog/1127436
JSP:include和include指令区别
05-13
JSP:include和include指令区别，对应我的博客 blog.csdn.net/svitter
使用jsp:include控制动态内容的方法
01-08
本文实例讲述了使用jsp:include控制动态内容的方法。分享给大家供大家参考，具体如下： 清单 1. JSP include 伪指令 <![CDATA[ <%@ page language=java contentType=text/html %> <html> <head&...
@include和jsp:include的区别
weixin_40486739的博客
04-29 6919
<%@include%>和<jsp:include>的区别 <%@include%>：页面请求之前预编译，所有代码包含进来之后，一起进行处理，把所有代码合在一起，编译成一个servlet <jsp:include>：所有代码分别处理，在页面被请求的时候才编译，被编译成多个servlet，页面语法相对独立，处理完成之后再将代码的显示结果（处理结果）...
jsp静态include和动态include区别
别抢我蓝buff
02-24 485
JSP中，include是一个经常用到的标签。当应用程序中所有的页面的某些部分(如标题、页脚和导航栏)都相同的时候,我们就可以考虑用include。但是相同的部分有静态的（装载进页面显示后再也不变的），有动态的（装载进页面后还会改变，如：随时间改变、...
<%%>,<%!%>,<%=%>,<%@%>,<jsp:include><%@ include%>区别
weixin_30950607的博客
09-29 68
<%! %>声明标记，声明变量或者方法，声明的变量为全局变量 <% %>代码片段，局部变量 <%= %>获取变量值 <%@ %> 例如：<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> 目前有...
jsp_include和@include的区别
HN.yz@ssg
12-05 970
jsp:include(动态包含)和@include(静态包含)的区别：     page 包含在页面中的相对URL地址。     flush 布尔属性，定义在包含资源前是否刷新缓存区。 1.jsp：include通过page属性包含文件  @include通过file属性包含文件 2.jsp:include 是在请求阶段向被包含的页面发起了一个请求
JSP中的page,request,session,application
treeroot的专栏
09-01 2383
application和session比较简单，这里主要说明request和page的作用范围。application：全局作用范围，整个应用程序共享，就是在部署文件中的同一个webApp共享，生命周期为：应用程序启动到停止。session：会话作用域，当用户首次访问时，产生一个新的会话，以后服务器就可以记住这个会话状态。生命周期：会话超时，或者服务器端强制使会话失效。request：请求作用域，
JSP 中＜%@include %＞与＜jsp:inclde＞的区别
Pamy的博客
06-29 1139
1.<%@include %>属于指令标签，通过file属性指定包含文件，并且file属性不支持任何表达式； <%jsp:inclde%>动作标识通过page属性指定被包含文件，page属性支持JSP表达式。 2.使用<%@include %>，被包含文件内容会原封不动插入到包含页面，然后JSP编译成一个Java文件； 使用<%jsp:inclde%>，当标识被执行程序将请求转发到被包含页面，并将执行结果输出到浏览器中，返回包含页面，继续执行后面的代码。（类似
<%@ page include=""%> 和<jsp:include flush="true" page=""></jsp:include>两者的区别
07-27 1656
和 两者的区别： 1.前者是include指令，后者是include行为； 2.发生的时刻不一样，前者是在编译时包含的，包含的是源代码，后者是在运行时才包含的，而且只包含运行结果。
<jsp:forword>跟<jsp:include>的区别
05-11
`<jsp:forward>` 和 `<jsp:include>` 都是 JSP 页面的指令标签，用于在 JSP 页面中包含其他 JSP 页面或者Servlet。 下面是二者的区别： 1. `<jsp:forward>` 指令用于将请求转发到另一个页面或者 Servlet，转发后，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值