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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 厦门校区 黑马粉丝团   /  2018-5-30 18:01  /  4874 人查看  /  76 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

同学们,今天继续学习了DBUtils,我们学习了ResultSetHandler的几种实现类,而后我们又学习了XML配置文件,这在我们之后的JavaWeb开发中大家几乎天天会用到。

今日需要掌握的有:
  • 熟练使用BeanHandler和BeanListHandler对查询的数据进行封装
  • 熟练使用ScalarHandler对查询的数据进行封装
  • 理解XML的作用
  • 会使用dom4j结合Xpath对xml进行解析

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




76 个回复

倒序浏览
王刘锁
依稀记得早上学习的是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更强大的约束力.
回复 使用道具 举报
本帖最后由 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解析就行了

回复 使用道具 举报
常小天
今天继续学习了JDBC的进阶内容,接着又学习了一些XML的知识。
JDBC进阶部分内容学习的是DBUtils的查询操作。使用DBUtils查询数据库数据的时候,我们将查询的结果进行封装,不同方法将其封装成不同的数据类型。这里我们重点掌握BeanHandler方法和BeanListHandler方法,这两个方法将查询结果封装成了类,一条表记录就封装成一个对象,前者查询单条记录并封装,后者查询多条记录并封装,将封装成的多个对象再装进集合中返回。这里需要传入一个字节码文件作为参数,这个字节码文件时我们编写的与要查询的记录相匹配的类的字节码文件。需要注意的是这个类中的成员变量的类型和变量名要与待查询的记录中的字段完全一致,否则就会出错。这是因为封装的方法就是将查询的数据赋给这个类的成员变量,而能够数据赋给正确的,相匹配的变量的依据就是类的变量名和表记录的字段名一致。
XML部分的内容主要是使用DOM4J以及XPath解析XML文件。XML文件的编写与HTML很类似,个别不同的地方稍加注意即可。XML的语法要求比HTML严格,XML区分大小写,必须要有根标签,必须要关闭标签,属性必须要加引号……编写好XML文件后,再编写java代码对其进行解析。步骤为:创建解析器、解析并返回document对象、使用document对象获得标签对象、通过标签对象获得其内容和属性。这里可以利用Xpath简化代码。正确使用“//标签名【@属性名】”的格式并理解其含义。
回复 使用道具 举报
吴利君
今天学习了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搭建分布式服务器集群,总之是个很厉害的东西。
回复 使用道具 举报
张育辉
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更加强大的语义和语法的约束.

                               
回复 使用道具 举报
陈昆明:
       今天对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对路径进行快速查找
回复 使用道具 举报
许剑鸿 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);
        *操作
回复 使用道具 举报
柯威龙
首先今天学习了DBUtils的查询功能.这个查询功能分为很多种.其中最重要的就是ArrayList和BeanList
每种都分为多条查询和一条查询.然后学习了xml.xml是一种可扩展标记语言.跟html类似.xml主要是被用来当做
配置文件的.xml语法和html大致相同.只要学习了就是xml的解析.xml有两种解析方式一种空是DOM一种是Sax.DOM的有点事可以
对xml进行增删改操作,但是他也有缺点,缺就是他属于一次性加载到内存的,如果文件过大的话他就会内存溢出.
SAM反之.两种解析方式凡是有多种解析的方法,API.其中今天主要学习的是DOM4J.解析的步骤首先是导包.
然后创建解析器,解析文档获得DOcument对象.然后获得根节点.最后从跟节点上去寻找子节点.
后面学习了Xpath的解析方式,在代码上会比较的简便.
回复 使用道具 举报
吴鹏
总结
---------------------------------------------------------------


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区
&lt;    <
&gt;    >
&amp;    &
&apos;    '
&quot;    "

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更加强大的语义和语法的约束,




回复 使用道具 举报 1 0
谢洪彬
今天学习的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对象但用查询第一个或者多个的方法完成查询
回复 使用道具 举报

2018/5/30 林玮

今天又接着前两天继续学jdbc,算是一个进阶吧,主要就是学一个更简单的查,前两天学的查不够简单,能简单谁会往难的写呢?对吧.然后还有就是xhl配置文件和一个Tomcat的一个了解;

jdbc:
      今天呢是jdbc最后一个知识点了,学的是一个增删改查里的查完全版的,和以往不同的是他是将结果集封装到集合,数组或一个指定的javaBean中,重点学习BeanHandler:就是将结果集封装到javaBean中的,为什么他要重点学习呢?首先他以后会比较常用,其次是他相对其他的也会比较简单一点.

xml:
     第二个就是一个xml了,他是一个类似于HTML的标记语言,不同HTML的它还是一个标签需要自定义的可扩展标记语.他可以传输,存储数据但那是以前,现在只有少数企业用它来传输和存储数据了,它现在的主要用途是配置文件.

Tomcat:
      最后了解了一下Tomcat,明天重点学习,他是一个服务器,之前我们都是用java项目文件夹来写代码的,而他在里面有一个特有项目文件夹就是那个带小圆球的,对就是那个.然后他的一个目录结构也和之前不大一样,还有就是学习了它,别人就可以在内网中通过你的ip地址和端口号访问到你做的页面了.
回复 使用道具 举报
李思贤:今天上午学习了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"));
                }
回复 使用道具 举报
邵倩


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);


回复 使用道具 举报
张裕
                                        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)
回复 使用道具 举报
郑阳阳
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方法.
回复 使用道具 举报
何平波
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

回复 使用道具 举报
林文辉
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下进行访问。

回复 使用道具 举报
16weisong
今天上午学习了使用DBUtils工具类进行查询,使用这个的好处是会对查询的结果集进行封装,可以封装到数组,javabean中,也可以封装到map集合中,其中要掌握的是封装到数组和javabean中.下午学习类xml及其解析,只要掌握使用dom4j及xpath解析xml文档即可.
回复 使用道具 举报
刘文峰
使用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特殊字符: <  &lt  >&gt   ' &apos   ""  &quot  &  &amp  
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文件路径)  
回复 使用道具 举报
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>)*******;
回复 使用道具 举报
123下一页
您需要登录后才可以回帖 登录 | 加入黑马