精华内容
下载资源
问答
  • jsp标签

    千次阅读 2017-07-27 19:55:30
    1、jsp标签 8.1 jsp标签的作用 jsp标签作用:替换jsp脚本。 1)流程判断(if for循环) 2)跳转页面(转发,重定向) 3)。。。。。   8.2 Jsp标签分类 1)内置标签(动作标签): 不需要在jsp页面导入...

    1、jsp标签

    8.1 jsp标签的作用

    jsp标签作用:替换jsp脚本。

    1)流程判断(if   for循环)

    2)跳转页面(转发,重定向)

    3)。。。。。

     

    8.2 Jsp标签分类

    1)内置标签(动作标签):

    不需要在jsp页面导入标签

    2)jstl标签:

    需要在jsp页面中导入标签

    3)自定义标签 :

    开发者自行定义,需要在jsp页面导入标签

    8.3 动作标签

      A)转发标签:  <jsp:forward />

      B)参数标签  <jsp:pararm/>

      C)包含标签:  <jsp:include/>

    原理: 包含与被包含的页面先各自翻译成java源文件,然后再运行时合并在一起。

    (先翻译再合并),动态包含

     

      D)静态包含  vs  动态包含的区别?

     

    1)语法不同

    静态包含语法: <%@inclue file="被包含的页面"%>

    动态包含语法: <jsp:include page="被包含的页面">

     

    2)参数传递不同

    静态包含不能向被包含页面传递参数

    动态包含可以向被包含页面传递参数

    3)原理不同

    静态包含: 先合并再翻译

    动态包含: 先翻译再合并

    8.4 JSTL标签

    JSTL (全名:java  standard  tag  libarary   -  java标准标签库  )

     

    1、核心标签库 c标签库) 天天用

    2、国际化标签(fmt标签库)

    3、EL函数库(fn函数库)

    4、xml标签库(x标签库)

    5sql标签库(sql标签库)

     

    8.5 使用JSTL标签步骤

    1) 导入jstl支持的jar包(标签背后隐藏的java代码)

    注意:使用javaee5.0的项目自动导入jstl支持jar包

    2)使用taglib指令导入标签库

    <%@taglib uri="tld文件的uri名称" prefix="简写" %>

    3)在jsp中使用标签

    86.6、核心标签库的重点标签:

    1、保存数据:

    <c:set></c:set>   

    2、获取数据: 

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

    3、单条件判断

                <c:if test=""></c:if>

    4、多条件判断

              <c:choose></c:choose>

           <c:when test=""></c:when>

              <c:otherwise></c:otherwise>

    5、循环数据

              <c:forEach></c:forEach>

              <c:forTokens items="" delims=""></c:forTokens>

    6、重定向

              <c:redirect></c:redirect>

    展开全文
  • JSP标签

    2013-09-03 21:21:54
    一:JSP标签  JSP标签也被称之为 JSP Action(JSP动作)元素,它用在JSP 页面中提供业务逻辑功能,避免在JSP页面中直接编写Java 代码,造成JSP 页面难以维护。 二:JSP 常用标签 ...

    一:JSP标签

            JSP标签也被称之为 JSP Action(JSP动作)元素,它用在JSP 页面中提供业务逻辑功能,避免在JSP页面中直接编写Java 代码,造成JSP 页面难以维护。


    二:JSP 常用标签

    	<jsp:include page="/index.jsp"/>        			<!-- 动态包含 --> 
    
    	<jsp:forward page="/index.jsp">						<!-- 跳转 -->
    		<jsp:param name="username" value="Haizhu"/>		<!-- 传递参数 -->
    	</jsp:forward>
    
    下面是javaBean 标签:

    	<jsp:useBean>
    		<jsp:setProperty/>
    		<<jsp:getProperty/>
    	</jsp:useBean>
    
    详见JSP 与 JavaBean 


    三:自定义标签





    展开全文
  • jsp标签详解

    千次阅读 2018-09-10 18:23:46
    学习jsp不得不学习jsp标签,一般来说,对于一个jsp开发者,可以理解为jsp页面中出现的java代码越少,对jsp的掌握就越好,而替换掉java代码的重要方式就是使用jsp标签。  jsp标签的分类:  1)内置标签(动作标签...

    学习jsp不得不学习jsp标签,一般来说,对于一个jsp开发者,可以理解为jsp页面中出现的java代码越少,对jsp的掌握就越好,而替换掉java代码的重要方式就是使用jsp标签。

     jsp标签的分类:

      1)内置标签(动作标签): 不需要在jsp页面导入标签

      2)jstl标签: 需要在jsp页面中导入标签

      3)自定义标签 : 开发者自行定义,需要在jsp页面导入标签

      1、内置标签(动作标签):   

    <jsp:forward />转发标签: 

      语法:<jsp:forward page="/MyJsp001.jsp"></jsp:forward>
    
      相当于java代码:request.getRequestDispatcher("/MyJsp001.jsp?name=jxf").forward(request, response);
    
      注意:但是java代码的转发可以通过url带参数的方式进行传递参数,而转发标签需要借助于下面的<jsp:param>标签实现参数传递

    <jsp:pararm/>参数标签:  

    语法:  <jsp:param value="jxf" name="name"/> <%-- 传递一个名为name,值为jxf的参数,参数一般作为其他标签的子标签使用--%>
    
    结合<jsp:forward>标签用法:
    <jsp:forward page="/MyJsp001.jsp">
      <jsp:param value="jxf" name="name"/>
    </jsp:forward> 

    <jsp:include/>包含标签:  

     语法:
    
    <jsp:include page="/MyJsp001.jsp">
            <jsp:param value="jxf" name="name"/><%--可以将参数传递给包含进来的页面--%>
    </jsp:include>
    
    jsp中还有一个包含指令,也是将一个页面包含另外的页面
    
    他们之间的区别:
    
      1、首先是语法不同
    
        <jsp:include page="/MyJsp001.jsp">
    
        <%@inclue file="被包含的页面"%>
    
      2、<jsp:include>可以传递参数,<%@inclue%>不可以
    
      3、<jsp:include>:包含页面与被包含页面分别编译为两个java源文件,在运行时引用
    
         <%@inclue%>:包含页面与被包含页面合并编译为一个java源文件

     2、jstl标签:    

         JSTL (java  standard  tag  libarary   -  java标准标签库)

      jstl标签的类型:
    
      核心标签库 (c标签库)//这里主要介绍c标签库,因为用的真的很多
    
      国际化标签(fmt标签库)
    
      EL函数库(fn函数库)
    
      xml标签库(x标签库)//一般不用该库,这属于数据操作,而数据操作应于dao层中,jsp页面主要用于展示数据
    
      sql标签库(sql标签库)//与xml标签库类似,不应在jsp页面中操作数据(当然他们是可以在jsp页面写)

    使用jstl标签库使用前提(此处以c标签库为例):

    1、导入jstl支持包:jstl-1.2.jar(如果用MyEclipse创建项目时候选择java EE5.0,则不需要导包,工程中已经包含)

    2、在页面中使用Taglib指令导入标签库  

    <%--uri:tld文件中的uri名称,prefix:标签前缀--%>
    <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

     

    uri和prefix怎样写?以标签库的为例:

    工程名->Java EE 5 Libraries->jstl-1.2.jar->META-INF-c.tld

    c标签库的主要标签:

    <c:set>标签:用于保存数据到域对象中

       <%--var为属性名 value为属性值 scope为保存属性到那个域对象,默认为page域 --%>
        <%--相当于java代码<%pageContext.setAttribute("name", "jxf") --%>
        <c:set var="name" value="jxf"  scope="page"></c:set>
        ${name}<%--EL表达式输出page域中的name属性值--%>

     <c:out>标签:显示数据

    <%--value:输出到浏览器的值,${name}EL表达式取出域对象属性值为name的值,
       default:当value值为null时显示的默认值,
       escapeXml:表示是否转义为xml格式(也可以理解为普通文本格式),true表示转义,默认false --%>
          <c:out value="${name}" default="<h1>标题h1<h1>" escapeXml="false"></c:out>

     <c:if>标签:但条件判断

    <%--test支持EL表达式 --%>
          <c:if test="${true}">
              条件成立!
          </c:if>

    <c:choose>+<c:when>+<c:otherwise>标签:多条件判断

    复制代码

    <%--相当于if else结构,当有一条件满足后其他条件都不满足,证:此实例只输出 10>5--%>
          <c:choose>
              <c:when test="${10>5}">
                  10>5<br />
              </c:when>
              <c:when test="${6>2}">
                  6>2<br />
              </c:when>
              <c:otherwise>
                  条件都不成立
              </c:otherwise>
          </c:choose>

    复制代码

    <c:forEach>标签:遍历

          <%--
          begin : 从哪个元素开始遍历,默认从0开始
          end    : 到哪个元素结束。默认到最后一个元素
          step     : 步长,默认1
          items    : 需要遍历的数据(集合) 
          var    : 每个元素的名称 
          varStatus: 当前正在遍历元素的状态对象。(count属性:当前位置,从1开始)
         --%>
          <%
    
        //Student{
        //  public String name;
        //  public int age;
        //  public Student(String Name,int Age){
        //    this.name = Name;
        //    this.age = age;
        //  }
        //}
            //List数据准备
             List<Student>  list = new ArrayList<Student>();
             list.add(new Student("name001",18));
             list.add(new Student("name002",19));
             list.add(new Student("name003",20));
             pageContext.setAttribute("list",list);//放入域中
             
             //Map数据准备
             Map<String,Student> map = new HashMap<String,Student>();
             map.put("001",new Student("name001",18));
             map.put("002",new Student("name002",19));
             map.put("003",new Student("name003",20));
             pageContext.setAttribute("map",map);//放入域中
             
             //array数据准备
             Student[] array = new Student[]{
             new Student("name001",18),
             new Student("name002",19),
             new Student("name003",20)};
             pageContext.setAttribute("array",array);//放入域中
         %>
        <%--遍历list --%>
          <c:forEach var="student" begin="0" end="2" items="${list}" step="1" varStatus="varSta">
              name:${student.name}---age:${student.age}<br/>
          </c:forEach>
          <%--遍历map --%>
          <c:forEach var="student" begin="0" end="2" items="${map}" step="1" varStatus="varSta">
              key:${student.key}---name:${student.value.name}---age:${student.value.age}<br/>
          </c:forEach>
          <%--遍历array --%>
          <c:forEach var="student" begin="0" end="2" items="${array}" step="1" varStatus="varSta">
              name:${student.name}---age:${student.age}<br/>
          </c:forEach>
          <%--一般遍历集合或者数组都是全部遍历,所以只写2个属性var和items,其他取默认值 --%>
          <c:forEach var="student" items="${array}">
              name:${student.name}---age:${student.age}<br/>
          </c:forEach>

    <c:forTokens>标签:切割字符串

    <%--
          切割字符串,相当于split函数
          var:切割出来的每一部分字符串
          items:要切割的字符串
          delims:分割的字符,若内容为字符串,则这个字符串的每个字符都会当作一个分割的字符
          如:items="a-b-c=d=e" dilims="-=",分割的结果为 a,b,c,d,e
     --%>
      <%
          //数据准备
          String str = "a-b-c=d=e";
          pageContext.setAttribute("str", str);
     %>
          <c:forTokens var="item" items="${str}" delims="-=">
              ${item}<br />
          </c:forTokens>

     3、自定义标签:      

      当JSTL标签库已经无法满足我们的需求时候,就需要自己开发自定义标签,来满足我们的需求,自定义标签实际上是一个普通的java类,继承SimpleTagSupport类。

    在介绍自定义标签之前,先介绍SimpleTagSupport类:

    SimpleTagSupport类继承自SimpleTag接口,而SimpleTag接口主要有以下4个方法,也可将这四个方法理解为标签处理器类的生命周期:

     1 public interface SimpleTag extends JspTag {   
     2 
     3    /**
     4      * 执行标签时调用的方法,一定会调用
     5      */
     6     public void doTag() throws javax.servlet.jsp.JspException, java.io.IOException;
     7     
     8     /**
     9      * 设置父标签对象,传入父标签对象,当标签存在父标签时会调用
    10      */
    11     public void setParent( JspTag parent );
    12    
    13     /**
    14      * 设置JspContext对象,其实他真实传入的是其子类PageContext
    15      */
    16     public void setJspContext( JspContext pc );
    17                 
    18     /**
    19      * 设置标签体内容。标签体内容封装到JspFragment对象 中,然后传入JspFragment对象
    20      */
    21     public void setJspBody( JspFragment jspBody );
    22 
    23 }

    SimpleTagSupport类在其基础上封装出了3个方法,方便自定义标签类编写,该方法实现也比较简单,无非就是内部维护一个变量,通过set方法将其赋值,再返回该对象,这样继承SimpleTagSupport拿到如PageContext对象就直接调用getJspContext()即可。

     1 /*SimpleTagSupport 类的一部分*/
     2 public class SimpleTagSupport implements SimpleTag
     3 {
     4     /** Reference to the enclosing tag. */
     5     private JspTag parentTag;
     6     
     7     /** The JSP context for the upcoming tag invocation. */
     8     private JspContext jspContext;
     9     
    10     /** The body of the tag. */
    11     private JspFragment jspBody;
    12 
    13     public void setParent( JspTag parent ) {
    14         this.parentTag = parent;
    15     }
    16    
    17     public JspTag getParent() {
    18         return this.parentTag;
    19     }
    20    
    21     public void setJspContext( JspContext pc ) {
    22         this.jspContext = pc;
    23     }
    24    
    25     protected JspContext getJspContext() {
    26         return this.jspContext;
    27     }
    28                
    29     public void setJspBody( JspFragment jspBody ) {
    30         this.jspBody = jspBody;
    31     }
    32    
    33     protected JspFragment getJspBody() {
    34         return this.jspBody;
    35     }
    36 }

    编写自定义标签的步骤:

    以写一个自定义标签为例:功能:向浏览器输出一句话“酒香逢 博客园欢迎您”

    1)编写一个普通的java类(OutInfo.java),继承SimpleTagSupport类,并重写doTag方法。(jsp文件最后编译为java文件,查看该java文件可知_jspService方法中,会创建标签类OutInfo对象,并执行doTag方法。编译后原文件路径:如D:\Program Files\Tomcat\apache-tomcat-6.0.39\work\Catalina\localhost\Tag\org\apache\jsp\xxx.java)

     1 /*
     2  * OutInfo.java
     3  */
     4 public class OutInfo extends SimpleTagSupport {
     5     
     6     @Override
     7     public void doTag() throws JspException, IOException {
     8         PageContext pageContext = (PageContext)getJspContext();
     9         pageContext.getOut().write("酒香逢 博客园欢迎您");
    10     }
    11 }

     2)在web项目的WEB-INF目录下建立tld文件(jxf.tld),这个tld文件为标签库的声明文件,并配置好相应的信息。(可以参考核心标签库的tld文件,如:项目/Java EE 5 Libraries/jstl-1.2jar/META-INF/c.tld)

     1 <?xml version="1.0" encoding="UTF-8" ?>
     2 
     3 <taglib xmlns="http://java.sun.com/xml/ns/javaee"
     4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     5     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
     6     version="2.1">
     7     
     8   <description>JSTL 1.1 core library</description>
     9   <display-name>JSTL core</display-name>
    10   <tlib-version>1.1</tlib-version>
    11   <!--标签库前缀 taglib指令中的prefix属性 -->
    12   <short-name>jxf</short-name>
    13   <!--tld文件的唯一标记 taglib指令中的uri属性 -->
    14   <uri>http://jxf.tag</uri>
    15 
    16   <tag>
    17     <description>
    18                     这是自定义标签的描述信息,可以在MyEclipse中有提示
    19     </description>
    20     <!-- 标签名 -->
    21     <name>outInfo</name>
    22     <!-- 标签类的完名 -->
    23     <tag-class>jxf.OutInfo</tag-class>
    24     <body-content>scriptless</body-content>
    25     <!-- <attribute>
    26         <description>
    27                                    这是属性的描述信息          
    28         </description>
    29         <name>var</name>
    30         <required>false</required>
    31         <rtexprvalue>false</rtexprvalue>
    32     </attribute> -->
    33   </tag>
    34 
    35 </taglib>

    3)在jsp页面的头部导入自定义标签库

    <%@taglib uri="http://jxf.tag" prefix="jxf" %>

    4)在jsp中使用自定义标签 

    <jxf:outInfo></jxf:outInfo>

    5)jsp页面

     1 <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
     2 <%@taglib uri="http://jxf.tag" prefix="jxf" %>
     3 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     4 <html>
     5   <head>
     6     <title>自定义标签</title>
     7   </head>
     8   <body>
     9     <jxf:outInfo></jxf:outInfo>
    10   </body>
    11 </html>

    自定义标签能够做的:

    1)控制标签体内容输出

    1         /*
    2          * 1)输出标签题内容
    3          */
    4         JspFragment jspBody = getJspBody();
    5         //方法:invoke(java.io.Writer out)
    6         //当参数为null时等价于 jspBody.invoke(getJspContext().getOut());
    7         jspBody.invoke(null);

    2)控制标签余下内容输出

    1         /*
    2          * 2)控制标签体余下内容是否输出
    3          * 抛出一个SkipPageException异常后,标签体余下内容输出
    4          */
    5         throw new SkipPageException();

    3)改变标签体内容

    1         /*
    2          * 3)改变标签体内容并输出到浏览器
    3          */
    4         //获取到标签体内容,并保存到自定义的款冲字符流中
    5         StringWriter sw = new StringWriter();
    6         //jspBodyString得到的即是标签体的内容
    7         String jspBodyString =  sw.toString();
    8         jspBodyString = "简单将字符串的值改变掉";
    9         getJspContext().getOut().write(jspBodyString);//输出到浏览器

    4)带属性的标签(以模仿c标签的<c:choose>+<c:when>+<c:otherwise>标签为例)

    编写3个自定义标签处理器类 ChooseTag.java、 When.java、 Otherwise.jave

     1 /*
     2  * ChooseTag.java
     3  */
     4 public class ChooseTag extends SimpleTagSupport {
     5     private boolean flag = false;
     6 
     7     public boolean isFlag() {
     8         return flag;
     9     }
    10 
    11     public void setFlag(boolean flag) {
    12         this.flag = flag;
    13     }
    14     @Override
    15     public void doTag() throws JspException, IOException {
    16         getJspBody().invoke(null);
    17     }
    18 }
    /*
     * WhenTag.java
     */
    public class WhenTag extends SimpleTagSupport {
        private boolean test;
        
        //tld文件中的属性必须要有对应的set方法,否则报错
        public void setTest(boolean test) {
            this.test = test;
        }
        @Override
        public void doTag() throws JspException, IOException {
            ChooseTag parent = (ChooseTag)getParent();
            if(!parent.isFlag()){
                if(test){
                    parent.setFlag(true);
                    getJspBody().invoke(null);
                }
            }
        }
    }
     1 /*
     2  * OtherwiseTag.java
     3  */
     4 public class OtherwiseTag extends SimpleTagSupport {
     5     @Override
     6     public void doTag() throws JspException, IOException {
     7         ChooseTag parent = (ChooseTag)getParent();
     8         if(!parent.isFlag()){
     9             getJspBody().invoke(null);
    10         }
    11     }
    12 }

    tld文件

     1 <?xml version="1.0" encoding="UTF-8" ?>
     2 
     3 <taglib xmlns="http://java.sun.com/xml/ns/javaee"
     4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     5     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
     6     version="2.1">
     7     
     8   <description>JSTL 1.1 core library</description>
     9   <display-name>JSTL core</display-name>
    10   <tlib-version>1.1</tlib-version>
    11   <!--标签库前缀 taglib指令中的prefix属性 -->
    12   <short-name>jxf</short-name>
    13   <!--tld文件的唯一标记 taglib指令中的uri属性 -->
    14   <uri>http://jxf.tag</uri>
    15 
    16   <tag>
    17     <name>chooseTag</name>
    18     <tag-class>jxf.ChooseTag</tag-class>
    19     <body-content>scriptless</body-content>
    20   </tag>
    21   <tag>
    22     <description>
    23                     自定义的when标签
    24     </description>
    25     <name>whenTag</name>
    26     <tag-class>jxf.WhenTag</tag-class>
    27     <body-content>scriptless</body-content>
    28     <attribute>
    29         <description>
    30             when标签属性test
    31         </description>
    32         <!-- 标签处理器类中的必须要有对应的set方法,否则会报错,如此时对应的标签处理器类中应有getTest()方法。 -->
    33         <name>test</name>
    34         <!-- 该属性是否是必须的 ,true为必须的,false为非必须的-->
    35         <required>true</required>
    36         <!-- 该属性是否支持EL表达式 true支持,false不支持 -->
    37         <rtexprvalue>true</rtexprvalue>
    38     </attribute>
    39   </tag>
    40   <tag>
    41     <name>otherwiseTag</name>
    42     <tag-class>jxf.OtherwiseTag</tag-class>
    43     <body-content>scriptless</body-content>
    44   </tag>
    45 </taglib>

    jsp代码

     1 <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
     2 <%@taglib uri="http://jxf.tag" prefix="jxf"%>
     3 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
     4 <html>
     5   <head>
     6     <title>模仿c标签库的choose,when,otherwise</title>
     7   </head>
     8   <body>
     9     <jxf:demoTag>标签体内容</jxf:demoTag>
    10     标签体余下内容
    11     <br />
    12     <jxf:chooseTag>
    13         <jxf:whenTag test="${4>5}">
    14             4>5是不输出的
    15         </jxf:whenTag>
    16         <jxf:whenTag test="${10>5}">
    17             10>5是成立的
    18         </jxf:whenTag>
    19         <jxf:whenTag test="${9>5}">
    20             9>5是成立的,但是不输出
    21         </jxf:whenTag>
    22         <jxf:otherwiseTag>
    23             当条件都不成立时候输出(由于第二个提条件成立,故不应输出)
    24         </jxf:otherwiseTag>
    25     </jxf:chooseTag>
    26   </body>
    27 </html>

     

    展开全文
  • JSP标签体系及自定义JSP标签

    千次阅读 2012-06-01 22:18:48
    JSP标签体系   二 . 标签的执行流程:     三.自定义标签; 3.1 自定义标签的主要作用:移除jsp中的java脚本。它属于jsp的技术 3.2、编写一个自定义标签的步骤:(传统标签的定义) 3.3写一个类,直接或...

     一 . JSP标签体系

     

    二 . 标签的执行流程:

     

     

    三.自定义标签;

    3.1 自定义标签的主要作用:移除jsp中的java脚本。它属于jsp的技术

    3.2、编写一个自定义标签的步骤:(传统标签的定义)
    3.3写一个类,直接或间接实现javax.servlet.jsp.tagext.Tag。一般通过继承TagSupport来间接实现Tag接口
      
     3.4、覆盖掉父类中的对应方法
     package com.itheima;

     import java.io.IOException;
     import java.io.PrintWriter;

     import javax.servlet.ServletRequest;
     import javax.servlet.jsp.JspException;
     import javax.servlet.jsp.JspWriter;
     import javax.servlet.jsp.tagext.TagSupport;

     public class ShowIpTag extends TagSupport {

      @Override
      public int doStartTag() throws JspException {
       ServletRequest request = pageContext.getRequest();
       String ip = request.getRemoteAddr();
       JspWriter out = pageContext.getOut();
       try {
        out.write(ip);
       } catch (IOException e) {
        e.printStackTrace();
       }
       return super.doStartTag();
      }
      
     }
     3.5在WEB-INF下面建立一个扩展名为tld的xml文件,对自定义的标签处理类进行描述
      <?xml version="1.0" encoding="UTF-8"?>
      <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
       version="2.0">
       <description>slkdjfdsjfdsfjlks.</description>
       <tlib-version>1.0</tlib-version>
       <short-name>itheima</short-name>
       <uri>http://www.itheima.com/jsp/myjstl</uri>
       <tag>
        <description>show remote ip</description>
        <name>showIp</name>
        <tag-class>com.itheima.ShowIpTag</tag-class>
        <body-content>empty</body-content>
       </tag>
      </taglib>
     3.6、在jsp中通过taglib指令引入自定义的标签,然后使用

     

    四、简单标签
    1、一般需要继承SimpleTagSupport,然后覆盖掉doTag方法即可
    2、
    a、控制部分内容不输出
     <demo1>
      abcd
     </demo1>

     doTag()方法什么都不做。
     如果要输出的话:getJspBody().invoke(null)
    b、控制标签后面的jsp内容不输出
     throw new SkipPageException();
    c、控制主体内容重复执行
     在doTag方法中循环调用getJspBody().invoke(null)
     属性:要有setter方法,同时也要在tld文件中进行描述
    d、修改主体内容后再输出
     getJspBody().invoke(null) 要吧内容输出到一个有缓冲的流中。
     StringWriter
     修改后再通过((PageContext)getJspContext).getWrtier()输出

    五、tld文件的主要标签和属性
     short-name:引用标签的前缀
     uri:tld文件要绑定到一个uri的地址。可以立即为帮到一个名称空间上
     tag:描述标签
      name:标签的名字
      tag-class:标签对应的标签处理类的全名
      body-content:标签主体内容的类型
       empty:没有主体内容
       JSP:有主体内容(用于传统标签)
       scriptless:有主体内容(用于简单标签)
      attribute:描述标签的属性
       name:属性名称
       required:是否是必须的属性
       rtexprvalue:属性的取值是否支持表达式(EL和Java表达式)

     

    展开全文
  • jsp标签和el表达式

    2018-05-26 20:43:43
    jsp标签和el表达式 (1)jsp标签是什么? jsp标签其实就是一个占位符,对应一个标签类,容器遇到jsp标签之后,会找到对应的标签类中的代码然后执行。 因为在jsp文件里面直接写java代码,不利于jsp文件的维护(比如,将...
  • JSP标签概念action元素XML元素标准Action元素JSP标签&amp;lt; jsp:include&amp;gt;标签动态引入语法&amp;lt; include&amp;gt;和&amp;lt; jsp:include&amp;gt;的区别&amp;lt; jsp:...
  • 自定义JSP标签

    2013-12-28 20:54:23
    一、自定义JSP标签概述  自定义JSP标签就是程序员定义的一种JSP标签,这种标签把那些信息显示逻辑封装在一个单独的Java类中,通过 一个XML文件来描述它的使用。当页面中需要使用类似的显示逻辑时,就可以在页面...
  • JSP标签也称为JSP Action(JSP动作)元素,用于在JSP页面中封装Java代码,这样使得在JSP页面中避免直接编写Java代码,让JSP真正成为MVC模式中的作为视图作用。 几个JSP常用标签:  &lt;jsp:include&gt;标签...
  • JSP标签库大全jsp常用的指令与标签

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

    千次阅读 2012-11-09 17:42:16
    JSP标签 JSP标签也称之为Jsp Action(JSP动作)元素,它用于在Jsp页面中提供业务逻辑功能,避免在JSP页面中直接编写java代码,造成jsp页面难以维护。     JSP的一些标签: 标签 page=”relativeURL | > flush=”...
  • JSP标签总结

    千次阅读 2011-09-30 14:24:00
    一、JSP标签基本概念:  1.标签(Tag): 标签是一种XML元素,通过标签可以使JSP网页变得简洁并且易于维护,还可以方便地实现  同一个JSP文件支持多种语言版本。由于标签是XML元素,所以它的名称和属性都是大小写...
  • 1.Spring通用标签库JSP的标签... Spring的 表单绑定 JSP标签库和Spring通用标签库 PS:JSTL 和 Spring的JSP标签库 互为补充或者互为替代吧。都是为了JSP添加功能 2.要使用Spring通用标签库 在页面上声明如下 &l...
  • JSP 标签

    千次阅读 2018-11-13 23:11:12
    标签库作用 替代Java代码 替代EL表达式脚本   导入标签库 &lt;%@ taglib prefix="c" uri=http://java.sun.com/jsp/jsti/core %&gt; prefix(前缀):区别不同的标签库 uri:标签库的路径 ...
  • Spring Security(18)——Jsp标签

    千次阅读 2017-06-15 08:55:50
    本文主要介绍Spring Security对JSP标签的支持。
  • 深入分析JavaWeb Item15 -- jsp标签

    千次阅读 2015-12-10 20:32:08
    一、JSP标签介绍 JSP标签也称之为Jsp Action(JSP动作)元素,它用于在Jsp页面中提供业务逻辑功能,避免在JSP页面中直接编写java代码,造成jsp页面难以维护。二、JSP常用标签 jsp的常用标签有以下三个 <jsp:include>...
  • # 自定义jsp标签 把已有的样式引入到标签中 我项目中之前是写<button></button>然后引入css样式 现在是想自己定义一个标签,然后引入标签就自己带样式
  • 自定义jsp标签实现按钮权限控制

    千次阅读 2018-05-15 11:39:25
    一、了解jsp自定义标签 自定义标签是用户... 好处:1.JSP标签主要用来显示结果数据,用来沟通表示层和业务逻辑层,把页面美工工作和程序编写分开。 2. 自定义标签方便JSP页面代码的维护,代码重用。二、按钮权限...
  • jsp标签之c标签 转载

    千次阅读 2011-06-02 11:32:00
    jsp标签之c标签 2009-10-12 (周一) 13:00 JSP HTML JSP HTML ⁄ 被围观 一共有 618 个打酱油的路过+ 核心标签库 如转载请注明,转载自:关注Java[http://www.gbsou.com] 本文链接: ...
  • 使用tld文件自定义jsp标签

    千次阅读 2018-12-14 14:39:19
    通过Java的TagSupport类或者BodyTagSupport类,和配套的tld文件,可以定义自己的jsp标签。 TagSupport类和BodyTagSupport类在jsp-api.jar中,这个jar包在tomcat的lib目录下有,maven里面也有。   一,标...
  • spring实战-Spring-JSP标签

    千次阅读 2017-08-17 01:01:00
    第四篇:Spring-JSP标签 1,Spring绑定标签,合计14个如下 2,Spring通用标签,合计10个,有些已经不再使用,下面重点使用messages标签 3,绑定标签实例 <!-- prefix可以赋值为任意值,本系列,将其命名为form, ...
  • Java Web学习总结(18)——JSP标签

    千次阅读 2016-01-18 15:47:45
    一、JSP标签介绍  JSP标签也称之为Jsp Action(JSP动作)元素,它用于在Jsp页面中提供业务逻辑功能,避免在JSP页面中直接编写java代码,造成jsp页面难以维护。 二、JSP常用标签  jsp的常用标签有以下三个 标签...
  • jsp标签自定义属性取值问题

    千次阅读 2018-11-22 14:18:21
    问题:jsp标签自定义属性取值问题 正确方法:var testValue = obj.getAttribute("testValue"); var testValue = obj.attributes.testValue .value; 错误方法(几种):var testValue = obj....
  • -----------------------------------------------------------------------jsp标签库的使用----------------------------------------------------------------------------- 标签: 可以理解成标记,或是变量,...
  • JSP标签介绍JSP标签也称之为Jsp Action(JSP动作)元素,它用于在Jsp页面中提供业务逻辑功能,避免在JSP页面中直接编写java代码,造成jsp页面难以维护。JSP常用标签jsp的常用标签有以下三个: <jsp:include>标签 ...
  • JSP标签编程 1

    千次阅读 2011-11-07 14:46:44
    JSP标签编程 1  标签编程在实际开发之中,并不是很常见,就是说自己开发标签的情况基本上是不存在的,因为这个与开发的环境所限制,因为自己开发之后的标签基本上没有任何的通用性,所以在实际中基本上都是大量的...
  • JSP标签c:forEach实例

    万次阅读 2014-03-31 21:52:20
    JSP标签c:forEach实例 1、实例源码 c:forEach String[] array = { "A", "B", "C", "D", "E", "F","G","H","I","J","K","L","M","N",
  • JSP标签工作原理

    千次阅读 2012-03-22 16:35:58
    最近在做chronicles的java项目。发现自己java web相关各种技术都比较稀松。...本文主要讲JSP标签的工作原理。首先看一个JSP文件: You already have 52 stories, so we wil

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,470
精华内容 14,188
关键字:

jsp标签