目录
jsp(3)
1. EL表达式
开发jsp的原则：尽量在jsp页面中少写，甚至不写java代码。使用EL(Expression Language)表达式便可替换掉Jsp表达式。
EL表达式作用：向浏览器输出域对象中的变量值或表达式计算的结果。
语法： ${变量或表达式}
- 获取数据
①例如：${name}
EL表达式语句在执行时，会调用pageContext.findAttribute（）方法，用name为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回”” （注意，不是null，而是空字符串）。
②例如从指定域获取：${pageScope.name}
域范围： pageScoep / requestScope / sessionScope / applicationScope
③EL表达式也可以很轻松获取JavaBean的属性，或获取数组、Collection、Map类型集合的数据，例如：
${student.name} 注： .name 相当于 .getName（）方法
${list[0].name } 注： [0] 相当于 get（下标）方法
${map[key].name} 注： ［key］相当于get（key）方法
例：在entity包中写Student.java类
package entity;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
在index.jsp文件夹中写jsp代码，使用EL表达式：
<%@ page language="java" import="java.util.*,entity.Student" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>EL表达式</title>
</head>
<body>
<%
//1)获取数据
String name="xiaohua";
//放入域中
pageContext.setAttribute("name",name);
pageContext.setAttribute("name",name,PageContext.REQUEST_SCOPE);
%>
<%--从四个域按顺序自动搜索，相当于<%=pageContext.findAttribute("name")%> --%>
EL表达式自动搜索获取数据： ${name }
<hr/>
<%--从指定域获取数据 ，相当于<%=pageContext.getAttribute("name",PageContext.PAGE_SCOPE)--%>
EL表达式从指定域获取数据：${pageScope.name}
<hr/>
<%
Student s=new Student("xiaohua", 24);//保存数据
pageContext.setAttribute("student",s);//放入域中
//list
List<Student> list=new ArrayList<Student>();
list.add(new Student("xiaohua",24));
list.add(new Student("xiaona",24));
pageContext.setAttribute("list", list);
//map
Map<String,Student> map=new HashMap<String,Student>();
map.put("001",new Student("xiaohua",24));
map.put("002",new Student("xiaona",24));
pageContext.setAttribute("map", map);
%>
<%--使用EL表达式获取对象属性 --%>
<%-- ${studen.name }等价于<%=((Student)pageContext.findAttribute("studen")).getName() --%>
${student.name } - ${student.age }
<hr/>
<%-- ${list[1].name }等价于<%=((List)pageContext.findAttribute("list")).get(1).getName() --%>
${list[1].name } - ${list[1].age }
<hr/>
<%-- ${map['001'].name }等价于((map)pageContext.findAttribute("map")).get('001').getName()--%>
${map['001'].name } - ${map['001'].age }
</body>
</html>
浏览器访问，查看：
2.执行运算
empty运算符：检查对象是否为null或“空”。
例：
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>EL表达式</title>
</head>
<body>
<%--2)执行运算 --%>
<% String name=null; %>
判断null: ${name==null } <br/>
判断空字符串： ${name=="" } <br/>
判断空字符串或null ${name==null || name=="" }<br/>
判断空字符串或null ${empty name }<br/>
</body>
</html>3.获得web开发常用的对象
EL表达式语言中定义了11个隐含对象，使用这些隐含对象可以很方便地获取web开发中的一些常见对象，并读取这些对象的数据。
语法：${隐式对象名称} ：获得对象的引用
| 隐含对象名称 |
描 述 |
| pageContext |
对应于JSP页面中的pageContext对象 |
| pageScope |
代表page域中用于保存属性的Map对象 |
| requestScope |
代表request域中用于保存属性的Map对象 |
| sessionScope |
代表session域中用于保存属性的Map对象 |
| applicationScope |
代表application域中用于保存属性的Map对象 |
| param |
表示一个保存了所有请求参数的Map对象 |
| paramValues |
表示一个保存了所有请求参数的Map对象，它对于某个请求参数，返回的是一个string[] |
| header |
表示一个保存了所有http请求头字段的Map对象 |
| headerValues |
同上，返回string[]数组。注意：如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”] |
| cookie |
表示一个保存了所有cookie的Map对象 |
| initParam |
表示一个保存了所有web应用初始化参数的map对象 |
注：变量在命名的时候，应该避免使用EL表达式的保留关键字，以免程序编译时发生错误。 EL表达式保留关键字：
2.Jsp标签
使用JSP标签便可替换掉JSP脚本。
标签分类：1）动作标签（内置标签）： 不需要在jsp页面导入标签
2）jstl标签： 需要在jsp页面中导入标签
3）自定义标签 ： 开发者自行定义，需要在jsp页面导入标签
2.1动作标签
（一）转发标签：<jsp:forward page="relativeURL | <%=expression%>" />
page属性用于指定请求转发到的资源的相对路径，也可以通过执行一个表达式来获得。
<jsp:forward>标签用于把请求转发给另外一个资源。
（二）包含标签： <jsp:include page="relativeURL | <%=expression%>" flush="true|false" />
<jsp:include>标签用于把另外一个资源的输出内容插入进当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。
page属性用于指定被引入资源的相对路径，它也可以通过执行一个表达式来获得。
flush属性指定在插入其他资源的输出内容时，是否先将当前JSP页面的已输出的内容刷新到客户端，默认为false。
<jsp:include>与include指令的比较：
- <jsp:include>标签是动态引入， <jsp:include>标签涉及到的2个JSP页面会被翻译成2个servlet，这2个servlet的内容在执行时进行合并； 而include指令是静态引入，涉及到的2个JSP页面会被翻译成一个servlet，其内容是在源文件级别进行合并。
- <jsp:include>标签：使用page属性指定被引入资源； include指令：使用file属性指定被引入资源。
3)不管是<jsp:include>标签，还是include指令，它们都会把两个JSP页面内容合并输出，所以这两个页面不要出现重复的HTML全局架构标签，否则输出给客户端的内容将会是一个格式混乱的HTML文档。
（三）参数标签：<jsp:param>
语法1：
<jsp:include page="relativeURL | <%=expression%>">
<jsp:param name="parameterName" value="parameterValue|<%= expression %>" />
</jsp:include>
语法2：
<jsp:forward page="relativeURL | <%=expression%>">
<jsp:param name="parameterName" value="parameterValue|<%= expression %>" />
</jsp:include>
当使用<jsp:include>和<jsp:forward>标签引入或将请求转发给其它资源时，可以使用<jsp:param>标签向这个资源传递参数。
<jsp:param>标签的name属性用于指定参数名，value属性用于指定参数值。在<jsp:include>和<jsp:forward>标签中可以使用多个<jsp:param>标签来传递多个参数。
例：
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>动作标签</title>
</head>
<body>
<%--转发标签 --%>
<%--
<jsp:forward page="/01.hello.jsp">
<%--参数标签 --%>
<jsp:param value="jacky" name="name"/>
<jsp:param value="123456" name="password"/>
</jsp:forward>
--%>
<%--包含标签 --%>
<jsp:include page="/header.jsp">
<%--参数标签 --%>
<jsp:param value="lucy" name="name"/>
</jsp:include>
</body>
</html>
2.2JSTL标签
JSTL (java standard tag libarary java标准标签库）
核心标签库 （c：）
国际化标签 （fmt：）
EL函数库 （fn：）
xml标签库 （x：）
sql标签库 （sql：）
使用JSTL标签步骤：
1） 导入jstl支持的jar包（标签背后隐藏的java代码）
注意：使用javaee5.0的项目自动导入jstl支持jar包
2）使用taglib指令导入标签库
<%@taglib uri="tld文件的uri名称" prefix="简写" %>
3）在jsp中使用标签
核心标签库的重点标签：
1）保存数据：
<c:set></c:set>标签用于把某一个对象存在指定的域范围内，或者设置Web域中的java.util.Map类型的属性对象或JavaBean类型的属性对象的属性。
| 属性名 |
是否支持EL |
属性类型 |
属 性 描 述 |
| value |
true |
Object |
用于指定属性值 |
| var |
false |
String |
用于指定要设置的Web域属性的名称 |
| scope |
false |
String |
用于指定属性所在的Web域 |
| target |
true |
Object |
用于指定要设置属性的对象，这个对象必须是JavaBean对象或java.util.Map对象 |
| property |
true |
string |
用于指定当前要为对象设置的属性名称 |
2）获取数据：
<c:out></c:out>用于输出一段文本到浏览器。
| 属性名 |
是否支持EL |
属性类型 |
属 性 描 述 |
| value |
true |
Object |
指定要输出的内容 |
| escapeXml |
true |
Boolean |
指定是否将>、<、&、'、" 等特殊字符进行HTML编码转换后再进行输出。默认值为true |
| default |
true |
Object |
指定如果value属性的值为null/””时所输出的默认值 |
- 单条件判断：
<c:if test=""></c:if>可以构造简单的“if-then”结构的条件表达式。
| 属性名 |
是否支持EL |
属性类型 |
属 性 描 述 |
| test |
true |
boolean |
决定是否处理标签体中的内容的条件表达式 |
| var |
false |
String |
用于指定将test属性的执行结果保存到某个Web域中的某个属性的名称 |
| scope |
false |
String |
指定将test属性的执行结果保存到哪个Web域中 |
4）多条件判断
<c:choose>标签用于指定多个条件选择的组合边界，它必须与<c:when>和<c:otherwise>标签一起使用。使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似 “if-else if-else” 的复杂条件判断结构。
5）循环数据
<c:forEach>标签用于对一个集合对象中的元素进行循环迭代操作，或者按指定的次数重复迭代执行标签体中的内容。
| 属性名 |
是否支持EL |
属性类型 |
属 性 描 述 |
| var |
false |
String |
指定将当前迭代到的元素保存到page这个Web域中的属性名称 |
| items |
true |
任何支持的类型 |
将要迭代的集合对象 |
| varStatus |
false |
String |
指定将代表当前迭代状态信息的对象保存到page这个Web域中的属性名称 |
| begin |
true |
int |
如果指定items属性，就从集合中的第begin个元素开始进行迭代，begin的索引值从0开始编号；如果没有指定items属性，就从begin指定的值开始迭代，直到end值时结束迭代 |
| end |
true |
int |
参看begin属性的描述 |
| step |
true |
int |
指定迭代的步长，即迭代因子的迭代增量 |
<c:forTokens items="" delims=""></c:forTokens>对带有相同符合格式内容进行分割输出，例如varstr="1,2,3,4,5,6";
| 属性名 |
是否支持EL |
属性类型 |
属 性 描 述 |
| Items |
true |
任何支持的类型 |
将要迭代的集合对象 |
| delims |
false |
String |
字符串的分割符，可以同时有个分割符（依次写在引号内即可。） |
| varStatus |
false |
String |
指定将代表当前迭代状态信息的对象保存到page这个Web域中的属性名称 |
| begin |
true |
int |
如果指定items属性，就从集合中的第begin个元素开始进行迭代，begin的索引值从0开始编号；如果没有指定items属性，就从begin指定的值开始迭代，直到end值时结束迭代 |
| end |
true |
int |
参看begin属性的描述 |
| step |
true |
int |
指定迭代的步长，即迭代因子的迭代增量 |
| var |
False |
String |
指定将当前迭代到的元素保存到page这个Web域中的属性名称 |
6）重定向或转发
<c:redirect>标签用于将当前的访问请求转发或重定向到其他资源，它可以根据url属性所指定的地址，执行类似<jsp:forward>这个JSP标准标签的功能，将访问请求转发到其他资源；或执行response.sendRedirect()方法的功能，将访问请求重定向到其他资源。
| 属性名 |
是否支持EL |
属性类型 |
属 性 描 述 |
| url |
true |
String |
指定要转发或重定向到的目标资源的URL地址 |
例：
<%@ page language="java" import="java.util.*,entity.*" pageEncoding="utf-8"%>
<%--导入标签库 --%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>jstl标签</title>
</head>
<body>
<%--set标签 ,默认保存在page域--%>
<c:set var="name" value="xiaohua" scope="request"></c:set>
${name }<br/>
<%--out标签 --%>
<% String msg=null;pageContext.setAttribute("msg", msg); %>
<c:out value="${msg }" default="<h1>xiaohua</h1>" escapeXml="false"></c:out> <br/>
<%--if标签:单条件判断 --%>
<c:if test="${empty msg }">
条件成立，执行。
</c:if> <br/>
<%--choose标签：多条件判断 --%>
<c:set var="score" value="80"></c:set>
<c:choose>
<c:when test="${score>=90 }">优秀</c:when>
<c:when test="${score>=60 && score<90 }">良好</c:when>
<c:otherwise>不及格</c:otherwise>
</c:choose> <br/>
<%--forEach标签 --%>
<%
//list
List<Student> list=new ArrayList<Student>();
list.add(new Student("xiaohua", 24));
list.add(new Student("xiaona",24));
pageContext.setAttribute("list", list);
//Map
Map<String,Student> map = new HashMap<String,Student>();
map.put("001",new Student("xiaohua", 24));
map.put("002",new Student("xiaona",24));
pageContext.setAttribute("map",map);
%>
<c:forEach items="${list}" var="stu" varStatus="status">
序号：${status.count} - 姓名： ${stu.name} - 年龄：${stu.age}<br/>
</c:forEach>
<c:forEach items="${map}" var="entry">
序号：${entry.key } - 姓名： ${entr.value.name } - 年龄：${entry.value.age }<br/>
</c:forEach>
<hr/>
<%-- forToken标签： 循环特殊字符串 --%>
<%
String str = "java+javascript-php-net-c+c#";
pageContext.setAttribute("str",str);
%>
<c:forTokens items="${str}" delims="-+" var="s">
${s }<br/>
</c:forTokens>
<%--redrict:重定向 --%>
<%-- <c:redirect url="https://blog.csdn.net/qq_34774655"></c:redirect> --%>
</body>
</html>
浏览器打开，查看：
2.3自定义标签
（一）自定义标签开发步骤
1）编写一个普通的java类，继承SimpleTagSupport类，叫做标签处理器类。
2）编写标签库描述符（tld）文件，在tld文件中对自定义标签进行描述，并放置在WEB-INF/目录下。
标签库描述文件：
<body-content>：指定标签体的类型。可能取值有 4 种：
JSP：表示支持jsp标本表达式取值，即<%= %>。只能在传统标签用，简单标签不支持！
empty：没有标签体
scriptless：标签体可以包含 el 表达式和 JSP 动作元素，但不能包含 JSP 的脚本元素
tagdependent：表示标签体交由标签本身去解析处理。若指定 tagdependent，在标签体中的所有代码都会原封不动的交给标签处理器，而不是将执行结果传递给标签处理器。
3） 在jsp页面的头部导入自定义标签库
4） 在jsp中使用自定义标签
例：
ShowIpTag.java
package tag;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.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);
}
}
xiaohua.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>xiaohua</short-name>
<!-- tld文件的唯一标记 -->
<uri>https://blog.csdn.net/qq_34774655</uri>
<!-- 一个标签的声明 -->
<tag>
<!-- 标签名称 -->
<name>showIp</name>
<!-- 标签处理器类的全名 -->
<tag-class>tag.ShowIpTag</tag-class>
<!-- 输出标签体内容格式 -->
<body-content>scriptless</body-content>
</tag>
</taglib>
tag.jsp文件：
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@taglib uri="https://blog.csdn.net/qq_34774655" prefix="xiaohua"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>第一个自定义标签</title>
</head>
<body>
<%
//String ip = request.getRemoteHost();
//out.write("当前客户的IP地址是："+ip);
%>
<%--使用标签库中的标签--%>
<xiaohua:showIp></xiaohua:showIp>
</body>
</html>
浏览器查看：
（二）自定义标签的执行过程
浏览器访问：http://http://localhost:8080/xiaohua/tag.jsp 如何访问到自定义标签？
前提： tomcat服务器启动时，加载到每个web应用，加载每个web应用的WEB-INF目录下的所有文件！例如。web.xml, tld文件！
1）访问tag.jsp资源
2）tomcat服务器把jsp文件翻译成java源文件->编译class->构造类对象->调用_jspService（）方法
3）检查jsp文件的taglib指令，是否存在一个名为https://blog.csdn.net/qq_34774655文件。如果没有，则报错。
4）上一步已经读到xiaohua.tld文件
5）读到<xiaohua:showIp> 到xiaohua.tld文件中查询是否存在<name>为showIp的<tag>标签
6）找到对应的<tag>标签，则读到<tag-class>内容
7）得到tag.ShowIpTag
8）构造ShowIpTag对象，然后调用ShowIpTag里面的方法
（三）自定义标签处理器类的生命周期
SimpleTag接口：
①void setJspContext(JspContext pc) 用于把JSP页面的pageContext对象传递给标签处理 器对象
getJspCotext() 得到pageContext对象
②void setParent(JspTag parent) 用于把父标签处理器对象传递给当前标签处理器对象。
getParent() 用于获得当前标签的父标签处理器对象
③void setJspBody(JspFragment jspBody) 用于把代表标签体的JspFragment对象(即标 签体内容)传递给标签处理器对象
getJspBody() 得到标签体内容。
注：JspFragment类
javax.servlet.jsp.tagext.JspFragment类是在JSP2.0中定义的，它的实例对象代表JSP页面中的一段符合JSP语法规范的JSP片段，这段JSP片段中不能包含JSP脚本元素，即<%%>。
WEB容器在处理简单标签的标签体时，会把标签体内容用一个JspFragment对象表示，并调用标签处理器对象的setJspBody方法把JspFragment对象传递给标签处理器对象。 JspFragment类中只定义了两个方法，如下所示：
getJspContext方法：用于返回代表调用页面的JspContext对象.
public abstract void invoke(java.io.Writer out) ：用于执行JspFragment对象所代表的JSP代码片段。 参数out用于指定将JspFragment对象的执行结果写入到哪个输出流对象中，如果传递给参数out的值为null，则将执行结果写入到JspContext.getOut()方法返回的输出流对象中。(简而言之，可以理解为写给浏览器)
JspFragment.invoke方法可以说是JspFragment最重要的方法，利用这个方法可以控制是否执行和输出标签体的内容、是否迭代执行标签体的内容或对标签体的执行结果进行修改后再输出。例如：
在标签处理器中如果没有调用JspFragment.invoke方法，其结果就相当于忽略标签体内容；
在标签处理器中重复调用JspFragment.invoke方法，则标签体内容将会被重复执行；
若想在标签处理器中修改标签体内容，只需在调用invoke方法时指定一个可取出结果数据的输出流对象（例如StringWriter），让标签体的执行结果输出到该输出流对象中，然后从该输出流对象中取出数据进行修改后再输出到目标设备，即可达到修改标签体的目的。
④void doTag() 用于完成所有的标签逻辑，包括输出、迭代、修改标签体 内容等。在doTag方法中可以抛出 javax.servlet.jsp.SkipPageException异常，用于通知WEB容器不 再执行JSP页面中位于结束标记后面的内容。
实现 SimpleTag 接口的标签处理器类的生命周期:
四）自定义标签的作用
1）控制标签体内容是否输出
2）控制标签余下内容是否输出
3）控制重复输出标签体内容
4）改变标签体内容
5）带属性的标签
自定义标签可以定义一个或多个属性，这样，在JSP页面中应用自定义标签时就可以设置这些属性的值，通过这些属性为标签处理器传递参数信息，从而提高标签的灵活性和复用性。
例：
DemoTag.java文件
package tag;
import java.io.IOException;
import java.io.StringWriter;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.SkipPageException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class DemoTag extends SimpleTagSupport {
//5)带属性的标签
//①声明属性的成员变量
private int num;
//②必须公开setter方法，给属性赋值
public void setNum(int num) {
this.num=num;
}
@Override
public void doTag() throws JspException, IOException {
//1)控制标签内容是否输出
//①得到标签体内容
JspFragment jF=this.getJspBody();
//②往浏览器输出
/*JspWriter out=this.getJspContext().getOut();
jF.invoke(out);*/
jF.invoke(null);//等价于上面的代码
//3)控制重复输出标签体内容
for(int i=1;i<=num;i++) {
jF.invoke(null);
}
//4)改变标签体内容
//①创建StringWriter临时容器
StringWriter sw=new StringWriter();
//②把标签体拷贝到临时容器
jF.invoke(sw);
//③从临时容器中得到标签体内容
String content=sw.toString();
//④改变内容
content=content.toUpperCase();
//⑤把改变的内容输出到浏览器
//jF.invoke(null);//不能使用此方法，因为jF没有改变过
this.getJspContext().getOut().write(content);
//2)控制标签余下内容是否输出
//throw new SkipPageException();
}
}
xiaohua.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>xiaohua</short-name>
<!-- tld文件的唯一标记 -->
<uri>https://blog.csdn.net/qq_34774655</uri>
<!-- 一个标签的声明 -->
<tag>
<!-- 标签名称 -->
<name>showIp</name>
<!-- 标签处理器类的全名 -->
<tag-class>tag.ShowIpTag</tag-class>
<!-- 输出标签体内容格式 -->
<body-content>scriptless</body-content>
</tag>
<tag>
<name>demoTag</name>
<tag-class>tag.DemoTag</tag-class>
<body-content>scriptless</body-content>
<!-- 属性声明 -->
<attribute>
<!-- 属性名称 -->
<name>num</name>
<!-- 是否必填 -->
<required>true</required>
<!-- 是否支持EL表达式 -->
<rtexprvalue>false</rtexprvalue>
</attribute>
</tag>
</taglib>
demotag.jsp文件：
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@taglib uri="https://blog.csdn.net/qq_34774655" prefix="xiaohua"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>自定义标签的作用</title>
</head>
<body>
<xiaohua:demoTag num="3">abcdef</xiaohua:demoTag>
<br/>
此处是标签余下内容 xiaohua 2018-10-31
</body>
</html>浏览器查看：
3. JavaBean
JavaBean是一个遵循特定写法的Java类，通常用于封装数据。它具有如下特点：
1）必须提供无参数的构造方法
2）类中属性都必须私有化(private)
3）该类提供公开的getXXX（）和 setXXX（）方法，将私有化的属性暴露给其他程序。
JavaBean的属性可以是任意类型，并且一个JavaBean可以有多个属性。每个属性通常都需要具有相应的setter、 getter方法，setter方法称为属性修改器，getter方法称为属性访问器。一个JavaBean的某个属性也可以只有set方法或get方法，这样的属性通常也称之为只写、只读属性。
JavaBean的使用场景：
1）项目中用到实体对象（entity）符合javabean规范
2）EL表达式访问对象属性。${student.name} 调用getName()方法，符合javabean规范。
3）jsp标签中的属性赋值。 setNum（Integer num）。符合javabean规范。
4）jsp页面中使用javabean。符合javabean规范
例：以下方法哪些属于javabean的规范的方法？ 答案 ：( 1，3，5，6 )
注： boolean类型的get方法名称叫 isXXX()方法
1）getName() 2)getName(String name)
3)setName(String name) 4)setName()
5) setFlag(boolean flag) 6)isFlag()
4.web开发模式
Servlet+JSP+JavaBean(MVC)模式适合开发复杂的web应用，在这种模式下，servlet负责处理用户请求，jsp负责数据显示，javabean负责封装数据。
MVC开发模式：
Model - JavaBean实现。用于封装业务数据
View - Jsp实现。用于显示数据
Controller- servlet实现。用于控制model和view
三层结构：
dao层： 和数据访问相关的操作
service层： 和业务逻辑相关的操作
web层： 和用户直接交互相关的操作（传接参数，跳转页面）
