一个jsp页面中，可以有0~N个指令的定义！
1. page --> 最复杂：<%@page language="java" info="xxx"...%>
* pageEncoding和contentType：
> pageEncoding：它指定当前jsp页面的编码，只要不说谎，就不会有乱码！在服务器要把jsp编译成.java时需要使用pageEncoding!
> contentType：它表示添加一个响应头：Content-Type！等同与response.setContentType("text/html;charset=utf-8");
> 如果两个属性只提供一个，那么另一个的默认值为设置那一个。
> 如果两个属性都没有设置，那么默认为iso
* import：导包！可以出现多次(就这一个可以多次出现)
* errorPage和isErrorPage
> errorPage：当前页面如果抛出异常，那么要转发到哪一个页面，由errorPage来指定
> isErrorPage：它指定当前页面是否为处理错误的页面！当该属性为true时，这个页面会设置状态码为500！而且这个页面可以使用9大内置对象中的exception!
* <error-page>
<error-code>404</error-code>
<location>/error/errorPage.jsp</location>
</error-page>
<error-page>
<error-code>500</error-code>
<location>/error/errorPage.jsp</location>
</error-page>
<error-page>
<exception-type>java.lang.RuntimeException</exception-type>
<location>/index.jsp</location>
</error-page>
* autoFlush和buffer
> autoFlush：指定jsp的输出流缓冲区满时，是否自动刷新！默认为true，如果为false，那么在缓冲区满时抛出异常！
> buffer：指定缓冲区大小，默认为8kb，通常不需要修改！
* isELIgnored：是否忽略el表达式，默认值为false，不忽略，即支持！
* 基本没有：
> language：指定当前jsp编译后的语言类型，默认值为java。
> info：信息！
> isThreadSafe：当前的jsp是否支持并发访问！
> session：当前页面是否支持session，如果为false，那么当前页面就没有session这个内置对象！
> extends：让jsp生成的servlet去继承该属性指定的类！
* import：等同与import语句
--> <%@ page import="java.util.*" %>
--> <%@ page import="java.util.*, java.net.*" %>
--> 在一个JSP页面中可以给出多个page指令，而且import是可以重复出现的
<%@ page import="java.util.*" %>
<%@ page import="java.next.*" %>
* pageEncoding：指定当前页面的编码
--> 如果pageEncoding没有指定，那么默认为contentType的值；
--> 如果pageEncoding和contentType都没有指定，那么默认值为iso-8859-1
* contentType：等同与调用response.setContentType("text/html;charset=xxx");
--> 如果没有指定contentType属性，那么默认为pageEncoding的值；
--> 如果contentType和pageEncoding都没有指定，那么默认值为iso-8859-1
* errorPage：如果当前页面出现异常，那么跳转到errorPage指定的jsp页面。例如：<%@ page errorPage="a.jsp" %>
* isErrorPage：上面示例中指定a.jsp为错误页面，但在a.jsp中不能使用内置对象exception，保有a.jsp中使用<%@page isErrorPage="true"%>时，才能在a.jsp中使用错误页面。
* autoFlush：当autoFlush为true时，表示out流缓冲区满时会自动刷新。默认为true
* buffer：指定out流的缓冲区大小，默认为8KB
* isELIgnored：当前JSP页面是否忽略EL表达式，默认为false，表示不忽略，即支持EL表达式
2. page指令不常用的属性：
* language：当前JSP编译后的语言！默认为java，当前也只能选择java
* info：当前JSP的说明信息
* isThreadSafe：当前JSP是否执行只能单线程访问，默认为false，表示支持并发访问
* session：当前页面是否可以使用session，默认为false，表示支持session的使用。
* extends：指定JSP真身的父类！
3. web.xml中对jsp的配置
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern> <!--表示对所有jsp进行配置-->
<el-ignored>true</el-ignored> <!--忽略EL表达式-->
<page-encoding>UTF-8</page-encoding> <!--编码为utf-8-->
<scripting-invalid>true</scripting-invalid> <!--禁用java脚本-->
</jsp-property-group>
</jsp-config>
2. include --> 静态包含
* 与RequestDispatcher的include()方法的功能相似！
* <%@include%> 它是在jsp编译成java文件时完成的！他们共同生成一个java(就是一个servlet)文件，然后再生成一个class！
* RequestDispatcher的include()是一个方法，包含和被包含的是两个servlet，即两个.class！他们只是把响应的内容在运行时合并了！
* 作用：把页面分解了，使用包含的方式组合在一起，这样一个页面中不变的部分，就是一个独立jsp，而我们只需要处理变化的页面。
语法：<%@include file="页面"%>
include指令的作用是包含指定的页面！在jsp被编译成java文件之前会把两个jsp文件合并，然后再编译成一个java文件。
注意：
<%@include file="<%=myfile%>" %>
这是不能通过编译的，因为myfile是一个变量，它的值只有在java编译成class后执行时才能确定。而include指令需要在jsp编译java时就要确定包含的是哪个页面，所以...
3. taglib --> 导入标签库
* 两个属性：
> prefix：指定标签库在本页面中的前缀！由我们自己来起名称！
> uri: 指定标签库的位置！
> <%@taglib prefix="s" uri="/struts-tags"%> 前缀的用法<s:text>
taglib指令是用来在当前jsp页面中导入第三方的标签库
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
prefix：指定标签前缀，这个东西可以随意起名
uri：指定第三方标签库的uri（唯一标识）
当然，需要先把第三方标签库所需jar包放到类路径中。
=========================================
九个内置对象
* out --> jsp的输出流，用来向客户端响应
* page --> 当前jsp对象！ 它的引用类型是Object，即真身中有如下代码：Object page = this;
* config --> 它对应真身中的ServletConfig对象！
* pageContext --> 一个顶9个！ JSP的页面容器。
* request --> HttpServletEequest 得到用户请求信息。
* response --> HttpServletResponse
* exception --> Throwable
* session --> HttpSession 保存每一个用户的信息。
* application --> ServletContext 用户的共享信息。
1. pageContext
* 一个顶9个！
page属性范围（pagecontext表示），表示将一个属性设置在本页上，跳转之后无法取得。
* Servlet中有三大域，而JSP中有四大域，它就是最后一个域对象！
> ServletContext：整个应用程序
> session：整个会话(一个会话中只有一个用户)
> request：一个请求链！在服务器跳转后，所有设置的内容依然会被保留下来。
> pageContext：一个jsp页面！这个域是在当前jsp页面和当前jsp页面中使用的标签之间共享数据！
> 域对象
> 代理其他域：pageContext.setAttribute("xxx", "XXX", PageContext.SESSION_SCOPE);
> 全域查找：pageContext.findAttribute("xxx");从小到大，依赖查找！
> 获取其他8个内置对象：
=========================================
JSP动作标签
这些jsp的动作标签，与html提供的标签有本质的区别。
* 动作标签是由tomcat(服务器)来解释执行！它与java代码一样，都是在服务器端执行的！
* html由浏览器来执行！
* <jsp:forward>：转发！它与RequestDispatcher的forward方法是一样的，一个是在Servlet中使用，一个是在jsp中使用！
* <jsp:include>：包含：它与RequestDispatcher的include方法是一样的，一个是在Servlet中使用，一个是在jsp中使用！
> <%@include>和<jsp:include>有什么不同！
* <jsp:param>：它用来作为forward和include的子标签！用来给转发或包含的页面传递参数！
----------------------
<jsp:include>
例如：<jsp:include page="xxx"/>，用来包含指定的页面。
例如在a.jsp中存在如下内容：<jsp:include page="b.jsp"/>
a.jsp和b.jsp分别编码成Servlet，然后在执行Servlet时才会执行包含过程。这也是include指令与include标签的区别。
注意：<jsp:include page="<%=myfile%>">，这是可以的！因为include指令是在执行时才完成的包含，在执行时已经可以确定myfile这个变量的值。
该标签内部使用的是RequestDispatcher#include()方法完成的包含
----------------------
<jsp:forward>
例如：<jsp:forward page="xxx"/>，用来转发到指定页面
例如在a.jsp中存在如下内容：<jsp:fowrad page="b.jsp"/>
a.jsp中的内容不会显示在浏览器上，而只是显示b.jsp的内容。而且在<jsp:forwad>标签下面的内容不会被执行。
----------------------
<jsp:param>
该标签是<jsp:include>和<jsp:forward>的子标签，用来向其他页面传递参数。
<jsp:include page="/b.jsp">
<jsp:param value="zhangSan" name="username"/>
</jsp:include>
在b.jsp中可以使用request.getParameter("username")来获取参数值。
=========================================
JavaBean
javaBean的规范：
1. 必须要有一个默认构造器
2. 提供get/set方法，如果只有get方法，那么这个属性是只读属性！
3. 属性：有get/set方法的成员，还可以没有成员，只有get/set方法。属性名称由get/set方法来决定！而不是成员名称！
4. 方法名称满足一定的规范，那么它就是属性！boolean类型的属性，它的读方法可以是is开头，也可以是get开头！
内省：
内省类 --> Bean信息 --> 属性描述符 --> 属性的get/set对应的Method！ --- > 可以反射了！
-----------------------
commons-beanutils，它是依赖内省完成！
* 导包：
> commons-beanutils.jar
> commons-logging.jar
BeanUtils.getProperty(Object bean, String propertyName)
BeanUtils.setProperty(Object bean, String propertyName, String propertyValue)
BeanUtils.populate(Map map, Object bean)
CommontUtils.toBean(Map map, Class class)
-----------------------
jsp中与javaBean相关的标签！
* <jsp:useBean> --> 创建或查询bean
* <jsp:useBean id="user1" class="cn.itcast.domain.User" scope="session"/> 在session域中查找名为user1的bean，如果不存在，创建之
* <jsp:useBean id="user1" class="cn.itcast.domain.User" scope="session"/>
* <jsp:setProperty>
* <jsp:setProperty property="username" name="user1" value="admin"/> 设置名为user1的这个javabean的username属性值为admin
* <jsp:getProperty>
* <jsp:getProperty property="username" name="user1"/> 获取名为user1的javabean的名为username属性值
满足JavaBean规范的类就是javaBean
* 必须有public的无参的构造器
* 如果成员变量提供了getter/setter方法，那么称之为javabean属性。
JavaBean主要是用来通过反射操作的类！
因为需要通过Class的newInstance()方法来创建类的实例，所以要求类必须提供public的无参构造器
因为需要通过反射来操作属性，所以需要提供getter/setter方法。
----------------------
内省
内省依赖反射，内省比反射简化一点点，用来操作JavaBean
把Map中的数据封装到指定类型的JavaBean中。
以有对象：Map、Class<User>
1. 通过Class对象获取BeanInfo
BeanInfo info = Introspector.getBeanInfo(User.class);
2. 通过BeanInfo获取所有属性描述符对象
PropertyDescriptor[] pds = info.getPropertyDescriptors();
3. PropertyDescriptor：
* String name getName()：获取当前属性名称
* Method getReadMethod()：获取get方法反射对象
* Method getWriteMethod()：获取set方法反射对象
----------------------
commons-beanutils
beanutils比内省要简单很多，而且还要强大很多，它底层依赖内省。
1. jar包
commons-beanutils.jar、commons-logging.jar
2. 通过反射设置Javabean
Class<User> clazz = User.class;
Object user = clazz.newInstance();
BeanUtils.setProperty(user, "username", "admin");
BeanUtils.setProperty(user, "password", "admin123");
3. 获取属性值
String username = BeanUtils.getProperty(user, "username");
4. 把Map数据封装到JavaBean对象中
Map<String,String> map = new HashMap<String,String>();
map.put("username", "admin");
map.put("password", "admin123");
User user = new User();
BeanUtils.populate(user, map);
要求：map的key名称必须与User类的属性名称相同。不要无法赋值！
-----------------
JSP中与JavaBean相关的标签
* <jsp:useBean>
* <jsp:setProperty>
* <jsp:getProperty>
<jsp:useBean id="user1" class="cn.itcast.domain.User" />
查看page域中是否存在user1这个域属性，如果存在，那么直接获取。
如果不存在，那么创建之！
等同与：
User user1 = pageContext.getAttribute("user1");
if(user1 == null) {
user1 = new User();//创建user1对象
pageContext.setAttribute("user1", user1);//保存到page域
}
-----------------
上面是操作page域，可以通过scope属性来指定操作的域
<jsp:useBean id="user1" class="cn.itcast.domain.User" scope="page"/>
<jsp:useBean id="user2" class="cn.itcast.domain.User" scope="request"/>
<jsp:useBean id="user3" class="cn.itcast.domain.User" scope="session"/>
<jsp:useBean id="user4" class="cn.itcast.domain.User" scope="applicatioin"/>
------------------
<jsp:setProperty>
设置属性值
<jsp:setProperty property="username" name="user1" value="admin"/>
* name：指定名为user1的JavaBean
* property：指定要设置的属性名称
* value：指定要设置的属性值
等同与
User user1 = (User)pageContext.getAttribute("user1");
user1.setUsername("admin");
------------------
<jsp:getProperty>
获取属性值
<jsp:getProperty property="username" name="user1"/>
输出user1这个javaBean的username属性值
等同与
User user1 = (User)pageContext.getAttribute("user1");
out.print(user1.getUsername());
=========================================
EL表达式
1. EL是JSP内置的表达式语言！
* jsp2.0开始，不让再使用java脚本，而是使用el表达式和动态标签来替代java脚本！
* EL替代的是<%= ... %>，也就是说，EL只能做输出！
2. EL表达式来读取四大域
* ${xxx}，全域查找名为xxx的属性，如果不存在，输出空字符串，而不是null。
* ${pageScope.xxx}、${requestScope.xxx}、${sessionScope.xxx}、${applicationScope.xxx}，指定域获取属性！
3. javaBean导航
<%
Address address = new Address();
address.setCity("北京");
address.setStreet("西三旗");
Employee emp = new Employee();
emp.setName("李小四");
emp.setSalary(123456);
emp.setAddress(address);
request.setAttribute("emp", emp);
%>
<h3>使用el获取request域的emp</h3>
${requestScope.emp.address.street }<!-- request.getAttribute("emp").getAddress().getStreet() --><br/>
4. EL可以输出的东西都在11个内置对象中！11个内置对象，其中10个是Map！pageContext不是map，它就是PageContext类型，1个项9个。
* 我们已经学习了四个
* param：对应参数，它是一个Map，其中key参数名，value是参数值，适用于单值的参数。
* paramValues：对应参数，它是一个Map，其中key参数名，value是多个参数值，适用于多值的参数。
* header：对应请求头，它是一个Map，其中key表示头名称，value是单个头值，适用于单值请求头
* headerValues：对应请求头，它是一个Map，其中key表示头名称，value是多个头值，适用于多值请求头
* initParam：获取<context-param>内的参数！
<context-param>
<param-name>xxx</param-name>
<param-value>XXX</param-value>
</context-param>
<context-param>
<param-name>yyy</param-name>
<param-value>YYY</param-value>
</context-param>
${initParam.xxx}
* cookie：Map<String,Cookie>类型，其中key是cookie的name，value是cookie对象。 ${cookie.username.value}
* pageContext：它是PageContext类型！${pageContext.request.contextPath}
=========================================
EL函数库（由JSTL提供的）
* 导入标签库：<%@ tablib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
String toUpperCase(String input)：把参数转换成大写
String toLowerCase(String input)：把参数转换成小写
int indexOf(String input, String substring)：从大串，输出小串的位置！
boolean contains(String input, String substring)：查看大串中是否包含小串
boolean containsIgnoreCase(String input, String substring)：忽略大小写的，是否包含
boolean startsWith(String input, String substring)：是否以小串为前缀
boolean endsWith(String input, String substring)：是否以小串为后缀
String substring(String input, int beginIndex, int endIndex)：截取子串
String substringAfter(String input, String substring)：获取大串中，小串所在位置后面的字符串
substringBefore(String input, String substring)：获取大串中，小串所在位置前面的字符串
String escapeXml(String input)：把input中“<”、">"、"&"、"'"、"""，进行转义
String trim(String input)：去除前后空格
String replace(String input, String substringBefore, String substringAfter)：替换
String[] split(String input, String delimiters)：分割字符串，得到字符串数组
int length(Object obj)：可以获取字符串、数组、各种集合的长度！
String join(String array[], String separator)：联合字符串数组！
=========================================
自定义函数库
* 写一个java类，类中可以定义0~N个方法，但必须是static，而且有返回值的！
* 在WEB-INF目录下创建一个tld文件
<function>
<name>fun</name>
<function-class>cn.itcast.fn.MyFunction</function-class>
<function-signature>java.lang.String fun()</function-signature>
</function>
* 在jsp页面中导入标签库
<%@ taglib prefix="it" uri="/WEB-INF/tlds/itcast.tld" %>
* 在jsp页面中使用自定义的函数：${it:fun() }
EL：Expression Language，它是可以在JSP页面中直接使用的语言！
JSP页面也可以忽略EL：<@page isELIgnored="true"%>
EL用来代替<%=...%>
--------------------
格式：${...}，例如：${1 + 2}，会在页面上输出3
--------------------
运算符：+ - * / % == != < > <= >= && ! || empty
${empty ""} --> 输出true，判断集合、数据、字符串长度是否为0
${null}，不会输出！如果是null不输出！
--------------------
EL内置对象
EL一共11个内置对象
EL操作四大域的内置对象：它们是Map类型
pageScope
requestScope
sessionScope
applicationScope
${pageScope.user}：输出pageContext.getAttribute("user")
${requestScope.user}：输出request.getAttribute("user");
${sessionScope.user}：输出session.getAttribute("user");
${applicationScope.user}：输出application.getAttribute("user");
${user}
依次在pageScope、requestScope、sessionScope、applicationScope中查找user
如果查找到，那么立刻停止查找。
-----------
对JavaBean的操作
对List的操作
对Map的操作
-----------
操作JavaBean
<%
User user = new User();
user.setUsername("zhangSan");
user.setPassword("123");
pageContext.setAttribute("user", user);
%>
${pageScope.user.username}
${pageScope.user.password}
-----------
操作List
<%
User user = new User();
user.setUsername("zhangSan");
user.setPassword("123");
List list = new ArrayList();
list.add(user);
pageContext.setAttribute("list", list);
%>
${pageScope.list[0].username}
${pageScope.list[0].password}
-----------
操作Map
<%
User user = new User();
user.setUsername("zhangSan");
user.setPassword("123");
Map map = new HashMap();
map.put("u1", user);
pageContext.setAttribute("map", map);
%>
${pageScope.map['u1'].username}
${pageScope.map['u1'].password}
${pageScope.map.u1.username}
${pageScope.map.u1.password}
------------------
EL操作参数内置对象：Map类型
param：Map<String,String>
paramValues：Map<String,String[]>
${param.username}：request.getParameter("username")
${paramValues.hobby}：request.getParameterValues("hobby");
------------------
EL操作请求头内置对象：Map类型
header：Map<String,String>
headerValues：Map<String,String[]>
${header.UserAgent}
${headerValues.UserAgener[0]}
------------------
应用初始化参数内置对象：Map类型
initParam：Map<String,String>
用来获取web.xml文件中的<context-param>参数，例如：
web.xml
<context-param>
<param-name>p1</param-name>
<param-value>v1</param-value>
</context-param>
${initParam.p1}
------------------
与Cookie相关的内置对象：Map类型
cookie：Map<String,Cookie>，其中key是Cookie的名称，而值是Cookie对象
${cookie.jsessionid.value}：获取sessionid
------------------
pageContext内置对象：PageContext类型
${pageContext.request}，等同pageContext.getRequest()
${pageContext.session}，等同pageContext.getSession()
${pageContext.request.contextpath}，获取项目名
${pageContext.session.id}，获取sessionId
------------------
EL中最重要的就是操作四大域！
==========================
==========================
==========================
EL函数库
EL函数库，当前就是一些函数了。
使用EL函数库需要在JSP页面中导入标签库：
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/function"%>
<%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
⋯
String[] strs = {"a", "b","c"};
List list = new ArrayList();
list.add("a");
pageContext.setAttribute("arr", strs);
pageContext.setAttribute("list", list);
%>
${fn:length(arr) }<br/><!--3-->
${fn:length(list) }<br/><!--1-->
${fn:toLowerCase("Hello") }<br/> <!-- hello -->
${fn:toUpperCase("Hello") }<br/> <!-- HELLO -->
${fn:contains("abc", "a")}<br/><!-- true -->
${fn:containsIgnoreCase("abc", "Ab")}<br/><!-- true -->
${fn:contains(arr, "a")}<br/><!-- true -->
${fn:containsIgnoreCase(list, "A")}<br/><!-- true -->
${fn:endsWith("Hello.java", ".java")}<br/><!-- true -->
${fn:startsWith("Hello.java", "Hell")}<br/><!-- true -->
${fn:indexOf("Hello-World", "-")}<br/><!-- 5 -->
${fn:join(arr, ";")}<br/><!-- a;b;c -->
${fn:replace("Hello-World", "-", "+")}<br/><!-- Hello+World -->
${fn:join(fn:split("a;b;c;", ";"), "-")}<br/><!-- a-b-c -->
${fn:substring("0123456789", 6, 9)}<br/><!-- 678 -->
${fn:substring("0123456789", 5, -1)}<br/><!-- 56789 -->
${fn:substringAfter("Hello-World", "-")}<br/><!-- World -->
${fn:substringBefore("Hello-World", "-")}<br/><!-- Hello -->
${fn:trim(" a b c ")}<br/><!-- a b c -->
${fn:escapeXml("<html></html>")}<br/> <!-- <html></html> -->
====================
自定义函数库
1. 编写类
类中只能有public static的方法，并且一定要有返回值
public class ItcastFuncations {
public static String test() {
return "传智播客自定义EL函数库测试";
}
}
2. 部署文件
/WEB-INF/itcast.tld
<?xml version="1.0" encoding="UTF-8" ?>
<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">
<tlib-version>1.0</tlib-version>
<short-name>itcast</short-name>
<uri>http://www.itcast.cn/jsp/functions</uri>
<function>
<name>test</name>
<function-class>cn.itcast.el.funcations.ItcastFuncations</function-class>
<function-signature>String test()</function-signature>
</function>
</taglib>