黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】XML [打印本页]
作者: 厦门校区 时间: 2018-5-30 18:01
标题: 【厦门JavaEE就业1期-每日总结】XML
同学们，今天继续学习了DBUtils，我们学习了ResultSetHandler的几种实现类，而后我们又学习了XML配置文件，这在我们之后的JavaWeb开发中大家几乎天天会用到。
今日需要掌握的有：
- 熟练使用BeanHandler和BeanListHandler对查询的数据进行封装
- 熟练使用ScalarHandler对查询的数据进行封装
- 理解XML的作用
- 会使用dom4j结合Xpath对xml进行解析
请同学们按照如上要求，总结今日所学。
作者: finfin12 时间: 2018-5-30 19:46
张育辉
XML总结:
一; xml是可扩展的标记语言
xml是自定义标签,区分大小写,有开始标签就必要结束标签,标签必须正确嵌套;
xml一般用于配置文件
XML的CDATA区:(CDATA:Character Data)
二: <![CDATA[ 内容 ]]> 里面的内容特殊符号可以不用转译,会当做字符串解析
实例:<![CDATA[ if(a>b&&b<c){原数据} ]]>
XML的解析的方式(*****):
DOM解析:DOM:Document Object Model.
SAX解析:Simple Api for XML.
DOM和SAX的区别:
DOM解析方式是:一次性将文档加载到内存,形成树形结构进行解析,
优点:可以对xml进行增删改的操作;
确定:如果xml文件过大,容易导致内存溢出;
SAX解析方式是:事件的驱动方式,一条一条的加载到内存;
优点:如果xml文件过大,不会导致内存溢出;
确定:不可以对xml进行增删改的操作;
针对这两种解析的方式，不同的公司提供了不同的API的实现.
JAXP:SUN公司提供的一套XML的解析的API.
JDOM:开源组织提供了一套XML的解析的API-jdom.
JDOM为了减少dom,SAX的编码量才出现的,
但是底层还是使用了SAX
DOM4J:开源组织提供了一套XML的解析的API-dom4j.
DOM4J是一个非常优秀的Java XML api,具有性能优异,功能强大和极端易使用的特点,
同时他是一个开放源代码的软件,
pull:主要应用在Android手机端解析XML.
三: 针对xml解析方式
//创建解析器
SAXReader saxreader = new SAXReader();
//解析XML文档,返回一个文档
Document read = saxreader.read("xml/demo1.xml");
//获取根节点
Element element = read.getRootElement();//presoins
//System.out.println(element.getName());
//查询跟节点下面的子节点
Element elem1 = element.element("presion");
Element element2 = elem1.element("name");
Element element3 = elem1.element("age");
Element element4 = elem1.element("sex");
System.out.println(element2.getText());
System.out.println(element3.getText());
System.out.println(element4.getText());
四:xpath解析,属于dom4j解析,调用selectNodes("//name")方法,返回一个集合,可以获取所有name的元数
selectNodes() 获得所有的节点
selectSingleNode() 获得一个节点
五:XML的约束的种类及区别?
DTD 和 Schema :
区别:
1.DTD语法是自成一体的.Schema语法就是XML的语法.
2.Schema的语法就是XML的语法所以更容易被解析器所解析.
3.Schema支持名称空间.
4.Schema有比DTD更加强大的语义和语法的约束.
作者: conan75 时间: 2018-5-30 20:00
陈昆明:
今天对DBUtils的查询方式以及XML进行了初步的学习:
运用DBUtils的查询方法Query对数据库进行查询后会产生一个结果集,那么我们需要用resultsethandler接口对结果集进行处理,那么就有以下几种模式:
1.自己编写一个实现类实现resultsethandler接口
2.使用DBUtils工具类的ArrayHandler实现类对结果集进行处理,返回一个Object类型的数组
3.使用DBUtils工具类的ArrayListHandler实现类对结果集进行处理,返回一个Object类型的数组集合
4.使用DBUtils工具类的BeanHandler实现类对结果集进行处理,返回Bean类的对象
5.使用DBUtils工具类的BeanListHandler实现类对结果集进行处理,返回一个Bean类对象的集合
6.使用DBUtils工具类的MapHandler实现类对结果集进行处理,返回Map集合
7.使用DBUtils工具类的MapListHandler实现类对结果集进行处理,返回一个Map集合的集合
针对单条的查询结果可以使用ScalarHandler对结果进行处理,返回一个Object类型对象
XML:可拓展性标记语言
有两种解析方式:
DOM树解析:一次性将XML文件加载至内存中形成DOM模型,可进行增删改操作,但可能会导致内存溢出
SAX解析:使用事件驱动模式对文件进行逐行解析,不可进行增删改操作,但不会导致内存溢出
可使用Dom4J进行解析,可结合XPath对路径进行快速查找
作者: 许大炮 时间: 2018-5-30 20:00
许剑鸿 webDay12
今日重点掌握部分:
DBUtils查询:重点掌握ArrayHandler ArrayListHandler BeanHandler BeanLIstHandler
ArrayHandler:将结果集中的第一条记录封装到一个Object[]数组中
ArrayListHandler:将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
BeanHandler:将结果集中第一条记录封装到一个指定的javaBean中。 javaBean中成员变量名必须与数据库中列名相同类型相同 且javaBean中必须有无参构造
BeanLIstHandler:将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
XML解析:
XML:可扩展性标记语言 用于传输和存储数据 一般用于配置文件;
XMl语法注意事项:*第一行定格必须是文档声明<?xml 属性名=”属性值” 属性名=”属性值” ...?>*必须关闭所有标签 *区别大小写*属性要有引号*标签必须正确嵌套
解析方式分为DOM解析与SAX解析
重点掌握:
DOM4J XPATH解析步骤:
*导包 DOM4J 与XPATH jar包
*创建解析器 SAXReader
*read文档获得document对象
*获得节点对象或者装有多个节点对象的列表 List | document.selectNodes(String xPath);/Node | document.selectSingleNode(String xPath);
*操作
作者: 渣.. 时间: 2018-5-30 20:06
柯威龙
首先今天学习了DBUtils的查询功能.这个查询功能分为很多种.其中最重要的就是ArrayList和BeanList
每种都分为多条查询和一条查询.然后学习了xml.xml是一种可扩展标记语言.跟html类似.xml主要是被用来当做
配置文件的.xml语法和html大致相同.只要学习了就是xml的解析.xml有两种解析方式一种空是DOM一种是Sax.DOM的有点事可以
对xml进行增删改操作,但是他也有缺点,缺就是他属于一次性加载到内存的,如果文件过大的话他就会内存溢出.
SAM反之.两种解析方式凡是有多种解析的方法,API.其中今天主要学习的是DOM4J.解析的步骤首先是导包.
然后创建解析器,解析文档获得DOcument对象.然后获得根节点.最后从跟节点上去寻找子节点.
后面学习了Xpath的解析方式,在代码上会比较的简便.
作者: 13163997058 时间: 2018-5-30 20:18
王刘锁
依稀记得早上学习的是DBUtils的查询query()方法!其实是把查询到的数据封装.还
好要重点掌握的就两种方式也就是结果集的一些实现类,
首先不管哪种方式,我们先创建queryRunner对象
QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
接下来就是各种查询方法
第一种:数组ArrayHandler()和ArrayListHandler()的封装方法,
object [] obj = queryRunner.query("select * from accounts where id=?",new ArrayHandler(),1);
1是?对应的值---这时查询一条记录
System.out.println(Arrays.toString(obj);---输出
List<object[]> list = queryRunner.query("select * from accounts where id=?",new ArrayListHandler(),1);
,---这是查询多条记录,每条记录是一个数组,
把数组存入集合,这种方式要遍历list来输出
for(Object[] object1 :list){
System.out.println(Arrays.toString(object1));
}
第二种方法:对象BeanHandler()和BeanListHandler(),这中方式要事先创建一个
bean(Account类 必须空参构造和setget方法toString方法)来
Account account = queryRunner.query
("select * from accounts where id=?",new BeanHandler<Account>(Account.class),1);
这里面泛型写的就是之前创建的bean,参数是bean的class对象,返回的是bean对象,那我们就可以直接输出这
个对象.那如果查询多条记录就可以参考上面的数组方法不过就是数组换成对象.
第三种:单值封装ScalarHandler(),很简单,查询统计数的时候可以用
Object obj = queryRunner.query("select count(*) from accounts",new ScalarHandler());
,直接输出obj就是统计出来的数字
然后学习了XML;它是一种通用性扩展标记语言跟HTML很像,不过XML现在一般用来做
为配置文件,因为它通用于各种编程语言,虽然它也有传输数据和存储数据的功能,
但是比它功能强大存储有数据库传输有Json,那我们学习一门语言就要学习它的语
法和规范.比较重要的是XML的标签是可扩展的我们可以自己定义标签,但是必须有
关闭标签,标签的属性值必须用引号,嵌套必须规范对应,并且标签名严格区分大小
写,说到名字那规则也要说一下,起名字可以用数字字母和其它字符,但不能数字和
标点符xml字样开头,而且名称不能有空格,像特殊字符和声明注释什么的简单的可以去查手册!!
下面写一段代码,用DOM4J+XPath解析XML文件
关于解析方式我们只要记住解析方式只有两种DOM和SAX,两者的不同就是DOM加载进
内存形成树结构,方便曾删改数据但是如果文件太大会内存溢出,SAX呢就是一条一
条的解析,不会内存溢出但是不能增删改数据,DOM4J巧妙的融合两种方式所以用的
最多,XPath呢是定义了一些可以直接获取标签路径的表达式,很暴力的样子.下面是
解析步骤
第一步:导包.dom4j-1.6.1.jar 不多说
第二步:创建解析器:SAXReader reader = new SAXReader();
第三步:解析文档:Document document = reader.read("xml/demo.xml");Document
是文档加载进内存形成树结构后的对象
第四步:利用XPath的格式来获取想要的标签元素.具体的表达式可以查api
List<Node> list = document.selectNodes("//city");
遍历list输出
for(Node node : list){
Element element = (Element)node;强转,
System.out.println(element.getText()--获取文本内容);
}
很多表达式和方法查手册就好了.然后是约束,就记住有两种约束DTD和Schema以及
区别就可以了,毕竟也不可能自己去写约束,区别就是DTD自立门户,Schema跟XML一
家亲,所以跟容易被解析并且支持名称空间(不知道啥意思)比DTD更强大的约束力.
作者: wpwing 时间: 2018-5-30 20:21
吴鹏
总结
---------------------------------------------------------------
DBUtils查询:
ArrayHandler:将一条记录封装到一个Object数组中;
ArrayListHandler:将多条记录封装到一个装有Object数组的List集合中
一条记录封装到Object[]数组中,多条记录就是多个Object[]数组,那么多个Object数组就将其装入List集合中;
BeanHandler BeanListHandler
1 将一条记录封装到一个JavaBean中;
Account account = queryRunner.query("select * form account where id = ?",new BeanHandler<Account>(Account.class),2);
System.out.println(account);
2 将多条记录封装到一个装有javabean的List集合中;
如果有多条记录,则将多条记录存放到List集合中;
List<Account> list = queryRunner.query("select * form account",new BeanListHandler<Account>(Account.class));
for(Account account : list) {
System.out.println(account);
}
javaBean用来描述一个实体,一张表的列名为JavaBean中的成员变量,写入get,set方法,即可为一个表格的JavaBean;
上面代码的account就是一个实体类,我们在创建实体类的时候,一定要保证实体类中的成员的数量和名称要和数据库中对应
表格的数量和列名一致;这个方法是通过无参构造写入数据,所以实体类中一定要有一个无参构造;
MapHandler MapListHandler
ColumnListHandler
将数据中的某列封装到List集合中;
ScalarHandler
返回的是long类型而不是int类型;
将单个值封装;
KeyedHandler
将一条记录封装到一个map几何中,将多条记录封装到一个装有map集合的map集合中,外层的key是
可以指定的;
---------------------------------------------
xml的概述
a 什么是xml:可扩展标记语言,用于标记电子文件时期具有结构性的编辑语言
主要是用来传输数据,而非显示数据
没有预定义,要自行定义标签;
具有自我描述性;
允许用户自定义
b 作用: 传输和存取数据;
软件的配置文件;
xml的使用:
xml的语法
XML的文档声明
通常出现在第一行第一列的位置!!
<?xml 属性名="属性值" 属性名="属性值"?>
version :必须的,值为1.0
encoding :字符集,是使用浏览器打开的时候采用的默认的自父子的编码;
standalone :描述这个xml是否需要依赖其它的文件
大小写敏感,要有根节点,属性值要有双引号;...
xml的注释
<!--注释内容-->
元素
名称字母,数字,或其他字符
不能以数字或标点开头
不能以字符xml开始
不能包含空格
不能有冒号
属性
特殊字符和CDATA区
< <
> >
& &
' '
" "
CDATA(character Data):
在该区域的内容都会被当成普通字符串,而不当成特殊字符;
<![CDATA[内容]]>
xml的解析:
从xml文档中获得想要的数据(通过代码);
DOM解析:document object model
一次性将文档加载进内存,然后通过读取树状结构来解析
如果文档特别大,容易导致内存溢出
可以对xml进行增删改
SAX解析:simple api for xml
事件驱动,逐行解析
不能对文档进行增删改,
如果文档特别大,不会导致内存溢出
针对这两种解析方式,不同的公司提供了不同的api的实现;
JAXP :sun公司提供的一套xml解析的api
JDOM :开源组织提供的一套xml的解析的api-jdom
DOM4J :开源组织提供的一套xml的解析的api-dom4j
pull :主要应用在安卓手机端
-------------------------------------
DOM4J:
属于第三方,需要导入jar包;
创建解析器;
解析文档获得代表文档的document对象;
获得根节点;
从根节点下查找其它的节点;
获得代表整个xml文档的对象;
在这个类库中,重写了SAX,通过SAX可以获得整个xml对象;
1 创建解析器;
SAXReader reader = new SAXReader();
2 解析xml文档;
Document document = reader.read("demo1.xml");
3 获得根节点;
Element root = document.getRootElement();
System.out.println(root.getName());
4 查找根节点下的子节点 element(),elements();
Element p = root.element("person");第一个person元素;
root.elements("person").get(2);第二个person元素;
Element n = p.element("name");
Element a = p.element("age");
Element s = p.element("sex");
System.out.println(n.getText());
System.out.println(a.getText());
System.out.println(s.getText());
-----------------------------------------
xpath:
DOM4J中想要使用xpath的话,需要导入dom4j支持xpath的jar包;
dom4j的xpath支持的api:
List document.selectNodes(String xpath);
Node document.selectSingleNode(String xpath);
1 创建解析器:
SAXReader reader = new SAXReader();
2 解析xml文档;
Document document = reader.read("demo1.xml");
3 获得节点:
List<Node> list = document.selectNodes("//name");
for(Node node : list) {
Element element = (Element) node;
System.out.println(element.getText());
}
document.selectNodes("//person[@id]");
-----------------------------------------
约束:
就是用来约束xml文档中可以出现那些标签,不能出现那些标签,标签中是否有顺序,出现的次数;
用来规范xml的写法;
xml约束的种类及区别:
DTD:
语法是自成一体的,不支持名称空间,
Schema:
语法就是xml的语法,更容易被解析器所解析,支持名称空间,有比DTD更加强大的语义和语法的约束,
作者: 小故事 时间: 2018-5-30 20:30
谢洪彬
今天学习的DBUtiles的查询操作和XML
DBUtiles的查询(调用Query方法):
重点是使用BeanHandler和BeanLlistHandler完成查询
次重点是使用ArrayHandler和Arraylisthandler完成查询
具体的使用看需求,如果是单条记录查询怎使用不带list的方法,返之查询多条则使用带list的方法
javaBean的多条查询需要传入2个参数:
1.第一个传入查询单条数据的SQL语句
2.第二个传入new出来的BeanHandler对象,需要传入泛型和泛型的.class对象
泛形:既对应你数据库的类,这个类中的成员变量需要和你数据库中的数据名称一致,数据类型一致;
javaBean的单条查询需要传入3个参数:
相对于多条查询,单条最后需要多加一个查询条件的值;
XML:
概述:可扩展性标记语言
作用:一般作用于配置文件使用
相对于html的标签是定义好的,每个标签都有他特有的功能,而XML的标签则可以自己定义,但是标签的定义也是需要遵循XML的定义规则的,不能随意定义
1.XML的编写一定要有文档声明,放在第一行的第一列
2.XML的编写要有一个大的标签进行包裹;
后面又学习了XML的两种语法
1.DOM
等DOM加载到内存完毕后开始执行
优点:可以对XML进行增删该
缺点:文件过大时可能会造成内存溢出
2.SAX
读取一行加载一行
优点:文件过大不会造成内存溢出
缺点:不能对文件进行增删改
今天又着重学习了操作XML的API工具,DOM4J他可以同时作用于DOM和SAX
使用DOM4J时需要导包
使用DOM4J中的XPATH查询XML文件中的数据是今天学习XML的重点,同样在使用XPATH的时候也需要导包配合使用;
使用XPATH查询元素大致思路:
1.创建SAX对象
2.利用SAX对象调用reader()方法读取XML文件路径,获取Document对象,
3.利用Document对象但用查询第一个或者多个的方法完成查询
作者: 1748341437 时间: 2018-5-30 20:51
2018/5/30 林玮
今天又接着前两天继续学jdbc,算是一个进阶吧,主要就是学一个更简单的查,前两天学的查不够简单,能简单谁会往难的写呢?对吧.然后还有就是xhl配置文件和一个Tomcat的一个了解;
jdbc:
今天呢是jdbc最后一个知识点了,学的是一个增删改查里的查完全版的,和以往不同的是他是将结果集封装到集合,数组或一个指定的javaBean中,重点学习BeanHandler:就是将结果集封装到javaBean中的,为什么他要重点学习呢?首先他以后会比较常用,其次是他相对其他的也会比较简单一点.
xml:
第二个就是一个xml了,他是一个类似于HTML的标记语言,不同HTML的它还是一个标签需要自定义的可扩展标记语.他可以传输,存储数据但那是以前,现在只有少数企业用它来传输和存储数据了,它现在的主要用途是配置文件.
Tomcat:
最后了解了一下Tomcat,明天重点学习,他是一个服务器,之前我们都是用java项目文件夹来写代码的,而他在里面有一个特有项目文件夹就是那个带小圆球的,对就是那个.然后他的一个目录结构也和之前不大一样,还有就是学习了它,别人就可以在内网中通过你的ip地址和端口号访问到你做的页面了.
作者: 李思贤126 时间: 2018-5-30 20:54
李思贤:今天上午学习了DButils中的查询部分，其中主要要掌握BeanHandler和BeanListHandler的使用；其他的几种查询方法（）用的不多。
BeanHandler举例: Student student = queryRunner.query("select *from student where sid =?",new BeanHandler<Student>(Student.class), 8);
BeanListHandler举例:
List<Student> list = queryRunner.query("select * from student", new BeanListHandler<Student>(Student.class));
1使用DBUtils工具类的ArrayHandler实现类对结果集进行处理,返回一个Object类型的数组
2.使用DBUtils工具类的ArrayListHandler实现类对结果集进行处理,返回一个Object类型的数组集合
3.使用DBUtils工具类的MapHandler实现类对结果集进行处理,返回Map集合
4.使用DBUtils工具类的MapListHandler实现类对结果集进行处理,返回一个Map集合的集合
下午主要学习了XML(可扩展性标记语言):
用来传输存取数据和软件的配置文件.
它有两种解析方式XML的解析的方式:
1:DOM解析 2:SAX解析.
针对这两种解析的方式，不同的公司提供了不同的API的实现.
* JAXP :SUN公司提供的一套XML的解析的API.
* JDOM :开源组织提供了一套XML的解析的API-jdom.
* DOM4J :开源组织提供了一套XML的解析的API-dom4j.
* pull :主要应用在Android手机端解析XML.
DOM4J支持XPath的jar包.我们要求掌握这种解析:
1:List document.selectNodes(String xPath);
2:Node document.selectSingleNode(String xPath);
解析步骤:1在Test中创建解析器:
SAXReader reader = new SAXReader();
2 解析XML文件返回Document对象:
Document document = reader.read("xml/demo1.xml");
3查找:
List<Node> list = document.selectNodes("//name");
List<Node> list = document.selectNodes("//person[@id]");
4 遍历输出:
for (Node node : list) {
Element element = (Element) node;
System.out.println(element.getText());
for (Node node : list) {
Element element = (Element) node;
System.out.println(element.attributeValue("id"));
}
作者: 望蜀 时间: 2018-5-30 20:55
邵倩
DBUtils的查询操作
创建一个实体类(JavaBean) Account
属性的数据类型要写包装类 Integer,Character等
表和实体一一对应指表中的字段(如id)和JavaBean中的属性(如private Integer id)一致,类名和表名无需一致
一定要有无参构造方法(可以不写构造方法 会默认生成一个无参构造)
一定要有get set方法
ResultHandler是一个接口 它有如下实现类
ArrayHandler: 把一条记录封装到一个Object数组 只显示值不显示列名
ArrayListHandler: 把多条记录封装到一个装有Object[]的List集合中 只显示值不显示列名
BeanHandler: 一条记录 JavsBean对象 列名和值都显示
BeanListHandler: 多条记录 JavsBean集合 列名和值都显示
MapHandler: 一条记录 Map集合 key是列名,value是表中的值 泛型<String,Object> 列名和值都显示
MapListHaandler: 多条记录 装有Map集合的List集合 List的泛型<Map<String,Object>> 列名和值都显示
ColumListHandler: 将数据中的某列的值封装到List集合中
ScalarHanler: 将单个值封装 如select count(*) from...
(了解)KeyedHandler:将一条记录封装到一个Map集合中.将多条记录封装到一个装有Map集合的Map集合中,而且外层的Map的key是可以指定的.
元数据 DBUtils的底层 不要求掌握
XML EXtensible Markup Language 可扩展的标记语言
和HTML的区别:HTML里的每个标签都有自己的功能,XML里的标签可以自定义,但是没有自己的功能. HTML和XML都要有根标签
XML的作用: 传输和存储数据 被json和数据库替代
软件的配置文件
XML语法:
文档声明: 通常出现在XML的第一行顶格的位置 <?xml version="1.0" encoding="UTF-8"?> 自动生成
XML的注释: <!--注释--> 和HTML一样
XML的元素(标签)的命名规范:不能以数字 标点符号 xml开头 名称不能有空格
XML的属性:同上 并需要加引号
XML的特殊字符:大于 小于 和 单引号 双引号
CDATA(Character Data)区: <![CDATA [ ] ]> 标签里面的所有内容都被当成字符串处理
必须有关闭标签
区分大小写
标签必须正确嵌套
XML的解析
通过代码从XML文档中获取想到的数据.
解析方式(面试):
DOM解析: Document Object Model 一次性将文档加载到内存 形成树形结构 再解析. 如果文档特别大,容易导致内存溢出. 可以对XML进行增删改操作.
SAX解析: Simple Api for XML 逐行解析. 不会导致内存溢出. 不能对XML进行增删改操作.
针对这两种解析方式 不同的公司提供了不同API的实现
JAXP: SUN公司提供的一套XML的解析的API
JDOM: 开源组织提供了一套XML的解析的API 叫JDOM
DOM4J: 开源组织提供了一套XML的解析的API 叫JDOM4J
pull: 主要应用在Android手机端解析XML
DOM4J
步骤一: 导入dom4j核心jar包
步骤二: 创建解析器
步骤三: 解析文档
步骤四: 获得根节点
步骤五: 从根节点获取其他节点
XPath
步骤一: 导入dom4j核心jar包 和 DOM4J支持XPath的jar包
步骤二: 创建解析器
步骤三:
List list=document.selectNodes(String xPath);
Node node=document.selectSingleNode(String xPath);
作者: 六道的骸6 时间: 2018-5-30 21:06
张裕
JDBC高级和XMl
ResultSetHandler的实现类
(数组)
ArrayHandler
将一条记录封装到一个数组当中.数据类型为Object[]
ArrayListHandler
将多条记录封装到一个List集合中 泛型为Object[]
(需要创建一个JavaBean类 类中的成员变量名字需要与表中的列名一致)
BeanHandler
将一条记录封装到一个JavaBean中
BeanListHandler
将多条记录封装到一个List集合中 泛型为JavaBean
(Map集合)
MapHandler
将一条记录封装到一个map集合中 key为列名 value为表中记录的值
MapListHandler
将多条记录封装到一个List集合中 泛型为Map
(了解↓)
ColumnListHandler
将数据中的某一列封装到List集合中
ScanlarHandler
将单个值封装
KeyedHandler
将一条记录封装到一个Map集合中
将多条记录封装到一个装有Map集合的Map集合中,外面的Map的Key是可以指定的
XML
概述
可扩展性标志语言(允许用户自定义标签)
作用
传输和存取数据
软件的配置文件
语法(区分大小写 必须有关闭标签 标签必须正确嵌套)
文档声明(必须在第一行第一列位置)
<?xml 属性名="属性值"...?>
version:必须写 版本号 通常使用1.0
encoding:字符集 是使用浏览器打开的时候采用的默认的字符集编码
standalone:描述XML文档是否需要依赖其他的文件
注释(跟HTML一样)
元素(标签)
命名规则
名称不能以数字或者标点符号开头
名称不能包含空格
名称不能以字符"xml"开始
名称中不能包含冒号(:)
属性
命名规范与元素(标签)一致
属性需要使用引号
特殊字符
大于小于等特殊符号需要用字符代替
CDATA区(字符数据 Character Data)
<![CDATA[写入的数据都被当成字符串 不会报错]]>
XML的解析:从XML文档中获得想要的数据(通过代码完成)
解析方式
DOM解析(文档对象模型):一次性将文档加载到内存 形成树形结构进行解析
缺点:容易导致内存溢出
优点:可以对XML进行增删改的操作
SAX解析:事件驱动的方式,逐行解析
缺点:不能对文档进行增删改的操作
优点:不会导致内存的溢出
API的实现
XML的解析API
JAXP
JDOM
DOM4J
pull:主要应用在Android手机端解析
DOM4J的使用
1 创建解析器 new SAXReader();
2 解析文档获得Document对象
3 获得根节点
4 查找根节点下的子节点
XPath:
dom4j支持XPath的jar包
dom4j的XPath支持的API
List document.selectNodes(String xPath);
Node document.selectSingleNode(String xPath);
元素(标签)对象.attributeValue(String)获取value值
服务器端口号的转变
1 创建解析器
2 解析文档获取Document对象
3 获取元素(标签)对象
4 获取端口号value
5 修改服务器端口号 需要用Integer方法转换String字符串
XML的约束
概述:用来约束XMl的文档中可以出现的标签,标签中是否有顺序,出现的次数
约束:规范XMl的写法
约束的种类及区别?
DTD和Schema
区别:DTD的语法是自成一体的.Schema语法就是XML的语法
Schema更容易被解析器所解析 支持名称空间
Schema有比DTD更加强大的语义和语法的约束
DTD的语法:(了解)
引入方式:
内部:<!DOCTYPE 根标签[]>
外部:
本地DTD:<!DOCTYPE 根标签 SYSTEM "unknown.dtd">
网络DTD:<!DOCTYPE 根标签 PUBLIC "//UNKNOWN/" "unknown.dtd">
元素:<!ELEMENT 元素名 元素类型>
元素类型:EMPTY ANY 子元素(是否有序:使用 , 或者竖线 | 出现的次数: ? + *) PCDATA
属性<!ATTLIST 元素名称 属性名称 属性类型 属性约束>
属性类型:
ID类型:表示属性值需要是唯一的
CDATA类型:普通的字符串
枚举:
属性约束:查APi
Schema的语法:(了解查API)
作者: Eclipse启动 时间: 2018-5-30 21:13
郑阳阳
BeanHandler和BeanListHandler对查询的数据进行封装:
BeanHandler是ResultSet的一个实现类,用于封装单个对象,返回一个对象
BeanListHandler是ResultSet的一个实现类,用于封装多个对象,返回一个对象集合
ScalarHandler对查询的数据进行封装:
ScalarHandler是ResultSet的一个实现类,用于封装单个值,比如count(*),返回一个Object对象
XML的两个作用:传输和存储数据和配置文件.
要使用dom4j结合Xpath对xml进行解析的话,需要导入dom4j-1.6.1.jar和jaxen-1.1-beta-6.jar.
创建SAXReader对象调用read传入xml的路径返回一个Document对象.
然后selectSingleNode是得到一个数据.
selectNodes可以获得多个数据.
得到的数据是Document类型,输入前需要强转成Element类型然后调用getText方法.
作者: hpb199567 时间: 2018-5-30 21:16
何平波
Dbutils查询
第一种查询 ResultSet
查询一条记录
(1)实体类
(2)QueryRunner qr=new QueryRunnner(传入连接池);
qr.quere("sql语句",new ResutSetHandler<表名>(),条件)
(3)重写Handle方法
查询多条记录
(1)实体类
(2)QueryRunner qr=new QueryRunnner(传入连接池);
qr.quere("sql语句",new ResutSetHandler<List<表名>>()){
(3)重写Handle方法}
(4).遍历 ,增强for
第二种查询
1.ArrayHandler(将一条记录封装到数组中) 和2.ArrayListHandler(将多条记录封装到数
组中)
1.QueryRunner qr=new QueryRunnner(传入连接池);
object[] obje= qr.quere("sql语句",new ArrayHandler(),条件)
输出语句是数组转字符串 Arrays.toString()
2.QueryRunner qr=new QueryRunnner(传入连接池);
List<Object[]> list=qr.quere("sql语句",new ArrayListHandler())
增强for遍历
输出语句是数组转字符串 Arrays.toString()
第三种查询
1.有一个实体类javabe的私有成员变量要与查询表中的数据类型和列名是一样的,生成
get`set方法,toString方法,jb类名与查询的表可以不一样,但里面的成员变量是一样的!
2.BeanHandler(将一条记录封装到JB中)
3.BeanListHandler(将一条记录封装到JB的list集合中)
1.QueryRunner qr=new QueryRunnner(传入连接池);
jb类名 变量名= qr.quere("sql语句",new BeanHandler<jb类名>(jb类名.class),条件)
输出变量名
2.QueryRunner qr=new QueryRunnner(传入连接池);
List<表名> list=qr.quere("sql语句",new BeanListHendler<jb类名>(jb类名.class)
())
因为拿到是全部的元素,要增强for遍历
输出变量名
第四种查询
1.MapHandler(将一条记录封装到Map中)
2.ManListHandler(将多条记录封装到Map中)
1.QueryRunner qr=new QueryRunnner(传入连接池);
Map<String,Object> 变量名= qr.quere("sql语句",new MapHandler<>(),条件)
输出变量名
2.QueryRunner qr=new QueryRunnner(传入连接池);
List<Map<String,Object>> 变量名= qr.quere("sql语句",new MapListHandler<>())
增强for遍历
输出变量名
第五种查询
1.ColumnListHandler(将某列的值封装到Column中)
2.ScalarHandler(单值封装到Scalar中) 比如求count(*),max(),就可以使用这个方法
1.QueryRunner qr=new QueryRunnner(传入连接池);
List<Object> 变量名= qr.quere("sql语句",new ColumnListHandler<>())
增强for遍历
输出变量名
2.QueryRunner qr=new QueryRunnner(传入连接池);
Object 变量名= qr.quere("sql语句",new ScalarHandler())
输出变量名
XML
1.概念:可扩展的标记语言,很类似HTML,允许用户自定义标签
2.xml的作用:
(1)传输 和 存取数据 (2)软件的配置文件
3.区分大小写,正确的嵌套,必须有关闭标签,属性有引号
4.cdata区 字符串区 写法<![CDATA[字符串内容]]>
5.xml的解析的方式
(1)DOM解析 Document Object Model:文档对象模型解析
(2)SAX解析 Simple Api for XML:简单的API进行xml文件的解析
区别:
DOM:一次性将文档加载到内存,形成属性结构进行解析
优点:如果文档特别大,容易导致内存溢出
缺点:对xml进行增删改的操作
SAX:时间驱动的方式,逐点行进行解析的
缺点:不能对文档进行增删改的操作
优点:如果文档特别大,不会导致内存的溢出
DOM4j解析 (引包)
环境准备 1.引包 2.创建xml文件并放入xml文件夹
步骤1.创建解析器 SAXReader 变量名1=new SACReader();
步骤2.获取解析XML的文档 Document 变量名2=变量名1.read("xml的路径")
步骤3.获得根节点 Elenment 变量名3=变量名2.getRootElement();
步骤4.查找根节点下的子节点 Element 变量名4= 变量名3.element("标签名");//查找第
一个标签元素
步骤4.查找根节点下的子节点 Element 变量名4= 变量名3.elements("标签名");//查找
第一个标签的所有元素
方法 attribute 获得id为..的元素
getText 获得..的文本内容
Xpath解析xml文件
环境准备 一个xml文件,xml文件里有自己定义的数据, 添加 dom4j.jar包 和 dom4j下
的插件功能包jaxen.jar包.
步骤一:创建解析器 SAXReader
步骤二:解析xml返回document对象 read("xml的文件路径")
步骤三:selectNodes(//) 获取xml文件的全部指定元素
selectsingleNode(//) 获取xml文件的单个元素
//符号的意思是如果路径以双斜线 // 开头, 则表示选择文档中所有满足双斜线//
之后规则的元素(无论层级关系)
/基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那
么该路径就表示到一个元素的绝对路径
*星号 * 表示选择所有由星号之前的路径所定位的元素
//* 选择所有元素
注意获取id的话就是attributeValue
作者: Do1 时间: 2018-5-30 21:19
本帖最后由 Do1 于 2019-11-23 00:36 编辑
BeanHandler和BeanListHandler还有ScalarHandler都是ResultSetHandler的实现类,DBUtils帮我们写好了方法,我们只需要传入一个javabean范型,还有通过这个范型的字节码反射来获取这个javabean的对象,这样我们就可以把sql读取好的数据放入这个类中,这个类中主要有set和get方法每读到一次sql传过来的数据就把这个数据set进去,如果是单个数值就用ScalarHandler用Object类来接收,多个就用BeanListHandler用List集合接收,也可以用Map集合来接收非主流的值,格式为Map<Object,Map<String,Object>>用的是KeyedHandler类,ColumnListHandler类可以用来接收表中行的指定列的值.
XML主要是用来配置文件的,XML是一种可扩展标记语言它和超文本标记语言一样都是用标签,不同的是XML中的标签名没有被规定住可以随便用,不过XML有基本的语法比如XML必须有关闭的标签,必须区分大小写,所有的属性值需要有引号,标签也需要正确的去嵌套,XML有一个文档声明放在最上方
<?xml 属性名="" 属性值="" ...>这个主要是对XML文件指定一个规则
XML中的约束以后不需要我们来写,是大神写的所以了解一下就行了
今天主要学习的是通过java代码获取到xml中的值,用到的是dom4j这个东西SAXReader Document Element注意不要导错包,List<Node> list = document.selectNodes("//person['@id']");这里面的字符串可以传各种数据,去看API写了很多方式,底层的东西不需要了解,所以会用这个dom4j解析就行了
作者: 磬辰 时间: 2018-5-30 21:25
林文辉
DBUtils工具类之常用查询：
ArrayListHandler()将多条记录存入Obejct[]的List集合中
List<Object[]> list= queryRunner.query(sql,new ArrayListHandler())
BeanHandler<User>((User.class));)将一条记录封装到一个JavaBean中
User user = queryRunner.query(sql, new BeanHandler<User>(User.class));
BeanListHandler<User>将多条记录封装到一个装有JavaBean的List集合中
List<User> list = queryRunner.query(sql, new BeanListHandler<User>(User.class));
ScalarHandler()将单个值进行封装
Object object = queryRunner.query(sql,new ScalarHandler());
ResultSetHandler<List<User>>()查询多条记录存入对象的list集合中（使用匿名内部类）
List<User> list = queryRunner.query(sql,new ResultSetHandler<List<User>>())（使用匿名内部类）
ResultSetHandler<User>()查询单条记录存入对象中
User user = queryRunner.query(sql,new ResultSetHandler<User>())
ArrayHandler()将单条记录存入Object[]中
Object[] object = queryRunner.query(sql,new ArrayHandler())
MapHandler() 将一条记录存入Map集合中,key为列名
Map<String,Object> map = queryRunner.query(sql, new MapHandler())
MapListHandler() 将多条记录存入装有Map的List集合中
List<Map<String,Object>> list = queryRunner.query(sql, new MapListHandler());
ColumnListHandler()将数据中的某列的值存入List中
List<Object> list = queryRunner.query(sql,new ColumnListHandler("name"));
XML语法:
1.允许自定义标签
2.可以作为传输和存储数据，普遍用于配置文件
3.语法严谨，区分大小写，不能以数字或者标点符号开始，不能包含空格
4.非CDATA区使用特殊符号需转义，CDATA区则没有限制。
XMl解析：
1.分为DOM解析和SAX解析。两者的区别在于：
DOM：是一次性读取整个文件，如果读取的文件过大，可能会导致内存溢出，
但是DOM可以对XML文件进行增删改的操作
SAX：逐行进行解析，不能为XMl文件进行增删改的操作，但是由于是逐行解析
所以不会出现内存溢出的情况。
2.针对这两种解析方式，主流的API的实现有;DOM4J，pull(主要针对于Android手机端解析XML)
3.通过DOM4J支持的jar包XPATH，可以更简洁的对XML文件进行解析。
3.1创建解析器：SAXReader reader = new SAXReader();
3.2解析XML返回Document对象 Document document =reader.read("XML路径");
3.3通过 document.selectNodes()或者document.selectSingleNode()获取标签
Tomcat:
1.阿帕奇公司研发的一个小型服务器，支持servlet/jsp;
2.默认端口号是8080，通过本机ip地址:8080或者localhost:8080加上自己的项目名即可访问，
或者可以将项目拷贝到Tomcat的webapps目录下，通过localhost:8080然后再Manager下进行访问。
作者: LittleSky 时间: 2018-5-30 21:36
常小天
今天继续学习了JDBC的进阶内容，接着又学习了一些XML的知识。
JDBC进阶部分内容学习的是DBUtils的查询操作。使用DBUtils查询数据库数据的时候，我们将查询的结果进行封装，不同方法将其封装成不同的数据类型。这里我们重点掌握BeanHandler方法和BeanListHandler方法，这两个方法将查询结果封装成了类，一条表记录就封装成一个对象，前者查询单条记录并封装，后者查询多条记录并封装，将封装成的多个对象再装进集合中返回。这里需要传入一个字节码文件作为参数，这个字节码文件时我们编写的与要查询的记录相匹配的类的字节码文件。需要注意的是这个类中的成员变量的类型和变量名要与待查询的记录中的字段完全一致，否则就会出错。这是因为封装的方法就是将查询的数据赋给这个类的成员变量，而能够数据赋给正确的，相匹配的变量的依据就是类的变量名和表记录的字段名一致。
XML部分的内容主要是使用DOM4J以及XPath解析XML文件。XML文件的编写与HTML很类似，个别不同的地方稍加注意即可。XML的语法要求比HTML严格，XML区分大小写，必须要有根标签，必须要关闭标签，属性必须要加引号……编写好XML文件后，再编写java代码对其进行解析。步骤为：创建解析器、解析并返回document对象、使用document对象获得标签对象、通过标签对象获得其内容和属性。这里可以利用Xpath简化代码。正确使用“//标签名【@属性名】”的格式并理解其含义。
作者: lnongge 时间: 2018-5-30 21:40
16weisong
今天上午学习了使用DBUtils工具类进行查询,使用这个的好处是会对查询的结果集进行封装,可以封装到数组,javabean中,也可以封装到map集合中,其中要掌握的是封装到数组和javabean中.下午学习类xml及其解析,只要掌握使用dom4j及xpath解析xml文档即可.
作者: 名字被人注册了 时间: 2018-5-30 21:40
刘文峰
使用beanHandler()和beanListHandler()对数据进行封装:
beanHandler()封装数据是将一条记录封装成一个javabean对象,beanListHandler()封装数据是将多个javabean对象存进集合中.不管哪种都要先有一个Javabean类,类的成员属性名要和表的字段名(列名)一样,还需要属性的set/get方法,否则数据无法封装进去.
封装步骤:
创建核心类 QueryRunner(需传入一个连接池);
封装数据 query()方法 如果sql语句中有?,则方法内还要根据?传入参数
query(“sql语句”,new beanHandler( javabean类.class) ); 返回一个javabean对象
query(“sql语句”,new beanListHandler( javabean类.class) );返回一个Javabean对象的集合
scalarHandler是将单个值进行封装,zz步骤与上面的类似,但不需要新建一个Javabean类,也不需要往里传入Javabean类的字节码对象.
Xml:
xml是可扩展标记语言,与html不同,xml文件用户可自定义标签名.
xml的作用是传输和存储数据和软件的配置文件,但通常作为配置文件使用,因为传输数据和存取数据有数据库.
xml的使用:
语法:
1基本语法:必须关闭标签 区分大小写 元素之间正确嵌套 必须且只能有一个根节点 属性需要加引号
2文档声明: 只能在xml第一行第一列的位置 <?xml 属性名="属性值"... ?> 有三种属性:
version(版本号)属性必须出现 使用1.0 encoding 字符集 standaone xml是否需要依赖其他文件 no,yes
3注释: 和html一样 <!-- -->
4元素(标签): 命名规则 不能以数字,标点符号,xml开头 不能有空格 不能有":"
5属性:命名规范和元素一致 属性要引号
6特殊字符: < < >> ' &apos "" " & &
cdata区 <![cdata[ 这里面的内容当字符串处理 ]]>
xml的解析:获取xml文件获得数据
dom解析 : 一次性将文档加载到内存,形成树状图
缺点:可能导致内存溢出 优点:可以对xml增删改
sax解析 : 逐行解析
缺点:不能增删改 优点:不会内存溢出
dom4J解析文件步骤: 导入jar包
创建解析器saxreader() 解析xml文件read(xml文件路径)返回一个document对象 获得根节点getrootelement() 查找子节点element()
XPath:导jar包:dom4J和jaxen.jar 主要由两个方法:
获取多个元素:selectNodes(); 获取单个元素:selectSingleNodes();
创建解析器saxreader() 获得document对象read(xml文件路径)
作者: seilye 时间: 2018-5-30 21:44
DBUtils:
增删改的步奏:
1,导入jar包(数据库连接,c3p0,dbutlis)
2,创建连接池对象ComboPooledDataSource
3,创建DBUtlis传入连接池对象QueryRunner
4,调用update例如queryrunner.update("insert into user values(null,?,?,?,?)", "aaa", "246", "大白", 15);
查询的步奏:
1,导包,引入jar包
2,创建连接池对象ComboPooledDataSource
3,创建DBUtlis传入连接池对象QueryRunner
4,调用query方法得到结果第二个参数主要有BeanHandler,BeanListHandler,ArrayHandler,ArrayListHandler
5,打印输出
XML:
解析步奏:
1,导入jar包.dom4j-1.6.1.jar
2,创建解析器 SAXReader
3,解析文档获得代表文档的Document对象. 调用read方法来解析传入xml文件例如"src/demo.xml"
4,调用selectNodes方法来使用Element的集合泛型来接收数据
5,将数据转型成Element类型,例如List<Element> list = (List<Element>)*******;
作者: rkko 时间: 2018-5-30 21:47
杜石苇
BeanHandler<T>
用于获取结果集中的第一行数据，并将其封装到JavaBean对象。
整个转换过程最终会在 BeanProcessor 类中完成。比如我们创建的Account类 成员变量都和SQL表的字段一样;
需要注意的是，默认的情况下要保证表的字段和javabean的属性一致（字符一致即可，对大小写不敏感），
比如字段是userName，那么javabean中属性必须是userName这几个字母
（可以是username，UserName，userNAME，不过还是建议按照规范来定义）。
BeanListHandler<T> 用于将结果集的每一行数据转换为Javabean，再将这个Javabean添加到ArrayList中。可以简单的看着是BeanHandler的高级版，只不过是多了一步，就是将生成的Javabean添加到ArrayList中，其他的处理都和BeanHandler一样。
ScalarHandler 的参数为空或null时，返回第一行第一列的数据,一般用来返回单个数值 比如 select count(*) from user;
XML就是种定义数据的标机语言，并没有定义如何传输，你可以把他放在http get的response里面，也可以直接拷贝一个xml文件到u盘里。其扩展xsd定义了xml的schema，而xslt又定义了xml的转换方式，这些使得xml更加强大。
现在用的比较多的是配置和数据结构定义;
XML的解析用Xpath 很方便
SAXReader 来读取XML文件 selectNodes 选择要读取的元素
作者: 李志勇 时间: 2018-5-30 21:47
DBUtils:
通过DBUtils的学习 能够更便捷的读取MySQL中的数据
创建DBUtils中核心类对象 传入连接池对象参数
QueryRunner qr=new QueryRunner(JDBCUtils.getDataSource());
qr.query(sql, rsh, params);获取所需要获得的查询结果,其中rsh为传入一个ResultSetHandle的对象;
重要的是传入
new Beanhandle<javaBeand的类>(javaBeand的类.class);把数据一条记录存入JavaBean的对象中返回一个javaBean
对象
new BeanListHandler<Account>(Account.class)
XML:
是一种可扩展标记语言;
常用作用是软件配置文件;
重要是xmlde 解析 两种解析
DOM;一次性将文档加载到内存 形成树形结构进行解析;
缺点 文档特别大容易导致内存溢出,优点; 对xml进行增删改操作
SAX:事件驱动的方式,一行一行进行解析
缺点 不能对文档进行增删改 优点 不会导致内存溢出;
主要使用的是DoM4J的解析
解析步骤
导入jar包.dom4j-1.6.1.jar----创建解析器 SAXReader sr=new SAXReader();---解析文档 获取文档Document对
象sr.read("传入要解析xml文件的路径");---获得根节点 document.getrootelement();----从根节点查其他的节
点, getelement()获取单个节点 getelements()获取多个节点 传入需要获得节点的参数;
xpath:
解析步骤
导入jar包.dom4j-1.6.1.jar----创建解析器 SAXReader sr=new SAXReader();---解析文档 获取文档Document对
象sr.read("传入要解析xml文件的路径");---获取所需要的值 .selectNodes();传入要获取值的参数,
作者: 光宇 时间: 2018-5-30 21:48
侯玉林
今天先讲了dbutils的各种扩展方法,后面介绍了xml的基本写法,以及如何如何通过xml获取端口号,进行端口监听.
作者: 厦门陈强 时间: 2018-5-30 21:48
陈强
XML的一天,
首先今天的第一部分内容还是DBUtils的内容---查询功能---BeanHandler
昨天是使用queryRunner.update,进行增删改的操作
今天进行查询使用的是queryRunner.query的方法去查询,根据查询的方法的不同,返回值也是不同,查询一个使用BeanHandler返回一个对象,查询多个内容使用BeanListHandler返回一个集合,在对集合去遍历获取结果.
整体流程还是先导入相应的JAR包,然后创建核心类,再执行查询,最后输出结果
第二部分是XML的解析---Xpath
首先要导入DOM4J的jar包和指定功能对应的jar包,然后创建解析器,获取reader的对象,然后根据对象去读取XML文件获取一个存在于内存中的对象document,最后根据需要查询的标签内容去查询指定的内容即可.
查询一个标签使用----selectSingleNode
查询多个内容使用selectNodes,返回一个集合
其中注意返回值的类型,Node相当于最根本的类型,包含了Document\Element\Attribute\Text,所有最后进行输出查询结果的时候,最好是向下转型,会有更多子类的方法可以使用.
作者: 凉面要趁热吃 时间: 2018-5-30 21:50
黄进安:
1. 使用dbutils工具类实现对数据库的查询操作,
l 创建一个类,通过这个类的对象来接收从数据库查询到的数据
l 类里的成员变量名必须与查询到的表名一致
学习了以下几种查询方法:
l MapHandler和MapListHandler--->将结果集第一行封装到Map集合,多条查询再把Map集合存储到List集合
l ArrayHandler和ArrayListHandler--->将结果集中的每一条记录都封装到一个Object[]数组中,多条查询将Object[]数组存储到List集合
l ColumnListHandler：将结果集中指定的列的字段值，封装到一个List集合中
l ScalarHandler：它是用于单数据
比较常用的两种查询方法:
l BeanHandler和BeanListHandler--->将结果集中第一条记录封装到一个指定的javaBean中,多条结果集把这些javaBean存储到List集合
2. 学习了可以用来存储和传输数据的可扩展语言XML
两种XML的解析方式: DOM解析和SAX解析
主要使用DOM4J解析方法: 两种解析方式都包含了
n List | document.selectNodes(String xPath);--->查找所有目标节点
n Node | document.selectSingleNode(String xPath);--->查找第一个目标节点
作者: 厦门黑马王子 时间: 2018-5-30 21:50
郑雪平
今天学习了两大类内容,一个是使用DBUtils完成CRUD的查询操作和使用XML作为配置文件的方式来完成模拟tomcat.在进行DBUtils操作前首先第一步要先引入JAR包,接着是创建一个实现类,在类里写上set,get以及tostring方法,然后才是写下测试类和创建test方法,接下来就是要开始写QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
至于使用XML作为配置文件模拟tomcat,首先要知道xml是一个可扩展的标记语言,它的作用是传输数据和存取数据以及作为软件的配置文件使用,xml对语法有一定的要求,1.必须要有关闭标签;2.区分大小写;3.需要有引号;4.标签必须嵌套正确才行;最重要的一点是必须在第一行第一列写上文档声明,写在其它地方都是不行的,格式也是固定且一成不变的:<?xml version="1.0" encoding="UTF-8"?> ;对元素的命名也是有一定规则的,具体如下:1.不能以数字或标点符号开头;2.不能以字符"xml"作为开头;3.不能含有空格.xml的解析分为两种,分别是DOM和SAX.两者各有优缺点,所以是有区别的.由于有存在缺点,所以有个开源组织提供了一套解析方法叫DOM4J使xml能更好的解析文件.
作者: Yanmo_ 时间: 2018-5-30 21:51
颜琳琳
今日先学习了DBUtil的查询:(是用来封装查询到的数据)主要通过九个实现类来学习:
1.ArrayHandler: 将一条记录封装到有个Object数组中
2.ArrayListHandler: 将多条记录封装到一个装有Object数组的集合
3.BeanHandler: 将一条记录封装到一个javaBean中
4.BeanListHandler:将多条记录封装到一个装有javaBean的集合中
5.MapHandler:将一条记录封装到有个Map的集合中
6.MapListHandler:将多条记录封装到一个装有Map的集合List集合中
7.ColumnListHandler:将单列值封装到哟个集合中
8.ScanlerHandler:单值封装
9.keyedHanlder:将多个数据封装到一个装有Map集合的Map集合中
(注: 以上几种实现类只需要掌握BeanHandler和BeanListHandler即可,其他作为了解即可)
接着学习了Xml,Xml是可扩展标记语言,作用是用来1.存储数据和传输数据 2.软件的配置文件(其中作为软件的配置文件是主要的作用)
Xml的语法:1:用<!-- -->来注释 2.区分都大小写 3.属性需要加引号 4.标签必须要嵌套 5.xml必须有关闭标签 5.特殊符号不能直接写 如:< >要写成 < 和 > 5.命名规范不能以xml,数字,标点符号等开头,不能有空格;
Xml的解析:DOM 和 SAX解析:
这两者的区别在于:1.DOM是一次性将文档加载到内存中,以树状的形式解析,而SAX是一行一行的解析. 2. 优点: Dom可以对XML进行增删改查的操作,而SAX的优点是如果文档太大不会造成内存溢出 3.缺点: Dom的缺点是如果文档太大会造成内存溢出,而Sax的缺点是不能对Xml进行增删改查.(对于这两种解析的解析方式有以下几种,由不同的公司提供的API进行解析:1.pull(主要用于解析Android手机端解析) 2.Dom4J 3.DomJ 4.JAXP)
主要掌握Dom4J解析:有两种方式:一种是传统的,另一种是XPATH解析,其中XPATH(只需需要掌握其中SelectNodes()获取多个标签的属性和SelectSingleNode()获取一个标签属性,以及attributeValue获取属性值 要获取某个标签的属性的写法需注意: 如获取person中所有id属性的要写成: //person[@id] 不能写成 //person[‘@id’])
最后还学了XML的约束:xml的约束是让xml文档的标签可以在哪个位置,不能再哪个位置,出现的次数以及在标签中的顺序,主要的作用是让xml写的更规范,不会被使用者随意更改. xml的约束的种类有DTD和Schema两种,主要区别如下: 1.DTD的语法是自成一体的,而Schema的语法就是XML语法, 2.Schema的语法是xml的语法解析起来更方便 3.Schema有比DTD更强大的语法和约束.
作者: Ldddd 时间: 2018-5-30 21:53
赖镇东
今天早上一开始讲的DButils根本听不懂在讲的是啥！我整个人听得犯困，也跟我请假多天，mysql和JDBC没学的原因有关。听下来差点睡着，最重要的Bean什么的方法也不懂。之后的XML学到了XML是一门可扩展标记语言，虽然标签可以自定义，但是还是有一些规范。Xml的功能有传输和存储文件，但是现在已经基本没人用了，最主要的功能是配值文件，学会了利用导入jar包利用dom4j解析XML，还学到了限制规范xml，但是只要能懂就可以。
作者: chenyelong 时间: 2018-5-30 21:54
陈叶隆
1.DBUtils 查询:
1.1 i)ArrayHandler：将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
ii) ArrayListHandler：将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
1.2 i) BeanHandler：将结果集中第一条记录封装到一个指定的javaBean中。
ii) BeanListHandler：将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
QueryRunner qr=new QueryRunner(JDBCUtils.getDataSource());
List<Exam> list = qr.query("select * from exam where id in(?,?,?)",new BeanListHandler<Exam>(Exam.class) ,2,3,4);
for (Exam exam : list) {
System.out.println(exam);
}
<![CDATA[ ]]>
2.XML解析:
DOM4J解析:
【步骤一】导入jar包.
【步骤二】创建解析器.
SAXReader sr = new SAXReader();
【步骤三】解析文档获得代表文档的Document对象.
Document doc= sr.read("src/demo1.xml");
【步骤四】获得节点.
List<Node> list = doc.selectNodes("//person[@id]");
【步骤五】获得属性值.
for (Node node : list) {
Element element = (Element) node;
System.out.println(element.attributeValue("id"));
}
作者: 5119 时间: 2018-5-30 21:54
游荣辉
总结
今天学习了JDBC的查询,前面第一行跟增删改一样,然后调用BeanHandler(查询一个封装成一个对象)或者BeanListHandler(查询多个封装成一个List集合对象)
还学习了mxl
什么是mxl呢?(就是可扩展标记语言)
可以用来存储数据也可以用来传输数据,但是一般都用来作为配置文件
想要在Java中使用mxl就必须解析它:
解析的方式有两种,dom(一次性把文件加载到内存) sax(一行一行的解析)
还学了dom4j:
用dom4j解析
【步骤一】导入jar包.dom4j-1.6.1.jar
【步骤二】创建解析器
【步骤三】解析文档获得代表文档的Document对象.
【步骤四】获得跟节点.
【步骤五】从跟节点下查找其他的节点.
用dom4j下面的Xpath解析
【步骤一】导入jar包.dom4j-1.6.1.jar和jaxen-1.1-bata-.jra
【步骤二】创建解析器
【步骤三】使用read方法解析,放回一个Document对象
【步骤四】使用支持xpath的jar包里的方法 selesNodes()返回一个集合(selesNode是返回一个node对象)
【步骤五】遍历集合
【步骤六】强转成子类对象
【步骤七】调用子类方法得到想要的值
作者: 滴滴eclipse启动 时间: 2018-5-30 21:55
江某人:
//创建解析器
SAXReader reader=new SAXReader();
//解析sql到Document对象
Document read = reader.read("xml文件);
//获得节点
List<Node> list = read.selectNodes("节点");new Beanhandle<javaBeand的类>(javaBeand的类.class);把数据一条记录存入JavaBean的对象中返回一个javaBean 对象
new BeanListHandler<Account>(Account.class)
XML的作用:
是一种可扩展标记语言;
常用作用是软件配置文件;
重要是xmlde 解析 两种解析
DOM;一次性将文档加载到内存 形成树形结构进行解析;
缺点 文档特别大容易导致内存溢出,优点; 对xml进行增删改操作
SAX:事件驱动的方式,一行一行进行解析
缺点 不能对文档进行增删改 优点 不会导致内存溢出;
dom4j结合Xpath对xml进行解析:
解析步骤
导入jar包.dom4j-1.6.1.jar----创建解析器 SAXReader sr=new SAXReader();---解析文档
获取文档Document对 象sr.read("传入要解析xml文件的路径");---获得根节点 document.getrootelement();----从根节点查其他的节
点, getelement()获取单个节点 getelements()获取多个节点 传入需要获得节点的参数;
xpath:
解析步骤
导入jar包.dom4j-1.6.1.jar----创建解析器 SAXReader sr=new SAXReader();---解析文档
获取文档Document对 象sr.read("传入要解析xml文件的路径");---获取所需要的值 .selectNodes();传入要获取值的参数,
作者: sts 时间: 2018-5-30 21:55
苏海斌
XML是一种可扩展的标记语言,跟HTML类似,可自定义标签,用于传输和存取数据.亦可作为配置文件.
XML必须有文档声明(声明中必须有version),并且在XML文件的第一行第一列;另外,XML区分大小写,属性要有引号,必须有关闭标签,而且标签必须正确嵌套.
在XML中有个CDATA区,在区中的文本会被解析器忽略,也就是被当做字符串;<![CDATA[内容]]>
XML的解析方式分为DOM和SAX,
DOM可以一次性将文档加载到内存中,从而形成树形结构进行解析,并且可以对XML文档进行增删改操作;不过缺点就是如果文档特别大容易导致内存溢出;
而SAX是以事件驱动的方式逐行进行解析的,不会导致内存的溢出,不过也有缺点,就是不能对文档进行增删改;
针对这两种解析方式有不同的API的实现
主要的DOM4J和pull;
重点掌握DOM4J;
XPath是一种路径语言,即用来确定XML文档中某部分位置的语言,将DOM4J解析的方式进行了增强,能采用document来调用
DOM4J解析步骤:
导入jar包
创建解析器
解析文档获得代表文档的Document对象
获得根节点
从根节点下查找其他节点
XPath
Document:
Element | getRootElement() :获取根元素对象（根标签）
Element:
List elements() ：获取所有的子元素
List elements(String name)：根据指定的元素名称来获取相应的所有的子元素
Element element(String name)：根据指定的元素名称来获取子元素对象,如果元素名称重复，则获取第一个元素
String elementText(String name) ：根据指定的子元素名称，来获取子元素中的文本
String getText() ：获取当前元素对象的文本
void setText(String text)：设置当前元素对象的文本
String attributeValue(String name)：根据指定的属性名称获取其对应的值
public Element addAttribute(String name,String value)：根据指定的属性名称和值进行添加或者修改
SAXReader:
作者: 张述明 时间: 2018-5-30 21:57
张述明
今天主要学习了DButils的高级和XML
DButils部分:
BeanlistHandler(重点)
将多条记录封装到javabean的List集合中;
Javabean用来描述实体
实体类中属性的名字要和表中的列名一致
类名可以不一样
ColumnListHandler
将某列的值封装到List集合中;
ScalarHandler
单值封装
Xml是扩展性标记语言
是一种标记语言；
宗旨是传输数据
自定义标签
和超文本标记语言的区别
Html每个标签都有自己特有的功能
Xml标签自定义
必须要有根标签
作用1:传输数据(过去式);
2:存储数据(现在使用数据库)
3:配置文件
Xml 注释 <!--注释-->.
XML的文档声明
出现在第一行第一列
Version 属性必须有
不能数字和标点符号开始
元素(标签) 名称中不能有逗号
Cdata区: 里面的特殊字符变成字符串
< ![CDATA [ 内容 ] ] >
Xml 解析
方式1 Dom解析
一次性将文档加载到内存,形成树形结构进行解析
缺点:如果文档太大,容易导致内存溢出
优点:对XML进行增删改
方式2 SAX解析
事件驱动的方式,一行 一行进行解析的
缺点:不能进行增删改
优点:文档特别大,也不会导致内存溢出.
Jaxp Sun公司
Jdom
DOM4J
PULL
DOM4J
1. 导包
2. 创建解析器
3. 解析文档获得代表文档的document对象
4. 获得根节点
5. 从根节点下查找元素
Element 得到第一个元素
Elements 查找所有元素
DOM4J
List document.selectNodes(String xpath);
Node document.selectSingleNode(String xpath)
;
Xml的约束的种类和区别
DTD
语法自成一体,schema语法就是xml的语法
Schema
支持名称空间
比dtd更加强大的语义和语法的约束
作者: 偏离X 时间: 2018-5-30 21:58
DBUtils::主要用的是ArrayHandler ArrayListHandler BeanHandler BeanLIstHandler 四种
BeanHandler 将一条记录封装到JAVABean中
BeanListHandler 将多条记录封装到JAVABean数组中
ArrayHandler:将结果集中的第一条记录封装到一个Object[]数组中
ArrayListHandler:将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
*XML的作用:
1.传输 和 存储数据 配置文件
[XML的语法]:文档声明,注释,元素,属性,特殊字符和CDATA区
DOM4J的使用
1 创建解析器 new SAXReader();
2 解析文档获得Document对象
3 获得根节点
4 查找根节点下的子节点
XPath:
dom4j支持XPath的jar包
dom4j的XPath支持的API
List document.selectNodes(String xPath);获取元素(标签)集合
Node document.selectSingleNode(String xPath);获取单个元素(标签)对象
元素(标签)对象.attributeValue(String)获取value值
作者: w849027724 时间: 2018-5-30 21:59
吴利君
今天学习了DButils的查询方法的使用主要注意的是BeanHander的使用，这个可以和java对象结合起来对数据库的表进行查询，获取列表或的单个的很方便，然后是XML,它是可扩展标记语言，可以用于数据的传输和存储，或者一些框架啊软件的配置文件，比如后面的要学习的SSH，SSM里面就有大量用到配置文件的地方。
XML是一种很严谨的语言，它对大小写敏感，必须标签真确嵌套等等，不过建议统一使用小写，然后他的名称命名规则也有要求，所有要注意！
然后是XML的解析，有两种，一种是DOM解析，这种解析一次性可以吧所有的内容加载到内存，然后形成一个树形结构，这种解析的好处就是可以对数据进行增删改，但是当内容过多就会导致内存溢出，可以结合实际情况进行选择，然后是SAX解析，这种解析是逐行解析，对于内存不会溢出，但是却不能进行增删改，优点很好，缺点也很明显。
DOM4J这个有开源组织提供的一个解析的API他结合了DOM解析和SAX解析，大大提高了解析效率，而且使用XPATH进行解析效率更快，它的List document.selectNodes(String xPath)和 * Node document.selectSingleNode(String xPath)，两个方法能改快速查找你要查找的内容。
然后是XML的约束，它有两种， DTD 和 Schema他们的区别有四点，其一是DTD语法是自成一体的而Schema语法就是XML的语法，其二是Schema的语法就是XML的语法所以更容易被解析器所解析，其三Schema支持名称空间，其四Schema有比DTD更加强大的语义和语法的约束。这些据说以后面试会被问到，要记。
最后是tomcat大致说了一下，tomcat是一个小型服务器，兼容很多java的web项目，很多都是使用它开发的，很好用，有的大型网站甚至使用多个tomcat搭建分布式服务器集群，总之是个很厉害的东西。
作者: 一梦 时间: 2018-5-30 21:59
陈世彪:
今天学习了DBUtils和xml配置文件
使用DBUtils查找文件的方法有很多
ArrayHandler查找数据返回集合形式
ArrayListHandler可以查找多个数据返回集合,遍历集合获得里面的数
BeanHandler查找数据,返回bean类型,new BeanHandler()<对象.class>
BeanListHandler实现类对结果集进行处理,返回一个Bean类对象的集合
单条的查询可以使用ScalarHandler,返回一个Object类型对象
xml是可扩展标记语言,用来配置文件
也可以用来传输和储存数据,但是不常用
使用dom4j时,里面有两种解析方法
dom,一次性将文档加载到内存,如果文档特别大容易内存溢出,可以进行增删改操作
sax,一行一行进行解析,如果文档特别大不会导致内存溢出,不能进行增删改操作
对xml进行解析时,要先导入包
再创建解析器
SEXReader reader=new SEXReader();
解析文档获得Document对象
Document document = reader.read("xml/demo1.xml");
获得根节点
第一种
Element root = document.getRootElement();
第二种
Element root = document.selectNodes();
使用selectNodes时
如果要找一个元素的属性,要加上[@属性]
再使用attributeValue获得属性的值
作者: 沅瞻 时间: 2018-5-30 22:02
詹源
什么是XML:
一款可扩展的标记语言,可作为配置文件,传输和存取数据.
XML特点:
标签可以由开发者自行定义,具有自我描述性
基本语法:
1.必须有关闭标签
2.区分大小写
3.属性需要有引号
4.标签必须正确嵌套
文档声明:
在XML第一行第一列位置
写法:<?xml 属性名="属性值" 属性名="属性值"...?>
*version:必须的,使用"1.0"
*encoding:字符集.是使用浏览器打开的时候采用的默认的字符集的编码
*standalone:描述XML文档是否需要依赖其他文件.
注释:<!-- XML的注释 -->
XML的元素:元素(标签)的命名规范,需要遵循以下规则
名称可以含字母,数字,其他字符
名称不能数字或者标点以及字符"xml"(或者XML,Xml)开头.
名称不能包含空格和冒号:
属性:属性的名称规范与元素一样.属性需要引号
CDATA区:(CDATA:Character Data)
<![CDATA[ 内容 ]]>.内容的特殊符号不会被转译.
(重点)
XML解析方式:
DOM解析: DOM:Document Object Model.
SAX解析: Simple Api for XML.
区别:DOM一次加载到位,形成树形结构解析,可以对XML进行增删改,
但是如果文档过大,易导致内存溢出
SAX一行一行进行解析.不能进行增删改操作.
相反,即使文档过大,也不会造成内存溢出.
作者: 咸鱼coder 时间: 2018-5-30 22:39
万冕
今天的知识主要掌握DBUtils的查询,每次都是查询相对的复杂,这次的查询有很多的实现类,主要掌握的是BeanHandler和
BeanListHandler, BeanHandler是将记录包装进javaBean中的方式,BeanlistHandler 是将多条数据包装进list集合中,
XML是可扩展标记语言,可扩展主要表现在用户可以自定义标签,但是自定义也是有规范的,主要是用来当做配置文件,传输
存取数据,XML的语法比HTML的严谨,规范, CDATA区可以将特殊的符号都转成字符串形式.
XML的解析方式,有两种,DOM,SAX,DOM:优点能增删改,但是文件太大会内存溢出,SAX不能增删改,但是文件太大不会导致内存
溢出,
主要的解析方法时DOM4J XPath,里面包含了DOM和SAX,首先是先创建解析器,然后获取document对象,然后在输入要获得的根节点,
在根节点的基础上去获得其子节点,
List<Node> list = doc.selectNodes("//name[@id]");
for (Node node : list) {
Element e = (Element) node;
System.out.println(e.getText());
}
作者: 追风筝的人哇 时间: 2018-5-30 23:25
康元中 (5.30)
XML和Tomcat
1 XML:可扩展标记语言(允许用户自定义标签)
XML作用:传输和存储数据
主要用用于软件的配置文件
XML的解析:从xml的文档中获取数据
xml语法注意:声明必须写在文件左上角,必须要有跟标签,必须<?xml 属性名=”属性值” 属性名=”属性值” ...?>
分为两种解析方式:DOM解析 和SAX解析
区别:DOM一次性将文档加载到内存,形成树状结构进行解析
缺点: 文档如果较大会出现内存溢出
优点:对XML进行增删该的操作
SAX: 事件驱动的方式,一行一行进行解析
缺点:不能对文档进行增删该操作;
优点:文档较大不会出现内存溢出;
针对这两种解析,不同公司提供不同api实现: JAXP / JDOM /DOM4J /PULL
重点: 使用DOM4j的Xpath 完成解析
步骤
导包 dom4j jar包;和xpath的包
串键解析器 SaxReader reader =new SAXReader()
解析xml文档获得Doucument对象Document document reader.read("xml文本路径")
selectNode 和selectSingleNode();
学习xml 约束(了解)
分成 DTD和Schema
两者区别分别是
1.DTD语法是自成一体的.Schema语法就是XML的语法.
2.Schema的语法就是XML的语法所以更容易被解析器所解析.
3.Schema支持名称空间.
4.Schema有比DTD更加强大的语义和语法的约束.
2 使用DBUtils进行查询
步骤: 导包DBUTils 的jar包/ CP30 的jar包 /mysql jar包
xml配置文件准备jdvcutils的工具类( 创建连接的方法/创建连接池的方法/释放资源的方法)
(1)ArrayHandler将一条记录封装到一个数组
ArrayListHandler将多条记录封装到一个数组
(2)BeanHandler 一条记录封装到javaBean
BeanListHandler 多条记录封装到装有javaBean的List集合
javaBean中的成员变量必须要和数据库中列名相同数据类型相同,且有无参构造!
作者: Nevermo 时间: 2018-5-30 23:40
许煜
JDBC查询及xml总结
Queryrunner.query(“sql语句”,”接受查询结果的抽象类实例”,args);
重点 beanhandler<>(class) beanlisthandler<>()
通过传入的class文件 通过反射直接对查询结果的数据进行处理 需要javabean提供无参构造方法 get/set方法
Xml重点 现在基本作为配置文件使用
Java代码获取xml文件的属性值步骤如下
创建解析器 SAXReader sr=new SAXReader()
解析文档获得document对象 docuement sr.read(文档路径)
传统方法 1 获得根元素 element getrootelement()
2查找根元素下面的子节点 element()一个 elements()多个
3 elememnt.gettext()
快速的方法 document.selectsinglenode(String xpatn)
Document.selectnodes(String xpath)
Tomcat 用来发布网站的服务器
作者: COLDER 时间: 2018-5-30 23:53
本帖最后由 COLDER 于 2018-10-18 19:15 编辑
Day12
今天的学习内容为JDBC高级部分的查找,XML
JDBC高级部分的查找:通过SQL查找数据库表格中的记录,如果是单条记录的话,将其封装成对象,再打印显示;
如果是多条记录,将其封装为集合再遍历显示.
查找的方法有:ResultSetHandler(对象or集合);ArrayHandler();ArrayListHandler();BeanHandler();
BeanListHandler();MapHandler();MapListHandler();ColumnListHandler();ScalarHandler();KeyedHandler();
XML:可扩展标记语言,作用为传输和读取数据及配置文件
XML的重点内容为XPath的解析,首先是导入Dom4J与XPath的jar包,然后创建解析器,解析XML的文档.
这边主要是通过List document.selectNodes(String xPath)和Node document.selectSingleNode(String xPath)
来获取XML文档中的多个节点和单个节点的内容.
PS:脑袋一片空白,对于今天所学内容的回忆在细节部分完全没有思路,总结先暂且写到这,这部分内容在后续再进行复习!
作者: 林荣彬 时间: 2018-5-31 00:04
林荣彬
今天主要学习了DBUtils的查询将一条或者多条语句进行封装,xml的入门了解并对dom4j和Xpath结合的使用对xml进行解析.
DButils的查询---封装查询到的数据
1. ArrayHandler:将一条记录封装到一个数组当中。这个数组应该是Object[]。
2. ArrayListHandler:将多条记录封装到一个装有Object[]的List集合中。
3. BeanHandler:将一条记录封装到一个JavaBean中。
4. BeanListHandler:将多条记录封装到一个装有JavaBean的List集合中。
xml:可扩展的标记语言,设计宗旨是传输数据,而非显示数据,
作用:
1.传输和存取数据
2.软件的配置文件
xml语法:
文档声明:通常出现在XML的第一行第一列的位置
写法: <?xml 属性名=”属性值” 属性名=”属性值” ...?>
version :必须的. 使用”1.0”
encoding :字符集.
xml元素的命名规则与Html相似.名称中不能包含有冒号.
xml的属性:属性的名称规范同元素一致,但是属性需要使用引号!
CTADA区:{![CDATA[ 内容 ]]}
XML的解析的方式:
1.DOM解析: DOM:Document Object Model.
2.SAX解析: Simple Api for XML.
两种的区别:
DOM:一次性将文档加载到内存,形成树形结构进行解析; 缺点:如果文档特别大,容易造成内存的溢出; 优点:对XML进行增删改的操作
SAX:事件驱动的方式,一行一行的进行解析, 缺点:不能对文档进行增删改的操作
优点:如果文档特别大,不会导致内存的溢出.
dom4j和XPath:
首先需要先进行导包导入jar包.dom4j-1.6.1.jar和jaxen-1.1-beta-6.jar
然后创建解析器--解析xml返回document对象--根据指定标签查询的对象--遍历集合向下转型---打印内容
作者: it小白001 时间: 2018-5-31 00:28
吴俊斌
Dbutils查询query()方法,流程将查询的内容封装成对象.一般使用beanListHandler()
xml是可拓展标记语言 它和html很像,可以用来传送数据,存储数据,配置文件,不过现在
主要学习xml的解析方式:
解析方式有两种:
一种是dom解析,dom是一次加载到内存形成树状结构,可以进行增
删查改,但是会造成内存溢出
第二种是sax解析:sax是一行一行解析,它不会造成内存溢出,但是
不能对数据进行操作,好在我们现在都使用数据库.
平时使用最多的是dom4j,使用流程
一:导包
二:创建解析器:SAXReader reader=new SAXReader();
三:解析文档,获得文档对象:Document document = reader.read("xml/demo.xml");
四:用XPath的格式来获取想要的标签元素.具体的表达式可以查api
作者: AsusCoder 时间: 2018-5-31 00:58
曾耀峰
一、DBUtils
1.DBUtils的更新方法
update(String sql,Object...Object);
update()这个方法能执行对增删改等三个DML操作。实现原理是从PreparedStatement对象中获预编译语句的元数据对象，进而得到sql语句中，问号占位符"?"代表的参数个数，和参数的数据类型。然后遍历参数个数。利用pstmt.setObject()方法对参数赋值。
public static void update(String sql, Object... objects) {
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = C3P0Utils.getConnection();
pstmt = conn.prepareStatement(sql);
// 获取参数个数
ParameterMetaData pmd = pstmt.getParameterMetaData();
// 获取?号的个数，就是参数的个数。根据参数的个数设置数据的值
int count = pmd.getParameterCount();
for (int i = 1; i <= count; i++) {
pstmt.setObject(i, objects[i - 1]);
}
//执行SQL语句
pstmt.executeUpdate();
} catch (Exception e) {
System.out.println("1111");
}finally {
C3P0Utils.release(conn, pstmt);
}
这里比较有意思的是没有采用函数重载，而是使用了可变参数(Object...objs)的写法接收了不确定个数的方法。了解一下即可
2.DBUtils的查询方法
query(String sql,new ResultSetHandler,Object...objs)
根据ResultSetHandler接口的实现子类，有九个保存数据的方法。其中常用的是5个:
1)Object[] ArrayHandler:返回Object[] 得到一个记录的数据存放在数组中
List<Object[]> ArrayListHandler:返回一个ArrayList<Object[]> 查询多个
2)Object BeanHandler<Object>(Object.class):得到一个Object对象，注意后面传入class参数
List<Object> BeanListHandler<Object>(Object.class):得到一个装有Object对象的列表
3)Map<String ,Object> MapHandler<String,Object> 得到一个map集合对象。String表示列名。整个map集合就是存放的是一个记录的"列名":"值"这样的对象。列名不可能重复
List<Map<String, Object>> MapListHandler:得到一个装有map集合对象的list列表
*Map遍历取值的两种方法了解一下:
1.Set键找值:
//获取所有的键值
Set<String> keys = map.keySet();
for(String key:keys)
{
String value = map.get(key);
System.out.println("键:"+key +"---"+"值:"+value);
}
2.EntrySet 键-值对象遍历
Set<Map.Entry<String, String>> entrys = map.entrySet();
for(Map.Entry<String, String> entry:entrys)
{
String hunsband = entry.getKey();
String wife = entry.getValue();
System.out.println(hunsband+"-----"+wife);
}
提出一个疑问:map本身并没有遍历迭代器，只能通过Set集合来遍历。Set集合是无序的。因此在取出来的记录中。有可能是无序的。所以，应该少使用。
4) List<Object> ColumnListHandler（"列名"）:得到一次查询结果中，某一列的所有值
5) Object ScalarHandler() 只得到一个值
二、XML:
作用:作为配置文件，传输与存储数据。
解析步骤:
步骤一: 导入dom4j核心jar包
步骤二: 创建解析器
步骤三: 解析文档
步骤四: 获得根节点
步骤五: 从根节点获取其他节点
利用SAXReader解析，掌握一种即可。多了没用。以后通常用Json来传输数据
作者: zzx835387607 时间: 2018-5-31 01:04
郑志祥day12-JDBC高级与XML
知识一
rsh
查询一个 --封装成一个对象
查询多条-- 封装成多个对象 在添加到一个集合中
知识二
arrayHandler
将查询到的一条记录封装到一个object的数组中（）
用object接受，因为数据有多种类型
arrayListHandler
将多个object[]数组封装到一个object的集合中
知识点三（重要）
javaBean是一个实体类，实体类就是跟之前的Student类差不多，只有属性和属性的get和set方法，没有main方法
百度下什么是实体类
《acount》的类型
acount.class 字节码对象
注意事项；那些属性需要跟表的顺序--对应，顺序不对会报错，
类名与表名可以不一样
表格列和实体类的属性值需要一一对应
BeanHandler
将一条记录封装到一个javaBean对象中（查下javabean的api）
BeanListHandler
将多条记录封装到集合中
@Test
//BeanHandler 将一条记录封装到一个javaBean当中
public void Demo3() throws SQLException{
//创建核心类（传入连接池）
QueryRunner queryRunner=new QueryRunner(JDBCUtils2.getDataSource());
Account account = queryRunner.query("select * from account where id=?",
//创建一个bean匿名对象
new BeanHandler<Account>(Account.class),2);
System.out.println(account);
}
@Test
//BeanListHandler
//将多条记录封装到BeanListHandler集合当中
public void Demo4() throws Exception {
QueryRunner queryRunner=new QueryRunner(JDBCUtils2.getDataSource());
List<Account> list = queryRunner.query("select * from account", new BeanListHandler<Account>(Account.class));
for (Account account : list) {
System.out.println(account);
}
}
知识点四
MapHandler
map集合中的key是列名，value是表格里面的数值
MapListHandler
将多条map集合添加到List集合中
xml可扩展性语言（标签自己定义）
html超文本链接（标签是w3c规定好了）
XML的基本语法
1.XML必须有关闭标签
2.严格区分大小写
3.属性需要有引导
4.标签必须正确嵌套
<![CDATA[内容]]> 内容将都会被当成字符串
XML的解析（面试题目）
解析方式有两种
1.DOM解析 文档对象模型
2.2.SAX解析 简单的API来解析
解析方式的区别
1.DOM一次性将文档加载到内存，形成树形结构，进行解析
缺点；如果文档特别大，容易导致内存溢出。
优点；对XML进行增删改的操作。
2.SAX是一行一行的解析，
缺点；不能对文档进行增删改。
优点；如果文档特别大，不会导致内存溢出。
DOM4j入门案例步骤（重要）
1.导入包jar Dom4j-1.6.jar
2.创建解析器，解析XML的文档
3.获得根节点
4.从根节点查找子节点
5.通过子节点获取元素
6元素来获取文本内容
DOM4J的XPath（重要）
public void demo2() throws DocumentException{
//创建解析器
SAXReader reader=new SAXReader();
//解析xml返回Document对象
Document document = reader.read("xml/demo1.xml");
//查找到有id的person
List<Node> list = document.selectNodes("//person[@id]");
//通过增强for来循环，拿到集合里面的每个值，赋值给node
for (Node node : list) {
//将节点强转为元素element
Element element=(Element) node;
//获取元素的属性值
//System.out.println(element.attributeValue("id"));
System.out.println(element.getText());
//System.err.println(node.getText());
}
}
method的提交方式 past（提交后台无法看到）
get可以在网址栏上显示
行内优先级 就近原则
Schema里面都是字符串
作者: ...ylq 时间: 2018-5-31 15:22
叶凌青
今天主要学了DBUtils
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
ArrayHandler：将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
ArrayListHandler：将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
BeanHandler ：将结果集中第一条记录封装到一个指定的javaBean中。
BeanListHandler ：将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
ColumnListHandler：将结果集中指定的列的字段值，封装到一个List集合中
ScalarHandler：它是用于单数据。例如select count(*) from 表操作。
什么是 XML
XML 指可扩展标记语言（EXtensible Markup Language）
XML 是一种标记语言，很类似 HTML
XML 的设计宗旨是传输数据，而非显示数据
XML 标签没有被预定义。您需要自行定义标签。
XML 被设计为具有自我描述性。
XML 是 W3C 的推荐标准
作用
传输 和 存取数据
用来当做配置文件
重点
xml解析
目的:从XML文档中获得想要的数据(通过代码完成的.)
解析方式:
DOM解析:DOM:Document Object Model.这种方式是W3C推荐的处理XML的一种方式。
SAX解析:Simple Api for XML.这种方式不是官方标准，属于开源社区XML-DEV，几乎所有的XML解析器都支持它
DOM和SAX解析的区别：
DOM: 一次性将文档加载到内存当中, 形成树形结构进行解析，我们可以非常方便的操作任意的标签和属性。
优点：可以对xml进行增删改的操作
缺点：如果文档特别大，容易导致内存溢出
节点: 标签、属性、文本、甚至是换行都称之为节点
SAX:事件驱动的方式，一行一行的进行解析。
优点：如果文档特别大，不会导致内存溢出
缺点：不能对文档进行增删改的操作。
解析步骤：
DOM4J的入门案例步骤:
【步骤一】导入jar包.dom4j-1.6.1.jar
【步骤二】创建解析器
【步骤三】解析文档获得代表文档的Document对象.
【步骤四】获得跟节点.
【步骤五】从跟节点下查找其他的节点.
作者: wahahaha 时间: 2018-5-31 21:26
林恒山
今天讲了DBUtils的ResultSetHandler的实现类:
调用DBUtils jar包里面的QueryRunner的query方法,传入sql语句,ResultSetHandler的实现类,sql语句的参数的值.
query方法的第二个参数传入的是ArrayHandler,得到查询到的一条数据存放到数组中.
ArrayListHandler则是将多条记录存放到装有Object[]的List集合中.
BeanHandler将一条记录封装到JavaBean中
BeanListHandler将多条记录封装到一个装有JavaBean的List集合中
MapHandler将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值。
MapListHandler将多条记录封装到一个装有Map的List集合中
ColumnListHandler将数据中的某列封装到List集合中
ScalarHandler将单个值封装
KeyedHandler(了解)将一条记录封装到一个Map集合中。将多条记录封装到一个装有Map集合的Map集合中。而且外面的Map的key是可以指定的
xml的作用:传输和存取数据,传输数据被json代替,存取数据被数据库代替.只剩下作为软件的配置文件.
xml语法:必须有闭合标签;区别大小写;属性需要有引号;标签的嵌套要正确.
xml声明:写在xml文档的第一行第一列.
<?xml 属性名=”属性值” 属性名=”属性值” ...?>
version:必写,使用"1.0";encoding:字符集
xml注释跟html注释一样
<!-- XML的注释 -->
xml元素/属性的命名规则:
不能以数字/特殊字符/xml(XML/Xml)开头;
不能包含空格;
包含数字/字母/其他字符.
xml特殊字符
> > < < & & ' ' " "
xml的CDATA区(character data) :
<![CDATA[内容]]>
xml解析:dom解析和sax解析
两种解析的区别:
dom一次性加载文档到内存,形成树形结构进行解析.
优点:可以对xml进行增删改操作.
缺点:文档过大的话,容易导致内存溢出.
sax:一行一行的解析
优点:文档过大也不会内存溢出
缺点:不能进行增删改操作
针对解析方式,有不同的api实现:
sun公司的jaxp
开源组织的jdom
开原组织的dom4j
android手机端解析xml的pull
现在流行的dom4j步骤:
导包dom4j-1.6.1.jar
创建解析器
SAXReader reader = new SAXReader();
解析文档获得代表文档的Document对象
Document document = reader.read("xml/demo1.xml");
// 获得跟节点
Element root = document.getRootElement();
从跟节点下查找其他的节点
element() elements()
XPath：
dom4j支持XPath的jar包.
jaxen-1.1-beta-6.jar
dom4j的XPath支持的api:
List document.selectNodes(String xPath);
Node document.selectSingleNode(String xPath);
作者: 376091692 时间: 2018-5-31 22:03
凌辉:
XML 指可扩展标记语言,用来传输 和存取数据和用来当做配置文件,现在主要是用来当做配置文件
XML的基本语法
* XML必须有关闭标签
* 区分大小写
* 属性需要有引号
* 标签必须正确嵌套
作者: 丶犯二 时间: 2018-6-2 01:22
任佳锋
关于DBUtils的使用:
查询:
1.导入jar包
2.创建连接池对象ComboPooledDataSource
3.创建核心对象QueryRunner
4.调用query方法得到结果
BeanHandler,BeanListHandler,ArrayHandler,ArrayListHandler
增删改:
1,导入jar包(数据库连接,c3p0,dbutlis)
2,创建连接池对象ComboPooledDataSource
3,创建DBUtlis传入连接池对象QueryRunner
4,调用update例如queryrunner.update("update cj set math=math+? where id = ?", "+50", "1");
xml的解析的方式
1.DOM解析 Document Object Model:文档对象模型解析
2.SAX解析 Simple Api for XML:简单的API进行xml文件的解析
作者: avip0000 时间: 2018-6-4 17:47
白有旺
XML文件可以用来作为一种小型数据库存在，但更多时候在项目中都是用来当成配置文件用的，也就避免不了对XML文件的增上改查操作。
在java中，解析XML文件的方式大致分为两种：DOM解析，SAX解析
先来说DOM解析方式：xml解析器一次性把整个xml文档加载进内存，然后在内存中构建一颗Document的对象树，通过Document对象，得到树上的节点对象，通过节点对象访问（操作）到xml文档的内容。
用的较为多的是Dom4j工具
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |