java的JSP技术
1.JSP简介
Jsp技术是用来开发java web的页面显示的，所有MVC模型里面的视图层，所以视图层的开发
jsp不是编程语言，三个英文是java server pages的缩写
Jsp其实也是继承Servlet的，属于在服务器上的开发。Servlet是用于java语言的动态资源开发的技术，而Jsp是把java和html结合，在html中可以写java语言，主要用在页面的显示开发上。
1.1.Jsp的特点
1.Jsp的运行必须交给tomcat服务器。tomcat的work目录就是服务器用来存放jsp运行时的临时文件的
2.Jsp页面即可直接写html代码，也可以直接写java代码
2.Jsp的执行过程
问题1：访问http://localhost:8080/hello/index.jsp 如何显示效果？
1.访问到index.jsp页面，tomcat扫描到jsp文件，在tomcat/work目录下把jsp文件翻译成java源文件
index.jsp-->_index.java(翻译)
2.tomcat服务器把java源文件编译成class字节码文件（编译）
_index.java-->_index.class
3.tomcat服务器构造_index_jsp类对象
4.tomcat服务器调用_index_jsp类里面的方法，返回内容显示到浏览器
如果是第一次访问当前jsp文件时，执行步骤是：1-->2-->3-->4
第N次访问jsp时，执行步骤是：4，不再执行其他步骤
注意：jsp文件被修改或者jsp的临时文件被删除了，要重新走翻译（1）和编译（2）的过程
问题2：既然jsp是servlet，那么jsp的生命周期和servlet的生命周期是不是一样的？
当jsp文件被翻译成java的源码时，可以在翻译出来的源码文件里看到当前访问的jsp文件继承HttpJspBase类，再通过查询JDK，可以发现HttpJspBase又是继承于HttpServlet的。所以，可以得到结论，jsp既是一个servlet的程序，而servlet的技术可以用在jsp程序中，但是并不是所有的servlet技术全部适用于jsp程序
Servlet的生命周期：
1.构造方法（第一次访问时执行）
2.init方法（第一次访问时执行）
3.service方法（每次访问都会执行）
4.destory方法（退出时执行）
Jsp的生命周期：
1.翻译：Jsp-->java源文件
2.编译：java文件-->class文件（servlet程序）
3.构造方法（第一次访问时执行）
4.init方法（第一次访问）：JspInit（）
5.service方法：JspService()
6.destory方法：jspDestory()
3.Jsp语法
3.1.Jsp模板
JSP页面中的HTML内容就是JSP的模板
这些模板定义了网页的基本骨架，也就是说定义了页面的结构和外观
3.2.Jsp表达式
JSP的表达式作用是向浏览器输出变量的值或表达式计算的结果
语法：<%=变量或表达式 %>
例如<% String name="Eric";%>
<%=name%>
注意：
1.表达式的原理即使翻译成out.print("变量“)；通过该方法向浏览器写出内容。
2.表达式后面不需要带分好结束
3.3.Jsp的脚本
脚本是指在JSP页面编写多行java代码的，可以执行java代码
语法：<%多行java代码； %>
注意
1.原理是把脚本中的java代码原封不动的拷贝到jspService方法中执行
2.jsp脚本中写的java是需要加分好的，语法跟java语法是一样的
3.多个脚本片段中的代码可以相互访问
4.单个脚本片段中的java语句可以是不完整的，但是，多个脚本片段组合后的结必须是完整的java语句
3.4.Jsp的声明
JSP的声明是用来声明变量或者方法的，如果在index.jsp页面内声明一个变量或者方法，则该变量或者方法是index_jsp类的成员变量，成员方法，即是全局变量。这个其实就是在类中写好方法，然后可以在jsp_service方法中调用其他方法。
jsp通过脚本也可以定义一个变量，但是这个变量是保存在index_jsp类下的jspService方法下的一个变量，由于是保存在方法下面，所有脚本里是不可以定义一个方法的，只能通过声明来定义方法。
注意以上两者的区别，一个是保存在类下面，称为成员变量或者成员方法，另一个则是保存在方法中，称之为局部变量
语法：<%! 变量或方法%>
作用：声明JSP的变量和方法
注意：
1.变量翻译成成员变量，方法翻译成成员方法
3.5.Jsp的注释
jsp的注释格式：
jsp的注释：<%!--jsp注释 --%>
html的注释：
注意：
1.html的注释会被翻译和执行，无论在jsp的页面翻译之后的源码还是在浏览器上查看网站的源码，都是可以查看到的。但是jsp的注释是不会被翻译和执行的，在翻译之后源码里是不能找到的，从浏览器查看源码也是查看不到的‘
4.Jsp的三大指令
JSP指令是为JSP引擎而设计的，他们并不产生任何可见的输出，只是告诉引擎如何处理jsp页面中的其余部分。jsp定义的有三大指令，分别是：include,page,tagllb
4.1.Include指令
Include指令的作用是当前页面包含其他页面，主要是导入其他jsp文件
语法：<%@include file="common/header.jsp%>
注意：
1.原理是把被包含的页面（header.jsp）的内容翻译到包含页面（index.jsp）中，合并并翻译成一个java源文件，再编译运行！！，这种包含就加叫静态包含（源码包含）
2.如果使用静态包含，被包含页面中不需要出现全局的html标签了，（如html,body,head）
4.2.page指令
page指令的作用是告诉tomcat服务器如何翻译jsp文件
语法：<%@ page contentType="text/html;charset=UTF-8" language="java" %>
language="java"--告诉服务器只用什么动态语言来翻译jsp文件
import="java.util.*" --告诉服务器java文件使用什么包，导入多个包时，用逗号隔开
pageEncoding="utf-8" --告诉服务器使用什么编码把jsp翻译成java文件
contentType="text/html; charset=utf-8" --服务器发送浏览器的数据类型和内容编码，在开发工具中，只需要设置pageEncoding即可解决中文乱码的问题
errorPage="error.jsp" --如果当前页面出现错误信息，则自动调用此处指定的错误页面
isErrorPage="false" --意思是当前页面为错误页面，默认为false，当设置为true时就认为是一个错误处理页面，就可以在页面中使用<%=exception.getMessage()%>方法来获取错误异常信息，使其在页面上可以显示
全局配置错误处理页面
在web.xml中配置如下：
<!--全局错误处理页面配置-->
<error-page>
<error-code>500</error-code>
<location>common/500.jsp</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>common/404.html</location>
</error-page>
配置之后，不用在jsp页面中特别指明，会自动跳转的
session="true" --是否开启Session功能，false时不能使用Session内置对象，ture时可以使用。默认为true
buffer="8kb" --页面的缓存区大小。
isELIgnored="false" --是否忽略EL表达式。
4.3.tagllb指令
5.JSP的内置对象
5.1.什么是内置的对象
在Service开发中会经常用到一些常用的类比如：HttpSession,ServletConfig,ServletContext,HttpServletRequet,用的时候，我们会直接创建就可以了，但是在jsp中这会经常使用到这些类。为了开发的方便，sun公司在设计jsp的时候，在jsp页面加载完毕以后就自动帮开发者创建好了这些对象，而开发者只需要直接使用这些对象就可以了，那么这些已经创建好的对象有一个统一的名字叫做内置对象,内置对象一共有九个
例如：
在Service中要使用Session，需要先HttpSession session = request.getSession(true); 来创建一个Session对象，然后在使用对象的方法
但是在JSP中，可以直接使用Session的方法，如session.getId();
九大内置对象分别为：
1.对象名(request)-->类型HttpServletRequest ：HTTP请求的时候使用到
2.对象名(response)-->类型HttpServletResponse :HTTP响应的时候用到
3.对象名(config)-->类型ServletConfig :获取属于自己的参数
4.对象名(session)-->类型HttpServletSession :会话管理使用
5.对象名(application)-->类型ServletContext ：获取全局参数
6.对象名(exception)-->类型Throwable ：异常
7.对象名(page)-->类型 Object(this) ：本jsp对象
8.对象名(out)-->类型JspWriter ：打印到浏览器
9.对象名(pageContext)-->类型PageContext ：
5.2.Out对象
Out对象类型是JspWrite类，相当于带缓存的PrintWriter
PrintWriter：
用write(内容)直接向浏览器写出内容，有一句写一句
JspWrite(内容)：
用write(内容)向jsp的缓冲区写出内容，当缓冲区满足一下条件的时候，把内容一起写到浏览器上，性能高于PrintWriter
当满足一下条件之一，JSP缓冲区内容写出到浏览器:
- 缓冲区满了
- 刷新缓存去：out.flush();
- 关闭缓冲区：buffer="0kb";
- 执行完毕JSP页面
5.3.pageContext对象
前面已经有了8个内置对象，这些对象都是在jsp_service方法中被创建的，然后直接只用，但是由于是在方法中被创建，属于局部变量，所以很难在其他方法被调用，所有，使用了PageContext把这八个内置对象分装起来，这样传参的时候只需要传一个就可以了，然后通过这个PageContext来调用
除了调用其他八个内置对象意外，PageContext本身也是一个域对象，可以传递参数，准确的说PageContext是jsp的上下文对象，只可以在当前jsp文件内传参
分别介绍PageContext的两个方法：
1.可以获取其他八个内置对象
源码分析：
public class 01_hello_jsp {
public void _jspService(request,response){
创建内置对象
HttpSession session =....;
ServletConfig config = ....;
把8个经常使用的内置对象封装到PageContext对象中
PageContext pageContext = 封装；
调用method1方法
method1(pageContext);
}
public void method1(PageContext pageContext){
希望使用内置对象
从PageContext对象中获取其他8个内置对象
JspWriter out =pageContext.getOut();
HttpServletRequest rquest = pageContext.getRequest();
........
}
}
注意：调用的时候，使用getout，getrequest等方法来调用
使用场景：在自定义标签的时候，PageContext对象对象频繁使用到
2.PageContext本身就是一个域对象
经常使用的域对象有4个，分别是
ServletContext context域
HttpServletRequest request对象
HttpSession session域
PageContext page域
PageContext域的作用是保存数据和获取数据，用于共享数据
常用方法如下：
保存数据
1.默认情况下，保存到page域
pageContext.setAttribute("name");
2.可以向四个域对象保存数据
pageContext.setAttribute("name",域范围常量)
获取数据
1.默认情况下，从page域获取
pageContext.getAttribute("name")
2.可以从四个域中获取数据
pageContext.getAttribute("name",域范围常量)
3.自动在四个域中搜索数据
pageContext.findAttribute("name");
顺序： page域 -> request域 -> session域- > context域（application域）
域范围常量:
PageContext.PAGE_SCOPE
PageContext.REQUEST_SCOPE
PageContext.SESSION_SCOPE
PageContext.APPLICATION_SCOPE
5.4.JSP中的四个域对象
四个域度对象
- pageContext page域
- request request域
- session session域
- application context域
1.域对象作用
保存数据和获取数据，用于数据共享
2.域对象方法
setAttribute("name",Object)保存数据
getAttribute("name")获取数据
removeAttribute("name")消除数据
域对象的作用范围
- page域 ：只能在当前jsp页面中使用（当前页面）
- request ： 只能在同一个请求中使用（转发）
- Session ： 只能在同一个会话（session对象）中使用（私有的）
- context ： 只能在同一个web应用中使用（全局的）
5.5.JSP的最佳实践
Servlet技术：开发动态资源。是一个java类，最擅长写java代码
JSP技术：开发动态资源，通过java代码最擅长输出html代码
一个在web项目中涉及到的逻辑：
1.接收参数
2.处理业务逻辑
3.显示数据到浏览器
4.跳转到其他页面
最佳实践中，对上述逻辑进行分工，由Servlet和JSP联合完成
Servlet：
1.接收参数
2.处理业务逻辑
3.把结果保存到域对象中
4.跳转到jsp页面
JSP：
1.从域对象中取出数据
2.把数据显示到浏览器
Servlet的数据-->JSP页面
6.EL表达式
6.1.EL表达式的作用
EL表达式也是用在html页面中的，目的是简化JSP操作，代码。
在最佳实践中，总结得出JSP中尽量不要写java代码，最好的方法就是不写，所以的逻辑全部放到Servlet中，所有的数据展示放在JSP中
JSP的核心语法： jsp表达式 <%=%>和 jsp脚本<% %>。
现在使用EL表达式来替换到JSP的表达式
EL表达式的作用：向浏览器输出”域对象中的“变量值或表达式计算的结果！，注意一定要是域对象中的
语法：${变量或表达式}
6.2.EL语法
1.输出基本数据类型便变量
1.1.从四个域获取
输出普通字符串： ${name}
若没有指定域，则域的搜索先后顺序： pageScoep / requestScope / sessionScope / applicationScope
1.2.指定域获取
${pageScope.name}，在pageScope域中查找name
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>测试jsp文件</title>
</head>
<body>
<%
String name = "roso";
pageContext.setAttribute("name",name,PageContext.REQUEST_SCOPE);
%>
<br>
EL表达式：${requestScope.name};
<%--
${name}等价于pageContext.findAtribute("name")
--%>
</body>
</html>
2.输出对象的属性值
输出对象属性： ${student.name} 注意： .name 相当于 .getName（）方法
如果我们定义了一个Student类，并定义了name成员变量，这个时候可以通过${student.name}来获取name值
**点 . **方法是其实是调用getXX()方法
3.输出集合对象
集合对象有List和Map
输出List集合： ${list[0].name } 注意： [0] 相当于 get（下标）方法
输出map集合： ${map[key].name} 注意： ［key］相当于get（key）方法
中括号[]其实是调用get
EL表达式没有遍历功能，但是可以结合标签使用遍历
4.EL表达式计算
表达式中需要注意的是字符串判空的一种方法${empty name}<br>
示例代码：
<%@ page import="servers.Student" contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.util.HashMap" %>
<html>
<head>
<title>测试IE表达式</title>
</head>
<body>
<%--1.EL输出对象的属性--%>
<%
//保存数据
Student student = new Student("eric", 20);
//放入域中
pageContext.setAttribute("student",student);
%>
<%--2.EL输出集合List对象--%>
<%
//List
List<Student> list = new ArrayList<Student>();
list.add(new Student("rose",18));
list.add(new Student("jack",20));
list.add(new Student("luck",38));
//List放到域中
pageContext.setAttribute("list",list);
%>
<%--3.EL输出集合Map对象--%>
<%
//Map
Map<String,Student> map = new HashMap<String, Student>();
map.put("100",new Student("mark",20));
map.put("101",new Student("maxwell",30));
map.put("102",new Student("Eric",40));
//放入域中
pageContext.setAttribute("map",map);
%>
<%--3.EL表达式--%>
<%--3.1.算术表达式--%>
${10+5}<br>
<%--3.2.比较运算--%>
${10>5} <br>
<%--3.3.逻辑运算--%>
${true && false} <br>
<%--3.4.判空，null或空字符串--%>
判断null：${name==null}<br>
判断空字符串：${name==""}<br>
判空： ${name==null || name==""}<br>
判空的另一个种写法： ${empty name}<br>
<%--1.使用EL获取对象--%>
<%--实际调用student的getName方法获取的值--%>
获取student的name属性值：${student.name}
<%--${student.name}的点相当于调用getXX()方法--%>
<br>
<%--2.使用EL获取List对象--%>
list对象：${list} <br>
获取list的第一个对象：${list[0]} <br>
获取list的第一个对象的name和age属性：${list[0].name} - ${list[0].age}
<br>
<%--${list[0]}等价于(ListpageContext.findAttribute("list)--%>
<%--${list[0]}的中括号相当于调用get()方法--%>
<%--3.使用EL获取Map对象--%>
获取Map对象：${map}<br>
获取key=100的值：${map['100'].name} - ${map['100'].age}
</body>
</html>
7.JSP标签
7.1.JSP标签的作用
我们使用EL表达式来替换JSP的表达式，但是JSP还有一个经常会使用的语法，就是JSP脚本，出于和EL表达式同样的目的，我们使用标签来替代JSP脚本，以达到简化JSP页面的目的
所以JSP标签作用：替换JSP脚本
主要功能有：
1.路程判断（if，for， 循环）
2.跳转页面（转发，重定向）
3.…………
7.2.JSP标签的分类
JSP的标签也分为几种类型的
- 1.内置标签：，也叫动作标签，不需要在jsp页面中导入的标签
- 2.JSTL标签：需要在jsp页面中导入的标签
- 3.自定义标签：开发者自行定义，需要在jsp页面导入标签
7.3.动作标签
转发标签： <jsp:forward />
参数标签： jsp:pararm/
包含标签： jsp:include/
包含标签的原理：
包含与被包含的页面先各自翻译成java源文件，然后在运行时再合并在一起。（先翻译再合并），动态包含，使用include指令包含是静态包含
静态包含 VS 动态包含
1.语法不同
静态包含语法：<%@inclue file="被包含的页面"%>
动态包含语法： <jsp:include page="被包含的页面">
2.参数传递不同
静态包含不能向被包含页面传递参数
动态包含可以向被包含页面传递参数
3.原理不同
静态包含： 先合并再翻译
动态包含： 先翻译再合并
7.4.JSTL标签
JSTL的全名是：Java Standard Tag Libarary ---java标准标签库
java标准标签库有五类，常用的是前三类
- 标签核心库（c标签库） 天天用
- 国际化标签（fmt标签库）
- EL函数库（fn函数库）
- xml标签库（x标签库）
- sql标签库（sqp标签库）
7.5.使用JSTL标签的步骤
1.导入jstl支持的jar包（标签背后隐藏的java代码）
把包放在WEB-INF下的lib包
2.使用tablib指令导入标签库
<%@taglib prefix="简写" uri="tld文件的uri名称" %>
uri从jstl.jar包下的META-INF下的tld文件中查找，把uri的值复制过来，prefix的值也是在tld中查找
3.在jsp中使用标签
核心标签库的重点标签
保存数据：
<c:set></c:set>
获取数据：
<c:out value=""></c:out>
单条件判断：
<c:if test=""></c:if>
多条件判断：
<c:choose></c:choose>
<c:when test=""></c:when>
<c:otherwise></c:otherwise>
循环数据：
<c:forEach></c:forEach>
<c:forTokens items="" delims=""></c:forTokens>
重定向：
<c:redirect></c:redirect>
代码示例：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--导入标签库--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
<title>JSTL核心标签</title>
</head>
<body>
<%--使用标签--%>
<%--1.set标签:保存数据(保存到域中)，默认保存到page域中,可以指定--%>
<c:set var="name" value="Eric" scope="request"></c:set>
${name}<br>
${requestScope.name}<br>
<%--2.out标签：获取数据（从域中）,当value值为null时，可以使用default指定的默认值,escapeXml标明默认值是原样输出还是转化为之后再输出，默认为true，表示原样输出--%>
<%--双引号内虽然是name，但是现实的是字符串name，因为是在双引号内--%>
<c:out value="name"/>
<%--调用name的值正确写法--%>
<c:out value="${name}" default="<h3>标题3</h3>" escapeXml="false"/><br>
<%--3.if标签：单条件判断，如果test里面的EL表达式为真，则运行if包含的代码--%>
<c:if test="${10>5}">
条件成立
</c:if>
<%--4.choose标签+when标签+otherwirse标签:多条件的判断--%>
<c:set var="score" value="86"></c:set>
<c:choose>
<c:when test="${score>=90 && score<=100}">
优秀
</c:when>
<c:when test="${score>=80 && score<=90}">
良好
</c:when>
<c:when test="${score>=70 && score<=80}">
一般
</c:when>
<c:when test="${score>=60 && score<=70}">
及格
</c:when>
<c:otherwise>
不及格
</c:otherwise>
</c:choose>
<br>
<%--5.forEach：循环--%>
<%
//List
List<Student> list = new ArrayList<Student>();
list.add(new Student("rose",18));
list.add(new Student("jack",20));
list.add(new Student("luck",38));
//List放到域中
pageContext.setAttribute("list",list);
%>
<%
//Map
Map<String,Student> map = new HashMap<String, Student>();
map.put("100",new Student("mark",20));
map.put("101",new Student("maxwell",30));
map.put("102",new Student("Eric",40));
//放入域中
pageContext.setAttribute("map",map);
%>
<%--<c:forEach
begin="从哪个元素开始遍历,默认从0开始，可以不写"
end="到哪个元素结束，默认到最后一个元素，可以不写"
step="步长，默认是1，可以不写"
var="每个元素的名称"
items="需要遍历的数据（集合）"
varStatus="当前正在遍历的元素的状态对象(count属性：当前位置，从1开始)"/>--%>
<%--遍历list--%>
<c:forEach begin="0" end="2" step="1" items="${list}" var="student" varStatus="varSta">
姓名：${varSta.count}--${student.name}--年龄：${student.age}<br>
</c:forEach>
<%--遍历Map--%>
<c:forEach items="${map}" var="entry">
${entry.key}--姓名：${entry.value.name}--年龄：${entry.value.age}<br>
</c:forEach>
<%--6.forToken标签：循环特殊字符串--%>
<%
String str = "java-php-net-平面";
pageContext.setAttribute("str",str);
%>
<c:forTokens items="${str}" delims="-" var="s">
${s}<br>
</c:forTokens>
<%--7.重定向--%>
<c:redirect url="http://www.baidu.com"/>
</body>
</html>
8.自定义标签
8.1.引入
当现有的标签无法满足我们的需求时，就需要自己开发一个适合的标签
例如，需要向浏览器输入当前客户端的IP地址，虽然用java程序是可以的，但是用标签是没有这个功能的，现在，我们来自定以这个标签
8.2.第一个自定义标签开发步骤
1.编写一个普通的类，继承SimpleTagSupport类，叫做标签处理器类
/**
* 标签处理类
* 1.继承SimpleTagSupport
*/
public class ShowIpTag extends SimpleTagSupport {
/**
* 2.覆盖doTag方法
*/
@Override
public void doTag() throws JspException, IOException {
//向浏览器输出客户的IP地址
PageContext pageContext = (PageContext)this.getJspContext();
HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();
String ip = request.getRemoteHost();
JspWriter out = pageContext.getOut();
out.write("使用自定义标签输出客户的IP地址："+ip);
}
}
2.在web项目的WEB-INF目录下建立net.tld文件，这个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">
<!--标签库的版本-->
<tlib-version>1.1</tlib-version>
<!--标签库前缀-->
<short-name>net</short-name>
<!--tld文件的唯一标记-->
<uri>http://gz.itcast.cn</uri>
<!--一个标签的声明-->
<tag>
<!--标签名-->
<name>ShoeIp</name>
<!--标签处理器类的全名-->
<tag-class>tag.ShowIpTag</tag-class>
<!--输出标签体内容格式-->
<body-content>scriptless</body-content>
</tag>
</taglib>
3.在jsp页面的头部导入自定义标签库
<%@taglib prefix="net" uri="http://gz.itcast.cn" %>
4.在jsp中使用自定义标签
net:ShoeIp</net:ShoeIp>
8.3.自定义标签的执行过程
问题： http://localhost:8080/hello/tag.jsp 如何访问到自定义标签？
前提：tomcat服务器启动时，加载到每个web应用，加载每个web应用的WEB-INF目录下的所有文件，如web.xml, tld文件
访问步骤：
1.访问tag.jsp资源
2.tomcat服务器把jsp文件翻译成java源文件-->编译class-->构造类对象-->调用_jspService()方法
3.检查jsp文件的taglib指令，是否存在名为http://gz.itcast.cn的tld文件，如果没有，则报错
4.上一步已经读取到net.tld文件
5.在tag.jsp中读到net:ShoeIp，到net.tld文件中查询是否存在
6.找到对应的
7.得到tag.ShowIpTag
8.构造ShowIpTag对象，然后调用ShowIpTag里面的方法
8.4.自定义标签处理类的生命周期
标签处理器本质上实现的还是SimpleTag接口，只是对里面的方法进行了重写。
SimpleTag接口：
void setJspContext(JspContext pc)
设置pageContext对象，传入pageContext（一定调用）
void setParent(JspTag parent)
设置父标签对象，传入父标签对象，如果没有父标签对象，则调用此方法。通过geetParent()方法得到父标签对象
void setXX(值)
设置属性值
void setJspBody(JSpFragment jspBody)
设置标签体内容。标签提内容封装到JspFragment中，然后传入JspFragment对象，通过getJspBody()方法得到标签体内容，如果没有标签体内容，则不会调用此方法
void doTag()
执行标签时调用的方法（一定会调用）
8.5.自定义标签的作用
1.控制标签体内容的是否输出
2.控制标签余下内容是否输出
3.控制重复输出标签体内容
4.改变标签体内容
5.带属性的标签
//1.声明属性的成员变量
private Integer num;
//2.关键点： 必须提供公开的setter方法，用于给属性赋值
public void setNum(Integer num) {
this.num = num;
}
自定义标签的作用代码示例：
/**
* 标签处理器类
*/
public class TagDemo extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
System.out.println("执行了标签");
/**
*1. 控制标签内容是否输出
* 输出：调用jspFrament.invoke();
* 不输出：不调用jspFrament.invoke();
*/
//1.1.得到标签体内容
JspFragment jspBody = this.getJspBody();
//执行invoke方法：会把标签体的内容输出到指定的Writer对象
//1.2.往浏览器输出，writer为null就是默认往浏览器输出
// JspWriter out = this.getJspContext().getOut();
// jspBody.invoke(out);
jspBody.invoke(null);//等价于上面的两行代码
/**
* 3.控制重复输出标签体内容
* 方法：执行多次jspBody.invoke（）方法
*/
for (int i=1; i <= 5 ; i++) {
jspBody.invoke(null);
}
/**
* 4.改变标签提内容
*/
//4.1.创建StringWriter临时容器
StringWriter sw = new StringWriter();
//4.2.把标签提内容拷贝到临时容器
jspBody.invoke(sw);
//4.3.从临时容器中得到的标签
String content = sw.toString();
//4.4.改变内容
content = content.toLowerCase();
//4.5.把改变的内容输出到浏览器
//不能使用jspBody.invoke()来输出,因为标签体内的内容并没有改变，改变的是容器里面的
this.getJspContext().getOut().write(content);
/**
* 2.控制标签余下内容是否输出
* 输出：什么都不做就会默认输出
* 不输出：抛出有SkipPageException()异常则不输出
*/
throw new SkipPageException();
}
}
8.6.输出标签体内容格式
JSP：在传统标签中使用。可以写和执行jsp的java代码
scriptless:标签体不可以写jsp的java代码
empty：必须是空标签
tagdependent：标签体内容可以写jsp的java代码，但不会执行
9.JavaBean
JavaBaen，咖啡豆，是一种开发规范，可以说是一种技术
JavaBaen就是一个普通的java类，只要符合以下规定才能称之为javaBean：
1.必须提供无参构造方法
2.类中属性都必须私有化
3.该类提供公开的getter和setter方法
javaBean的作用：
用于方法数据，保存数据
方法javaBean只能使用getter和seetter方法
javaBean的使用场景：
1.项目中用到实体对象（entity）符合javaBean规范
2.EL表达式访问对象属性，${student.name}滴啊用getName()方法，符合javaBean规范
3.jsp标签中的属性赋值，setNum(Integet num)。符合javaBean规范
4.jsp页面中使用javaBean，符合javaBean规范
javaBean在jsp页面中的使用
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>jsp页面中使用javabean</title>
</head>
<body>
<%--创建对象,使用无参构造器--%>
<jsp:useBean id="stu" class="servers.Student"/>
<%--赋值--%>
<jsp:setProperty name="stu" property="name" value="jacky"/>
<%--获取--%>
<jsp:getProperty name="stu" property="name"/>
</body>
</html>