A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

同学们,今天讲JQuery,主要讲了一个省市联动案例;讲监听器Listener,主要介绍了web开发中的三类监听器。

今日需要掌握的有:
  • 掌握Json格式
  • 省市联动案例中掌握响应JSon数据,对响应XML数据不作要求。
  • 对于监听器,更重在理解,理解监听器到底发挥了什么作用?能够知晓有三类监听器,可以对每类监听器做大概的描述,对于代码则不作要求。


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


29 个回复

正序浏览
万冕

今天学了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
回复 使用道具 举报
5119 中级黑马 2018-6-19 19:46:12
27#
游荣辉
总结
        今天学了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.通过配置文件配置监听器
回复 使用道具 举报
许剑鸿         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>:当前这个工程按照配置执行.
回复 使用道具 举报
吴鹏

总结

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()    钝化

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


回复 使用道具 举报
王清松
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
回复 使用道具 举报
Do1 中级黑马 2018-6-16 15:12:02
23#
本帖最后由 Do1 于 2019-11-23 00:37 编辑


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

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

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

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

监听器应用:
监听器实现接口会产生一个run方法,也就是说它单独开了个线程监听事件源
可以通过监听器的延时方法来配合异步传送AJAX WebSocket等等实现定时推送广告,推送消息的功能
回复 使用道具 举报
三类监听器是针对于Servlet中的三大域对象,
1.监听三大域对象的创建和销毁
2.监听三大域对线的变更(添加,移除,替换)
3.监听Session中javaBean的状态
3.1javaBean的绑定和解除绑定
3.2javaBean的钝化和活化 (钝化)序列化到硬盘  (活化)反序列化

一类:类需要实现对应的接口,在XML中需要进行配置
二类:类需要实现对应的接口,在XML中需要进行配置
三类:类需要实现对应的接口的同时还要实现一个序列化接口,不需要在XML中需要进行配置
回复 使用道具 举报
李思贤: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.通过配置文件配置监听器
回复 使用道具 举报
常小天
今天继续学习了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.
回复 使用道具 举报
刘文峰
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(活化,钝化)就可以创建监听器.
回复 使用道具 举报
郑阳阳
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 钝化与活化
回复 使用道具 举报
张裕
今天掌握了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

分组.....
回复 使用道具 举报
黄志彬
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上的监听器,)
回复 使用道具 举报
陈叶隆
        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");
        });
});
回复 使用道具 举报
郑志祥

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就可收到城市的值了。
回复 使用道具 举报
林荣彬
     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>
回复 使用道具 举报
张述明
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 ())//打印一个对象
回复 使用道具 举报
施炎生
今日总结:
一、重点:使用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对象:会
回复 使用道具 举报
常小天
今天继续学习了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.
回复 使用道具 举报
12下一页
您需要登录后才可以回帖 登录 | 加入黑马