同学们，今天我们学习了Session和JSP，这算是我们JavaWeb阶段的核心内容了，今天需要大家考虑一个问题，我学了Cookie、Session和JSP，到底和之前没学的时候有了哪些改变，我通过学习这些，我可以完成哪些功能了。自己一定要动脑去思考，去总结。

今日需要掌握的有：

• 熟练掌握Session的作用范围，及创建、销毁时间（对比着ServletContext和Request一起记忆）
• JSP最需要掌握的是：JSP脚本、JSP内置对象和四大域及作用范围（非常重要）
• 熟练案例中的实际代码操作
  
  

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

王刘锁
就是这个Session搞的我头快炸了!可Cookie不同的是Session是域对象,但是Session依赖于
Cookie当服务器第一次访问getSession()这个方法时,服务器会创建一个Session对象,并且会生
成一个识别id,当服务器做出响应会把这个id响应给浏览器保存在cookie中,因为Session是会话
技术,有id我们就可以找到这个Session对象,如果我们没有设置cookie的MaxAge(),那当我们关
闭浏览器,虽然Session域不会销毁但是存储id的cookie销毁了,我们也就不能获取这个Session
了,ServletContext对象是当启动服务器,会为每一个项目创建一个域,作用在整个项目,当服务
器关闭或项目从服务器中移除域才会消失,Request对象是当我们浏览器做出请求就会创建,作用
在一次请求,一旦服务器做出响应就消失,
据说jsp不流行了?学起来很难的,总是记不住语法,今天学习jsp这种动态页面开发技术,它是先
被翻译成Servlet然后编译成class再进内存执行的,我们主要学习它的一些脚本语言,内置对象(
面试会被问到)还有jsp的四个域的作用范围,下面就来详细说下这个让人恼火的jsp,
1,脚本语言:就是那三个往jsp写Java代码的格式<%%>,<%!%>,<%=%>,这个昨天好像说过了,
2,九大内置对象-面试题:有些是之前用过的,内置对象就是可以在代码中直接调用
request--HttpServletRequest==getParameter(),setAttribute("name",Object value);
response --HttpServletResponse--setHeader("name","value"),getWriter();
session--HttpSession--setAttribute(),getAttribute();
application--ServletContext()--同上
page--Object--toString(),wait();--jsp翻译成Servlet后的类的引用
config--ServletConfig--getServletName/Value()
out--JspWriter--write(),print();
exception--Throwable--getMessage(),getCause();
pageContext--PageContext--set/getAttribute();这时重点了解,它可以获取其它8个对象,还
可以像jsp四个域中存取数据,
四大域对象:requestScope,aoolicationScope,sessionScope,这三种就是上面说的三种域,另外
一种是pageScope只不过这中域是在当前页面有效的,跳转了页面就失效了,案例代码啥的就不敲
了,还有点迷糊呢.还没有完全熟悉.

许剑鸿  webDay17

Session:是将数据保存到服务器端.利用Cookie回写一个Session的ID.获得Session对象域的方法:request.getSession();
Session的作用范围为一次对话(多次请求)
Session创建:第一次调用getSession方法时创建
Session销毁:
* 1.session过期. 默认过期时间为30分钟.
* 2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
* 3.手动调用session.invalidate();

JSP脚本元素(JSP中嵌入Java代码):
1* <%!    %>:翻译成类中的成员部分. 定义变量,定义方法,定义类.Servlet是线程不安全的,尽量少在类中定义成员属性！！
2* <%     %>:翻译成类的service方法内部的内容. 定义变量,定义类,直接写代码块.
3* <%=    %>:翻译成service方法内部的out.print();

JSP九大内置对象(在Jsp中不用new就可以直接使用的对象)
1`request 2`response 3`session 4`application 5`page 6`pageContext(重要) 7`config 8`out 9`exception

pageContext :
1 可获得其它8个内置对象
2 向jsp的4个域中存取数据
4个域:
(1):PageScope      :当前页面中有效
(2):RequestScope   :一次请求范围中有效
(3):SessionScope     :一次对话范围中有效
(4)ApplicationScope     :应用范围(在服务器正常开启至关闭中有效?)

柯威龙
今天学习了另外一个会话技术 Session 他的数据是保存在服务器端的.不过session的执行原理是基于
cookie上的.今天主要用session来完成购物车的案例.在完成购物车案例里,需要创建一个Map集合.
session也是一个域对象.它的创建是在服务器端第一次调用getsession()创建session的.销毁方式
的话有三种情况.第一种是session过期,某人的时间是三十分钟.这个时间我们是可以去代码里面调整
的.第二种是非正常关闭服务器,如果是正常关闭服务器的话session是序列化到硬盘的.第三种是手动
调用session.invalidate()的方法来使其关闭.
还学习了JSP,学习了注释,指令,内置对象和动作标签.
猪似的话分为html,java代码注释,jsp的注释. 指令的话也分为三种 一种是page指令,include指令和
taglib指令.errorPage指令 设置错误友好以页面的提示.他可以设置全局的错误友好页面.在web.xml
设置.jsp还有就打的内置对象.有1.request  2.response  3.session  4.application  5.page
6.pageContext   7.config   8.out  9.exception  pageContext可以直接使用来获取其他的八个
内置对象. 还对jsp的四个域范围进行了讲解
pageScope           当前页面中有效         pageContext      PageContext
RequestScope        次请求范围.            request             HttpServletRequest
SessionScope             次会话范围.            session             HttpSession
ApplicationScope    应用范围                    application      ServletContext       
动作标签 的作用是用来简化代码
        <jsp:forward >     :用来页面的转发
        <jsp:include>            :用于页面的包含
        <jsp:param>           :用于带有路径标签下,传递参数

苏海斌
Session就是将数据保存到服务器端的会话技术,基于Cookie回写SessionID的;
Session存取数据的方法:setAttribute(String name,Object value);和getAttribute(String name);
同时,session也是域对象,在服务器第一次调用getSession()时创建session;
而session被销毁有三种情况:
1.session过期时,session的默认过期时间为30分钟,
2.在非正常关闭服务器的时候,如果是正常关闭的话,session会序列化到硬盘,
3.手动调用session.invalidate()的时候;
session的作用范围:多次请求(一次会话)

JSP:
JSP是Java服务器端的页面
使用:JSP=HTML+Java代码+JSP自身的东西
执行JSP的过程:JSP翻译成Servlet,编译该Servlet类,生成class文件,得到执行

JSP的脚本:
<%!     %>翻译成Servlet中的成员内容,定义变量,方法,类.存在线程不安全,所以不建议
<%      %>翻译成Servlet中service方法内部的内容,定义类,变量
<%=     %>翻译成Servlet中service方法中的out.print();

JSP有三个指令:page指令,include指令和taglib指令
page指令有很多,重点掌握
contentType:设置浏览器打开这个JSP时采用的默认的字符集的编码
pageEncoding:设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码
import:在JSP中引入类对象,但import可以出现多次
include指令是指示JSP包含其他的页面
taglib指令指示JSP引入标签库,标签库还没学,暂时知道就好

JSP的内置对象是个重点!!!
内置对象是指在JSP中可以直接使用的对象,一共有9个!!!
1.request                HttpServletRequest                getParameter(),setAttribute(String name,Object value);
2.response        HttpServletResponse                setHeader(String name,String value);getOutputStream();getWriter();
3.session                HttpSession                        setAttribute();getAttribute();
4.application        ServletContext                        setAttribute();getAttribute();
5.page                Object                                toString();wait();
6.pageContext        PageContext                        setAttribute();getAttribute();
7.config                ServletConfig                        getServletName();getServletContext();
8.out                JspWriter                        write(),print();
9.exception        Throwable                        getMessage(),getCause();                 设置isErrorPage="true"


重点!!!
  page真实对象是Object,就是JSP翻译成servlet后的类的引用
  out和response.getWriter不是同一个对象!!!out的真实对象是JSPWriter,response获得writer是PrintWriter
**pageContext可以获得其他8个内置对象:编写通用性代码或者框架的时候
  向JSP的四个域中存取数据:
JSP的四个域范围:
PageScope                :当前页面中有效.        pageContext                PageContext
RequestScope                :一次请求范围.                request                        HttpServletRequest
SessionScope                :一次会话范围.                session                        HttpSession
ApplicationScope        :应用范围                application                ServletContext

最后还有JSP的动作标签,着重掌握include标签中静态包含和动态包含的区别

李志勇:
JSP中有9大内置对象:
* request                                HttpServletRequest                               
* response                                HttpServletResponse                               
* session                                HttpSession                                               
* application                                ServletContext                                       
* page                                        Object                                                       
* pageContext                                PageContext                                               
* config                                ServletConfig                                       
* out                                        JspWriter                                               
* exception                                Throwable       
JSP的动作标签:
<jsp:forward />        :用于页面的转发.
        <jsp:forward page="/demo1-jsp/demo3-object/demo3.jsp"></jsp:forward>
<jsp:include />        :用于页面的包含.（动态包含）
静态包含和动态包含的区别?(<%@ include%>和<jsp:include>)
<jsp:param />                        :用于带有路径的标签下,传递参数.
<jsp:useBean />                        :用于在JSP中使用JavaBean.
<jsp:setProperty />                :用于在JSP中向JavaBean设置属性的.
<jsp:getProperty />                :用于在JSP中获得JavaBean的属性.               
session何时创建和销毁?作用范围:
* 创建:服务器端第一次调用getSession()创建session.
* 销毁:三种情况销毁session:
    * 1.session过期. 默认过期时间为30分钟.
    * 2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
    * 3.手动调用session.invalidate();
* 作用范围:多次请求.(一次会话)       

施炎生
一.session何时创建和销毁?作用范围:
* 创建:服务器端第一次调用getSession()创建session.
* 销毁:三种情况销毁session:
    * 1.session过期. 默认过期时间为30分钟.
    * 2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
    * 3.手动调用session.invalidate();
* 作用范围:多次请求.(一次会话)

二.JSP的脚本
        <%!   %>:翻译成Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
        <%    %>:翻译成Servlet中service方法内部的内容. 定义类,变量
        <%=   %>:翻译成Servlet中service方法中out.print();

三.JSP内置对象：
* request                                HttpServletRequest                                getParameter(),setAttribute(String name,Object value);
* response                                HttpServletResponse                                setHeader(String name,String value);getOutputStream();getWriter();
* session                                HttpSession                                                setAttribute();getAttribute();
* application                        ServletContext                                        setAttribute();getAttribute();
* page                                        Object                                                        toString();wait();
* pageContext                        PageContext                                                setAttribute();getAttribute();
* config                                ServletConfig                                        getServletName();getServletContext();
* out                                        JspWriter                                                write(),print();
* exception                                Throwable                                                getMessage(),getCause();                         设置isErrorPage=”true”

四.JSP作用域范围：
* PageScope                    :当前页面中有效.        pageContext                PageContext
* RequestScope            :一次请求范围.                request                        HttpServletRequest
* SessionScope            :一次会话范围.                session                        HttpSession
* ApplicationScope      :应用范围                        application                ServletContext

游荣辉
总结       
        今天我就来跟你们说说Session
        Session是将数据保存到服务器端.利用Cookie回写一个session的ID.
        Session的执行原理：基于Cookie的.
        如何获得Session对象 request.getSession方法就可以得到了
        他是在服务器第一次调用request.getSession创建的,而销毁的方式有3种,1.过了默认时间30分钟2.非正常关闭服务器3.手动调用session.invalidate
        他的作用范围是一次会话
       

        还学了jsp,在jsp中直接可以调用的对象9种
       

        方法名                实体类                        常用的方法
        * request        HttpServletRequest        getParameter(),setAttribute(String name,Object value);
        * response        HttpServletResponse        setHeader(String name,String value);getOutputStream();getWriter();
        * session        HttpSession                setAttribute();getAttribute();
        * application        ServletContext                setAttribute();getAttribute();
        * page                Object                        toString();wait();
        * pageContext        PageContext                setAttribute();getAttribute();
        * config        ServletConfig                getServletName();getServletContext();
        * out                JspWriter                write(),print();
        * exception        Throwable                getMessage(),getCause();         想要使用就要设置isErrorPage=”true”

郭明杰
[Session]
Cookie本身有大小跟个数限制,Session没有限制,Cookie的数据保存在客户端,Session的数据保存在服务器端.

Session的执行原理是基于Cookie的
使用Session:
        *获得Session:request.getSession();
        

****************Session的作用域跟ServletContext类似,可以在全局调用


Session是一个域对象
  *session的创建和销毁时间?
        创建:*服务器端第一次调用getSession(),创建session
        销毁:
           1. session过期:session的默认过期时间是30分钟
           2. 非正常关闭服务器,直接点X,会使session销毁(如果正常关闭,session会序列化到硬盘)
           3. 手动调用session.invalidate();

        (关闭浏览器不会让session销毁,访问不到session的原因是携带id的cookie销毁了,所以访问不到session)
         作用范围* :多次请求,一次会话;
=====================================
[JSP] : Java Servlet Pages (java服务器页面)  抄过500遍
JSP的本质就是一个Servlet
JSP的注释有多种,可以用<%     %> 在里面写java的注释

[JSP的指令]
*指令的语法: <%@ 指令名称 属性名称="属性值"  属性名称="属性值"   ...%>
*JSP中有三个指令:page指令 ,include指令 ,taglib指令
*JSP中的page指令: <%@ page%> --设置JSP的
        language :JSP脚本中使用的语言,现在只能写java
        contentType: 设置浏览器打开这个JSP的时候采用的默认的字符集的编码
        pageEndoding:设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬

盘上的编码
        import :在JSP中引入类对象,import可以出现多次
        extends
        autoFlush :设置JSP的缓存自动刷出,true为自动刷出
        buffer   :设置JSP的缓冲区的大小,默认8kb;1        
        session :

[JSP的内置对象] 可以在JSP直接使用的对象
request  response  session  applocation  page  pageContext  config  out  

exception

page内置对象 :真实对象是Object,就是JSP翻译成Servlet后的类的引用;
out 内置对象 :out跟response.getWriter是不是同一个对象?区别是?
                *不是.out真实对象JspWriter ,response获得的Writer 是printWriter
pageContext内置对象  :
        *获得其他8个内置对象
        *向JSP的四个域对象存取数据
                JSP的四个域范围:
                  *PageScope                :当前页面中有效   pageContext     

PageContext
                  *RequesScope                :一次请求范围          request        
                  *SessionScope                :一次会话范围          session
                   *ApplicationScope        :应用范围          application

郑雪平

今天学了如何使用session技术把商品添加到购物车和如何使用jsp把商品信息显示在页面上,session和cookie一样

都是属于会话技术的一种,区别在于cookie有大小和个数的限制而session没有,cookie是把数据存储在客户端而

session是存储在服务器端的,session是个域对象,所以可以用来存取数据,保存用户的信息.我们还可以使用session来实现一次性验证码的校验.session在服务

器端第一次调用getsession()方法时被创建的,至于销毁则有三种方式:1.时间过期,默认时长为30分钟;2.使用

非正常手段关闭服务器,如果是正常关闭session的话,则会序列号到硬盘的;3.手动调用了

session.invalidate()方法.session的作用范围用一句话来说就是:一次会话多次请求.

     jsp是java的服务器端页面,jsp的执行流程是:首先jsp先被翻译成servlet,接着编译servlet的这个类,

再接下来是生成class文件,最后才被执行.jsp有三大指令:1.page指令;2.include指令;3.taglib指令.jsp中还

有9个内置对象,其中pagecontext这个内置对象可以获得其他另外的八个内置对象,jsp有四个域范围以

及很多的动作标签,比较常用的且需要记的有6个.

江某人:
熟练掌握Session的作用范围，及创建、销毁时间:
session何时创建和销毁?作用范围:
创建:服务器端第一次调用getSession()创建session.
销毁:三种情况销毁session:
     1.session过期. 默认过期时间为30分钟.
     2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
     3.手动调用session.invalidate();
作用范围:多次请求.(一次会话)       
JSP最需要掌握的是：JSP脚本、JSP内置对象和四大域及作用范围:
PageScope      :当前页面中有效
RequestScope   :一次请求范围中有效
SessionScope     :一次对话范围中有效
ApplicationScope     :应用范围(在服务器正常开启至关闭中有效?)

王清松
JSP(Java Server Pages)
        JSP的实现
                被翻译成Servlet，编译程成class进行执行
                默认创建Session
        组成
                HTML
                嵌入Java代码
                        <%! %>翻译成类的成员部分，Servlet是线程不安全的，尽量不定义成员属性
                        <% %>翻译成service方法内部的内容
                        <%= %>翻译成service方法内部的out.print()
                JSP
                        三种注释
                                HTML注释
                                        <!--  -->
                                        存在范围
                                                JSP源码
                                                翻译后的Servlet
                                                生成的HTML
                                Java注释
                                        //
                                        /*
*/
                                        /**
*/
                                        存在范围
                                                JSP源码
                                                翻译后的Servlet
                                JSP注释
                                        <%-- --%>
                                        存在范围
                                                JSP源码
                                翻看JSP翻译成Servlet后的源代码
                                        D:\develop\apache-tomcat-7.0.69\work\Catalina\localhost\MyWeb\org\apache\jsp\Store
                        指令
                                语法
                                        <%@ 指令名称 属性名称="属性值" 属性名称="属性值"...%>
                                三大指令
                                        page
                                                作用：设置JSP
                                                属性
                                                        language
                                                                JSP脚本中所使用的语言
                                                                目前只能写java
                                                        contentType
                                                                设置浏览器打开这个JSP时所采用的字符集编码
                                                        pageEncoding
                                                                设置文件保存到本地硬盘，以及生成Servlet后，保存到硬盘时的字符集编码
                                                        import
                                                                在JSP引入jar包
                                                                注意：import属性可以出现多次，其余属性只能出现一次
                                                        extends
                                                                设置JSP翻译成Servlet后继承的类
                                                                默认为org.apache.jasper.runtime.HttpJspBase
                                                                若想更改，只能改为HttpServlet的子类
                                                        buffer
                                                                设置JSP的缓冲区的大小
                                                                默认8kb
                                                        autoFlush
                                                                设置JSP的缓存自动刷出
                                                                默认为true：自动刷出
                                                        session
                                                                设置在JSP中是否默认创建session对象
                                                                默认为ture
                                                        isELIgnored
                                                                设置在JSP中是否忽略EL表达式
                                                                默认为false不忽略
                                                        设置错误友好页面
                                                                errorPage
                                                                        设置错误友好页面的提示
                                                                        已经在服务器内，路径不需要写工程名
                                                                isErrorPage
                                                                        设置JSP的错误信息
                                                                        默认为false不显示
                                                                设置全局错误友好页面
                                                                        <error-page>
          <error-code>404</error-code>
          <location>/404.jsp</location>
</error-page>
<error-page>
          <error-code>500</error-code>
          <location>/500.jsp</location>
</error-page>
                                        include
静态包含
                                                作用：指定JSP包含其他的页面
                                                属性
                                                        file
                                                                被包含的页面的路径
                                                                相对路径
                                                注意
                                                        被包含的部分不需要写结构体，直接写被包含的部分
                                        taglib
                                                作用：在JSP中引入标签库
                                                属性
                                                        uri
                                                                标签路径
                                                        prefix
                                                                标签的别名
                        内置对象——真实对象
                                概述
                                        在JSP中可以直接使用的对象
                                request——HttpServletRequest
                                respinse——HttpServletResponse
                                session——HttpSession
                                application——ServletContext
                                config——ServletConfig
                                exception——Throwable
                                page——Object
                                pageContext——PageContext
继承自JSPContext
                                        获得其他的8个内置对象
                                                主要在编写框架，通用性很高的代码中，作为浓缩的对象参数传递，传1个对象顶9个
                                        JSP的4个域范围
                                                真实对象                内置对象                域范围
ServletContext        application                应用范围(工程内)
HttpSession        session                一次会话范围
ServletRequest        request                一次请求范围
PageContext        pageContext        当前页面
                                        API
                                                获取数据
                                                        pageContext.findAttribute(String name)
                                                                从小到大范围进行查找，找到了返回，如果都没找到
                                                读取数据
                                                        pageContext.getAttribute(String name, Object value)
                                                存入数据
                                                        pageContext.setAttribute(String name, Object value, int scope)
                                                                int scope
                                out——JspWriter
                                        与response.getWriter()，返回的是PrintWriter对象
                                        JspWriter和PrintWriter都是字符流，各自有缓冲区，JspWriter的缓冲区的内容会被输出到response里面，然后统一输出到页面
                        动作标签
                                概述
                                <jsp:forward/>——用于页面转发
                                        属性page="转发路径"
                                <jsp:include/>——用于页面包含(动态包含)
                                <jsp:param/>——用于带有路径的标签下，传递参数
                                        举例
<jsp:forward>
        <jsp:param value="aaa" name="name"/>
<jsp:forward/>
                                        但是一般传参都用域对象
                                <jsp:useBean/>——用于在JSP中使用JavaBean
                                <jsp:setProperty/>——用于在JSP中向JavaBean设置属性
                                <jsp:getProperty/>——用于在JSP中获得JavaBean的属性
                        静态包含和动态包含的区别
                                静态包含
                                        1.找到目标文件
2.将目标文件的代码复制到自身位置
3.然后翻译成一个Servlet类型的.java文件
4.然后编译成一个.class
5.执行
                                动态包含
                                        1.找到目标文件
2.目标文件翻译成Servlet类型的.java文件，编译成class，执行，然后将结果返回
3.自身也翻译成Servlet类型的.java文件，编译成.class，执行

Session
        概述
                将数据保存到服务器
                大小和个数不限
                执行原理，基于Cookie
        生命周期
                作用范围:多次请求，一次会话
                创建
                        第一次调用getSession()
                销毁
                        过期：Tomcat默认30分钟
                        非正常关闭服务器
                                正常关闭，session会序列化到硬盘（项目根目录下的.ser文件）
                        手动调用.invalidate()
                                void invalidate()
          Invalidates this session then unbinds any objects bound to it.
        HttpSession

詹源
Session:
Session和Cookie区别:
cookie有大小个数限制,Session没有.
Cookie数据保存在客户端.Session数据保存在服务器端
使用Session:
        获得Session:


Session 也是个域对象
作用范围:
多次请求.一次会话
创建于服务器端第一次调用getSession()创建session.
三种销毁方式:
1.session过期,默认有效时间30分钟.
2.非正常关闭服务器.来不及序列化到硬盘.正常关闭session则序列化到硬盘
3.调用方法:session.invalidate();

JSP:
JSP跟Servlet一样,是sun公司开发的一个动态网页开发技术
但是因为Servlet本身存在缺陷,竞争力不足,所以推出了JSP

JSP构成
JSP= HTML + Java代码 + JSP自身的东西

JSP的执行
JSP翻译成Servlet,然后编译这个Servlet的类,生成class文件,得到执行.

JSP的脚本
<%!  %>             :翻译成Servlet中的成员内容.定义变量,方法,类.---不建议
<%   %>      :翻译成Servlete中service方法内部的内容.定义类,变量
<%=  %>      :翻译成Servlete中service方法中out.print();

JSP的注释
HTML的注释                :<!-- 注释 -->
Java代码的注释                :// 单行注释 /*多行注释*/ /** 文档注释 */
JSP的注释                :<%-- JSP的注释 --%>

JSP的指令
指令的语法:
<%@ 指令名称 属性名称=”属性值” 属性名称=”属性值” ...%>
JSP中有三个指令:page指令, include指令, taglib指令

JSP的内置对象:在JSP中可以直接使用的对象.
JSP中有9大内置对象

陈叶隆
案例一：将商品添加到购物车
注意点:
//创建Map集合用于保存购物信息.Map<String,Integer>的key是商品的名称,value是数量
Map<String,Integer> map = (Map<String,Integer>) request.getSession().getAttribute("cart");
if(map == null){
                        map = new LinkedHashMap<String,Integer>();                }
// 判断购物车中是否已经买了该商品.
if(map.containsKey(name)){
                        Integer count = map.get(name);}
// 将Map集合保存到session中.
                request.getSession().setAttribute("cart", map);
response.getWriter().println("<h3><a href='/day11/demo2/product_list.jsp'>继续购物</a> | <a href='/day11/demo2/cart.jsp'>去结算</a></h3>");

案例二: 进行一次性验证码的校验
注意点:
String code1 = request.getParameter("code");
        String code2 = (String) request.getSession().getAttribute("code");
                //为了确保验证码用一次,做删除处理
request.getSession().removeAttribute("code");
                if(!code1.equalsIgnoreCase(code2)){
                        request.setAttribute("msg", "验证码输入错误！");
request.getRequestDispatcher("/demo2/login.jsp").forward(request, response);
                        return ;
JSP:
i)设置全局的错误友好页面：
* 在web.xml中设置:
  <error-page>
          <error-code>404</error-code>
          <location>/404.jsp</location>
  </error-page>
ii)pageContext内置对象:
* 获得其他的8个内置对象        :编写通用性代码或者框架的时候.
* 向JSP的四个域中存取数据        :
iii) 静态包含和动态包含的区别?(<%@ include%>和<jsp:include>)
静态包含相当于直接拷贝代码到主jsp中,动态包含是自己翻译成java,之后编译成class.

张育辉
Session:是将数据保存到服务器端.利用Cookie回写一个Session的ID.获得Session对象域的方法:request.getSession();
                Session的作用范围为一次对话(多次请求)
                Session创建:第一次调用getSession方法时创建
                Session销毁:
                1.session过期. 默认过期时间为30分钟.
                2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
                3.手动调用session.invalidate();       
       
        四:jsp的指定
                        语法:<%@ 指令名称 属性名称=”属性值” 属性名称=”属性值” ...%>
                        JSP中有三个指令:page指令, include指令, taglib指令
                        page指令-|
                                        -|contentType        :设置浏览器打开这个JSP的时候采用的默认的字符集的编码.
                                        -|pageEncoding        :设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码.
                                        -|import                :在JSP中引入类对象.但是import可以出现多次
                        设置全局的错误友好页面：在web.xml中设置:比如你页面有错误(资源不存在)的话,可以跳转到一个指定的页面,
                                        <error-page>
                                        <error-code>404</error-code>
                                        <location>/404.jsp</location>
                                  </error-page>
                                  <error-page>
                                        <error-code>500</error-code>
                                        <location>/500.jsp</location>
                                  </error-page>
                  
                include指令-|指示JSP包含其他的页面.
                                        -|静态包含：把其它资源包含到当前页面中。
                                        <%@ include file="/include/header.jsp" %>
                                        动态包含：
                                        <jsp:include page="/include/header.jsp"></jsp:include>

                                        两者的区别：翻译的时间段不同
                                        前者：在翻译时就把两个文件合并复制到自己的jsp文件中,副jsp定义的变量,正jsp可以使用
                                        后者：不会合并文件，当代码执行到include时，才包含另一个文件的内容。

                                        原则：能用静的就不用动的

                taglib指令-|作用：在JSP页面中导入JSTL标签库。替换jsp中的java代码片段。
                                        <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

        五:jsp的九大内置对象
                                request
                                response
                                session
                                application   前身就是ServletContext
                                exception
                                page   
                                config
                                out
                                pageContext    本身也是一个域对象：它可以操作其它三个域对象（request session application）的数据
                               
        六: JSP的四个域范围:
                                PageScope                :当前页面中有效.
                                RequestScope        :一次请求范围.
                                SessionScope        :一次会话范围.       
                                ApplicationScope:应用范围       

陈世彪:
今天学习了Session&JSP
Session:是将数据保存到服务器端.利用Cookie回写一个Session的ID.获得Session对象域的方法:request.getSession();
获取的Session是获取到一个Cookie钥匙再通过钥匙区服务器里找
Session的作用范围为一次对话
ServletContext是公共的,在项目里都可以访问
Request是单独的,一次访问创建一次,结束后就销毁
Session创建:第一次调用getSession方法时创建
Session销毁:
1.session过期. 默认过期时间为30分钟.
2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
3.手动调用session.invalidate();
JSP的脚本
<%!   %>  :Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
<%    %>  :Servlet中service方法内部的内容. 定义类,变量
<%=   %>  :Servlet中service方法中out.print();
JSP中有9大内置对象:
request    HttpServletRequest    getParameter(),setAttribute(String name,Object value);
response    HttpServletResponse    setHeader(String name,String value);getOutputStream();getWriter();
session    HttpSession      setAttribute();getAttribute();
application   ServletContext     setAttribute();getAttribute();
page     Object       toString();wait();
pageContext   PageContext      setAttribute();getAttribute();
config    ServletConfig     getServletName();getServletContext();
out     JspWriter      write(),print();
exception    Throwable      getMessage(),getCause();   
1:PageScope      :当前页面中有效
2:RequestScope   :一次请求范围中有效
3:SessionScope     :一次对话范围中有效
ApplicationScope     :应用范围

刘文峰
session也是一个会话技术,可以将数据保存在服务器端.同时也是一个域对象,可以存取数据.用户发出请求并第一次调用getSession()方法时创建session,默认生效时间为半小时,可以在web.xml配置文件中进行修改(<session-config>中的<session-timeout>);调用session.invalidate()方法可以销毁session;非正常关闭服务器也会直接销毁.
Jsp嵌入java代码的方式有三种
1  <%!    %>:翻译成类中的成员部分. 可以定义变量,定义方法,定义类.
2  <%     %>:翻译成类的service方法内部的内容. 可以定义变量,定义类,直接写代码块.
3  <%=    %>:翻译成service方法内部的out.print();

        jsp有9个内置对象
1.request  2.response  3.session  4.application  5.page  6.config   7.out  8.exception  9.pageContext(可以获得其他的的内置对象,servlet只有三个域对象,pagecontext可以看做只属于jsp内的第四个域对象)
        jsp的四个作用域(可直接用pageContext操作四个域的属性):
1.PageScope  :只在当前页面中有效,跳转页面立即失效
2.RequestScope   :一次请求有效,响应后立即失效
3.SessionScope   :一次会话有效,管理浏览器后立即失效
4.ApplicationScope   :web工程中有效,服务器关闭或移除工程时失效

侯玉林
今天讲了域对象session,和jsp

颜琳琳
Session也是一个回话技术,其的执行原理：基于Cookie的.(作用的范围是一次会话,多次请求) 同时session还是一个域对象,创建的时间是:服务器第一次调用getSession()方法时创建,销毁的方式有三种:1. session过期,默认的时间是30 分钟; 2.非正常关闭服务器,正常关闭不会将session销毁,而 会将其序列化到硬盘; 3.手动调用session.invalidate()
获得Session的方法有:  request.getSession()
Session添加购物车案例的步骤:1.获取商品名称,2.创建一个Map集合来存取数据,3.进行判断购物车是否有商品,没有就将获取到的商品名称和数据添加到集合,有的话就在原有的商品上的数量加1, 4.最后将Map集合添加到session.
JSP是java服务器端的页面.JSP的执行过程:JSP翻译成Servlet,编译这个Servlet的类,生成class文件.得到执行.JSP的指令有三种1.page指令, 2.include指令, 3.taglib指令
1.<%@page %>指令是用来设置JSP,需要知道的有如下:
contentType        :设置浏览器打开这个JSP的时候采用的默认的字符集的编码.
pageEncoding        :设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码.
import                :在JSP中引入类对象.但是import可以出现多次.
设置全局的错误友好页面：在web.xml中设置:
  <error-page>
          <error-code>404</error-code>
          <location>/404.jsp</location>
  </error-page>
  <error-page>
          <error-code>500</error-code>
          <location>/500.jsp</location>
  </error-page>
2.<%@include %>指令是用来指示JSP页面包含其他页面
<%@taglib %>指令是用力啊指示JSP引入的标签库

JSp的内置对象有九种分别为:
1.request, 2.response, 3.application, 4.page,5.out,6.session,7.pageContext,8,config,9.exception分别对应的真实类对象:httpServletrequest , httpServletresponse , ServletContext , Object , JspWriter , PageContext , ServletConfig , Throwable
2.其中pageContext内置对象                :
     获得其他的8个内置对象        :编写通用性代码或者框架的时候. 向JSP的四个域中存取数据:
JSP的四个域范围:
PageScope                        :当前页面中有效.               
        RequestScope                        :一次请求范围.               
        SessionScope                        :一次会话范围.               
        ApplicationScope                :应用范围                               
3.动作标签化:
标签的作用:简化代码.
<jsp:forward />                        :用于页面的转发.
<jsp:forward page="/demo1-jsp/demo3-object/demo3.jsp"></jsp:forward>
<jsp:include />                        :用于页面的包含.（动态包含）
*****静态包含和动态包含的区别:(<%@ include%>和<jsp:include>)
静态包含是直接copy然后进行翻译成Servlet然后再编译成class之后再执行,而动态包含是将原来的和包含的一起进行翻译成Servlet然后编译成Class之后,将包含的执行结果传给原来的,然后在输出到页面.
<jsp:param />                        :用于带有路径的标签下,传递参数.
<jsp:useBean />                        :用于在JSP中使用JavaBean.
<jsp:setProperty />                :用于在JSP中向JavaBean设置属性的.
<jsp:getProperty />                :用于在JSP中获得JavaBean的属性.

汪志阳:
Session域对象:
request.getSession()第一次创建Session,后面不再创建,而是获取Session,完成一次会话会销毁
cookie与Session的区别在于:cookie有大小限制,cookie的数据保存在客户端,Session的数据保存在服务器端
但是Session是基于cookie进行数据的传递的.
销毁它有三种方法:1.session自动过期,即长时间放置,默认时间为30分钟;2.非正常关闭服务器,
3.手动调用session.invalidate().
JSP(Java Server Pages):
即Java服务端的页面.JSP = HTML + Java代码 + JSP自身的东西.执行的过程为:jsp翻译为Servlet,
编译这个Servlet类,生成class文件,最后才能得到执行.
要在jsp中写入java语言,就要使用jsp的脚本,分为三种:?<%!   %>        :翻译成Servlet中的成员内容.可以定义变量，方法，类
<%    %>:翻译成Servlet中service方法内部的内容.可以定义类,变量 ;<%=   %>:翻译成Servlet中service方法中out.print();
JSP的指令:page指令,include指令,taglib指令;
指令的语法:<%@ 指令名称 属性名称=”属性值” 属性名称=”属性值” ...%>
设置全局错误的提示页面:在web.xml中设置:  <error-page>
                                                                                <error-code>404</error-code>
                                                                                <location>/404.jsp</location>
                                                                                </error-page>
                                                                                <error-page>
                                                                                <error-code>500</error-code>
                                                                                <location>/500.jsp</location>
                                                                                </error-page>
include指令:指示JSP包含到其他页面.就是将各部分的jsp内容进行提取
<%@include file="logo.jsp" %>
<%@ include file="menu.jsp" %>
<h1>BODY部分</h1>
<%@ include file="footer.jsp" %>
JSP的内置对象:在jsp中可以直接使用的对象,有9个内置对象,我们可以通过pageContext对象调用方法获取其它的内置对象,由于现在的jsp中不流行写java代码
所以这些对象只有在编写通用性的代码或者框架的时候使用.
JSP的四个域范围:PagesScope(只在当前页面有效);RequestScope(一次请求范围);SessionScope(一次会话范围);ApplicationScope(英语范围内)
JSP的动作标签:静态包含,可以使用被包含对象的数据;动态包含不可以.