精华内容
下载资源
问答
  • AG对象的结构使用XML形式表示,从而定义了此处显示的AGML语法。 拟议的方案可容纳电泳结果以及所选凝胶斑点的质谱分析数据。 正在开发一个基于Web的软件库来处理数据存储,分析和图形表示。所描述的计算工具将在...
  • 维表关联系列目录:一、维表服务与Flink异步IO、Mysql维表关联:全量加载 三、Hbase维表关联:LRU策略 四、Redis维表关联:实时查询 五、kafka维表关联:广播方式 六、自定义异步查询 LRU LRU(Least Recently ...

    维表关联系列目录:
    一、维表服务与Flink异步IO
    二、Mysql维表关联:全量加载
    三、Hbase维表关联:LRU策略
    四、Redis维表关联:实时查询
    五、kafka维表关联:广播方式
    六、自定义异步查询

    LRU

    LRU(Least Recently Used),最近最少使用缓存淘汰算法,认为最近访问过的数据在将来被访问的概率也比较大,当内存达到上限去淘汰那些最近访问较少的数据。

    在Flink中做维表关联时,如果维表的数据比较大,无法一次性全部加载到内存中,而在业务上也允许一定数据的延时,那么就可以使用LRU策略加载维表数据。但是如果一条维表数据一直都被缓存命中,这条数据永远都不会被淘汰,这时维表的数据已经发生改变,那么将会在很长时间或者永远都无法更新这条改变,所以需要设置缓存超时时间TTL,当缓存时间超过ttl,会强制性使其失效重新从外部加载进来。接下来介绍两种比较常见的LRU使用:

    1. LinkedHashMap
      LinkedHashMap是双向链表+hash表的结构,普通的hash表访问是没有顺序的,通过加上元素之间的指向关系保证元素之间的顺序,默认是按照插入顺序的,插入是链表尾部,取数据是链表头部,也就是访问的顺序与插入的顺序是一致的。要想其具有LRU特性,那么就将其改为访问顺序,插入还是在链表尾部,但是数据访问会将其移动达到链表的尾部,那么最近插入或者访问的数据永远都在链表尾部,被访问较少的数据就在链表的头部,给 LinkedHashMap设置一个大小,当数据大小超过该值,就直接从链表头部移除数据。
      LinkedHashMap本身不具有ttl功能,就是无法知晓数据是否过期,可以通过给数据封装一个时间字段insertTimestamp,表示数据加载到内存的时间,当这条记录被命中,首先判断当前时间currentTimestamp与insertTimestamp差值是否达到ttl, 如果达到了就重新从外部存储中查询加载到内存中。

    2. guava Cache
      google guava下面提供了Cache缓存模块,轻量级,适合做本地缓存,能够做到以下几点:
      a. 可配置本地缓存大小
      b. 可配置缓存过期时间
      c. 可配置淘汰策略
      非常适用于Flink维表关联LRU策略,使用方式:

     

    1.  `cache =  CacheBuilder.newBuilder()`
    
    2.  `.maximumSize(1000)`
    
    3.  `.expireAfterWrite(100,  TimeUnit.MILLISECONDS)`
    
    4.  `.build();`
    
    

    表示最大缓存容量为1000,数据的过期时间为100s。

    LRU方式读取Hbase

    实现思路:

    1. 使用Flink 异步IO RichAsyncFunction去异步读取hbase的数据,那么需要hbase 客户端支持异步读取,默认hbase客户端是同步,可使用hbase 提供的asynchbase 客户端;

    2. 初始化一个Cache 并且设置最大缓存容量与数据过期时间;

    3. 数据读取逻辑:先根据Key从Cache中查询value,如果能够查询到则返回,如果没有查询到结果则使用asynchbase查询数据,并且将查询的结果插入Cache中,然后返回

    引入pom.xml 依赖:

     

    1.  `<dependency>`
    
    2.  `<groupId>org.hbase</groupId>`
    
    3.  `<artifactId>asynchbase</artifactId>`
    
    4.  `<version>1.8.2</version>`
    
    5.  `</dependency>`
    
    6.  `<dependency>`
    
    7.  `<groupId>com.google.guava</groupId>`
    
    8.  `<artifactId>guava</artifactId>`
    
    9.  `<version>28.0-jre</version>`
    
    10.  `</dependency>`
    
    

    demo版:

     

    2.  `class  HbaseAsyncLRU(zk:  String, tableName:  String, maxSize:  Long, ttl:  Long)  extends  RichAsyncFunction[String,  String]  {`
    
    4.  `private  var hbaseClient:  HBaseClient  = _`
    
    5.  `private  var cache:  Cache[String,  String]  = _`
    
    7.  `override  def open(parameters:  Configuration):  Unit  =  {`
    
    8.  `hbaseClient =  new  HBaseClient(zk)`
    
    9.  `cache =  CacheBuilder.newBuilder()`
    
    10.  `.maximumSize(maxSize)`
    
    11.  `.expireAfterWrite(ttl,  TimeUnit.SECONDS)`
    
    12.  `.build()`
    
    13.  `}`
    
    15.  `override  def asyncInvoke(input:  String, resultFuture: async.ResultFuture[String]):  Unit  =  {`
    
    17.  `val key = parseKey(input)`
    
    18.  `val value = cache.getIfPresent(key)`
    
    19.  `if  (value !=  null)  {`
    
    20.  `val newV:  String  = fillData(input, value)`
    
    21.  `resultFuture.complete(Collections.singleton(newV))`
    
    22.  `return`
    
    23.  `}`
    
    24.  `val get  =  new  GetRequest(tableName, key)`
    
    25.  `hbaseClient.get(get).addCallbacks(new  Callback[String, util.ArrayList[KeyValue]]  {`
    
    26.  `override  def call(t: util.ArrayList[KeyValue]):  String  =  {`
    
    27.  `val v = parseRs(t)`
    
    28.  `cache.put(key, v)`
    
    29.  `resultFuture.complete(Collections.singleton(v))`
    
    30.  `""`
    
    31.  `}`
    
    32.  `},  new  Callback[String,  Exception]  {`
    
    33.  `override  def call(t:  Exception):  String  =  {`
    
    34.  `t.printStackTrace()`
    
    35.  `resultFuture.complete(null)`
    
    36.  `""`
    
    37.  `}`
    
    38.  `})`
    
    39.  `}`
    
    40.  `private  def parseKey(input:  String):  String  =  {`
    
    41.  `""`
    
    42.  `}`
    
    43.  `private  def fillData(input:  String, value:  String):  String  =  {`
    
    44.  `""`
    
    45.  `}`
    
    46.  `private  def parseRs(t: util.ArrayList[KeyValue]):  String  =  {`
    
    47.  `""`
    
    48.  `}`
    
    49.  `}`
    
    

    对于查询hbase, 需要合理设计rowKey,为了避免查询热点,例如rowKey通过md5方式散列。


     

    展开全文
  • as3操作xml

    千次阅读 2009-12-23 10:58:00
    范例如下:var xml:XML= text1 barText1 barText1 text2 trace(xml.text());//输出:text1text2trace(xml.text()[0

    范例如下:

    var xml:XML=

             <body>

                 text1

                 <bar>barText1</bar>

                 <bar>barText1</bar>

                 text2

             </body>

    trace(xml.text());//输出:text1text2

    trace(xml.text()[0]);//输出:text1

    trace(xml.text()[1]);//输出: text2

    trace(xml.child(1).toXMLString());//输出:<bar>barText1</bar>

    trace(xml.child(1).toString());//输出:barText1

    ?       

    toXMLString()方法:始终返回XML 对象的开始标签、属性和结束标签的字符串型式。

    toString()方法:只是按字符串形式返回节点的内容。

    text()方法:则是返回XML 文本节点的所有 XML 属性的 XMLList 对象,上面的例子,有两个文本节点text1和text2。

    11.3.2  XML节点访问

    存取节点是使用XML对象的基础,要用好XML先要掌握管理XML类的方法,XML类提供了以下各管理节点的方法。

    1.访问XML各节点。

    在学习访问XML节点前,要先弄明白XML各层次的关系后面,要使用这个层级与节点编号来访问不同位置的节点。

    虽然我们看来,“<item>text1<item>”只是一段包含<item>卷标元素的字符串而以,但是经过Flash内部的XML解析器处理后,XML里的每个元素都会被展现成树状的层级结构,各层之间都存在规律性的编号。我们把下面的代码分解如图11-12所示。

    var xml:XML=

        <myxml>

            <item>

                 <pro>proText</pro>

            </item>

            <item>text1</item>

            <item>text2</item>

        </myxml>

    图11-12用IE浏览XML文件

    上图中,红色方块表示卷标,黑色方块表示文字元素。XML中卷标和文字元素都算是一个节点。XML结构如同一个二维表对横向和纵向进行编号,我们常要使用这个编号访问各节点。

    在AS2里,我们常使用xmlObj.firstChild.childNodes[0]来访问节点。AS3里我们有很多方法来访问不同位置的节点,首先介绍使用child()访问节点。

    ① child()方法 (propertyName:Object):XMLList

    使用child()方法列出其子项,一个XML子项就是一个XML元素、文本节点、注释或处理指令。代码如下:

    var xml:XML=

             <foo>

                 <bar>text1</bar>

                 <bar>text1</bar>

             </foo>

    trace(xml.child("bar").length());

    //输出2

    trace(xml.child("bar")[0].toXMLString());

    //输出: <bar>text1</bar>

    trace(xml.child("bar") [1].toXMLString ());

    //输出: <bar>text2</bar>

    child()方法,可以直接使用子项目编号来读取,及child(1)比如上面的xml对象,我们用xml.child("bar")[0]和xml.child(1)输出结果是一样的。如果用“*”号代替编号则表示输出所有节点,范例代码如下:

    var xml:XML=

             <foo>

                 <bar>text1</bar>

              ,    <bar>text1<, /bar>

             </foo>

    trace(xml.child("bar")[0].toXMLString());

    //输出: <bar>text1</bar>

    trace(xml.child(0).toXMLString());

    //输出: <bar>text1</bar>

    trace(xml.child("*").toXMLString ());

    //输出:<bar>text1</bar> <bar>text2</bar>

    ② children()方法 (propertyName:Object):XMLList

    children()按照XML对象的显示顺序列出其子项。一个XML子项就是一个XML元素、文本节点、注释或处理指令。和child()方法不同,child只是读取单个子项的,而children()是读取所有的子项。我们也可以按子项编号用children()来完成child()的工作,下面用个范例做个对比,如下:

    var xml:XML=

             <foo>

                 <bar>text1</bar>

                 <bar>text2</bar>

             </foo>

    trace(xml.children());

    //输出: <bar>text1</bar><bar>text2</bar>

    trace(xml.children()[0].toXMLString());//输出text1

    trace(xml.child(0).toXMLString());//输出text1

    代码中,第6行children()没有用编号时,则读取所有的子项结点。第8行,xml.children()[0]读取编号为0的节点,这和第9行使用child()方法读取单条节点项的作用是一样的。

    ③ elements () 方法 (name:Object = *):XMLList

    elements()方法可以列出XML对象的元素。一个由开始和结束标签组成的元素,可以使用参数name,用节点名子访问,也可以使用“*”访问所有节点。范例如下:

    var xml:XML=

             <body>

                 <bar>barText1</bar>

                 <bar>barText2</bar>

             </body>

    trace(xml.elements("*"));//输出: <bar>barText1</bar><bar>barText2</bar>

    trace(xml.elements("*")[0].toXMLString());//输出: <bar>barText1</bar>

    trace(xml.elements("bar").length());//输出: 2

    trace(xml.elements("bar")[1].toXMLString());//输出: <bar>barText2</bar>

    elements()看起来和children()一样,都是读取XML对象的所有子项。这两个方法是有区别的,而且区别很大。elements()只是读取XML对象的元素,如<bar>batText<bar/>或者单个元素<bar/>,而children()都是读取所有的子项,包括文本节点、注释或处理指令等,只要在XML里有设置其注释与指令能输出,并可以用children()。对比范例如下:

    XML.ignoreComments=false;//先设置不忽略注释才能用childern获取注释

    XML.ignoreProcessingInstructions=false;//先设置不忽略XML指令

    var myxml:XML=

             <body>

                 <bar>44</bar>

                 dtext

                 <!--这是注释-->

                 <btt/>

    <?一个指令?>

             </body>;

    trace(myxml.children().toXMLString());

    /*输出所有子项:

                 <bar>44</bar>

                 dtext

                 <!--这是注释-->

                 <btt/>

    <?一个指令?>

    */

    trace(myxml.elements("*").toXMLString());

    //输出: <bar>44</bar> <btt/>

    对比下第11行和第19行,两种方法输出的子项,现在可以很显视地区分这两个方法了。

    ④ descendants()方法 (name:Object = *):XMLList

     descendants()是读取包含给定 name 参数的 XML 对象的所有后代(子级、孙级、曾孙级等)。这和前面介绍的几个方法又有所不同了,前面介绍的child()、children()和elements()都只是读取所指点的那层的子项,而这个descendants()是读取其下面所有的层级子项,所用的参数和elements()是一样可以使用参数name,用节点名子访问,也可以使用“*”访问所有节点。范例如下:

    var xml:XML=

             <body>

                 <a>

                     <b>text1</b>

                 </a>

                 <b>text2</b>

             </body>

    trace(xml.descendants("b").toXMLString());//输出: <bar>text1</bar><bar>text2</bar>

    trace(xml.child("b").toXMLString());//输出: <bar>text1</bar>

    对比下使用descendants()和child()读取节名b后的区别,child()只是从当前层读取节点b,descendants()则读取XML对象里所有节点名为b的节点,我们可以xml.descendants("b")[1]用编号去选取需要访问的结点,从而在不清楚XML对象里节点名为“b”的层次位置也能很好的访问。

    ⑤ “.”dot (XML) 运算符

    这里,还可以使用点运算符来读取XML的结点,别看这个“小不点”点运算符在AS里的并不莫生,作用也大着。AS2时代,我们使用点运算符来向影片剪辑的深层次访问变量,现在XML的层级关系里,一样可以灵活地运用点运算符来问了。范例如下:

    var xml:XML=

             <foo>

         &nbs, p;      , ; <bar>text1</bar>

                 <bar>text2</bar>
             </foo>

     

    trace(xml.bar);

    //输出: <bar>text1</bar><bar>text2, </bar>

    trace(xml.bar[1].toXMLString());

    //输出: <bar>text2</bar>

     

     

     

     

     

     

     

     

     第6行,使用点运算符,直接访问节点名则获得他所有的子项这和上面介绍的xml.children()作用一样,只是children可以在未知节点名的情况下获取所有子项,第8行则跟child(1)的作用一样了。

    ⑥ 使用parent()访问上一级节点

    在AS2里,访问上一个节点是使用parentNode,还有firstChild、lastChild、nextSibling等等,层级之间的访问方法比较多。

    现在AS3的XML类对于层级之间的访问方法只留了个parent()其它的都被去了。因为XML对象的访问很灵活了,在AS2时所用的很多方法都可以使用别的来替代了。我们来看下parent的使用,第11行,声明对象,一个在xml结点上位置第三层的“<li>1</li>”,然后在第14行用parent()查看下他上一级是什么,则输出节点<ul>。代码如下:

    var xml:XML=

             <top>

                 <p>child0</p>

            &n, bsp;    <p>

                    <ul>

    <li>1</li>

    <li>2</li>

    </ul>

                 </p>

             </top>;

    var node:XML=xml.child("p")[1].child("ul").child("li")[1];

    //上面的,表示把<li>1<li>给node对象

    //我们再用node.parent()看看他上一个节点是什么

    trace(node.parent());

    /*输出node的上一个节点所有子项

    <ul>

    <li>1</li>

    <li>2</li>

    </ul>

    */

    ⑦ childIndex()方法

    childIndex()方法不是用来读取节点的,是用来获取节点的位置,其父项上下文中从0开始编制索引的位置,范例如下:

    var myxml:XML=<topxml>

                     <bar>text1</bar>

                     <btext/>

                   </topxml>

    trace(myxml.childIndex());//输出:-1

    trace(myxml.bar.childIndex());//输出:0

    trace(myxml.btxt.childIndex());//输出:1


    2.访问XML的属性

    每个卷标都可以拥有一个以上的属性,这个属性可以像我们AS里的字符型变量一样存放一段字符串,访问属性XML对象提供了下面几个方法。

    ① attribute(attributeName:*):XMLList

    使用attribute()读取与参数相符属性的值,如下:

    var xml:XML=

                 <myxml theName="大山" theSex="男">

                    <item theAge="30">text1</item>

                 </myxml>

    trace(xml.attribute("theName"));//输出:大男

    trace(xml. attribute("*"));//输出:大山男

    trace(xml. attribute("*")[1]);//输出:男

    attribute()可以使用“*”号输出下面所有属性。使用属性名读取时,属性名是区分大小写的,这和我们的变量规则一样。如图没有这个属性则输出一个空值,不会报错。

    ② attributes(attributeName:*):XMLList

    使用attributes()返回给定 XML 对象的属性值列表。结合使用 name()方法和attributes()方法可返回属性的名称。

    和上面的attribute()方法有些不一样,上面那个方法是读取单个属性值。而这个方法是读取属性值列表,所以使用xml.attribute(“*”)和xml.attributes()输出结果一样,都是获取所有属性,范例如下:

    var xml:XML=<img id=’20’ imgName=’myphoto’/>

    trace(xml.attribute("*"));//输出:20myphoto

    trace(xml.attribute("*")[1]);//输出:myphoto

    trace(xml.attribute());//输出:20myphoto

    trace(xml.attribute().length());//输出:2

    trace(xml.attribute()[1]);//输出:myphoto

    ③ @运算符attribute identifier运算符

    @运算符可以像attribute()方法一样,取得属性值。也可以结合“*”号来取得指定层下所有的节点值,代码如下:

    var xml:XML=<img id=’20’ imgName=’myphoto’/>

    trace(xml.@id);//输出:20

    trace(xml.@*.length());//输出:2

    trace(xml. @*);//输出:20myphoto

    trace(xml. @*[1]);//输出:myphoto

    @运算符配合“*”获取所有属性时,不用加双引号。我们可以很方便地使用@算符替代attribute(),下面我们再看看使用@向卷标里存入属性。

    var xml:XML=<img id=’20’ imgName=’myphoto’/>

    xml.@newing="newphoto"//新创建一个属性newing

    trace(xml.@*.length());//输出:3

    trace(xml.@*);//输出:20myphotonewphoto

    trace(xml. @*[2]);//输出:newphoto

    ④ name()

    name()方法用来获取限定名称,限定名称也就是卷标名或者属性名。name()可获取各节点或属性名,范例如下:

    var myxml:XML=<topxml>

                    <bar va="123">text1</bar>

                  </topxml, >

    trace(myxml.name());//输出:topxml

    trace(myxml.child ("*")[0].na, me());//输出:bar

    trace(myxml.child(0).attributes()[0].name());//输出:va

    3.XML节点管理

    XML节点管理即节点的添加删除复制等管理。

    ① appendChild方法(child:Object):XML

    将给定子项追加到该XML对象属性的末尾。appendChild()方法可采用 XML 对象、XMLList 对象或随后转换为 String 的任何其它数据类型。范例如下:

    var myxml:XML=<topxml>

                    <bar va="123">text1</bar>

                  </topxml>

    myxml.appendChild(<newbar>text2</newbar>);

    trace(myxml.bar.toXMLString());//输出:<bar va= "123">text1</bar>

    trace(myxml.newbar. toXMLString());//输出: <newbar>text2</newbar>

    ② insertChildAfter()方法(child1:Object, child2:Object):*

    在该XML对象的child1参数后插入给定的child2参数并返回生成的对象。如果child1参数为null,该方法将在XML对象的所有子项之前插入 child2的内容(也就是说,不在任何子项之后)。

    如果提供child1,但XML对象中不包含该参数,则不修改该XML对象并返回undefined。

    如果对不是元素(文本、属性、注释、pi 等等)的XML子项调用该方法,则返回undefined。范例如下:

    var myxml:XML=<topxml>

                   <bar>text1</bar>

    <bar>text2</bar>

                 </topxml>;

    myxml.insertChildAfter(myxml.bar[0],<newbar>text1</newbar>);

    trace(myxml)

    输出以后,新的XML节点被插入到中间,如下:

    <topxml>

    <bar>text1</bar>

    <newbar>text1</newbar>

    <bar>text2</bar>

    </topxml>;

    ③ insertChildBefore()方法(child1:Object, child2:Object):*

    和上面的insertChildAfter()方法的相似,这个方法是在对象的child1参数后面插入给定的child2参数并返回生成的对象。

    如果提供child1,但XML对象中不包含该参数,则不修改该XML对象并返回undefined。

    如果对不是元素(文本、属性、注释、pi 等等)的XML子项调用该方法,则返回undefined。范例如下:

    var myxml:XML=<topxml>

                   <bar>text1</bar>

    <bar>text2</bar>

                 </topxml>;

    myxml.insertChildBefore(myxml.bar[0],<newbar>text1</newbar>);

    trace(myxml)


    输出以后,新的XML节点被插入到了第一个位置,如下:

    <topxml>

    <newbar>text1</newbar>

    <bar>text1</bar>

    <bar>text2</bar>

    </topxml>;


    ④ delete()运算符

    delete()不是XML的方法,他是一个运算符。XML没有提供删除节点的方法了,这个运算符完全可以满足我们的需求即删除指定的节点,使用delete可以删除节点也可以删除属性,范例如下。

    var myxml:XML=<topxml>

                    <bar va="123">text1</bar>

                    <bar>text2</bar>

    <bar>text3</bar>

                 </topxml>;

    delete(myxml.bar[1]);//删除第二个节点

    delete(myxml.bar[0].@va);//删除属性va

    trace(myxml)



    删除了节点和属性后输出如下:

    <topxml>

    <bar>text1</bar>

    <bar>text3</bar>

    </topxml>;


    ⑤ normalize()方法

    normalize()用于合并相邻所有文本节点。比如<bar>text1<bar>如果文本结点text1有两个以上,并可用这个方法将他们合并,范例如下:

    var xml:XML=<body>text1</body>;

    trace(xml.children().length());//输出: 1

    xml.appendChild("newtext");//再添加一个文本节点newtext

    trace(xml.children().length());//输出: 2

    xml.normalize();//合并两个文本点

    trace(xml..toXMLString());//输出: <body>text1newtext</body>

    trace(xml.children().length());//输出: 1


    ⑥ replace()方法(propertyName:Object,value:XML):XML

    用给定的value参数替换propertyName参数所指定的属性。如果没有属性与propertyName匹配,会将XML对象保持为未修改状态。

    var xml:XML=

             <foo>

                <bar>

                  <bar1_1>text1_1</bar1_1>

                  <bar1_2>text1_2</bar1_2>

                </bar>

             </foo>

    xml.child(0).replace(1,<bar>newbar</bar>);

    trace(xml);


    上面的代码使用卷标<bar>替换了<bar1_2>以后,输出如下:

       <foo>

                <bar>

                  <bar1_1>text1_1</bar1_1>

                  <bar>newbar</bar>

                </bar>

             </foo>

    展开全文
  • 知识表示:用计算机符号来描述人脑中的知识,以及通过符号之间的运算来模拟人脑的推理过程。 语义网核心:RDF OWL 知识表示方法  一阶谓词逻辑表示法  产生式规则表示法  框架表示法  语义网表示法  ...

    知识表示:用计算机符号来描述人脑中的知识,以及通过符号之间的运算来模拟人脑的推理过程。
    语义网核心:RDF OWL
    知识表示方法
     一阶谓词逻辑表示法
     产生式规则表示法
     框架表示法
     语义网表示法
     分布式知识表示

    谓词逻辑

    非常严谨!以数理逻辑为基础,是到目前为止能够表达人类思维和推理的一种最精确的形式语言。
    常见谓词逻辑:
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    谓词是一种断言!!!!!
    在这里插入图片描述
    用谓词逻辑既可以表示事物的状态、属性、概念等事实性知识,也可以表示事物间具有因果关系的规则性知识。
    用谓词逻辑表示知识的一般步骤:
    1.定义谓词及个体,确定每个谓词及个体的确切含义。
    2.根据所要表达的事物或概念,为每个谓词中的变量赋以特定的值。
    3.根据所要表达的知识的语义,用适当的逻辑联结词将各个谓词连接起来形成谓词公式。
    优点:
    精确性:可以较准确地表示知识并支持精确推理。
    通用性:拥有通用的逻辑演算方法和推理规则。
    自然性:是一种接近于人类自然语言的形式语言系统。
    模块化:各条知识相对独立,它们之间不直接发生联系,便于知识的添加、删除和修改。
    缺点:
    表示能力差:只能表示确定性知识,不能表示非确定性知识、过程性知识和启发式知识。
    管理困难:缺乏知识的组织原则,知识库管理困难。
    效率低:把推理演算与知识含义截然分开,往往使推理过程冗长,降低了系统效率。

    产生式规则表示法

    产生式系统是用规则序列的形式来描述问题的思维过程,形成求解问题的思维模式。
    系统中的每一条规则称为一个产生式。
    在这里插入图片描述
    案例:
    在这里插入图片描述
    在这里插入图片描述
    优点:
    有效性:既可以表示确定性知识,又可以表示不确定性知识,有利于启发性和过程性知识的表达。
    自然性:用“如果…,则…”表示知识,直观、自然。
    一致性:所有规则具有相同的格式,并且数据库可被所有规则访问,便于统一处理。
    模块化:各条规则之间只能通过数据库发生联系,不能相互调用,便于知识的添加、删除和修改。
    缺点:
    效率低:求解是反复进行的“匹配—冲突消解—执行”过程,执行效率低。
    表示的局限性:不能表示结构性或层次性知识!!

    框架表示法

    框架表示法是以框架理论为基础发展起来的一种结构化知识表示方式,适用于表达多种类型的知识。框架理论认为人们对现实世界中各种事物的认识都是以一种类似于框架的结构存储在记忆当中的,当面临一个新事物时,就从记忆中找出一个适合的框架,并根据实际情况对其细节加以修改补充,从而形成对当前事物的认识。
    在这里插入图片描述
    框架分为两种类型:
    类框架(class frame)用于描述一个概念或一类对象。
    实例框架(instance frame)用于描述一个具体的对象。

    框架的层次结构:
    子类-subclass of->父类:类框架之间的包含关系。
    实例-instance of->类:实例框架和类框架的从属关系。

    下层框架可以从上层框架继承某些属性和值。后文对两者
    不做区分,统称为“类属”关系。

    优点:
    结构化:分层次嵌套式结构,既可以表示知识的内部结构,又可以表示知识之间的联系。
    继承性:下层框架可以从上层框架继承某些属性或值,也可以进行补充修改,减少冗余信息并节省存储空间。
    自然性:框架理论符合人类认知的思维过程。
    模块化:每个框架是相对独立的数据结构,便于知识的添加、删除和修改。
    缺点:
    不能表示过程性知识。
    缺乏明确的推理机制。

    语义网表示

    语义网提供了一套为描述数据而设计的表示语言和工具,用于形式化的描述一个知识领域内的概念、术语和关系。
    在这里插入图片描述
    OWL有更强大的语义表达能力
    在这里插入图片描述
    在这里插入图片描述

    XML

    XML(eXtensible Markup Language,可扩展标记语言)是最早的语义网表示语言,它取消了HTML的显示样式和布局描述能力,突出了数据的语义和元素结构描述能力。
    用于存储和传输数据,侧重于如何结构化地描述信息
    XML的元素代表XML文档所描述的“事件”,比如书籍、作者和出版商。
    一个元素由起始标签、元素内容和结尾标签构成。

    <author>Thomas B. Passin</author>
    

    用户可以随意地选择标签名,只有很少的限制。元素具有嵌套结构,并且没有约束嵌套的深度。

    <author>
    <name>Thomas B. Passin</name>
    <gender>Male</gender>
    <phone>+61-7-3875 507</phone>
    </author>
    

    与HTML类似,XML也可拥有属性,即元素名称-值对,可以表达与元素相同的语义。

    <author name=“Thomas B. Passin”
    phone=“+61-7-3875 507”/>
    gender=“Male”
    

    属性也可以与元素混合使用,但是不能嵌套。

    <author name=“Thomas B. Passin” gender=“Male” >
    <phone>+61-7-3875 507</phone>
    </author>
    

    属性具有唯一性!!
    子元素可以有多值
    用Xlink去描述关系

    XML优点:
    结构化的数据表示方式,使得数据内容与其形式分离。良好的可扩展性,使用者可创建和使用自己的标记,可定义行业领域特殊的标记语言,进行数据共享和交换。包含文档类型声明,其数据可被任何XML解析器提取、分析、处理,可以轻松地跨平台应用。
    XML缺点:
    XML是一种元标记语言,任何组织或个人都可以用它来定义新的标记和标准,容易产生冲突和混乱。
    XML文档作为数据集合使用时,相当于一个数据库,不具备数据库管理系统那样完备的功能。
    数据是以树状结构存储的,插入和修改比较困难。

    RDF

    RDF(Resource Description Framework,资源描述框架)是一种资源描述语言,利用当前的多种元数据标准来描述各种网络资源,形成人机可读,并可由机器自动处理的文件。
    RDF的核心思想: 利用Web标识符(URI)来标识事物,通过指定的属性和相应的值描述资源的性质或资源之间的关系。
    数据模型:
    在这里插入图片描述
    案例:
    在这里插入图片描述

    RDF Schema

    RDFS是RDF的扩展,它在RDF的基础上提供了一组建模原语,用来描述类、属性以及它们之间的关系。
    Class, subClassOf:描述类别层次结构。
    Property, subPropertyOf:描述属性层次结构。
    domain, range:声明属性所应用的资源类和属性值类。
    type:声明一个资源是一个类的实例。

    案例:
    在这里插入图片描述
    在这里插入图片描述
    RDF(S)特性
    优点:
    简单:资源以三元组的形式描述,简单、易控制。
    易扩展:描述和词汇集分开,具备良好的可扩展性。
    包容性:允许定义自己的词汇集,并可以无缝使用多种词汇集来描述资源。
    易综合:RDF认为一切都是资源,这样很容易综合描述。
    缺点:
    不能准确描述语义:同一个概念有多种词汇表示,同一个词汇有多种含义(概念)。
    没有推理模型,不具备推理能力。

    Ontology(本体)通过对概念的严格定义和概念与概念之间的关系来确定概念的精确含义,表示共同认可的、可共享的知识。
    对于ontology来说,author,creator和writer是同一个概念,而doctor在大学和医院分别表示的是两个概念。因此在语义网中,ontology具有非常重要的地位,是解决语义层次上Web信息共享和交换的基础。

    Studer:本体是共享概念模型的明确的形式化规范说明。
    特点:
    概念模型 (conceptualization):本体是通过抽象客观世界的概念而得到的模型,其表示的含义独立于具体的环境状态。
    明确性 (explicit):本体所使用的概念及使用这些概念的约束都有明确的定义,没有二义性。
    形式化 (formal):本体是计算机可处理的,而非自然语言。
    共享 (shared):本体体现的是共同认可的知识,反映的是相关领域中公认的概念集合,它所针对的是团体而非个体。
    在这里插入图片描述

    OWL

    OWL (Web Ontology Language,Web本体语言)是在语义网上表示本体的推荐语言,作为RDF(S)的扩展,其目的是提供更多原语以支持更加丰富的语义表达并支持推理。
    OWL的三个子语言:
    Lite:提供一个分类层次和简单属性约束。
    DL:提供推理系统,保证计算完备性和可判定性。
    Full:支持完全自由的RDF语法,但是不具备可计算性保证。
    表达能力:OWL Lite < OWL DL < OWL Full
    在这里插入图片描述
    在这里插入图片描述

    总结:

    在这里插入图片描述

    分布式知识表示

    核心思想:将样本(符号化的实体和关系)通过变换映射到一个低维稠密的空间里,用低维度向量表示原始样本。在简化计算的同时最大程度保留原始的图结构。
    映射!!!
    表示学习:自动从数据中自动学习有用的特征,用于后续的任务中!
    在这里插入图片描述
    统计语言模型
    – 把语言(词的序列)看作一个随机事件,并赋予相应的概率来描述其属于某种语言集合的可能性。
    – 给定一个词汇集合 V,对于一个由 V 中的词构成的序列S = ⟨w1, … , wT ⟩ ∈ Vn,统计语言模型赋予这个序列一个概率P(S),来衡量S 符合自然语言的语法和语义规则的置信度。
    – 一个句子的打分概率越高,越说明他是更合乎人说出来的自然句子。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    核心:上下文相似的词,其语义也相似。

    连续词带模型:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    A是临接矩阵
    A+I是为了统计本身的信息
    D是度矩阵(对角线)
    DAD相当于对A的归一化操作

    展开全文
  • 在本实验中发现,一个XML文档可以通过平面的形式、或者层次的形式来表示多个关系数据库中的二维表,那么哪种方式更合适,为什么? [提交时间及内容] 最后提交时间 2013年?月?日 提交内容 提交SpyBase1.xml、...
  • 在Java开发的报表工具FineReport中,假如在目录下保存了几个XML文件,希望把XML文件转换为报表数据源,同时希望展示动态xml数据源的效果,这时可通过参数的方式,动态获取xml字段中的值再作为报表数据源。...

    在Java开发的报表工具FineReport中,假如在目录下保存了几个XML文件,希望把XML文件转换为报表数据源,同时希望展示动态xml数据源的效果,这时可通过参数的方式,动态获取xml字段中的值再作为报表数据源。

    Northwind.xml记录数据格式如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <Northwind>
        <Customers>
    	    <CustomerID>ALFKI</CustomerID>
    		<CompanyName>ALfreds Futterkiste</CompanyName>
    		<ContactName>Maria Anders</ContactName>
    		<ContactTitle>Sales Representative</ContactTitle>
    		<Address>Obere Str.57</Address>
    		<City>Berlin</City>
    		<PostalCode>12209</PostalCode>
    		<Country>Germany</Country>
    		<Phone>030-0074321</Phone>
    		<Fax>030-0076545</Fax>
    	</Customers>
    </Northwind>

    最终用于制作报表的数据源形式如下:


    对于这样的情况我们如何来实现呢?FineReport中可以通过自定义程序数据集来对xml字段数据进行解析,最终返回所希望的数据表。实现步骤如下:

    1、  定义XMLColumnNameType4Demo封装类

    首先定义参数name及type,供其他类直接调用,安全性比较高,详细代码如下:

    package com.fr.data;  
      
    public class XMLColumnNameType4Demo {  
        private int type = -1;  
        private String name = null;   
        public XMLColumnNameType4Demo(String name, int type) {  
            this.name = name;  
            this.type = type;  
        }  
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }      
        public int getType() {  
            return type;  
        }  
        public void setType(int type) {  
            this.type = type;  
        }  
    }
    
    

    2、定义XMLParseDemoDataModel.java类文件

    定义XMLParseDemoDataModel.java类继承AbstractDataModel接口,实现getColumnCount、getColumnName、getRowCount、getValueAt四个方法,详细代码如下:

    package com.fr.data;  
      
    import java.io.File;  
    import java.util.ArrayList;  
    import java.util.List;  
    import javax.xml.parsers.SAXParser;  
    import javax.xml.parsers.SAXParserFactory;  
    import org.xml.sax.Attributes;  
    import org.xml.sax.SAXException;  
    import org.xml.sax.helpers.DefaultHandler;  
    import com.fr.base.FRContext; 
    import com.fr.data.AbstractDataModel;  
    import com.fr.general.ComparatorUtils;
    import com.fr.general.data.TableDataException;
      
    /** 
     * XMLParseDemoDataModel 
     *  
     * DataModel是获取数据的接口 
     *  
     * 这里通过init方法一次性取数后,构造一个二维表对象来实现DataModel的各个取数方法 
     */  
    public class XMLParseDemoDataModel extends AbstractDataModel {  
        // 数据类型标识  
        public static final int COLUMN_TYPE_STRING = 0;  
        public static final int COLUMN_TYPE_INTEGER = 1;  
        public static final int COLUMN_TYPE_BOOLEAN = 2;  
      
        // 缓存取出来的数据  
        protected List row_list = null;  
      
        // 数据对应的节点路径  
        private String[] xPath;  
        // 节点路径下包含的需要取数的节点  
        private XMLColumnNameType4Demo[] columns;  
      
        private String filePath;  
      
        public XMLParseDemoDataModel(String filename, String[] xPath,  
                XMLColumnNameType4Demo[] columns) {  
            this.filePath = filename;  
            this.xPath = xPath;  
            this.columns = columns;  
        }  
      
        /** 
         * 取出列的数量 
         */  
        public int getColumnCount() throws TableDataException {  
            return columns.length;  
        }  
      
        /** 
         * 取出相应的列的名称 
         */  
        public String getColumnName(int columnIndex) throws TableDataException {  
            if (columnIndex < 0 || columnIndex >= columns.length)  
                return null;  
            String columnName = columns[columnIndex] == null ? null  
                    : columns[columnIndex].getName();  
      
            return columnName;  
        }  
      
        /** 
         * 取出得到的结果集的总的行数 
         */  
        public int getRowCount() throws TableDataException {  
            this.init();  
            return row_list.size();  
        }  
      
        /** 
         * 取出相应位置的值 
         */  
        public Object getValueAt(int rowIndex, int columnIndex)  
                throws TableDataException {  
            this.init();  
            if (rowIndex < 0 || rowIndex >= row_list.size() || columnIndex < 0  
                    || columnIndex >= columns.length)  
                return null;  
            return ((Object[]) row_list.get(rowIndex))[columnIndex];  
        }  
      
        /** 
         * 释放一些资源,取数结束后,调用此方法来释放资源 
         */  
        public void release() throws Exception {  
            if (this.row_list != null) {  
                this.row_list.clear();  
                this.row_list = null;  
            }  
        }  
      
        /** ************************************************** */  
        /** ***********以上是实现DataModel的方法*************** */  
        /** ************************************************** */  
      
        /** ************************************************** */  
        /** ************以下为解析XML文件的方法**************** */  
        /** ************************************************** */  
      
        // 一次性将数据取出来  
        protected void init() throws TableDataException {  
            if (this.row_list != null)  
                return;  
      
            this.row_list = new ArrayList();  
            try {  
                // 使用SAX解析XML文件, 使用方法请参见JAVA SAX解析  
                SAXParserFactory f = SAXParserFactory.newInstance();  
                SAXParser parser = f.newSAXParser();  
      
                parser.parse(new File(XMLParseDemoDataModel.this.filePath),  
                        new DemoHandler());  
            } catch (Exception e) {  
                e.printStackTrace();  
                FRContext.getLogger().error(e.getMessage(), e);  
            }  
        }  
      
        /** 
         * 基本原理就是解析器在遍历文件时 发现节点开始标记时,调用startElement方法 读取节点内部内容时,调用characters方法 
         * 发现节点结束标记时,调用endElement 
         */  
        private class DemoHandler extends DefaultHandler {  
            private List levelList = new ArrayList(); // 记录当前节点的路径  
            private Object[] values; // 缓存一条记录  
            private int recordIndex = -1; // 当前记录所对应的列的序号,-1表示不需要记录  
      
            public void startElement(String uri, String localName, String qName,  
                    Attributes attributes) throws SAXException {  
                // 记录下  
                levelList.add(qName);  
      
                if (isRecordWrapTag()) {  
                    // 开始一条新数据的记录  
                    values = new Object[XMLParseDemoDataModel.this.columns.length];  
                } else if (needReadRecord()) {  
                    // 看看其对应的列序号,下面的characters之后执行时,根据这个列序号来设置值存放的位置。  
                    recordIndex = getColumnIndex(qName);  
                }  
            }  
      
            public void characters(char[] ch, int start, int length)  
                    throws SAXException {  
                if (recordIndex > -1) {  
                    // 读取值  
                    String text = new String(ch, start, length);  
                    XMLColumnNameType4Demo type = XMLParseDemoDataModel.this.columns[recordIndex];  
                    Object value = null;  
                    if (type.getType() == COLUMN_TYPE_STRING) {  
                        value = text;  
                    }  
                    if (type.getType() == COLUMN_TYPE_INTEGER) {  
                        value = new Integer(text);  
                    } else if (type.getType() == COLUMN_TYPE_BOOLEAN) {  
                        value = new Boolean(text);  
                    }  
      
                    values[recordIndex] = value;  
                }  
            }  
      
            public void endElement(String uri, String localName, String qName)  
                    throws SAXException {  
                try {  
                    if (isRecordWrapTag()) {  
                        // 一条记录结束,就add进list中  
                        XMLParseDemoDataModel.this.row_list.add(values);  
                        values = null;  
                    } else if (needReadRecord()) {  
                        recordIndex = -1;  
                    }  
                } finally {  
                    levelList.remove(levelList.size() - 1);  
                }  
            }  
      
            // 正好匹配路径,确定是记录外部的Tag  
            private boolean isRecordWrapTag() {  
                if (levelList.size() == XMLParseDemoDataModel.this.xPath.length  
                        && compareXPath()) {  
                    return true;  
                }  
      
                return false;  
            }  
      
            // 需要记录一条记录  
            private boolean needReadRecord() {  
                if (levelList.size() == (XMLParseDemoDataModel.this.xPath.length + 1)  
                        && compareXPath()) {  
                    return true;  
                }  
      
                return false;  
            }  
      
            // 是否匹配设定的XPath路径  
            private boolean compareXPath() {  
                String[] xPath = XMLParseDemoDataModel.this.xPath;  
                for (int i = 0; i < xPath.length; i++) {  
                    if (!ComparatorUtils.equals(xPath[i], levelList.get(i))) {  
                        return false;  
                    }  
                }  
      
                return true;  
            }  
      
            // 获取该字段的序号  
            private int getColumnIndex(String columnName) {  
                XMLColumnNameType4Demo[] nts = XMLParseDemoDataModel.this.columns;  
                for (int i = 0; i < nts.length; i++) {  
                    if (ComparatorUtils.equals(nts[i].getName(), columnName)) {  
                        return i;  
                    }  
                }  
      
                return -1;  
            }  
        }  
    }
    

    3、定义程序数据集XMLDemoTableData

    通过参数filename,动态显示xml文件内容,首先xml文件需要放到某个目录下,如下代码是放到D盘,并且定义需要解析的数据列,这边定义的数据列名称,根xml内字段名称是一一对用的。详细代码如下:

    packagecom.fr.data;   
     
    importjava.io.BufferedInputStream; 
    importjava.io.ByteArrayInputStream; 
    importjava.io.File; 
    importjava.io.FileInputStream; 
    importjava.io.FileNotFoundException; 
    importjava.io.FileReader; 
    importjava.io.InputStream; 
    importjava.io.Reader; 
    importjava.util.*;
     
    importjavax.xml.stream.XMLEventReader; 
    importjavax.xml.stream.XMLInputFactory; 
    importjavax.xml.stream.XMLStreamException; 
    importjavax.xml.stream.events.XMLEvent;
     
    importcom.fr.base.Parameter; 
    importcom.fr.data.AbstractParameterTableData;
    importcom.fr.general.data.DataModel;
    importcom.fr.script.Calculator;   
    importcom.fr.stable.ParameterProvider;
    importcom.fr.stable.StringUtils;
       
    /** 
     * XMLDemoTableData 
     *  
     *  这是一个按参数来解析不同地址XML文件的demo 
     *  
     * AbstractParameterTableData 包装了有参数数据集的基本实现 
     */   
    publicclass XMLDemoTableData extends AbstractParameterTableData {   
           
        // 构造函数   
        public XMLDemoTableData() {   
            // 定义需要的参数,这里定义一个参数,参数名为filename,给其一个默认值"Northwind.xml"   
            this.parameters = newParameter[1];   
            this.parameters[0] = newParameter("filename", "Northwind");    
        }   
       
        /** 
         * 返回获取数据的执行对象 
         * 系统取数时,调用此方法来返回一个获取数据的执行对象 
         * 注意!当数据集需要根据不同参数来多次取数时,此方法在一个计算过程中会被多次调用。 
         */   
       @SuppressWarnings("unchecked") 
        public DataModel createDataModel(Calculatorcalculator) {   
            // 获取传进来的参数   
            ParameterProvider[] params =super.processParameters(calculator);   
               
            // 根据传进来的参数,等到文件的路径   
            String filename = null;   
            for (int i = 0; i < params.length;i++) {   
                if (params[i] == null)continue;   
                   
                if("filename".equals(params[i].getName())) {   
                    filename =(String)params[i].getValue();   
                }   
            }   
               
            String filePath;   
            if (StringUtils.isBlank(filename)){   
                filePath ="D://DefaultFile.xml";   
            } else {   
                filePath = "D://" +filename + ".xml";   
            }   
               
            // 定义需要解析的数据列,机器   
    //        XMLColumnNameType4Demo[] columns = newXMLColumnNameType4Demo[7];   
    //        columns[0] = newXMLColumnNameType4Demo("CustomerID",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
    //        columns[1] = newXMLColumnNameType4Demo("CompanyName",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
    //        columns[2] = newXMLColumnNameType4Demo("ContactName",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
    //        columns[3] = newXMLColumnNameType4Demo("ContactTitle",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
    //        columns[4] = newXMLColumnNameType4Demo("Address",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
    //        columns[5] = newXMLColumnNameType4Demo("City",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
    //        columns[6] = new XMLColumnNameType4Demo("Phone",XMLParseDemoDataModel.COLUMN_TYPE_STRING);   
               
            List list=new ArrayList(); 
            XMLInputFactory inputFactory =XMLInputFactory.newInstance(); 
            InputStream in; 
            try { 
                in = new BufferedInputStream(newFileInputStream(new File(filePath))); 
                XMLEventReader reader =inputFactory.createXMLEventReader(in); 
                readCol(reader,list); 
                in.close(); 
            } catch (Exception e) { 
                // TODO Auto-generated catchblock 
                e.printStackTrace(); 
            } 
            XMLColumnNameType4Demo[]columns=(XMLColumnNameType4Demo[])list.toArray(newXMLColumnNameType4Demo[0]); 
             
             
            // 定义解析的数据在xml文件结构中的位置   
            String[] xpath = new String[2];   
            xpath[0] = "Northwind";   
            xpath[1] = "Customers";   
            /* 
             * 说明 
             * 提供的样例xml文件的格式是: 
             * <Notrhwind> 
             *    <Customers> 
             *         <CustomerID>ALFKI</CustomerID> 
             *         <CompanyName>AlfredsFutterkiste</CompanyName> 
             *         <ContactName>MariaAnders</ContactName> 
             *         <ContactTitle>SalesRepresentative</ContactTitle> 
             *         <Address>Obere Str. 57</Address> 
             *         <City>Berlin</City> 
             *        <PostalCode>12209</PostalCode> 
             *        <Country>Germany</Country> 
             *        <Phone>030-0074321</Phone> 
             *        <Fax>030-0076545</Fax> 
             *    </Customers> 
             * </Northwind> 
             *  
             * 上面定义的意义就是 
             * /Northwind/Customers路径所表示的一个Customers节点为一条数据,它包含的节点中的CustomerID...等等是需要获取的列值 
             */   
               
            // 构造一个实际去取值的执行对象   
            return new XMLParseDemoDataModel(filePath,xpath, columns);   
        } 
        private int deep=0; 
        private static final int COL_DEEP=3; 
        private boolean flag=false; 
        private void readCol(XMLEventReader reader,List list) 
                throws XMLStreamException { 
            while (reader.hasNext()) { 
                XMLEvent event =reader.nextEvent(); 
                if (event.isStartElement()) { 
                    //deep是控制层数的,只把xml中对应的层的加入到列名中 
                    deep++; 
                    //表示已经进入到了列名那一层 
                    if(deep==COL_DEEP){ 
                        flag=true; 
                    } 
                    //如果在高层,并且已经进入到了col层,则退出 
                   if(deep<COL_DEEP&&flag){ 
                        return; 
                    } 
                    if(deep!=COL_DEEP){ 
                        continue; 
                    } 
    //              println("name: " +event.asStartElement().getName()); 
                    XMLColumnNameType4Democolumn=new XMLColumnNameType4Demo(event.asStartElement().getName().toString(),XMLParseDemoDataModel.COLUMN_TYPE_STRING); 
                    list.add(column); 
                    readCol(reader,list); 
                } else if (event.isCharacters()){ 
                    //对数据值不做处理 
                } else if (event.isEndElement()){ 
                    deep--; 
                    return; 
                } 
            } 
        } 
         
        private void readCol0(XMLEventReader reader) 
                throws XMLStreamException { 
            while (reader.hasNext()) { 
                XMLEvent event = reader.nextEvent(); 
                if (event.isStartElement()) { 
                    //deep是控制层数的,只把xml中对应的层的加入到列名中 
                    deep++; 
                    //表示已经进入到了列名那一层 
                    if(deep==COL_DEEP){ 
                        flag=true; 
                    } 
                    //如果在高层,并且已经进入到了col层,则退出 
                   if(deep<COL_DEEP&&flag){ 
                        return; 
                    } 
                    if(deep!=COL_DEEP){ 
                        continue; 
                    } 
                    System.out.println("name:" + event.asStartElement().getName()); 
                    readCol0(reader); 
                } else if (event.isCharacters()){ 
                    //对数据值不做处理 
                } else if (event.isEndElement()){ 
                    deep--; 
                    return; 
                } 
            } 
        } 
        public static void main(String[]args){ 
            XMLInputFactory inputFactory =XMLInputFactory.newInstance(); 
    //      in = new FileReader(newFile(filePath)); 
    //      XMLEventReader reader = inputFactory.createXMLEventReader(in); 
    //      readCol(reader,list); 
            BufferedInputStream in; 
            try { 
                in = new BufferedInputStream(newFileInputStream(new File("D:/tmp/f.xml"))); 
                byte[] ba=new byte[3]; 
                in.read(ba,0,3); 
    //      System.out.println(in) 
            XMLEventReader reader =inputFactory.createXMLEventReader(in); 
            newXMLDemoTableData().readCol0(reader); 
            } catch (Exception e) { 
                    // TODO Auto-generated catchblock 
                    e.printStackTrace(); 
                } 
        } 
    }

    注:如果xml文件的格式上问题描述处所展示的xml格式不一致,则需要修改类中的deep变量,把列名所在的节点层数改成相对应的数值。

    注:XMLDemoTableData里面的filename并不是文件名,而是xml里面某个标签名。

    4、编译程序数据源

    分别编译XMLColumnNameType4Demo.java、XMLParseDemoDataModel.java、XMLDemoTableData.java三个类文件,将生成的class文件放于%FR_HOME%\WebReport\WEB-INF\classes\com\fr\data下。

     

    5 配置程序数据源

    新建报表,模板数据集>程序数据集,选择我们定义好的程序数据集XMLDemoTableData.class文件,名字可以自定义,如程序1。



    6、使用程序数据源

    在模板数据集窗口,点击预览按钮,弹出参数对话框,输入要显示的xml文件名称,点击确定则可以把Northwind.xml文件里面的数据读取出来转换报表数据源了,如下图:


    展开全文
  • XML信息检索基础

    千次阅读 2017-02-19 19:51:33
    2.1 信息检索系统数据检索系统可分为四个部分: 1、数据预处理: 从多种格式的数据中提取正文和其他所需的信息。... 目前主流的方法是以词为单位构造倒排索引。 3、查询处理 用户输入的查询条件可以有多种形
  • 二维数据,也称表格数据,由关联关系数据构成,采用二维表格方式组织,对应于数学中的矩阵,常见的表格都属于二维数据。 一般行首算作二维数据的一部分。 高维数据由键值对类型的数据构成,采用对象方式组织,可以...
  • xml 特点

    2014-05-20 09:53:13
    1. 具有良好的格式 XML 文档格式属于良好格式的文件。...如果没有结尾标记,那么在结束的“>”前,需要有“/”,表示开头和结尾是在同一标记内,例如: 2. 具有验证机制 XML 的标记是程序员自己定义的,标记
  • C#读取Excel中的内容,并将内容存放在二维数组中 读取Excel中的内容,存放在DataTable中 string path= @“E:\C# 读取Excel存放在二维数组中\11.xls”; (1)不区分后缀名 具体代码如下: public static DataTable ...
  • 浅出Java 的Xml编程

    2007-07-05 11:35:00
    浅出Java 的Xml编程作者:何双江(yarshray)对于Xml,我的认识是,一个用来存放数据的标准格式.怎么看我都觉得XML和Html,完全不一样,...它不同与一般的关系型数据库,把数据看出二维表.通过基本的关系运算,获取二维表中的
  • XML经验总结

    千次阅读 2013-08-28 22:28:34
    什么是XML 资料引用:http://www.knowsky.com/343580.html xml即可扩展标记语言(eXtensible Markup Language)。标记是指计算机所能理解的信息符号,通过此种标记,计算机之间可以处理包含各种信息的文章等。如何...
  • 对于Xml,我的认识是,一个用来存放数据的标准格式.怎么看我都觉得XML和Html,完全不一样,也许仅仅只是都使用了...通过基本的关系运算,获取二维表中的数据.XML仅仅把数据当成一个文档,然后正对文档解析获取数据.所以我的
  • XML(一)使用DOM读取XML文档 楼主  发表于 2013-5-21 21:14:28 | 查看: 1001| 回复: 14 使用DOM读取XML文档 版权声明 该文章原创于作者yafeilinux,转载...
  • XML标准和文档的出现为关系数据库出了一道难题,以访问二维表数据为主的SQL和XML的结合就成了一条中和之路。于是乎,漫长的SQL/XML结合之旅开始了。 随着新XML文档规范的问世,厂商正在加大在RDBMS(关系型数据库管理...
  • XML学习教程

    2014-08-02 10:16:48
    XML学习进阶1-- 什么是XML. 1 1  为什么使用 XML?... 3 2  什么是 XML?... 3 3  数据的结构表示... 4 4  XML 文档... 4 5  数据是从表示和处理中分离出来的... 7 6  使XML数据自描述......
  • 浅出Java 的Xml编程作者:何双江(yarshray)对于Xml,我的认识是,一个用来存放数据的标准格式.怎么看我都觉得XML和Html,完全不一样,也许仅仅...它不同与一般的关系型数据库,把数据看出二维表.通过基本的关系运算,获取二维
  • XML+SQL=数据库的未来?

    千次阅读 2004-06-29 11:02:00
    XML标准和文档的出现为关系数据库出了一道难题,以访问二维表数据为主的SQL和XML的结合就成了一条中和之路。于是乎,漫长的SQL/XML结合之旅开始了。 随着新XML文档规范的问世,厂商正在加大在RDBMS(关系型数据库...
  • XML标准和文档的出现为关系数据库出了一道难题,以访问二维表数据为主的SQL和XML的结合就成了一条中和之路。于是乎,漫长的SQL/XML结合之旅开始了。 随着新XML文档规范的问世,厂商正在加大在RDBMS(关系型数据库管理...
  •  * 将结果集二维集合数据转换为XML   *   * @param columns 列名集合   * @param result 二维结果集   * @return 返回格式良好的XML字符串   */     public   static  String listToXML...
  • XML实用大全》一

    千次阅读 2014-04-28 14:33:02
    第1章 XML概览 本章将向读者介绍XML的基本知识以及概略地解释什么是XML以及如何使用XML。还要向读者说明如何将各种不同的XML表达式组合在一起,XML文档是如何创建的并如何向人们发送这种文档。 本章的主要内容包括...
  • 第17章 数据库和XML

    千次阅读 2014-07-02 14:43:18
    第17章 数据库和XML
  • SQL Server 对XML数据功能支持

    千次阅读 2016-07-03 11:18:34
    SQL Server 对XML数据功能支持
  • XML实用大全》

    千次阅读 多人点赞 2018-11-17 22:46:18
    本章将向读者介绍XML的基本知识以及概略地解释什么是XML以及如何使用XML。还要向读者说明如何将各种不同的XML表达式组合在一起,XML文档是如何创建的并如何向人们发送这种文档。 本章的主要内容包括: · 什么是...
  • XML for Analysis 规范

    千次阅读 2005-03-30 13:29:00
    XML for Analysis 规范 1.0 版Microsoft CorporationHyperion Solutions Corporation更新日期:4/24/2001摘要:详细说明基于 SOAP 的 XML 通信 API,它支持在任何平台上使用任何语言在客户端和服务器之间进行分析...
  • XML学习摘要

    2016-05-23 08:52:27
    XML(Extensible Markup Language)可扩展标记语言,标准通用标记语言的子集,是一种用于标记电子文件使其具有结构性的标记语言。 在电子计算机中,标记指计算机所能理解的信息符号,通过此种标记,计算机之间可以...
  • 上一篇文章 《在SSIS 中使用 Web Service 以及 解析XML 数据》中介绍了使用SSIS的WebService控件解析XML数据,最后也提到对于返回的XML数含有数组类型的时候需要一点额外的处理。本示例将介绍在SSIS中用Web服务任务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,036
精华内容 6,014
关键字:

xml表示二维表