Java进阶学习第十二天——JSP JavaBean EL

最新推荐文章于 2023-03-26 15:14:32 发布

鹿天斐

最新推荐文章于 2023-03-26 15:14:32 发布

阅读量2k

点赞数 1

分类专栏： Java Java进阶文章标签： Java进阶 JSP JavaBean 内省技术 EL表达式

本文链接：https://blog.csdn.net/lutianfeiml/article/details/51354921

版权

Java 同时被 2 个专栏收录

74 篇文章 2 订阅

订阅专栏

Java进阶

41 篇文章 1 订阅

订阅专栏

文档版本	开发工具	测试平台	工程名字	日期	作者	备注
V1.0				2016.05.04	lutianfei	none

session（拓展）

session的追踪（了解）

session的创建和销毁

创建session : 第一次访问资源，调用request.getSession()
session销毁的三种方法:
- 非正常关闭服务器
- session的过期，默认是30分钟。(tomcat/conf/web.xml)

        <session-config>
        <session-timeout>30</session-timeout>
        </session-config>

* 调用session.invalidate() 手动销毁session

session的域对象
- ServlerContext ：代表整个web应用，数据库链接
- session ：一次会话，存放个人的信息。
- request ：一次请求，存放错误处理。

JSP

JSP概述

JSP(Java Server Pages)与Java Servlet一样，是在服务器端执行的
- 不同的是先由服务器编译部署成Servlet执行
JSP技术的企业最佳实践
- 生成html内容
新的JSP2.0规范版本包括新的功能
- EL表达式

JSP的设置

设置JSP文件的打开方式：window –> preferences –> General –> Editors –> File Associations –> *.jsp – 选择MyEclipse JSP Editor – default
设置JSP文件的编码：window –> preferences–> 搜索JSP –> 找到JSP –> 选择UTF-8

JSP页面的注释

HTML的注释  JSP文件的阶段存在，在翻译成java文件也存在，在页面存在
JAVA的注释 JSP文件的阶段存在，在翻译成java文件也存在，在页面不存在
JSP的注释 <%-- JSP的注释 --%> 只会存在JSP文件的阶段，编译阶段消失。

JSP的指令元素

功能
- 用于指示JSP执行某些步骤
- 用于指示JSP表现特定行为
语法：<%@ 指令元素属性名=属性值 %> : <%@ directive [ attribute =“value” ] %>
分类
- page指令标记，设置JSP的属性
- include指令标记，包含页面
- taglib指令标记：引入标签库文件

page指令标记

page属性包含在<%@ page和%>之间。
这些属性可以单独使用，也可以几个或多个同时使用
page指令用来定义JSP文件的全局属性
在JSP页面中，只有import可以出现多次，其它属性都只能出现一次
属性：
- language ：JSP文件允许嵌入的语言。只支持一种JAVA语言。（不需要改变）
- extends ：JSP翻译成Servlet文件，servlet继承的类。（不需要改变）
- session ：默认值是true，可以直接使用session。设置false，不能直接使用。
- import ：引入java的jar包（使用多次）
- buffer ：设置缓冲区的大小默认8kb
- aotoFlush ：设置默认刷新缓冲区（不要修改）
- errorPage ：指定错误页面
- isErrorPage ：设置值，可以是exception对象，设置true，使用exception，设置false不能使用exception对象
- contentType ：服务器端输出所有内容采用编码。
- pageEncoding ：JSP翻译成Servlet文件时采用的编码。
- isELIgnored ：是否忽略EL表达式（false，不忽略，true，忽略）
- 重点：
  - session import contentType pageEncoding isELIgnored

配置全局的错误页面
在web.xml中进行配置。

<error-page>
<error-code>404</error-code>
<location>/404.jsp</location>
 </error-page>

 <error-page>
<error-code>500</error-code>
<location>/500.jsp</location>
 </error-page>

page指令练习

<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" session="true" buffer="8kb" autoFlush="true" 
    errorPage="/jsp/error.jsp" isELIgnored="false"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>

<h4>欢迎</h4>

<%
    List list = new ArrayList();    
    // int a = 10 / 0;
    request.setAttribute("username", "小风");
%>

<!-- HTML的文本 -->
${ username }

</body>
</html>

include指令标记

include指令的语法<%@ include file=“filename” %>
include指令的作用是在JSP页面中静态包含一个文件，同时由JSP解析包含的文件内容
静态包含的含义
- file不能为变量
  - <% String url="index.html" ; %>
  - <%@ include file = "<%= url %>" %>
- 不可以在file 所指定的文件后接任何参数
  - <%@ include file = "jw.jsp?nm=browser" %>

静态包含举例
- 包含的是目标文件的源码；包含过来，一起翻译

//head.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<h3>网站的LOGO</h3>

//

//menu.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <h3>网站的超链接</h3>

///

//foot.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<h3>网站的友情链接</h3>

//

//body.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>    

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>

<%@ include file="/include/head.jsp" %>
<%@ include file="/include/menu.jsp" %>
    <h3>网站的新闻（数据变化）</h3>
<%@ include file="/include/foot.jsp" %>


</body>
</html>

taglib指令标记

Taglib指令用于在JSP页面中导入标签库
常用标签库JSTL
常用属性
- uri 标签文件的URI地址
- prefix 标签组的命名空间前缀
- 语法：<%taglib %>

JSP的内置对象（9个）

request response session application out pageContext page config exception

内置对象	真实的对象	方法
request	HttpServletRequest	setAttribute() getAttribute()
response	HttpServletResponse	addCookie() getWriter()
session	HttpSession	setAttribute() getAttribute()
application	ServletContext	setAttribute() getAttribute()
config	ServletConfig	getInitParameter() getInitParameterNames()
exception	Throwable	getMessage()
page	this(HttpServlet)Object	（不使用对象）
out	JspWriter	write() print()
pageContext	PageContext	setAttribute() getAttribute()

exception对象

exception对象是java.lang.Trowable类的实例
前提条件：isErrorPage="true"，才能使用exception对象。
exception对象用来处理JSP文件在执行时所有发生的错误和异常
exception对象可以和page指令一起使用，通过指定某一个页面为错误处理页面，对错误进行处理<%@ page isErrorPage=”true “%>的页面内使用

page对象

当前页面的对象。
“page” 对象代表了正在运行的由JSP文件产生的类对象【一般不建议使用】
page对象是指向当前JSP程序本身的对象this
page对象其实是java.lang.Object类的实例对象

out对象

向客户端输出数据
管理服务器输出缓冲区
内部使用PrintWriter对象来输出文本级数据
通过page指令的buffer属性来调整缓冲区的大小，默认的缓冲区是8kb
举例：


<%= "HELLO" %>
<% out.print("AAAA"); %>
<% response.getWriter().print("BBBB"); %>
<% out.print("CCCC"); %>
* 输出结果：
 //BBBB HEELO AAAA CCCC

out隐式对象的工作原理图

pageContext对象

pageContext对象可以直译为“页面上下文”对象，代表的是当前页面运行的一些属性。
它是javax.servlet.jsp.PageContext类的实例对象，可以使用PageContext类的方法。pageContext对象提供了对JSP页面所有的对象及命名空间的访问。
pageContext对象提供了page范围的存取方法
pageContext也是域对象，代表当前的页面范围，在当前的页面范围内获取数据。
向JSP的四个作用域范围内存数据。
- Servlet中有三个域，而JSP有四个域。
- JSP中多了pageContext的域范围，代表当前页面范围。
获取其他8个内置对象。
- 编写框架、通用性较高的代码。
pageContext中的方法:
- setAttribute(String name, Object value)
- setAttribute(String name, Object value, int scope)
- getAttribute(String name)
- getAttribute(String name, int scope)
- removeAttribute(String name)
- removeAttribute(String name, int scope)
- findAttribute(String name)
JSP的四种数据范围
- ServletContext 整个web应用
  - application 应用范围
- session 一次会话,会话范围
- request 一次请求,请求范围
- pageContext 当前页面,page范围
通过pageContext获得其他对象(默认从最小的域开始取)
- getException方法返回exception隐式对象
- getPage方法返回page隐式对象
- getRequest方法返回request隐式对象
- getResponse方法返回response隐式对象
- getServletConfig方法返回config隐式对象
- getServletContext方法返回application隐式对象
- getSession方法返回session隐式对象
- getOut方法返回out隐式对象
- pageContext封装其它8大内置对象的意义，思考：如果在编程过程中，把pageContext对象传递给一个普通java对象，那么这个java对象将具有什么功能？

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>

<%=request.getParameter("username") %>

<h4>pageContext向其他域中存入值</h4>    
<%
    pageContext.setAttribute("name", "美美");
    // 下面这句等价于上面
    pageContext.setAttribute("name", "美美", pageContext.PAGE_SCOPE);

    request.setAttribute("name", "小凤");
    // 向request域中存入值
    pageContext.setAttribute("name", "小凤", pageContext.REQUEST_SCOPE);

    // 向session域存入值
    pageContext.setAttribute("name", "小苍", pageContext.SESSION_SCOPE);
    // 向ServletContext域存入值
    pageContext.setAttribute("name", "小班长", pageContext.APPLICATION_SCOPE);

%>

<%= pageContext.getAttribute("name", pageContext.SESSION_SCOPE)%>
<%= session.getAttribute("name") %>


${ pageScope.name }
${ requestScope.name }
${ sessionScope.name }
${ applicationScope.name }

</body>
</html>

JSP的标签

JSP标签也称之为Jsp Action(JSP动作)元素，它用于在Jsp页面中提供业务逻辑功能，避免在JSP页面中直接编写java代码，造成jsp页面难以维护。

JSP常用标签

把数据封装到JavaBean中（JSP页面中完成）
- <jsp:useBean> 使用一个ID和一个给定作用范围和同一ID的JavaBean相关联
- <jsp:setProperty> 设置JavaBean的属性值
- <jsp:getProperty> 取得JavaBean的属性值
<jsp:include> 页面的包含（服务器端路径，没有项目名称）
- 属性：page 要包含的页面
<jsp:forward> 在JSP的页面中完成转发（服务器端路径，没有项目名称）
- 属性：page 要转发的页面
<jsp:param> 传递参数，需要写在<jsp:forward>的中间
- 属性：name：参数名称 value：参数值

动态包含原理

指令 `<jsp:forward>`和`<jsp:param>`

将请求传递给另一个JSP页面（转发）。<jsp:forward page=“转发路径”} />
<jsp:param>用来传递参数，可以写在<jsp:forward>中间,可以使用request.getParameter();来接收参数
param，forward 练习

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>

<h4>JSP的动作标签</h4>
<jsp:forward page="/jsp/pageContext.jsp">
    <jsp:param name="username" value="meimei"/>
</jsp:forward>

</body>
</html>

在Servlet中如果使用request.getRequestDispatcher.forward进行页面跳转，那么该语句以后的代码会执行：
request.getRequestDispatcher.forward(“XXX”);
System.out.println(“It can execute…”);
但是JSP中<jsp:forward>后面的代码不会执行，因为翻译的时候，Serlvet容器自动为<jsp:forward>后面添加了return语句。

<%
    String s=request.getRemoteAddr();
    if(s.startsWith("10.28.176.",0)){
%>
    <jsp:forward page="index_inner.jsp"/>
    <%}else{ %>
    <jsp:forward page="index_outter.jsp"/>
<%
    }
%>

`<jsp:include>`与`include`指令的比较

<jsp:include>标签是动态引入， <jsp:include>标签涉及到的2个JSP页面会被翻译成2个servlet，这2个servlet的内容在执行时进行合并。
而include指令是静态引入，涉及到的2个JSP页面会被翻译成一个servlet，其内容是在源文件级别进行合并。
不管是<jsp:include>标签，还是include指令，它们都会把两个JSP页面内容合并输出，所以这两个页面不要出现重复的HTML全局架构标签，否则输出给客户端的内容将会是一个格式混乱的HTML文档。
两种include用法的区别
主要有两个方面的不同：
- 一、执行时间上：
  - <%@?include?file=“relativeURI”%>是在翻译阶段执行；
  - <jsp:include?page=“relativeURI”?flush=“true”?/>在请求处理阶段执行。
- 二、引入内容的不同：
  - <%@?include?file=“relativeURI”%>引入静态文本(html,jsp)，在JSP页面被转化成servlet之前和它融和到一起。
  - <jsp:include?page=“relativeURI”?flush=“true”?/>引入执行页面或servlet所生成的应答文本。
- 另外在两种用法中file和page属性都被解释为一个相对的URI。如果它以斜杠/开头，那么它就是一个环境相关的路径，将根据赋给应用程序的URI的前缀进行解释；如果它不是以斜杠开头，那么就是页面相关的路径，就根据引入这个文件的页面所在的路径进行解释。

<!-- index.jsp --> 无法编译
<%
    int num = 100;
    if (num > 10) {
%>
<%@ include file="a.jsp"%>
<% } else { %>
<%@ include file="b.jsp"%>
<% } %> 一起编译执行


<!-- index.jsp --> 显示正常a.jsp
<%
    int num = 100;
    if (num > 10) {
%>
<jsp:include page="a.jsp" />
<% } else { %>
<jsp:include page="b.jsp" />
<% } %> else无法执行


<!-- b.jsp  是一个有错误-->
<%=new  java.util.Date()<u style="text-underline:single">;</u> %>

指令`<jsp:forward>`

将请求传递给另一个JSP页面。

<jsp:forward page={"relativeURL" | "<%= expression %>"} />

<jsp:forward page={"relativeURL" | "<%= expression %>"} >
    <jsp:param name="PN" value="{PV | <%= expression %>"}/> *
</jsp:forward>

<jsp:forward>之后的代码不执行

JavaBean和内省

什么是JavaBean？

JavaBean是一个遵循特定写法的Java类，它通常具有如下特点：
- 这个Java类必须具有一个无参的构造函数
- 属性私有化。
- 私有化的属性必须通过public类型的方法暴露给其它程序，并且方法的命名也必须遵守一定的命名规范。

public class User(){
    private String username;
    private String password;
    public void setUsername(){

    }
    public void getUsername(){

    }
    public void getPassword(){

    }
    public void getInfo(){

    }
}

作用：
- JavaBean在J2EE开发中，通常用于封装数据，对于遵循以上写法的JavaBean组件，其它程序可以通过反射技术实例化JavaBean对象，并且通过反射那些遵守命名规范的方法，从而获知JavaBean的属性，进而调用其属性保存数据。
把数据封装到JavaBean中（JSP页面中完成的）

<jsp:useBean id="u" class="cn.itcast.vo.User"></jsp:useBean>
<jsp:setProperty property="username" name="u"/>
<jsp:setProperty property="password" name="u"/>
或者
<jsp:setProperty property="*" name="u"/>


<jsp:getProperty property="username" name="u"/>
<jsp:getProperty property="password" name="u"/>

JavaBean的属性

JavaBean的属性可以是任意类型，并且一个JavaBean可以有多个属性。每个属性通常都需要具有相应的setter、 getter方法，setter方法称为属性修改器，getter方法称为属性访问器。
属性修改器必须以小写的set前缀开始，后跟属性名，且属性名的第一个字母要改为大写
- 例如，name属性的修改器名称为setName，password属性的修改器名称为setPassword。
属性访问器通常以小写的get前缀开始，后跟属性名，且属性名的第一个字母也要改为大写
- 例如，name属性的访问器名称为getName，password属性的访问器名称为getPassword。
一个JavaBean的某个属性也可以只有set方法或get方法，这样的属性通常也称之为只写、只读属性。

在JSP中使用JavaBean

JSP技术提供了三个关于JavaBean组件的动作元素，即JSP标签，它们分别为：
<jsp:useBean>标签：用于在JSP页面中查找或实例化一个JavaBean组件。
<jsp:setProperty>标签：用于在JSP页面中设置一个JavaBean组件的属性。
<jsp:getProperty>标签：用于在JSP页面中获取一个JavaBean组件的属性。
编写表单页面，把数据提交到另一个JSP的页面，可以使用传统方式封装数据，也可以使用<jsp:userBean>来封装数据。
设置属性是<jsp:setProperty name=“u” property=“*”> : * 代表所有的属性

`<jsp:useBean>`标签

<jsp:useBean>标签用于在指定的域范围内查找指定名称的JavaBean对象：
- 如果存在则直接返回该JavaBean**对象的引用**。
- 如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。
常用语法：<jsp:useBean id="beanName" class="cn.itcast.Test" scope="page|request|session|application"/>
id属性用于指定JavaBean实例对象的引用名称和其存储在域范围中的名称。
class属性用于指定JavaBean的完整类名（即必须带有包名）。
scope属性用于指定JavaBean实例对象所存储的域范围，其取值只能是page、request、session和application等四个值中的一个，其默认值是page。

`<jsp:useBean>`执行原理


<jsp:useBean id="currentDate" class="java.util.Date"/>

//翻译成的Servlet源码：
java.util.Date currentDate = null;
synchronized (_jspx_page_context) {
    currentDate = (java.util.Date)_jspx_page_context.getAttribute(
                "currentDate", PageContext.PAGE_SCOPE);
    if (currentDate == null){
        currentDate = new java.util.Date();
        _jspx_page_context.setAttribute("currentDate",
                currentDate, PageContext.PAGE_SCOPE);
    }
}

带标签体的`<jsp:useBean>`标签

语法：

    <jsp:useBean ...>
        Body
    </jsp:useBean>

功能：
- Body部分的内容只在<jsp:useBean>标签创建JavaBean的实例对象时才执行。

`<jsp:setProperty>`标签

<jsp:setProperty>标签用于设置和访问JavaBean对象的属性。
语法格式：

<jsp:setProperty name="beanName" 
{ 
    property="propertyName" value="{string | <%= expression %>}" |
    property="propertyName" [ param="parameterName" ] | 
    property= "*" 
}/>

name属性用于指定JavaBean对象的名称。
property属性用于指定JavaBean实例对象的属性名。
value属性用于指定JavaBean对象的某个属性的值，value的值可以是字符串，也可以是表达式。为字符串时，该值会自动转化为JavaBean属性相应的类型，如果value的值是一个表达式，那么该表达式的计算结果必须与所要设置的JavaBean属性的类型一致。
param属性用于将JavaBean实例对象的某个属性值设置为一个请求参数值，该属性值同样会自动转换成要设置的JavaBean属性的类型。

`<jsp:getProperty>`标签

<jsp:getProperty>标签用于读取JavaBean对象的属性，也就是调用JavaBean对象的getter方法，然后将读取的属性值转换成字符串后插入进输出的响应正文中。
语法：<jsp:getProperty name="beanInstanceName" property="PropertyName" />
- name属性用于指定JavaBean实例对象的名称，其值应与<jsp:useBean>标签的id属性值相同。
- property属性用于指定JavaBean实例对象的属性名。
- 如果一个JavaBean实例对象的某个属性的值为null，那么，使用<jsp:getProperty>标签输出该属性的结果将是一个内容为“null”的字符串。

内省（Introspector）

访问JavaBean属性的两种方式：
- 直接调用bean的setXXX或getXXX方法。
- 通过内省技术访问(java.beans包提供了内省的API)
  - 内省技术是基于反射技术的
  - 通过Introspector类获得Bean对象的 BeanInfo，然后通过 BeanInfo 来获取属性的描述器（ PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter方法，然后通过反射机制来调用这些方法。

@Test
public void run() throws Exception{
User user = new User();
// 获取类的信息
BeanInfo info = Introspector.getBeanInfo(user.getClass());
// 获取属性的描述
PropertyDescriptor [] pds = info.getPropertyDescriptors();
// 循环遍历，获取属性的名称
for (PropertyDescriptor pd : pds) {
// System.out.println(pd.getName());
if(!"class".equals(pd.getName())){
// 获取写的方法
Method m = pd.getWriteMethod();
m.invoke(user, "admin");
}
}

System.out.println(user.getUsername());
System.out.println(user.getPassword());
}

beanutils工具包

Apache组织开发了一套用于操作JavaBean的API，这套API考虑到了很多实际开发中的应用场景，因此在实际开发中很多程序员使用这套API操作JavaBean，以简化程序代码的编写。
Beanutils工具包的常用类：
- BeanUtils
  - populate(Object bean, Map properties)
- 自定义转换器
  - ConvertUtils.regsiter(Converter convert, Class clazz)
  - 传入日期类型的Date.class
导入jar包,放在WEB-INF–>lib目录下
- commons-beanutils-1.8.3.jar
- commons-logging-1.1.1.jar
把字符串转换成日期类型
- 编写一个类，实现Converter接口。重写该方法。eg：把字符串转换日期。
- 在封装数据之前进行注册。
- ConvertUtils.register(Converter converter, Class clazz) Date.class

/**
 * 字符串转换日期类
 * @author Administrator
 *
 */
public class MyDateConverter implements Converter{

    /**
     * 字符串转换成日期
     */
    public Object convert(Class clazz, Object obj) {
        // 把输入的字符串，转换成日期类型，返回
        String dDate = (String) obj;
        // 把字符串转换成日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date;
        try {
            date = sdf.parse(dDate);
        } catch (ParseException e) {
            e.printStackTrace();
            throw new RuntimeException("转换日期错误");
        }
        return date;
    }

}

UserBeanUtilServlet类

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获取数据
        Map<String, String []> map = request.getParameterMap();
        // 创建User对象
        User user = new User();

        // 完成注册
        ConvertUtils.register(new MyDateConverter(), Date.class);

        // 完成封装
        try {
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        // 打印
        System.out.println(user.getUsername());
        System.out.println(user.getPassword());
        System.out.println(user.getMoney());
        System.out.println(user.getBirthday());
    }

EL表达式

EL表达式简介

语法：${ }
EL 全名为Expression Language。EL主要作用：
获取数据：
- EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域中检索java对象、获取数据。(某个web域中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)
执行运算：
- 利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。${user==null}
获取web开发常用对象
- EL 表达式定义了一些隐式对象，利用这些隐式对象，web开发人员可以很轻松获得对web常用对象的引用，从而获得这些对象中的数据。
调用Java方法
- EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。

EL注意事项

EL表达式是JSP 2.0(JavaEE1.4)规范中的一门技术。因此，若想正确解析EL表达式，需使用支持Servlet2.4/JSP2.0技术的WEB服务器。
注意：有些Tomcat服务器如不能使用EL表达式
- （1）升级成tomcat6
- （2）在JSP中加入<%@ page isELIgnored="false" %>

* EL获取（域对象中的）数据*

使用EL表达式获取数据语法：${标识符}
EL表达式语句在执行时，会调用pageContext.findAttribute方法，用标识符为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回（注意，不是null，而是空字符串）。
示例：${user}
EL表达式也可以很轻松获取JavaBean的属性，或获取数组、Collection、Map类型集合的数据，例如：
- ${user.address.city}
- ${user.list[0]}：访问有序集合某个位置的元素
- ${map.key} ：获得map集合中指定key的值
. 和 [ ] 区别
结合JSTL的foreach标签，使用EL表达式也可以很轻松迭代各种类型的数组或集合，示例：
- 迭代数组
- 迭代collection类型集合
- 迭代map类型集合

<h4>获取域对象中的值</h4>
<%
pageContext.setAttribute("name", "黄海波");
request.setAttribute("name", "美美");
%>

${ pageScope.name }
${ requestScope.name }



<h4>域中数组的值</h4>
<%
String [] arrs = {"美美","波波","东东","名名"};
request.setAttribute("arrs", arrs);
%>
${ arrs[2] }



<h4>域中集合的值</h4>
<%
List<String> list = new ArrayList<String>();
list.add("美美");
list.add("小凤");
list.add("芙蓉");
request.setAttribute("list", list);
%>
${ list[1] }


<h4>域中Map集合的值</h4>
<%
Map<String,String> map = new HashMap<String,String>();
map.put("aa", "美美");
map.put("bb", "小凤");
request.setAttribute("map", map);
%>
${ map.bb }



<h4>域中集合中有对象的值</h4>
<%
List<User2> uList = new ArrayList<User2>();
uList.add(new User2("banzhang","123"));
uList.add(new User2("美美","abc"));
request.setAttribute("uList", uList);
%>
${ uList[1].username }

EL执行运算

语法：${运算表达式}，EL表达式支持如下运算符：
empty运算符：检查对象是否为null或“空”
二元表达式：${user!=null?user.name : “”}

<h4>加法运算</h4>
${ n1 + n2 }


<h3>关系运算</h3>
<h4>大于</h4>
${ n1 > n2 } 或者 ${ n1 gt n2 }

<h4>小于</h4>
${ n1 < n2 } 或者 ${ n1 lt n2 }

<h4>等于</h4>
${ n1 == n2 } 或者 ${ n1 eq n2 }


<h4>不等于</h4>
${ n1 != n2 } 或者 ${ n1 ne n2 }


<h4>大于等于</h4>
${ n1 >= n2 } 或者 ${ n1 ge n2 }


<h4>小于等于</h4>
${ n1 <= n2 } 或者 ${ n1 le n2 }


<h3>逻辑运算</h3>
<h4>与</h4>
${ n1 > n2 && n3 > n4 } 或者 ${ n1 > n2 and n3 > n4 }


<h4>或</h4>
${ n1 > n2 || n3 > n4 } 或者 ${ n1 > n2 or n3 > n4 }


<h4>非</h4>
${ !(n1 > n2) } 或者 ${ not (n1 > n2) }

EL表达式保留关键字

所谓保留字的意思是指变量在命名时，应该避开上述的名字，以免程序编译时发生错误

获取WEB开发中的对象

EL表达式语言中定义了11个隐含对象，使用这些隐含对象可以很方便地获取web开发中的一些常见对象，并读取这些对象的数据。
语法：${隐式对象名称} ：获得对象的引用

param 获取请求的参数 getParameter()
paramValues 获取请求的参数 getParameterValues()
header 获取请求头的信息
headerValues 获取请求头的信息
initParam 获取全局的初始化参数
cookie 获取cookie
pageContext
测试各个隐式对象
注意事项
- 测试headerValues时，如果头里面有- ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
- 测试cookie时，例${cookie.key}取的是cookie对象，如访问cookie的名称和值，须${cookie.key.name}或${cookie.key.value}

<h4>EL的WEB对象</h4>
${ param.username }


<h4>获取请求头</h4>
${ header.referer }

<h4>获取全局初始化参数</h4>
${ initParam.username }

<h4>pageContext对象</h4>
${ pageContext.request.contextPath }