java web--自定义jstl标签

   1、 自定义标签

 1). HelloWorld

①. 创建一个标签处理器类: 实现 SimpleTag 接口.
                   ②. 在 WEB-INF 文件夹下新建一个 .tld(标签库描述文件) 为扩展名的 xml 文件. 并拷入固定的部分: 并对
                         description, display-name, tlib-version, short-name, uri 做出修改

<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/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
                                       version="2.0">
                                     <description>JSTL 1.1 core library</description>
                                     <display-name>JSTL core</display-name>
                                     <tlib-version>1.1</tlib-version>
                                    <short-name>c</short-name>
                                    <uri>http://java.sun.com/jsp/jstl/core</uri>
                         </taglib>

③. 在 tld 文件中描述自定义的标签:

<!-- 描述自定义的 HelloSimpleTag 标签 -->
                                  <tag>
                                           <!-- 标签的名字: 在 JSP 页面上使用标签时的名字 -->
                                     <name>hello</name>
                                            <!-- 标签所在的全类名 -->
                                     <tag-class>com.atguigu.javaweb.tag.HelloSimpleTag</tag-class>
                                            <!-- 标签体的类型 -->
                                     <body-content>empty</body-content>
                                  </tag>
                     ④. 在 JSP 页面上使用自定义标签:

> 使用 taglib 指令导入标签库描述文件: <%@taglib uri="http://www.atguigu.com/mytag/core" prefix="atguigu" %>
                           > 使用自定义的标签: <atguigu:hello/>
              2). setJspContext: 一定会被 JSP 引擎所调用, 先于 doTag, 把代表 JSP 引擎的 pageContext 传给标签处理器类.

private PageContext pageContext;
                            @Override
                            public void setJspContext(JspContext arg0) {
                                        System.out.println(arg0 instanceof PageContext);
                                        this.pageContext = (PageContext) arg0;
                            }

     3). 带属性的自定义标签:

①. 先在标签处理器类中定义 setter 方法. 建议把所有的属性类型都设置为 String 类型.

private String value;
                          private String count;

public void setValue(String value) {
                                     this.value = value;
                                }

public void setCount(String count) {
                                    this.count = count;
                               }

②. 在 tld 描述文件中来描述属性:

<!-- 描述当前标签的属性 -->
                             <attribute>
                                     <!-- 属性名, 需和标签处理器类的 setter 方法定义的属性相同 -->
                             <name>value</name>
                                     <!-- 该属性是否被必须 -->
                             <required>true</required>
                           <!-- rtexprvalue: runtime expression value
                                当前属性是否可以接受运行时表达式的动态值 -->
                                <rtexprvalue>true</rtexprvalue>
                           </attribute>

③. 在页面中使用属性, 属性名同 tld 文件中定义的名字.

<atguigu:hello value="${param.name }" count="10"/>

   4). 通常情况下开发简单标签直接继承 SimpleTagSupport 就可以了. 可以直接调用其对应的 getter 方法得到对应的 API

public class SimpleTagSupport implements SimpleTag{
                                        public void doTag()
                                        throws JspException, IOException{}
                                        private JspTag parentTag;
                                   public void setParent( JspTag parent ) {
                                                 this.parentTag = parent;
                                           }
                                   public JspTag getParent() {
                                                 return this.parentTag;
                                          }
                                   private JspContext jspContext;
                                   public void setJspContext( JspContext pc ) {
                                          this.jspContext = pc;
                                             }
                                   protected JspContext getJspContext() {
                                               return this.jspContext;
                                               }
                                   private JspFragment jspBody;
                                   public void setJspBody( JspFragment jspBody ) {
                                            this.jspBody = jspBody;
                                              }
                                   protected JspFragment getJspBody() {
                                               return this.jspBody;
                                               }
                                    }

    2. JSTL:

1)*. c:out 主要用于对特殊字符进行转换. 真正进行输出时, 建议使用 c:out, 而不是使用 EL
                  2)*. c:set: 可以为域赋属性值。 而对域对象中的 JavaBean 的属性赋值用的并不多.
                  3). c:remove: 移除指定域对象的指定属性值(较少使用, 即便移除也是在 Servlet 中完成)

4)*. c:if: 在页面上对现实的内容进行过滤, 把结果存储到域对象的属性中. 但不灵活, 会被其他的自定义标签所取代.
                   5). c:choose, c:when, c:otherwise: 作用同上, 但麻烦, 不灵活.

6)*. c:forEach: 对集合进行遍历的. 常用!
                  7). c:forTokens: 处理字符串, 类似于 String 累的 split() 方法(知道即可)

8). c:import: 导入页面到当前页面的. (了解)
                  9). c:redirect: 当前页面进行重定向的. (使用较少)
                 10)*. c:url: 产生一个 URL 的, 可以进行 URL 重写, 变量值编码, 较为常用.

   3. 开发有父标签的标签:

1). 父标签无法获取子标签的引用, 父标签仅把子标签作为标签体来使用.

2). 子标签可以通过 getParent() 方法来获取父标签的引用(需继承 SimpleTagSupport 或自实现 SimpleTag 接口的该方法):
                         若子标签的确有父标签, JSP 引擎会把代表父标签的引用通过 setParent(JspTag parent) 赋给标签处理器

3). 注意: 父标签的类型是 JspTag 类型. 该接口是一个空接口, 但是来统一 SimpleTag 和 Tag 的. 实际使用需要进行类型的强制转换.

4). 在 tld 配置文件中, 无需为父标签有额外的配置. 但, 子标签是是以标签体的形式存在的, 所以父标签的

<body-content></body-content>      需设置为 scriptles

5). 实现

<c:choose>
                                         <c:when test="${param.age > 24}">大学毕业</c:when>
                                        <c:when test="${param.age > 20}">高中毕业</c:when>
                                        <c:otherwise>高中以下...</c:otherwise>
                              </c:choose>

> 开发 3 个标签: choose, when, otherwise
                     > 其中 when 标签有一个 boolean 类型的属性: test
                     > choose 是 when 和 otherwise 的父标签
                     > when 在 otherwise 之前使用
                     > 在父标签 choose 中定义一个 "全局" 的 boolean 类型的 flag: 用于判断子标签在满足条件的情况下是否执行.
                                * 若 when 的 test 为 true, 且 when 的父标签的 flag 也为 true, 则执行 when 的标签体(正常输出标签体的内容),
                                    同时把 flag 设置为 false
                               * 若 when 的 test 为 true, 且 when 的父标签的 flag 为 false, 则不执行标签体.
                               * 若 flag 为 true, otherwise 执行标签体.

 4. 带标签体的自定义标签:

1). 若一个标签有标签体:

<atguigu:testJspFragment>abcdefg</atguigu:testJspFragment>

在自定义标签的标签处理器中使用 JspFragment 对象封装标签体信息.

2). 若配置了标签含有标签体, 则 JSP 引擎会调用 setJspBody() 方法把 JspFragment 传递给标签处理器类
                           在 SimpleTagSupport 中还定义了一个 getJspBody() 方法, 用于返回 JspFragment 对象.

3). JspFragment 的 invoke(Writer) 方法: 把标签体内容从 Writer 中输出, 若为 null,
                            则等同于 invoke(getJspContext().getOut()), 即直接把标签体内容输出到页面上

有时, 可以 借助于 StringWriter, 可以在标签处理器类中先得到标签体的内容:

//1. 利用 StringWriter 得到标签体的内容.
                                 StringWriter sw = new StringWriter();
                                  bodyContent.invoke(sw);

//2. 把标签体的内容都变为大写
                                   String content = sw.toString().toUpperCase();

4). 在 tld 文件中, 使用 body-content 节点来描述标签体的类型:

<body-content>: 指定标签体的类型, 大部分情况下, 取值为 scriptless。可能取值有 3 种:
                               empty: 没有标签体
                               scriptless: 标签体可以包含 el 表达式和 JSP 动作元素,但不能包含 JSP 的脚本元素
                               tagdependent: 表示标签体交由标签本身去解析处理。
                              若指定 tagdependent,在标签体中的所有代码都会原封不动的交给标签处理器,而不是将执行结果传递给标签处理器

<body-content>tagdependent</body-content

5. 定义一个自定义标签: <atguigu:printUpper time="10">abcdefg</atguigu>

把标签体内容转换为大写, 并输出 time 次到 浏览

      6. 实现 forEach 标签:

> 两个属性: items(集合类型, Collection), var(String 类型)
                             > doTag:
                                     * 遍历 items 对应的集合
                                     * 把正在遍历的对象放入到 pageContext 中, 键: var, 值: 正在遍历的对象.
                                    * 把标签体的内容直接输出到页面上.

<c:forEach items="${requestScope.customers }" var="cust2">
                                     ${pageScope.cust2.id } -- ${cust2.name } <br>
                            </c:forEach>
                            <atguigu:saveAsFile src="d:\\haha.txt">
                                   abcde
                            </atguigu>

原文地址:https://www.cnblogs.com/ou-pc/p/8287751.html

时间: 2024-10-07 19:01:50

java web--自定义jstl标签的相关文章

Java Web(七) JSTL标签库

在之前我们学过在JSP页面上为了不使用脚本,所以我们有了JSP内置的行为.行为只能提供一小部分的功能,大多数的时候还是会用java脚本,接着就使用了EL表达式,基本上EL表达式看似能满足我们的要求,它能够获取各种对象,各种值,并且还不会抛出NullPointerException之类的错误,但是EL表达式功能还是有限,例如不能遍历集合等,因此为了完善JSP,让其完全不使用java代码,就有了jstl标签库,使用jstl和EL的配合使用,基本上可以实现所有的功能,显示数据,遍历数据等. 一.为什么

自定义JSTl标签-----满足自身需求(JSTL标签库无法满足需求时)

一.JSTL是: apache开发的一套jsp标签,后来捐献给了sun,sun将其命名为jstl 二.JSTL的使用(ideal中) 1.导入jar包到pom文件中: <!--jstl的jar--><dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> <scope

自定义JSTL标签和函数库

一.自定义JSTL标签 1.编写标签处理类: (1)实现 SimpleTag 接口,通过 setJspContext()方法可以获取到 jspContext 对象,实际上也是 pageContext 对象. 在 doTag() 方法中完成逻辑,通过 JspWriter out = jspContext.getOut(); 获取到的 out 对象,可以输出到页面.如: /** * MyTag2 * * @author solverpeng * @create 2016-07-03-10:20 */

Java web自定义标签按钮级别权限控制完美诠释(jplogic 快速开发平台)

接下来跟大家聊聊JavaWeb中权限控制,往大的方向说可以聊聊整合应用系统中的权限控制.在聊权限控制之前先跟大家聊聊RBAC.那么什么是RBAC呢?RBAC(Role-Based Access Control,基于角色的访问控制),就是用户通过角色与权限进行关联的,用户通过成为适当角色的成员而得到这些角色的权限.这就极大地简化了权限的管理.在一个组织中,角色是为了完成各种工作而创造,用户则依据它的责任和资格来被指派相应的角色,用户可以很容易地从一个角色被指派到另一个角色.角色可依新的需求和系统的

自定义jstl标签

JSTL(JSP Standard Tag Library,JSP标准标签库)是一个不断完善的开放源代码的JSP标签库. JSTL 核心标签库标签共有13个,功能上分为4类: 1.表达式控制标签:out.set.remove.catch 2.流程控制标签:if.choose.when.otherwise 3.循环标签:forEach.forTokens 4.URL操作标签:import.url.redirect 使用时需要在项目中加入jstl-1.2.jar,同时在jsp中加入以下代码来使用 <

java基础开发—jstl标签库

在DRP项目中.接触到了JSTL标签库. 在未使用Jstl之前,我们使用JSP脚本实现一些声明或是表达式任务,做一些业务相关操作时,须要在页面中嵌入大量的java代码.在DRP项目开发前期.使用jsp页面给我的感受就是.jsp页面什么活都能干,权利过高.导致的结果就是,jsp页面提高了程序的复杂性.增强了代码维护的复杂度.以及代码阅读的困难.对程序猿的要求也相对较高.比如,虽然精通页面设计的开发者来维护jsp.也经常须要依赖于经验丰富的程序猿.所以须要一种技术来解决这些问题,以下简介一下jstl

Java Web自定义MVC框架详解 (转)

转自:http://blog.csdn.net/jackfrued/article/details/42774459 最近给学生讲Java Web,希望他们能够在学完这部分内容后自己实现一个MVC框架.但是突然发现百度上能搜索到的靠谱的资料并不是很多,有些只是原理没有代码实现,有些有 代码实现但是对于初学者来说理解起来还是比较困难,于是决定把自己讲自定义MVC框架的内容放在这里分享给大家,不仅仅是代码,也有原理和探讨.内容会比 较长,因为我打算用递增的方式讲解如何写一个自定义MVC框架,重点是前

web day13 JSTL标签库(c标签,自定义标签),MVC设计模式,JavaWeb经典三层框架

JSTL 1. jstl的概述 *apache的东西,依赖EL * 使用jstl需要导入jstl1.2.jar * 四大库: > core:核心库,重点 > fmt:格式化:日期.数字 > sql:过时 > xml:过时 2. 导入标签库 *jar包 * 在jsp页面中:<%@taglib prefix="前缀" uri="路径"%> ---------------------- core --> c标签! 1. out和s

自定义jstl标签库

自定义函数库: 1.定义类和方法(方法必须是public static)  2.编写自定义tld文件,并且将此文件放到WEB-INF或WEB-INF任意子目录下 3.在jsp中采用taglib指令引入自定义函数库 4.采用 前缀+冒号(:)+函数名 调用即可 MyFunctions.java 代码: [java] view plain copy public class MyFunctions { public static String sayHello(String name) { retu