黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】EL&JSTL与MVC初识 [打印本页]
作者: 厦门校区 时间: 2018-6-8 18:13
标题: 【厦门JavaEE就业1期-每日总结】EL&JSTL与MVC初识
同学们，今天我们主要就学习了EL和JSTL表达式，它们可以很方面的在JSP中获取数据以及做各种运算
今日需要掌握的有：
请同学们按照如上要求，总结今日所学。
作者: Yanmo_ 时间: 2018-6-8 19:45
颜琳琳
EL是表达式语言,有简化<% %>中的JSP代码的作用.使用的格式${ EL表达式},主要的功能有:1.获取数据,2.执行运算,3.操作WEB开发是常用对象(有 1.pageScope,requestScope,responseScope,applicationScope---用来获取JSP中域的数据 2.param,paramValues---用来接收参数 3.header,headerValues---用来获取请求头 4.initParam---获取全局初始化参数 5.cookie---Web开发中的cookie使用方法:${cookie.history.value}获取cookie中的值 6.pageContext----用于web开发中的pageContext,使用方法:${pageContext.request.Contextpath}获取工程路径)
JSTL是JSP的标准标签库,包含了5中标签库 : core(核心标签),fmt(国际化标签),xml(XML标签),sql(SQL标签),fn(JSTL提供EL函数库)其中主要掌握JSTL中的核心标签(if, forEach), 使用步骤1.导入JSTL相关的jar包; 2.引入标签库<%@taglib uri=”” prefix=”” %>,
作者: wpwing 时间: 2018-6-8 21:02
吴鹏
总结:
----------------------------------------------------
掌握EL的表达式的用法
语法:${EL表达式}
作用:1 获取四个域中的数据;
如果四个域中有重名的,则获取的顺序为:page--->request--->session--->application;
获取数组数据:${数组名[索引值]}
获取List集合的数据:${集合名[索引值]}
获取Map集合的数据:${map.key名}
.和[]的区别:.[]用于有下表的数据(数组,list集合) .用于有属性的数据(map,对象)
如果属性名中有特殊字符,则必须使用${map["属性名"]}
获取对象的数据:${对象名.成员变量名}
获取对象的集合的数据:${集合名[索引值].对象成员变量名}
2 执行运算(算术运算,逻辑运算,关系运算);
算数运算:
${变量1 + 变量2};
会帮我们完成类型转换,字符串传换成int等类型,
当有多个变量时,变量为空也不会报错,而是会只执行变量有值的的变量;
逻辑运算:
${变量1 < 变量2}或者${变量1 lt 变量2}
< lt less than
> gt great than
<= le less equal
>= ge great equal
== eq equal
关系运算:
${表达式1 && 表达式2} ${表达式1 and 表达式2}
${表达式1 || 表达式2} ${表达式1 or 表达式2}
${!(表达式1<表达式2)} ${not(表达式1<表达式2)}
三元运算:
${表达式1<表达式2?"正确":错误}
empty运算:
${user ==(!=) null} ${(not)empty user} 判断空与否
3 操作11个WEB常用对象,重点掌握:cookie,pageContext;
${cookie.名称.value};获取指定名称的cookie的值;
${pageContext.request.remoteAddr};获得当前的IP地址;
${pageContext.request.contextPath};获取当前工程路径;
---------------------------------------------------------------------------
掌握JSTL的常用标签的使用
重点掌握核心(core)标签库中的if标签和forEach标签;
if:
<c:if test="判断条件" var="flag" scope="page">
判断条件为true时执行,不满足则跳过,没有else语句;
</c:if>
将判断结果存入var,下次使用可以直接用var里面的结果进行判断;
scope表示结果是放在page域里面;
forEach:
<c:forEach var="i" items="${arrs}">
${i}
</c:forEach>
Map集合:
<c:forEach var = "entiry" items= "${map}">
${entry.key}-${entry.value}
</c:forEach>
遍历1到10
<c:forEach var="i" begin="1" end="10" step ="1">
${i}
</c:forEach>
作者: 咸鱼coder 时间: 2018-6-8 21:03
万冕
EL表达式:
就是为了代替<% %> 格式为${ }
功能: 从JSP的四个域中获取数据
执行逻辑运算
操作web开发的11个对象(主要Cookie(cookie.aaa.value)和pageContext(pageContext.aaa.value))
调用java中的方法
JSTL(JSP标签库):
和EL一起代替jsp页面里的<% %>
JSTL主要包含5类标签:
先导入相关的jar包,两个jar包
在引入标签库时要注意导入带jsp的包
core(核心标签)用来操作<c:循环与判断语句>
fn(函数库)用来操作<fn:大多操作的是字符串的函数>
作者: 渣.. 时间: 2018-6-8 21:04
柯威龙
EL作用就是可以简化jsp中java的代码.EL使用的语句是${}.
EL四个功能是: 1.获取数据只能获取jsp中的四个域
2.可以运算
3.操作WEB开发的常用对象
4.调用java中的方法(但是这个很少用到)
JSTL是一个标签库.使用EL加上JSTL可以直接简化<%%>.让代码看起来跟简洁也会更方便.JSTL包含了
五类标签.但是核心标签是if和forEach.在使用JSTL之前都需要引入两个包.
作者: Nevermo 时间: 2018-6-8 21:26
许煜
EL &JSTL总结
EL expression language 表达式语言 ${ }直接写在jsp页面 类似<%= %>
功能 1获取数据 01 从jsp四个域获取数据 获取顺序和pagecontext.findattribute( )一致
02 数组集合等使用索引[ ],属性值等使用.(点) 类似于get(属性)
2 执行运算 01 会自动转换类型再进行预算 如${“10”+”20” }=30
02 可以执行逻辑运算 大于 小于 等于
03 可以执行关系运算 与 非 或
04 可以执行三元运算 ${ a>b? a:b }
04 可以执行非空运算 $(date==null) 判断数据是否为空 返回true或false
3 常用对象 共有11个常用对象
01 四个域对象 requestscope pagescope sessionscope applicationscope
02 param 获取网页传递参数(单值) paramvalues 多值 使用索引
03 header headervalues 获取请求头信息
04 initparam 获得全局初始化参数
05 cookie 获得web开发中的cookie值 $(cookie.history.value)
06 pagecontext 获得web开发中的pagecontext 获取工程路径,IP地址
4 调用java中方法
JSTL Jsp Standard Tag Library :Jsp标准标签库
使用前准备 :导入相关jar包 引入标签库<%@taglib= %>
常用标签 <c:set var=”” value=”” scope=”” > </c:set>用于设置参数
var 定义参数名
value 设置参数值
Scope 设置参数存贮的区域(四个域对象)
<c:if test=” ” var=”” scope=”” >条件成立执行的内容</c:if>
test 条件语句
var 定义参数,值为前面条件语句的结果(以备以后相同情况用,非必要)
scope 确定参数存储的区域 (jsp四个域对象)
<c:forEach var= “i” items =” ” begin=”” end=”” step=”” varStatus=”” >${ i }</c:foreach>
var 定义参数名
Items 被遍历的目标对象
Begin 遍历开始的位置
End 遍历结束的位置
Step 遍历的时候每次跳跃间隔
varStatus 遍历的进行状态 varStatus.count 正在进行的次数
遍历数组或单列集合
<c:forEach var =”arraylist” items=”${ArrayList }”> ${arraylist} </c:forEach>
遍历map集合的
<c:forEa var=”entry” items=”${Map }”>${entry.key}--${entry.value} </c:forEach>
遍历数字 <c:forEach var=”i” begin=”0” end=”10” step”2” varStatus=”num”>${i} {/c:forEach}
从0遍历到10 每次差值是2 ${num.count}可以表示当前遍历的次数
作者: sts 时间: 2018-6-8 21:32
苏海斌
EL表达式可以简化JSP代码,就是减少<%%>:底层是get方法
语法:${EL表达式}
功能的话可以获取数据,也就是JSP的四个域,还可以执行运算和操作web开发的常用的对象;
获取数据有个小重点:就是获取数据的优先性:
即:pageContext>request>session>application(这里的>是先于的意思)
EL可操作的web开发的有11个常用对象:重点掌握cookie和pageContext(获取pageContext中的对象如IP地址(${pageContext.request.remoteAddr})和工程路径(${pageContext.request.contextPath}))
JSTL:
JSTL的标签库:包含了5类标签:
core(核心标签)fmt(国际化标签)xml(XML标签)sql(SQL标签)fn(JSTL提供EL函数库)
if标签(重点)
forEach标签!!!
通过标签可更简化:
<h3>获取数组的数据</h3>
<%
String[] arrs = {"李旭华","李冠希","杨凤","杨如花"};
pageContext.setAttribute("arrs", arrs);
%>
${ arrs[0] }
${ arrs[1] }
${ arrs[2] }
${ arrs[3] }
<h3>获取List集合的数据</h3>
<%
List<String> list = new ArrayList<String>();
list.add("李芙蓉");
list.add("杨芙蓉");
list.add("王凤");
pageContext.setAttribute("list", list);
%>
${ list[0] }
${ list[1] }
${ list[2] }
<h3>获取Map集合的数据</h3>
<%
Map<String,String> map = new HashMap<String,String>();
map.put("aaa","李旭华");
map.put("bbb","杨久君");
map.put("ccc","李芮");
map.put("ddd","李凤");
pageContext.setAttribute("map", map);
%>
${ map.aaa }
${ map.bbb }
${ map.ccc }
${ map.ddd }
forEach标签:
<h3>遍历数组</h3>
<%
String[] arrs = {"李旭华","李冠希","董阳阳"};
pageContext.setAttribute("arrs", arrs);
%>
<c:forEach var="i" items="${arrs }">
${i}
</c:forEach>
<h3>遍历List集合</h3>
<%
List list = new ArrayList();
list.add("李旭华");
list.add("李冠希");
list.add("董阳阳");
pageContext.setAttribute("list", list);
%>
<c:forEach var="i" items="${list }">
${i }
</c:forEach>
<h3>遍历Map集合</h3>
<%
Map<String,String> map = new HashMap<String,String>();
map.put("aaa","李旭华");
map.put("bbb","李冠希");
map.put("ccc","董阳阳");
pageContext.setAttribute("map", map);
%>
<c:forEach var="i" items="${map }" varStatus="map">
${i }
</c:forEach>
作者: LittleSky 时间: 2018-6-8 21:41
常小天
今天学习的是EL、JSTL以及MVC的知识。EL表达式的格式是${EL表达式}。EL的功能有四个。一是从域中获取数据。这里区分“[]”和“.”的使用。“[]”用于有下标的数据(数组,list集合) ，而“.”用于有属性的数据(map,对象).但如果属性名中包含有特殊的字符。必须使用“[]”。二是执行运算。除了加减乘除这些算术运算外，EL表达式还可以执行关系运算、逻辑运算、三元运算以及empty运算。三是操作WEB开发常用的对象，这些对象里我们重点掌握cookie和pageContext。${ cookie.history.value }用于获取cookie值，${ pageContext.request.contextPath }用于获取工程路径，这种动态获取工程路径的方法可以降低工程的维护难度。JSTL标签库中我们重点掌握两个标签。if和foreach。前者用于判断语句，后者用于循环。这里需要注意的一点是这两个标签内双引号内的东西如果是字符串就直接编写，如果是其他类型的数据或者是代码就必须要用EL表达式来书写。最后学习了MVC的设计模式。M即model，模型层，包括domain，DAO，service这些java类；V即view，视图层，就是jsp，专门用于显示；C即control，控制层，也就是servlet类。所有的请求都要传送给servlet，由servlet调用模型层的类进行处理，接收处理结果再进行判断及其他操作，最后将结果响应给浏览器。通常servlet的处理结果会通过重定向或者转发交由视图再进行响应。这就是jsp的设计模式二。
作者: 13163997058 时间: 2018-6-8 21:41
王刘锁
先补一下昨天的代码!拿作业来说吧,作业的要求是注册成功后转到登录界面,登陆成功后跳转到商品列表页面,但是如果没有登录会提示去登录并且看不到商品列表,商品列表中有购物车按钮和添加商品到购物车的功能,购物车同样不登录无法看到,购物车中有移除单个商品的功能,那在写代码的时候需要定义注册,登录,添加商品和移除商品的Servlet,注册和登录写过很多次了,这里记一下这次作业需要的功能代码,首先是登录成功后需要把用户User对象村到Session中,request.getSession().setAttribute("user", user2);然后我们可以在商品列表的页面和购物车的页面最上方先写一个<%if(request.getSession().getAttribute("user")==null)%>做这样一个判断,当user2存在说明登录成功,就可以显示页面否则不显示页面,接下来就是添加商品功能了.这个功能需要在我们点击添加到购物车的时候提交商品名Servlet<td><ahref="/web_07/countServlet?name=苹果">加入购物车</a></td>,然后在Servlet中获取到传入的name数据,然后是不太好像的关键点了,我也是尝试了很多次才完成的,我们需要获取Session中的保存购物车商品信息的数据表,并把它转成一个map集合,key是商品名,value是数量,这段的意思就是我们从Session中获取一个map集合,集合中存的是商品信息,Map<String,Integer> map =(Map<String, Integer>) request.getSession().getAttribute("products");然后判断map是否为空,为null说明购物车中还没有商品,那我们直接把接收的商品名和数量1存入map,如果map不为null我们再判断map中是否已经有要添加的商品map.containsKey(name),如果有就把value数量取出加1再存入,如果没有就直接存数量为1map.put(name, 1);,最后把map存入session中就可以了request.getSession().setAttribute("products", map),还有就是移除商品,在购物称重点击移除商品,一样会把要移除的商品名传入Servlet,一样的获取map,然后就可以直接移除了,map.remove(name);最后转发 到购物车提示移除成功!!那么这个案例就基本完成了,另外还可以添加登录时的验证码等功能,不过有一点需要知道的是我们关了浏览器那cookie存的Session的id就消失了,再打开页面购物车的商品也就清空了,因为没有id我们获取不到Session.那要想把购物车保存,需要在数据库中创建一张表来存储购物车,这张表中有很多购物车通过外键和用户信息表来连接,我们可以通过用户来获取其对应的购物车,
这是今天学的内容:基本没有代码,要记的只有一些语法,标签什么的,概念性的东西比较多,首先是EL,它的语法很好记${EL表达
式},从昨天的代码中可以看出为了获取域中的数据我们需要写一些Java代码在jsp中,写代码用到很多的<%%>还有嵌套,看起来很乱,还容易晕头,那今天学的EL就是为了解决<%%>符号太多的问题,极大程度简化代码,避免晕头转向,关于EL我们最终要的是如何获取域中的数据:${pageScope/requestScope/sessionScope/applicationScope.name};当然也可以存数据,就是
${pageContext.setAttribute("name","value")};此外还可以做运算表达式,算数运算(如果数据是整型字符串,获取到会自动转换成整型来做算数运算),逻辑运算,关系运算,三元运算,非空empty运算,无非就是一些运算表达式,--再有就是面试会问到的内容:EL的隐含对象11个有4个域对象,接收请求参数的对象param和paramValues,获取请求头对象header和headerValues,获取全局参数对象initParam,获取Cookie中的数据的对象cookie${cookie.cookie名.value};获取PageContext域中数据的对象${pageContext.request.remoteAddr}获取请求ip,${pageContext.request.contextPath}获取请求项目名,这里我们需要掌握cookie和pageContext两个对象,这个pageContext和pageScope不一样,pageScope只能获取域中数据,PageContext可以获取请求信息,然后我们还学习了JSTL,我们把EL和JSTL组合使用可以更简化jsp代码,EL中我们只能获取数据,无法做一些判断循环,所以有JSTL这个标准标签库,可以在jstl标签中套el标签,很实用,也是面试题,JSTL有哪些标签,一共有五类core(核心)fmt(国际化)xml(xml标签)sql(sql标签)fn(EL函数库)我们必须掌握core和fn,首先在使用的时候先引包,jstl.jar和standard.jar两个包,然后在jsp最上面引入标签库写一个<%@ 剩下的全靠Alt+/%>;核心标签记住if-判断和forEach-循环还有他们的一些属性<c:if test="条件" var="名字随便起" scope="域名">内容</c:if>如果条件为true把true以名字存入域中并输出内容,没有else一说,想要else再写一个if判断相反的条件,,forEach呢就是<c:forEach var="以该名字输出" begin="100" end="300" step="5" arStatus="account">${名字}/c:forEach>意思就是以名字输出100到300间的数字,输出的数字间相差5,account是随便起的名字记录循环到第几次,关于函数库,记些标签好了${fn:contain("HelloWord","Hello")},${fn:length("Hello")},${fn:toLowerCase("HELLO")},${fn:split("h-e-l-l-o"),"-"}结果是数组,今天差不多就这些内容!!
作者: 六道的骸6 时间: 2018-6-8 21:45
张裕
EL表达式 可以直接通过${} 获取属性数据
为了在JSP代码中减少<% %>的数量 更方便的获得一些数据
可以在四个域PageScope RequestScope SessionScope ApplicationScope 中获取数据
还能执行一些算数 逻辑 关系 三元 运算
操作WEB开发常用的对象(11个)
pageScope,requestScope,sessionScope,applicationScope - 获取JSP中域中的数据
param,paramValues - 接收参数.
header,headerValues - 获取请求头信息
initParam - 获取全局初始化参数
(掌握)
cookie - WEB开发中cookie
${ cookie.key.value } 可以获取指定的cookie
pageContext - WEB开发中的pageContext.
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }
JSTL(JSP标准标签库)
使用需要引入jar包 在JSP页面中引入标签库<%@ taglib uri="" prefix="" %>
常用标签
<c : set> 设置属性以及所在的域范围
<c : out> 在页面输出内容 default设置默认输出 escapeXml设置标签是否转义
(重点)
<c : if test="表达式"> 根据表达式结果来显示内容 可以将表达式的结果 赋值给一个变量 存储到域中
<c : forEach> var得到的每个值 items遍历的元素 begin开始 end结束 step每次累加的数
varStatus记录循环状态(有count和index方法)
MVC设计模式 相当于
Model 模型层 JavaBean
View 视图层 JSP
Controller 控制层 Servlet
JSP的开发模式(动态网页开发过程)
Servlet: 显示麻烦 处理数据方便
JSP: 封装处理数据麻烦 显示方便
JSP+JavaBean: 维护麻烦 显示封装处理数据方便
JSP+Servlet+JavaBean: MVC的设计模式(目前主流)
<jsp:setProperty property="*" name="类的变量名!"> 表单元素和类中的属性名称一致 就自动封装
BeanUtils.pupulate(对象,map集合): 匹配map中的key 给对象类的成员变量赋值
感觉最近标签啊 方法啊东西太多 使用的又太少 页面也做了好几次 但是总是想不起有什么便利的方法可以供自己使用 总觉得学的
方法不懂在何时使用 有点头痛
作者: lnongge 时间: 2018-6-8 21:47
16weisong
今天主要学习了el表达式+jstl和初步学习mvc知识,3el+jstl是用来替换jsp中的<% %>,mvc是一种开发思想,m是模型用来封装数据,v是视图用来显示数据,c是控制器用来控制业务流程.今天只需把老师布置的作业敲了就没问题
作者: 许大炮 时间: 2018-6-8 21:52
许剑鸿 webDay18
EL表达式:
1.从域中获取数据:
${ 存入对象域中的名称 } | ${ 存入对象域中的名称.对象属性(若存入的是对象) } | ${ 存入对象域中的名称[index](若存入的对象有索引值)}...............
2.执行运算:
${a+b} ${ a>b} ${ a<b} ${ a==b} ${ a!=b} ${ a>b&&a>c} ${a>b||a>c}
3.常用11个对象(重点掌握cookie,pageContext)
${cookie.history.value}
${pageContext.request.contextPath} (项目名)
JSTL(JSP标签库 重点掌握if forEach):
使用步骤: 1 导jar包(2个) 2 引入uri <%@ taglib uri="" prefix = "" %>
<c:if test="${EL表达式}">
满足EL表达式后执行的执行体
</c:if>
<c:forEach var="遍历出来的每一个值变量名" items="${ EL表达(要遍历的对象) }">
执行体
</c:forEach>
MVC:
M:model 模型层 JavaBean Dao Service
V:view 视图层 Jsp
C:controller 控制层 Servlet
作者: Eclipse启动 时间: 2018-6-8 21:54
郑阳阳
掌握EL的表达式的用法:
1.用于获取域中的数据
2.执行运算
3.EL的常用对象11个,一般只用cookie和pageContext
掌握JSTL的常用标签的使用:
core(核心标签),fn(JSTL提供的EL函数库)
core的常用用法:
if:<c:if text="${判断}"></c:if>
forEach:<c:forEach var="(遍历得到的所有数据)" items="${(需要遍历的)}" begin="开始" end="结束" > </c:forEach>
fn的常用用法:
${fn:contains("Hello World","Hello")} 是否包含
${fn:length("Hello World")} 长度
${fn:toLowerCase("ADCDE")} 转为小写
${fn:split("a-b-c","-")} 按-符号切割
作者: 沅瞻 时间: 2018-6-8 21:57
詹源
EL:
(功能)简化尖括号百分号代码,减少尖括号使用,辅助开发
(重点)获取的数据来源,必须是放在4个域中
可以执行运算
可以用EL操作WEB开发的一些常用对象
可以调用JAVA中的方法(一般不用)
map.put("数据名","数据")获取一个map数据
(键值对?)
获取list集合
${list[0]} ${list[1]}
map:${map["name..."]}
EL表达式还可以执行运算:
${ n1 + n2 }
除了逻辑运算还有表达式
$ {n1 < n2} - ${ n1 lt n2} <!-- less than --><br/>
. . .> gt <!-- great than --><br/>
. . .<= le less equal ...
. . .>= ge great equal ...
. . . == eq equal ...
还有执行三元运算:
${ n1 < n2 ? "正确":"错误" }
empty运算
${ user ==null } - ${ empty user}
EL操作WEB开发的常用对象一共11个.
(常见几个:)
param,paramValues - 接收参数
header,headerValues - 获取请求头信息
initParam - 获取全局初始化参数
cookie - WEB开发中cookie
pageContext - WEB开发中的pageContext.
接收请求的参数
< %= requset.getParameter("id") %>
< %= requset.getParameter("name") %>
< %= Arrays.toString(request.getParameterValues("hobby"))>
获取请求头
< %= request.getHeader("User-Agent") %>
${ header["User-Agent"]}
获取全局初始化
${ initParam.username }
获取cookie中的值
${ cookie.history.value }
获取PageContext中的值
(注:现在都不在JSP中做以上操作,JSP只做显示.只做理解.掌握cookie和pageContext)
pageContext:获取当前工程名
JSTL
在JSP中使用的一些标签.是个标签库
EL表达式替换<%%>中的获取数据java代码,但是不能替换if else for循环
JSTL可以替换if else for 循环
JSTL和EL结合.可以替换页面中所有的<% %>
重点:!!if标签
如何使用JSTL
1.引入JSTL的jar包.(导2个包.jstl.jar和standard.jar放到classpath)
2.在jsp页面中引入jstl标签库.<%@ taglib uri="" prefix=""%>(alt+/提示快速引入)
JSTL常用的标签
<c:set var="" value="" scope=""></c:set>
<c:out value="(可以是常量,也可以是变量)"default=""></c:out>
<c:if test= "${ n1<n2 }" var="flag" scope="page">
n1小于n2
</c:if>
不能在"${ }"引号内加空格,在括号内可以随意添加.
引号内必须有${ }.
foreach标签库:uri="http://java.sun.com/jsp/jstl/core" prefix="c"
if标签库: . . . jstl/functions" prefix="fn"
**JSP的开发模式发展过程:
Servlet 缺陷:
↓ *显示HTML元素的时候麻烦.
JSP 优点:
*显示数据方便
缺点:
↓ 在封装数据和处理数据上麻烦.
JSP+JavaBean 优点:显示数据和封装处理数据很方便 →JSP模式一:JSP+JavaBean的模式
↓ 缺点:后期维护麻烦. JSP显示数据,JavaBean封装和处理数据
JSP+Servlet+JavaBean 优点:JSP显示,JavaBean封装处理.Servlet控制 →JSP模式二:JSP+Servlet+JavaBean的模式
也被称为是MVC的设计模式.
M:Model:模型层 JavaBean
V:View:视图层 JSP
C:Controller:控制层 Servlet
作者: w849027724 时间: 2018-6-8 21:57
吴利君
今天学了el表达式，jstl标签库和mvc的设计模式。
首先是el表达式，这个是用来简化jsp中的java代码，可以极大的减少代码的数量，其中主要的就是值的显示，主要有普通值的显示${}，对象属性的显示${对象.属性}，list值的显示${list[i]}和Map值的显示${map.key}，其他的知道就好。
然后是el表达式的11个对象其中要记得是${pageContext.request.contextPath}这个的动态的获取工程路径，可以多项目更好的兼容不同环境，然后是cookie的获取，这个可以简化获取cookie的操作，减少了很多不必要的jsp里面的java代码。
然后是jstl这个标签库，这个标签库可以简化jsp中的java代码，其中他需要导入两个包，一个是core核心包，然后是standerd差不多名字的这个包，然后在要使用的页面进行导入<@tag.......>，导入之后就可以使用，其中<c:if><C:forEach>这两个表情很好用，可以循环遍历自己传来的值，或者对值进行判断，然后进行相对应的操作。之后的Struts2里面也有类似的标签，或者是Thymeleaf模板，都有差不多的功能，懂了一个其他的都差不多。
然后是MVC开发模式，这种开发模式是现在软件设计的主要的开发模式，主要就是把程序分层三个部分，模型。视图和控制，例如后面的jsp+Servlet+javabean，而且后面的框架也都基于这种模式。
作者: 厦门黑马王子 时间: 2018-6-8 21:58
郑雪平
今天学习了三方面的内容：1.EL表达式；2.JSTL；3.MVC模式完成转账案例。学习EL表达式可以简化JSP代码并且可以减少使用<% %>,EL表达式的语法也很简单明了${表达式}就可以了；EL有四大功能：1.存取数据功能，这个是最重要也是最常用的功能；2.执行运算功能，除了基本的加减乘除算数运算外还可以做于，或，非，比大小判断错对等逻辑运算，关系运算和三元运算的功能；3.操作WEB中有11种常用的对象，最重要最常用需要记住的就Cooike和pagecontext两个；4调用java中的方法，这个现在很少使用了。
第二部分是JSTL：JSTL是一个标准标签库，学习JSTL是为了和EL相互结合来达到替换JSP页面中的<% %>的目的，JSTL中有五类标签：1，core核心标签;2.fmt国际化标签;3.xml（xml标签）;4.sql（sql标签）;5.fn（JSTL提供的EL函数库标签）.JSTL的使用步骤是：1.引入JSTL相关的JAR包；2.在页面中引入标签库文件。
作者: 磬辰 时间: 2018-6-8 21:59
林文辉
EL表达式:
语法:${ EL表达式 }
常用：获取数据，操作web对象，主要是pageContext和cookie
获取数据：如果是对象，要求对象属性的值，直接对象名.属性即可
集合或数组则可以通过[ 索引]来获取数据
JSTL:
作用：JSTL和EL结合 替换页面中<%%>
常用标签：core(核心标签)，fn(JSTL提供EL函数库)
常用的有：if和forEach,fn提供EL的函数库，如length ,split等等
MVC：M:数据层 V：界面层 C：控制层
作用：降耦合
思想：面向接口开发
原因;为了扩展，比如现在你的Dao层是用DBUtils写的，
哪天你想换成其他框架或者工具，你只要修改你的实现类就好了
EL和JSTL结合
动态获取商品：
<c:forEach var="p" items="${pageBean.list }">
<div class="col-md-2">
<a href="${pageContext.request.contextPath }/ProductServlet?method=findByPid&pid=${p.pid}">
<img src="${pageContext.request.contextPath}/${p.pimage}" width="170" height="170" style="display: inline-block;">
</a>
<p><a href="${pageContext.request.contextPath }/ProductServlet?method=findByPid&pid=${p.pid}" style='color:green'>${fn:substring(p.pname,0,7)}</a></p>
<p><font color="#FF0000">商城价：¥${p.shop_price}</font></p>
</div>
</c:forEach>
购物车的实现：
<c:if test="${fn:length(cart.map)==0 }">
<h3 align="center">您的购物车空空如也，去购买商品吧</h3>
</c:if>
<c:if test="${fn:length(cart.map)!=0 }">
<div class="container">
<div class="row">
<div style="margin:0 auto; margin-top:10px;width:950px;">
<strong style="font-size:16px;margin:5px 0;">订单详情</strong>
<table class="table table-bordered">
<tbody>
<c:forEach var="list" items="${cart.list }">
<tr class="warning">
<th>图片</th>
<th>商品</th>
<th>价格</th>
<th>数量</th>
<th>小计</th>
<th>操作</th>
</tr>
<tr class="active">
<td width="60" width="40%">
<input type="hidden" name="id" value="22">
<img src="${pageContext.request.contextPath }/${list.product.pimage }" width="70" height="60">
</td>
<td width="30%">
<a target="_blank">${list.product.pname }</a>
</td>
<td width="20%">
${list.product.shop_price }
</td>
<td width="10%">
${list.count }
</td>
<td width="15%">
<span class="subtotal">${list.subTotal }</span>
</td>
<td>
<a href="#" class="delete" id="delItem" onclick="deleteItems('${list.product.pid}')">删除</a>
</td>
</tr>
</c:forEach>
</tbody>
</table>
</div>
</div>
<div style="margin-right:130px;">
<div style="text-align:right;">
<em style="color:#ff6600;">
登录后确认是否享有优惠
</em> 赠送积分: <em style="color:#ff6600;">${cart.total/20 }</em> 商品金额: <strong style="color:#ff6600;">${cart.total }</strong>
</div>
<div style="text-align:right;margin-top:10px;margin-bottom:10px;">
<a href="${pageContext.request.contextPath }/CartServlet?method=clearCart" id="clear" class="clear">清空购物车</a>
<a href="${pageContext.request.contextPath }/OrderServlet?method=saveOrder">
<input type="button" width="100" value="提交订单" name="submit" border="0" style="background: url('${pageContext.request.contextPath}/images/register.gif') no-repeat scroll 0 0 rgba(0, 0, 0, 0);
height:35px;width:100px;color:white;">
</a>
</div>
</div>
</div>
</c:if>
作者: finfin12 时间: 2018-6-8 21:59
张育辉
EL总结:
一:EL的基本概述
简化jsp中java代码开发,来代替jsp中<%= %>,
它不是一种开发语言，是jsp中获取数据的一种规范;
<%
//设置
pageContext.setAttribute("name", "pValue"); //当前页面
request.setAttribute("name", "rValue");//一次请求
session.setAttribute("name", "sValue"); //一次会话
application.setAttribute("name", "aValue");//一个项目
%>
//获取,如果没找到会获取null //如果没找到会获取字符串""//找到所属域对象,
<%=pageContext.getAttribute("name") %> = ${ pageScope.name }
<%=request.getAttribute("name") %> = ${ requestScope.name }
<%=session.getAttribute("name") %> = ${ sessionScope.name }
<%=application.getAttribute("name") %> = ${ applicationScope.name }
二: 操作WEB开发常用11个对象 可以直接写 ${11个对象.id}来获取参数
1-4个:pageScope,requestScope,sessionScope,applicationScope |-只能获取JSP域中数据!比如 requestScope.name 获取name的值
一般域对象名字相同的时候,可以用这4个对象,名字不一样的话的可以直接${name}来获取;
5-6个:param,paramValues |- 接受参数,相当于 request.getpagetParameter("id") = ${param.id}
|- paramValues 相当于getParameterValues("id")返回一个数组 = ${paramValues[0]}
7-8个:header,headerValues |- 获取请求头的信息,相当于getHeader("") = ${header[]}注意:如果有特殊字符,必须要用中括号,内容要用双引号来概括
9个:initParam |-获得全局初始化参数,就是获取在web.xml配置的<context-parm>的参数
10个:cookie |-WEB开发中的cookie 以前需要遍历,查找,获取值 = ${cookie.cookie的名称.value} 如果cookie的没有的话,他就返回一个字符串""(空)
11个:pageContext |-WEB开发中的pageContext 想要获取request等其他8个内置对象必须通过pageContext对象来获取${pageContext.request.get...}
JSTL总结:
一:JSTL概述:JSP标准标签库
<c:set var="给变量取名字" value="变量" scope="存到那个域中page">
<c:out value="输出的内容,不要写标签,默认当字符串输出" escapeXml="false" 设置了false了就会把value中的标签符号用html解析>
<c:if test="条件表达式" var="把表达式的结果赋值给var,下次也可以用" scope="存到那个域中page"
<c:forEach var="i(取名字)" items="${要遍历集合(数组)的名字}"> (打印) ${i}</c:forEach>
<c:forEach var="i(取名子,entry)" items="${map集合名字}"> (打印) ${i.key} - ${i.value} </c:forEach>
<c:forEach var="i(取名字)" begin="100(从几开始i=100)" end="300(什么时候结束i<=300)" step="5(i+5 每次循环加几)" varStatus="status(状态,第几次循环count++)">
<c:if test="${ status.count(循环次数) % 3 == 0 }">
<font color="red">${ i }</font>
</c:if>
<c:if test="${ status.count % 3 != 0 }">
${ i }
</c:if>
</c:forEach>
二:Jstl函数:
用到函数的时候需要导包<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="f" %>
一般里面都是操作字符串的方法
${ fn:contains("Hello World","Hello") } 是否包含
${ fn:length("HelloWorld") } 长度
${ fn:toLowerCase("ABCDE") } 转成小写
<c:forEach var="i" items="${f:split(cookie.hostory.value,'-')}">${i}(打印结果2,3,4) </c:forEach>//切割
注意:如果${f:参数1,'-')}参数1是用${}获取的话,可以不用写,单引号也不要写
MVC设计模式总结:
M:Model:模型层(dao,user,service), V:View:视图层(JSP), C:Controller:控制层(servlet)
JSP的开发模式一:JSP + JavaBean
优点:显示数据和封装处理数据很方便;
缺点:维护麻烦;
JSP的开发模式二:JSP + JavaBean + Servlet(就是mvc设计模式)
优点:JSP用于显示数据,JavaBean用于封装和处理数据,Servlet控制
作者: rkko 时间: 2018-6-8 22:00
杜石苇
${EL表达式}
2．EL从域中取出数据(EL最重要的作用)
jsp脚本：<%=request.getAttribute(name)%>
EL表达式替代上面的脚本：${requestScope.name}
EL最主要的作用是获得四大域中的数据，格式${EL表达式}
EL获得pageContext域中的值：${pageScope.key};
EL获得request域中的值：${requestScope.key};
EL获得session域中的值：${sessionScope.key};
EL获得application域中的值：${applicationScope.key};
EL从四个域中获得某个值${key};
---同样是依次从pageContext域，request域，session域，application域中 获取属性，在某个域中获取后将不在向后寻找
1）获得普通字符串
2）获得User对象的值
3）获得List<User>的值
3．EL的内置对象11个
pageScope,requestScope,sessionScope,applicationScope
---- 获取JSP中域中的数据
param,paramValues - 接收参数.
相当于request.getParameter() rrquest.getParameterValues()
header,headerValues - 获取请求头信息
相当于request.getHeader(name)
initParam - 获取全局初始化参数
相当于this.getServletContext().getInitParameter(name)
cookie - WEB开发中cookie
相当于request.getCookies()---cookie.getName()---cookie.getValue()
pageContext - WEB开发中的pageContext.
pageContext获得其他八大对象
${pageContext.request.contextPath}
相当于
<%=pageContext.getRequest().getContextPath%> 这句代码不能实现
获得WEB应用的名称
4．EL执行表达式
例如：
${1+1}
${empty user}
${user==null?true:false}
JSTL核心库的常用标签
1）<c:if test=””>标签
其中test是返回boolean的条件
<c:forEach var = "" items="
1）遍历List<String>的值
2）遍历List<User>的值
3）遍历Map<String,String>的值
4）遍历Map<String,User>的值
5）遍历Map<User,Map<String,User>>的值
entry.key-----User
entry.value------List<String,User>
作者: 5119 时间: 2018-6-8 22:00
游荣辉
总结
EL:
* EL的概述
* EL:Expression Language
* EL的作用:
* 获取数据${ }
* 执行运算
* 操作web开发中常用的对象${param }
* 调用Java中方法:
*EL操作WEB的开发常用对象
重点:cookie ${ cookie.history.value }
pageContext ${ pageContext.request.contextPath }
JSTL
*使用JSTL：
* 引入JSTL的相关的jar包.
* 在页面中引入标签库.<%@ taglib uri=”” prefix=””%>
* core是核心标签(常用的有if forEach 这两个必须掌握)
MVC
* M:Model:模型层
* V:View:视图层
* C:Controller:控制层
作者: chenyelong 时间: 2018-6-8 22:01
陈叶隆
1. EL获取数据
i)存:<%pageContext.setAttribute("name", "pValue");%>
取:${ pageScope.name}
ii)获取Cookie中的值:
${ cookie.history.value }
iii)获取PageContext中的对象:
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }
2. JSTL
2.1使用JSTL：
* 引入JSTL的相关的jar包.
* 在页面中引入标签库.<%@ taglib uri=”” prefix=”” %>
2.2核心标签:if,foreach:
遍历数组: <c:forEach var="i" items="${map}">
${i.key} = ${i.value}
</c:forEach>
案例一:遍历100到300每隔5个的数,将3个的整数倍的数字变红色:
<c:forEach var="i" begin="100" end="300" step="5" varStatus="status">
<c:if test="${status.count%3==0}">
<font color="red">${i }</font>
</c:if>
</c:forEach>
案例二:显示商品详情页面:
<c:forEach var="p" items="${list }">
<tr>
<td>${ p.pid }</td>
<td>
<c:if test="${ p.is_hot == 1 }">
是
</c:if>
<c:if test="${ p.is_hot != 1 }">
否
</c:if>
</td>
</tr>
</c:forEach>
作者: 偏离X 时间: 2018-6-8 22:01
郭明杰:
学习EL的目的是为了让jsp页面写起来更简单,最主要的作用就是简化jsp的语句.
EL有四个功能,第一是获取数据,把<% 域对象获取数据语句 %> 简化成${"name"},这个方
法可以重载,查找顺序是域范围的从小到大,找不到则返回null;
*获取数据: 获取有索引的元素,比如集合,数据的时候,用[] ,获取带属性的元素 ,比如
map ,用 "." ,如果属性名带特殊字符,可以用[""] 代替" ." ;
*执行运算:EL可以执行算数,逻辑,关系运算,三元运算符,自动完成类型转换,
${cookie.history.value} 获取cookie history
${pageContext.request.ContextPath} 获取当前工程名
*JSTL需要导两个包才可以使用!!!
在jsp中引入jstl标签库的语句: <%@ taglib
uri="http://java.sum.com/jsp/jstl/core" prefix="c"%><c:if test="n1>n2">
JSTL中标签 if forEach 两个较为重要
作者: 滴滴eclipse启动 时间: 2018-6-8 22:42
江某人:
语法:${EL表达式}
作用:1 获取四个域中的数据;
如果四个域中有重名的,则获取的顺序为:page--->request--->session--->application;
JSTL的标签库:包含了五类标签.
* core(核心标签),fmt(国际化标签),xml(XML标签),sql(SQL标签),fn(JSTL提供EL函数库)
要倒两个新的包
在页面中引入标签库.<%@ taglib uri=”” prefix=””%>
var 定义参数名
Items 被遍历的目标对象
Begin 遍历开始的位置
End 遍历结束的位置
Step 遍历的时候每次跳跃间隔
varStatus 遍历的进行状态 varStatus.count 正在进行的次数
<c:forEach var="随意写变量名" items="${要遍历的变量或集合或对象}" varStatus="随意写变量名">
${i }
</c:forEach>
作者: 小故事 时间: 2018-6-8 22:47
谢洪彬:
今天学习了EL和JSTL
学习EL和之前相比就是替换了<%%>的这种写法,让页面显得更干净,程序员开发起来工作效率更高.
EL的作用:
1.存取数据
在取数据的时候如果多个域中有域名一样,就以小到大来一个显示(只显示一个)
2.执行运算
比如+,-,*,/
3.操作WEB开发的常用对象
就是操作11个常用对象
其中比较重要的有两个
1.Cookie来获取并遍历数组(使遍历变得更简单)
2.pageContext.request.ContextPath()来获取工程名
JSTL是属于El的标准标签库
使用之前需要导两个包,并且在页面中引入标签库
里面定义了很多函数,其中又以if 和foreach
If里面的属性
Test:里面填写关系表达式
如果这个关系表达式的值为true,则里面的内容被执行,否则不执行
Foreach里面的属性:
Items 需要遍历的数组或集合
Var 遍历得到的数据存放在这个属性里面
Begin:从哪里开始
End:到哪里结束
varStatus:记录状态(比如记录遍历的个数)
MVC :设计者模式
模式一:jsp+javaBean结合开发(基本已经淘汰)
模式二:jsp+javaBean+Servlet结合开发
MVC的含义:
M: 模型层 --- domain dao service
V: 显示曾 --- jsp
C: 控制层 -- servlet--获取数据--处理业务--跳转页面
作者: 名字被人注册了 时间: 2018-6-8 23:02
刘文峰
EL表达式(语法:${ EL表达式 })可以简化jsp代码并且减少<% %>的使用.
EL表达式有四个功能:1.获取数据:${ EL表达式}可以获取四个域中的数据,如果有重复的名字,会以作用域范围从小到大获得数据,有索引的可以在表达式后面加”[]”获得数据,没索引的在表达式后面加”.”;2:执行运算:可以执行算数运算,逻辑运算,三元运算,empty运算(判断是否为空);3:11个常用对象:常用的有Cookie和pageContext两个对象,${cookie.属性名.value}可以直接得到数据,&{pageContext.request.contextPath}获的工程名,可以用来解决一些路径问题;4:调用java中的方法
JSTL是jsp的标签库,和EL表达式一起使用可以替换掉jsp中<% %>语句;JSTL有5个标签库,常用的有core和fn两个标签库,使用JSTL前要先导入jstl.jar和standard.jar两个jar包,并且在jsp中引入标签库,core常用的标签<c:if test=”判断条件 ” var=”参数名” scope=”存储的域” >(将test的结果以var的参数名存进scope的域中);<c:forEAch var=”参数名” item=”遍历的对象”>可以用来遍历,还有 begin end step varStatus等属性可以使用;fn标签库主要是以对字符串的操作为主(参照String类).
作者: 张述明 时间: 2018-6-8 23:05
张述明
今天学习的主要内容是EL jstl mvc
主要要掌握的内容是 jstl的if 和foreach 标签,el中的11个常用对象的cookie对象和pageContext对象 掌握mvc的三个字符
所对应的含义 以及一个商品列表打印的案例
以下是今天的知识点
El
表达式语言
为了使jsp写起来更加简单
使用EL表达式
语法${EL表达式 }
El的功能
获取数据(jsp的四个域)
执行运算
操作WEB 开发的常用的对象
调用java中方法:--很少用
获取数据
点和[]的区别
[]用于有下标的数据(数组,lis集合),用于有属性的额数据(map,对象)
如果属性名中包含有特殊的字符,必须使用[]
执行运算
El操作web开发的常用对象11个
1. pageScope 获取jsp域中的数据
2. requestScope 获取jsp域中的数据
3. sessionScope 获取jsp域中的数据
4. applicationScope 获取jsp域中的数据
5. param 接收参数
6. paramValues 接收参数
7. header 获得请求头信息
8. headerValues 获得请求头信息
9. initParam 获得全局初始化参数
10. cookie web开发中cookie
11. pageContext web开发中的pageContext
JSTL
Jsp标准标签库
Jstl和el结合 能替换<% %>
Jstl的标签库 包含了五类标签
1. Core(核心标签) ,
2. Fmt(国际化标签)
3. Xml(XML标签)
4. Sql(sql的标签)
5. Fn(JSTL提供el函数)
使用jstl:
引入jar包
在页面中引入标签库<%@ taglib uri=”” prefix=””%>
Mvc设计模式完成转账的案例
需求:
Jsp的模式一
Jsp+ javaBean
Jsp的模式二
Model:模型层 javaBean JavaBean dao Service 封装和处理数据
View:视图层 jsp 显示数据
Controller:控制层 servlet 处理请求,任务分派,获取数据u,处理业务,跳转页面.
作者: zzx835387607 时间: 2018-6-8 23:06
郑志祥 Day13 JSP与EL与JSTL
实现类中 一般不写基本类型int 而是写interge
因为 int 默认值为0
interge 默认值为null
添加数据的时候 自增长（设置主键）的那一列，
数据库就没有0 所以会报错。
el 就是简化jsp的代码
el的第一个功能
1.从域获取数据
2、执行运算${ user!=null}
3.操作web的常用的对象
调用java的方法（基本不用）
在域对象当中，从小到大获取
page request session ServletContext=（aplication）
${ name} 如果获取不到得到的是一个“ ”
<%= request.getattribute(key ) %>如果获取不到，得到的是一个null
获取数组中的元素
${ arr[ 5]} 通过下标和索引获取
Map的获取
${map.key }
点与【】的区别使用
【】用于有下标的（数组 .list集合）
点用于获得属性的数据（map ，对象） 如果属性值中包含属性值必须使用【】
el的第二个功能
1.进行算数运算（加减乘除）
2.执行逻辑运算（比较大小或相等）返回的是boolean
< it less than
> gt great than
= eq equal
3.执行关系运算(与或非)返回的是boolean
4.执行三元运算 ${ n1 < n2 ? "正确":"错误" }
5. empt运算(判断对象是不是为空)
${ user == null } --》 ${ empty user }
${ user != null } --》 ${ not empty user }
11大常用web对象（能够在el表达式可以直接使用的对象）
主要掌握cookie.history.value 获取history.cookie的值
pageContext.request.ContextPath 获取工程名
jsp的9大内置对象
JSTL :jsp的标准标签库（JSP Standard Tag Library ）
JSTL的作用：EL与JSTL的结合可以完美的操作jsp，来替代原始的<% %>
JSTL主要来操作 if...else for循环
JSTL的五类标签
core（核心标签）
fn（JSTL提供的EL的函数库）
fmt（国际化标签）
xml（xml标签）（一般不使用）
使用JSTL
1.导jar包 （ Standard包与jstl包）
2.在页面里引入标签库
if标签（重要）
foreach的遍历（重要）
1.遍历数组
2、遍历List集合
3、遍历MAP集合
${ } 里面可以随意加空格
items=“ ${ }” 字符串里面不要随便加空格
MVC
modle模型层 javaBean ( domai dao service)
view 视图 层 jsp
controller控制层 Servlet --获取数据-处理业务--跳转页面
作者: 厦门陈强 时间: 2018-6-8 23:12
陈强
EL & JSTL的一天
首先是EL的内容,主要的就是EL的获取功能,可以做各种运算,和EL的11个常用的对象:
-获取功能就是可以获取JSP的四个域中所存放的数据,---${ },前提是这些对象有对应的get方法.数组和有索引的集合获取元素就是之间采用域存放的名称[索引]即可,而Map集合就要根据key来获取,同时有一个需要注意的就是属性名中如果包含有特殊符号的,就要改成[ “ 属性名 ” ],避免被当成字符创处理了.
-EL的常用对象---需要记住就是cookie和pagecontext两个,还有4个就是JSP对应的4个域也是比较好记的—pagescope\requestscope\sessionscope\applicationscope
然后就是JSTL的内容了-JSP的标准标签库
使用的时候就得先引入响应的JAR包---两个!!!!!
然后是要在JSP中引入标签库---taglib----直接使用快捷键就可以完成---ALT+/
此部分的标签重点的就是if和foreach
<c:if>---test中是写表达式的,if标签中的代码只有在test为true的时候才会执行,而且if标签是没有else语句的,所有如果要执行else语句的话,就再写一个if标签,test的表达式为非.
<c:foreach>---当中有var\items\begin\end\step等属性
Items是表遍历的对象,要写在EL表达式内${ 遍历的对象 }
难点是遍历MAP集合,遍历获得的是集合中的键值对,所以要获取对应的键和值,就应该用键值对对象点key和value的形式获得.
最后是MVC模式----Model模型View视图Controller控制.
作者: 一梦 时间: 2018-6-8 23:34
陈世彪:
今天学了EL和JST认识到了MVC
EL的作用
获取数据:(JSP的四个域)
${ pageScope.name }
${ arrs[0] }
${ map.aaa }
${ userList[0].id }
EL还可以执行逻辑运算
${ n1 < n2 } - ${ n1 lt n2 } <!-- less than --><br/>
${ n1 > n2 } - ${ n1 gt n2 } <!-- great than --><br/>
${ n1 <= n2 } - ${ n1 le n2 } <!-- less equal --><br/>
${ n1 >= n2 } - ${ n1 ge n2 } <!-- great equal --><br/>
${ n1 == n2 } - ${ n1 eq n2 } <!-- equal --><br/>
在WEB开发中常用的对象
cookie - WEB开发中cookie
${ cookie.history.value }
pageContext - WEB开发中的pageContext.
${ pageContext.request.contextPath }
掌握JSTL的常用标签的使用
JSTL要先导两个包
在页面中引入标签库.<%@ taglib uri=”” prefix=””%>
常用的JSTL标签
${ fn:contains("Hello World","Hello") }查看是否包含
${ fn:length("HelloWorld") }查看字符长度
${ fn:toLowerCase("ABCDE") }转小写
遍历集合
<c:forEach var="i" items='${ map}'>
${ i }
</c:forEach>
if语句
<c:if test="${ true或者false}">
语句
</c:if>
作者: 李思贤126 时间: 2018-6-8 23:44
李思贤:EL表达式
语法:${ EL表达式 }
功能:1EL获取数据 2EL执行运算 3EL常用对象(11个)
1现在主要用到的就是获取数据,${ EL表达式 },获取集合或者数组中要在后面加下标,要注意如果属性名中含有特殊字符也要用[ ]
2执行运算: 可以执行算术,逻辑,关系,三元,empty等运算,这里介绍下empty运算,后面有点用;
<h3>empty运算</h3>
${ user == null } - ${ empty user }
${ user != null } - ${ not empty user }
3EL操作WEB常用对象:
pageScope,requestScope,sessionScope,applicationScope - 获取JSP中域中的数据
param,paramValues - 接收参数.
header,headerValues - 获取请求头信息
initParam - 获取全局初始化参数
cookie - WEB开发中cookie
pageContext - WEB开发中的pageContext.
后面两个有点用,其他了解:
获取Cookie中的值:
${ cookie.history.value }
获取PageContext中的对象:
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }
JSTL
JSTL和EL结合可以替换页面中<%%>,要注意使用JSTL1.1,因为JSTL1.0不支持EL
JSTL标签库:
core(核心标签),fmt(国际化标签),xml(XML标签),sql(SQL标签),fn(JSTL提供EL函数库)
使用JSTL:
先引入JSTL的2个jar包,
在页面引入标签库<%@ taglib url=”” prefix=””%>
在url中引入的java.sun.com/jsp/jstl/core 注意不要导错了 一定要带jsp
JSTL中核心的两个标签是if标签和forEach标签:
1 if标签用法: 在字符串中写入结果为true或false的判断语句(要用EL语句),尖括号中是判断语句为true输出的结果:
<c:if test="${ n1 < n2 }">
n1小于n2;
</c:if>
2forEach标签用法:
集合或数组遍历 在{ }中填入数组名集合名
<c:forEach var="a" items="${ list }">
${ a }
</c:forEach>
Map集合遍历
<c:forEach var="a" items="${ map }">
${ a.key }-${ a.value }
</c:forEach>
普通有序遍历:
<h3>遍历从100到300</h3>
<c:forEach var="a" begin="100" end="300" step="5" varStatus="status" >
<c:if test="${ status.count % 3 ==0 }">
<font color="red">${ a }</font>
</c:if>
<c:if test="${ status.count % 3 !=0 }">
<font color="green">${ a }</font>
</c:if>
三MVC
MVC设计模式: JSP+JavaBean+Servlet
M:M:Model:模型层
V:View:视图层
C:Controller:控制层
作者: 光宇 时间: 2018-6-8 23:46
侯玉林
1.为什么学习EL:
* 简化JSP的代码,而且减少<%%>
2.使用EL表达式:
* 语法:${ EL表达式 }
3.EL的功能:
* 获取数据:(JSP的四个域).
1.PageScope:范围当前页面
2.RequestScope:范围一次请求结束(包括请求和响应,响应完,就消失)
3.SessionScope:范围一次回话(一般关闭浏览器,非法给Cookie设置时间,或者Session销毁)
4.ApplicationScope:关闭服务器.
重点:四个作用域从上到下,范围依次变大.当四个作用域中都有name的key时,而在调用${name}中的name没有指明作用域时,默认调用作用域小的.
例如: <%=pageContext.getAttribute("name") %>
${ pageScope.name }
<h3>获取List集合的数据</h3>
//存数据
<%
List<String> list = new ArrayList<String>();
list.add("李芙蓉");
list.add("杨芙蓉");
list.add("王凤");
pageContext.setAttribute("list", list);
%>
//取数据
${ list[0] }
${ list[1] }
${ list[2] }
* 执行运算:
例如:
<%
pageContext.setAttribute("n1", "10");
pageContext.setAttribute("n2", "20");
pageContext.setAttribute("n3", "30");
pageContext.setAttribute("n4", "40");
%>
${ n1 + n2 + n3 }
* 操作WEB开发的常用的对象:
* 调用Java中方法:--很少用.
4.EL功能:操作WEB开发常用的对象(一共11个,主要记两个:cookie,pagecontext)
1.cookie - WEB开发中cookie
<h3>获取Cookie中的值</h3>
${ cookie.history.value }
2.pageContext - WEB开发中的pageContext.
<h3>获取PageContext中的对象</h3>
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }
作者: 铁木啊童臂 时间: 2018-6-9 00:02
汪志阳:
EL表达式:简化JSP的代码,减少<%%>,页面看起来更整洁.所有能.出来的基层都有get方法
语法:$(EL表达式),表达式可以是对象,数据
功能1:获取数据(数据存储于pageContext,request,sessionScope,applicationScope四个域对象)
首先存入数据:pageContext.setAttribute("name",value):value可以是数组,集合,map等数据
取值:数组:${arr[1]}; 集合:${list[0]}; map:${map.name}
功能2:执行运算(算数运算,逻辑运算,关系运算)
存数据:pageContext.setAttribute("n1",10); pageContext.setAttribute("n2",20); pageContext.setAttribute("n3",30)
算数运算:${ni+n2+n3};
逻辑运算:${n1>n2}-${n1 lt n2} 返回boolear类型[lt:less than(小于);gt:great than(大于);eq:equal(等于);less equal:小于等于]
关系运算:${n1<n2? "true":"false"};
功能3:操作WEB开发的常用对象
pageScope,requestScope,sessionScope,applicationScope - 获取JSP中对应域中的数据
获取cookie中的值(之前需要用数组存储cookie的值,遍历数组,获取cookie中的值)
${cookie.history.value}:获取名字叫history的cookie中的所有值
获取PageContext的对象:
获取IP地址值:${pageContext.request.remoteAddr};
获取工程路径:${pageContext.request.contextPath}
JSPL:JSTL和JSL结合,完全替换了页面中的<%%>.使用jstl首先要导入两个jar包,在标签库<%@ taglib uri=”” prefix=””%>引入包
JSTL的核心掌握标签:if和forEach
利用jstl变量数组,集合和map:先将数据用pageContext.setAttribute存入,然后
<c:forEach var="listName" items="${list }"> ${listName }
解释:用items="${list }"存储数据,然后命名为变量为 var="listName",在调用var,注意map获取key,value需要${mapName.key }${mapName.value }
forEach中的begin和end,step属性可以代培来进行增减遍历.
mvc:现在主流使用的jsp+servlet+javaBean开发模式,今天主要进行初步介绍,明天进行进一步的学习.
作者: hpb199567 时间: 2018-6-9 00:19
本帖最后由 hpb199567 于 2018-6-9 21:20 编辑
何平波
今天学EL表达式和JSTL
什么是EL表达式呢?
就是为了使JSP(这里可以与JSTL结合)写起来更简单,可以将<% %>这种写法直接写成${el表达式},不过重点是要存取session(request.getSession.setAttribute("el表达式",
存取的值)),才能直接在JSP的页面调用.
EL有4个功能:
1.获取数据:要存在JSP的4个域中,这4个域分别是
域对象的作用:用于存取数据,获取数据,在不同的资源之间共享数据.
域对象的方法
setAttribute(name,object):保存数据方法
getAttribute(name):获取数据方法
removeAttribute(name):清除数据
4个域对象的作用范围是
page域:处于同一个JSP页面中数据是有效的
request域:处于同一个请求中数据共享是有效的
session域:处于同一个会话中数据共享是有效的
application域:处于同一个web应用中数据共享是有效的
大小执行顺序
<!-- 类似findAttribute("name") 先从page域中查找,没找到去request域中查询,没有找到去session域中找，没有找到就去application域中找 -->
这里的域可以存很多类型的对象,比如数组,集合,javabean对象数据
注意:和[]的区别.
[]用于有下标的数据(数组,list集合) .用于有属性的数据(map,对象)
* 如果属性名中包含有特殊的字符.必须使用[]
2.执行运算
比如在JSP的页面中存值n1=10 n2=20;
pageContext.setAttribute("n1", "10");
pageContext.setAttribute("n2", "20");
pageContext.setAttribute("n3", "20");
pageContext.setAttribute("n4", "20");
算数运算:这样的话可以直接在jsp页面中写${n1+n2},会在JSP页面直接显现结果30;
逻辑运算:写成${n1==n2} 或者${n1 qe n2},这样也可以直接在页面中显示结果false
关系运算:${ n1<n2 && n3 < n4 } - ${ n1<n2 and n3 < n4 }<br/>,这样的话也是同样的效果
3.操作WEB开发的常用的对象:
这里的功能可以结合今天的一个案列是在页面显示商品信息
首先要结合前面所学的知识点将数据库中的信息封装在一个list的集合中,然后存入域对象中,这个域对象的name是要在页面中的打印的对象,
value值就是这些在数据库中的商品信息,然后在页面中遍历集合,打印信息<c:forEach item="name"></c:forEach>,具体用法可以参照代码实现.
JSTL
EL表达式可以与JSTL结合起来使用,这样可以替代<% %>,方便了代码的编写.
那么什么是JSTL呢? JSTL是一个JSP的标签库,它简化,限制作用域,为JSP带来了非常灵活的形式${EL表达式 },通过作用域来获取域中的数据.
JSTL有很多标签,其中forEach(循环标签),if(判断标签)是比较核心的.
具体的格式:
<c:forEach items="${域中存取的属性名称}" var=(这里的名称可以直接代替域中属性的名称)
比如案例,这里已将数据库的商品信息封装在一个list的集合中了,这里就可以直接遍历list
${var的名称.要获取的属性,比如list.id(获取的是list集合中的全部id)}
</c:forEach>
例如:
<c:if test="${list==null}">
输出结果
</c:if>
作者: it小白001 时间: 2018-6-9 00:40
吴俊斌
EL表达式
EL主要是获取四个域中内容,page request session application
基本用法${可以直接写域名.value}出现同名的就需要在前面添加域
执行运算 ${"20"+"10"}会自动转成int在做运算
其他和java差不多
还可以遍历集合,和if语句
<c:forEach var= “i” items =” ” begin=”” end=”” step=”” varStatus=”” >
${ i }
</c:foreach
<c:if test=” ” var=”” scope=”” >条件成立执行的内容</c:if>
最后学习了MVC的设计模式。M即model，模型层，包括domain，DAO，service这些java类；V即view，
视图层，就是jsp
作者: 李成林 时间: 2018-6-9 00:41
JSP&EL&JSTL总结
李成林
EL表达式
获取:${name};这里是从域中获取,获取特点是从小到大开始寻找根据返回值是value
${cookie.name.value}:获取cookie中的值
${map.key}
运算:${a>b}返回布尔值
El的对象
有9个需要掌握的有两个
cookie:${ cookie.history.value }获取值
pageContext:${pageContext.request.Contextpath}获取当前项目名
JSTL的核心标签
if:<c:if test="${条件}"></c:if>
forEach:<c:forEach var="变量名" items="${ 遍历的对象 }">循环体</c:forEach>
需要记忆的单词
store(商店)
empty(空的):判断是否为空
not empty()判断是否不为空
param(参数)
scope(处理)
default(未履行)
escape(溜走)
forEach(循环)
test(实验):在<c:if>里书写test="条件"
step():在forEach里书写step(一次循环加几次)
varStatus:在forEach里书写varStutas:设置count或index可以代表当前循环次数
begin(开始)
作者: doudou0606 时间: 2018-6-9 01:00
施炎生
今日总结：
今日重点掌握了EL表达式JSTL标签库，了解MVC两种设计模式。
一，学完EL表达式后，在JSP内就可以减少<% %>的使用了，简化了页面。
EL主要有三个功能：1.获取数据，2执行运算，3，操作WEB开发的常用对象
1.获取数据
比起之前使用的<%request.getpramater()%>方便很多，只需使用${参数名}即可。
需要注意的是：
（1）${ name } 获取name的值时，<!-- 类似findAttribute("name") 先从page域中查找,没找到去request域中查询,没有找到去session域中找，没有找到就去application域中找 -->；
（2）.和[]的区别.
* []用于有下标的数据(数组,list集合) .用于有属性的数据(map,对象（比如user对象内的name属性，直接user.name）)
* 如果属性名中包含有特殊的字符.必须使用[] (这里的特殊字符一般指点. 下横线貌似不算（p.is_hot，比如今日的案例这个is_hot属性直接用点就行）)
2，执行运算
<h3>empty运算</h3>
${ user == null } - ${ empty user }
${ user != null } - ${ not empty user }
3.操作WEB开发的常用对象
(1)重点掌握cookie:
<h3>获取Cookie中的值</h3> ：${ cookie.history.value }
(2)重点掌握pageContext
工程路径:${ pageContext.request.contextPath }
二，JSTL进一步简化EL表达式
重点掌握 core(核心标签)，fn(JSTL提供EL函数库)
1.使用JSTL：
* 引入JSTL的相关的jar包.
* 在页面中引入标签库.<%@ taglib uri=”” prefix=””%>
2.重点掌握这两个标签的使用：
遍历Map集合:
（1）<c:forEach var = "entry" items= "${map}">
${entry.key}-${entry.value}
</c:forEach>
（2）
<h3>遍历从100到300，并将能整除3的用红色字体输出</h3>
<c:forEach var="i" begin="100" end="300" step="5" varStatus="status" >
<c:if test="${status.count%3==0 }">
<font color="red">${i}</font>
</c:if>
</c:forEach>
有两个容易出BUG的地方需注意：
美元符忘加(for循环内两个)，美元符外双引号内的空间不能出现空格。
作者: COLDER 时间: 2018-6-9 01:10
本帖最后由 COLDER 于 2018-10-18 19:34 编辑
[EL&JSTL And MVC]
1.EL是什么?
EL(Expression Language)从英文翻译来看,这是一种表达语言,它提供了在JSP中简化表达式的方法.
2.EL的作用?
使用EL表达式可以简化JSP的代码,就是可以减少在JSP中使用<% %>来获取域中的数据...为什么需要这样做呢?
据说是因为如果JSP文件中都是<% %>这样的表达式的话,让美工来对其进行图片修改...她会懵圈看不懂的...
所以使用EL表达式的目的是这样的吗?当然在写,代码上的确是效率比较高呢!
3.EL的表达式?
语法:${ EL表达式 },使用EL表达式记得使用$符号,为什么是用$这个符号呢?我想应该是跟老美有关系吧,如果是中国
人设计出来的话,会不会是用¥这个符号呢?唉,只能强行记住了...饿,走远了....
4.EL的功能?
(1).EL获取JSP域中的数据:
如果是使用<% %>:<% pageContext.getAttribute("name","value") %>
现在使用${ }: ${ pageScope.name } 可以把"."理解为"的",意思就是取出pageScope的name
还可以使用 ${ name },这种表达会默认从最小的域中查找name对应的value值,当找到就输出,如果找不到的话,就往
更大范围的域查找,依次是pageContext,request,session,application
*获取域数据可以获取数组的数据,List集合的数据,Map集合的数据,区别在数组和List集合都是有索引的,所以根据
索引来获取:表达式 ${ arrs[index]},而Map集合就根据键来获取值,因为键是唯一的.
(2).EL的执行运算:算术运算,逻辑运算,关系运算,三元运算,empty运算,这些和java中类似
empty运算: ${ user == null} , ${ user != null}
(3).EL操作WEB开发的常用对象
pageScope,requestScope,sessionScope,applicationScope - 获取JSP中域中的数据
param,paramValues - 接收参数.
header,headerValues - 获取请求头信息
initParam - 获取全局初始化参数
*(重点)cookie - WEB开发中cookie , 获取Cookie中的值:${cookie.name.value}
*(重点)pageContext - WEB开发中的pageContext , 获取工程路径:${ pageContext.request.contextPath }
5.JSTL是什么?
JSTL是JSP的标准标签库,作用是结合EL来替换JSP页面中的<%%>
6.JSTL的标签库有哪些?
core(核心标签),fmt(国际化标签),xml(XML标签),sql(SQL标签),fn(JSTL提供EL函数库)
core(核心标签):if,foreach
fn(JSTL提供EL函数库):contains,length,toLowerCase,split
7.使用JSTL需要做的准备?
(1).引入JSTL的相关的jar包. (2).在页面中引入标签库.<%@ taglib uri=”” prefix=””%>
作者: 黄志彬 时间: 2018-6-9 01:20
黄志彬
今天学习了EL表达式语言 作用就是简化了JSP的写法，可以减少<% %>。获取域中的数据，存取的是普通的单值数据，获取数组和集合中的数据。执行运算 里的empty 判断对象是否为空会经常用得到
操作对象有11个对象可以直接在el表达式中使用，主要是cookie和pageContext
cookie web开发中的cookie 直接${ cookie.history.value } 可以用来记住用户名
pageContext web开发中的pageContext 获取工程路径 ${pageContext.request.contextPath }
由于EL表达式解决JSP 替换<% %>中的获取数据java代码，但不能替换if。esle.for循环...
所以又学习了jstl
JSTL
标签库包含5类标签主要的是core核心类标签和 fn JSTL提供EL函数库
jstl的使用
1.引入jstl相关的jar包（2个）jstl.jar standard.jar
2.引入jstl标签库 <%@ taglib uri="" prefix="" %>
常用的标签 core核心类标签 if和forEach标签，注意forEach里的 sitems="${arr}" 双引号里面${}外面不能有空格
最后学习了MVC
M:Model:模型层
V:View:视图层
C:Controller:控制层
作者: ...ylq 时间: 2018-6-9 01:20
叶凌青
今天学了EL表达式 最重要的功能是1.从域中获取数据 2.还可以执行运算
常用的11对象,要掌握的是cookie pageContext
jstl
主要掌握 if标签和foreach标签
要导入两个jar包
还学习了MVC设计模式
M模型层 domain+dao+service
V视图层 jsp
C控制层 servet
自己做的总结挺乱,就不上传了.
作者: AsusCoder 时间: 2018-6-9 01:22
曾耀峰
web07_EL&JSTL总结:
今天的内容逻辑不难，主要以了解记忆为主。唯一的一个案例显示数据库的数据到前端页面展示，是在前面的作业有做过。案例的关键方法如下:
1.DAO查询多个结果返回对象集合:
ArrayList<Product> productList = QueryRunner("select * from product",new BeanListHandler<product>(product.class));再次回顾一下这个方法，有两个作用:
1).BeanListHandler()接口实例化的对象，通过商品类的字节码文件，反射得到类的属性对象，和数据库的字段名比较，当类的成员属性和字段名一样的时候，就会把数据库的数据填充到类的成员属性中。得到一个完整的对象。所以，用户传入一个username，password的两个数据，可以通过这个操作得到该用户的更详细信息，比如昵称，属性等。
2)该方法返回了一个装有Bean实体对象的集合，这个集合就是案例要求的后台数据表
2.制作前端页面的表格，展示后台的数据。根据1)分析得到了productList，把它放在session空间中。在前端product_list.jsp页面中，通过今天学习的JSTL和EL表达式获取Session中的product:
<c:forEach var "i" items ="${productList}">
<td>${i.pname}</td>
<td>${i.shop_price}</td>
<td>${i.pdesc}</td>
<c:if test="${i.is_hot==1}">
<c:out value="是"/>
</c:if>
<c:if test = "${i.is_hot !=1}">
<c:out value="是"/>
</c:if>
</c:forEach>
貌似今天学的核心内容就在上面的这段代码里面了。接下来总结一些要记的EL表达式和JSTL常见用法
一、EL表达式
首先在EL表达式和JSTL中有四个域对象（作用范围）:pageContext,requestContext,sessionContext,applicationContext 这四个作用范围 从小到大，当四个域对象存储相同名字的数据时，EL获取${name} 得到的是最小范围的值：pageContext.EL有以下作用:
1.获取域对象中的值:${name} 等价于<%=request.getSession.getAttribute("name")%>
2.获取常见的数据对象:
1).获取集合的值:${list[0]}
2).获取map的值:${map.aaa};
3).获取对象的值:$(user.id);
4)获取装有对象的集合的对象成员变量:$(userlist[0].id);
3.作为表达式进行运算
4.EL中有11个对象，掌握两个重点:
1)四个:pageScope,requestScope,sessionScope,applicationScope 获取Jsp域中的数据
2)二个:param,paramvalues。分别是获取一个参数，获取全部参数
3)二个：header,headerValues:获取请求头信息
4)一个:initParam:获取初始化参数
上面的对象纯了解。下面两个重点掌握:
1)cookie:WEB开发中的cookie
2)pageContext:web开发中的pageContext:这个对象能获取所有域对象中的数据
二、JSTL：
JSTL的出现是为了简化JSP的代码简写，我们利用JSP做过for循环的嵌套可以知道，JSP对网页的跳动挺大的，容易造成前端页面的困扰。使用JSTL的标签形式能集中写JSP代码。
1.使用JSTL:下载jstl.jar包和standard.jar包，放在/WEB-INF/lib/里面。在JSP页面中要引用任何库的话，必须加一个头指令:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 这个表示引用JSTL的核心标签库
2.重要的核心库标签:
1)<c:forEach> 标签是一种迭代标签，接受多种集合类型:
(1)属性:
items:要被循环的集合，记得加${myList}这个符号
var:当前项的变量名称 var="i" 记住 不是value
begin:开始的元素索引位置
end:最后的元素元素索引位置
step:每次循环加多少:默认是0,step="2"表示一次加2
varStatus："s" s.count 表示当前的循环次数
2)<c:if>标签相当于if()语句，格式是：<c:if test="${判断条件}"
<c:if test="${i%2==0}">
<font color='red'>${i}</font>
</c:if>
for标签和if标签重点掌握，其余了解
3)<c:out> :用于在JSP中显示数据，就像<%= ... >
把输出的内容放在value,escapeXml忽略转义字符
<c:forEach var="entry" items="${cartMap}">
<c:out value="${entry.key }"/>
4)<c:redirect url="www.baidu.com"/>重定向
3.作用域范围:
scope属性值设置变量的作用域(作用范围)
在JSTL中有四个作用范围，由小到到一次是
pageContext<requestContext<sessionContext<ServletContext
三、MVC设计模式:
MVC是一种设计思想，核心内容是model模型，view显示，controller控制三个模块。开发的原则是view显示方面只做数据显示工作；model主要是一些Bean实体类，还有普通的java类；contorller通过调用model做逻辑数据操作。因此，后面负责view方面的jsp就尽量只做数据接收和显示的操作。逻辑代码都放在servlet中处理，最后返回jsp页面。
MVC中，一个请求最先发送到Servlet中，然后Servlet经过处理以后，返回到JSP页面，JSP根据Servlet处理的数据集合，或者结果。展示到前端。
这样的有序操作能提升代码的逻辑结构，并且有较好的扩展性
MVC包的建立:
com.web.dao:DAO数据库操作
com.web.service:连接DAO和Servlet的中间服务
com.web.servlet:放Servlet接收用户请求
com.web.utils:常用的工具类
com.web.bean:javaBean实体类(User类，Product类这些)
四、老师总结的关于Session的生命周期
Session默认是在request对象第一次访问Session空间的时候创建(通过request.getSession().setAttribute()方法)，这时候服务器给request一个SESSIONID，通过cookie带回浏览器。当浏览器关闭的时候,Session不会消失的。如果清空了浏览器的缓存，Session也不会消失。而是以游离状态存在服务器端，因为装在cookie里面的SEESIONID丢了。
Session默认的寿命是30分钟(意思是30分钟内没有对象访问seesion会被注销)，要手动设置寿命，可以在web.xml中设置；非正常关闭服务器，Session来不及序列化保存到硬盘中，也会被注销。如果正常关闭，Session会保存下来；另外还有Session的方法inval....什么来着可以结束Session;
作者: 林荣彬 时间: 2018-6-9 01:41
林荣彬
今天主要学习的内容有三个:
一:EL
EL表达式语言:简化JSP的代码,而且减少<%%>.但是不能替换if else和for循环,底层调用的是get方法.
表达式:${EL表达式}
EL的功能:
1. 获取数据:(JSP的四个域)
2. 执行运算:
3. 操作WEB开发的常用的对象:
4. 调用Java中方法:
功能一:获取数据
${ name } <!-- 类似findAttribute("name") 先从page域中查找,没找到去request域中查询,没有找到去session域中找，没有找到就去application域中找 -->
功能二:执行运算
获取数组和list集合的数据需要先将数据放入到域中利用索引获得数据;
注意:"."和[]的区别.
[]用于有下标的数据(数组,list集合) .用于有属性的数据(map,对象)
如果属性名中包含有特殊的字符.必须使用[]
功能三:操作WEB开发常用的对象
pageScope,requestScope,sessionScope,applicationScope获取JSP中的域中的数据
param.paramValues---接收参数
header,headerValues---获取请求头信息
initParam---获取全局初始化参数
cookie---WEB开发中cookie
pageContext ----WEB开发中的pageContext
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }
二:JSTL
JSTL:JSP标准标签库
作用:JSTL和EL结合.替换页面中<%%>;
使用JSTL,导包需要导两个包,在页面中引入标签库.<%@ taglib uri=”” prefix=””%>
JSTL的标签库:包含了五类标签.
core(核心标签),fmt(国际化标签),xml(XML标签),sql(SQL标签),fn(JSTL提供EL函数库)
JSTL的核心标签的用法
if:<c:if test="${ }"></c:if>
forEach:<c:forEach var="" items="${}"></c:forEach>
注意事项:items="不能直接写字符串必须是----${}"
三:MVC
MVC设计模式
M模型层:domain+dao+service
V视图层:JSP
C控制层:servlet
作者: 望蜀 时间: 2018-6-9 02:52
邵倩
EL表达式
目的: 简化JSP代码,减少<% %> (不能完全取代 )
语法: ${ EL表达式}
功能一 (从JSP的4个域中)获取数据
功能二 执行算数/逻辑/关系/三元/empty运算
功能三 操作WEB开发中的常用对象 主要掌握以下两个
${ cookie.history.value } ---获取名字叫history的cookie的值
${ pageContext.request.contextPath } ---获取工程路径
功能四 调用Java中的方法--很少用
JSTL---JSP标准标签库
1.0版本不支持直接使用EL表达式,我们使用的一般是1.1或1.2
EL表达式不能替代if for循环
所以我们需要使用JSTL结合EL表达式来完全取代<% %>
JSTL的标签库 包含了5类标签
主要掌握 core(核心标签),fn(JSTL提供EL函数库)
使用JSTL前
引入JSTL的相关jar包 (jstl.jar standard.jar)
在jsp页面引入jstl标签库:
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
或<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
重点掌握<c:if >和<c:forEach >的使用
案例 从数据库获得商品信息 显示到页面上
MVC
动态网页开发模式的发展:
Servlet有缺陷:显示HTML元素的时候麻烦
然后就有了JSP 优点:显示数据方便 缺点: 所有代码都写在JSP里,封装和处理数据时麻烦
(了解)然后就有了JSP+JavaBean的开发模式(占了很长时间,称为JSP的模式一) 优点:显示/封装/处理数据都很方便 缺点: 维护麻烦
(掌握)然后就有了JSP+Servlet+JavaBean模式(JSP的模式二,也被称为MVC的设计模式/思想) 优点 : JSP用于显示数据,JavaBean用于封装/处理数据,Servlet控制
MVC: Model View Controller 模型-视图-控制器
模型层: JavaBean DAO Service
视图层:JSP
控制层 :Servlet---获取数据---处理业务---跳转页面
Servlet调用一个JavaBean封装数据,再调用一个JavaBean(实际上是Service层)去处理数据 再由JSP去显示页面
DAO层 要写一个接口 然后让原来的DAO去实现这个接口 Servlet也是如此
作者: conan75 时间: 2018-6-9 08:52
陈昆明:
25.用EL表达式进行元素查找的功能实现时,如果使用了简写模式(${name}),那么查找范围会从小到大开始进行查找,而且只会找到一个.使用EL表达式的时候,如果该域对象里面的值为空,那么得到的是””,而非EL表达式则会返回null
26.EL的算术运算:会将字符串数字进行转换后再进行计算
pageContext能够获取其他8个内置对象,功能比pageScope强大多了
pageScope只能获取域中的数据
param对象主要功能为接收参数,但是在目前的MVC模式中,这种方式很少使用了,因为现在这些参数一般直接传到Servlet中进行处理了,不会在jsp中处理
27.out标签中的default属性要和value属性(为变量)结合使用
28.内省技术获得的属性的个数是看get/set方法的,与成员变量无关
作者: Do1 时间: 2018-6-9 09:06
EL的功能:
* 获取数据:(JSP的四个域)
* 执行运算:
* 操作WEB开发的常用的对象:
* 调用Java中方法:--很少用.
【EL获取数据】
<h3>存取是普通的单值数据</h3>
<%
//pageContext.setAttribute("name", "pValue");
//request.setAttribute("name", "rValue");
//session.setAttribute("name", "sValue");
application.setAttribute("name", "aValue");
%>
<%=pageContext.getAttribute("name") %> <!-- 如果没找到 返回null -->
<%=request.getAttribute("name") %>
<%=session.getAttribute("name") %>
<%=application.getAttribute("name") %>
<hr/>
${ pageScope.name } <!-- 返回的是"" -->
${ requestScope.name }
${ sessionScope.name }
${ applicationScope.name }
<hr/>
${ name } <!-- 类似findAttribute("name") 先从page域中查找,没找到去request域中查询,没有找到去session域中找，没有找到就去application域中找 -->
<h3>获取数组的数据</h3>
<%
String[] arrs = {"李旭华","李冠希","杨凤","杨如花"};
pageContext.setAttribute("arrs", arrs);
%>
${ arrs[0] }
${ arrs[1] }
${ arrs[2] }
${ arrs[3] }
<h3>获取List集合的数据</h3>
<%
List<String> list = new ArrayList<String>();
list.add("李芙蓉");
list.add("杨芙蓉");
list.add("王凤");
pageContext.setAttribute("list", list);
%>
${ list[0] }
${ list[1] }
${ list[2] }
<h3>获取Map集合的数据</h3>
<%
Map<String,String> map = new HashMap<String,String>();
map.put("aaa","李旭华");
map.put("bbb","杨久君");
map.put("ccc","李芮");
map.put("ddd","李凤");
pageContext.setAttribute("map", map);
%>
${ map.aaa }
${ map.bbb }
${ map.ccc }
${ map.ddd }
<h3>获取对象的数据</h3>
<%
User user = new User(1,"aaa","123");
pageContext.setAttribute("user", user);
%>
${ user.id }
${ user.username }
${ user.password }
<h3>获取对象的集合的数据</h3>
<%
User user1 = new User(1,"aaa","123");
User user2 = new User(2,"bbb","123");
User user3 = new User(3,"ccc","123");
List<User> userList = new ArrayList<User>();
userList.add(user1);
userList.add(user2);
userList.add(user3);
pageContext.setAttribute("userList", userList);
%>
${ userList[0].id } - ${ userList[0].username } - ${ userList[0].password }<br/>
${ userList[1].id } - ${ userList[1].username } - ${ userList[1].password }<br/>
${ userList[2].id } - ${ userList[2].username } - ${ userList[2].password }<br/>
作者: 凉面要趁热吃 时间: 2018-6-9 09:22
黄进安:
1. 学习EL表达式,简化了jsp中的代码(Java代码)
功能:
file:///C:/Users/ADMINI~1/AppData/Local/Temp/msohtmlclip1/01/clip_image001.gif 获取数据: EL表达式语句在执行时，会调用pageContext.findAttribute方法，用标识符为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回””（注意，不是null，而是空字符串）。
file:///C:/Users/ADMINI~1/AppData/Local/Temp/msohtmlclip1/01/clip_image001.gif 执行运算: 利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。${user==null}
file:///C:/Users/ADMINI~1/AppData/Local/Temp/msohtmlclip1/01/clip_image001.gif 获取web开发常用对象: EL 表达式定义了一些隐式对象，利用这些隐式对象(11个隐式对象,常用: cookie和pageContext
file:///C:/Users/ADMINI~1/AppData/Local/Temp/msohtmlclip1/01/clip_image001.gif 调用Java方法: EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。
注意:
n 不同域存在相同的标识符查找顺序:page>>> request>>>session>>>application
n .和[]的区别.
*[]用于有下标的数据(数组,list集合) .用于有属性的数据(map,对象)
* 如果属性名中包含有特殊的字符.必须使用[]
2. JSTL标签库的使用是为弥补html标签的不足，规范自定义标签的使用而诞生的。使用JSLT标签的目的就是不希望在jsp页面中出现java逻辑代码
n 导包: jstl.jar 和standard.jar 包
n 在JSP页面引入核心标签库的代码为：
<%@ taglib prefix="c"uri="http://java.sun.com/jsp/jstl/core" %>
n JSTL的核心标签库标签共13个,从功能上可以分为4类：表达式控制标签、流程控制标签(if)、循环标签(forEach)、URL操作标签。
作者: q55w66 时间: 2018-6-9 14:37
王清松
EL&JSTL
EL(Expression Language)
概述
简化JSP写法，让JSP代码看起来更结构脉络更加清晰
语法
${EL表达式}
功能
获取数据
数据来源——JSP的四个域
域名——作用范围
pageContext——当前页
request——一次请求
session——一次会话
application——当前工程
从指定域获得数据
${ pageScope.数据的Key }
${ requestScope.数据的Key }
${ sessionScope.数据的Key }
${ applicationScope.数据的Key }
举例：
${ applicationScope.sth }——在application中寻找Key为sth的数据
不限定域获得数据
${数据的Key}
举例：
${sth}——在四个域中寻找key为sth的键值对，然后返回值(从小到大)
目前推断以下两个方法等同(问过辉哥)
EL语法——${String name}
JSP的内置对象pageContext的方法——Object findAttribute(String name)
相同点：假设JSP不止一个域存在Key为sth的数据，那么会从范围最小的域(pageContext)找数据，找不到去高一级的域找值，一直找到最顶层
不同点：如果直到在最后都找不到值
${String name}——返回空字符串""
Object findAttribute(String name)——返回null
获取数据中的属性值
一般情况
${Key值.属性名}
举例：
${sth.password}
说明：
假设根据Key(sth)获得的数据获取的数据是个对象user(User类的实例),那么可以通过${sth.password}获取该对象password属性的属性值
附User类部分定义：
public class User
{
private String password;
private String nick_name;
...
}
对象内部属性命名有特殊符号
${Key值[属性名])}
举例：
${sth[nick_name]}
底层实现
通过getXxxxx()方法获取数据，所以要保证对象所属的类必须有相应的getXxxxx()方法
执行运算
算术运算
基本语法
${n1+n2}
n1=10;n2=20;
结果：30
自动完成类型转换
${n1+n2}
n1="10";n2="20";
结果：30
自动舍弃未定义的变量
${n1+n2+n3}
n1=10;n2=20;未定义n3;
结果：30,不会报错
逻辑运算
基本语法
${n1 < n2}
${n1 lt n2}
结果：true或者false
其他符号
> gt
<= le
>= ge
== eq
关系运算
基本语法
${n1>n2 && n3>n4}
${n1>n2 and n3>n4}
结果：true或者false
其他符号
|| or
! not
三元运算
${n1<n2?"正确":"错误"}
结果："正确":"错误"
empty运算
${user==null}
${empty user}
结果：true或者false
${user!=null}
${not empty user}
结果：true或者false
操作WEB开发的常用的11个对象
获取JSP域中的数据(四个域范围)
pageScope
requestScope
sessionScope
applicationScope
接收参数
param——接收一个参数
以下两个表达式等同
${param.id}
<%= request,getParameter("id")%>
paramValues——接收多个参数
以下两个表达式等同
${paramValues.hobbies}
String[] getParameterValues("hobbies")
取数组的值可以如下
${paramValues.hobbies[index]}
获取请求头信息
header
一个Key对应一个Value
以下两个表达式等同
${header["User-Agent"]}——包含特殊字符，所以用${Key值[属性名])}
<%=request.getHeader("User-Agent")%>
headerValues
一个Key对应多个Value
获取全局初始化参数
initParam
${initParam.myName}
结果:Kingdon
附:web.xml部分代码
<context-param>
<param-name>myName</param-name>
<param-value>Kingdon</param-value>
</context-param>
cookie-WEB开发中的cookie
${cookie.records.value}
结果:cookie中Key为records的Value值
pageContext-WEB开发中的pageContext
IP地址:${pageContext.request.remoteAddr}
工程路径:${pageContext.request.contextPath}
调用Java中的方法(少用)
JSTL(JSP Standard Tag Library)
版本
不支持EL表达式
1.0
支持EL表达式
1.1
1.2
作用
JSTL和EL结合替换页面中的<%%>
JSTL替换for if else循环等Java代码
EL替换获取数据的Java代码
标签库
core——核心标签
fmt——国际化标签
xml——XML标签(少用)
sql——SQL标签(少用)
fn——JSTL提供EL函数库
使用
引入JSTL相关的jar包
导包——在页面中引入标签库<%@ taglib uri="" prefix=""%>
uri/prefix：
1.Java Recources目录下，找到导入的standard.jar
2.standard.jar目录下，找到里面的META-INF文件夹
3.META-INF文件夹中找到标签对应的.tld文件
4.文件内容找到<uri>标签，uri所需设置的值就是这个标签内的值
5.文件内容找到<short-name>，prefix所需设置的值就是这个标签内的值
附：c.tld的部分内容
<short-name>c</short-name>
<uri>http://java.sun.com/jsp/jstl/core</uri>
注意：注意不要导成1.0的包，1.0不支持EL
1.0
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c"%>
1.1/1.2
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
核心标签core的用法
<c:set></c:set>
属性
var——变量名
value——值
scope——存入的域
page
request
session
application
举例：<c:set var="name" value="Kingdon" scopo="page"></c:set>
<c:out></c:out>(少用)
属性
value——输出值
变量${i}
常量Hello
default——默认值
举例：
<c:out value="${city}" default="北京">
结果一：${city}有值，输出值
结果二：${city}没有值，输出默认值——北京
escapeXml——是否需要转义
true
举例：
<c:out value="<h1>上海</h1>" escapeXml="true">
结果:上海(以h1标签形式输出)
false
举例：
<c:out value="<h1>上海</h1>" escapeXml="false">
结果:<h1>上海</h1>(普通形式)
<c:if></c:if>
属性
test——条件
满足条件，则输出标签中的内容
不满足条件，不输出任何内容
var——将test结果存入该变量
scope——存入的域
举例
<c:if test="${n1 > n2} var="flag" scope="page"></c:if>
结果：将if的结果存入变量flag中，并存入page域
注意
没有else标签，需要else就再起一个<c:if></c:if>
<c:forEach></c:forEach>
遍历数组
属性
var——变量名
items——被遍历数组
遍历list
<c:forEach var="i" items="${arrs}">
${i}
</c:forEach>
遍历map
<c:forEach var="entry" items="${map}">
${entry.key}-${entry.value}
</c:forEach>
注意：
${i}是去域中找Key为i的数据
底层代码完成了arrs中元素的抽取，然后存入了相应域中，Key就叫i
完成循环操作
属性
var——变量名
begin——开始值
end——结束值
step——每次递增量,默认为1
varStatus——记录遍历状态
count:当前循环是第几次循环
index:有下标的数据的下标
例一
<c:forEach var="i" begin="1" end="10" >
${i}
</c:forEach>
结果：1 2 3 4 5 6 7 8 9 10
例二
<c:forEach var="i" begin="1" end="10" step="2" >
${i}
</c:forEach>
结果：1 3 5 7 9
例三
<c:forEach var="i" begin="1" end="10" step="1" varStatus="status">
<c:if test="${status.count % 2 ==0}">
<b>${i}</b>
</c:if>
<c:if test="${status.count % 2 !=0}">
${i}
</c:if>
</c:forEach>
结果：1 2(加粗) 3 4(加粗) 5 6(加粗) 7 8(加粗) 9 10(加粗)
JSTL提供了EL的函数库
fn
${fn:contains("hello world","hello")}
${fn:length("helloworld")}
${fn:toLowerCase("ABCDE")}
${fn:split("a-b-c-d","-")}
获得的是一个数组，可以遍历
与字符串处理相关的操作
作者: 李志勇 时间: 2018-6-9 20:14
使用EL表达式:
语法:${ EL表达式 }
EL的功能:
获取数据:(JSP的四个域)
执行运算:
操作WEB开发的常用的对象:
调用Java中方法:--很少用.
JSTL的核心标签的用法:
<c:if var="i" text="条件"></c:if>
<c:forEach var="i" items='要遍历的对象'>
${ i }
</c:forEach>
作者: 1748341437 时间: 2018-6-9 20:21
2018/6/7 林瑋
昨天我们把jsp给大致框架和基本使用给学习了一遍,然后呢今天我们还是继续学习一个有关jsp的一些知识点,它们就是EL表达式和JSTL标签库,主要内容讲的就是EL,不过JSTL也很重要.
EL表达式就是为了让jsp代码书写更为简洁而发明的一个表达式,他提供了很多简化表达式的方法,这样我们就不用像之前那样应用<% %>..等标签在代码中插入代码那样繁琐了,直接${ EL表达式 }这样就好了,其实这个我们之前是见过的,就是在页面中获取数据用的就是${name}等..但是没有深入讲解,只是知道这个东东可以拿来获取数据,直到今天学了才知道原来是这么玩的啊.还有用到的一个就是${pageContext.request.contextPath }了,之前也不知道为什么能这么玩,现在才知道这原来是用配置域对象来获取的.除了这两个EL表达式还有很多方法,我就直接来说EL方法的大体反向,1. 获取数据:就是通过jsp的四个域获取数据的,获取到的数据他们是从小到大查找的:pageContext<request<session<applicationpe.还有一点要注意就是表达式里面要是有特殊符号要用中括号括起来!!但是中括号也不能乱用除了前者大多都是用于数组,和集合了.2. 执行运算:执行运算顾名思义就是在jsp执行算数运算,它也跟我们其他的运算一样,只不过多了一个${ }而已.他有分:算数运算,逻辑运算,关系运算,三元运算和一个empty运算,这五种运算.他的运算符还可以用英文代替,但是比起英文肯定是符号更简单一点啦.EL的WEB开发的一个常用对象有11个,我之前说的那个${ pageContext.request.contextPath }获取工程路径就是通过这些常用对象来使用的,对于这11个常用对象我们其实不用全记只要记两个就好,他们就是cookie和pageContext,这两个相对其他的更要常用和实用一点.
还有一个JSTL,JSTL呢是一个JSP标准标签库,他和EL配合使用,可以很大程度的简化页面,这里要说一下JSTL1.0是不支持的EL表达式的,只有1.1和1.2支持,所以要想用JSTL与EL搭配使用的话就要使用EL1.1跟1.2版本的JSTL;它包含了五类标签库,core,fmt,xml,sql,fn,其中常用及重点的标签库是core(核心标签)和fn(EL函数库标签),那既然JSTL如此方便要怎么用它呢?我们在使用它之前要先引入它的相关jar包,还要在jsp页面上引入标签库,这样就可以使用了.刚刚有说它的常用标签库,而他的常用标签库里又有分常用标签,core的就是:if标签和forEach标签了;其实所有JSTL里的标签库书写方法都一样:<c:?> ?里就是标签名了,使用又是另外一说了,只要你会格式,使用问题都不大,都是要自己去练的;函数库的话,就有种似曾相识的感觉了,没错就是对字符串的操作,我不知道还有没有其他用途今天是只了解了这个.
作者: 郑学馨 时间: 2018-6-9 21:57
郑学馨
EL:获取数据
JSTL:实现判断
案例一:将数据库中的信息显示到jsp页面上
项目前期准备:
步骤一:新建一个数据库,导入数据信息
步骤二:新建一个项目工程
步骤三;新建一个与数据库信息对应的Javabean,
功能实现步骤:
步骤一:新建一个servlet类(mvc的控制层)
1.1:new一个service类,
1.2:利用service对象调用service中的方法
1.3:将获得的结果保存到session中
步骤二:新建一个service类(mvc的模型层)
2.1:new一个dao类
2.2:调用dao中的方法将获得的结果返回给上一级
步骤三:新建一个Dao类(mvc的模型层)
3.1:new一个queryrunner对象
3.2:创建一个sql语句
3.3:到数据库查询数据,返回一个javabean对象并返回给上一级
步骤四:新建一个JSP(MVC的视图层)
4.1:新建一个表格结构
4.2:接收页面中保存的session值
4.3:将session的内容进行遍历,并显示到页面上
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |