EL表达式取servlet中的对象总结
来源:互联网 发布:赵敏 情趣 知乎 编辑:程序博客网 时间:2024/06/08 05:27
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]EL的语法:- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]EL的语法:- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]EL的语法:- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码
比方说一个对象 Person 的 name属性
${person.name}或者${person["name"]}
两者是等价的。
记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code]
E表达式:
一、下面是第一个最简单的表达式例子:
建立servlet 文件,名称为:Hello.java 内容如下:
request.setAttribute("hello","hello");
request.getRequestDispatcher("index.ftp").forward(request,response);
建立index.ftp 文件,内容如下:
${hello}
二、作用域的访问对象
pageScope requestScope sessionScope applicationScope
获取的机制如何?
上面ftp的代码改写成:
${requestScope.hello}等价于${hello}
如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,
最终把结果返回
三、举例说明
先建立实体类
Student.java School.java
1、实例1
Hello.java
Student stu=new Student();
stu.setName("张三");
request.setAttribute("student",stu);
Index.jsp
${requestScope.student["name"]}或${requestScope.student.name}
2、实例2
Hello.java
School school=new School();
Student stu=new Student();
stu.setName("张三");
school.setStudent(stu);
request.setAttribute("school",school);
Index.jsp
${requestScope.school.student["name"]}或${requestScope.school.student.name}
3、实例3
Hello.java
ArrayList list=new ArrayList();
Student stu=new Student();
stu.setName("张三");
Student stu2=new Student();
stu2.setName("张三2");
list.add(stu);
list.add(stu2);
request.setAttribute("list",list);
Index.jsp
${requestScope.list["1"].name}
访问不同的对象实例:
1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,
Person person=new Person();
先request.setAttibute("person",person);
显示name :${person.name}
2.访问数组,利用下标直接访问
String s[]={"1","2"};
request.setAttribute("s",s);
显示s[1]
${s[1]}或者${s["1"]}
3.访问 List,直接用下标进行访问
ArrayList list=new ArrayList();
list.add("1");
list add("1");
request.setAttribute("list",list);
显示list[1]:
${list[1]}或者${list["1"]}
注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字
其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧
4.访问一个Map,用.或者[]访问
Map map=new Map();
map.put("one","no.1");
map.put("two","no.2");
request.setAttribute("map",map);
显示map("one"):
${map.one} 或者${map["one"]}
注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于
一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了
中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的
例如:
${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错
EL隐含对象
你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。
就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧
EL共有11个隐含对象
pageContext
对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问
ServletContext,Request,Response,Session,例如:
${pageContext.servletContext}
${pageContext.request}
${pageContext.response}
${pageContext.session}
pageScope
类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值
例如上面的person
${pageScope.person}
requestScope
类型是Map,用于直接获得请求访问内的属性值
例如
${requestScope,user}
sessionScope
跟上面的requestScope类似,只是范围不同,它是会话范围内的属性
例如
${sessionScope.user}
applicationScope
跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性
例如
${applicationScope.user}
param
类型是Map,就是请求中参数属性
例如 http://www.janeky.com/request.jsp?name=jiange
获得name
${param.name}
一个请求有多个参数值
paramValues
类型Map
例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2
${paramValues.name[0]}
${paramValues.name[1]}
headerValuess
用于获得请求报头的值,等同于调用ServletRequest.getHeader()
cookie
这个很好用。以前你在jsp中都是先 requst.getCookies();
for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]EL的语法:- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码 比方说一个对象 Person 的 name属性${person.name}或者${person["name"]}两者是等价的。记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code] E表达式:一、下面是第一个最简单的表达式例子:建立servlet 文件,名称为:Hello.java 内容如下:request.setAttribute("hello","hello");request.getRequestDispatcher("index.ftp").forward(request,response);建立index.ftp 文件,内容如下:${hello}二、作用域的访问对象pageScope requestScope sessionScope applicationScope获取的机制如何?上面ftp的代码改写成:${requestScope.hello}等价于${hello}如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,最终把结果返回三、举例说明先建立实体类Student.java School.java1、实例1Hello.javaStudent stu=new Student();stu.setName("张三");request.setAttribute("student",stu);Index.jsp${requestScope.student["name"]}或${requestScope.student.name}2、实例2Hello.javaSchool school=new School();Student stu=new Student();stu.setName("张三");school.setStudent(stu);request.setAttribute("school",school);Index.jsp${requestScope.school.student["name"]}或${requestScope.school.student.name}3、实例3Hello.javaArrayList list=new ArrayList();Student stu=new Student();stu.setName("张三");Student stu2=new Student();stu2.setName("张三2");list.add(stu);list.add(stu2);request.setAttribute("list",list);Index.jsp${requestScope.list["1"].name}访问不同的对象实例:1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,Person person=new Person();先request.setAttibute("person",person);显示name :${person.name}2.访问数组,利用下标直接访问String s[]={"1","2"};request.setAttribute("s",s);显示s[1]${s[1]}或者${s["1"]}3.访问 List,直接用下标进行访问ArrayList list=new ArrayList();list.add("1");list add("1");request.setAttribute("list",list);显示list[1]:${list[1]}或者${list["1"]}注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧4.访问一个Map,用.或者[]访问Map map=new Map();map.put("one","no.1");map.put("two","no.2");request.setAttribute("map",map);显示map("one"):${map.one} 或者${map["one"]}注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的例如:${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错EL隐含对象你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧EL共有11个隐含对象pageContext对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问 ServletContext,Request,Response,Session,例如:${pageContext.servletContext}${pageContext.request}${pageContext.response}${pageContext.session}pageScope类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值例如上面的person${pageScope.person}requestScope类型是Map,用于直接获得请求访问内的属性值例如${requestScope,user}sessionScope跟上面的requestScope类似,只是范围不同,它是会话范围内的属性例如${sessionScope.user}applicationScope跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性例如${applicationScope.user}param类型是Map,就是请求中参数属性例如 http://www.janeky.com/request.jsp?name=jiange获得name${param.name}一个请求有多个参数值paramValues类型Map 例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2${paramValues.name[0]}${paramValues.name[1]}headerValuess用于获得请求报头的值,等同于调用ServletRequest.getHeader()cookie这个很好用。以前你在jsp中都是先 requst.getCookies();for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码 比方说一个对象 Person 的 name属性${person.name}或者${person["name"]}两者是等价的。记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code] E表达式:一、下面是第一个最简单的表达式例子:建立servlet 文件,名称为:Hello.java 内容如下:request.setAttribute("hello","hello");request.getRequestDispatcher("index.ftp").forward(request,response);建立index.ftp 文件,内容如下:${hello}二、作用域的访问对象pageScope requestScope sessionScope applicationScope获取的机制如何?上面ftp的代码改写成:${requestScope.hello}等价于${hello}如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,最终把结果返回三、举例说明先建立实体类Student.java School.java1、实例1Hello.javaStudent stu=new Student();stu.setName("张三");request.setAttribute("student",stu);Index.jsp${requestScope.student["name"]}或${requestScope.student.name}2、实例2Hello.javaSchool school=new School();Student stu=new Student();stu.setName("张三");school.setStudent(stu);request.setAttribute("school",school);Index.jsp${requestScope.school.student["name"]}或${requestScope.school.student.name}3、实例3Hello.javaArrayList list=new ArrayList();Student stu=new Student();stu.setName("张三");Student stu2=new Student();stu2.setName("张三2");list.add(stu);list.add(stu2);request.setAttribute("list",list);Index.jsp${requestScope.list["1"].name}访问不同的对象实例:1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,Person person=new Person();先request.setAttibute("person",person);显示name :${person.name}2.访问数组,利用下标直接访问String s[]={"1","2"};request.setAttribute("s",s);显示s[1]${s[1]}或者${s["1"]}3.访问 List,直接用下标进行访问ArrayList list=new ArrayList();list.add("1");list add("1");request.setAttribute("list",list);显示list[1]:${list[1]}或者${list["1"]}注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧4.访问一个Map,用.或者[]访问Map map=new Map();map.put("one","no.1");map.put("two","no.2");request.setAttribute("map",map);显示map("one"):${map.one} 或者${map["one"]}注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的例如:${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错EL隐含对象你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧EL共有11个隐含对象pageContext对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问 ServletContext,Request,Response,Session,例如:${pageContext.servletContext}${pageContext.request}${pageContext.response}${pageContext.session}pageScope类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值例如上面的person${pageScope.person}requestScope类型是Map,用于直接获得请求访问内的属性值例如${requestScope,user}sessionScope跟上面的requestScope类似,只是范围不同,它是会话范围内的属性例如${sessionScope.user}applicationScope跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性例如${applicationScope.user}param类型是Map,就是请求中参数属性例如 http://www.janeky.com/request.jsp?name=jiange获得name${param.name}一个请求有多个参数值paramValues类型Map 例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2${paramValues.name[0]}${paramValues.name[1]}headerValuess用于获得请求报头的值,等同于调用ServletRequest.getHeader()cookie这个很好用。以前你在jsp中都是先 requst.getCookies();for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码 比方说一个对象 Person 的 name属性${person.name}或者${person["name"]}两者是等价的。记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code] E表达式:一、下面是第一个最简单的表达式例子:建立servlet 文件,名称为:Hello.java 内容如下:request.setAttribute("hello","hello");request.getRequestDispatcher("index.ftp").forward(request,response);建立index.ftp 文件,内容如下:${hello}二、作用域的访问对象pageScope requestScope sessionScope applicationScope获取的机制如何?上面ftp的代码改写成:${requestScope.hello}等价于${hello}如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,最终把结果返回三、举例说明先建立实体类Student.java School.java1、实例1Hello.javaStudent stu=new Student();stu.setName("张三");request.setAttribute("student",stu);Index.jsp${requestScope.student["name"]}或${requestScope.student.name}2、实例2Hello.javaSchool school=new School();Student stu=new Student();stu.setName("张三");school.setStudent(stu);request.setAttribute("school",school);Index.jsp${requestScope.school.student["name"]}或${requestScope.school.student.name}3、实例3Hello.javaArrayList list=new ArrayList();Student stu=new Student();stu.setName("张三");Student stu2=new Student();stu2.setName("张三2");list.add(stu);list.add(stu2);request.setAttribute("list",list);Index.jsp${requestScope.list["1"].name}访问不同的对象实例:1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,Person person=new Person();先request.setAttibute("person",person);显示name :${person.name}2.访问数组,利用下标直接访问String s[]={"1","2"};request.setAttribute("s",s);显示s[1]${s[1]}或者${s["1"]}3.访问 List,直接用下标进行访问ArrayList list=new ArrayList();list.add("1");list add("1");request.setAttribute("list",list);显示list[1]:${list[1]}或者${list["1"]}注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧4.访问一个Map,用.或者[]访问Map map=new Map();map.put("one","no.1");map.put("two","no.2");request.setAttribute("map",map);显示map("one"):${map.one} 或者${map["one"]}注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的例如:${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错EL隐含对象你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧EL共有11个隐含对象pageContext对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问 ServletContext,Request,Response,Session,例如:${pageContext.servletContext}${pageContext.request}${pageContext.response}${pageContext.session}pageScope类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值例如上面的person${pageScope.person}requestScope类型是Map,用于直接获得请求访问内的属性值例如${requestScope,user}sessionScope跟上面的requestScope类似,只是范围不同,它是会话范围内的属性例如${sessionScope.user}applicationScope跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性例如${applicationScope.user}param类型是Map,就是请求中参数属性例如 http://www.janeky.com/request.jsp?name=jiange获得name${param.name}一个请求有多个参数值paramValues类型Map 例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2${paramValues.name[0]}${paramValues.name[1]}headerValuess用于获得请求报头的值,等同于调用ServletRequest.getHeader()cookie这个很好用。以前你在jsp中都是先 requst.getCookies();for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code]
- EL的语法:
- 比如: request.setAttibute("person",Person);
- 在JSP页面中如何访问person呢?
- <html>
- <body>
- the person is: ${person}
- </body>
- </html>
- 如何访问一个对象的属性呢?
复制代码 比方说一个对象 Person 的 name属性${person.name}或者${person["name"]}两者是等价的。记住"."能做到的,"[]"也能做到。反过来可就不一定了[/code] E表达式:一、下面是第一个最简单的表达式例子:建立servlet 文件,名称为:Hello.java 内容如下:request.setAttribute("hello","hello");request.getRequestDispatcher("index.ftp").forward(request,response);建立index.ftp 文件,内容如下:${hello}二、作用域的访问对象pageScope requestScope sessionScope applicationScope获取的机制如何?上面ftp的代码改写成:${requestScope.hello}等价于${hello}如果明确访问对象,直接到访问对象中找,否则就从最小的作用域开始找直到applicationScope,最终把结果返回三、举例说明先建立实体类Student.java School.java1、实例1Hello.javaStudent stu=new Student();stu.setName("张三");request.setAttribute("student",stu);Index.jsp${requestScope.student["name"]}或${requestScope.student.name}2、实例2Hello.javaSchool school=new School();Student stu=new Student();stu.setName("张三");school.setStudent(stu);request.setAttribute("school",school);Index.jsp${requestScope.school.student["name"]}或${requestScope.school.student.name}3、实例3Hello.javaArrayList list=new ArrayList();Student stu=new Student();stu.setName("张三");Student stu2=new Student();stu2.setName("张三2");list.add(stu);list.add(stu2);request.setAttribute("list",list);Index.jsp${requestScope.list["1"].name}访问不同的对象实例:1.访问一个普通的java bean, 假设 一个对象 Person 有name属性,Person person=new Person();先request.setAttibute("person",person);显示name :${person.name}2.访问数组,利用下标直接访问String s[]={"1","2"};request.setAttribute("s",s);显示s[1]${s[1]}或者${s["1"]}3.访问 List,直接用下标进行访问ArrayList list=new ArrayList();list.add("1");list add("1");request.setAttribute("list",list);显示list[1]:${list[1]}或者${list["1"]}注意:这里你可能会举得奇怪,为什么数组和list下标可以用数字或者引号加数字其实在解析的时候,[]里面的索引都是被强制转成int的,索引随便你加不加引号吧4.访问一个Map,用.或者[]访问Map map=new Map();map.put("one","no.1");map.put("two","no.2");request.setAttribute("map",map);显示map("one"):${map.one} 或者${map["one"]}注意:这里千万不能用 ${map[one]} 因为下标里面的东西如果不加引号,它就相当于一个属性,容器编译的时候就会去寻找one属性,相当于${one},找不到,当然就错了中括号里面是可以嵌套表达式的,但是,中括号里面的表达式是去掉${}的例如:${test1[test2[2]] 正确 而 ${test1[${test2[2]}]编译报错EL隐含对象你可能又会问什么事隐含对象?隐式对象就是事先准备好的,你可以直接访问,不必知道是怎么来的。就跟JSP中的隐含对象 request,response一样, 你直接用就行,没人会说你的,放心吧EL共有11个隐含对象pageContext对应于 javax,servlet.jsp.PageContext对象,利用 pageContext,可以访问 ServletContext,Request,Response,Session,例如:${pageContext.servletContext}${pageContext.request}${pageContext.response}${pageContext.session}pageScope类型是Map,将页面范围内的属性名和它的值进行映射。主要是用于获取页面范围的属性值例如上面的person${pageScope.person}requestScope类型是Map,用于直接获得请求访问内的属性值例如${requestScope,user}sessionScope跟上面的requestScope类似,只是范围不同,它是会话范围内的属性例如${sessionScope.user}applicationScope跟上面的requestScope类似,只是范围不同,它是应用程序范围内的属性例如${applicationScope.user}param类型是Map,就是请求中参数属性例如 http://www.janeky.com/request.jsp?name=jiange获得name${param.name}一个请求有多个参数值paramValues类型Map 例如 http://www.janeky.com/request.jsp?name=jiange&name=jiange2${paramValues.name[0]}${paramValues.name[1]}headerValuess用于获得请求报头的值,等同于调用ServletRequest.getHeader()cookie这个很好用。以前你在jsp中都是先 requst.getCookies();for()cookies.getName().equal("name");
现在一句话就搞定了
${cookie.name.value}
initParam
用于访问上下文的初始化参数。在web.xml中<context-param>
等价于 application.getInitParameter("");
命名变量的查找
你有时偷懒,直接${name}
这时候程序就忙了,它按照page,request,session,application范围帮你找
很多时候命名冲突就麻烦了。你最好限定范围
${requestScope.name}
EL还可以进行简单的运算操作呢
算术运算
+
-
*
/(或者div) ${3/2}或者${3div2} //主要这里的两个操作数都会被强制转型double,结果是1.5
%(或者mod)
逻辑运算
&&(或者and) ||(或者or)!(或者not)
关系操作符
== eq
!= ne
< lt
> gt
<= le
>= ge
还觉得EL不够强大,那自己去定义函数吧。个人觉得这样没必要。还是把方法告之一下
1.编写有一个公共静态方法的Java类
2.编写一个标记库描述文件(Tag Library Descriptor,TLD)
3.在JSP中放一个taglib指令
4使用EL调用函数[/code] 0 0