精华内容
下载资源
问答
  • jsp指令和标签
    2015-10-26 13:02:57
    更多相关内容
  • JSP 指令

    2021-01-08 22:40:30
    JSP指令用来设置整个JSP页面相关的属性,如网页的编码方式脚本语言。 语法格式如下: 指令可以有很多个属性,它们以键值对的形式存在,并用逗号隔开。 JSP中的三种指令标签: 指令 描述 ...
  • 今天复习了JSP指令元素部分,整理了下,跟大家一起分享: 一、page指令:设定JSP页面的全局属性,该配置作用于整个JSP页面,设置包括静态包含的文件。 <%@ page 属性1=”属性值1“ 属性2=”属性值2“ %> 1、...
  • jsp中include指令静态导入动态导入的区别详解JSP编译指令page、include详解JSP中动态include与静态include的区别介绍JSP指令元素(page指令/include指令/taglib指令)复习整理基于jsp:included的使用与jsp:param乱码...
  • JSP标签库大全jsp常用的指令标签

    千次阅读 2016-05-12 07:01:11
    JSP标签库大全 标签: jspstringimportlibraryurlc 2012-07-30 10:28 6541人阅读 评论(0) 收藏 举报  分类:   JSP(5)  版权声明:本文为博主原创文章,未经博主允许不得转载。 目录(?)[-] ...
     

    JSP标签库大全

    标签: jspstringimportlibraryurlc
      6541人阅读  评论(0)  收藏  举报
      分类:
     

    待续

    Core Tag Library

     <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

    [html]  view plain  copy
    1. <c:set var="temp" value="hello world" scope="page"/>  
    2.   ${temp }  
    3. <c:remove var="temp"/>  

    [html]  view plain  copy
    1. <%  
    2. String[] ss={"one","two","three"};  
    3. pageContext.setAttribute("ss",ss);  
    4. %>  
    5. <c:forEach var="s" items="${pageScope.ss }">  
    6.     ${s}<br/>  
    7. </c:forEach>  

    [html]  view plain  copy
    1. <%  
    2. String temp="hello";  
    3. pageContext.setAttribute("temp",temp);  
    4. %>  
    5. <c:if test="${!empty temp}">  
    6.     ${temp }  
    7. </c:if>  
    8. <c:if test="${1==2 }">  
    9.   1==2  
    10. </c:if>  

    [html]  view plain  copy
    1. <%  
    2. String temp="two";  
    3. pageContext.setAttribute("temp",temp);  
    4. %>  
    5. <c:choose>  
    6.     <c:when test="${temp=='one' }">  
    7.         one  
    8.     </c:when>  
    9.     <c:when test="${temp=='two' }">  
    10.         two  
    11.     </c:when>  
    12.     <c:otherwise>  
    13.         otherwise  
    14.     </c:otherwise>  
    15. </c:choose>  

    [html]  view plain  copy
    1. <c:url var="hello"  value="/jsp/hello.jsp">  
    2.     <c:param name="username"> jiajia</c:param>  
    3. </c:url>  
    4.  <a href="${hello}"> hello world</a>  

    [html]  view plain  copy
    1. <c:import url="/jsp/hello.jsp">  
    2.     <c:param name="username" value="jiajia"></c:param>  
    3. </c:import>  

    XML Tag Library

    [html]  view plain  copy
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <books>  
    3. <span style="white-space:pre">  </span><book id="1">  
    4. <span style="white-space:pre">      </span><name>jia</name>  
    5. <span style="white-space:pre">      </span><price>100</price>  
    6. <span style="white-space:pre">  </span></book>  
    7. <span style="white-space:pre">  </span><book id="2">  
    8. <span style="white-space:pre">      </span><name>wodwl</name>  
    9. <span style="white-space:pre">      </span><price>200</price>  
    10. <span style="white-space:pre">  </span></book>  
    11. </books>  
    [html]  view plain  copy
    1. <c:import url="/jsp/xmlTest.xml" var="xml" <span style="font-family: simsun; font-size: 14px; line-height: 23px; text-align: left; ">charEncoding="UTF-8"/</span>></c:import>  
    2. <x:parse doc="${xml}" var="booklist" scope="application"></x:parse>  
    3. <x:forEach var="item" select="$booklist/books/book">  
    4.     <x:out select="$item/@id"/>  
    5.     <c:set var="name">  
    6.         <x:out select="$item/name"/>  
    7.     </c:set>  
    8.     <c:set var="price">  
    9.         <x:out select="$item/price"/>  
    10.     </c:set>  
    11.     <c:url var="url" value="/jsp/hello.jsp">  
    12.         <c:param name="name">${name}</c:param>  
    13.         <c:param name="price">${price}</c:param>  
    14.     </c:url>  
    15.     <a href="${url}">  
    16.         <x:out select="$item/name"/>  
    17.     </a>  
    18. </x:forEach>  

    注意:以下不加上charEncoding='utf-8"可能导致乱码
    [html]  view plain  copy
    1. <c:import url="/jsp/xmlTest.xml" var="xml" <span style="font-family: simsun; font-size: 14px; line-height: 23px; ">charEncoding="UTF-8"/</span>></c:import>  
    [html]  view plain  copy
    1.  









    JSP页面中四种变量的范围

      (2011-01-26 15:06:57)
       

    JSP页面中四种变量的范围

    分类: JAVA相关

    我们在编写JSP网站程序的时候,可以在WEB应用程序的不同范围中保存变量,
    JSP中变量的范围分为四种:page,request,session和application。
    这四个范围依序从前到后,范围越来越大。

     

    一、page范围
    在page范围内定义的变量,只能在同一个页面内部访问。在JSP页面中,演示如下代码:
    <%
    pageContext.setAttribute("name","Johnson");
    out.println(pageContext.getAttribute("name"));
    %>
    上面的代码中,在page范围内,定义了一个名称为name的属性,其值为Johnson,
    第二行代码将该属性的值打印出来。注意:这样定义的这个name属性,在这个页面之外
    的部分是访问不到的。考虑到page范围只是在一个页面中共享数据,其范围是非常小的。
    需要注意的是,在page范围,以及其他三种范围中,存储的值都只能是引用类型的值。
    下面的例子演示怎么将一个整数存入page范围之内。
    <%
    pageContext.setAttribute("amount",new Integer(100));
    out.println(pageContext.getAttribute("amount"));
    %>

     

    二、request范围
    在Java的WEB应用程序中,可以将一个变量值存入request范围中,然后可以将request
    对象传递给下一个页面,那么下一个页面中,可以获得从上一个页面传送过来的request
    对象中保存的属性值。
    这里,我们修改上一章中的登陆案例,来演示request范围属性的使用。
    我们希望用户登录成果以后,能够在登陆成功页面,即welcome.jsp页面中,显示
    该登陆用户的用户名,那么可以修改前面登陆案例中的验证登陆用户的servlet如下:
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException {
    String name=request.getParameter("name");
    String pwd=request.getParameter("pwd");
    User user=new User();
    user.setName(name);
    user.setPwd(pwd);
    String dbName=request.getRealPath("goods.mdb");
    //转向器
    String url="";
    try {
    db d1 = new db(dbName);
    if(d1.isUserValid(user))
    {
    request.setAttribute("name",name);
    url="welcome.jsp";
    }
    else
    {
    url="failed.jsp";
    }
    RequestDispatcher rd=request.getRequestDispatcher(url);
    //把用户名存入request scope中
    //设置属性
    rd.forward(request,response);
    }
    catch (Exception ex) {
    ex.printStackTrace();
    }
    }
    在上面的代码中,用户登陆成功以后,把用户名存入request范围,
    request.setAttribute(“name”,name);
    然后获取将要转向的页面的转向器,
    url=”welcome.jsp”;
    RequestDispatcher rd=request.getRequestDispatcher(request,response);
    这样,本servlet中的request对象就会被传递到下一个页面,在下一个页面,
    即welcome.jsp中,就可以通过
    request.getAttribute(“name”);
    的方式获取到name属性,即登陆用户的用户名。

     

    三、session范围
    当用户通过浏览器和服务器连通以后,服务器为该用户在服务器上分配一个供该用户专
    用的内存空间,这个内存空间中保存着用户访问该网站服务器期间的一些信息,这些信
    息称为会话信息,也就是Session信息。服务器为每个访问该服务器的连接分配一个唯
    一的编号,该编号用以唯一确认该用户。这个编号就是我们通常说的SessionID。
    有了这个会话信息空间以后,用户就可以把和本次访问相关的一些信息保存在这个会话
    信息空间中。会话信息空间中保存的信息只和本次连接有关。
    需要注意的是,通过同一台主机打开多个浏览器访问服务器的时候,每一个浏览器连
    接对应一个会话。要设置一个session范围的变量,可以使用下面的方法。
    <%
    session.setAttribute("name",”Johnson”);
    out.println(session.getAttribute("name"));
    %>

     

    四、application范围
    一台WEB服务器启动以后,在服务器上有一个由所有连接共享的内存空间,
    这就是application范围空间。在application范围中定义的变量,可以由所有连接共享。
    一个连接对application范围中变量的修改,会体现到另外一个连接中。
    要设置一个application范围的变量,可以使用如下方法:
    <%
    application.setAttribute("name",”Johnson”);
    out.println(application.getAttribute("name"));
    %>











    JSP标准标签

    JSP标准标签库

    JSP标准标签库(JSP Standard Tag Library,JSTL)是实现Web应用程序中常见的通用功能的定制标签库集,程序员使用JSTL标签来避免在JSP页面中使用脚本。

    JSTL概述

    (1)、JSTL英文全称是“JSP  Standard  Tag Library”,即JSP标准标签库之意。

    (2)、JSTL是由JCP(JavaCommnunity Process)指定的标准规范,是一组形如html的标签。

    (3)JSTL提供了诸如循环、条件、数据库访问、XML处理、国际化等开发上的工具和流程。

    (4)、目前最新的版本为1.2,是一个正在不断开发和完善的开发源代码的JSP标签库,它支持多种标签。

    JSTL分成了5大类

                                       
     

    功能范围

     
     

    URL

     
     

    前缀

     
     

    核心标签库(Core)

     
     

    http://Java.sun.com/jsp/jstl/core

     
     

    c

     
     

    国际化/格式化标签库(il8n)

     
     

    http://java.sun.com/jsp/jstl/fmt

     
     

    fmt

     
     

    数据库标签库吧(SQL)

     
     

    http://java.sun.com/jsp/jstl/sql

     
     

    sql

     
     

    XML标签库(XML)

     
     

    http://java.sun.com/jsp/jstl/xml

     
     

    X

     
     

    Functions标签库(Functions)

     
     

    http://java.sun.com/jsp/jstl/functions

     
     

    fn

     

    (5)、在学习JSTL标签库之前,需要先下载JSTL所需要的JAR包。有两种获取方法

                  1)通过官方网站(http://www.apache.org/dist/jakarta/taglibs/standard)下载,获取API里面的jstl.jar、standard.jar

                  2)使用MyEclipse自带的驱动包。使用MyEclipse创建Web工程时,选择“JSTL Support”选项。

    Core标签库

    (1)、核心标签库主要包括通用标签、条件标签、迭代标签和与URL相关的标签

    (2)、在使用Core标签库的JSP文件的开始部分,添加代码:%@tagliburi=”http://java.sun.com/jsp/jstl/core” prefix=”c”%

    1、通用标签

    <c:out>标签

      用于将表达式的结果输出到当前的JSPWriter对象中。其功能类似于JSP的表达式<%= %>或者EL表达式${}。

    request.setAttribute("user","lisi");

       %>

        <c:out value="helloworld"/><br>

        hello world ${"hello world"}<br>

        <c:out value="${userName}"default="xxxx"></c:out><br>

        <c:out value="<h1>你好</h1>" escapeXml="false"></c:out><br>

        <c:out value="${userName}">文本内容</c:out>

    <c:set>标签

        <c:set>标签用于设置JSP页面的各种域范围中的变量,或者设置java.util.Map对象或JavaBean对象的属性

        将value的值保存到名为name的变量中,name变量保存到选定的作用范围中

           <c:set value="孙悟空" var="user"scope="request"/>

         ${user}

         <c:set var="user"scope="request">猪八戒</c:set>

         ${user}

         <%

         Map map=new HashMap();

         request.setAttribute("map",map);

          %>

          <c:set value="唐曾" property="aaa"target="${map}"></c:set>

           ${map.aaa}

           <%

           Personp=new Person();

           request.setAttribute("person",p);

            %>

           <c:set value="Jerry" property="name"target="${person}"></c:set>

           ${person.name}

    <c:remove>标签

        <c:remove>标签用于移除JSP页面中指定域范围中的变量

    <c:remove var="person"scope="request"/>

      <c:out value="${person.name}" default="没有该人"></c:out>

    <c:catch>标签

        <c:catch>标签用于捕获嵌套在标签体内的内容抛出的异常对象,并将异常信息保存到变量中

           <c:catch var="myex">

       <%

       int i=10/0;

        %>

        </c:catch>

      异常:<c:out value="${myex}"></c:out><br>

      异常原因:<c:out value="${myex.cause}"></c:out><br>

      异常消息:<c:out value="${myex.message}"></c:out><br>

     异常堆栈轨迹:<c:out value="stackTrace"></c:out><br>

    条件标签

    <c:if>标签

        <c:if>标签用来做条件判断,功能类似于JSP中的<%if(boolean){}%>

    <c:if test="${userName==null}" var="xx"scope="request">

     改用户没有登录

     </c:if>

     ${xx}

    <c:choose>、<c:when>、<c:otherwise>标签

           <c:choose>标签用于提供条件选择的上下文,它必须与<c:when>和<c:otherwise>标签一起使用

           <c:when>作为<c:choose>的子标签,<c:when>有一个test属性,该属性的值为布尔型,如果test的值为true,则执行<c:when>标签体的内容。

                  <c:otherwise>标签没有属性,它必须作为<c:choose>标签的最后分支出现。

    <%

      request.setAttribute("age",18);

       %>

       <c:choose>

            <c:when test="${age>70}">老年人</c:when>

            <c:when test="${age<=70&&age>35}">中年人</c:when>

            <c:when test="${age<=35&&age>18}">青年</c:when>

            <c:when test="${age<=18&&age>0}">少年或儿童</c:when>

            <c:otherwise>输入错误</c:otherwise>

       </c:choose>

    迭代标签

      <c:forEach>标签

           <c:forEach>标签用于对包含了多个对象的集合进行迭代,重复执行它的标签体,或者重复迭代固定的次数。

    注意:

    items属性并不是一定要有的属性,但是当没有使用items属性时,就一定要使用begin和end属性。

    varStatus:用来保存现有遍历计数相关的信息。例如,如果varStatus=“i”,那么会将相应信息放到名称为i的变量中,i变量有四个属性值,index、count、first和last。

    <c:forEach begin="1"end="10" step="1">

        helloworld

       </c:forEach>

       <br>

       <%

       List list=new ArrayList();

       list.add("aa");

       list.add("bb");

       list.add("cc");

       list.add("dd");

       list.add("ee");

       list.add("ff");

       list.add("gg");

       list.add("hh");

       list.add("ii");

       list.add("jj");

       request.setAttribute("list",list);   

        %>

        <table border="1"width=50%>

        <c:forEach items="${list}"var="str" begin="0"end="7" step="1"varStatus="status">

         <tr class="${(status.count%2!=0)?'even':'odd'}">

         <td>${str}</td>

         <td>${status.index}</td>

         <td>${status.first}</td>

         <td>${status.last}</td>

         <td>${status.count}</td>

        

         </tr>

        </c:forEach>

        </table>

    <c:forTokens>标签

           <c:forTokens>标签用来浏览一字符串中所有的成员,其成员是由定义符号(Delimiters)所分隔的。

    <c:forTokens items="this:is:an:example" delims=":" var="token">

           ${token}

        </c:forTokens>

    URL相关的标签

    <c:url>标签

    <%

        session.setAttribute("xxx","xxx");

        %>

        <c:url value="/index.jsp" var="strUrl" scope="request">

           <c:param name="userName"value="王五"></c:param>

        </c:url>  

        ${strUrl}

        <a href="${strUrl}">首页</a> <br>

    <a href="<c:url value='/index.jsp'/>">首页</a>

    <c:redirect>标签

    <c:redirect>标签用于向用户的浏览器发送HTTP重定向响应,它是JSTL中与javax.servlet.http.HttpServletResponse的sendRedirect()方法功能相当的标记。

    <c:redirect url="/MyJsp.jsp"></c:redirect>

    <c:param>标签

           <c:param>标签的作用是为一个URL添加请求参数,在前面的<c:url>、<c:redirect>和<c:import>标签中都已经见过<c:param>的用法。

    <c:import url="/MyJsp.jsp"var="secondPage"></c:import>

    标签控制页面

    标签控制页面

    使用标签控制页面逻辑案例:

    1、         防止盗链<c:referer site=”” page=””>

    Jsp页面的内容:<c:referer site=”http://localhost”page=”index.jsp”>

    Tld文件的描述:<tag>

                          <name>referer</name>

                       <tag-class>com.hbsi.web.tag.RefererTag</tag-class>

                           <body-content>empty</body-content>

                           <attribute>

                              <name>site</name>

                             <required>true</required>

                             <rtexprvalue>true</rtexprvalue>

                         </attribute>

                           <attribute>

                             <name>page</name>

                             <required>true</required>

                             <rtexprvalue>true</rtexprvalue>

                         </attribute>

                   </tag>

    标签处理器:public class RefererTag extends SimpleTagSupport {

        private String site;

        private String page;

        public void setSite(String site) {

           this.site = site;

        }

        public void setPage(String page) {

           this.page = page;

        }

        @Override

        public void doTag() throws JspException, IOException {

           // 获取request对象

           JspContext jc = this.getJspContext();

           PageContext pc = (PageContext) jc;

           HttpServletRequest request = (HttpServletRequest)pc.getRequest();

     

           HttpServletResponse response = (HttpServletResponse) pc.getResponse();

           String referer = request.getHeader("referer");

           if (referer == null || !referer.startsWith("http://localhost")) {

               // 跳转到首页

               //获取地址的完整路径

               if (page.startsWith(request.getContextPath())) {

                  response.sendRedirect(page);

               } else if (page.startsWith("/")) {//获取加/的路径

                  response.sendRedirect(request.getContextPath() + page);

               } else {

                  //最不完整的路径

                  response.sendRedirect(request.getContextPath() + "/" + page);

               }

               // 不运行以下的代码

               throw new SkipPageException();

           }

        }

    }

    2、条件选择<c:if test=””>

           Jsp的页面:<%session.setAttribute("user","蛋蛋");%>

                      <c:if test="${user!=null}">

                           aaa

                       </c:if>

        Tld文件的描述:<tag>

               <name>if</name>

               <tag-class>com.hbsi.web.tag.IfTag</tag-class>

                <body-content>scriptless</body-content>

               <attribute>

                      <name>test</name>

                      <required>true</required>

                      <rtexprvalue>true</rtexprvalue>

                </attribute>

           </tag>

        标签处理器:public class IfTag extends SimpleTagSupport {

                      private boolean test;

                      public void setTest(boolean test) {

                             this.test = test;

                      }

    @Override

                      public void doTag() throws JspException,IOException {

                             if(test){

                                    JspFragmentjf=this.getJspBody();

                                    jf.invoke(null);

                                }

                          }

                   }

    3、迭代标签<c:foreach  items=”” var=””>

    Jsp的页面:< c:foreach items="${list}" var="str">

                          ${str}

                       </c:foreach>

           Tld文件的描述:<tag>

      <name>foreach</name>

      <tag-class>com.hbsi.web.tag.ForEachTag</tag-class>

      <body-content>scriptless</body-content>

      <attribute>

      <name>items</name>

      <required>true</required>

      <rtexprvalue>true</rtexprvalue>

      </attribute>

      <attribute>

      <name>var</name>

      <required>true</required>

      <rtexprvalue>false</rtexprvalue>

      </attribute>

      </tag>

    标签处理器:public class ForEachTag extends SimpleTagSupport {

       

        private Object items;

        private String var;

       

        public void setItems(Object items) {

           this.items = items;

        }

        public void setVar(String var) {

           this.var = var;

        }

        @Override

        public void doTag() throws JspException, IOException {

               //得到集合对象

           Collection collection=null;

           if(items instanceof Map){

               Map map=(Map)items;

               //两列集合转换成单列;映射

               collection=map.entrySet();

           }else if(items instanceof Collection){

               collection=(Collection)items;//集合

           }else if(items.getClass().isArray()){

               collection=new ArrayList();

               int length=Array.getLength(items);

               for(int i=0;i<length;i++){

                  collection.add(Array.get(items, i));

               }

           }

           Iterator it=collection.iterator();

           while(it.hasNext()){

               Object obj=it.next();//一个元素

               this.getJspContext().setAttribute(var,obj);

               this.getJspBody().invoke(null);

           }

        }

    }

     

    jar包:标签处理器以及(META-INF)tld文件打成一个jar包

     

    自定义标签


    自定义标签

    自定义标签主要用于移除Jsp页面中的Java代码

    快速入门:使用自定义标签输出客户机的IP

    移除jsp页面中的java代码,只需要完成两个步骤:

    编写一个实现Tag接口的Java类,并覆盖doStartTag方法,把jsp页面中的java代码写到doStartTag方法中。

    编写标签库描述符(tld)文件,在tld文件中对自定义标签进行描述。

    完成以上操作,即可在JSP页面中导入和使用自定义标签。

    查看tag接口api文档,分析自定义标签的执行流程。

     

    自定义标签的创建步骤:

    (1)      标签处理器——java类,实现Tag接口

    (2)      编写.tld:

    JSP页面中使用自定义标签

    <dhw:aaa>

    <dhw:viewIP>系统自动调用doStartTag()

     

    </dhw:viewIP>系统自动调用doEndTag()

    </dhw:aaa>

    Tag接口的执行流程

    JSP引擎将遇到自定义标签时,首先创建标签处理器类的实例对象,然后按照JSP规范定义的通信规则依次调用它的方法。

           1、public voidsetPageContext(PageContext pc), JSP引擎实例化标签处理器后,将调用setPageContext方法将JSP页面的pageContext对象传递给标签处理器,标签处理器以后可以通过这个pageContext对象与JSP页面进行通信。

           2、public void setParent(Tag t),setPageContext方法执行完后,WEB容器接着调用的setParent方法将当前标签的父标签传递给当前标签处理器,如果当前标签没有父标签,则传递给setParent方法的参数值为null。

           3、public int doStartTag(),调用了setPageContext方法和setParent方法之后,WEB容器执行到自定义标签的开始标记时,就会调用标签处理器的doStartTag方法。

           4、public int doEndTag(),WEB容器执行完自定义标签的标签体后,就会接着去执行自定义标签的结束标记,此时,WEB容器会去调用标签处理器的doEndTag方法。

           5、public void release(),通常WEB容器执行完自定义标签后,标签处理器会驻留在内存中,为其它请求服务器,直至停止web应用时,web容器才会调用release方法。

    自定义标签功能扩展

    自定义标签除了可以移除Jsp页面中的java代码外,它还可以用于完成一些页面逻辑,例如:

    通过自定义标签可以控制jsp页面某一部分内容是否执行。

    例如:<c:if>标签

    通过自定义标签可以控制标签后的jsp页面是否执行。

    通过自定义标签可以控制jsp页面某一部分内容重复执行。

    例如:<c:foreach>标签

    通过自定义标签可以修改jsp页面内容输出。

     

    tld文件中的四种标签体类型

    EMPTY  JSP scriptless  tagdepentend

    简单标签

    由于传统标签使用三个标签接口来完成不同的功能,显得过于繁琐,不利于标签技术的推广, SUN公司为降低标签技术的学习难度,在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口来实现标签的功能。实现SimpleTag接口的标签通常称为简单标签。简单标签共定义了5个方法:

    setJspContext方法

    setParent和getParent方法

    setJspBody方法

    doTag方法

    SimpleTag方法介绍

    setJspContext方法

    用于把JSP页面的pageContext对象传递给标签处理器对象

    setParent方法

    用于把父标签处理器对象传递给当前标签处理器对象

    getParent方法

    用于获得当前标签的父标签处理器对象

    setJspBody方法

    用于把代表标签体的JspFragment对象传递给标签处理器对象

    doTag方法

    用于完成所有的标签逻辑,包括输出、迭代、修改标签体内容等。在doTag方法中可以抛出javax.servlet.jsp.SkipPageException异常,用于通知WEB容器不再执行JSP页面中位于结束标记后面的内容,这等效于在传统标签的doEndTag方法中返回Tag.SKIP_PAGE常量的情况。

    SimpleTag接口方法的执行顺序

    当web容器开始执行标签时,会调用如下方法完成标签的初始化

    WEB容器调用标签处理器对象的setJspContext方法,将代表JSP页面的pageContext对象传递给标签处理器对象。

    WEB容器调用标签处理器对象的setParent方法,将父标签处理器对象传递给这个标签处理器对象。注意,只有在标签存在父标签的情况下,WEB容器才会调用这个方法。

    如果调用标签时设置了属性,容器将调用每个属性对应的setter方法把属性值传递给标签处理器对象。如果标签的属性值是EL表达式或脚本表达式,则WEB容器首先计算表达式的值,然后把值传递给标签处理器对象。

    如果简单标签有标签体,容器将调用setJspBody方法把代表标签体的JspFragment对象传递进来。

    执行标签时:

    容器调用标签处理器的doTag()方法,开发人员在方法体内通过操作JspFragment对象,就可以实现是否执行、迭代、修改标签体的目的。

    JspFragment类

    javax.servlet.jsp.tagext.JspFragment类是在JSP2.0中定义的,它的实例对象代表JSP页面中的一段符合JSP语法规范的JSP片段,这段JSP片段中不能包含JSP脚本元素。

     

    WEB容器在处理简单标签的标签体时,会把标签体内容用一个JspFragment对象表示,并调用标签处理器对象的setJspBody方法把JspFragment对象传递给标签处理器对象。JspFragment类中只定义了两个方法,如下所示:

     

    getJspContext方法

    用于返回代表调用页面的JspContext对象.

     

    public abstractvoid invoke(java.io.Writer out)

    用于执行JspFragment对象所代表的JSP代码片段

    参数out用于指定将JspFragment对象的执行结果写入到哪个输出流对象中,如果传递给参数out的值为null,则将执行结果写入到JspContext.getOut()方法返回的输出流对象中。(简而言之,可以理解为写给浏览器)

    invoke方法详解  

    JspFragment.invoke方法可以说是JspFragment最重要的方法,利用这个方法可以控制是否执行和输出标签体的内容、是否迭代执行标签体的内容或对标签体的执行结果进行修改后再输出。例如:

    在标签处理器中如果没有调用JspFragment.invoke方法,其结果就相当于忽略标签体内容;

    在标签处理器中重复调用JspFragment.invoke方法,则标签体内容将会被重复执行;

    若想在标签处理器中修改标签体内容,只需在调用invoke方法时指定一个可取出结果数据的输出流对象(例如StringWriter),让标签体的执行结果输出到该输出流对象中,然后从该输出流对象中取出数据进行修改后再输出到目标设备,即可达到修改标签体的目的。

     

    <span style="white-space:pre"> </span>什么意思

    这是html+css。

    CSS中的 white-space 属性设置如何处理元素内的空白。

    可能的值

    • normal    默认。空白会被浏览器忽略。    

    • pre    空白会被浏览器保留。其行为方式类似 HTML 中的 <pre> 标签。    

    • nowrap    文本不会换行,文本会在在同一行上继续,直到遇到 <br> 标签为止。    

    • pre-wrap    保留空白符序列,但是正常地进行换行。    

    • pre-line    合并空白符序列,但是保留换行符。    

    • inherit    规定应该从父元素继承 white-space 属性的值。    

    Eclipse 使用jsp标签依赖的两个包



    1. <span style="white-space:pre">      </span><dependency>  
    2.             <groupId>jstl</groupId>  
    3.             <artifactId>jstl</artifactId>  
    4.             <version>1.2</version>  
    5.         </dependency>  
    6.         <dependency>  
    7.             <groupId>taglibs</groupId>  
    8.             <artifactId>standard</artifactId>  
    9.             <version>1.1.2</version>  
    10.         </dependency>  


    [html]  view plain  copy
    1. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>  
    2. <%@ taglib uri="http://java.sun.com/jsp/jstl/xml" prefix="x" %>  

    EL表达式的总结


    EL表达式

    JSP表达式语言(Expression Language),简称EL,最初定义在JSTL1.0规范中,直到JSP2.0之后,EL表达式才正式成为JSP规范中的一部分。EL为存取变量、表达式运算和读取内置对象等内容提供了新的操作方式。

    EL表达式的目的是为了使JSP页面编写起来更简单。

    EL表达式概述

    EL表达式是为了便于获取数据而定义的一种语言,JSP 2.0之后才成为一种标准。下面的示例是一个简单的EL表达式:

    <%@ page contentType="text/html;charset=UTF-8"%>

    <!DOCTYPE HTML PUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN">

    <html>

    <body>

                  ${stuno+ 1} <br>

    </body>

    </html>

    EL表达式的基本语法

    EL表达式的出现让Web的显示层发生了大的变革,EL表达式用于获取数据,在JSP 2.0之后成为一种标准,是由JSP 标准标签库专家组和JSP 2.0 专家组开发。

    EL表达式的语法格式: ${标识符}

    在JSP页面中使用的形式,通知JSP引擎调用pageContext.findAttribute()方法,以标识符为关键字从各个域对象中获取对象。如果域对象中不存在标识符所对应的对象,则返回结果为“”(注意,不是null)。

    语法结构

    静态文本

    标准标签和自定义标签(可以作为元素属性的值,也可以在自定义或者标准动作元素的内容中使用)

    EL不能在脚本元素中使用

    []与.运算符

    EL提供(.)和([])两种运算符来存取数据,即使用点运算符(.)和方括号运算符([])。

    点运算符和方括号运算符可以实现某种程度的互换,如${student.name}等价于${student [“name”]}。

    当要存取的属性名称中包含一些特殊字符,如.或?等并非字母或数字的符号时,就一定要使用[]。例如${student.name }应当改为${student[“name”] }。

    如果要动态取值,就可以用[]来做,而.无法做到动态取值。例如${sessionScope.student[data]}中data是一个变量。

    EL存取变量数据的方法很简单,例如${username}。它的意思是取出某一范围中名称为username的变量。

    文字常量

    一个EL表达式包含变量、文字常量、操作符。文字常量主要包括字符串、数字和布尔值、还有NULL,其中

    字符串是由任何由单引号或双引号引起来的一串字符。

    数字常量包括整型、浮点型,整型表示十进制、十六进制和八进制类型的值,浮点型与Java类似,可以包含任何正的或者负的浮点数。

    布尔型包括true和false。

     

    ${true} ${10} ${10.5f} ${“hello”} ${null}

    操作符

    EL表达式的操作符主要有

    算术运算符

    关系运算符

    逻辑运算符

    验证运算符empty

    条件运算符

    算术运算符

    算术运算符主要有平时常用的“+”、“-”、“*”、“/”、“%” 。

    关系运算符

    关系运算符主要有“==”、“!=”、“<”、“>”、“<=”、“>=”

    逻辑运算符

    逻辑运算符主要有“&&”、“||”、“!”

    EL表达式的隐式对象

    在JSP中已经介绍了9个内置对象,在EL表达式中共有11个隐式对象,下面分别来讲述这些隐式对象的用法。

    与范围有关的隐式对象

    与作用范围有关的EL隐含对象包含有:pageScope、requestScope、sessionScope和applicationScope

    它们可以读取使用JSP内置对象pageContext、request、session以及application的setAttribute()方法所设定的对象的数值-----即getAttribute(String name),却不能取得其他相关信息。

    例如,要取得session中储存的一个username属性的值,可以利用下面的方法:session.getAttribute("username")

    在EL中则使用下面的方法:${sessionScope.username}

    注意:如果没有设定使用EL内置对象的作用范围,则按照pageScope、requestScope、sessionScope和applicationScope的先后顺序读取属性值。

    即,通知JSP引擎调用pageContext.findAttribute()方法,以标识符为关键字从各个域对象中获取对象。如果域对象中不存在标识符所对应的对象,则返回结果为“”(注意,不是null)。

    与输入有关的隐式对象

    与输入有关的隐含对象有两个,即param和paramValues,它们是EL中比较特别的隐含对象。例如,要取得用户的请求参数时,可以利用下列方法:

    request.getParameter(String name)

    request.getParameterValues(String name)

    在EL中则可以使用param和paramValues两者来取得数据:

    ${param.name}

    ${paramValues.name}

    其他隐式对象

    cookie

    用来取得使用者的cookie值,例如在cookie中设定了username属性值,可以使用${cookie.username.value}来取得属性值。

    header和headerValues

    读取请求的头数据,使用header或headerValues内置对象,例如${header[“User-Agent”]},headerValues则用来取得所有的头信息,等价于调用request.getHeaders()方法。

    initParam

    initParam用来读取设置在web.xml中的参数值。例如${initParam.repeat},等价于:(String)application.getInitParameter(“repeat”);  或
    servletContext.getInitParameter(“repeat”);

    pageContext

    pageContext用于取得其他有关用户要求或页面的详细信息

    ${pageContext.request.queryString} 取得请求的参数字符串

    ${pageContext.request.requestURL} 取得请求的URL,不包括参数字符串

    ${pageContext.request.contextPath}        服务的webapplication 的名称

    ${pageContext.request.method}          取得HTTP 的方法(GET、POST)

    ${pageContext.request.protocol}        取得使用的协议(HTTP/1.1、HTTP/1.0)

    ${pageContext.request.remoteUser}        取得用户名称

    ${pageContext.request.remoteAddr}         取得用户的IP 地址

    ${pageContext.session.new}            判断session 是否为新的

    ${pageContext.session.id}              取得session 的ID

    ${pageContext.servletContext.serverInfo}  取得主机端的服务信息jsp常用的指令与标签


    jsp常用的指令与标签
    语法:<%@ 指令名 属性="值"%>.

    jsp指令负责告诉jsp引擎如何把页面翻译成servlet.

    page指令:用于定义jsp页面的各种属性,最好放在jsp页面的起始位置,属性有language,extends,import,session,buffer,autoFlush,isThreadSafe,info,isErrorPage,contentType,pageEncoding,isELIgnored.

    include指令:在后面与include标签对比讲解.

    2.
    out对象:这个out不是servlet里面的out.是PageContext.getWriter()方法返回的out对象.
    实验1:
    <%
     out.println("first");
     response.getWriter("second");
    %>
    结果如下:
    second
    first
    为什么out的后输出?这是因为jsp引擎先把内容放到PageContext.getWriter()方法返回的out对象的缓冲区.写完后再交给servlet的response.getWriter()方法写到servlet引擎提供的缓冲区,缓冲区再把内容写到客户端.

    实验2:
    <%
     ServletOutputStream sos = response.getOutputStream();
     sos.println("hehe");
    %>这里加上一个换行

    运行结果报错了,为什么?上面说过,out最终会调用response.getWriter()方法返回的out对象,我们这个实验首先使用了response.getOutputStream()方法,记住我们写的所有的jsp页面都会翻译成Servlet的,然而在这里的代码中输出换行符时又去调用了response.getWriter()方法,而response的getWriter()和getOutputStream()不能同时在一个方法里面调用,所以报错了.注意:用了ServletOutputStream 就不能再使用out对象了.

    实验3:
    <%
     RequestDispatcher rd = application.getRequestDispatcher("/test.html");
     rd.forward(request,response);
    %>在这里回车

    结果报告有错.为什么?
    实际上当调用forward方法时,是去找了一个缺省的servlet,这个缺省的servlet使用的是getOutputStream()方法,而这里的回车使用的是jsp的out对象打印出来的.这个out对象最终要使用的是getWriter(),而上面说过response的getWriter()和getOutputStream()不能同时使用,所以报错了.当然在前面加上回车也是一样的效果.

    3.
    pageContext对象:->request->session->application
    pageContext对象代表此jsp页面,它是通过调用JspFactory.getPageContext方法返回的,在自定义标签用的非常多.
    可以使用pageContext得到其他8大内置对象.

    实验4:
    这是一个换行
    <%
     1.//RequestDispatcher rd = application.getRequestDispatcher("/test.html");
       //rd.forward(request,response);
     2. pageContext.forward("/test.html");
    %>
    第一种方法会出错,第二种不会,为什么?
    第一种出错的原因我们在上面说过,第二种为什么不会出错呢?我们说过,pageContext包装了其他八大隐式对象,所以它的forward方法内部也是调用了request.getRequestDispatcher的forward方法,但是在执行RequestDispatcher的forward方法之前调用了out.clear()方法.这样就不会出错了,去掉前面的换行,在%>后面加一个换行,两种方法都会报错.

    几个常用的方法:
    setAttribute(String name,Object object);
    setAttribute(String name,Object object,int scope);scope代表指定的范围(page,request,session,application)
    getAttribute(String name);
    getAttribute(String name,int scope);
    removeAttribute(String name);
    findAttribute(String name);此方法依次从page,request,session,appllication这四个范围去找,直到找到为止.如果没找到则返回null.

    4.
    jsp标签:
    <%@ include file=""%>:静态包含,a包含b,编译过程中a会受到b的jsp指令的影响,例如,b中有一个isELIgnored指令,会影响b,效率更高,不仅仅是引入输出内容,引入共同的的编译元素,不会检查所含文件的变化,适用于包含静态页面 
    <jsp:include page=""/>:动态包含,a包含b,a在执行过程中调用b,page的值可以是变量.它总是会检查所含文件中的变化,适合用于包含动态页面,并且可以带参数 
    <jsp:forward>:此forward调用的pageContext的forward然后return了
    <jsp:param>:用于给上面两个标签传参数.

    以下是jsp2.0里面才可以使用的标签:
    <jsp:scriptlet>:相当于<%%>
    <jsp:scriptlet>
     int x = 3;
     if(x < 5){
      out.println(x);
     }
    </jsp:scriptlet>
    会报错.因为在此使用了"<"这个符号,必须用
    <![CDATA[
     代码
    ]]>

    <jsp:declartion>
    </jsp:declaration>相当于<%!%>

    <jsp:expression>
    </jsp:expression>相当于<%=%>

    <jsp:directive.指令名 属性="值"/>相当于<%@ page 属性="值"%>

    <%@ page contentType="text/html;charset=gb2312"%>
    <%
     out.println("中国"); 
    %>

    <%
     response.setContentType("text/html;charset=gb2312");
     out.println("中国");
    %>
    的效果是不一样的.前者打印出了"中国"两字,后者打印出来的是乱码,为什么呢?
    前者告诉jsp引擎按照指定的contentType去把jsp的内容翻译成servlet,因为charset指定为了gb2312,所以正常的输出了.
    后者为什么是乱码呢?这是因为jsp源文件的中文字符在翻译成Servlet源文件时已经不是其正确的unicode编码了,当服务器把这两个字符按照gb2312输出正文时,出现的就是乱码了.

    <jsp:setProperty name="date" property="time" param="time"/>

    <jsp:setProperty name="date" property="time" value="<%=Integer.parseInt(request.getParameter("time"))%>"/>
    意思是一样的.

    自省机制:<jsp:setProperty name="date" property="*"/>
    这种形式用于对javaBean实例对象中的多个属性赋值,它表示将请求消息中的参数逐一与javaBean实例对象中的属性进行比较,如果两个属性同名,则将该参数值赋值给该属性.注意:必须是同名的才赋值.

    <jsp:useBean id="date" class="Java.util.Date" scope="request"/>
    这个jsp标签的含义为:
    在指定范围(这里是request,如果不写,默认为page)内去找一个名字为date的对象,如果找到了则把它取出来,如果没找到则实例化一个新的类型为java.util.Date的名字为date的对象,并将它保存在request中,

    <jsp:useBean id="date" class="java.util.Date" scope="request">
    ......
    </jsp:useBean>
    如果上面的语句这样写,其含义则为:
    在指定范围(这里是request,如果不写,默认为page)内去找一个名字为date的对象,如果找到了则把它取出来,"......"地方的代码不再执行.如果没找到则实例化一个新的类型为java.util.Date的名字为date的对象,并将它保存在request中,还将执行"......"地方的代码.

    5.
    forward() 与redirect()的区别? 
    答:前者仅是容器中控制权的转向,在客户端浏览器地址栏中不会显示出转向后的地址;后者则是完全的跳转,浏览器将会得到跳转的地址,并重新发送请求链接。这样,从浏览器的地址栏中可以看到跳转后的链接地址。所以,前者更加高效,在前者可以满足需要时,尽量使用forward()方法,并且,这样也有助于隐藏实际的链接。在有些情况下,比如,需要跳转到一个其它服务器上的资源,则必须使用sendRedirect()方法。

     




















    展开全文
  • 包含指令和包含操作标记都用于将文件包含到当前 JSP 页面中。但是,它们包含文件的方式有所不同。在解释它们之间的区别之前,让我们简要介绍一下它们。 JSP 包含指令 index.jsp <html> <head> <...

    包含指令包含操作标记都用于将文件包含到当前 JSP 页面中。但是,它们包含文件的方式有所不同。在解释它们之间的区别之前,让我们简要介绍一下它们。

    JSP 包含指令

    index.jsp

    <html>
    <head>
    <title>JSP include Directive example</title>
    </head>
    <body>
    <%@ include file="display.jsp" %>
    </body>
    </html>

    display.jsp

    <p>This is the content of my file</p>

    输出:

    JSP 包含动作标签

    index.jsp

    <html>
    <head>
    <title>JSP include Action example</title>
    </head>
    <body>
    <jsp:include page="display.jsp" />
    </body>
    </html>

    display.jsp

    <p>This is the content of my file</p>

    输出:与我们在 include 指令示例中得到的完全相同。

    JSP 包含指令与包含操作标记

    我们在上面看到,两者的输出是相同的,但是它们之间几乎没有明显的差异。

    1) Include 指令在翻译时包含文件(JSP 生命周期的阶段, JSP 被转换为等效的 servlet),而包含操作在运行时包含文件。

    2) 如果包含的文件发生了更改,但包含它的 JSP 没有更改,那么这些更改将仅在我们使用 include 操作标记时反映。如果您使用 include 指令,更改将不会反映,因为 JSP 没有更改,因此不会翻译(在此阶段,使用指令时仅包含文件)以进行请求处理,因此更改不会反映。

    3)语法差异:include指令: <%@ include file="file_name" %>而include动作有这样的 <jsp:include page="file_name" />

     

    4)当使用包含动作标签时,我们也可以通过使用参数动作标签将参数传递给包含页面,但在包含指令的情况下,这是不可能的。

    <jsp:include page="file_name" />
     <jsp:param name="parameter_name" value="parameter_value" />
     </jsp:include>

    这些是包含指令和包含操作之间的主要区别。

    展开全文
  • JSP中的常用指令标签

    2019-10-15 19:21:12
    Taglib 导入java标准标签库 Page指令 //告知浏览器以什么格式编码解析 响应的数据 <%@ page contentType=“text/html;charset=UTF-8” %> //设置jsp页面转换的语言 <%@ page language=“java” %> /.....

    Page 导包 设置网页编码 指定脚本语言 指定错误页面

    Include 静态导入页面

    Taglib 导入java标准标签库

    Page指令

    //告知浏览器以什么格式和编码解析 响应的数据
    <%@ page contentType=“text/html;charset=UTF-8” %>

    //设置jsp页面转换的语言
    <%@ page language=“java” %>

    //导包
    <%@page import=“com.bjsxt.entity.User” %>

    //在转换成java代码时使用的编程一般不用设置
    <%@ page pageEncoding=“UTF-8” %>

    //指定错误页 当页面发生错误时 指定跳转的页面
    <%@ page errorPage=“error500.jsp” %>

    //指定当前页为错误提示页 当前页面可以接收异常对象
    <%@ page isErrorPage = “true”>

    ErrorPage是一种处理错误提示页的功能

    在web.xml中配置各种错误提示的提示页

    500
    /error500.jsp

    404 /error404.jsp

    当jsp中配置的错误页和web.xml中配置的错误页冲突了jsp page指令的errorPage优先级更高

    Include指令
    用于在当前jsp页面引入其他jsp页面使用的

    被引入的jsp页面不会生成java代码被引用的网页和当前页生成代码后形成了一个java文件
    <%@include file=“head.jsp” %>

    //动态引用jsp标签中的include选项
    被引用的jsp页面会生成独立的java代码
    <jsp: include page=“head.jsp”/>

    Taglib指令
    用于导入标签库
    Jsp中的九大内置对象

    在jsp页面可以直接使用 不用我们自己创建的对象
    四个域对象 最重要的经常用
    PageContext page域 当前页面内可用
    HttpServletRequest reqeust域 单次请求
    HttpSession sessoin域单次会话
    Application ServletContext 上下文域 任何会话 任何请求 任何jsp页面
    两个关于响应和输出
    Response响应对象
    Out 打印流对象 Writer out = response.getWriter();
    三个打酱油对象
    ServletConfig
    Page this对象 当前jsp对象本身
    Exception 对象 在错误提示页上使用当page指令标签isErrorpage=true 当前网页可以接收项目本身的异常对象
    Servlet1 用于向三个域中放入数据并跳转至jsp

    展开全文
  • JSP指令标签 使用包含操作,可以将一些重复的代码包含进来继续使用,从正常的页面组成来看,有时可能分为几个区域。 而其中的一些区域可能是一直不需要改变的,改变的就其中的一个具体内容区域。现在有两种...
  • 一、JSP三大指令标签 1.page:用来定义整个JSP页面的一些属性这些属性的值。如:<%@ page buffer = “24kb”%> **注意:**如果为一个属性指定几个值,这些值需要用逗号隔开。page指令只能给import属性指定...
  • 其中,inlcude指令只有一个file属性,filename指被包含的文件的名称(相对路径),被插入的文件必须与当前JSP页面在同一Web服务目录下。 include指令在编译时,编译器就会把指令所指向目标文件的内容复制到指令所在的...
  • jsp指令标签

    千次阅读 2018-08-30 14:47:58
    page指令 page常用属性  language属性 该属性用于设置JSP页面使用的语言,目前只支持Java语言。例:&lt;%@ page language=”java” %&gt; import属性 该属性用于设置JSP所导入的类包,JSP页面可以嵌入...
  • jsp中page指令用法详解

    2020-10-23 12:03:10
    主要介绍了jsp中page指令用法,以实例形式较为详细的分析了JSP中page相关指令的功能、定义及用法,具有一定参考借鉴价值,需要的朋友可以参考下
  • 标签设定数据源 语法结构: 代码如下:  ”jdbcUrl” driver=”driverClassName” user=”userName” password=”password” xss=removed u201cvarName”][scope=”{page> 标签进行增删改的操作 第一种格式: ...
  • JSP中JSTL标签指令使用详解

    千次阅读 2016-12-23 13:54:10
    标签用于通用数据循环,它有以下属性|属 性 ——- |描 述——————–|是否必须———–|缺省值items ——-进行循环的项目 ———-否——————–无 begin ——–开始条件——————否—————— 0 end ...
  • jsp的指令标记有哪些_JSP指令标记

    千次阅读 2020-07-29 19:43:23
    jsp的指令标记有哪些 JSP指令标记 (JSP Directive Tag) Directive Tag gives special instruction to Web Container at the time of page translation. Directive tags are of three types: page, include and ...
  • jsp的三种指令标签

    千次阅读 2017-01-18 14:56:33
    一、三种指令标签: 1.page指令: 定义网页依赖属性 2.taglib指令: 引入标签库 3.include指令: 包含其他文件 二、page指令 属性: 1:language  定义jsp页面使用的脚本语言,默认为Java 2:import 导入要使用的...
  • JSP taglib指令:引入标签指令

    千次阅读 2021-06-18 07:57:43
    通过使用 JSP taglib 指令,开发者就可以在页面中使用这些基本标记或自定义的标记来完成特殊的功能。语法:参数说明:uri:该属性指定了 JSP 要在 web.xml 文件中查找的标签库描述符,该描述符是一个标签描述文件(*....
  • JSP指令标签

    2017-06-20 14:23:16
    JSP指令标签
  • 在实际的开发中,如为了简化JSP中出现大量的JSP脚本,那么我们需要使用标准标签EL表达式,但是和新标签库中提供的标签是有限的,不可能完全满足开发的需要。如:分页。因此需要学习如何自定义自己的标签库。 ...
  • JSP指令

    千次阅读 多人点赞 2018-08-07 10:04:35
    -------------------------------------JSP指令------------------------------------- JSP指令 1 什么是JSP指令 JSP指令的格式:&lt;%@指令名 attr1=”” attr2=”” %&gt;,一般都会把JSP指令放到JSP...
  • JSP的学习路线 ... JSP标签式语法(指令和动作) JSTL标签JSP的解析编译执行过程* 什么是JSP? 1.Java Server Pages(JSP) is a technology thathelps software develop...
  • 3.JSP动作标记和指令标记

    千次阅读 2021-10-01 11:04:34
    page指令用来定义整个jsp页面的一些属性这些属性的值,属性值用单引号或者双引号括起来 page语法格式: <%@ page 属性1= “值1” 属性2=“值2” …%> page指令标记可以指定如下属性的值:contentType、...
  • JSP指令

    2021-11-12 20:39:21
    常用的JSP指令有page指令、include指令taglib指令。 1.page指令 2.include指令 3.taglib指令 page指令 page指令用来定义JSP文件中的全局属性,它描述了与页面相关的一些信息,其作用域被它所在的JSP页面其包含...
  • 这样在界面jsp中引入其中的标签库或者标签库文件,然后才可以正常使用其中定义的标签。 代码如下:<%@ taglib prefix =”bean” uri= “http://struts.apache.org/tags-bean” %> <%@ taglib
  • JSP三大指令

    2022-02-16 19:59:32
    JSP 指令 是为 JSP 引擎(比如 Tomcat)而设计的,它们并不直接产生任何可见输出,而只是告诉引擎如何处理 JSP 页面中的其余部分。 JSP 引擎会根据 JSP指令信息来编译 JSP,生成 Java 文件。在生成的 Java 文件中...
  •  标准的JSP标记可以调用JavaBeans组件或者执行客户的请求,这大大降低了JSP开发的复杂度维护量。JSP技术也允许你自定义的taglib,其实换句话说,taglib可以看成是对JSP标记的一种扩展,正如xml是对html的一种扩展...
  • JSP指令标签大全

    千次阅读 2014-12-08 21:40:54
    指令元素 1.page指令 import session contentType buffer isTreadSafe info errorPage isErrorPage 2.include指令 3.taglib指令 二.脚本元素 1.声明元素 2.表达式元素 3.脚本元素 4.注释元素 三....
  • 这篇文章主要介绍JSP中的脚本、注释、表达式等知识点,已经如何在JSP页面中使用Java代码编写程序。 往期文章 目录 一、JSP的注释 注释,我们都知道是啥了,就是解释说明你的代码是干啥的,注释是不影响程序的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,016
精华内容 16,006
关键字:

jsp指令和标签