黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】Session&JSP [打印本页]
作者: 厦门校区 时间: 2018-6-6 20:38
标题: 【厦门JavaEE就业1期-每日总结】Session&JSP
同学们，今天我们学习了Session和JSP，这算是我们JavaWeb阶段的核心内容了，今天需要大家考虑一个问题，我学了Cookie、Session和JSP，到底和之前没学的时候有了哪些改变，我通过学习这些，我可以完成哪些功能了。自己一定要动脑去思考，去总结。
今日需要掌握的有：
请同学们按照如上要求，总结今日所学。
作者: 许大炮 时间: 2018-6-6 21:16
许剑鸿 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 :应用范围(在服务器正常开启至关闭中有效?)
作者: 渣.. 时间: 2018-6-6 21:42
柯威龙
今天学习了另外一个会话技术 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> :用于带有路径标签下,传递参数
作者: sts 时间: 2018-6-6 21:43
苏海斌
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标签中静态包含和动态包含的区别
作者: 13163997058 时间: 2018-6-6 21:49
王刘锁
就是这个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只不过这中域是在当前页面有效的,跳转了页面就失效了,案例代码啥的就不敲
了,还有点迷糊呢.还没有完全熟悉.
作者: 李志勇 时间: 2018-6-6 21:52
李志勇:
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();
* 作用范围:多次请求.(一次会话)
作者: doudou0606 时间: 2018-6-6 21:56
施炎生
一.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
作者: 5119 时间: 2018-6-6 21:57
游荣辉
总结
今天我就来跟你们说说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”
作者: 偏离X 时间: 2018-6-6 21:57
本帖最后由 偏离X 于 2018-6-9 21:20 编辑
郭明杰
[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
作者: 厦门黑马王子 时间: 2018-6-6 21:58
郑雪平
今天学了如何使用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个.
作者: 滴滴eclipse启动 时间: 2018-6-6 21:58
江某人:
熟练掌握Session的作用范围，及创建、销毁时间:
session何时创建和销毁?作用范围:
创建:服务器端第一次调用getSession()创建session.
销毁:三种情况销毁session:
1.session过期. 默认过期时间为30分钟.
2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
3.手动调用session.invalidate();
作用范围:多次请求.(一次会话)
JSP最需要掌握的是：JSP脚本、JSP内置对象和四大域及作用范围:
PageScope :当前页面中有效
RequestScope :一次请求范围中有效
SessionScope :一次对话范围中有效
ApplicationScope :应用范围(在服务器正常开启至关闭中有效?)
作者: q55w66 时间: 2018-6-6 21:58
王清松
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
作者: 沅瞻 时间: 2018-6-6 22:00
詹源
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大内置对象
作者: chenyelong 时间: 2018-6-6 22:01
陈叶隆
案例一：将商品添加到购物车
注意点:
//创建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.
作者: finfin12 时间: 2018-6-6 23:25
张育辉
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:应用范围
作者: 一梦 时间: 2018-6-6 23:36
陈世彪:
今天学习了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 :应用范围
作者: 名字被人注册了 时间: 2018-6-6 23:40
刘文峰
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工程中有效,服务器关闭或移除工程时失效
作者: 光宇 时间: 2018-6-7 01:16
侯玉林
今天讲了域对象session,和jsp
作者: Yanmo_ 时间: 2018-6-7 06:29
颜琳琳
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的属性.
作者: 铁木啊童臂 时间: 2018-6-7 09:03
汪志阳:
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的动作标签:静态包含,可以使用被包含对象的数据;动态包含不可以.
作者: 磬辰 时间: 2018-6-7 09:31
林文辉
获得Session: request.getSession();
将商品添加到购物车:
String pid = request.getParameter("pid");
Integer count = Integer.parseInt(request.getParameter("count"));
//封装购物项
CartItems cartItems = new CartItems();
ProductService productService = (ProductService) BeanFactory.getBean("ProductService");
cartItems.setProduct(productService.findByPid(pid));
cartItems.setCount(count);
Cart cart =getCart(request);
cart.addToCart(cartItems);
response.sendRedirect(request.getContextPath()+"/jsp/cart.jsp");
销毁:三种情况销毁session:
session过期. 默认过期时间为30分钟.
非正常关闭服务器.如果正常关闭session序列化到硬盘.
手动调用session.invalidate();
验证码的校验：
String code1 = request.getParameter("code");
String code2 = (String)request.getSession().getAttribute("code");
request.getSession().removeAttribute("code");
//校验验证码是否一致
if(!code1.equalsIgnoreCase(code2)) {
request.setAttribute("msg", "验证码输入错误");
return "/jsp/login.jsp";
}
切换验证码：
$(function(){
$("#ImgCheck").click(function(){
$(this).attr("src","${pageContext.request.contextPath}/CheckImgServlet?time="+new Date().getTime());
});
});
<%! %> :翻译成Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
<% %> :翻译成Servlet中service方法内部的内容. 定义类,变量
<%= %> :翻译成Servlet中service方法中out.print();
Jsp有9大内置对象：
request
response
session
application
page
pageContext
config
out
exception
jsp4个领域有效范围：
pageContext:当前页面
request:响应之前
session:一次会话
applicatiton或者servletContext:只要服务器正常运行。
作者: COLDER 时间: 2018-6-7 11:11
本帖最后由 COLDER 于 2018-10-18 19:16 编辑
[Session And Jsp]
1.Session是什么?
Session是会话技术,也是域对象.ps:会话技术是从打开浏览器浏览各种页面到关闭浏览器的过程.
2.Session的作用?
Session的作用是将数据保存到服务器端.
3.Session的原理?
Session是通过request.getSession()的方法,从浏览器端发送请求到服务器端查找在服务器端
有没有存在Session的开辟的空间,如果没有找到Session则会创建一个新的Session来存放数据;如果找到了Session
则利用其存放在浏览器端的钥匙来打开Session空间,进行数据的添加.
*注意:每个用户的浏览器端都有在服务器端所对应的Session空间,互不干涉,所以Session是一个私有的空间,具有一定的
安全性.
4.Session的创建和销毁?
Session的创建是从服务器端第一次调用getSession()方法开始.
Session的销毁有三种情况:
(1)Session默认过期时间为30分钟.
(2)非正常关闭服务器,也就是点击console界面的Terminate按键,非正常关闭服务器将不会创建备份文件到硬盘中;
正常关闭服务器是点击Servers界面中的Stop the server按键,此时会在硬盘的阿帕奇文件夹中Work文件夹中创建备份文件(序列化),
当再次启动服务器就会加载备份文件(反序列化).
(3)手动调用session.invalidate()方法.
*注意:Session技术的底层是基于Cookie技术,所以如果是关闭浏览器的话,如果不设置Cookie的最大保存时间的话,Cookie将会被销毁,
那么基于Cookie的Session的钥匙传输也会丢失,也就是说存放于服务器端的Session空间也会丢失,当然如果是有记录下Session的钥匙
的话,那么服务器端的Session空间是可以被找回的.
5.案例:将商品添加到购物车
思路:
(1)点击商品列表中商品名或图片跳转到商品详情页面,然后点击添加到购物车按钮,跳转到CartServlet,
(2)首先是拿到商品的名字,然后将请求的Session空间赋值给map集合,判断map集合是否为空,如果为空,则创建新的map集合;
(3)判断map集合中有没有包含拿到的商品名称,如果有则将数量进行加1,再把商品名称和新的数量传入map集合(已经有添加到购物车过),
如果没有则默认将商品名称和数量1传入map集合(第一次添加到购物车).
(4)将map集合保存到Session空间中.
6.案例:进行一次性验证码的校验
思路:
(1)拿到浏览器端输入的验证码.
(2)拿到服务器端产生的验证码.
(4)判断这两个验证码是否一致.
(5)清空服务器端产生的验证码.
7.JSP是什么?
Java Server Pages(Java服务器端的页面),JSP=HTML+JAVA+JSP,JSP的本质是Servlet,可以查看其编译后的.java文件,JSP实现了servlet接口
8.JSP的指令?
JSP有三个指令:page指令,include指令,taglib指令
page指令:<%@ page%>,page指令的属性有contentType(设置浏览器打开JPS的默认字符集的编码),pageEncoding(设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码),
import(在JSP中引入类对象.但是import可以出现多次).
9.JSP的内置对象:
pageContext可以获得其他8个内置对象,pageContext.getAttribute();
pageContext可以向JSP的四个域中存取数据.
作者: 咸鱼coder 时间: 2018-6-7 11:12
万冕
今天学了第二种会话技术:
session:session的底层代码是基于Cookie的,但是session存的数据是在服务器内,session也是一个对象
生命周期:
作用范围是:多次请求,但是是存在于一次会话 随着第一次调用getSession()方法会创建session
有三种情况会摧毁session:
1.session的有效期过期,默认的过期时间为30分钟
2.非正常关闭服务器(直接拔电源),但是如果正常关机session会序列化到硬盘,等服务器再次启动时,服务器会将session
读取进去.
3.手动调用session.invalidate();也能摧毁session.
Jsp的九大内置对象
request(域对象) response session(域对象) application(域对象) page pageContext(域对象) config out exception
pageContext:
可以获得其他的八个内置对象:但是这个功能一般用在编写通用性非常高的代码或者框架里
可以向四个域中存放数据
session的生命周期:一次会话范围
request:一次请求范围
application: 类似于ServletContext全局变量,在整个工程内有效
pageContext:当前页面有效
作者: Eclipse启动 时间: 2018-6-7 11:29
郑阳阳
Session的作用范围，及创建、销毁时间:
session的作用范围就是一次会话,因为session是基于cookie的.
创建:在服务器第一次调用getsession()的时候创建session.
销毁有三种情况:
1.session的默认销毁时间是三十分钟.
2.非正常关闭服务器,正常关闭的的话会序列化session.
3.调用session.invalidate();方法
JSP脚本、JSP内置对象和四大域及作用范围:
JSP的脚本:
<%! %> 翻译成Servlet中的成员部分,定义成员变量方法和类,不过线程不安全,不建议使用
<% %> 翻译成Servlet中的service方法中的内容,定义类和变量
<%= %> 翻译成Servlet方法中的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四大域的范围:
RequestScope 一次请求
SessionScope 一次会话
ApplicationScope 应用范围
PageScope 当前页面有效
作者: 厦门陈强 时间: 2018-6-7 12:00
陈强
Session&jsp的一天
首先是学习了之前学过的域对象的另一个----session
为什么会有session呢?因为cookie本身有大小和个数的限制.而且cookie和session对于数据存储的位置也是不同的.
Session----将数据保存到服务器端
Cookie-----将数据保存到客户端—即浏览器端
而session是怎么执行的呢?每个session都会有一个JsessionID,第一次浏览器请求服务器的时候,就会创建一个session.而在第二次请求服务器的时候,就会带着JsessionID去服务器,然后服务器就会根据JsessionID找到之前创建的那一块空间,去进行数据的查询或者添加.
Session的作用范围是一次会话,(多次请求)
关于session的销毁就是三种情况,过期\非正常关闭服务器\手动invalidate方法,所以这边有一个值得注意的就是,关闭浏览器并未销毁session,而是销毁了带有JsessionID的cookie,在服务器端的session并未因为浏览器的关闭而被删除.
然后就是JSP的学习---JAVA SERVER PAGES
这部分都是关于JSP的一些注释\指令\内置对象等学习,主要都是相当于理论性的知识,比较少逻辑性的东西就不做过多的整理了.
作者: 林荣彬 时间: 2018-6-7 12:38
林荣彬
今天主要学习会话技术session,Session的执行原理：利用Cookie回写一个Session的ID.获得Session对象域的方法:request.getSession(); cookie和session的区别Cookie本身是有大小和数量限制的,Session是没有限制的.
Session是域对象:作用范围:多次请求(一次会话)
创建:服务器端第一次调用getSession()的时候创建session,
销毁:三种情况
1. session过期,默认过期时间为30分钟
2. 非正常关闭服务器,如果正常关闭session序列化到硬盘
3. 手动调用session.nvalidate()
JSP的脚本
<%! %> :翻译成Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
<% %> :翻译成Servlet中service方法内部的内容. 定义类,变量
<%= %> :翻译成Servlet中service方法中out.print();
JSP指令的语法:
<%@ 指令名称 属性名称=”属性值” 属性名称=”属性值” ...%>
JSP中有三个指令:page指令, include指令, taglib指令.
JSP的9大内置对象:
1.requst 2.response 3.session 4.application 5.page 6.pageContext 7.config 8.out 9.exception
page内置对象:真实对象是Object,就是JSP翻译成Servlet后的类的引用.
pageContext内置对象: 获得其他的8个内置对象:编写通用性代码或者框架的时候.向JSP的四个域中存取数据:
JSP的四个域范围:
PageScope :当前页面中有效.
RequestScope :一次请求范围.
SessionScope :一次会话范围.
ApplicationScope :应用范围
标签的作用:简化代码.
<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的属性.
作者: 张述明 时间: 2018-6-7 13:38
张述明
今天讲了session和jsp的一些内容
两个案例一个是商品添加到购物车另一个是验证码的问题
下面是重点的部分
Session
Cookie有大小和数量的限制,session没有.
Cookie的数据保存在客服端,session保存在服务器端
Session执行的原理基于cookie
Session是域对象
创建:服务器端第一次调用get Sesssion(),创建session
销毁:三种情况销毁
1. session过期:默认时间30分钟
2. 非正常关闭服务器. 正常关闭 如点击stop servers,序列化到硬盘
3. 手动调用session.invalidate();
作用范围
多次请求(一次会话)
Jsp的注解
1. html的注释:<!--注释--> 存在JSP的源码中,翻译成servlet中
2. java代码注释: //单行注释 存在JSP的源码中,翻译成servlet中
/* 多行注释*/
/** 文档注释*/
3. jsp注释:只会存在于JSP 的源代码中,被翻译成servlet后,jsp的注释就消失了
Jsp的指令(了解)
<%@ 指令名称 属性 属性值 %>
三大指令 page指令 include指令 taglib指令
<%@page%>--设置jsp的
* language :JSP脚本中使用的语言.现在只能写java.
* contentType :设置浏览器打开这个JSP的时候采用的默认的字符集的编码.
* pageEncoding :设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码.
* import :在JSP中引入类对象.但是import可以出现多次.
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
Extends:被翻译成servlet后继承的类,默认继承 :org.apache.jasper.runtime.HttpJspBase,
Autoflush:设置jsp的缓存自动刷出 默认是true
Buffer: :设置jsp的缓冲区的大小 默认是8kb.
Session:设置在jsp中是否可以直接使用session对象 默认是true
IsElignored:设置在jsp中是否忽略el 表达式
ErrorPage:设置友好页面的提示
IsErrorpage:通过这个设置来显示错误
设置全局错误提示 web.xml
Eeror-page
Error-code
Location
Jsp中的include指令 :指示jsp包含其他的页面
J
JSP中的include指令:指示JSP包含其他的页面.
<%@ include file="logo.jsp" %>
<%@ include file="menu.jsp" %>
<h1>BODY部分</h1>
<%@ include file="footer.jsp" %>
JSP中的taglib指令:指示JSP引入标签库.
<%@ taglib uri="标签的URI的路径" prefix="标签的别名" %>
Jsp的内置对象:在JSP中可以直接使用的对象
九大对象
JSP的内置对象:在JSP中可以直接使用的对象.
JSP中有9大内置对象:
request,response,out,session,page,application,config,exception,pageContext
pageContext内置对象 :
* 获得其他的8个内置对象 :编写通用性代码或者框架的时候.
* 向JSP的四个域中存取数据 :
JSP的四个域范围:
* PageScope :当前页面中有效. pageContext PageContext
* RequestScope :一次请求范围. request HttpServletRequest
* SessionScope :一次会话范围. session HttpSession
* ApplicationScope :应用范围 application ServletContext
作者: 376091692 时间: 2018-6-7 16:47
凌辉:
Cookie本身是有大小和个数的限制.Session没有限制.Cookie的数据保存在客户端,Session数据保存在服务器端.
Session的执行原理：基于Cookie的.
使用Session:
* 获得Session:
* request.getSession();
session何时创建和销毁?作用范围:
* 创建:服务器端第一次调用getSession()创建session.
* 销毁:三种情况销毁session:
* 1.session过期. 默认过期时间为30分钟.
* 2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
* 3.手动调用session.invalidate();
* 作用范围:多次请求.(一次会话)
作者: 望蜀 时间: 2018-6-7 19:31
邵倩
session
cookie的数据保存在客户端,有大小和个数限制 而session保存在服务器,没有限制
session的执行原理基于cookie
获得session: request.getSession();
创建: 服务器第一次调用getSession() 时创建session
销毁: 1.session过期,默认为30分钟
2.非正常关闭服务器. 如果是正常关闭 session序列化到硬盘
3.手动调用session.invalidate();
作用范围: 多次请求(一次会话)
JSP=HTML元素+JAVA代码+JSP内置对象
JSP的执行:JSP翻译成servlet,编译这个servlet的类,生成class文件,加载到JVM,打印html
JSP的脚本: <%! %> <% %> <%= %>
JSP的注释
<%-- JSP的注释 ：只会存在于 JSP的源代码中.翻译成Servlet后,JSP的注释就消失了. --%> 权限最高
<!-- HTML的注释：存在JSP源码中,存在于JSP翻译后的Servlet中,存在于生成的HTML中 -->
java代码的注释 和java中一样
JSP的指令: page include taglib
page指令中有3个重要的属性:
contentType 设置浏览器打开这个jsp的时候才用的字符集编码
pageEncoding:设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码
import 在JSP中引入类对象,但是import可以出现多次
设置全局的错误友好页面: 写一个404.jsp和一个500.jsp 再去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>
JSP的9大内置对象
request response session application(ServletContext) page(Object) pageContext config(ServletConfig) out(JspWriter) exception(Throwable)
pageContext内置对象:
获得其他8个内置对象(编写通用性代码或者框架的时候)
向JSP的四个域中存取数据(PageScope 当前页面有效,RequestScope 一次请求范围,SessionScope 一次会话范围,ApplicationScope 应用范围)
JSP的6个动作标签:
<jsp:forward/>
<jsp:include/>
<jsp:param/>
<jsp:useBean/>
<jsp:setProperty/>
<jsp:getProperty/>
静态包含
相当于代码的copy 直接将logo中的代码复制到index中
<jsp:include page="/demo1-jsp/demo4-tag/logo.jsp"></jsp:include> 翻译成 index_jsp.java 编译成class文件 执行
作者: Nevermo 时间: 2018-6-7 19:58
xuyu
Session及Jsp总结
创建
Session的创建:服务器端第一次调用getsession()时创建 (jsp会在底层默认调用getsession)
Servletcontext的创建:服务器加载完web项目,就会为每个web项目即刻创建一个servletcontext对象
Request的创建:每次页面访问都会为这次访问创建一个request对象
作用范围
Session作用范围: 一次会话 (多次请求).
Servlet作用范围: web项目
Request:当前页面
生命周期
Session生命周期:默认时间是30分钟 非正常关闭会因为来不及序列化而销毁.
Servletcontext 生命周期: 服务器开启到关闭
Request生命周期:页面响应结束就销毁.
Jsp内置对象(无需创建,可以直接调用)
1 request 域对象 httpreques 一次请求
2 response httpresponse
3 session 域对象 httpsession 一次会话
4 application 域对象 servletcontext 应用
5 page object
6 pagetext 域对象 pagecontext 当前页面
7 config servletconfig
8 out jspwriter
9 exception throwable
Pagecontext.findattribute(“ ”) 根据名字从小范围的域对象开始查找 找到直接返回
静态包含<%@include >和动态包含的区别<jsp:include> 静态包含相当于将包含部分的页面代码拷贝过来然后在进行编译 动态包含一边编译一边将包含部分代码添加进来 添加部分的代码继续自己编译 本身也处于动态编译过程,主要特点是主体部分不能使用编译部分定义的局部变量,就像java不同类之间的变量不通用一样 ,而静态包含因为是直接copy过来的缘故是可以使用的 .
作者: 小故事 时间: 2018-6-7 21:17
谢洪彬:
Session: 域对象
Cookie,ServletContext,Session作为Servlet中的三大域对象,其作用范围和生命周期也是有所区别的
ServletContext:作用于整个项目工程
Cookie:作用与一次回话
Session:作用与一次回话
Session不同于Cookie,Session是数据保存在服务器,然后会生成一把钥匙,并把这个钥匙响应回浏览器并由浏览器保存,待下次浏览器再访问的时候就是携带这个钥匙回服务器,当然这个钥匙的数据传输是由Cookie来完成的.
当然作为Servlet的与对象Session的存取数据的方法是一样的
getAtturibute() 获取数据
setAtturibute() :存取数据
当然说了这么久还没有介绍怎么去获的Session对象,当然不是去new,是:
Request.getSession(String name)
如果说没有这个Session 服务器就会去创建一个Session对象
如果有的话就会根据浏览器带过来的钥匙找到指定的Session对象
还有就是Session的销毁:
1.非正常关闭服务器.
2.session过期(默认30分钟)
3.手动调用invalidate方法的时候
后面我们又学习了jsp ,动态网页开发技术,可以理解为在html中写java代码的存在
Jsp的脚本
<%! %> 可以定义在Servlet中的成员变量,成员方法,内部类
<% %>可以定义在Servlet中service中的局部局部变量,内部类
<%= %>可以理解为作为输出打印使用
JSP的九大内置对象
* request HttpServletRequest
*response HttpServletResponse
* session HttpSession
* application ServletContext
* page Object
* pageContext PageContext
* config ServletConfig
* out JspWriter
* exception Throwable
其中pageContext又可以获取其他的八大内置对象,应用的话就是:比如要传参数的时候传这一个就行了,他就可以获取其他的八个.
Jsp中的四大域
JSP的四个域范围:
* PageScope :当前页面中有效. pageContext PageContext
* RequestScope :一次请求范围. request HttpServletRequest
* SessionScope :一次会话范围. session HttpSession
* ApplicationScope :整个项目 application ServletContext
在Jsp中可以使用这三种注释:
1.java注释
2.Html注释
3.Jsp注释
其他两个都一个,就是jsp的注释是<%--写注释--%>
作者: 郑学馨 时间: 2018-6-7 21:34
郑学馨
案例一:利用session实现购物车功能
新建一个servlet类
步骤一:获得的客户端传输的商品信息(比如:name值)
步骤二:根据session键值获得对应的values值(返回一个map集合)
步骤三:判断获得map集合是否存在
步骤四:如果(map==null)说明我们要的集合不存在,这时要新建一个集合
步骤五:判断集合中是否有我们需要的键值对(比如key="name")
步骤六:如果判断为false;说明我们是第一次添加该商品进购物车,这是往集合中添加map("name",1);
步骤七:如果判断为true:说明我们之前已经添加过该商品了,这时要将它对应的value值取出来加1;再添加进集合中
步骤八:将集合存进session中;
步骤九:利用重定向转到购物车页面中
:购物车页面如何显示商品信息(显示:商品名+数量)
步骤一:新建一个jsp页面
步骤二:获取客户端传送的session值.返回的是一个集合
步骤三:将集合进行遍历;获得对应的键值对的值
步骤四:将键值对的值打印到页面上进行显示
案例二:验证码功能的实现:
步骤一:在登录功能servlet类中重新dopost方法;
步骤二:获得客户端输入的验证码值(保存为string类型)
步骤三:获得客户端中带过来的session中的验证码值(也就是验证码图片上的信息,我们再生成验证码同时将信息提取出来,保存进session中)
步骤四:将session中的验证码值删除(因为验证码只能使用一次,这次使用后下次会生成新的,我们需要将旧的删除)
步骤五:判断我们输入的验证码值与session中的值是否相等,如果相等才能登录成功,如果不等,显示验证码错误,且验证码信息刷新
什么是jsp:jsp是动态页面,jsp页面中可以添加java代码(jsp相当一个servlet类)
如何再jsp中添加java代码:
<%! %> :翻译成Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
<% %> :翻译成Servlet中service方法内部的内容. 定义类,变量
<%= %> :翻译成Servlet中service方法中out.print();
jsp的三大指令:page指令;include指令;taglib指令
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的动作标签:
1:转发:forward 2:传参:param 3:包含:include 4:设置属性:setproperty 5:得到属性:getproperty 6:使用javabena :usebean
作者: 凉面要趁热吃 时间: 2018-6-7 21:43
黄进安:
1. session:服务器可以为每个用户浏览器创建一个会话对象（session对象），注意：一个浏览器独占一个session对象(默认情况下)
l 创建:在服务器启动时,浏览器访问服务器,第一次调用Servlet中Request.getSession();可以用isNew()方法来判断Session是不是新创建的
l 销毁:
1. 默认30分钟没有使用，则服务器会自动销毁session，在web.xml文件中可以手工配置session的失效时间
<!-- 设置Session的有效时间:以分钟为单位-->
<session-config>
<session-timeout>15</session-timeout>
</session-config>
2. 调用session.invalidate();
3. 非正常关闭服务器.如果正常关闭session序列化到硬盘.
2. 商品添加购物车案例
利用map集合的key保存商品名,value保存商品数量,将map集合保存在session中,在购物车页面中利用jsp技术将session保存的map中的信息提取出来即可
3. 验证码案例
在处理验证码的servlet中,将生成的字符添加到字符串中(用stringbuffer,方便添加),在将字符串保存在session中,然后在处理登入页面的servlet的中,获得登入页面客户提交的验证码的信息和保存验证码信息的session中的信息,两者在用户名和密码判断之前进行对比,根据对比进行相关登入处理即可.
--->注意的是在获得完保存验证码的session之后把这个session移除,符合现实生活中验证码的即时性: request.getSession().removeAttribute("要移除的session名 ");
4. 关于点击验证码图片更新图片的时间戳扩展:
代码:通过点击鼠标事件(onclick)触发changeImg()函数
function changeImg(){
document.getElementById("img").src="/day0606/CheckImgServlet?time="+newDate().getTime();
}
根据获取的系统时间的即时性,所以每次点击图片提交的URL地址就变了，浏览器就会刷新缓存，否则，浏览器会认为，URL地址没变化，默认数据没变化，所以，不刷新缓存（你没变化，刷新干吗啊，不浪费我动作嘛）
5. Jsp:
浏览器向服务器发请求，不管访问的是什么资源，其实都是在访问Servlet，所以当访问一个jsp页面时，其实也是在访问一个Servlet，服务器在执行jsp的时候，首先把jsp翻译成一个Servlet，所以我们访问jsp时，其实不是在访问jsp，而是在访问jsp翻译过后的那个Servlet
基础语法:
l JSP脚本表达式（expression）用于将程序数据输出到客户端
语法：<%= 变量或表达式 %>
l JSP脚本片断(scriptlet)用于在JSP页面中编写多行Java代码。
l 语法：
<%
多行java代码
%>
在<% %>中可以定义变量、编写语句，不能定义方法。
l JSP页面中编写的所有代码，默认会翻译到servlet的service方法中，而Jsp声明中的java代码被翻译到_jspService方法的外面。
语法：
<%！
java代码
%>
所以，JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法
6. Jsp中的三个指令和九大内置对象,概念性知识,还需多理解和代码实现一下.
作者: 六道的骸6 时间: 2018-6-7 22:26
张裕
说实话 最近的学习状态感觉非常的差 知识量的增多 睡眠不足 听课越加乏味 连总结都腾不出时间写
每晚都在补当天的视频 超哥的话一巴掌打醒了我 现在在不努力 以后就没机会了
最近学习了Cookie Session JSP 先说下个人对这三玩意的理解
Cookie 可在服务器端返回一个数据到浏览器端 这就是Cookie(本地文件数据)
在一次会话过后(浏览器关闭)后销毁 但是可以通过setMaxAge来控制保存时间 单位为秒
也可以设置为0来销毁持久性的Cookie 也可设置有效的路径以及域名来控制存在的范围(然而没用过 不了解)
Session 服务器端数据 第一次request.getSession创建 会在服务端开辟一片空间来存储数据 (保险柜)
并且返回一个Cookie(钥匙)?到浏览器端 然而我想问 关闭浏览器后Cookie销毁了 保险柜还在 那么怎么获取之前的钥匙
销毁的时间:有效时间过后 默认30min 非正常关闭服务器(控制台关闭 拔电源?) 手动调用invalidate()销毁
JSP 说实话 对这玩意还是不了解 视频说的多了? 所以懵了?
Java Server Pages(Java服务器页面) 动态网页开发技术
让我们可以在页面中写入java代码 提高了便利性
指令:可以直接设置一些JSP属性 嘛 感觉就include比较给力 可以直接进行页面的转发
内置对象:可以直接在JSP中使用的Java对象 免去了创建对象的操作
其中需要重点掌握的是pageContext 这货比较牛 可以召唤其他8个小弟(内置对象)
还可以在指定的作用域内存取数据 从小范围到大范围查找指定的属性
在四个域中存储数据
域范围 存储数据的对象
PageScope :当前页面有效 PageContext
RequestScope :一次请求到响应之间 request
SessionScope :浏览器为关闭之前 session
ApplicationScope :应用(???)范围 application
动态标签:<jsp:xxx />简化代码 可以直接使用代码的功能
静态和动态包含的区别:
静态包含是直接复制了页面中的代码拿来使用 而动态包含是把代码的执行结果拿过来使用(操作方式区别不同)
虽然视频看了挺多遍了,但是感觉知识点还是太抽象了,不知道哪里是必须掌握的地方,总想把全部都吸收 然而捡芝麻丢西瓜
我比较不愿听到关于以后工资的事情 说的多了也就烦了 我不期望有什么月薪过万 付出和收获是相对的 还没付出就讨论结果是最搞笑的一件事情
我觉得只要工资不是太过分就OK 毕竟刚入行不要太膨胀 需要慢慢积累经验
希望自己接下来能更加努力吧 现在的状态差都是之前膨胀的结果吧
作者: seilye 时间: 2018-6-7 23:26
叶身辉:
主要学习的是session和jsp,
session和cookie是一对好基友,只是session是域对象,cookie用来连接浏览器,结合案例主要是购物车的案例,需要用session域对象和cookie来和浏览器传输数据,session是保存在服务器中的各种数据,需要使用cookie保存的钥匙才能打开,实际上浏览器和服务器仍然是传递的cookie,他们的生命周期都是一次会话,但是cookie有大小限制,而session因为保存在服务器中所以没有大小限制,通过这样的方式可以提高了传输的效率和安全性,session默认保留时间是30分钟,
学习jsp主要是学了如何在jsp页面输出java代码和一些底层代码是如何实现这些功能的,但是我们要尽量避免在jsp上写java代码,
之后是结合前几天的知识所完成的案例的互相关联和一些注意事项
一, 首先,需要完成一个基本的环境配置准备工作():
1;准备四个jsp文件:
cart.jsp 购物车界面
login.jsp 登陆界面
product_list.jsp 商品列表界
regist.jsp 注册界面
2;导入需要的jar包:
c3p0-0.9.1.2.jar c3p0jar包
commons-dbutils-1.4.jar DBUtils 的jar包
mysql-connector-java-5.0.8-bin.jar mysql的jar包
3;C3P0所需要的xml文件
c3p0-config.xml 固定的xml文件名
4,创建项目,将以上文件全部拷贝到项目中,
二, 开始准备java代码
（一）注册的servlet
1.处理中文乱码request.setCharacterEncoding("utf-8");
2.接收从页面传过来的参数:request.getParameter();
3.将接收到的参数保存到一个实体类中:创建实体类对象调用set方法
4.调用service业务处理层
5.在service中调用dao先查询是否存在用户名,如果不存在就添加到数据库
6.再跳转页面request.getRequestDispatcher("/login.jsp").forward(request, response);或者重定向,
（二）登陆的servlet
1．处理中文乱码问题
2．接收页面传过来的参数账号和密码
3．将参数保存到实体类中,传给service
4．调用Dao核对账号密码是否正确
5．传回servlet,跳转页面
（三）购物车cart 的servlet
1,处理中文乱码的问题:
String name = new String(request.getParameter("name").getBytes("ISO-8859-1"),"UTF-8");
2,调用购物车的session域对象,request.getSession().getAttribute("cart");购物车的域对象是session(“cart”, map);名字+map集合
3,如果不存在就创建一个,map = new LinkedHashMap<String ,Integer>();因为linkedhashmap比较方便增删数据
4,如果存在就直接判断map中是否存在传过来的参数key,存在的话将其value加1再存进去,不存在的话就直接给map添加一个数据
5,将处理好的数据存入session对象中
6,输出的中文编码和跳转页面
三 ,使用到的不熟悉的知识点和方法
1.中文的get请求的编码
2.Session(“cart ”,map)域对象格式map=LinkedHashMap<String ,Integer>();
3.遍历map集合的方法需要复习
4.注意跳转的时候保存数据什么时候该用什么域对象request/session/servletcontext
注意每个域对象的作用范围和生命周期.
5.${域对象的名称},可以把值显示在页面上
6.商品的连接要改成"/Demo0607/CartUserServlet?name=苹果"这种样式而不是定义参数name
作者: hpb199567 时间: 2018-6-7 23:51
何平波
Cookie本身是有大小和个数的限制.Session没有限制.Cookie的数据保存在客户端,Session数据保存在服务器端.
Session的执行原理：基于Cookie的.
使用Session:
* 获得Session:
* request.getSession();
案例二添加购物车
案例步骤解析加理解
1.首先需要有商品页面,且将商品添加超链接并且为超链接设置解析路径和name属性
<a href="/Test/AddServlet?name=xxx">加入购物车</a>
2.一个Servlet类,获得商品的name属性
//获取商品数据
String name = request.getParameter("name");
3.//获取map集合,这里可以将map集合的数据直接存入session中,这里的cart是session寻找想对应的存取值,
Map<String,Integer> map=(Map <String,Integer>)request.getSession().getAttribute("cart");
//先判断map是否为空,如果为空的话,创建一个map的linkenHashMap,防止出现空指针异常,而且linkenHashMap是对于数据的增删改会比较方便
if(map==null){
map=new LinkedHashMap<String,Integer>();
}
//在判断map的键也就是商品的名称是否包含
if(map.containsKey(name)){
//如果包含的话就获取商品的数量,进行累加数量
Integer count = map.get(name);
//累加数量
count++;
//再存入map中
map.put(name, count);
}else{
//如果不包含商品名称的话就是第一次添加
map.put(name,1);
}
//将map集合存入session中
request.getSession().setAttribute("cart", map);
//响应跳转超链接继续购物或者是结算商品
response.setContentType("text/html;charset=utf-8");
response.getWriter().println("<font color='red'><h4><a href='/Test/produts.jsp'>继续购物</a>|<a href='/Test/cars.jsp'>结算商品
</a></h4></font>");
4.最后是创建一个商品结算页面
在<% %>里编写java代码
<%
//获取session域对象的值 用map集合接收,这里就可以同时得到商品的名称和数量
Map<String, Integer> map = (Map<String, Integer>) request.getSession().getAttribute("cart");
//遍历商品获得名称和数量 ,用key键寻找数量
for (String name : map.keySet()) {
//获取商品名称和数量
Integer count = map.get(name);
%>
<font size="5" color="yellow">你添加的商品是<%=name%>,购买数量是<%=count%>
</font><br>
<%
}
%>
作者: conan75 时间: 2018-6-7 23:58
陈昆明:
22.cookie本身是有大小和个数的限制的,session是没有限制的,session能够较高地提高效率,存取会比cookie简单(cookie的存取是字符串,需要指定符号连接再切割,,,)session的强大之处在于,它存的是一个对象,cookie存的是字符串,所以操作会更为灵活
session ID只有在创建后的第一次响应才会带回浏览器,否则每次服务器使用ID的话,浏览器都只是将ID副本带到服务器,服务器响应则不会将ID再次带回
Session的生命周期:
创建:当用户第一次调用getSession时,服务器内部就会创建指定名字的Session,并自动生成ID
销毁:1.session过期,默认过期时间为30分钟
2.非正常关闭服务器,如果是正常关闭,session会序列到硬盘
3.手动调用session中的invalidate方法
作用范围:多次请求,(一次会话)
验证码更换清除缓存的操作,加上一个时间戳?time=new Date().getTime();
23.jsp的注释只会存在于jsp的源代码中,翻译成Servlet后,JSP注释就会消失,Java中的代码块用html注释是注释不了的
24.JSP的九大内置对象
Request
Response
Session
Application
Page
pageContext
config
out
exception
out和response.getWriter不是同一个对象,out的真实对象是JspWriter
作者: 李思贤126 时间: 2018-6-8 00:18
李思贤: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 :应用范围(在服务器正常开启至关闭中有效?)
JSP九大内置对象(在Jsp中不用new就可以直接使用的对象)
1`request 2`response 3`session 4`application 5`page 6`pageContext(重要) 7`config 8`out 9`exception
案例总结:
1注册
在regist页面中填写数据后,跳转到registServlet中
在registServlet中接收参数(要注意中午乱码问题),然后调用Service中的regist方法,返回一个参数来判读是否注册成功.
,在Service中先要做出判断数据库中用户名是否被占用,调用个query方法,,给registServlet返回参数,若没被占用再执行regist方法向数据库添加注册对象.
我们registServlet中接收到返回值就可以在页面中打印是否注册,用request.setAttribute(“msg”,”xxx”)方法转发给页面,页面内用<span>${ msg }</span>接收显示在页面上,这里我们不论是否注册成功都用msg,因为request作为域对象,一次请求一次响应就没了.不会影响下次使用.
2登录
在loginServlet中接收参数,然后调用Service中的login方法,返回一个参数来判读是否注册成功,去数据库查找是否含有这个对象,若无,跳转到登录页面,把错误信息打出来,注意此时request.setAttribute(“msg1”,”xxx”) 这里不能再用msg了,和上面的msg会混淆,发生错误.,若有找个对象,把登录人信息保存在session中,用重定向跳转到商品页面.在product_list.jsp中
开头欢迎这个人,用<span>${aaa.nickname},欢迎光临</span>.
3商品列表(必须登录才能访问)
刚才登录人信息已经保存在session中了,我们在页面中只要查询session是否含有这个信息就可以了,在product_list.jsp的body开头中
注意导包和强转User
<%
User realname= (User) request.getSession().getAttribute("existUser");
if (realname== null) {
%>
<h3>请先<a href='/Test/login.jsp'>登录</a></h3>
<%
} else {
%>
.......
<%>
}
</%>
在最后body结束前还要<%> }</%>
4添加到购物车(登录才能访问)
登录才能访问同上
cartServlet中先接受参数String name = new String(request.getParameter("name").getBytes("ISO-8859-1"), "UTF-8");
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);
count++;
map.put(name, count);
}else{
map.put(name, 1);
}
request.getSession().setAttribute("cart", map);
response.setContentType("text/html;charset=UTF-8");
然后再cart.jsp接收
<%
Map<String,Integer>map=(Map<String,Integer>)request.getSession().getAttribute("cart");
for(String name:map.keySet()){
Integer count =map.get(name);
%>
.....
<%
}
%>
未完待续...
作者: wpwing 时间: 2018-6-8 00:33
吴鹏
总结
Session的作用范围是:一次会话,一次会话指的是打开浏览器,访问网站,关闭浏览器,这样的称为一次会话;
创建:服务器端第一次调用getSession()方法的时候;
销毁:浏览器关闭时只是销毁了JSESSIONID,如果直到此ID,依然可以访问;当Session过期(默认为30分钟),非正常关闭浏览器,手动调用
session.invalidate()方法的时候,session就会销毁;
对比:
作用范围 创建 销毁时间
Request 一次请求 浏览器向服务器发送请求时 服务器向浏览器响应
ServletContext 整个工程 服务器加载时 服务器关闭或项目被移除时
Session 一次会话 服务器调用getSession()方法时 超过默认设定时间或服务器非正常关机或调用session.invalidate()
JSP相关:
JSP脚本即为在JSP页面中使用的Java代码,所以,我们要记住引用Java代码的方式:
引用方式有三种:
<% %>,service中的代码;变量,类
<%! %>,成员的内容,方法,变量,内部类;但是会被其它调用,不建议使用;
<%= %>,输出语句中的内容;out.print()的内容;
内置对象:
在JSP中可以直接使用的对象;
九大内置对象:
request HttpServletRequest
response HttpServletResponse
session HttpSession
application ServletContext
page Object
pageContext pageContext
config ServletConfig
out JspWriter
exception Throwable
四大域及作用范围:
request 作用范围是在一次请求中,一般与转发联立使用;
ServletContext 作用在整个项目;
Session 作用范围是一次会话中;
PageContext 作用在整个页面;
作者: zzx835387607 时间: 2018-6-8 01:12
郑志祥
四个域对象
1.ServletContext context域
2.HttpServletRequet request域
3.HttpSession session域 Servlet时就能接触到
4.PageContext page域 --jsp学习的
域的作用范围
1.page域: 只能在当前jsp页面使用 (当前页面)
2.request域: 只能在同一个请求中使用 (转发)
3.session域: 只能在同一个会话(session对象)中使用 (私有的)
4.context域: 只能在同一个web应用中使用 (全局的)
session何时创建和销毁?作用范围:
* 创建:服务器端第一次调用getSession()创建session.
* 销毁:三种情况销毁session:
* 1.session过期. 默认过期时间为30分钟.
* 2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
* 3.手动调用session.invalidate();
* 作用范围:多次请求.(一次会话)
Jsp既可以写html又可以写java代码（如下）
JSP的脚本: <%! %> <% %> <%= %>
Jsp的九大内置对象
1 request 域对象 httpreques 一次请求
2 response httpresponse
3 session 域对象 httpsession 一次会话
4 application 域对象 servletcontext 应用
5 page object
6 pagetext 域对象 pagecontext 当前页面
7 config servletconfig
8 out jspwriter
9 exception throwable
作者: 黄志彬 时间: 2018-6-8 01:43
黄志彬
Session是域对象
Session执行原理基于Cookie，服务器为每一个session开辟一块新的空间
request.getSession()使用request中的session id去找到这个用户对应的session，session数据保存在服务器
创建和销毁
*服务器第一次调用getSession创建，
* 三种情况能销毁session，
1.session 过期，默认过期时间为30分钟
2.非正常关闭浏览器（如拔掉电源），如果正常关闭session序列化到硬盘
3.手动调用session.invalidate();
作用范围：一次会话
JSP底层就是一行一行的打印
JSP有三个指令 page指令，include指令，taglib指令
指令语法 <%@ 指令名称 属性名称="属性值" 属性名称="属性值".....%>
JSP的四个域范围
*pageScope: 当前页面中有效 pageContext
*RequestScope: 一次请求范围 request
*SessionScope: 一次会话范围 session
*Application: 应用范围 application
从小范围先查找pageContext--->request--->session--->application
设置全局错误的提示页面web.xml中
例：
<error-page>
<error-code>404</error-code>
<location>/error.jsp</location>
</error-page>
***JSP的内置对象(面试题)
在JSP中可以直接使用的对象
有9大内置对象 真实对象 常用方法
*request HttpServletRequest getparamter(); setAtttibute()
*response HttpServletResponse setHeader(); getWriter(); getOutputStream();
*session HttpSession setAtttibute() getAtttibute()
*application ServletContext setAtttibute() getAtttibute()
*page Object toString(); wait();
*pageContext PageContext setAtttibute() getAtttibute()
*out JspWriter write(); print();
*exception Throwable getMessage() getCause()
作者: AsusCoder 时间: 2018-6-8 02:14
今天主要学习了session，关于Session的一些常识总结一下
1.Session机制
除了使用Cookie，Web应用程序中还经常使用Session来记录客户端状态。Session是服务器端使用的一种记录客户端状态的机制，使用上比Cookie简单一些，相应的也增加了服务器的存储压力。
2 .关于Session
Session是另一种记录客户状态的机制，不同的是 Cookie保存在客户端浏览器中，而Session保存在服务器上 。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。客户端浏览器再次访问时只需要从该Session中查找该客户的状态就可以了。
如果说Cookie机制是通过检查客户身上的"通行证"来确定客户身份的话，那么Session机制就是通过检查服务器上的"客户明细表"来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。
3 Session的生命周期
Session保存在服务器端。为了获得更高的存取速度，服务器一般把Session放在内存里 。每个用户都会有一个独立的Session。如果Session内容过于复杂，当大量客户访问服务器时可能会导致内存溢出。因此，Session里的信息应该尽量精简。
Session在用户第一次访问服务器的时候自动创建 。需要注意只有访问JSP、Servlet等程序时才会创建Session，只访问HTML、 IMAGE等静态资源并不会创建Session。如果尚未生成Session，也可以使用request.getSession(true)强制生成 Session。
Session生成后，只要用户继续访问，服务器就会更新Session的最后访问时间，并维护该Session 。用户每访问服务器一次，无论是否读写Session，服务器都认为该用户的Session"活跃（active）"了一次。
4 Session的有效期
由于会有越来越多的用户访问服务器，因此Session也会越来越多。为防止内存溢出，服务器会把长时间内没有活跃的Session从内存删除。这个时间就是Session的超时时间 。如果超过了超时时间没访问过服务器，Session就自动失效了。
之前想手动设置Session的寿命。通过网上查询得知使用maxInactiveInterval属性，可以通过对应的getMaxInactiveInterval()获取，通过setMaxInactiveInterval(long interval)修改。
Session的超时时间也可以在web.xml中修改。另外，通过调用Session的invalidate()方法可以使Session失效。
二,JSP:
JSP在web工程发布后会被转换为Servlet，所以在jsp里面是一种java代码。它是一种服务器语言。可以方便获取服务器上的数据。关于jsp以后一直会用，掌握以下知识点:
1.JSP的定义
【JSP的脚本】
<%! %>:翻译成Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
<% %>:翻译成Servlet中service方法内部的内容. 定义类,变量
<%= %>:翻译成Servlet中service方法中out.print();相当于输出一个值
2.JSP的指令：
1)掌握page指令，<%@ page %> -- 设置JSP的语言
* contentType :设置浏览器打开这个JSP的时候采用的默认的字符集的编码.
* pageEncoding :设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码.
* import :在JSP中引入类对象.但是import可以出现多次.
<%@page import="java.util.ArrayList"%>:引入一个页面的方法
3.设置一个错误页面
* 设置全局的错误友好页面：
* 在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>
4.包含其他页面:
JSP中的include指令:指示JSP包含其他的页面.
<%@ include file="logo.jsp" %>
<%@ include file="menu.jsp" %>
<h1>BODY部分</h1>
<%@ include file="footer.jsp" %>
5.9个内置对象:
request,reponse,session,application,page,pageContext,cofig,out等
pageContext内置对象 :
* 获得其他的8个内置对象 :编写通用性代码或者框架的时候.
* 向JSP的四个域中存取对象
【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的属性.
作者: it小白001 时间: 2018-6-8 08:37
吴俊斌Session底层用了Cookie,它的原理是在服务器开辟一片空间.这片空间是有锁的
,然后通过Cookie将钥匙传给游览器.
Session的作用访问:一次会话,默认游览器关闭钥匙就消失.但是这是Session
并没有消失,通常半个小时才会消失,它在第一次调用getSession的时候,销毁在
1.session过期. 默认过期时间为30分钟.
2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
3.手动调用session.invalidate();
jsp其实就是网页和java相结合,在html中可以写java代码.使用方式也挺简单的
<% 这是在Servlet方法中 %>
<%= 这是直接在html里输入 不加分号%>
<%! 这是在成员 %>
jsp的九大对象
JSP九大内置对象(在Jsp中不用new就可以直接使用的对象)
1`request 2`response 3`session 4`application 5`page 6`pageContext(重要)
7`config 8`out 9`exception
苏海斌
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中可以直接使用的对象,一共有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"
重点!!!
JSP的四个域范围:
PageScope :当前页面中有效. pageContext PageContext
RequestScope :一次请求范围. request HttpServletRequest
SessionScope :一次会话范围. session HttpSession
ApplicationScope :应用范围 application ServletContext
作者: wahahaha 时间: 2018-6-8 08:55
林恒山
Session的作用范围:一次会话
创建:服务器第一次调用getSession()创建Session
销毁:三种情况销毁Session:
1.session过期. 默认过期时间为30分钟.
2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
3.手动调用session.invalidate();
Session是一个域对象.存取数据和移除数据跟其他域对象调用的方法一样.但是Session数据是存在服务器端的.
JSP脚本:
<%! %> servlet实现类的成员部分,可以定义变量/方法/类
<% %> service()内部的内容,可以定义变量/类
<%= %> service()内部的out.print().
JSP内置对象:就是在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
作者: Do1 时间: 2018-6-8 09:03
本帖最后由 Do1 于 2021-6-21 08:16 编辑
session是通过附在cookie请求头上和响应头上的一组通过加密后获得的id,用来实现个性化服务,客户端第一次传过来的时候并没有session,只有在客户端访问Servlet的时候服务器内存中才会开启session,之后的每一次请求都视为session活跃了一次
session案例
1.判断登录 JSP+session判断语句
2.session名称遍历获取
Enumeration<String> sessions= request.getSession().getAttributeNames();
String kk="";
while(s.hasMoreElements()) {
kk+=s.nextElement();
}
Enumeration是一种古老的迭代器,主要用在Servlet,其它地方被iterator迭代器替代
session比其它域对象灵活的地方在于它可以存Object类型
JSP主要的标签是<% %>和<%= %> 百分号后加等号它等价于<% out.print()%>
JSP中特殊的地方在于if语句
<%if(boolean flag){%>
<%内容%>
<%}else{%>
<%内容%>
<%}%>
作者: LittleSky 时间: 2018-6-8 21:40
常小天
session是一种将数据保存在服务器端的会话技术。其原理是在一次会话中，服务器在它自己的硬盘上为本次会话开辟一块区域来存储用户的一些操作信息，并为这块区域配置一个sessionID，以cookie的方式响应给浏览器端，浏览器再次发送请求时会在cookie中携带sessionID，服务器接收请求后通过sessionID找到硬盘中对应的那块空间，继续在这块空间中存取数据。Session的生命周期与其作用范围并不一致。Session是在会话中第一次调用getsession方法时创建，本次会话中后续的调用getsession方法都是获得这个session而不重新创建session。Session的销毁有三种情况。一是默认在30分钟没有被使用时销毁；二是当手动调用session.invalidate()方法销毁；三是服务器异常关闭时销毁（服务器正常关闭时会序列化到硬盘，在此开启时再反序列化）。Session从创建到销毁的过程是它的生命周期，但session基于cookie的工作原理，使得它的作用范围仅限在一次会话中，因为一次会话关闭后cookie默认就被销毁了，尽管session可能还存在，但因为浏览器已经丢失了sessionID，所以无法再次访问之前的session空间。我们借助request中的getsession方法来创建或获取session。
Jsp即java服务器端的页面。Jsp中嵌入java代码的方式昨天已经学习过，今天新学习的有jsp中的注释、jsp中的指令、jsp中的内置对象和jsp中的动作标签。Jsp的三种注释方式为：
HTML的注释:<!-- 注释 -->
Java代码的注释:// 单行注释；/*多行注释*/； /** 文档注释 */
JSP的注释:<%-- JSP的注释 --%>
需要注意的一点是HTML的注释不能注释java代码。
Jsp的指令有<%@ page %>；<%@ include file=" " %>；<%@ taglib uri="标签的URI的路径" prefix="标签的别名" %>。
Jsp的9大内置对象：request、response、session、application、page、pageContext、config、out、exception。
Jsp的动作标签：<jsp:forward />:用于页面的转发、<jsp:include /> :用于页面的包含.（动态包含）、<jsp:param />:用于带有路径的标签下,传递参数、<jsp:useBean />:用于在JSP中使用JavaBean、<jsp:setProperty /> :用于在JSP中向JavaBean设置属性的、<jsp:getProperty />:用于在JSP中获得JavaBean的属性。
作者: ...ylq 时间: 2018-6-9 01:21
叶凌青
今天学习了Session
Session是将数据保存到服务器端.利用Cookie回写一个session的ID.
Session的执行原理：基于Cookie的.
Session作为域对象的方法:
request.getSession();
session的生命周期
创建:服务器端第一次调用getSession()创建session.
销毁:三种情况销毁session:
1.session过期. 默认过期时间为30分钟.
2.非正常关闭服务器.如果正常关闭session序列化到硬盘.
3.手动调用session.invalidate();
session作用范围:
作用范围:多次请求.(一次会话)
作者: 1748341437 时间: 2018-6-9 14:04
2018/6/6 林瑋
昨天了解了一下session,今天就开始学习session及jsp;
session是一个基于cookie的一个域对象,它用来储存数据的域都是在服务器中的,而cooki储存数据的域是在客户端中,每次创建session对象都会有一个"钥匙"随着产生,我们如果想要获取里面的数据就可以通过set-cookie把session的钥匙响应到浏览器中,从而获得里面的数据.有人说为什么不把数据存入cookie里呢?其实存入cookie也不是不可以,只不过cookie有大小限制,而session没有,所以如果数据量比较多的话最好用session.虽然说session是基于cookie的,session确实是一个独立的存在.对于session与cookie的关系如果还不理解的话,还有一个图解,或者自己闲时也可以画一下,这样对以后的应用很有帮助.
接下来就是jsp了,jsp呢之前是有了解很多的,它的全面叫Java Server Pages,为什么会弄这么一个东西呢?因为一开始SUN公司一直推出的是Servlet,后来发现Servlet在动态页面上有很大的缺陷,已经没有办法与ASP,PHP来竞争了,后来才推出了JSP的,为什么要推出JSP呢?重点来了,首先JSP可以兼容html代码和java代码还有jsp自身,这就大大提高了页面数据的代入,其次就是提高了页面的灵活输出.那jsp的代码书写格式又是怎么样的呢?它呢是指令开头,html代码与HTML原文件一样,最后就是java代码的代入了,也是最重要的之前了解也有讲过,今天就在讲一遍,java代码是通过三个标签来代入的,<% %>,<%= %>和<% ! %>,其作用我就不多说了,相信我是能记住的.jsp还有三个指令:page指令,include指令和taglib指令,比较重要的就是page指令了.还有九大内置对象:request,response,session,application,page,pageContext,config,out还有exception,常见的就是request,response,session,和page还有pageContext.动作标签有六个:<jsp:forward />,<jsp:include />,<jsp:param />,<jsp:useBean /> ,<jsp:setProperty /> ,<jsp:getProperty /> .动作标签主要在于简化代码,有句话怎么说的一切从简,代码也是这个道理.都说servlet有域对象,我们jsp也有,而且有三个和servlet里的一样,它们分别是:PageScope=pageContext,RequestScope=request,SessionScope=session,ApplicationScope里application.它们之间的范围大小是这么一个等级: pageContext<request<session<application;
好了这就是今天所学的内容了...(之前因为因为种种原因才这么久没发,可把我憋得不轻,今天发出去了也是终于松了一口气.也挺对不起老师们,虽然的这是为我们自己写的,但是老师们都这么努力,一直以来对我们的总结都是认真对待的!这样子有点让你们煞费苦心了,谢谢超哥,辉哥及各位老师!)
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |