什么是JSP
JSP全名为Java Server Pages，java服务器页面。JSP是一种基于文本的程序，其特点就是HTML和Java代码共同存在！
为什么需要JSP
JSP是为了简化Servlet的工作出现的替代品，Servlet输出HTML非常困难，JSP就是替代Servlet输出HTML的。
简单使用一下JSP
- 在idea下生成一个JSP，我们来看一下JSP长什么样子
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
简单使用JSP
- 看起来就像一个HTML页面，前面也说了：JSP的特点就是HTML和Java代码共同存在
- 我们向浏览器输出一句HelloWorld，至于<%%>这个东西，我先不解释！
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
简单使用JSP
<%
String s = "HelloWorld";
out.println(s);
%>
JSP的工作原理
- 在Tomcat博客中我提到过：Tomcat访问任何的资源都是在访问Servlet！，当然了，JSP也不例外！JSP本身就是一种Servlet。为什么我说JSP本身就是一种Servlet呢？其实JSP在第一次被访问的时候会被编译为HttpJspPage类（该类是HttpServlet的一个子类）
- 刚才我简单使用了一下JSP，它被编译成了这么一个Servlet:
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.Date;
public final class _1_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();
private static java.util.List _jspx_dependants;
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.tomcat.InstanceManager _jsp_instancemanager;
public java.util.List getDependants() {
return _jspx_dependants;
}
public void _jspInit() {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
_jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
}
public void _jspDestroy() {
}
public void _jspService(final HttpServletRequest request, final HttpServletResponse response)
throws java.io.IOException, ServletException {
final PageContext pageContext;
HttpSession session = null;
final ServletContext application;
final ServletConfig config;
JspWriter out = null;
final Object page = this;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\r\n");
out.write("\r\n");
out.write("\r\n");
out.write("\r\n");
out.write(" 简单使用JSP \r\n");
out.write("\r\n");
out.write("\r\n");
String s = "HelloWorda";
out.println(s);
out.write("\r\n");
out.write("\r\n");
out.write("\r\n");
} catch (Throwable t) {
if (!(t instanceof SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try { out.clearBuffer(); } catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
}
- 编译过程是这样子的：浏览器第一次请求1.jsp时，Tomcat会将1.jsp转化成1_jsp.java这么一个类，并将该文件编译成class文件。编译完毕后再运行class文件来响应浏览器的请求。
- 以后访问1.jsp就不再重新编译jsp文件了，直接调用class文件来响应浏览器。当然了，如果Tomcat检测到JSP页面改动了的话，会重新编译的。
- 既然JSP是一个Servlet，那JSP页面中的HTML排版标签是怎么样被发送到浏览器的？我们来看下上面1_jsp.java的源码就知道了。原来就是用write()出去的罢了。说到底，JSP就是封装了Servlet的java程序罢了。
out.write("\r\n");
out.write("\r\n");
out.write("\r\n");
out.write("\r\n");
out.write(" 简单使用JSP \r\n");
out.write("\r\n");
out.write("\r\n");- 有人可能也会问：JSP页面的代码服务器是怎么执行的？再看回1_jsp.java文件，java代码就直接在类中的service()中。
String s = "HelloWorda";
out.println(s);- JSP比Servlet更方便更简单的一个重要原因就是：内置了9个对象！内置对象有：out、session、response、request、config、page、application、pageContext、exception，这几个内置对象不在这里讲。现在先知道一下即可！
-
- *
JSP生命周期
JSP也是Servlet，运行时只有一个实例，JSP初始化和销毁时也会调用Servlet的init()和destroy()方法。另外，JSP还有自己初始化和销毁的方法
public void _jspInit() {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
_jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
}
public void _jspDestroy() {
}JSP的语法
JSP代码可以分为两部分：
- 模板数据：就是HTML代码
- 元素：JSP页面中的java代码、JSP指令、JSP标签
JSP脚本
- JSP的脚本就是JSP页面中的java代码，也叫做scriptlet。JSP的脚本必须使用<%%>括起来，不然会被当成是模板数据的！
JSP脚本有三种方式：
- <%%>【定义局部变量，编写语句】
- <%!%>【定义类或方法，但是没人这样用！】
- <%=%>（也称之为表达式输出）【输出各种类型的变量，int、double、String、Object等】
- 如果过多地使用<%%>会导致代码混乱，JSP还提供了一种scriptlet标签，使用此标签和<%%>有相同的功能，只不过它更美观了一些
String s = "HelloWorld";
out.println(s);
JSP注释
<%--这是JSP注释--%>
<%--%>
//这是java的当行注释
//
/*这是java的多行注释*/
/**/
JSP指令
JSP指令用来声明JSP页面的相关属性，例如编码方式、文档类型等等
JSP指令的语法：
<%@指令 属性名="值" %>page指令
- 我在idea生成的JSP页面就有page指令了。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>- page指令常见属性：
- language="java"
- extends="package.class"
- import="{package.class | package.*}, ..."
- session="true | false"
- buffer="none | 8kb | sizekb"
- autoFlush="true | false"
- isThreadSafe="true | false"
- info="text"
- errorPage="relative_url"
- isErrorPage="true | false"
- contentType="mimeType ;charset=characterSet " | "text/html ; charset=ISO-8859-1"
- pageEncoding="characterSet | ISO-8859-1"
- isELIgnored="true | false"
- 一般地，在eclipse或idea这些高级开发工具上开发，我们只需要在page指令中指定contentType="text/html;charset=UTF-8"，就不会出现中文乱码问题！
- 当然了contentType 不仅仅可以指定以text/html的方式显示，还可以使用其他的形式显示出来。在conf/web.xml文件中可以查询出来
- 比如，我以doc形式显示jsp的数据
<%@ page contentType="application/msword;charset=UTF-8" language="java" %>
简单使用JSP
1111
- 效果是这样子的：
- 我们上网的时候，如果我们操作不当，或者服务器出错了，页面都是会出现友好提示的！这个也能通过page指令来实现跳转到友好提示页面上！
- page指令errorPage=和isErrorPage这两个属性，下面我们来看一下怎么使用！
- 1.jsp出现了错误，通过page指令的errorPage属性跳转到error.jsp页面上
<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="error.jsp" %>
该页面出错了！
<%--模拟页面出错了！！！--%>
<%
int result = 2 / 0;
%>
你好呀
- error.jsp页面要通过page指令的isErrorPage属性设置页面就是错误页面
<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
友好提示页面
服务器正忙着呢！
- 下面是效果：
- 当然了，细心的朋友可以发现地址栏是没有变化的，所以属于是服务器跳转。以上的做法是单个页面设置的，如果我会有很多错误（JSP多的情况下，错误就会多），单个设置太麻烦了！
- 我们可以在web.xml文件中全局设置错误页，只要发生了404错误或者空指针异常的错误都会跳转到error.jsp页面上
404
/error.jsp
java.lang.NullPointerException
/error.jsp
- 随便输个资源进行，会发生发404错误的，跳转到错误页面。下面是效果：
include指令
- 在讲解request对象的时候，我们曾经使用过request.getRequestDispatcher(String url).include(request,response)来对页头和页尾面进行包含
- inclue指令也是做这样的事情，我们来试验一下吧！
- 这是页头
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
页头
我是页头
- 这是页尾
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
页尾
我是页尾
- 在1.jsp中把页头和页尾包含进来
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
包含页头和页尾进来
<%@include file="head.jsp" %>
<%@include file="foot.jsp" %>
- 访问1.jsp
- include指令是静态包含。静态包含的意思就是：把文件的代码内容都包含进来，再编译！，看一下jsp的源代码就知道了！
- jsp还提供另一种包含文件的方式：JSP行为---动态包含。jsp行为在下面会讲到！
-
- *
taglib指令
- JSP支持标签技术，要使用标签技术就先得声明标签库和标签前缀。taglib指令就是用来指明JSP页面内使用标签库技术。
- 这里就不详细说明了，等到学习JSP标签的时候再使用吧！现在记住有这个指令即可。
-
- *
JSP行为
JSP行为（JSP Actions）是一组JSP内置的标签，只书写少量的标记代码就能够使用JSP提供丰富的功能， JSP行为是对常用的JSP功能的抽象和封装。
为什么我不把它直接称为JSP标签呢？我把这些JSP内置的标签称之为JSP行为，能够和JSTL标签区分开来。当然了，你也可以把它称之为JSP标签，你不要搞混就行了。我个人喜欢把这些JSP内置标签称之为JSP行为。
include行为
- 上面已经提及到了，include指令是静态包含，include行为是动态包含。其实include行为就是封装了request.getRequestDispatcher(String url).include(request,response)
- include行为语法是这个样子的
- 我们先来使用一下把，在1.jsp页面中也将页头和页尾包含进来。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
包含页头和页尾进来
- 访问1.jsp页面看一下效果：
- 使用jsp行为来包含文件，jsp源文件是这样子的：
- jsp行为包含文件就是先编译被包含的页面，再将页面的结果写入到包含的页面中（1.jsp)
- 当然了，现在有静态包含和动态包含，使用哪一个更好呢？答案是：动态包含。
- 动态包含可以向被包含的页面传递参数（用处不大），并且是分别处理包含页面的（将被包含页面编译后得出的结果再写进包含页面）【如果有相同名称的参数，使用静态包含就会报错！】！
- 模拟一下场景吧，现在我的头页面有个名为s的字符串变量
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
页头
<%
String s = "zhongfucheng";
%>
我是页头呀
- 我的页尾也有个名为s的字符串变量
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
页尾
<%
String s = "zhongfucheng";
%>
我是页尾呀
- 现在我使用静态包含看看会发生什么，出现异常了。
- 出现异常的原因很简单，就是同一个文件中有两个相同的变量s
- 使用动态包含就可以避免这种情况
param行为
- 当使用
forward行为
- 在讲解request对象的时候，我们使用request.getRequestDispatcher(String url).forward(request,response)进行跳转。其实forward行为就是对其封装！
- 我们来看一下forward的语法：
- 好的，我们来使用一下吧。访问1.jsp页面就跳转到head.jsp页面中
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
访问1.jsp就跳转到head.jsp
- 看一下效果
- 如果我要传递参数，就要在forward行为嵌套param行为
- 在跳转到head.jsp时传入参数username值为zhongfucheng
- 在head.jsp页面中获取到传递过来的参数
<%
String ss = request.getParameter("username");
%>
获取到的参数是：
<%=ss%>
- 效果如下图所示
directive行为
directive的中文意思就是指令。该行为就是替代指令<%@%>的语法的
- 我们来试一下能不能用的
- 看下效果，正常可以包含页面：
- 使用该指令可以让JSP页面更加美观！
- 使用scriptlet行为
javaBean行为
JSP还提供了操作javaBean对象的行为，在这里就不详细说明了，后面会讲到的！现在记住JSP提供了javaBean行为来操作简单类即可！
- 什么是JSP内置对象
==========
JSP引擎在调用JSP对应的jspServlet时， 会传递或创建9个与web开发相关的对象供jspServlet使用。JSP技术的设计者为便于开发人员在编写JSP页面时获得这些web对象的引用，特意定义了9个相应的变量， 开发人员在JSP页面中通过这些变量就可以快速获得这9大对象的引用
细心的朋友会发现，我们没有在JSP页面上定义过out对象，却可以直接使用！其实out对象就是JSP内置对象之一。
九个内置对象：
- pageContext
- page
- config
- request
- response
- session
- application
- exception
- out
-
- *
out对象
out对象的API
- int getBufferSize()【得到缓存大小】
- int getRemaining()【得到未使用缓存的大小】
- boolean isAutoFlush()
- void println()
- void flush()
- void close()
- void clearBuffer()
- void clear()
- out对象用于向浏览器输出数据，与之对应的是Servlet的PrintWriter对象。然而这个out对象的类型并不是PrintWriter，是JspWriter
- 我们可以简单理解为：JspWriter就是带缓存的PrintWrieter。
- out对象的原理如下：
只有向out对象中写入了内容，且满足如下任何一个条件时，out对象才去调用ServletResponse.getWriter方法，并通过该方法返回的PrintWriter对象将out对象的缓冲区中的内容真正写入到Servlet引擎提供的缓冲区中：
- 设置page指令的buffer属性关闭了out对象的缓存功能
- out对象的缓冲区已满
- 整个JSP页面结束
- 一般我们在JSP页面输出都是用表达式（<%=%>)，所以out对象用得并不是很多！
-
- *
request
- 内置对象request其实就是HttpServletRequest，在Servlet讲解的时候已经详细说明了，没什么好说的
response
- 内置对象response其实就是HttpServletResponse，在Servlet讲解的时候已经详细说明了，没什么好说的
config
- 内置对象config其实就是ServletConfig，在Servlet讲解的时候已经详细说明了，没什么好说的
session
- 内置对象session其实就是HttpSession。，在Servlet讲解的时候已经详细说明了，没什么好说的
注意：在page指令配置如下信息，session将不可使用
<%@page session="false" %>application
- 内置对象application其实就是ServletContext对象，在Servlet讲解的时候已经详细说明了，没什么好说的
page
- 内置对象page是HttpJasPage对象，其实page对象代表的就是当前JSP页面，是当前JSP编译后的Servlet类的对象。也就是说：page对象相当于普通java类的this
exception
- 内置对象exception是java.lang.Exception类的对象，exception封装了JSP页面抛出的异常信息。exception经常被用来处理错误页面
- 前面我们已经讲过了怎么设置错误页面了，下面我们就来简单使用一下exception对象吧
- 1.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="error.jsp" %>
- error.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
错误页面
<%
out.println("程序抛出了异常：" + exception);
%>
- 效果：
pageContext
pageContext是内置对象中最重要的一个对象，它代表着JSP页面编译后的内容（也就是JSP页面的运行环境）！
pageContext获取8个内置对象
- 既然它代表了JSP页面编译后的内容，理所当然的：它封装了对其他8大内置对象的引用！，也就是说，通过pageContext可以获取到其他的8个内置对象！
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
获取八大内置对象
<%
System.out.println(pageContext.getSession());
System.out.println(pageContext.getRequest());
System.out.println(pageContext.getResponse());
System.out.println(pageContext.getException());
System.out.println(pageContext.getPage());
System.out.println(pageContext.getServletConfig());
System.out.println(pageContext.getServletContext());
System.out.println(pageContext.getOut());
%>
- 看下效果：
pageContext作为域对象
类似于request，session，ServletContext作为域对象而言都有以下三个方法：
- setAttribute(String name,Objcet o)
- getAttribute(String name)
- removeAttribute(String name)
- 当然了，pageContext也不例外，pageContext也有这三个方法！
- pageContext本质上代表的是当前JSP页面编译后的内容，作为域对象而言，它就代表着当前JSP页面（也就是page）！也就是说：pageContext域对象只在page范围内有效，超出了page范围就无效了！
- 首先来看看在page范围内能不能使用
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
使用page域对象
<%
pageContext.setAttribute("name", "zhongfucheng");
%>
<%
String value = (String) pageContext.getAttribute("name");
System.out.println(value);
%>
- 效果如下：
- 我们现在来试验一下是不是超出了page范围就无效了！
- 在2.jsp中request域对象设置属性
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
request域对象设置属性
<%
//这是request域对象保存的内容
request.setAttribute("name","zhongfucheng");
%>
<%--跳转到1.jsp中--%>
- 企图在1.jsp中pageContext取出request存进去的属性
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
在page域对象获取属性
<%
//企图获取request域对象存进的属性
String value = (String) pageContext.getAttribute("name");
System.out.println(value);
%>
- 效果如下：
- pageContext本质上代表着编译后JSP的内容，pageContext还可以封装了访问其他域的方法！
上面的pageContext默认是page范围的，但pageContext对象重载了set、get、removeAttribute这三个方法
- getAttribute(String name,int scope)
- setAttribute(String name,Object value,int scope)
- removeAttribute(String name,int scope)
多了一个设置域范围的一个参数，如果不指定默认就是page。当然了，pageContext把request、session、application、page这几个域对象封装着了静态变量供我们使用。
- PageContext.APPLICATION_SCOPE
- PageContext.SESSION_SCOPE
- PageContext.REQUEST_SCOPE
- PageContext.PAGE_SCOPE
- 刚才我们没有使用重载方法的时候，使用pageContext是无法获取到request域对象设置的属性的。现在我们使用重载后的方法看一下能不能获取得到！
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
在page域对象获取request域对象的属性
<%
//使用重载的方法获取request域对象的属性
String value = (String) pageContext.getAttribute("name",pageContext.REQUEST_SCOPE);
System.out.println(value);
%>
- 效果：
pageContexst还有这么一个方法：
- findAttribute(String name)
- 该方法会查找各个域的属性，从小到大开始寻找！也就是page—>request->session->application。这个是EL表达式的原理！，EL表达式后面会讲到！
- 我们用此方法看能不能查找出request域对象的属性吧！
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
使用findAttribute
<%
//使用findAttribute查找2.jsp中request域对象的属性
String value = (String) pageContext.findAttribute("name");
System.out.println(value);
%>
- 效果如下：
引入和跳转
PageContext类中定义了一个forward方法和两个include方法来分别简化和替代RequestDispatcher.forward方法和include方法。
- pageContext.forward(String url)
- pageContext.include(String url)
4种属性范围
到目前为止，我们已经学了4种属性范围了。
- page【只在一个页面中保存属性，跳转页面无效】
- requet【只在一次请求中保存属性，服务器跳转有效，浏览器跳转无效】
- session【在一个会话范围中保存属性，无论何种跳转均有效，关闭浏览器后无效】
- application【在整个服务器中保存，所有用户都可以使用】
-
- *
- 4个内置对象都支持以下的方法：
- setAttribute(String name, Object o )
- getAttribute(String name)
- removeAttribute(String name)
应用场景
- request：如果客户向服务器发请求，产生的数据，用户看完就没用了，像这样的数据就存在request域,像新闻数据，属于用户看完就没用的
- session：如果客户向服务器发请求，产生的数据，用户用完了等一会儿还有用，像这样的数据就存在session域中，像购物数据，用户需要看到自己购物信息，并且等一会儿，还要用这个购物数据结帐
- servletContext：如果客户向服务器发请求，产生的数据，用户用完了，还要给其它用户用，像这样的数据就存在servletContext域中，像聊天数据
什么是javaBean
- JavaBean就是一个普通的java类，也称之为简单java对象--POJO（Plain Ordinary Java Object），是Java程序设计中一种设计模式，是一种基于 Java 平台的软件组件思想
JavaBean遵循着特定的写法，通常有以下的规则：
- 有无参的构造函数
- 成员属性私有化
- 封装的属性如果需要被外所操作，必须编写public类型的setter、getter方法
- 上面的文字看起来好像很高大上，javaBean其实非常简单，下面的代码就是按照特定写法、规则编写的一个JavaBean对象
public class Person {
private String username ;
private int age;
public Person() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
为什么需要使用Javabean
- 使用javaBean的好处就是：封装，重用,可读！
- 下面引用知乎一段回答：
JaveBean你可以理解为一辆货车，在你的java端和web页面进行数据传递的载体，你当然可以每个变量单独传递，或者使用集合传递，但是 javabean可以使你的数据更有可读性，方便开发时明确变量的意义，也使其他阅读你代码的人能直接你的意图
如果把bean类与数据库联合使用，一张表使用bean类，可以使你的代码更加简洁高效，易于理解，现在大多数框架都会使用这种机制。
JSP行为--JavaBean
JSP技术提供了三个关于JavaBean组件的动作元素，即JSP行为（标签），它们分别为：
jsp:useBean
- 存在则直接返回该JavaBean对象的引用。
- 不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。
- 语法：
- 如果JSP不支持
<%--这里需要导入Person类--%>
<%@ page import="domain.Person" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
- 效果如下
- 我们使用
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
- 也可以实现同样的效果：
- 有人可能会想，凭什么写一个
- 现在我把JavaBean中无参的构造函数改成有参的，我们看看会出现什么情况，出现异常了！
public Person(int age) {
this.age = age;
}
- 通过上面的代码我们也知道了为什么要有一个无参的构造函数！内部在new 对象的时候是没有传递参数进去的！
jsp:setProperty
- 语法：
在语法上可分为4种模式
- 当我们没有学习到
- 这是表单的页面代码：
- 这是处理表单提交过来数据的jsp的代码
- 这是可以完成的，但是相对来说，比较麻烦！
- 我们来使用
- 也可以完成，并且代码更少，功能更强大！
- 代码更少可以直观看出来，为什么我说它功能更加强大呢？表单提交过来的数据都是字符串，在我们没有用
- 我们再来使用一下自动匹配来感受它的强大之处吧
- 我们再来看一下效果：
- 看到这里，有人可能会觉得好神奇：只要设置property的值就可以将表单传递过来的数据封装到JavaBean对象中了！这究竟是这样做到的？？？
- 细心的朋友会发现，JavaBean的属性名称和表单的name属性设置的名称是一模一样的！
private String username ;
private int age;
用户名：
年龄：- 如果我设置不一样还能不能用？我们试试：表单name属性的username改成是user
用户名：- 我们再来看看还能不能把表单的数据完整地封装JavaBean对象中
- 我们可以发现：要想能够把表单带过来的数据成功封装到JavaBean对象上，名字要一致！也就是说：JavaBean属性名要和表单的name的名称一致
- 至于原理，它是通过反射来做的,调用了内省的方法！，我们看编译后的JSP就明白了。
jsp:getProperty
语法：
- 该jsp行为十分简单，我们来使用一下就知道了。
<%--使用输出--%>
- 效果：
- 原理如下
什么是EL表达式？
表达式语言（Expression Language，EL）,EL表达式是用"${}"括起来的脚本，用来更方便的读取对象！
- EL表达式主要用来读取数据，进行内容的显示！
为什么要使用EL表达式？
- 为什么要使用EL表达式，我们先来看一下没有EL表达式是怎么样读取对象数据的吧！
- 在1.jsp中设置了Session属性
<%@ page language="java" contentType="text/html" pageEncoding="UTF-8"%>
向session设置一个属性
<%
//向session设置一个属性
session.setAttribute("name", "aaa");
System.out.println("向session设置了一个属性");
%>
- 在2.jsp中获取Session设置的属性
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
- 效果：
- 上面看起来，也没有多复杂呀，那我们试试EL表达式的！
- 在2.jsp中读取Session设置的属性
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
- 只用了简简单单的几个字母就能输出Session设置的属性了！并且输出在浏览器上！
- 使用EL表达式可以方便地读取对象中的属性、提交的参数、JavaBean、甚至集合！
-
- *
EL表达式的作用
- 首先来看一下EL表达式的语法吧：
${标识符}- EL表达式如果找不到相应的对象属性，返回的的空白字符串“”，而不是null，这是EL表达式最大的特点！
获取各类数据
获取域对象的数据
- 上面在例子中，我们已经体验到了获取Session域对象的数据是多么地方便！其实EL表达式可以让我们获取各个域范围的数据
- 在1.jsp中设置ServeltContext属性（也就是application）
<%
//向ServletContext设置一个属性
application.setAttribute("name", "aaa");
System.out.println("向application设置了一个属性");
%>- 在2.jsp中获取application的属性
<%
${name}
%>
- 和Session一样，也能获取得到！
- 之前我们来讲ServletContext对象的时候讲过一个方法findAttribute(String name),EL表达式语句在执行的时候会调用该方法，用标识符作为关键字分别从page、request、session、application四个域中查找相应的对象。这也解释了为什么EL表达式可以仅仅通过标识符就能够获取到存进域对象的数据！
- findAttribute()的查找顺序：从小到大，也就是page->request->session->application
获取JavaBean的属性
- 以前在JSP页面获取JavaBean的数据是这样子的：
- 1.jsp页面Session存进一个Person对象，设置age的属性为22
在2.jsp中取出Session的属性
<%
Person person = (Person) session.getAttribute("person");
System.out.println(person.getAge());
%>- 效果如下
- 现在我使用了EL表达式读取数据又会非常方便了
//等同于person.getAge()
${person.age}
- 上面的代码 等同于调用对象的getter方法，内部是通过反射机制完成的！
获取集合的数据
- 集合操作在开发中被广泛地采用，在EL表达式中也很好地支持了集合的操作！可以非常方便地读取Collection和Map集合的内容
- 为了更好地看出EL表达式的强大之处，我们也来对比一下使用EL表达式和不使用EL表达式的区别
- 下面不使用EL表达式输出集合的元素
- 在1.jsp页面中设置session的属性，session属性的值是List集合，List集合装载的又是Person对象
<%
List list = new ArrayList();
Person person1 = new Person();
person1.setUsername("zhongfucheng");
Person person2 = new Person();
person2.setUsername("ouzicheng");
list.add(person1);
list.add(person2);
session.setAttribute("list",list);
%> - 在2.jsp中获取到session的属性，并输出到页面上
<%
List list = (List) session.getAttribute("list");
out.write(list.get(0).getUsername()+"
");
out.write(list.get(1).getUsername());
%> 使用EL表达式又是怎么样的效果呢？我们来看看！
<%--取出list集合的第1个元素（下标从0开始），获取username属性--%>
${list[0].username}
<%--取出list集合的第2个元素，获取username属性--%>
${list[1].username}
- 同样也可以有相同的效果：
- 我们再来使用一下Map集合
- 在1.jsp中session属性存储了Map集合，Map集合的关键字是字符串，值是Person对象
<%
Map map = new HashMap<>();
Person person1 = new Person();
person1.setUsername("zhongfucheng1");
Person person2 = new Person();
person2.setUsername("ouzicheng1");
map.put("aa",person1);
map.put("bb",person2);
session.setAttribute("map",map);
%> - 看起来好像取出数据的时候是会有点复杂，但是有了EL表达式也是非常轻松的！
${map.aa.username}
${map.bb.username}
- 效果：
- 如果Map集合存储的关键字是一个数字，就不能使用"."号运算符了，如下所示
- 对于这种情况，我们可以使用"[]"的形式读取Map集合的数据
${map["1"].username}
${map["2"].username}
- EL表达式配合JSTL标签可以很方便的迭代集合，后面讲到JSTL标签的时候会用到!这里就不详细说明了。
-
- *
EL运算符
- EL表达式支持简单的运算符：加减乘除取摸，逻辑运算符。empty运算符（判断是否为null)，三目运算符
- empty运算符可以判断对象是否为null，用作于流程控制！
- 三目运算符简化了if和else语句，简化代码书写
<%
List list = null;
%>
${list==null?"list集合为空":"list集合不为空"} - 效果：
EL表达式11个内置对象
EL表达式主要是来对内容的显示，为了显示的方便，EL表达式提供了11个内置对象。
- pageContext 对应于JSP页面中的pageContext对象（注意：取的是pageContext对象）
- pageScope 代表page域中用于保存属性的Map对象
- requestScope 代表request域中用于保存属性的Map对象
- sessionScope 代表session域中用于保存属性的Map对象
- applicationScope 代表application域中用于保存属性的Map对象
- param 表示一个保存了所有请求参数的Map对象
- paramValues表示一个保存了所有请求参数的Map对象，它对于某个请求参数，返回的是一个string[]
- header 表示一个保存了所有http请求头字段的Map对象
- headerValues同上，返回string[]数组。
- cookie 表示一个保存了所有cookie的Map对象
- initParam 表示一个保存了所有web应用初始化参数的map对象
- 下面测试各个内置对象
<%--pageContext内置对象--%>
<%
pageContext.setAttribute("pageContext1", "pageContext");
%>
pageContext内置对象：${pageContext.getAttribute("pageContext1")}
<%--pageScope内置对象--%>
<%
pageContext.setAttribute("pageScope1","pageScope");
%>
pageScope内置对象:${pageScope.pageScope1}
<%--requestScope内置对象--%>
<%
request.setAttribute("request1","reqeust");
%>
requestScope内置对象:${requestScope.request1}
<%--sessionScope内置对象--%>
<%
session.setAttribute("session1", "session");
%>
sessionScope内置对象：${sessionScope.session1}
<%--applicationScope内置对象--%>
<%
application.setAttribute("application1","application");
%>
applicationScopt内置对象：${applicationScope.application1}
<%--header内置对象--%>
header内置对象：${header.Host}
<%--headerValues内置对象,取出第一个Cookie--%>
headerValues内置对象：${headerValues.Cookie[0]}
<%--Cookie内置对象--%>
<%
Cookie cookie = new Cookie("Cookie1", "cookie");
%>
Cookie内置对象：${cookie.JSESSIONID.value}
<%--initParam内置对象，需要为该Context配置参数才能看出效果【jsp配置的无效！亲测】--%>
initParam内置对象:${initParam.name}
- 效果图：
注意事项：
- 测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
- 测试cookie时，例
${cookie.key}取的是cookie对象，如访问cookie的名称和值，须${cookie.key.name}或${cookie.key.value} - 测试initParam时，初始化参数要的web.xml中的配置Context的，仅仅是jsp的参数是获取不到的
- 上面已经测过了9个内置对象了，至于param和parmaValues内置对象一般都是别的页面带数据过来的（表单、地址栏）！
- 表单页面
- 处理表单页面：
${param.username}
${param.age}
//没有学习jstl之前就一个一个写吧。
${paramValues.hobbies[0]}
${paramValues.hobbies[1]}
${paramValues.hobbies[2]}
- 效果：
- 当然了，使用地址栏方式提交数据给处理页面也是用param内置对象去获取数据的！
EL表达式回显数据
EL表达式最大的特点就是：如果获取到的数据为null，输出空白字符串""！这个特点可以让我们数据回显
- 在1.jsp中模拟场景
<%--模拟数据回显场景--%>
<%
User user = new User();
user.setGender("male");
//数据回显
request.setAttribute("user",user);
%>
男
女
- 效果：
EL自定义函数
EL自定义函数用于扩展EL表达式的功能，可以让EL表达式完成普通Java程序代码所能完成的功能
- 开发HTML转义的EL函数
- 我们有时候想在JSP页面中输出JSP代码，但是JSP引擎会自动把HTML代码解析，输出给浏览器。此时我们就要对HTML代码转义。
步骤：
- 编写一个包含静态方法的类（EL表达式只能调用静态方法），该方法很常用，Tomcat都有此方法，可在webappsexamplesWEB-INFclassesutil中找到
public static String filter(String message) {
if (message == null)
return (null);
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuilder result = new StringBuilder(content.length + 50);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case '<':
result.append("<");
break;
case '>':
result.append(">");
break;
case '&':
result.append("&");
break;
case '"':
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
}- 在WEB/INF下创建tld（taglib description）文件，在tld文件中描述自定义函数
1.0
myshortname
/zhongfucheng
filter
utils.HTMLFilter
java.lang.String filter(java.lang.String)
- 在JSP页面中导入和使用自定义函数，EL自定义的函数一般前缀为"fn"，uri是"/WEB-INF/tld文件名称"
<%@ page language="java" contentType="text/html" pageEncoding="UTF-8" %>
<%@taglib prefix="fn" uri="/WEB-INF/zhongfucheng.tld" %>
- 效果：
EL函数库（fn方法库）
- 由于在JSP页面中显示数据时，经常需要对显示的字符串进行处理，SUN公司针对于一些常见处理定义了一套EL函数库供开发者使用。
- 其实EL函数库就是fn方法库，是JSTL标签库中的一个库，也有人称之为fn标签库，但是该库长得不像是标签，所以称之为fn方法库
- 既然作为JSTL标签库中的一个库，要使用fn方法库就需要导入JSTL标签！要想使用JSTL标签库就要导入jstl.jar和standard.jar包！
- 所以，要对fn方法库做测试，首先导入开发包（jstl.jar、standard.jar)
- 在JSP页面中指明使用标签库
<%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>- fn方法库全都是跟字符串有关的（可以把它想成是String的方法）
- fn:toLowerCase
- fn:toUpperCase
- fn:trim
- fn:length
- fn:split
- fn:join 【接收字符数组，拼接字符串】
- fn:indexOf
- fn:contains
- fn:startsWith
- fn:replace
- fn:substring
- fn:substringAfter
- fn:endsWith
- fn:escapeXml【忽略XML标记字符】
- fn:substringBefore
- 测试代码：
contains:${fn:contains("zhongfucheng",zhong )}
containsIgnoreCase:${fn:containsIgnoreCase("zhongfucheng",ZHONG )}
endsWith:${fn:endsWith("zhongfucheng","eng" )}
escapeXml:${fn:escapeXml("你是谁呀 ")}
indexOf:${fn:indexOf("zhongfucheng","g" )}
length:${fn:length("zhongfucheng")}
replace:${fn:replace("zhongfucheng","zhong" ,"ou" )}
split:${fn:split("zhong,fu,cheng","," )}
startsWith:${fn:startsWith("zhongfucheng","zho" )}
substring:${fn:substring("zhongfucheng","2" , fn:length("zhongfucheng"))}
substringAfter:${fn:substringAfter("zhongfucheng","zhong" )}
substringBefore:${fn:substringBefore("zhongfucheng","fu" )}
toLowerCase:${fn:toLowerCase("zhonGFUcheng")}
toUpperCase:${fn:toUpperCase("zhongFUcheng")}
trim:${fn:trim(" zhong fucheng ")}
<%--将分割成的字符数组用"."拼接成一个字符串--%>
join:${fn:join(fn:split("zhong,fu,cheng","," ),"." )}
- 效果：
- 使用fn方法库数据回显
<%
User user = new User();
String likes[] = {"sing"};
user.setLikes(likes);
//数据回显
request.setAttribute("user",user);
%>
<%--java的字符数组以","号分割开，首先拼接成一个字符串，再判读该字符串有没有包含关键字，如果有就checked--%>
唱歌
跳舞- 效果：
什么是JSTL
JSTL全称为 JSP Standard Tag Library 即JSP标准标签库。
JSTL作为最基本的标签库，提供了一系列的JSP标签，实现了基本的功能：集合的遍历、数据的输出、字符串的处理、数据的格式化等等！
为什么要使用JSTL
- EL表达式不够完美，需要JSTL的支持！在JSP中，我们前面已经用到了EL表达式，体会到了EL表达式的强大功能：使用EL表达式可以很方便地引用一些JavaBean以及其属性，不会抛出NullPointerException之类的错误！但是，EL表达式非常有限，它不能遍历集合，做逻辑的控制。这时，就需要JSTL的支持了！
- Scriptlet的可读性，维护性，重用性都十分差！JSTL与HTML代码十分类似，遵循着XML标签语法，使用JSTL让JSP页面显得整洁，可读性非常好，重用性非常高，可以完成复杂的功能！
- 在JSP中不推荐使用scriptlet输出，推荐使用JSP标签。
使用JSTL标签库步骤：
- 导入jstl.jar和standard.jar开发包
- 在JSP页面中用tablib指令引入需要用到的JSTL标签
core标签库
- core标签库是JSTL的核心标签库，实现了最基本的功能：流程控制、迭代输出等操作！
- core标签库的前缀一般是c
c:out
- 简单使用一下
<%
session.setAttribute("name", "zhongfucheng");
%>
//您要的数据找不着
- 我们发现上面的代码实现的效果和EL表达式是一样的，它出色的地方就多了两个属性,default和escapeXml属性。如果我们用到这两个属性，我们就使用该标签，如果没有用到这两个属性就用EL表达式就可以了。
-
- *
c:set
- 该标签有5个属性，用起来有稍微有些复杂了！现在要记住的就是：var属性操作的是Integer、Double、Float、String等类型的数据，target属性操作的是JavaBean或Map对象的数据，scope代表的是Web域，value是值，property是对象的属性！
使用var属性
- 既然var属性只能操作Integer、Double、String等类型，那么存在var属性就一定没有property属性（property代表的是对象的成员属性，Integer、String这些类型哪来的成员变量呀）
- 下面的代码流程是这样的：创建了一个name的变量，设置的值为zhongfucheng，范围是page
- 效果：
- 当然了，set标签也支持标签体，value的值可以写在标签体里边
zhongfucheng
- 使用var属性和scope属性实现计数器
<%--由于下面变量需要做加法运算，所以要定义出来，不然服务器是不知道我的变量是Integer类型的--%>
<%
Integer sessionCount = 0;
Integer applicationCount = 0;
%>
- 效果：
使用target属性
- 使用target属性与之配对的是property属性，target属性只能操作JavaBean或Map对象，property就是对应的成员变量或key了。。
- 既然target属性操作的是JavaBean或Map对象，那么一定是通过EL表达式来获取到对象了。taget属性如果获取不到数据会抛出异常！使用target属性就一定没有scope属性（scope属性代表的是保存范围，target的值都是获取来的，难道你还能改变人家的范围？）
<%--创建出JavaBean对象，设置为session范围的属性--%>
- 效果：
c:remove
remove标签就相当简单了，只有var和scope属性，代表的是删除域范围的属性
- 下面简单来测试一下吧：
<%--创建出JavaBean对象，设置为session范围的属性--%>
<%--删除session属性--%>
- 效果：
c:catch
该标签主要用来处理程序中产生的异常。
catch标签也十分简单，只有一个var属性，var属性封装了异常的信息！
<%--创建出JavaBean对象，设置为session范围的属性--%>
<%--target属性只能是EL表达式，现在我是字符串，获取不到对象，肯定会抛出异常的！--%>
${message}- 效果：
c:if
JSTL提供了if标签完成分支语句的实现，test属性是不可或缺的。
var和scope属性我看来好像没什么用的（保存执行结果有什么用？）
- 根据传递过来的参数的不同显示不同的页面！
<%--如果带过来的名字是zhongfucheng，那么可以登陆--%>
用户名：
密码：
<%--如果带过来的名字是ouzicheng，那么就是注册--%>
用户名：
密码：
- 注意地址栏的参数！
c:choose
if标签没有else的功能，如果需要类似于java中的if else流程就需要使用choose标签。
choose标签需要联合when和otherwise标签一起使用！
你好啊，zhongfucheng
你好啊，ouzicheng
你是谁啊？别随便过来！
- 效果：
c:forEach
forEach为循环标签，相当于Java中的while和for
- 之前我们在使用EL表达式获取到集合的数据，遍历集合都是用scriptlet代码循环，现在我们学了forEach标签就可以舍弃scriptlet代码了。
- 向Session中设置属性，属性的类型是List集合
<%
List list = new ArrayList<>();
list.add("zhongfucheng");
list.add("ouzicheng");
list.add("xiaoming");
session.setAttribute("list", list);
%>- 遍历session属性中的List集合,items：即将要迭代的集合。var：当前迭代到的元素
${list}
- 效果：
- 遍历Map对象有稍微地不一样，我们来看一下，var属性保存的不是每个迭代的对象，而是Map.Entry。
<%
Map map = new HashMap();
map.put("1", "zhongfucheng");
map.put("2", "xiaohong");
map.put("3", "xiaoming");
session.setAttribute("map",map);
%>
${me.key} ${me.value}
- begin默认从0开始、end默认为集合的最后一个元素、step默认为1
varStatus代表着当前对象被迭代的信息，它有以下的属性。
- index【返回当前是第几个对象，从0开始计数】
- count【已经遍历多少个对象了，从1开始计数】
- first【是否是第一个】
- last【是否是最后一个】
- current【当前被迭代的对象】
- begin【开始的位置】
- end【最后的位置】
- step【步长】
${list}您的下标是:${varStatus.index}
- 效果：
c:forTokens
该标签类似于String类的split()和for循环的一种集合
它与forEach标签非常相似，都有begin、end、step、items、var、varStatus属性，不同的是forTokens标签的items属性里面是字符串，这个字符串会被delims属性的内容分割成多个字符串！
${name}
- 效果图：
c:import
import标签类似于JSP行为<%include>
import标签的属性：
- url【指定要包含的路径，Internet所有的url都可以】
- context【访问同一个web容器的其他资源，以"/"开头】
- var【保存导入的文件的内容，以String类型存储】
- socpe【保存的范围，默认是page】
- charEncoding【字符编码】
- varReader【保存导入文件的内容，以Reader类型存储】
当然了，import标签功能更加更大！强大在哪里呢？import标签可以引入Internet网页上的内容，也就是说，csdn也可以引入进来！
- 我们来用一下把！
- 我们一看，是没有样式的：
- 打印csdn的源代码：
- 效果：
c:param
- 在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。
-
- *
c:url
url标签十分实用！在浏览器禁用Cookie的时候，我们之前学Servlet时解决办法是：response.encodeURL()。url标签也可以实现这样的功能，再配合param标签使用，就十分实用了！
- 我们配合param标签来使用一下吧！
我经过了URL地址重写！
- 效果：
c:redirect
redirect标签用于实现Redirect功能，当然了，此标签也能够配合param标签使用！
- 简单使用一下，重定向到2.jsp，带了一个参数：
- 在2.jsp中获取到参数
fmt标签库
fmt标签库也叫做国际化标签库。这里就不详细说明了，等我讲到Web 国际化的时候才讲吧！
fn方法库
fn方法库也叫做EL函数库、fn标签库。这个在讲解EL表达式的时候有详细的说明，可转移到我EL表达式的博文中！
为什么要使用自定义标签？
JSTL标签库只提供了简单的输出等功能，没有实现任何的HTML代码封装，并且某些复杂类型转换，或者逻辑处理的时候，JSTL标签库完成不了，需要自定义标签!
编写自定义标签的步骤：
- 编写一个实现Tag接口的Java类【标签处理器类】
- 在WEB-INF目录下创建tld(Tag Library Descriptor)文件，在tld文件中对标签处理类（实现Tag接口的Java类）进行描述
快速入门
- 目标：使用标签输出客户机的IP地址！
- 按照步骤来：首先编写一个实现Tag接口的Java类
public class showIp implements Tag {
@Override
public void setPageContext(PageContext pageContext) {
}
@Override
public void setParent(Tag tag) {
}
@Override
public Tag getParent() {
return null;
}
@Override
public int doStartTag() throws JspException {
return 0;
}
@Override
public int doEndTag() throws JspException {
return 0;
}
@Override
public void release() {
}
}- 既然要获取到客户机的IP地址，那么request对象是必不可少的。现在问题来了，在Tag重写的方法好像不能直接获取到request对象啊。
- 经过我一番仔细的观察，发现了下面这个方法：
@Override
public void setPageContext(PageContext pageContext) {
}- 既然能获取到pageContext对象，那么其他8大内置对象还不是随随便便？于是乎，我就定义一个成员变量pageContext，在setPageContext()方法中传递过来的pageContext赋值给我定义的成员变量即可！
private PageContext pageContext = null;
@Override
public void setPageContext(PageContext pageContext) {
this.pageContext = pageContext;
}- 好的，看回我们的需求：使用标签输出客户机的IP地址。在上面剩余5个方法中，最有可能就是在doStartTag()方法中编写代码！
@Override
public int doStartTag() throws JspException {
//获取到request对象
HttpServletRequest httpServletRequest = (HttpServletRequest) pageContext.getRequest();
//获取到客户机的ip地址
String ip = httpServletRequest.getRemoteAddr();
//获取输出到浏览器的对象
JspWriter jspWriter = pageContext.getOut();
//下面的异常只能捕获，因为子类的异常不能比父类多
try {
jspWriter.write(ip);
} catch (IOException e) {
e.printStackTrace();
}
return 0;
}- 接着，编写tld文件，描述实现Tag接口的Java类【标签处理类】。
1.0
zhongfucheng
/zhongfucheng
viewIp
tag.showIp
empty
- 下面我们来测试一下看能不能用
标签处理类详细说明
看完上面的程序，大部分人都是懵逼的。因为还不知道它具体是怎么用的，调用顺序是什么。
- 首先我们来看一下Tag接口的源码！
public interface Tag extends JspTag {
int SKIP_BODY = 0;
int EVAL_BODY_INCLUDE = 1;
int SKIP_PAGE = 5;
int EVAL_PAGE = 6;
void setPageContext(PageContext var1);
void setParent(Tag var1);
Tag getParent();
int doStartTag() throws JspException;
int doEndTag() throws JspException;
void release();
}
上面程序的执行流程：
- JSP引擎遇到自定义标签，首先创建标签处理器类的实例对象。
- JSP引擎实例化完标签处理器类后，调用setPageContext()方法，将pageContext对象传递给标签处理器类，使得标签处理器类可以通过pageContext对象与JSP页面进行通信！
- setPageContext()方法执行完后，调用setParent()方法，将当前标签的父标签传递给当前处理器类，如果当前标签没有父标签，则传入null
- 当WEB容器执行到自定义标签的开始标记时，调用doStartTag()方法。
- 当WEB容器执行到自定义标签的结束标记时，调用doEndTag()方法。
- 一般来说，当WEB容器执行完自定义标签后，标签处理器类会驻留在内存中，直至停止WEB应用时，WEB容器才会调用release()方法
我们现在已经清楚了方法的执行顺序了，可Tag接口的源码还有4个变量阿，它们是用来做什么的呢？我们在编写JSP页面时，经常需要在页面中引入一些逻辑，例如：
- 控制JSP页面某一部分（标签体）是否执行
- 控制整个JSP页面是否执行
- 控制JSP页面内容重复执行
- 修改JSP页面内容输出
- 再看回4个变量的名字，我们可以发现，这4个变量就是用来做逻辑判断的！
- 我们来测试一下吧，在doEndTag()方法中，返回的是SKIP_PAGE变量，看下会怎么样！
@Override
public int doEndTag() throws JspException {
return SKIP_PAGE;
}
- 我们再来看一看效果：
- 好像是没什么区别！我们再查看一下源代码，发现执行完标签后，后面的代码全都没有执行！
- doStartTag()方法使用的是SKIP_BODY和EVAL_BODY_INCLUDE这两个变量，判断是否执行标签体的内容。
- doEndTag()方法使用的是SKIP_PAGE和EVAL_PAGE这两个变量，判断是否执行剩下页面的内容
- 控制JSP页面内容重复执行和修改JSP页面内容输出后面会有！
-
- *
tld文件详细说明
- 首先我们来看一下tld文件当前用到的内容吧！
1.0
myshortname
http://mycompany.com
我们一个一个来看：
- shortname推荐使用prefix
- uri就是引入这个标签库使用的uri
- name为标签名
- tagclass为实现类
- bodycontent为标签体的限制，它有4个值： EMPTY【不允许有标签体】，JSP【允许有JSP代码】 ，scriptless【不允许有脚本代码（也就是<%%>），允许有EL表达式，文本，JSP行为】 ， tagdepentend【标签体内的JSP代码不会被解析，直接输出文本】
-
- *
TagSupport类
大部分时候我们都不需要实现Tag接口来编写自定义标签，TagSupport是Tag的一个模板类，实现了pageContext，parent的getter、setter方法以及一些其他的功能。我们要做的就是重写doStartTag()和doEndTag()方法
- 下面我们就来简单使用一下吧：
- 继承TagSupport类，重写doStartTag()方法，比直接实现Tag接口简洁很多！
public class Demo1 extends TagSupport {
@Override
public int doStartTag() throws JspException {
//获取到request对象
HttpServletRequest httpServletRequest = (HttpServletRequest) pageContext.getRequest();
String method = httpServletRequest.getMethod();
JspWriter jspWriter = pageContext.getOut();
try {
jspWriter.write(method);
} catch (IOException e) {
e.printStackTrace();
}
return 0;
}
}- 在tld文件中描述一把：
showMethod
tag.Demo1
empty
- 效果：
带属性的标签
上面我们编写的自定义标签都没有附带属性的，我们在使用core标签库的时候，标签一般都带有属性。
其实JSTL标签库的原理就是自定义标签，把自定义标签搞明白了，对JSTL标签库的使用就有更好的理解了！
- 想要自定义标签带有属性也非常简单，只要在标签处理器类上加一个成员变量和setter、getter()，再在tld文件中描述下该属性即可！它的原理是这样的：当标签使用到属性的时候，引擎就会调用它的setter()方法
- 下面我想要完成的功能是：使用标签的人，传入一个字符串格式就可以显示想要的格式日期
- 编写标签处理器类，增加一个成员变量以及对应的setter、getter方法
public class Demo1 extends TagSupport {
//创建成员对象，对应的setter、getter方法
private String format = null;
@Override
public int doStartTag() throws JspException {
//创建日期格式化对象
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
//格式化日期并向浏览器输出
try {
pageContext.getOut().write(simpleDateFormat.format(new Date()));
} catch (IOException e) {
e.printStackTrace();
}
return 0;
}
public String getFormat() {
return format;
}
public void setFormat(String format) {
this.format = format;
}
}- 在tld文件中描述标签和属性，name代表的是属性的名字，required代表的是是否为必须，rtexprvalue代表能否使用EL表达式
formatDate
tag.Demo1
empty
format
true
true
- 我们来看一下效果：
标签的继承关系
- 在深入讲解之前，我们先来看一下各种Tag接口、类之间的关系，这样学习下去才不会晕！
IterationTag说明
- 我们已经使用过了Tag接口和TagSupport类了。接下来我们看一下IterationTag是什么玩意。
public interface IterationTag extends Tag {
int EVAL_BODY_AGAIN = 2;
int doAfterBody() throws JspException;
}- 从关系图我们也可以看出，IterationTag接口实现了Tag接口，InterationTag接口和Tag接口最主要的区别就是多了个doAfterBody()方法和EVAL_BODY_AGAIN变量
- 理解起来也很简单：当doAfterBody()返回的是EVAL_BODY_AGAIN变量，那么标签体的内容就一直循环！当然了，TagSupport也实现了Iteration接口，也就是说TagSupport类也能完成Iteration接口的事情！
- 我们来使用一下吧：
public class Demo1 extends TagSupport {
@Override
public int doStartTag() throws JspException {
try {
pageContext.getOut().write("hello");
} catch (IOException e) {
e.printStackTrace();
}
//执行标签体
return EVAL_BODY_INCLUDE;
}
@Override
public int doAfterBody() throws JspException {
//标签体不断循环，直到doAfterBody()返回的是SKIP_BODY
return EVAL_BODY_AGAIN;
}
}- tld文件中描述，既然标签体有内容，就不能用empty了！
foreverEval
tag.Demo1
tagdependent
- 注意看横向的滑轮，已经死循环输出了：
- doAfterBody()中只要返回的是SKPI_BODY就退出循环，执行doEndTag()方法
//定义一个变量，规定标签体循环的次数
int x = 0;
@Override
public int doStartTag() throws JspException {
try {
pageContext.getOut().write("hello");
} catch (IOException e) {
e.printStackTrace();
}
//执行标签体
return EVAL_BODY_INCLUDE;
}
@Override
public int doAfterBody() throws JspException {
x++;
if (x >= 10) {
return SKIP_BODY;
}
//标签体不断循环，直到doAfterBody()返回的是SKIP_BODY
return EVAL_BODY_AGAIN;
}- 现在我们已经能控制循环的次数了！
BodyTag说明
前面我们已经使用到了带标签体的自定义标签了，前面的都是只能直接输出而得不到标签体的内容，既然得不到标签体的内容，就更别说修改标签体了！
- 此时，我们就需要BodyTag接口的支持了！它专门用来处理带标签体的标签，下面我们来看一下BodyTag的源码！
public interface BodyTag extends IterationTag {
/** @deprecated */
int EVAL_BODY_TAG = 2;
int EVAL_BODY_BUFFERED = 2;
void setBodyContent(BodyContent var1);
void doInitBody() throws JspException;
}- BodyTag多了EVAL_BODY_BUFFERED变量【一个已经标识过时了】，多了setBodyContent和doInitBody()两个方法
其实使用BodyTag十分简单
- 如果doStartTag()方法返回的是EVAL_BODY_BUFFERED，把标签体的内容缓存起来
- 接着调用setBodyContent()方法和doInitBody()方法，封装标签体的内容到BodyContent对象中
- 接着调用doEndTag()方法
- 对于标签体的内容，我们可以通过getBodyContenet()来获取！
- 再看回上面的关系图，BodyTag实现了IterationTag和Tag接口，如果直接实现BodyTag接口做开发，要实现的方法就太多了。一般我们使用继承BodyTag的BodyTagSupport来做开发
-
- *
BodyTagSupport说明
- 首先来看一下源代码吧：
public class BodyTagSupport extends TagSupport implements BodyTag {
protected BodyContent bodyContent;
public BodyTagSupport() {
}
public int doStartTag() throws JspException {
return 2;
}
public int doEndTag() throws JspException {
return super.doEndTag();
}
public void setBodyContent(BodyContent b) {
this.bodyContent = b;
}
public void doInitBody() throws JspException {
}
public int doAfterBody() throws JspException {
return 0;
}
public void release() {
this.bodyContent = null;
super.release();
}
public BodyContent getBodyContent() {
return this.bodyContent;
}
public JspWriter getPreviousOut() {
return this.bodyContent.getEnclosingWriter();
}
}可以发现:BodyTagSupport主要扩充了以下的内容:
- 把BodyContent直接定义为成员变量，在获取标签体内容的时候就不需要通过getBodyContent()获取了
- 提供获取JspWriter的方法，不需要从pageConext中获取了
- 以上的两个扩充都简化了我们的代码书写！
protected BodyContent bodyContent;
public JspWriter getPreviousOut() {
return this.bodyContent.getEnclosingWriter();
}
- 从BodyTag接口中，我就说到了：标签体的内容封装到了BodyContent类中，那么BodyContent类究竟是什么？我们来看一下源码：
public abstract class BodyContent extends JspWriter {
private JspWriter enclosingWriter;
protected BodyContent(JspWriter e) {
super(-2, false);
this.enclosingWriter = e;
}
public void flush() throws IOException {
throw new IOException("Illegal to flush within a custom tag");
}
public void clearBody() {
try {
this.clear();
} catch (IOException var2) {
throw new Error("internal error!;");
}
}
public abstract Reader getReader();
public abstract String getString();
public abstract void writeOut(Writer var1) throws IOException;
public JspWriter getEnclosingWriter() {
return this.enclosingWriter;
}
}
- 原来BodyContent继承着JspWriter，它与JspWriter最大的区别是：BodyContent类的任何写入的内容并不自动地向页面输出！
- 我们一般使用BodyContent都使用两个方法：
//将数据转变成Reader对象
public abstract Reader getReader();
//将数据转变成String对象
public abstract String getString();- 再从关系图我们可以看初，BodyTagSupport继承了TagSupport类实现了BodyTag接口，可以说：BodyTagSupport有着前面讲的接口和类的所有功能！。
- 下面我们来使用下BodyTagSupport将标签体的内容转成是小写的：
- 标签处理器类
public class Demo1 extends BodyTagSupport {
@Override
public int doStartTag() throws JspException {
//想要获取到标签体的内容，就要返回EVAL_BODY_BUFFERED变量
return EVAL_BODY_BUFFERED;
}
@Override
public int doEndTag() throws JspException {
//获取到标签体的内容
String value = bodyContent.getString();
//将标签体的内容转成小写并输出
try {
this.getPreviousOut().write(value.toLowerCase());
} catch (IOException e) {
e.printStackTrace();
}
return super.doEndTag();
}
}
- tld文件：
BodyContentToLowerCase
tag.Demo1
tagdependent
- 效果：