黑马程序员技术交流社区

标题: 【厦门JavaEE就业1期-每日总结】jQuery和listener [打印本页]

作者: 厦门校区    时间: 2018-6-14 17:33
标题: 【厦门JavaEE就业1期-每日总结】jQuery和listener
同学们,今天讲JQuery,主要讲了一个省市联动案例;讲监听器Listener,主要介绍了web开发中的三类监听器。

今日需要掌握的有:

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



作者: 小故事    时间: 2018-6-14 21:02
谢洪彬:
今天学习了JSON和监听器
JSON:可以理解为储存数据使用(比如:集合,对象等),在我们使用异步请求是,响应回去的可能是一个数组,集合,或对象,这样我们就可以将这些对象转成JSON类型写回去.
JSON常见的格式:
{ “ name ” , ” abc ” ; ” age ” , 18 }         普通JSON        正确写法
[{ “ name ” , ” abc ” ; ” age ” , 18 },{ “ name ” , ” abc ” ; ” age ” , 18 }]         JSON数组        正确写法
{  name , ” abc ” ; ” age ” , 18 }                 错误写法
{  “name” , ” abc ” , ” age ” , 18 }         错误写法
[  “name” , ” abc ”; ” age ” , 18 ]         错误写法
在JSON中有这样几个常用的方法:
不过在使用JSON之前需要导6个包,集体什么包赋值黏贴就好
List集合,数组可以使用JSONArray.fromObjec(参数),方法
Map集合,对象可以使用JSONObjec.fromObjec(参数),方法
New Config 得到的对象调用setExcludes(String数组),可以过滤掉你不想用的参数,不过在过滤的时候需要调用转JSON方法时需要传两个参数.
今天做了一个省市联动的案例(思路):
1.省,市数据库表建好;
2.拿到数据库中所有的省信息并显示
3.根据省份的id从数据库中查询对应的市信息
4.在写会data之前先转JSON,
5.在js中的get()或set()方法需要传四个参数
(路径,参数,回调函数,JSON)
Js中本是可以解析JSON的,但是写会Js的是字符串,所以需要设置接受数据类型
后面我们有学习了三类监听器:
这三类监听器是针对于Servlet中的三大域对象,
1.监听三大域对象的创建和销毁
2.监听三大域对线的变更(添加,移除,替换)
3.监听Session中javaBean的状态
3.1javaBean的绑定和解除绑定
3.2javaBean的钝化和活化
钝化--序列化到硬盘
活化--反序列化
这三类监听器的使用:
一类:类需要实现对应的接口,在XML中需要进行配置
二类:类需要实现对应的接口,在XML中需要进行配置
三类:类需要实现对应的接口的同时还要实现一个序列化接口,不需要在XML中需要进行配置
在今天学习了这三类监听器的同时又加深了对三大域对象的使用

作者: 13163997058    时间: 2018-6-14 21:37
王刘锁
2018-6-14-->JSON..监听器.
通过一个省市联动的案例来学习json,json是一种传输数据的格式,{"数据名":"数据值"}.多个json的
话就是一个json数组[json,json1...],我们要记住的有json转换json数据的方法,需要记住连个工具类
JSONArray和JSONObject,案例呢首先先创建一个servlet去数据库中查询所有的省集合,把集合存入
request域,再转发到页面,在jsp中遍历集合显示所有的省,定义一个js文件,在文件中写jq入口函数,然
后设置省列表改变change事件,在事件函数中用异步post请求想servlet2发出请求携带参数是选中省份
的pid,pid在<option value="${p.pid}">定义,然后在后台通过pid去数据库查城市,得到的集合转成
json,用法是JSONArray jsonarray = JSONArray.fromObject(list集合/数组),还可以先JSONConfig
config= new JSONConfig();cofig可以用来设置某个属性是否显示:config.setExcludes(new String
[]{"属性名"})这样这个属性就不会显示了,然后再JSONArray.fromObject(集合/数组,config),最后
response打印json到data,在js中获取到city的下拉列表并覆盖一个标签$("#city").html
("<option>--请选择--</option>);这样就不会多个城市叠加了, 接下来就可以吧data转成jq对象
$(data)然后遍历添加到city下拉列表中:
$(data).each(function(i,n){
$("#city").append("<option value='"+n.cid+"''>+n.cname+"</option>")
                        })提醒一下要记得在回调函数加一个参数字符串型"json",,

作者: 沅瞻    时间: 2018-6-14 21:48
詹源

AJAX常用响应格式:
文本,HTML标签,XML,JSON.

实用工具生成XML的文件
  通常使用xStream工具.将集合,数组,对象,转换成XML.
//修改标签名
xSteam.alias("city",city.class);
//将类中属性作为 标签的属性
xStream.useAttributeFor(City.class,"city");

xSring xmlStr = xSream.toXML(list);

json ---专门传输数据,比较小(??),可以直接被js解析

JSON就是种数据格式   (JavaScript Object Notation)---js可以直接识别它

格式介绍:{"id":1,"name":aaa}
                逗号        ↑
         不能写成分号    变量.如果是个值.要加上双引号
JSON生成工具
JSONLIB 转换JSON数据:
        JSONArray :将数据或list集合转换成JSON
        JSONObject:将对象或Map集合转换成JSON
//部分不转换成JSON.config---不包含
JsonConfig config = new
config.setExcludes(new String[]{"pid","cid"});

JSON依赖包全部导入,缺一不可


下午:
监听器

WEB中的监听器共有三类八种(监听三个域对象)
事件源:Servlet中的三个域对象.ServletContext,HttpSession,ServletRequest.
监听源:自定义类实现8个接口
事件源与监听器的绑定:配置.

3类.
1.监听3个域对象的创建的销毁
2.监听3个域对象属性的变更.(存储,删除,替换都是变更)
3.监听session中的JavaBean的状态(绑定,解除绑定,钝化)

监听器的使用
编写一个类实现监听器的接口:

通过配置文件配置监听器:

第一类第一种:
ServletContextListener
方法:
contextDestroyed   :销毁
contextInitialized :创建

配置监听器:
<listener>
<listener-class>全路径<listener-class>
<listener>
ServletContext创建与销毁
创建:服务器启动时,服务器为每个web应用创建一个属于该web项目的对象ServeletContext(全局的)
销毁:服务器关闭或者项目从服务器中移除时销毁

企业中的应用:
1.加载框架的配置文件(提高框架配置文件效率):Spring 框架 ContextLoaderListener:
2.定时任务调度:服务器启动后,开始计时,间隔多久去监听一次
                Timer.TimerTask
                (定时)   
第一类第二种:
HttpSessionListener
创建:服务器端第一次调用getSession();
销毁:1.非正常关闭服务器(正常关闭序列化)
     2.过期.默认30分钟过期
     3.手动调用session.invalidate();销毁
访问Servlet :不会
访问JSP     :会(内置对象默认调用了getSession)
访问html    :不会

第一类第三种:
ServletRequestListener:
创建:客户端向服务器发送一次请求.服务器就会创建request;
销毁:服务器作出响应后,销毁.

访问Servlet:会
访问JSP    :会
访问HTML   :会

都是请求.都会创建

第二类第一种:
ServletContextAttributeListener:监听ServletContext属性变更

HttpSessionAttributeListener:监听HttpSession属性变更

ServletRequestAttributeListener:监听ServletRequest属性变更

(后两种类似)

第三类:
监听HttpSession中的JavaBean的对象的状态改变.不需要配置.作用在JavaBean上的监听器.JavaBean可以自己感知到Session中的状态
HttpSessionBindingListener:监听绑定和解除绑定
valueBound(绑定)
valueUnbound(解除绑定)

HttpSessionActivationListener:钝化,活化.
sessionDIdActivate();  :活化(反序列化)
sessionWIllPassivate();:钝化(序列化)
(Session一次会话可以响应多次请求)

优化Session(节省服务器空间)

通过配置<Context>标签配置定时session序列化
作者: 厦门黑马王子    时间: 2018-6-14 21:55
郑雪平

今天学习了如何使用JQUERY完成省市联动效果返回XML和JSON以及监听器,使用JQUERY完成省市联动效果返回XML是比较老的过时技术了,现在基本上没人在用。现在大多都是在使用JSON技术,JSON是一种小型轻量化的数据交换格式,它使用了类似于C语言家族的习惯,使得它成为了一种理想的数据交换语言。JSON的数据格式是:{“id”:1,"name":"张三"}
JSON的数据转换有两种,第一种:JSONArray将数组和list集合转换成JSON;第二种:JSONobject将对象和MAP集合转换成JSON
  监听器的作用:是一个Java类,用来监听Java中三个域对象的状态的变化.WEB中的监听器共有三类八种,三大类分别是:ServletContext,HttpSession,ServletRequest.
作者: 厦门陈强    时间: 2018-6-14 22:02
陈强
JSON和listener的一天;
今天的第一部分就是JSON;
-JSON是一种数据交换格式,可以直接被JavaScript解析;
-格式就是以键值对的形式---{ “key” : value },中间以逗号隔开,值可以是数组\集合\对象等;
-使用到的工具就是JSONLib
-方法有:JsonArray---是对数组和List集合的
           JsonObject---就是对对象和Map集合的
-使用的步骤就是引包,其余步骤都跟之前的差不多,get\post方法就是在最后多加一个参数”json”,其余的操作原理没有多大变化.
第二部分就是监听器了;
-监听器的使用就是以下两个步骤:
---编写一个类去实现监听器的接口
---通过配置文件的配置监听器
根据三类八种的监听器的不同使用情况,对应的去实现不用的接口,不会很难理解.
然后整理了一下web三个对象的创建和销毁的时机:
ServletContext:
        ---服务器启动的时候创建
        ---服务器关闭的时候销毁
HttPSession:
        ---服务器端第一次调用getSession时创建
        ---销毁有三种情况:非正常关闭服务器\过期\手动调用invalidate()方法
ServletRequest:
        ---客户端向服务器发送一次请求时创建
        ---服务器对这次请求做出响应都销毁

作者: Yanmo_    时间: 2018-6-14 22:05
颜琳琳
今天主要学习了Json,Json是一种轻量级的数据交换格式.Json是数据格式:1.{“id”:18,”name”:”yan”} 2.[{“id”:18,”name”:”yan”},{“id”:”18””,”name”:”zheng”}] 3.{“city”:{“cid”:1,”cname”:”xxx”}}
Jsond 的生成工具JSONLIB 转换JSON数据:
        JSONArray                :将数组或List集合转成JSON.
JSONObject                :将对象或Map集合转成JSON.
Listener监听器分为三类:
        1.监听三个域对象的创建和销毁
                1.ServletContextListener:监听ServletContex对象的创建和销毁
                        1.方法:contextInitialzed()销毁 contextDestroy创建
                        2.ServletContex对象的创建和销毁:
                                在服务器启动的时候,服务器向每个WEB应用创建一个属于该项目的ServletContext对象
                                在服务器关闭或者项目从服务器中移除的时候
                        3.企业中的应用:
                                1.加载框架的配置文件:Spring框架
                                2.执行定时的任务调度:定时发邮件  Timer

                2.HttpSessionListenter:监听HttpSession的创建与销毁
                        1.方法:sessionCreated()创建  sessionDestroy()销毁
                        2.HttpSession的创建与销毁:
                                在服务器第一次调用getSession()时候创建
                                销毁有三种方式:
                                         1.非正常关闭服务器(正常关闭会序列化到磁盘)
                                        2.默认过期时间三十分钟
                                        3.手动调用session.invalidate()
                        3.问题:
                                1.访问Servlet会不会创建Session:   不会(只有手动调用getSession才会创建,默认没有)
                                2.访问JSP会不会创建session:          会(jsp中的内置对象会调用)
                                3.访问HTML会不会被创建session:    不会

                3.HttprequestListener:监听Httprequest的创建与销毁
                        1.方法:requestInitialzed()销毁 requestDestroy创建
                        2.Httprequest的创建与销毁:
                                在客户端向服务器发送请求时,服务器会创建一个request对象
                                服务器在客户端发来的的请求作出响应后就会销毁request对象
                        3.问题:
                                1.访问Servlet会不会创建request:   会
                                2.访问JSP会不会创建request:          会
                                3.访问HTML会不会被创建request:    会

        2.监听三个域对象的属性变更的监听器:(属性的添加,移除,替换)
                1.ServletContextAttributeListener:监听ServletContext中的属性变更
                        1.方法:attributeAdded()添加  attributeremoved()移除  attributeReplaced()替换
                2.HttpSessionAttributeListener:监听HttpSession中的属性变更
                        1.方法:attributeAdded()添加  attributeremoved()移除  attributeReplaced()替换
                3.ServletRequestAttributeListener:监听ServletRequest对象的属性变更的
                        1.方法:attributeAdded()添加  attributeremoved()移除  attributeReplaced()替换

        3.监听HttpSession中的JavaBean的对象的状态改变的监听器(不用配置,作用在JavaBean中,能自己感知在session中的状态)
                1.HttpSessionBindingListener:监听HttpSession这个的JavaBean的绑定和解绑定
                        方法:valueBound()绑定  valueUnbound()解除绑定
                2.HttpSessionActivationListener:监听HttpSession中的JavaBean的钝化和活化的
                        方法:sessionDidActivate()   --活化(反序列化)
                             sessionWillPassivate() --钝化(反序列到硬盘)






作者: 铁木啊童臂    时间: 2018-6-14 22:56
汪志阳:
省市联动案例思路:
创建数据库-查询所有省份以List封装-转发到jsp运用JQ遍历获取省份信息-在js中编写change事件-Ajax调用get/post方法,跳转到利用pid获取city信息
-在Servlet中完成获取city,List封装数据-转为JSonArray对象,响应打印回js(data),遍历data编写jq语句完成jsp城市的获取.
$(function(){
        $("#province").change(function(){
                var pid=$(this).val();
                $.post("/day0614/CityServlet",{"pid":pid},function(data){
                        var $city = $("#cid");
                        $city.html("<option>-请选择-</option>");
                        $(data).each(function(i,n){
                                $city.append("<option value='"+n.cid+"'>"+n.cname+"</option>");
                        });
                }, "json")
        })
})
监听器:就是一个java类,用来监听其他java的状态变化.
web三类八种监听器:
一类:监听三个域对象的创建和销毁的监听器:
ServletContextListener
HttpSessionListener
ServletRequestListener
二类:监听三个域对象的属性变更的监听器(属性添加,移除,替换):
ServletContextAttributeListener
HttpSessionAttributeListener
ServletRequestAttributeListener
三类:监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)
HttpSessionBindingListener
HttpSessionActivationListener








作者: hpb199567    时间: 2018-6-14 23:15
本帖最后由 hpb199567 于 2018-6-16 00:12 编辑

何平波
JS0N(JavaScript Object Notation)
概述:其实就是一种数据交换格式,可以直接被JS解析
JSON:数据的传输,小,可以直接被JS解析
格式介绍
{"id":1,"name":"aaa"}
[{"id":1,"name":"aaa"},{"id":2,"name""bbb"}]  数组JSON
导哪些包
JSONlib的包
json--lib-2.4
依赖包6个
xstream:生成xml文件的工具包


监听器
概述:就是一个java类,用来监听类的变化
用途:
1.加载框架的配置文件:Spring框架
2.定时任务调度:* Timer,TimerTask
方法:scheduleAtFixedRate()
web中监听器的分类
三类八种

一类:监听三个域对象的监听器
ServletContextListenner:监听servlet的创建和销毁
1.实现ServletContextListenner类,添加方法
2.配置监听器
<listener>
<listener-class>
监听器实现类位置
</listener-class>
</listener>
总结:工程服务启动时创建,工程服务器关闭时销毁

一类:HttpSessionListenner:监听Httpsession的创建和销毁
创建:服务器第一次调用getSession();
销毁:非正常关闭服务器(正常关闭session会序列化)
     session过期了默认30分钟
     手动调用session.invalidate();
访问Servlet不会创建Session监听器
访问JSP会创建Session监听器  (JSP九大内置对象就有getsession()方法)
访问html不会创建Session监听器


一类ServletRequestListenner:监听ServletRequest对象的创建和销毁
创建:客户端向服务器发送一次请求,服务器就会创建rquest对象
销毁:服务器对这次请求做出响应后就会销毁request对象
访问Servlet会创建request对象
访问jsp会创建request对象
访问html会创建request对象

二类ServletContextAttributetListenner 监听ServlectContext中的属性变更


三类监听HttpSession中的JavaBean的对象的状态改变的监听器
第三类监听器很特殊,不需要进行配置
HttpSessionBinDingListenner:监听HttpSession中的Javabeand 解除和绑定的对象
三类HttpSessionActivationListenner:监听HttpSession中的钝化和活化
钝化:序列化(序列化到硬盘)
活化:反序列化
优化Seesion
通过配置<Context> </Context>标签配置定时session序列化
案例总结:利用jq的ajax和json完成从数据库查询省市联动
1.创建数据库,两张表,一张保存省的表,一张保存市的表,市的一个外键对应省的id(这里的外键可以不加约束).
2.先查询省的数据,servlet,domain,service,Dao,将查询到的省的数据转发到注册页面,利用jstl遍历
3.注册页面有两个下拉列表,第一个列表是省的数据,第二个列表是市的数据,给省和市的列表定义一个id.
4.编写一个js文件,可以在注册页面引入,注意这里也要引入JQ的包,这个js文件有一个函数.函数方法触发一个change事件.
5.获取到省的id的值(值=省集合list里的id),ajax的post方法
$.post("获取数据库市的Servlet路径",参数{"pid":pid(pid=省的id值)},回调函数function(data(存入session的字符串),"json(ajax识别json的固定写法)")
6.利用省的id值查询市的数据,servlet,domain,service,Dao,将查询到的市的数据封装到一个集合中,存入json数组中(导包),可以截取需要的数据.将获得的市的数据响应打印,这里打印的是一个字符串类型,所以就可以被封装在data里了.
7.js在获取第二个复选框的id,添加进data.然后遍历,因为是一个集合.这可以随便html写一些东西,清空重复显示的问题.

JsonConfig config=new JsonConfig();
            config.setExcludes(new String[]{"cid","pid"});
截取不需要的元素
JSONArray array = JSONArray.fromObject(list, config);
将list转换成一个json数组



作者: LittleSky    时间: 2018-6-14 23:42
常小天
今天继续学习了AJAX的后续内容,之后还学习了监听器Listener.在今天的案例中我们使用了json作为传输数据的格式. JSON的数据格式如下:
{“id”:1,”name”:aaa}表示封装成一个对象(花括号括起来)
[{“id”:1,”name”:aaa},{“id”:2,”name”:bbb}]表示一个数组(方括号括起来),元素为对象
{ “city”:{“cid”:1,”cname”:”xxx”}}表示一个对象,并给对象起了一个名字.
我们使用JSONArray.fromObject(Object)来将数组或List集合转成JSON.使用JSONObject. fromObject(Object)来将对象或Map集合转成JSON.今天我们在省市联动案例中就使用JSON从后台向前台传输数据.在servlet中将JSON打印至data,在jsp中将jqery和AJAX结合使用来实现省市联动的效果.因为本案例中查询结果是一个集合,所以在jsp中获得data后使用jQuery的循环方法:jQuery对象.each(function(i,n){})来遍历集合并输出.
下午学习的是监听器.监听器就用来监听其他java的状态变化的一个java类.分为三类八种.第一类监听器监听三个域对象的创建和销毁,包括ServletContextListener; HttpSessionListener; ServletRequestListener.第二类监听三个域对象的属性的变更,包括ServletContextAttributeListener; HttpSessionAttributeListener; ServletRequestAttributeListener.第三类监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化).绑定与解除绑定就是JavaBean在session中添加和移除.钝化和活化就是指序列化到硬盘和反序列化,所以钝化和活化不但要求javabean实现HttpSessionActivationListener,而且还要实现序列化接口Serializable.
作者: doudou0606    时间: 2018-6-14 23:48
施炎生
今日总结:
一、重点:使用JSON传输数据(二级联动案例)。学完JSON,要把servlet得到的集合遍历给JS不再需要转发到JSP中进行遍历再传给JS了,可以使用$(data).each(function(){})直接在JS中进行遍历。
二、省市联动思路:首先访问ProvinceServlet得到省的list集合,传到JSP中进行遍历得到省列表,再进入JS中,进入入口函数,进入省的change(function(){$.post(“url”,参数,回调函数,“json”})方法,传省pid到CityServlet得到对应省一下的市list,使用
JSONArray jsonArray=JSONArray.fromObject(list)(备注:这个方法是将数组或list转为Json;如果是对象或Map使用JSONObject jsonObject=JSONObject.fromObject(object););将list集合转为json,响应给JS,使用$(data).each(function(i,n){
                $("#city").append("<optionvalue='n.cid'>"+n.name+"</option>");
})遍历出对应的市。
注意:当第一次选中一个省后,再选中另一个省,会发现第一个省的市出现在第二个省的市列表中,只需再遍历市list之前,加一句        $("#city").html("<option>--请选--</option>");
可以覆盖掉第一个省中的市列表。
三、使用ServletContextListener进行定时任务调度的应用(比如每隔一年发生日祝福邮件)
calendar.set(2018,5,14,16,00,00)
这里的5代表六月份,注意月份的设置是要减一才是我们想得到的月份。
四、回顾Sessoin和Request
【HttpSession的问题】
* 访问Servlet会不会创建Session        : 不会
* 访问JSP会不会创建Session                :会. (Session作为JSP的内置对象默认调用了getSession(),从底层代码可以找到。)
* 访问html会不会创建Session                :不会
【Request问题】:
访问一个Servlet会不会创建request对象:会
访问一个JSP会不会创建request对象:会  
访问一个HTML会不会创建request对象:会

作者: 张述明    时间: 2018-6-14 23:57
张述明
Json
轻量级的数据交换格式
Json的数据格式的介绍
Json(“id”:1,”name”:aaa);
[{“id”:1,”name”:aaa},{“id”:2,”name”:bbb}]

语法规则
数据在键值对中
数据由逗号分开
花括号保存对象
方括号保存数据

Javascript 可以直接解析


Json的生成工具
Jsonlib转换json数据
jsonArray: 将数组或list集合转成Json
jsonobject: 将对象或map集合转成json


Listener 监听器:就是一个java类,用来监听其他的java的状态的变化
Web的监听器(三类八种监听器-三个域对象)
事件源:servlet中三个域对象:servletcontext,
Htttpsession, servletRequest
第一类监听器
监听三个域对象的创建和销毁(3个)
:servletcontextListenner,
HtttpsessionListenner,
servletRequestListenner

第二类
监听域对象的属性变更的监听器(3个)(属性添加,移除,替换)
第三类
监听HTTPsession中的javabean的状态改变(绑定,解绑,钝化,活化)
监听器的使用
编写一个类事件监听器的接口
通过配置文件配置监听器

案例思路
  完成对省的查询并通过foreach遍历
然后自己编写一个js
regist .js
入口函数
//为省份下拉列表绑定事件
获得省份的pID
$.POST("servlet",{"pid":pid} function(data){
字符串转成json
$(data).each(funtion(i,n){
var city=  $("#city");
$city.html("<option>-"请选择"-</option>)

})
//JS识别json
} ,"json" )


servlet   根据省份的id查询市的信息

//获得省份的id

调用业务层 获得List<city> list
把list集合转成JSON
  jsonAarry jsonarray=Jsonarray.fromObject(list);
jsonConfig config=new JsonConfig();
config.setExcludes(new String[] {"pid"})
response.setCotenttype("text/html";charset=utf-8")
request.getWriter().println(jsonarray.toString ())//打印一个对象

作者: 林荣彬    时间: 2018-6-15 00:00
林荣彬
     JSON:轻量级的数据交换格式.可以直接被JS解析
JSON的数据格式:
("key":"value","key":"value")
JSON的生成工具:
   JSONLIB转换JSON数据:
        JSONArray   :将数组转成JSON
        JSONObject  :将对象或map集合转成JSON

JSON需要引入一个核心包,5个依赖包
省市联动案例
1.为省份下拉列表绑定事件
2.获得省份的id
3.获得post的演示方法(路径,参数,回调函数,数据类型)
4.获得市的下拉列表
5.清空下拉列表
6.data遍历数组(JSON其实就是js里面是数组或对象)
7.添加属性

WEB中的监听器共有三类八种:
事件源:servlet中的三个域对象:servletContext,HttpSession,ServletRequest.
监听器:自定义类实现8个接口
事件源和监听的绑定:配置

三类八种:
一类:监听三个域对象的创建和销毁的监听器
二类:监听三个域对象的属性变更的监听器(属性添加,移除,替换)
三类:监听HTTPSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)
第三类监听器很特殊,不需要进行配置,作用在JavaBean上的监听器JavaBean可以自己感知到在session中的状态.
HTTPSessionActivationLisrener:监听Httpsession中的JavaBean的钝化和活化
sessionDidActivate()  ---活化(反序列化)
sessionWillPassivate() ---钝化(序列化到硬盘)

监听器的使用:
1.编写一个类实现监听器的接口
2.通过配置文件配置监听器

企业中的应用:
1.加载框架的配置文件:Spring框架 contextLoaderListener
2.定时任务调度:Timer,TimeTask

优化session
通过配置<Context>标签配置定时session序列化
1. 在Tomcat/conf/context.xml配置<context>    :
2. 在Tomcat/conf/catalina/localhost/context.xml配置<context>

作者: zzx835387607    时间: 2018-6-15 00:10
郑志祥

js.value   this.value
jquery.val();     $(this).val();   this是js的(前面加上一个$,将js转换成jquery)
json 概念;是一种数据格式。

格式就是一个key个value
单个{ “id”:1, “username”:“username”}
单个{ “id”:1, “username”:username}   username是一个变量

利用jeson完成省市联动的案例
解题思路:
1.编写省的Servlet,处理业务,从数据库得到所有的省份,
2.在利用orearch在jsp中遍历,实现省的下拉列表(注意引  jstl.jar   standard.jar  这两个包 )
3.然后在jsp中引入  jquery-1.8.3.js  在从jsp的regist.js跳转到js配置文件中,
4.在js中,通过id触动change的方法(省的改变来带动市的改变)a.先获得pid的值(pid是外键,一(省)对多(个城市),外键建在多的那边)
  b.   $.post( 路径(跳转到城市的Servlet),{参数},function(data){  },json)  注释:data是从城市的Servlet获得所有城市的数组,    $(data).each(function(i,n))  i是索引,n是得到城市的一对键值对
c.     var   $city=$("#city");   注释:这是通过id获取城市的下拉列表
d 。  $city.html("<option>--请选择--</option>");     //这个是为覆盖第一次点击的值,往html添加的值
e。$city.append("<option value='"+n.cid+"'>"+n.cname+"</optiom>")     //在往html添加一个拼接的字符串 相当于<option value='1'>济南</optiom>
.
5.写完js,开始编写city的Servlet,  a。接收pid      b。处理业务    c。config.setExcludes(调用config里面的setExcludes(去除的方法))
f。JSONArray 将的到的城市数组list转为JSON    【JSONObject   将对象或Map集合转成JSON.】
g。打印   response.getWriter().print(jsonArray.toString());  这样data就可收到城市的值了。
作者: chenyelong    时间: 2018-6-15 01:02
陈叶隆
        JSON的数据格式:
{“id”:1,”name”:”aaa”}
[{“id”:1,”name”:”aaa”},{“id”:2,”name”:”bbb”}]
{
    “city”:{“cid”:1,”cname”:”xxx”}
}
        JSONLIB 转换JSON数据:
* JSONArray                :将数组或List集合转成JSON.
* JSONObject        :将对象或Map集合转成JSON.

使用JQ完成省市联动的案例
$(function(){
        $("#province").change(function(){
                var pid = $(this).val();
                $.post("/day15/ServletDemo8",{"pid":pid},function(data){
                        // alert(data);
                        // JS识别JSON:
                        // var json = eval(data);
                        var $city = $("#city");
                        $city.html("<option>-请选择-</option>");
                        $(data).each(function(i,n){
                                // alert(n.cname);
                                $city.append("<option value='"+n.cid+"'>"+n.cname+"</option>");
                        });
                },"json");
        });
});

作者: 黄志彬    时间: 2018-6-15 01:44
黄志彬
JSON;就是一种能被js解析的数据格式.
数据格式
描述一个值{"id":1,"name":aaa}保存的是对象
描述多个值[{"id":1,"name":aaa},{"id":2,"name":bbb}]保存的是数组
{
        "city":{"cid":"1","cname":"xxx"}
}

json的生成工具
JSONArray转换JSON数据
*JSONArray将数组或集合转成json
*JSONObject将对象或map集合转成json

使用xStream工具生成xml,将集合,数组,对象转成xml;
让list集合生成xml;
*首先要引包,6个包。
*直接String xmlStr=new XStream();
//*XStream.toXml(list);
response.setContextType("text/xml;charset=UTF-8");
response.getWriter.println(xmlStr);   把字符串打印给js的data

变成jQuery对象$(data) 遍历标签.each(function(){

var cid=$(this).children("cid").text();

})

优点:遍历解析方便,节省网络传输成本,小巧。


listener监听器:
事件源:servlet中的三个域对象。ServletContext,HttpSession,ServletRequest
监听器:自定义实现8个接口
事件源个监听器的绑定:配置

用来监听其他的对象变化的,主要应用在图形化界面中比较多
分类:
一类;监听三分域对象的创建和销毁的监听器(配置文件)
ServletContextlistener    创建: 服务器启动的时候,服务器为每个web应用创建一个属于web对象的ServletContext,销毁:服务器关闭或者项目移除的时候销毁的
HttpSession                创建:服务器端第一次调用getSession();销毁:非正常关闭服务器(正常关闭session会序列化),过期(session默认30分钟),手动调用session.invalidate().    访问JSP会创建session。访问servlet和HTML都不会创建
ServletRequest                创建:客户端向服务器发送一次请求,服务器会创建request对象 销毁:服务器对这次请求做出响应之后就会销毁request对象。  访问servlet,JSP,HTML都会创建一个request对象。

二类:监听三个域对象的属性的变更的监听器(属性的添加,移除,替换)(配置文件)

三类:监听HttpSession中的javabean的状态改变(绑定,解除绑定,钝化,活化)(不需要进行配置,作用在javabean上的监听器,)
作者: 六道的骸6    时间: 2018-6-15 08:52
张裕
今天掌握了Ajax的文件传输格式 XML和JSON
XML因为体积过于膨大 已被淘汰
接替的是轻量级的数据交换格式 JSON 可以自定义传输的数据格式 减少了没用数据的传输
好像没什么好写的 写下省市联动的操作步骤好了
        1 查询所有的省信息 存入一个List集合中 泛型JavaBean
        2 将集合存到作用域中 重定向或转发到jsp页面
        3 在jsp页面中使用标签库 遍历attribute属性
        4 给下拉框添加change事件触发函数
        5 获取返回的省份id 获取市标签对象 添加一个html标签 覆盖重复
        6 调用异步方法 写入url 参数省id 回调函数 json
        7 在新的Servlet中根据省id查询所在的市 返回List集合 泛型JavaBean
        8 将集合通过JSONArray转为json文件 返回到jsp中
        9 jsp中遍历json文件 在市标签中append子标签


监听器
        用来监听java的状态变化
        主要监听的是三个域对象的变化 创建 销毁 属性变化 (需要到web.xml中绑定监听器)
        JavaBean的监听不用绑定 可以自己感知到在session中的状态
企业中的应用
        1 加载框架的配置文件
        2 定时调度任务: Timer,TimerTask

分组.....
作者: Eclipse启动.    时间: 2018-6-15 16:41
郑阳阳
Json格式:
Json的数据格式是类似键值对的格式:
{"参数名称":参数,"参数名称":参数},{"参数名称":参数,"参数名称":参数}
参数如果不是数字需要加上双引号.
Json的生成方法:
JSONArray :将list集合转为Json
JSONObject:将对象或map集合转为Json
监听器到底发挥了什么作用:
监听器就是一个java类,用来监听其他java状态变化.
监听器有三类八种
一类:监听三个域的创建与销毁
ServletContextListener  ServletContext域
HttpSessionListener        Session域
ServletRequestListener  Request域
二类:监听三个域属性变更
ServletContextAttributeListener  ServletContext域
HttpSessionAttributeListener         Session域
ServletRequestAttributeListener  Request域
三类:监听HttpSession中javabean状态的改变
HttpSessionBindingListener 绑定与解除绑定
HttpSessionActivationListener 钝化与活化

作者: 名字被人注册了    时间: 2018-6-15 18:28
刘文峰
Json是这一种轻量级的数据格式,和xml一样可以用来传输数据,但是比xml更快而且更小,所以现在json用于传输数据的比xml多;
Json的三种数据格式: 是以键值对的形式存数据
1.{ “参数” : 值...} 存单个json对象
2.[{“参数” : 值...},{“参数” : 值...}]  存多个json对象
3.{
“参数:”{“参数” : 值...}...
}
将数据转为json的方法:
JSONArray        :将数组或List集合转成JSON.
JSONObject        :将对象或Map集合转成JSON.
使用json传输数据完成省市联动的案例:
创建两张表分别存放省和市的信息,给省下拉栏绑定一个change事件,调用$.get或$.post方法,方法的参数要多传入一个”json”作为参数(将字符串以json解析),在servlet里查找到省对应的市信息后将数据用方法转为json响应给回调函数的data参数;用jQuery的each()遍历data将数据写到市下拉栏里(写入之前将市里的信息先清除,).

监听器Listener
监听器分为三类八种:
第一类:监听servlet的三个域对象的创建和销毁
写一个类实现ServletContextListener    HttpSessionListener   ServletRequestListener其中的一个接口,重写里面的方法(域对象创建和销毁时触发)就能创建对应域对象的监听器;
第二类:监听三个域对象中属性变化(创建,修改,移除)
创建一个类实现ServletContextAttributeListener  HttpSessionAttributeListener ServletRequestAttributeListener其中一个就可以创建对应的监听器,当里面的属性发生改变时会触发里面的方法
第三类:监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)
创建一个javabean类并实现HttpSessionBindingListener(绑定,解除绑定)   HttpSessionActivationListener(活化,钝化)就可以创建监听器.
作者: LittleSky    时间: 2018-6-15 21:35
常小天
今天继续学习了AJAX的后续内容,之后还学习了监听器Listener.在今天的案例中我们使用了json作为传输数据的格式. JSON的数据格式如下:
{“id”:1,”name”:aaa}表示封装成一个对象(花括号括起来)
[{“id”:1,”name”:aaa},{“id”:2,”name”:bbb}]表示一个数组(方括号括起来),元素为对象
{ “city”:{“cid”:1,”cname”:”xxx”}}表示一个对象,并给对象起了一个名字.
我们使用JSONArray.fromObject(Object)来将数组或List集合转成JSON.使用JSONObject. fromObject(Object)来将对象或Map集合转成JSON.今天我们在省市联动案例中就使用JSON从后台向前台传输数据.在servlet中将JSON打印至data,在jsp中将jqery和AJAX结合使用来实现省市联动的效果.因为本案例中查询结果是一个集合,所以在jsp中获得data后使用jQuery的循环方法:jQuery对象.each(function(i,n){})来遍历集合并输出.
下午学习的是监听器.监听器就用来监听其他java的状态变化的一个java类.分为三类八种.第一类监听器监听三个域对象的创建和销毁,包括ServletContextListener; HttpSessionListener; ServletRequestListener.第二类监听三个域对象的属性的变更,包括ServletContextAttributeListener; HttpSessionAttributeListener; ServletRequestAttributeListener.第三类监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化).绑定与解除绑定就是JavaBean在session中添加和移除.钝化和活化就是指序列化到硬盘和反序列化,所以钝化和活化不但要求javabean实现HttpSessionActivationListener,而且还要实现序列化接口Serializable.

作者: 李思贤126    时间: 2018-6-15 23:32
李思贤:json
        JSON的数据格式
                {“id”:1,”name”:aaa}   单个json
                [{“id”:1,”name”:aaa},{“id”:2,”name”:bbb}]    json数组
        JSONLIB 转换JSON数据:
                JSONArray                :将数组或List集合转成JSON.
                JSONObject        :将对象或Map集合转成JSON.\
案例实现 JSON完成省市联动



        还学习了Listener监听器
                监听器:就是一个Java类,用来监听其他的Java的状态的变化.
        在web中有三类八种的监听器(监听的是三个域对象)
                监听器分为:1.事件源        2.监听器(需要实现8个接口)        3.事件源和监听器的配置
                一类:监听三个域对象的创建和销毁的监听器:
                            ServletContextListener
                             HttpSessionListener
                            ServletRequestListener
                二类:监听三个域对象的属性变更的监听器(属性添加,移除,替换):
                            ServletContextAttributeListener
                         HttpSessionAttributeListener
                         ServletRequestAttributeListener
                三类:监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)
                         HttpSessionBindingListener
                         HttpSessionActivationListener
        想要使用监听器只要两个步骤
                1.编写一个类实现监听器的8个接口之一
                2.通过配置文件配置监听器
作者: 偏离X    时间: 2018-6-16 08:50
三类监听器是针对于Servlet中的三大域对象,
1.监听三大域对象的创建和销毁
2.监听三大域对线的变更(添加,移除,替换)
3.监听Session中javaBean的状态
3.1javaBean的绑定和解除绑定
3.2javaBean的钝化和活化 (钝化)序列化到硬盘  (活化)反序列化

一类:类需要实现对应的接口,在XML中需要进行配置
二类:类需要实现对应的接口,在XML中需要进行配置
三类:类需要实现对应的接口的同时还要实现一个序列化接口,不需要在XML中需要进行配置
作者: Do1    时间: 2018-6-16 15:12
本帖最后由 Do1 于 2019-11-23 00:37 编辑


JQ已经很熟悉了,今天主要了解的是监听器

监听器主要有三类八种,一个是创建销毁,一个是属性变更,一个是javabean状态绑定

首先来说状态绑定,当你把Javabean通过setAttribute在session时,就叫作一种绑定,销毁就叫作解绑,监听器去监听你这两个状态然后你可以进行相应的操作

接着说钝化活化,钝化默认30分钟被钝化可以通过修改tomcat配置修改钝化时间,活化就是服务器器再次调用getsession请求的时候即活化,需要序列化接口和监听器接口(单词太长记不住..)

监听器应用:
监听器实现接口会产生一个run方法,也就是说它单独开了个线程监听事件源
可以通过监听器的延时方法来配合异步传送AJAX WebSocket等等实现定时推送广告,推送消息的功能
作者: q55w66    时间: 2018-6-16 19:58
王清松
XML生成工具
        xstream
                构造方法
                        new Xsteam()
                对象-->XML
                        String toXML(Object obj)
                                将object对象转换为XML(本质就是字符串)
                        例一——转换字符串类型的集合List<String>
                                代码
                                        List<String> list=new ArrayList<>();
list.add("用户名");
list.add("密码");
XStream x=new XStream();
String s=x.toXML(list);
System.out.println(s);
                                结果
                                        <list>
  <string>用户名</string>
  <string>密码</string>
</list>
                        例二——转换JavaBean类
                                JavaBean类代码
                                        package mypackage;

public class User
{
        private String username;
        private String password;
        public User(String username, String password)
        {
                this.username = username;
                this.password = password;
        }
        .......
}
                                代码
                                        User user=new User("用户一","密码一");
XStream x=new XStream();
String s=x.toXML(user);
System.out.println(s);
                                结果
                                          <mypackage.User>
    <username>用户一</username>
    <password>密码一</password>
  </mypackage.User>
                        例三——转换JavaBean类型的集合List<JavaBean>
                                代码
                                        User user1=new User("用户一","密码一");
User user2=new User("用户二","密码二");
List<User> list=new ArrayList<>();
list.add(user1);
list.add(user2);
XStream x=new XStream();
String s=x.toXML(list);
System.out.println(s);
                                结果
                                        <list>
  <mypackage.User>
    <username>用户一</username>
    <password>密码一</password>
  </mypackage.User>
  <mypackage.User>
    <username>用户二</username>
    <password>密码二</password>
  </mypackage.User>
</list>
                修改标签名
                        void alias(String name, Class type)
                        举例
                                修改前
                                        代码
                                                User user=new User("用户一","密码一");
XStream x=new XStream();
String s=x.toXML(user);
System.out.println(s);
                                        结果
                                                  <mypackage.User>
    <username>用户一</username>
    <password>密码一</password>
  </mypackage.User>
                                修改后
                                        代码
                                                User user=new User("用户一","密码一");
XStream x=new XStream();
x.alias("aftermodify", User.class);
String s=x.toXML(user);
System.out.println(s);
                                        结果
                                                <aftermodify>
  <username>用户一</username>
  <password>密码一</password>
</aftermodify>
                将JavaBean类的属性从子标签变为标签属性
                        void useAttributeFor(Class definedIn, String fieldName)
                        更改前
                                结果
                                        默认将类中属性作为子标签
<list>
  <mypackage.User>
    <username>用户一</username>
    <password>密码一</password>
  </mypackage.User>
  <mypackage.User>
    <username>用户二</username>
    <password>密码二</password>
  </mypackage.User>
</list>
                        更改后
                                代码
                                        User user1=new User("用户一","密码一");
User user2=new User("用户二","密码二");
List<User> list=new ArrayList<>();
list.add(user1);
list.add(user2);
XStream x=new XStream();
x.alias("User", User.class);
x.useAttributeFor(User.class,"username");
String s=x.toXML(list);
System.out.println(s);
                                结果
                                        类中属性变为标签属性
<list>
  <User username="用户一">
    <password>密码一</password>
  </User>
  <User username="用户二">
    <password>密码二</password>
  </User>
</list>
JSON(Javascript Object Notation)
        概述
                一种轻量级的数据交换格式
        JSON&JS
                关系
                        一、JSON是一种信息传递的数据格式
二、JSON可以理解为是JS对象的字符串表示法,用字符串表示一个满足JSON格式的JS对象的信息
三、传递时,JSON可以看成一个字符串
                        举例:
JS对象——var obj={a:'Hello',b:'World'}
JSON——var json='{"a":"Hello","n":"World"}'
                互相转换
                        JS对象—>JSON
                                var json=JSON.stringify({a:'Hello',b:'World'})
结果:'{"a":"Hello","b":"World"}'
                        JSON—>JS对象
                                var obj=JSON.parse('{"a":"Hello","b":"World"}')
结果:{a:'Hello',b:'World'}
        语法规则
                数据在键值对中
                数据由逗号分隔
                花括号保存对象
                方括号保存数组
        数据格式
                单个JSON对象
                        单个键值对
                                {key1:value1}
                                举例:
{"firstName":"Json"}
                        多个键值对
                                {key1:value1,key2:value2}
                                举例:
{"firstName":"Json","lastName":"Kingdon"}
                多个JSON对象
                        [{key1:value1},{key2:value2}]
                        举例:
[{"firstName":"Json"},{"lastName":"Kingdon"}]
                        带名称举例:
"People":
[
        {"firstName":"Json"},
        {"lastName":"Kingdon"}
]
        生成工具
                Json-lib
                        对象JSONArray
                                将数组或List集合转成JSON
                                static JSONArray fromObject( Object object )
                                public static JSONArray fromObject( Object object, JsonConfig jsonConfig )
                        对象JSONObject
                                将对象或Map集合转成JSON
                                static JSONObject fromObject( Object object )
                                 public static JSONObject fromObject( Object object, JsonConfig jsonConfig )
                        对象JsonConfig
                                构造方法
                                        public JsonConfig()
                                public void setExcludes( String[] excludes )
                        不带JsonConfig参数举例
                                代码
                                        User u1 = new User("用户一", "密码一");
User u2 = new User("用户二", "密码二");
List<User> list = new ArrayList<>();
list.add(u1);
list.add(u2);
JSONArray json = JSONArray.fromObject(list);
System.out.println(json);
                                结果
                                        字符串
[{"password":"密码一","username":"用户一"},
{"password":"密码二","username":"用户二"}]
                        带JsonConfig参数举例
                                代码
                                        User u1 = new User("用户一", "密码一");
User u2 = new User("用户二", "密码二");
List<User> list = new ArrayList<>();
list.add(u1);
list.add(u2);
JsonConfig f=new JsonConfig();
f.setExcludes(new String[]{"username"});
JSONArray json = JSONArray.fromObject(list,f);
System.out.println(json);
                                结果
                                        字符串
[{"password":"密码一"},{"password":"密码二"}]
                fastjson
作者: wpwing    时间: 2018-6-17 16:40
吴鹏

总结

1 在后台将list集合转成json格式的字符串,打印给data;
2 在前端页面中,遍历json;

json(JavaScript Object Notation):
是一种数据的格式,可以直接被js解析;
轻量级的数据交换格式;

数据格式:
{"id":1,"name":aaa}
[{"id":1,"name":aaa},{"id":2,"name":bbb}]
当只有一个数据时,用花括号包裹,在里面,数据使用双引号包裹,数据之间用逗号隔开,
当有多个数据时,用逗号分隔数据,在外围用方括号包裹;

json的生成工具:
jsonlib;
fastjson;

json转换json数据:
JSONArray   用于将数组或List集合转换成JSON
JSONObject   将对象或Map集合转换成JSON;


将List集合转换成json(不全部要):
JsonConfig config = new JsonConfig();
config.setExcludes(new String[] {"pid"});
以上代码转换后的json里面不包含pid字段的数据;

JS识别JSON:
只需在$.post或$get括号里面最后面添加数据类型"json"\\

------------------------------------------------
监听:
监听三个域对象的创建和销毁

监听三个与对象属性的变更

监听session中的JavaBean的状态

web中的监听器:

web中的Listener和Filter是属于Servlet规范中的高级的技术;
web中的监听器共有三类八种(监听三个域对象)
事件源 : Servlet中的三个域对象,ServletContext,HttpSession,ServletRequest
监听器: 自定义类实现8个接口
事件源和监听器的绑定,只需配置一下就可以;

web中的监听器的分类:
三类八种:
第一类:监听三个域对象的创建和销毁的监听器:
ServletContextListener
HttpSessionListener
ServletRequestListener
第二类,监听三个域对象的属性变更的监听器(增,删,改):
ServletContextAttributeListener
HttpSessionAttributeListener
HttpRequestAttributeListener
第三类 监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化):
HttpSessionBindingListener
HttpSessionActivationListener

监听器的使用:
编写一个类实现监听器的接口:
通过配置文件配置监听器:

一类:监听三个域对象的创建和销毁的监听器:
ServletContextListener监听ServletContext的创建和销毁
方法:
void contextInitialized(ServletContextEvent sce) 监听创建
void contextDestroyed(ServletContextEvent sce) 监听销毁

ServletContext对象的创建和销毁:
创建:服务器启动的时候,服务器为每个web应用创建一个属于该web项目的对象
销毁:服务器关闭或者项目被移除的时候;

配置在web.xml中配置Listerner标签;
企业中的应用:
1 加载框架的配置文件:Spring框架ContextLoaderListener
2 定时任务调度:
Timer,TimerTask;

HttpSessionListener

创建和销毁:
void sessionCreated(HttpSessionEvent se)
void sessionDestroyed(HttpSessionEvent se)
创建:服务器第一次调用getSession()
销毁:非正常关闭服务器(正常关闭时session会序列化到本地);过了默认的30分钟时限;手动调用session.invalidate()


ServletRequestListener
创建和销毁:
void requestInitialized(ServletRequestEvent sce) 监听创建
void requestDestroyed(ServletRequestEvent sce) 监听销毁

创建:客户端向服务器发送一次请求,服务器就会创建request对象
销毁:服务器对这次请求做出相应后就会销毁;

----------------------------------------------------
监听三个域对象属性的变更的监听器

ServletContextAttributeListener
void attributeAdded()
void attributeRemoved()
void attributeReplaced()

HttpSessionAttributeListener
void attributeAdded()
void attributeRemoved()
void attributeReplaced()

HttpRequestAttributeListener
void attributeAdded()
void attributeRemoved()
void attributeReplaced()

--------------------------------------------------------

监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)
第三类监听器比较特殊,不需要进行配置,作用在JavaBean上的监听器,JavaBean可以自己感知到在Session中的状态;
HttpSessionBindingListener
保存到session域中时会绑定,移除时解绑;
void valueBound()
voidUnbound()

HttpSessionActivationListener
钝化:序列化
活化:反序列化
void sessionDidActivate()    活化
void sessionWillPassivate()    钝化

---------------------------------------------------------



作者: 许大炮    时间: 2018-6-19 19:43
许剑鸿         webDay22

JSON : JAvaScript Object Notation            JS对象标记 是一种轻量级的数据交换格式,用来存储和表示数据 , 提高网络传输效率

JSON数据格式:         {"id":1,"name":aaa} 单条json              [{"id":1,"name":aaa},{"id":2,"name":bbb}] json数组

JSONLIB两种转换JSON数据的方法:
        JSONArray:将数组或List集合转成JSON.
        JSONObject:将对象或Map集合转成JSON.


Listener :监听器 就是一个Java类实现(8种)Listener 用来监听状态的变化

事件源:被监听对象
监听器:监听的对象
事件源与监听器的绑定
事件对象:事件源的改变.

三类八种监听器:(1.创建类实现listener 2.配置文件)
第一类:监听三个域对象的创建和销毁的监听器:
    * ServletContextListener   监听ServletContext对象的创建和销毁
    * HttpSessionListener  监听HttpSession的创建和销毁的监听器
    * ServletRequestListener  监听ServletRequest对象的创建和销毁的监听器:

第二类:监听三个域对象的属性变更的监听器(属性添加,移除,替换):
    * ServletContextAttributeListener  监听ServletContext对象的属性变更
    * HttpSessionAttributeListener 监听HttpSession中的属性变更
    * ServletRequestAttributeListener 监听ServletRequest对象的创建和销毁的监听器

第三类:监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)  
比较特别 不新建类实现接口而是在JavaBean中使它实现HttpSessionBindingListener/HttpSessionActivationListener 且不需要配置配置文件

    * HttpSessionBindingListener 监听HttpSession中的JavaBean的绑定和解除绑定的
    * HttpSessionActivationListener 监听HttpSession中的JavaBean的钝化和活化的.  同时JavaBean要实现序列化接口
        void sessionDidActivate(HttpSessionEvent se)  活化:数据反序列化到内存中
         void sessionWillPassivate(HttpSessionEvent se)  钝化:数据序列化到硬盘

优化Session(同时大量的用户访问  且一部分一段时间后变不进行操作 为了节省内存 让一段时间不进行操作的用户数据序列化到硬盘中):
     * 通过配置<Context>标签配置定时session序列化   可配置序列化时间及存储的位置.
         * 在tomcat/conf/context.xml中配置<Context>:在tomcat中所有的虚拟主机和虚拟路径都会按照这个配置执行.
         * 在tomcat/conf/Catalina/localhost/context.xml配置<Context>:在tomcat中的localhost虚拟主机中的所有虚拟路径按照这个配置执行.
         * 在当前的工程下的META-INF/context.xml配置<Context>:当前这个工程按照配置执行.

作者: 5119    时间: 2018-6-19 19:46
游荣辉
总结
        今天学了json
        JSON的数据格式
                {“id”:1,”name”:aaa}   单个json
                [{“id”:1,”name”:aaa},{“id”:2,”name”:bbb}]    json数组
        JSONLIB 转换JSON数据:
                JSONArray                :将数组或List集合转成JSON.
                JSONObject        :将对象或Map集合转成JSON.\
        还学习了Listener监听器
                监听器:就是一个Java类,用来监听其他的Java的状态的变化.
        在web中有三类八种的监听器(监听的是三个域对象)
                监听器分为:1.事件源        2.监听器(需要实现8个接口)        3.事件源和监听器的配置
                一类:监听三个域对象的创建和销毁的监听器:
                            ServletContextListener
                             HttpSessionListener
                            ServletRequestListener
                二类:监听三个域对象的属性变更的监听器(属性添加,移除,替换):
                            ServletContextAttributeListener
                         HttpSessionAttributeListener
                         ServletRequestAttributeListener
                三类:监听HttpSession中的JavaBean的状态改变(绑定,解除绑定,钝化,活化)
                         HttpSessionBindingListener
                         HttpSessionActivationListener
        想要使用监听器只要两个步骤
                1.编写一个类实现监听器的8个接口之一
                2.通过配置文件配置监听器
作者: 咸鱼coder    时间: 2018-6-19 21:33
万冕

今天学了jq加强和新的listener

listener是一个监听器,就是用来监听状态的改变,

监听术语:

        事件源:被监听对象
        监听器:监听对象
        事件源与监听器绑定:就是在事件源上安装监听器
        事件:就是事件源被改变

web监听器主要监听三个域对象:

ServletContext,HttpSession,ServletRequest

监听的状态有:监听三个域对象的创建与销毁

ServletContext:
创建:第一次开启服务器的时候,会为每一个web创建一个单独的对象ServletContext
销毁:服务器正常关闭或者项目被移除



HttpSession:
创建:第一次调用getSession()的时候创建
销毁:默认时间过期,手动调用Session.invalidate,非正常关闭服务器(如果正常关闭服务器,Session会被序列化到硬盘上)

访问Servlet不会创建Session,因为他没有调用getSession();
访问JSP会创建Session,因为Jsp里面有内置对象Session,会默认调用getSession()
访问html不会创建Session,因为他没有调用getSession();


ServletRequest:
创建:浏览器发送一次请求时,服务器就会创建一个request对象
销毁:服务器对这次请求处理响应完毕后就会销毁request对象

访问Servlet会创建request,因为会产生一次请求
访问JSP会创建request,因为会产生一次请求
访问html会创建request,因为会产生一次请求

三个域对象的属性变更

添加属性,移除属性,替换属性(名字相同,覆盖)

监听HttpSession的JavaBean状态改变
绑定和解除绑定(在javabean中实现HttpSessionBindingListener接口)
钝化(序列化)与活化(反序列化)在JavaBean中实现HttpSessionActivationListener





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2