同学们，今天我们主要就学习了EL和JSTL表达式，它们可以很方面的在JSP中获取数据以及做各种运算

今日需要掌握的有：

• 掌握EL的表达式的用法
• 掌握JSTL的常用标签的使用
  
  

请同学们按照如上要求，总结今日所学。

王刘锁
先补一下昨天的代码!拿作业来说吧,作业的要求是注册成功后转到登录界面,登陆成功后跳转到商品列表页面,但是如果没有登录会提示去登录并且看不到商品列表,商品列表中有购物车按钮和添加商品到购物车的功能,购物车同样不登录无法看到,购物车中有移除单个商品的功能,那在写代码的时候需要定义注册,登录,添加商品和移除商品的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"),"-"}结果是数组,今天差不多就这些内容!!

颜琳琳
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=”” %>,

吴鹏

总结:

----------------------------------------------------
掌握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>

万冕

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:大多操作的是字符串的函数>

柯威龙
EL作用就是可以简化jsp中java的代码.EL使用的语句是${}.
EL四个功能是:   1.获取数据只能获取jsp中的四个域
                2.可以运算
                3.操作WEB开发的常用对象
                4.调用java中的方法(但是这个很少用到)
JSTL是一个标签库.使用EL加上JSTL可以直接简化<%%>.让代码看起来跟简洁也会更方便.JSTL包含了
五类标签.但是核心标签是if和forEach.在使用JSTL之前都需要引入两个包.

许煜
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}可以表示当前遍历的次数
                     

苏海斌
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>

常小天
今天学习的是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的设计模式二。

张裕
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 给对象类的成员变量赋值


感觉最近标签啊 方法啊东西太多 使用的又太少 页面也做了好几次 但是总是想不起有什么便利的方法可以供自己使用 总觉得学的
方法不懂在何时使用 有点头痛

16weisong
今天主要学习了el表达式+jstl和初步学习mvc知识,3el+jstl是用来替换jsp中的<% %>,mvc是一种开发思想,m是模型用来封装数据,v是视图用来显示数据,c是控制器用来控制业务流程.今天只需把老师布置的作业敲了就没问题

许剑鸿 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

郑阳阳
掌握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","-")} 按-符号切割

詹源
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       

吴利君
今天学了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，而且后面的框架也都基于这种模式。

郑雪平

今天学习了三方面的内容：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.在页面中引入标签库文件。

林文辉
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">商城价：&yen;${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;">
                                登录后确认是否享有优惠&nbsp;&nbsp;
                        </em> 赠送积分: <em style="color:#ff6600;">${cart.total/20 }</em>&nbsp; 商品金额: <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>

张育辉
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控制
               
               
               

杜石苇
${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>

游荣辉
总结
        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:控制层