jsp、javabean、el

摘要:
在服务器要把jsp编译成.java时需要使用pageEncoding!*404/error/errorPage.jsp500/error/errorPage.jspjava.lang.RuntimeException/index.jsp*autoFlush和buffer˃autoFlush:指定jsp的输出流缓冲区满时,是否自动刷新!他们共同生成一个java文件,然后再生成一个class!它与RequestDispatcher的forward方法是一样的,一个是在Servlet中使用,一个是在jsp中使用!=========================================JavaBeanjavaBean的规范:1.必须要有一个默认构造器2.提供get/set方法,如果只有get方法,那么这个属性是只读属性!

JSP三大指令
一个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去继承该属性指定的类!
2. include --> 静态包含
* 与RequestDispatcher的include()方法的功能相似!
* <%@include%> 它是在jsp编译成java文件时完成的!他们共同生成一个java(就是一个servlet)文件,然后再生成一个class!
* RequestDispatcher的include()是一个方法,包含和被包含的是两个servlet,即两个.class!他们只是把响应的内容在运行时合并了!
* 作用:把页面分解了,使用包含的方式组合在一起,这样一个页面中不变的部分,就是一个独立jsp,而我们只需要处理变化的页面。
3. taglib --> 导入标签库
* 两个属性:
> prefix:指定标签库在本页面中的前缀!由我们自己来起名称!
> uri: 指定标签库的位置!
> <%@taglib prefix="s" uri="/struts-tags"%> 前缀的用法<s:text>
=========================================
九个内置对象
* out --> jsp的输出流,用来向客户端响应
* page --> 当前jsp对象! 它的引用类型是Object,即真身中有如下代码:Object page = this;
* config --> 它对应真身中的ServletConfig对象!
* pageContext --> 一个顶9个!
* request --> HttpServletEequest
* response --> HttpServletResponse
* exception --> Throwable
* session --> HttpSession
* application --> ServletContext
1. pageContext
* 一个顶9个!
* 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的子标签!用来给转发或包含的页面传递参数!
=========================================
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 scope="session"/> 在session域中查找名为user1的bean,如果不存在,创建之
* <jsp:useBean 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属性值
=========================================
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>com.example.fn.MyFunction</function-class>
<function-signature>java.lang.String fun()</function-signature>
</function>
* 在jsp页面中导入标签库
<%@ taglib prefix="it" uri="/WEB-INF/tlds/example.tld" %>
* 在jsp页面中使用自定义的函数:${ex:fun()
jsp、javabean、el第1张

JSP指令
JSP指令分类
JSP有三大指令:
* page指令
* include指令
* taglib指令
在JSP中没有任何指令是必须的!!!
但基本上每个JSP都是使用page指令!
==========================
page指令
page指令是最为常用的指令!
1. page指令的常用属性:
* 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>
==========================
include指令
语法:<%@include file="页面"%>
include指令的作用是包含指定的页面!在jsp被编译成java文件之前会把两个jsp文件合并,然后再编译成一个java文件。
注意:
<%@include file="<%=myfile%>" %>
这是不能通过编译的,因为myfile是一个变量,它的值只有在java编译成class后执行时才能确定。而include指令需要在jsp编译java时就要确定包含的是哪个页面,所以...
==========================
taglib指令
taglib指令是用来在当前jsp页面中导入第三方的标签库
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
prefix:指定标签前缀,这个东西可以随意起名
uri:指定第三方标签库的uri(唯一标识)
当然,需要先把第三方标签库所需jar包放到类路径中。
==========================
九大内置对象
无需在jsp中声明即可使用的9个对象
* out(JspWriter):等同与response.getWriter(),用来向客户端发送文本数据;
* config(ServletConfig):对应“真身”中的ServletConfig;
* page(当前JSP的真身类型):当前JSP页面的“this”,即当前对象,引用为Object类型;
* pageContext(PageContext):页面上下文对象,它是最后一个没讲的域对象;
* exception(Throwable):只有在错误页面中可以使用这个对象;
* request(HttpServletRequest):即HttpServletRequest类的对象;
* response(HttpServletResponse):即HttpServletResponse类的对象;
* application(ServletContext):即ServletContext类的对象;
* session(HttpSession):即HttpSession类的对象,不是每个JSP页面中都可以使用,如果在某个JSP页面中设置<%@page session=”false”%>,说明这个页面不能使用session。
pageContext对象
pageContext对象是PageContext类型
* 域对象:只在当前jsp页面中有效的域,通常用来让jsp与当前jsp中标签之间共享数据
* 获取其他8个内置对象:可以获取其他8个内置对象
* 代理其他域对象:可以用pageContext来操作其他3个域。
==========================
JSP动作标签
JSP动作标签是用来替代一部分java脚本,使非java开发人员也可以向jsp中添加动态信息
----------------------
<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规范的类就是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 />
查看page域中是否存在user1这个域属性,如果存在,那么直接获取。
如果不存在,那么创建之!
等同与:
User user1 = pageContext.getAttribute("user1");
if(user1 == null) {
user1 = new User();//创建user1对象
pageContext.setAttribute("user1", user1);//保存到page域
}
-----------------
上面是操作page域,可以通过scope属性来指定操作的域
<jsp:useBean scope="page"/>
<jsp:useBean scope="request"/>
<jsp:useBean scope="session"/>
<jsp:useBean 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表达式
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 ExampleFuncations {
public static String test() {
return "自定义EL函数库测试";
}
}
2. 部署文件
/WEB-INF/example.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>example</short-name>
<uri>http://www.example.com/jsp/functions</uri>
<function>
<name>test</name>
<function-class>com.example.el.funcations.ExampleFuncations</function-class>
<function-signature>String test()</function-signature>
</function>
</taglib>
3. 在JSP中使用自定义
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="example" uri="/WEB-INF/example.tld" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body>
<h1>${example:test() }</h1>
</body>
</html>
day12
JSP指令
JSP指令概述
JSP指令的格式:<%@指令名 attr1=”” attr2=”” %>,一般都会把JSP指令放到JSP文件的最上方,但这不是必须的。
JSP中有三大指令:page、include、taglib,最为常用,也最为复杂的就是page指令了。
2 page指令
page指令是最为常用的指定,也是属性最多的属性!
page指令没有必须属性,都是可选属性。例如<%@page %>,没有给出任何属性也是可以的!
在JSP页面中,任何指令都可以重复出现!
<%@ page language=”java”%>
<%@ page import=”java.util.*”%>
<%@ page pageEncoding=”utf-8”%>
这也是可以的!
2.1 page指令的pageEncoding和contentType(重点)
pageEncoding指定当前JSP页面的编码!这个编码是给服务器看的,服务器需要知道当前JSP使用的编码,不然服务器无法正确把JSP编译成java文件。所以这个编码只需要与真实的页面编码一致即可!在MyEclipse中,在JSP文件上点击右键,选择属性就可以看到当前JSP页面的编码了。
contentType属性与response.setContentType()方法的作用相同!它会完成两项工作,一是设置响应字符流的编码,二是设置content-type响应头。例如:<%@ contentType=”text/html;charset=utf-8”%>,它会使“真身”中出现response.setContentType(“text/html;charset=utf-8”)。
无论是page指令的pageEncoding还是contentType,它们的默认值都是ISO-8859-1,我们知道ISO-8859-1是无法显示中文的,所以JSP页面中存在中文的话,一定要设置这两个属性。
其实pageEncoding和contentType这两个属性的关系很“暧昧”:
当设置了pageEncoding,而没设置contentType时: contentType的默认值为pageEncoding;
当设置了contentType,而没设置pageEncoding时: pageEncoding的默认值与contentType;
也就是说,当pageEncoding和contentType只出现一个时,那么另一个的值与出现的值相同。如果两个都不出现,那么两个属性的值都是ISO-8859-1。所以通过我们至少设置它们两个其中一个!
2.2  page指令的import属性
import是page指令中一个很特别的属性!
import属性值对应“真身”中的import语句。
import属性值可以使逗号:<%@page import=”java.net.*,java.util.*,java.sql.*”%>
import属性是唯一可以重复出现的属性:
<%@page import=”java.util.*” import=”java.net.*” import=”java.sql.*”%>
但是,我们一般会使用多个page指令来导入多个包:
<%@ page import=”java.util.*”%>
<%@ page import=”java.net.*”%>
<%@ page import=”java.text.*”%>
2.3 page指令的errorPage和isErrorPage
我们知道,在一个JSP页面出错后,Tomcat会响应给用户错误信息(500页面)!如果你不希望Tomcat给用户输出错误信息,那么可以使用page指令的errorPage来指定错误页!也就是自定义错误页面,例如:<%@page errorPage=”xxx.jsp”%>。这时,在当前JSP页面出现错误时,会请求转发到xxx.jsp页面。
a.jsp
<%@ page import="java.util.*" pageEncoding="UTF-8"%>
<%@ page errorPage="b.jsp" %>
<%
if(true)
throw new Exception("哈哈~");
%>
b.jsp
<%@ page pageEncoding="UTF-8"%>
<html>
<body>
<h1>出错啦!</h1>
</body>
</html>
在上面代码中,a.jsp抛出异常后,会请求转发到b.jsp。在浏览器的地址栏中还是a.jsp,因为是请求转发!
而且客户端浏览器收到的响应码为200,表示请求成功!如果希望客户端得到500,那么需要指定b.jsp为错误页面。
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ page isErrorPage="true" %>
<html>
<body>
<h1>出错啦!</h1>
<%=exception.getMessage() %>
</body>
</html>
注意,当isErrorPage为true时,说明当前JSP为错误页面,即专门处理错误的页面。那么这个页面中就可以使用一个内置对象exception了。其他页面是不能使用这个内置对象的!
温馨提示:IE会在状态码为500时,并且响应正文的长度小于等于512B时不给予显示!而是显示“网站无法显示该页面”字样。这时你只需要添加一些响应内容即可,例如上例中的b.jsp中我给出一些内容,IE就可以正常显示了!
2.3.1 web.xml中配置错误页面
不只可以通过JSP的page指令来配置错误页面,还可以在web.xml文件中指定错误页面。这种方式其实与page指令无关,但想来想去还是在这个位置来讲解比较合适!
web.xml
<error-page>
<error-code>404</error-code>
<location>/error404.jsp</location>
</error-page>
<error-page>
<error-code>500</error-code>
<location>/error500.jsp</location>
</error-page>
<error-page>
<exception-type>java.lang.RuntimeException</exception-type>
<location>/error.jsp</location>
</error-page>
<error-page>有两种使用方式:
<error-code>和<location>子元素;
<exception-type>和<location>子元素;
其中<error-code>是指定响应码;<location>指定转发的页面;<exception-type>是指定抛出的异常类型。
在上例中:
当出现404时,会跳转到error404.jsp页面;
当出现RuntimeException异常时,会跳转到error.jsp页面;
当出现非RuntimeException的异常时,会跳转到error500.jsp页面。
这种方式会在控制台看到异常信息!而使用page指令时不会在控制台打印异常信息。
2.4 page指令的autFlush和buffer
buffer表示当前JSP的输出流(out隐藏对象)的缓冲区大小,默认为8kb。
authFlush表示在out对象的缓冲区满时如果处理!当authFlush为true时,表示缓冲区满时把缓冲区数据输出到客户端;当authFlush为false时,表示缓冲区满时,抛出异常。authFlush的默认值为true。
这两个属性一般我们也不会去特意设置,都是保留默认值!
2.5 page指令的isELIgnored
后面我们会讲解EL表达式语言,page指令的isElIgnored属性表示当前JSP页面是否忽略EL表达式,默认值为false,表示不忽略(即支持)。
2.6 page指令的其他属性
language:只能是Java,这个属性可以看出JSP最初设计时的野心!希望JSP可以转换成其他语言!但是,到现在JSP也只能转换成Java代码;
info:JSP说明性信息;
isThreadSafe:默认为false,为true时,JSP生成的Servlet会去实现一个过时的标记接口SingleThreadModel,这时JSP就只能处理单线程的访问;
session:默认为true,表示当前JSP页面可以使用session对象,如果为false表示当前JSP页面不能使用session对象;
extends:指定当前JSP页面生成的Servlet的父类;
2.7 <jsp-config>(了解)
在web.xml页面中配置<jsp-config>也可以完成很多page指定的功能!
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<el-ignored>true</el-ignored>
<page-encoding>UTF-8</page-encoding>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>
</jsp-config>
3 include指令
include指令表示静态包含!即目的是把多个JSP合并成一个JSP文件!
include指令只有一个属性:file,指定要包含的页面,例如:<%@include file=”b.jsp”%>。
静态包含:当hel.jsp页面包含了lo.jsp页面后,在编译hel.jsp页面时,需要把hel.jsp和lo.jsp页面合并成一个文件,然后再编译成Servlet(Java文件)。
jsp、javabean、el第2张

很明显,在ol.jsp中在使用username变量,而这个变量在hel.jsp中定义的,所以只有这两个JSP文件合并后才能使用。通过include指定完成对它们的合并!
4 taglib指令
这个指令需要在学习了自定义标签后才会使用,现在只能做了了解而已!
在JSP页面中使用第三方的标签库时,需要使用taglib指令来“导包”。例如:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
其中prefix表示标签的前缀,这个名称可以随便起。uri是由第三方标签库定义的,所以你需要知道第三方定义的uri。
JSP九大内置对象
1 什么是JSP九大内置对象
在JSP中无需创建就可以使用的9个对象,它们是:
out(JspWriter):等同与response.getWriter(),用来向客户端发送文本数据;
config(ServletConfig):对应“真身”中的ServletConfig;
page(当前JSP的真身类型):当前JSP页面的“this”,即当前对象;
pageContext(PageContext):页面上下文对象,它是最后一个没讲的域对象;
exception(Throwable):只有在错误页面中可以使用这个对象;
request(HttpServletRequest):即HttpServletRequest类的对象;
response(HttpServletResponse):即HttpServletResponse类的对象;
application(ServletContext):即ServletContext类的对象;
session(HttpSession):即HttpSession类的对象,不是每个JSP页面中都可以使用,如果在某个JSP页面中设置<%@page session=”false”%>,说明这个页面不能使用session。
在这9个对象中有很多是极少会被使用的,例如:config、page、exception基本不会使用。
在这9个对象中有两个对象不是每个JSP页面都可以使用的:exception、session。
在这9个对象中有很多前面已经学过的对象:out、request、response、application、session、config。
2 通过“真身”来对照JSP
我们知道JSP页面的内容出现在“真身”的_jspService()方法中,而在_jspService()方法开头部分已经创建了9大内置对象。
public void _jspService(HttpServletRequest request, HttpServletResponse response)
throws java.io.IOException, ServletException {
PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
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;
从这里开始,才是JSP页面的内容
}…
3 pageContext对象
在JavaWeb中一共四个域对象,其中Servlet中可以使用的是request、session、application三个对象,而在JSP中可以使用pageContext、request、session、application四个域对象。
pageContext 对象是PageContext类型,它的主要功能有:
域对象功能;
代理其它域对象功能;
获取其他内置对象;
3.1 域对象功能
pageContext也是域对象,它的范围是当前页面。它的范围也是四个域对象中最小的!
void setAttribute(String name, Object value);
Object getAttrbiute(String name, Object value);
void removeAttribute(String name, Object value);
3.2 代理其它域对象功能
还可以使用pageContext来代理其它3个域对象的功能,也就是说可以使用pageContext向request、session、application对象中存取数据,例如:
pageContext.setAttribute("x", "X");
pageContext.setAttribute("x", "XX", PageContext.REQUEST_SCOPE);
pageContext.setAttribute("x", "XXX", PageContext.SESSION_SCOPE);
pageContext.setAttribute("x", "XXXX", PageContext.APPLICATION_SCOPE);
void setAttribute(String name, Object value, int scope):在指定范围中添加数据;
Object getAttribute(String name, int scope):获取指定范围的数据;
void removeAttribute(String name, int scope):移除指定范围的数据;
Object findAttribute(String name):依次在page、request、session、application范围查找名称为name的数据,如果找到就停止查找。这说明在这个范围内有相同名称的数据,那么page范围的优先级最高!
3.3 获取其他内置对象
一个pageContext对象等于所有内置对象,即1个当9个。这是因为可以使用pageContext对象获取其它8个内置对象:
JspWriter getOut():获取out内置对象;
ServletConfig getServletConfig():获取config内置对象;
Object getPage():获取page内置对象;
ServletRequest getRequest():获取request内置对象;
ServletResponse getResponse():获取response内置对象;
HttpSession getSession():获取session内置对象;
ServletContext getServletContext():获取application内置对象;
Exception getException():获取exception内置对象;
JSP动作标签
1 JSP动作标签概述
动作标签的作用是用来简化Java脚本的!
JSP动作标签是JavaWeb内置的动作标签,它们是已经定义好的动作标签,我们可以拿来直接使用。
如果JSP动作标签不够用时,还可以使用自定义标签(今天不讲)。JavaWeb一共提供了20个JSP动作标签,但有很多基本没有用,这里只介绍一些有坐标的动作标签。
JSP动作标签的格式:<jsp:标签名 …>
2 <jsp:include>
<jsp:include>标签的作用是用来包含其它JSP页面的!你可能会说,前面已经学习了include指令了,它们是否相同呢?虽然它们都是用来包含其它JSP页面的,但它们的实现的级别是不同的!
include指令是在编译级别完成的包含,即把当前JSP和被包含的JSP合并成一个JSP,然后再编译成一个Servlet。
include动作标签是在运行级别完成的包含,即当前JSP和被包含的JSP都会各自生成Servlet,然后在执行当前JSP的Servlet时完成包含另一个JSP的Servlet。它与RequestDispatcher的include()方法是相同的!
hel.jsp
<body>
<h1>hel.jsp</h1>
<jsp:include page="lo.jsp" />
</body>
lo.jsp
<%
out.println("<h1>lo.jsp</h1>");
%>
jsp、javabean、el第3张
其实<jsp:include>在“真身”中不过是一句方法调用,即调用另一个Servlet而已。
3 <jsp:forward>
forward标签的作用是请求转发!forward标签的作用与RequestDispatcher#forward()方法相同。
hel.jsp
jsp、javabean、el第4张

lo.jsp
<%
out.println("<h1>lo.jsp</h1>");
%>
注意,最后客户端只能看到lo.jsp的输出,而看不到hel.jsp的内容。也就是说在hel.jsp中的<h1>hel.jsp</h1>是不会发送到客户端的。<jsp:forward>的作用是“别在显示我,去显示它吧!”。
4 <jsp:param>
还可以在<jsp:include>和<jsp:forward>标签中使用<jsp:param>子标签,它是用来传递参数的。下面用<jsp:include>来举例说明<jsp:param>的使用。
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>a.jsp</title>
</head>
<body>
<h1>a.jsp</h1>
<hr/>
<jsp:include page="/b.jsp">
<jsp:param value="zhangSan" name="username"/>
</jsp:include>
</body>
</html>
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>b.jsp</title>
</head>
<body>
<h1>b.jsp</h1>
<hr/>
<%
String username = request.getParameter("username");
out.print("你好:" + username);
%>
</body>
</html>
JavaBean
1 JavaBean概述
1.1 什么是JavaBean
JavaBean是一种规范,也就是对类的要求。它要求Java类的成员变量提供getter/setter方法,这样的成员变量被称之为JavaBean属性。
JavaBean还要求类必须提供仅有的无参构造器,例如:public User() {…}
User.java
package com.example.domain;
public class User {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
1.2 JavaBean属性
JavaBean属性是具有getter/setter方法的成员变量。
也可以只提供getter方法,这样的属性叫只读属性;
也可以只提供setter方法,这样的属性叫只写属性;
如果属性类型为boolean类型,那么读方法的格式可以是get或is。例如名为abc的boolean类型的属性,它的读方法可以是getAbc(),也可以是isAbc();
JavaBean属性名要求:前两个字母要么都大写,要么都小写:
public class User {
private String iD;
private String ID;
private String qQ;
private String QQ;

}
JavaBean可能存在属性,但不存在这个成员变量,例如:
public class User {
public String getUsername() {
return "zhangSan";
}
}
上例中User类有一个名为username的只读属性!但User类并没有username这个成员变量!
还可以并变态一点:
public class User {
private String hello;
public String getUsername() {
return hello;
}
public void setUsername(String username) {
this.hello = username;
}
}
上例中User类中有一个名为username的属性,它是可读可写的属性!而Use类的成员变量名为hello!也就是说JavaBean的属性名取决与方法名称,而不是成员变量的名称。但通常没有人做这么变态的事情。
2 内省(了解)
内省的目标是得到JavaBean属性的读、写方法的反射对象,通过反射对JavaBean属性进行操作的一组API。例如User类有名为username的JavaBean属性,通过两个Method对象(一个是getUsenrmae(),一个是setUsername())来操作User对象。
如果你还不能理解内省是什么,那么我们通过一个问题来了解内省的作用。现在我们有一个Map,内容如下:
Map<String,String> map = new HashMap<String,String>();
map.put("username", "admin");
map.put("password", "admin123");
public class User {
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
}
}
现在需要把map的数据封装到一个User对象中!User类有两个JavaBean属性,一个叫username,另一个叫password。
你可能想到的是反射,通过map的key来查找User类的Field!这么做是没有问题的,但我们要知道类的成员变量是私有的,虽然也可以通过反射去访问类的私有的成员变量,但我们也要清楚反射访问私有的东西是有“危险”的,所以还是建议通过getUsername和setUsername来访问JavaBean属性。
2.1 内省之获取BeanInfo
我们这里不想去对JavaBean规范做过多的介绍,所以也就不在多介绍BeanInfo的“出身”了。你只需要知道如何得到它,以及BeanInfo有什么。
通过java.beans.Introspector的getBeanInfo()方法来获取java.beans.BeanInfo实例。
BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
2.2 得到所有属性描述符(PropertyDescriptor)
通过BeanInfo可以得到这个类的所有JavaBean属性的PropertyDescriptor对象。然后就可以通过PropertyDescriptor对象得到这个属性的getter/setter方法的Method对象了。
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
每个PropertyDescriptor对象对应一个JavaBean属性:
String getName():获取JavaBean属性名称;
Method getReadMethod:获取属性的读方法;
Method getWriteMethod:获取属性的写方法。
2.3 完成Map数据封装到User对象中
public void fun1() throws Exception {
Map<String,String> map = new HashMap<String,String>();
map.put("username", "admin");
map.put("password", "admin123");
BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
User user = new User();
for(PropertyDescriptor pd : pds) {
String name = pd.getName();
String value = map.get(name);
if(value != null) {
Method writeMethod = pd.getWriteMethod();
writeMethod.invoke(user, value);
}
}
System.out.println(user);
}
3 commons-beanutils
提到内省,不能不提commons-beanutils这个工具。它底层使用了内省,对内省进行了大量的简化!
使用beanutils需要的jar包:
commons-beanutils.jar;
commons-logging.jar;
3.1 设置JavaBean属性
User user = new User();
BeanUtils.setProperty(user, "username", "admin");
BeanUtils.setProperty(user, "password", "admin123");
System.out.println(user);
3.2 获取JavaBean属性
User user = new User("admin", "admin123");
String username = BeanUtils.getProperty(user, "username");
String password = BeanUtils.getProperty(user, "password");
System.out.println("username=" + username + ", password=" + password);
3.3 封装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);
System.out.println(user);
4 JSP与JavaBean相关的动作标签
在JSP中与JavaBean相关的标签有:
<jsp:useBean>:创建JavaBean对象;
<jsp:setProperty>:设置JavaBean属性;
<jsp:getProperty>:获取JavaBean属性;
我们需要先创建一个JavaBean类:
User.java
package com.example.domain;
public class User {
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
}
}
4.1 <jsp:useBean>
<jsp:useBean>标签的作用是创建JavaBean对象:
在当前JSP页面创建JavaBean对象;
把创建的JavaBean对象保存到域对象中;
<jsp:useBean />
上面代码表示在当前JSP页面中创建User类型的对象,并且把它保存到page域中了。下面我们把<jsp:useBean>标签翻译成Java代码:
<%
com.example.domain.User user1 = new com.example.domain.User();
pageContext.setAttribute("user1", user1);
%>
这说明我们可以在JSP页面中完成下面的操作:
<jsp:useBean />
<%=user1 %>
<%
out.println(pageContext.getAttribute("user1"));
%>
<jsp:useBean>标签默认是把JavaBean对象保存到page域,还可以通过scope标签属性来指定保存的范围:
<jsp:useBean scope="page"/>
<jsp:useBean scope="request"/>
<jsp:useBean scope="session"/>
<jsp:useBean scope="applicatioin"/>
<jsp:useBean>标签其实不一定会创建对象!!!其实它会先在指定范围中查找这个对象,如果对象不存在才会创建,我们需要重新对它进行翻译:
<jsp:useBean scope="applicatioin"/>
<%
com.example.domain.User user4 = (com.example.domain.User)application.getAttribute("user4");
if(user4 == null) {
user4 = new com.example.domain.User();
application.setAttribute("user4", user4);
}
%>
4.2 <jsp:setProperty>和<jsp:getProperty>
<jsp:setProperty>标签的作用是给JavaBean设置属性值,而<jsp:getProperty>是用来获取属性值。在使用它们之前需要先创建JavaBean:
<jsp:useBean />
<jsp:setProperty property="username" name="user1" value="admin"/>
<jsp:setProperty property="password" name="user1" value="admin123"/>
用户名:<jsp:getProperty property="username" name="user1"/><br/>
密 码:<jsp:getProperty property="password" name="user1"/><br/>
EL(表达式语言)
1 EL概述
1.1 EL的作用
JSP2.0要把html和css分离、要把html和javascript分离、要把Java脚本替换成标签。标签的好处是非Java人员都可以使用。
JSP2.0 – 纯标签页面,即:不包含<% … %>、<%! … %>,以及<%= … %>
EL(Expression Language)是一门表达式语言,它对应<%=…%>。我们知道在JSP中,表达式会被输出,所以EL表达式也会被输出。
1.2 EL的格式
格式:${…}
例如:${1 + 2}
1.3 关闭EL
如果希望整个JSP忽略EL表达式,需要在page指令中指定isELIgnored=”true”。
如果希望忽略某个EL表达式,可以在EL表达式之前添加“”,例如:${1 + 2}。
1.4 EL运算符

jsp、javabean、el第5张

1.5 EL不显示null
当EL表达式的值为null时,会在页面上显示空白,即什么都不显示。
2 EL表达式格式
先来了解一下EL表达式的格式!现在还不能演示它,因为需要学习了EL11个内置对象后才方便显示它。
操作List和数组:${list[0]}、${arr[0]};
操作bean的属性:${person.name}、${person[‘name’]},对应person.getName()方法;
操作Map的值:${map.key}、${map[‘key’]},对应map.get(key)。
3 EL内置对象
EL一共11个内置对象,无需创建即可以使用。这11个内置对象中有10个是Map类型的,最后一个是pageContext对象。
pageScope
requestScope
sessionScope
applicationScope
param;
paramValues;
header;
headerValues;
initParam;
cookie;
pageContext;
3.1 域相关内置对象(重点)
域内置对象一共有四个:
pageScope:${pageScope.name}等同与pageContext.getAttribute(“name”);
requestScope:${requestScope.name}等同与request.getAttribute(“name”);
sessionScoep: ${sessionScope.name}等同与session.getAttribute(“name”);
applicationScope:${applicationScope.name}等同与application.getAttribute(“name”);
如果在域中保存的是JavaBean对象,那么可以使用EL来访问JavaBean属性。因为EL只做读取操作,所以JavaBean一定要提供get方法,而set方法没有要求。
Person.java
public class Person {
private String name;
private int age;
private String sex;
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;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
jsp、javabean、el第6张

全域查找:${person}表示依次在pageScope、requesScopet、sessionScope、appliationScope四个域中查找名字为person的属性。
3.2 请求参数相关内置对象
param和paramValues这两个内置对象是用来获取请求参数的。
param:Map<String,String>类型,param对象可以用来获取参数,与request.getParameter()方法相同。
jsp、javabean、el第7张

注意,在使用EL获取参数时,如果参数不存在,返回的是空字符串,而不是null。这一点与使用request.getParameter()方法是不同的。
jsp、javabean、el第8张
paramValues:paramValues是Map<String, String[]>类型,当一个参数名,对应多个参数值时可以使用它。
jsp、javabean、el第9张

3.3 请求头相关内置对象
header和headerValues是与请求头相关的内置对象:
header: Map<String,String>类型,用来获取请求头。
jsp、javabean、el第10张

headerValues:headerValues是Map<String,String[]>类型。当一个请求头名称,对应多个值时,使用该对象,这里就不在赘述。
3.4 应用初始化参数相关内置对象
initParam:initParam是Map<String,String>类型。它对应web.xml文件中的<context-param>参数。
jsp、javabean、el第11张

3.5 Cookie相关内置对象
cookie:cookie是Map<String,Cookie>类型,其中key是Cookie的名字,而值是Cookie对象本身。

3.6 pageContext对象
pageContext:pageContext是PageContext类型!可以使用pageContext对象调用getXXX()方法,例如pageContext.getRequest(),可以${pageContext.request}。也就是读取JavaBean属性!!!
EL表达式
说明
jsp、javabean、el第12张

EL函数库
1 什么EL函数库
EL函数库是由第三方对EL的扩展,我们现在学习的EL函数库是由JSTL添加的。JSTL明天再学!
EL函数库就是定义一些有返回值的静态方法。然后通过EL语言来调用它们!当然,不只是JSTL可以定义EL函数库,我们也可以自定义EL函数库。
EL函数库中包含了很多对字符串的操作方法,以及对集合对象的操作。例如:${fn:length(“abc”)}会输出3,即字符串的长度。
2 导入函数库
因为是第三方的东西,所以需要导入。导入需要使用taglib指令!
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
3 EL函数库介绍
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):hello-world, “-“
substringBefore(String input, String substring):hello-world, “-“
String escapeXml(String 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):
<%@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> -->
4 自定义EL函数库
写一个类,写一个有返回值的静态方法;
编写example.tld文件,可以参数fn.tld文件来写,把example.tld文件放到/WEB-INF目录下;
在页面中添加taglib指令,导入自定义标签库。
ExampleFuncations.java
package com.example.el.funcations;
public class ExampleFuncations {
public static String test() {
return "自定义EL函数库测试";
}
}
example.tld(放到classes下)
<?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>example</short-name>
<uri>http://www.example.com/jsp/functions</uri>
<function>
<name>test</name>
<function-class>com.example.el.funcations.ExampleFuncations</function-class>
<function-signature>String test()</function-signature>
</function>
</taglib>
index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="example" uri="/WEB-INF/example.tld" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body>
<h1>${example:test() }</h1>
</body>
</html>

免责声明:文章转载自《jsp、javabean、el》仅用于学习参考。如对内容有疑问,请及时联系本站处理。

上篇Snack3 一个新的微型JSON框架Resttemplateget带特殊字符调用 异常处理总结下篇

宿迁高防,2C2G15M,22元/月;香港BGP,2C5G5M,25元/月 雨云优惠码:MjYwNzM=

相关文章

docker 源码分析 一(基于1.8.2版本),docker daemon启动过程;

最近在研究golang,也学习一下比较火的开源项目docker的源代码,国内比较出名的docker源码分析是孙宏亮大牛写的一系列文章,但是基于的docker版本有点老;索性自己就git 了一下最新的代码研读; docker是c/s的架构,分为docker client 和 docker daemon,client端发送命令,daemon端负责完成clien...

[SpringBoot] SpringApplication.run 执行流程

作者:王奕然链接:https://www.zhihu.com/question/21346206/answer/101789659来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。建议不要硬着头皮看spring代码,本身的代码800多m,就是不上班开始看也不知道什么时候看完。如果想学学ioc,控制反转这些建议看看jodd项目,...

LinQ 多表查询

编辑器加载中... 1. oneTT有字段AA BB CC 2. twoTT有字段EE FF BB 两个表连接查询, List<MulTable> mul = (from a in _db.oneTTT join b in _db.twoTTT on...

.NET Core 常用加密和Hash工具NETCore.Encrypt

https://www.cnblogs.com/piscesLoveCc/p/7423205.html  前言  在日常开发过程中,不可避免的涉及到数据加密解密(Hash)操作,所以就有想法开发通用工具,NETCore.Encrypt就诞生了。目前NETCore.Encrypt只支持.NET Core ,工具包含了AES,DES,RSA加密解密,MD5...

【RabbitMQ】一文带你搞定springboot整合RabbitMQ涉及消息的发送确认,消息的消费确认机制,延时队列的实现

说明 这一篇里,我们将继续介绍RabbitMQ的高级特性,通过本篇的学习,你将收获: 什么是延时队列 延时队列使用场景 RabbitMQ中的TTL 如何利用RabbitMQ来实现延时队列 本文大纲 什么是延迟队列 延时队列,首先,它是一种队列,队列意味着内部的元素是有序的,元素出队和入队是有方向性的,元素从一端进入,从另一端取出。 其次,延时队列,最...

vb.net的数据类型

一,Numeric(数值型)数据类型 Integer 整型 4字节 变量存储为32位整数型,范围从-2147483.648至2147483.648 Long 长整型 8字节 变量存储为64位整数型,范围从-9223372036854775.808至9223372036854775.807 Short 短整型 2字节 变量存储为16位整数型,范围...