学习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个方法,也可将这四个方法理解为标签处理器类的生命周期:

 public interface SimpleTag extends JspTag {   

    /**
* 执行标签时调用的方法,一定会调用
*/
public void doTag() throws javax.servlet.jsp.JspException, java.io.IOException; /**
* 设置父标签对象,传入父标签对象,当标签存在父标签时会调用
*/
public void setParent( JspTag parent ); /**
* 设置JspContext对象,其实他真实传入的是其子类PageContext
*/
public void setJspContext( JspContext pc ); /**
* 设置标签体内容。标签体内容封装到JspFragment对象 中,然后传入JspFragment对象
*/
public void setJspBody( JspFragment jspBody ); }

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

 /*SimpleTagSupport 类的一部分*/
public class SimpleTagSupport implements SimpleTag
{
/** Reference to the enclosing tag. */
private JspTag parentTag; /** The JSP context for the upcoming tag invocation. */
private JspContext jspContext; /** The body of the tag. */
private JspFragment jspBody; public void setParent( JspTag parent ) {
this.parentTag = parent;
} public JspTag getParent() {
return this.parentTag;
} public void setJspContext( JspContext pc ) {
this.jspContext = pc;
} protected JspContext getJspContext() {
return this.jspContext;
} public void setJspBody( JspFragment jspBody ) {
this.jspBody = jspBody;
} protected JspFragment getJspBody() {
return this.jspBody;
}
}

编写自定义标签的步骤:

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

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)

 /*
* OutInfo.java
*/
public class OutInfo extends SimpleTagSupport { @Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext)getJspContext();
pageContext.getOut().write("酒香逢 博客园欢迎您");
}
}

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

 <?xml version="1.0" encoding="UTF-8" ?>

 <taglib xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
version="2.1"> <description>JSTL 1.1 core library</description>
<display-name>JSTL core</display-name>
<tlib-version>1.1</tlib-version>
<!--标签库前缀 taglib指令中的prefix属性 -->
<short-name>jxf</short-name>
<!--tld文件的唯一标记 taglib指令中的uri属性 -->
<uri>http://jxf.tag</uri> <tag>
<description>
这是自定义标签的描述信息,可以在MyEclipse中有提示
</description>
<!-- 标签名 -->
<name>outInfo</name>
<!-- 标签类的完名 -->
<tag-class>jxf.OutInfo</tag-class>
<body-content>scriptless</body-content>
<!-- <attribute>
<description>
这是属性的描述信息
</description>
<name>var</name>
<required>false</required>
<rtexprvalue>false</rtexprvalue>
</attribute> -->
</tag> </taglib>

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

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

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

<jxf:outInfo></jxf:outInfo>

5)jsp页面

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

自定义标签能够做的:

1)控制标签体内容输出

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

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

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

3)改变标签体内容

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

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

编写3个自定义标签处理器类 ChooseTag.javaWhen.javaOtherwise.jave

 /*
* ChooseTag.java
*/
public class ChooseTag extends SimpleTagSupport {
private boolean flag = false; public boolean isFlag() {
return flag;
} public void setFlag(boolean flag) {
this.flag = flag;
}
@Override
public void doTag() throws JspException, IOException {
getJspBody().invoke(null);
}
}
/*
* 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);
}
}
}
}
 /*
* OtherwiseTag.java
*/
public class OtherwiseTag extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
ChooseTag parent = (ChooseTag)getParent();
if(!parent.isFlag()){
getJspBody().invoke(null);
}
}
}

tld文件

 <?xml version="1.0" encoding="UTF-8" ?>

 <taglib xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
version="2.1"> <description>JSTL 1.1 core library</description>
<display-name>JSTL core</display-name>
<tlib-version>1.1</tlib-version>
<!--标签库前缀 taglib指令中的prefix属性 -->
<short-name>jxf</short-name>
<!--tld文件的唯一标记 taglib指令中的uri属性 -->
<uri>http://jxf.tag</uri> <tag>
<name>chooseTag</name>
<tag-class>jxf.ChooseTag</tag-class>
<body-content>scriptless</body-content>
</tag>
<tag>
<description>
自定义的when标签
</description>
<name>whenTag</name>
<tag-class>jxf.WhenTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<description>
when标签属性test
</description>
<!-- 标签处理器类中的必须要有对应的set方法,否则会报错,如此时对应的标签处理器类中应有getTest()方法。 -->
<name>test</name>
<!-- 该属性是否是必须的 ,true为必须的,false为非必须的-->
<required>true</required>
<!-- 该属性是否支持EL表达式 true支持,false不支持 -->
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
<tag>
<name>otherwiseTag</name>
<tag-class>jxf.OtherwiseTag</tag-class>
<body-content>scriptless</body-content>
</tag>
</taglib>

jsp代码

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

学会怎样使用Jsp 内置标签、jstl标签库及自定义标签的更多相关文章

  1. JSP标签:jsp内置标签、jstl标签、自定义标签

     一.jsp标签的分类: 1)内置标签(动作标签): 不需要在jsp页面导入标签 2)jstl标签: 需要在jsp页面中导入标签 3)自定义标签 : 开发者自行定义,需要在jsp页面导入标签    1 ...

  2. JSP内置标签 JSP中JavaBean标签 JSP开发模式 EL和JSTL快速入门

    2 JSP内置标签(美化+业务逻辑)   1)为了取代<%%>脚本形式,使用JSP标签/JSP动作,目的:与JSP页面的美化,即JSP面页都是由标签组成,不再有其它的内容   2)JSP内 ...

  3. JavaWeb之 JSP:内置对象,EL表达式,JSP标签基础

    JSP的内置对象 什么是JSP的内置对象呢? 在JSP页面进行编程的时候,如果我们要使用一些对象,如:HttpSession,ServletConfig,ServletContext这些对象,如果每次 ...

  4. JSP运行过程 JSP脚本 静态动态包含 jsp指令 jsp内置对象jsp四大作用域 jsp动作元素 EL表达式 JSTL 设计模式 JSP开发模式 EL内置对象

    Day38 JSP JSP的运行过程具体如下: (1)客户端发出请求,请求访问JSP文件. (2)JSP容器先将JSP文件转换成一个Java源文件(Java Servlet源程序),在转换过程中,如果 ...

  5. JSP--JSP语法--指令---九大隐式对象--四大域对象--JSP内置标签--JavaBean的动作元素--MVC三层架构

    一.JSP 原理:JSP其实就是一个servlet. Servlet负责业务逻辑处理,JSP只负责显示.开发中,JSP中不能有一行JAVA代码 二.JSP语法 1. JSP模板元素:JSP中HTML标 ...

  6. JSP--JSP语法--指令--include(动态包含/静态包含)--九大隐式对象--四大域对象--JSP内置标签--JavaBean的动作元素--MVC三层架构

    一.JSP 原理:JSP其实就是一个servlet. Servlet负责业务逻辑处理,JSP只负责显示.开发中,JSP中不能有一行JAVA代码 二.JSP语法 1.    JSP模板元素:JSP中HT ...

  7. jsp内置对象和el表达式

    九个内置对象 *out jsp的输出流,用来向客户端响应 *page 当前jsp页面, 它的引用数据类型是Object,即真身中有如下代码 Object page=this; *config 它对应真 ...

  8. Java遇见HTML——JSP篇之JSP内置对象(上)

    一.JSP内置对象简介 1.1.内置对象简介 JSP内置对象是WEB容器中创建的一组对象,可以直接使用不需要new,如截图中的out 对象. JSP有九大内置对象: 五大常用对象: out.reque ...

  9. 转:jsp内置对象中page与pageContext与el内置对象pageScope与pageContext区别

    原文地址:jsp内置对象中page与pageContext与el内置对象pageScope与pageContext区别 首先说明一下jsp9大内置对象 (1)HttpSession类的session对 ...

随机推荐

  1. JSP控制select不可再选择

    首先分析下disable ,display和readonly: 1,Readonly只针对input(text / password)和textarea有效,而disabled对于所有的表单元素都有效 ...

  2. 修复直接删除linux系统后grub丢失错误

    如果删除了系统后,grub丢失,开机出现“grub>”的话,可以用如下代码进入目标linux系统:grub>ls (hd0,X)/boot             //x为目标系统所在分区 ...

  3. Java学习——数据类型【2】

    1. 对象与类 对象:类的一个实例,有状态和行为. 类:一个模板,描述一类对象的行状态和行为. 2. 类可以包含的变量 类型 局部变量 成员变量 类变量(静态变量) 定义位置 方法.或语句块中 类中, ...

  4. extjs6.0点击grid一行数据显示在一端的form中

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  5. android的消息处理机制(图+源码分析)——Looper,Handler,Message

    android源码中包含了大量的设计模式,除此以外,android sdk还精心为我们设计了各种helper类,对于和我一样渴望水平得到进阶的人来说,都太值得一读了.这不,前几天为了了解android ...

  6. MapReduce链接作业

    对于简单的分析程序,我们只需一个MapReduce就能搞定,然而对于比较复杂的分析程序,我们可能需要多个Job或者多个Map或者Reduce进行计算.下面我们来说说多个Job或者多个MapReduce ...

  7. 关于cocos2d-x精灵加亮及变灰效果

    //根据现有CCSprite,变亮和变灰 static CCSprite* graylightWithCCSprite(CCSprite* oldSprite,bool isLight) { //CC ...

  8. java Thread.join()

    thread1.join()方法阻塞调用此方法的线程,直到线程thread1完成,此线程再继续. 通常用于在main()主线程内,等待其它线程完成再结束main()主线程 @Test /** * ou ...

  9. Android开发之Action Bar

    Action Bar代替了传统的位于设备屏幕的标题栏,主要用来显示应用程序的图标和活动的名称以及添加定制动作项等功能. 1. 显示和隐藏Action Bar 显示和隐藏Action Bar 一般有两种 ...

  10. Java基础知识强化之IO流笔记31:转换流出现的原因和格式

    1. 由于字节流操作中文不是特别方便,所以Java就提供了转换流.  字符流 = 字节流 + 编码表 2. 编码表 由字符及其对应数值组成的一张表 常见的编码表: • ASCII/Unicode字符集 ...