同学们，今天我们主要就学习了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:获取数据
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的内容进行遍历,并显示到页面上

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:?> ?里就是标签名了,使用又是另外一说了,只要你会格式,使用问题都不大,都是要自己去练的;函数库的话,就有种似曾相识的感觉了,没错就是对字符串的操作,我不知道还有没有其他用途今天是只了解了这个.

使用EL表达式:
        语法:${ EL表达式 }
EL的功能:
        获取数据:(JSP的四个域)
        执行运算:
        操作WEB开发的常用的对象:
        调用Java中方法:--很少用.
JSTL的核心标签的用法:
<c:if var="i"  text="条件"></c:if>
<c:forEach var="i" items='要遍历的对象'>
        ${ i }
</c:forEach>

王清松
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","-")}
                                        获得的是一个数组，可以遍历
                                与字符串处理相关的操作

黄进安:

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操作标签。

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/>

陈昆明:
25.用EL表达式进行元素查找的功能实现时,如果使用了简写模式(${name}),那么查找范围会从小到大开始进行查找,而且只会找到一个.使用EL表达式的时候,如果该域对象里面的值为空,那么得到的是””,而非EL表达式则会返回null
26.EL的算术运算:会将字符串数字进行转换后再进行计算
pageContext能够获取其他8个内置对象,功能比pageScope强大多了
pageScope只能获取域中的数据
param对象主要功能为接收参数,但是在目前的MVC模式中,这种方式很少使用了,因为现在这些参数一般直接传到Servlet中进行处理了,不会在jsp中处理
27.out标签中的default属性要和value属性(为变量)结合使用               
28.内省技术获得的属性的个数是看get/set方法的,与成员变量无关

邵倩


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也是如此

林荣彬
   今天主要学习的内容有三个:
一: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

曾耀峰
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;

叶凌青
今天学了EL表达式 最重要的功能是1.从域中获取数据 2.还可以执行运算
常用的11对象,要掌握的是cookie pageContext
jstl
主要掌握 if标签和foreach标签
要导入两个jar包
还学习了MVC设计模式
M模型层  domain+dao+service
V视图层 jsp
C控制层 servet
自己做的总结挺乱,就不上传了.

黄志彬
今天学习了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:控制层

[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=””%>

施炎生
今日总结：
今日重点掌握了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循环内两个)，美元符外双引号内的空间不能出现空格。

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(开始)

吴俊斌
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

何平波
今天学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>

汪志阳:
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开发模式,今天主要进行初步介绍,明天进行进一步的学习.

侯玉林
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 }