——Castor可以完成Java和XML的相互转换

前面有介绍过json-lib这个框架,在线博文:http://www.cnblogs.com/hoojo/archive/2011/04/21/2023805.html

以及Jackson这个框架,在线博文:http://www.cnblogs.com/hoojo/archive/2011/04/22/2024628.html

它们都可以完成Java对象到XML的转换,但是还不是那么的完善。还有XStream对JSON及XML的支持,它可以对JSON或XML的完美转换。在线博文:

http://www.cnblogs.com/hoojo/archive/2011/04/22/2025197.html

这 里将介绍Castor来完成Java对象到xml的相互转换。它是怎么样转换的?和前面不同的是castor可以用一个mapping.xml文件来描述 转换后的Java对象的xml基本形态,类似于xStream的annotation,这点还是非常不错的。下面我们就来看看Castor是怎么样完成 Java对象到XML之间的相互转换吧。

一、 准备工作

1、 官方资源

本示例会运用到如下依赖包(jar包):

资源及jar包下载:http://www.castor.org/download.html

junit jar下载地址:

https://github.com/KentBeck/junit/downloads

关于官方提供的mapping配置相关示例、文档:

http://www.castor.org/xml-mapping.html

ibm提供的castor方面的文档资料:

http://www.google.com.hk/search?hl=zh-CN&newwindow=1&safe=strict&client=aff-cs-360se&hs=Gon&biw=1349&bih=603&q=castor+site%3Awww.ibm.com%2Fdeveloperworks%2Fcn%2Fxml%2F&aq=f&aqi=&aql=&oq=

2、 程序测试运行代码

package com.hoo.test;
 
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.exolab.castor.mapping.Mapping;
import org.exolab.castor.mapping.MappingException;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.Marshaller;
import org.exolab.castor.xml.Unmarshaller;
import org.exolab.castor.xml.ValidationException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.hoo.entity.Account;
import com.hoo.entity.AccountArray;
import com.hoo.entity.Birthday;
import com.hoo.entity.ListBean;
import com.hoo.entity.MapBean;
 
/**
 * <b>function:</b>Castor完成Java对象到XML的相互转换
 * 依赖jar: castor-1.3.jar 
 * castor-1.3-core.jar 
 * junit-4.8.2.jar 
 * log4j-1.2.16.jar 
 * commons-logging.jar
 * @author hoojo
 * @createDate 2011-4-21 下午07:57:26
 * @file CastorTest.java
 * @package com.hoo.test
 * @project WebHttpUtils
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class CastorTest {
    
    private Account bean = null;
    private Mapping mapping = new Mapping();
    private StringWriter writer = null;
    private StringReader reader = null;
    
    @Before
    public void init() {
        bean = new Account();
        bean.setAddress("北京");
        bean.setEmail("email");
        bean.setId(1);
        bean.setName("jack");
        Birthday day = new Birthday();
        day.setBirthday("2010-11-22");
        bean.setBirthday(day);
        
        try {
            /**
             * 加载mapping.xml,此文件是对需要转换的Java对象的配置描述,
             * 即:转换后的Java对象的xml内容的转换规则
             */
            mapping.loadMapping(System.getProperty("user.dir") + "\\src\\mapping.xml");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (MappingException e) {
            e.printStackTrace();
        }
    }
    
    @After
    public void destory() {
        bean = null;
        mapping = null;
        try {
            if (writer != null) {
                writer.flush();
                writer.close();
            }
            if (reader != null) {
                reader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.gc();
    }
    
    public void fail(Object o) {
        System.out.println(o);
    }
    
    public void failRed(Object o) {
        System.err.println(o);
    }
}

Mapping对象可以完成Java对象到XML的编组和解组,它需要先设定一个mapping.xml,通过xml对JavaObject的描述。来完成JavaObject的编组、解组工作。

3、 看看即将被转换的JavaEntity代码

Account

package com.hoo.entity;
 
public class Account {
    private int id;
    private String name;
    private String email;
    private String address;
    private Birthday birthday;
    
    //setter、getter
    @Override
    public String toString() {
        return this.id + "#" + this.name + "#" + this.email + "#" + this.address + "#" + this.birthday;
    }
}

Birthday

package com.hoo.entity;
 
public class Birthday {
    private String birthday;
    
    public Birthday(String birthday) {
        super();
        this.birthday = birthday;
    }
    //getter、setter
    public Birthday() {}
    
    @Override
    public String toString() {
        return this.birthday;
    }
}

AccountArray

package com.hoo.entity;
 
public class AccountArray {
    private Account[] accounts;
    private int size;
    public int getSize() {
        size = accounts.length;
        return size;
    }
    public void setSize(int size) {
        this.size = size;
    }
    public Account[] getAccounts() {
        return accounts;
    }
    public void setAccounts(Account[] accounts) {
        this.accounts = accounts;
    }
}

ListBean

package com.hoo.entity;
 
import java.util.List;
 
public class ListBean {
    private String name;
    private List list;
    //setter、getter
}

MapBean

package com.hoo.entity;
 
import java.util.Map;
 
public class MapBean {
    private Map<String, Object> map;
    
    public Map<String, Object> getMap() {
        return map;
    }
    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
}

二、 编组JavaObjectXML

1、 将JavaBean编组,转换成XML

/**
 * <b>function:</b>将Javabean编组,转换成XML
 * @author hoojo
 * @createDate 2011-4-22 下午12:08:48
 */
@Test
public void writeBean2XML() {
    writer = new StringWriter();
    try {
        //编组
        Marshaller.marshal(bean, writer);
        fail(writer);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

代码很简单,通过Marshaller的marshal方法来完成Java对象到XML的编组(序列化、转换)工作。

运行后的结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<account id="1"><address>北京</address><email>email</email><name>jack</name>
<birthday><birthday>2010-11-22</birthday></birthday></account>

2、 将List集合转换成XML

/**
 * <b>function:</b>将List转换成xml
 * @author hoojo
 * @createDate 2011-4-22 下午12:11:00
 */
@Test
public void writeList2XML() {
    writer = new StringWriter();
    List<Account> list = new ArrayList<Account>();
    list.add(bean);
    bean = new Account();
    bean.setName("tom");
    bean.setId(223);
    list.add(bean);
    try {
        Marshaller.marshal(list, writer);
        fail(writer);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行后,结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<array-list>
<account xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:java="http://java.sun.com" id="1" xsi:type="java:com.hoo.entity.Account">
<address>北京</address><email>email</email><name>jack</name><birthday><birthday>2010-11-22</birthday></birthday></account>
<account xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:java="http://java.sun.com" id="223" xsi:type="java:com.hoo.entity.Account">
<name>tom</name>
</account>
</array-list>

怎么样,List存放的是2个Account吧。

3、 将Array数组转换成XML

/**
 * <b>function:</b>将Array数组转换成XML
 * @author hoojo
 * @createDate 2011-4-22 下午12:11:25
 */
@Test
public void writeArray2XML() {
    writer = new StringWriter();
    Account[] acc = new Account[2];
    acc[0] = bean;
    bean = new Account();
    bean.setName("tom");
    bean.setId(223);
    acc[1] = bean;
    
    try {
        Marshaller.marshal(acc, writer);
        fail(writer);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<array><account id="1"><address>北京</address><email>email</email><name>jack</name>
<birthday><birthday>2010-11-22</birthday></birthday></account>
<account id="223"><name>tom</name></account></array>

4、 转换其他Java类型

/**
 * <b>function:</b>将Java常用类型编组成xml
 * @author hoojo
 * @createDate 2011-4-22 下午12:11:44
 */
@Test
public void writeObject2XML() {
    writer = new StringWriter();
    try {
        Marshaller.marshal(true, writer);
        Marshaller.marshal(9527, writer);
        Marshaller.marshal(2.2f, writer);
        Marshaller.marshal(1.11d, writer);
        Marshaller.marshal("lucy", writer);
        Marshaller.marshal("hello castor".getBytes(), writer);
        Marshaller.marshal(new char[] { 'a', 'b', 'c' }, writer);
        Marshaller.marshal(new String[] { "hi", "spring", "castor" }, writer);
        fail(writer);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<boolean>true</boolean><?xml version="1.0" encoding="UTF-8"?>
<integer>9527</integer><?xml version="1.0" encoding="UTF-8"?>
<float>2.2</float><?xml version="1.0" encoding="UTF-8"?>
<double>1.11</double><?xml version="1.0" encoding="UTF-8"?>
<string>lucy</string><?xml version="1.0" encoding="UTF-8"?>
<[-b>aGVsbG8gY2FzdG9y</[-b><?xml version="1.0" encoding="UTF-8"?>
<array><character>a</character><character>b</character><character>c</character></array><?xml version="1.0" encoding="UTF-8"?>
<array><string>hi</string><string>spring</string><string>castor</string></array>

都是类型为节点名称,值为text。但是这里并没有出现Map,如果转换Map需要mapping进行配置。下面再慢慢道来-.-

5、 将xml解组成JavaBean

/**
 * <b>function:</b>将XML内容,解组成JavaBean
 * @author hoojo
 * @createDate 2011-4-22 下午12:12:14
 */
@Test
public void readXML2Bean() {
    
    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                    "<account id=\"1\"><address>北京</address>" +
                    "<name>jack</name><email>email</email>" +
                    "<birthday><birthday>2010-11-22</birthday></birthday></account>";
    reader = new StringReader(xml);
    
    try {
        //解组
        Account account = (Account) Unmarshaller.unmarshal(Account.class, reader);
        fail(account);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (ValidationException e) {
        e.printStackTrace();
    }
}

结果如下:

1#jack#email#北京#2010-11-22

其他的类型,如:map、list、array都不能成功解组。因为这些类型里面有很多系统默认的xml描述。但是利用mapping和自定义JavaBean就可以成功编组和解组了。下面看看mapping是怎么玩转这些类型的。

三、 利用mapping配置,编组JavaObject、解组XML

最开始的init方法就提供了mapping,让我们对mapping这个配置有了大概的了解。下面我们将详细介绍mapping是个什么:

1、 在此之前我们设置过mapping.xml。如果不设置,肯定是不能转换成我们想要的XML的。那么,mapping.xml配置文件是怎么配置Account这个对象的呢?

mapping.xml配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN" "http://castor.org/mapping.dtd">
<mapping>
    <class name="com.hoo.entity.Account" auto-complete="true">   
        <map-to xml="Account"/>
 
        <field name="id" type="integer">
            <bind-xml name="id" node="attribute" />
        </field>
 
        <field name="name" type="string">
            <bind-xml name="name" node="element" />
        </field>
 
        <field name="email" type="string">
            <bind-xml name="email" node="element" />
        </field>
 
        <field name="address" type="string">
            <bind-xml name="address" node="element" />
        </field>
 
        <field name="birthday" type="com.hoo.entity.Birthday">
            <bind-xml name="生日" node="element" />
        </field>
    </class>
 
    <class name="com.hoo.entity.Birthday">
        <map-to xml="birthday" />
 
        <field name="birthday" type="string">
            <bind-xml name="birthday" node="attribute" />
        </field>
    </class>
</mapping>

首先,看看这个xml文档的根元素是mapping,在mapping中可以配置class。也就是我们要转换的JavaObject的配置描述了。

class元素的name属性就是配置的JavaObject的classpath路径了。

关于class元素的auto-complate属性,如果这个属性的值为ture。那么编组后的xml,castor会自动给没有在 mapping配置文件进行配置的属性自动编组(转换)到xml中。如果为false,那么在mapping配置文件中出现的属性将在编组后不现在在编组 后的xml中。

map-to就是当前class编组后的xml文档的节点元素名称。

field就是描述JavaObject中的属性,name是Java对象的属性名称,type是类型。关于配置的type类型也有规定,你可以参考:http://www.castor.org/xml-mapping.html的field配置讲解。

而field还有其他的属性配置,如get-method应该是getter方法、set-method应该是setter的方法、 has-mehtod应该是hashCode方法,有时候我们不一定要提高getter、setter方法,我们需要用自己的方法名称来代替 setter、getter。如果当前field配置的是集合类型,那么你需要给field元素配置collection属性。

bind-xml就是绑定(编组)成xml后的xml内容的描述,name就是编组后xml的节点元素名称,node有2个值,分别是 attribute、element。attribute是属性,它会在节点元素的属性中显示,例如:<account id=”2”></account>

而element则是单独的一个元素,例如:<account><id>2</id></account>

就这个样子的。

mapping.xml还可以有其他标签,如:

<include href="other_mapping_file.xml"/>

导入外部xml文件,可以分多个配置。

好了,先将这么多的mapping方面的内容。我们还是看看实际运行的示例吧,代码如下:

/**
 * <b>function:</b>将XML内容解组成Java对象
 * @author hoojo
 * @createDate 2011-4-22 下午12:13:28
 */
@Test
public void bean4Mapping2XML() {
    writer = new StringWriter();
    try {
        //编组
        Marshaller mar = new Marshaller(writer);
        mar.setMapping(mapping);
        mar.marshal(bean);
        fail(writer);
        
        //解组
        reader = new StringReader(writer.toString());
        Unmarshaller unmar = new Unmarshaller(Account.class);
        unmar.setMapping(mapping);
        
        Account account = (Account) unmar.unmarshal(reader);
        fail(account);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行后结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<Account id="1"><name>jack</name><email>email</email><address>北京</address><生日 birthday="2010-11-22"/></Account>
1#jack#email#北京#2010-11-22

上面的xml的根节点是Account,这个功劳就来源于mapping配置中的map-to元素,而根节点的id属性是有field和bind- xml来完成的。当bind-xml的node值为attribute时,就会以属性的方式显示。当node为element时,就会像后面name、 email一样,以元素名称显示。

再看看上面的mapping文件中的Account的配置,有个auto-complate属性,如果把这个属性的值设置成false,会怎么样?那我们赶紧试试。

没有发现上面异样,但是当我们删除下面配置的filed的时候,就发现有变化了。

结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<Account><name>jack</name><email>email</email><address>北京</address><生日 birthday="2010-11-22"/></Account>
0#jack#email#北京#2010-11-22

发现id没有显示在xml中,那么我们再将auto-complate的属性设置true,会有什么惊喜?

结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<Account id="1"><name>jack</name><email>email</email><address>北京</address><生日 birthday="2010-11-22"/></Account>
1#jack#email#北京#2010-11-22

发现id又回来了,但是Account的配置中并没有配置id的field。这是为什么,其实auto-comlate在上面已经讲过了。 Castor在编组时会自动将int类型的属性,显示在父元素的属性中。并且JavaObject中有的属性没有在mapping配置文件中配 置,castor也会自动将其编组在xml中。

下面我们看看map-to配置的用法,map-to的主要属性是name,也就是我们把当前根元素重命名的名称。Map-to还有2个属性 可以用,分别是ns-uri、ns-prefix。看名称就知道它大概的意识,一个是命名空间的uri另一个则是命名空间的前缀。我们给上面 mapping加上这两个属性看看。

<map-to xml="Account" ns-uri="http://hoojo.cnblogs.com" ns-prefix="castor"/>

结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<castor:Account xmlns:castor="http://hoojo.cnblogs.com" id="1"><castor:name>jack</castor:name><castor:email>email</castor:email>
<castor:address>北京</castor:address><castor:生日 birthday="2010-11-22"/></castor:Account>
1#jack#email#北京#2010-11-22

发现了什么?节点元素都带上了ns-prefix的值,而根元素则有了xml的ns。

2、 将一段XML格式字符串转换成JavaBean

@Test
public void readBean4Mapping2XML() {
    String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                "<Account id=\"2241\"><name>jack</name><email>email</email><address>北京</address><生日 birthday=\"2010-11-22\"/></Account>";
    try {
        reader = new StringReader(xml);
        Unmarshaller unmar = new Unmarshaller(Account.class);
        unmar.setMapping(mapping);
        
        Account account = (Account) unmar.unmarshal(reader);
        fail(account);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

运行后结果如下:

2241#jack#email#北京#2010-11-22

3、 将XML内容解组成Java的Array

/**
 * <b>function:</b>将XML内容解组成Java的Array
 * @author hoojo
 * @createDate 2011-4-22 下午12:14:50
 */
@Test
public void array4Mapping2XML() {
    writer = new StringWriter();
    Account[] acc = new Account[2];
    acc[0] = bean;
    bean = new Account();
    bean.setName("tom");
    bean.setId(223);
    acc[1] = bean;
    AccountArray array = new AccountArray();
    array.setAccounts(acc);
    try {
        Marshaller mar = new Marshaller(writer);
        mar.setMapping(mapping);
        mar.marshal(array);
        fail(writer);
        
        reader = new StringReader(writer.toString());
        Unmarshaller unmar = new Unmarshaller(AccountArray.class);
        unmar.setMapping(mapping);
        array = (AccountArray) unmar.unmarshal(reader);
        fail(array.getSize());
        fail(array.getAccounts()[0]);
        fail(array.getAccounts()[1]);
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

AccountArray的mapping配置如下:

<class name="com.hoo.entity.AccountArray">
    <map-to xml="account-array"/>
    <field name="size" type="int" />
    <field name="accounts" collection="array" type="com.hoo.entity.Account">
        <bind-xml name="accounts" auto-naming="deriveByClass"/>
    </field>
</class>

collection表示是数组,auto-maming有2中值,一种是类driverByClass,另一种则是driverByField是属性。

运行后,结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<account-array><size>2</size><Account id="1"><name>jack</name><email>email</email><address>北京</address>
<生日 birthday="2010-11-22"/></Account><Account id="223"><name>tom</name></Account></account-array>
2
1#jack#email#北京#2010-11-22
223#tom#null#null#null

4、 将Map编组、解组成JavaObject

/**
 * <b>function:</b>xml转换成Java的Map
 * @author hoojo
 * @createDate 2011-4-22 下午12:15:18
 */
@Test
public void map4Mapping2XML() {
    writer = new StringWriter();
    MapBean mapBean = new MapBean();
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("No1", bean);
    bean = new Account();
    bean.setName("tom");
    bean.setId(223);
    map.put("No2", bean);
    mapBean.setMap(map);
    
    try {
        Marshaller mar = new Marshaller(writer);
        mar.setMapping(mapping);
        mar.marshal(mapBean);
        fail(writer);
        
        reader = new StringReader(writer.toString());
        Unmarshaller unmar = new Unmarshaller(MapBean.class);
        unmar.setMapping(mapping);
        mapBean = (MapBean) unmar.unmarshal(reader);
        fail(mapBean.getMap());
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Mapping配置

<class name="com.hoo.entity.MapBean">
    <field name="map" collection="map">
        <bind-xml name="map">
            <class name="org.exolab.castor.mapping.MapItem">
                <field name="key" type="java.lang.String">
                    <bind-xml name="key" node="attribute" />
                </field>
                <field name="value" type="com.hoo.entity.Account">
                    <bind-xml name="value" auto-naming="deriveByClass"/>
                </field>
            </class>
        </bind-xml>
    </field>
</class>

上面的map配置必须这样配置,利用org.exolab.castor.mapping.MapItem这个class,完成key、value的配置。

结果如下:

<?xml version="1.0" encoding="UTF-8"?>
<map-bean><map key="No2"><Account id="223"><name>tom</name></Account></map>
<map key="No1"><Account id="1"><name>jack</name><email>email</email><address>北京</address>
<生日 birthday="2010-11-22"/></Account></map></map-bean>
{No2=223#tom#null#null#null, No1=1#jack#email#北京#2010-11-22}

5、 JavaList编组、解组XML

/**
 * <b>function:</b>List到XML的相互转换
 * @author hoojo
 * @createDate 2011-4-22 下午12:16:04
 */
@SuppressWarnings("unchecked")
@Test
public void listForMapping2XML() {
    writer = new StringWriter();
    
    List<Account> list = new ArrayList<Account>();
    list.add(bean);
    bean = new Account();
    bean.setName("tom");
    bean.setId(223);
    list.add(bean); 
    
    ListBean listBean = new ListBean();
    listBean.setList(list);
    try {
        Marshaller mar = new Marshaller(writer);
        mar.setMapping(mapping);
        mar.marshal(listBean);
        fail(writer);
        
        reader = new StringReader(writer.toString());
        Unmarshaller unmar = new Unmarshaller(ListBean.class);
        unmar.setMapping(mapping);
        listBean = (ListBean) unmar.unmarshal(reader);
        fail(listBean.getList().size());
        for (Account acc : (List<Account>)listBean.getList()) {
            fail(acc);
        }
    } catch (MarshalException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Mapping配置

<class name="com.hoo.entity.ListBean">
    <map-to xml="listBean"/>
    <field name="list" collection="arraylist" type="com.hoo.entity.Account">
        <bind-xml name="beans" auto-naming="deriveByClass"/>
    </field>
</class>

结果:

<?xml version="1.0" encoding="UTF-8"?>
<listBean><Account id="1"><name>jack</name><email>email</email><address>北京</address>
<生日 birthday="2010-11-22"/></Account><Account id="223"><name>tom</name></Account></listBean>
2
1#jack#email#北京#2010-11-22
223#tom#null#null#null
原文:http://www.cnblogs.com/hoojo/archive/2011/04/25/2026819.html

用Castor 处理XML文档的更多相关文章

  1. C#反序列化XML异常:在 XML文档(0, 0)中有一个错误“缺少根元素”

    Q: 在反序列化 Xml 字符串为 Xml 对象时,抛出如下异常. 即在 XML文档(0, 0)中有一个错误:缺少根元素. A: 首先看下代码: StringBuilder sb = new Stri ...

  2. 【.net 深呼吸】使用二进制格式来压缩XML文档

    在相当多的情况下,咱们写入XML文件默认是使用文本格式来写入的,如果XML内容是通过网络传输,或者希望节省空间,特别是对于XML文档较大的情况,是得考虑尽可能地压缩XML文件的大小. XmlDicti ...

  3. 【Win 10应用开发】把文件嵌入到XML文档

    把文件内容嵌入(或存入)到XML文档中,相信很多朋友会想到把字节数组转化为Base64字符串,再作为XML文档的节点.不过,有人会说了,转化后的base64字符串中含有像“+”这样的符号,写入到XML ...

  4. 用ORM的思想操作XML文档,一个对象就搞定不要太简单。滚蛋吧!XmlDocument、XmlNode、Xml***……

    大家有没有这样的感受,一涉及XML文档操作就得百度一遍.是不是非!常!烦!.各种类型,各种方法,更别提为了找到一个节点多费劲.本来想写个XML操作的工具方法,写了两行一想既然XML文档是有规律的,如果 ...

  5. 【Win10 应用开发】自适应Toast通知的XML文档结构

    老规矩,在开始之前老周先讲个故事. 话说公元2015年7月20日,VS 2015发布.于是,肯定有人会问老周了,C#6有啥新特性,我学不来啊.学不来的话你应该检讨.老周比较保守地计算一下,学会C# 6 ...

  6. XML文档操作集锦(C#篇)

    在JSON没流行起来的时候xml一直作为程序存储配置信息的主流介质:特别是小型数据表方面还是不错的选择,所以经常涉及到的操作无非也就是增删改查,这篇博客主要是对这些对比较常用的操作做了个简单的总结 文 ...

  7. XmlReader和XElement组合之读取大型xml文档

    简介 在.NET framework 中存在大量操作xml数据的类库和api,但在.NET framework 3.5后我们的首选一般就是linq to xml. linq to xml操作xml数据 ...

  8. Java获取XML节点总结之读取XML文档节点

    dom4j是Java的XML API,用来读写XML文件的.目前有很多场景中使用dom4j来读写xml的.要使用dom4j开发,需要下载导入dom4j相应的jar文件.官网下载:http://www. ...

  9. 使用sp_xml_preparedocument处理XML文档

    有时会在存储过程中处理一些XML格式的数据,所以会用到sp_xml_preparedocument,他可以将XML数据进行读取,然后使用 MSXML 分析器 (Msxmlsql.dll) 对其进行分析 ...

随机推荐

  1. Node.js的net模块

    net模块提供了一个异步网络包装器,用于TCP网络编程,它包含了创建服务器和客户端的方法 创建TCP服务器 net.createServer方法 创建客户端去连接服务器 net.connect方法 简 ...

  2. js-JavaScript高级程序设计学习笔记8

    第十三章 事件 1.DOM2级事件规定的事件流包括三个阶段:事件捕获阶段.处于目标阶段.事件冒泡阶段. 2.大部分浏览器都会在捕获阶段出发对象上的事件,结果就是,有两个机会在目标对象上面操作事件. 3 ...

  3. 【UOJ#33】【UR#2】树上GCD 有根树点分治 + 容斥原理 + 分块

    #33. [UR #2]树上GCD 有一棵$n$个结点的有根树$T$.结点编号为$1…n$,其中根结点为$1$. 树上每条边的长度为$1$.我们用$d(x,y)$表示结点$x,y$在树上的距离,$LC ...

  4. 主机和虚拟机能相互ping通但是不能复制

    1.本机能ping通虚拟机 2.虚拟机也能ping通本机 3.虚拟机能访问自己的web 4.本机无法访问虚拟己的web 后来发现是防火墙将80端口屏蔽了的缘故. 检查是不是服务器的80端口被防火墙堵了 ...

  5. springMVC-自定义数据类型转换器

    自定义类型转换器 201603005,今天想了一个问题,Spring中的Conventer是如何实现的,因为他没有绑定类中的属性,它怎么知道要将那个String转换?看了几遍的书也没有找到,后来想想, ...

  6. cmd 利用IE打开网页

    "C:\Program Files\Internet Explorer\iexplore.exe" "http://dmsite.chinacloudsites.cn/r ...

  7. cmd执行sql文件

    string infile = @"C:\Users\yudm\Desktop\test\Patch.sql"; Process sqlprocess = new Process( ...

  8. PCRE Perl Compatible Regular Expressions Learning

    catalog . PCRE Introduction . pcre2api . pcre2jit . PCRE Programing 1. PCRE Introduction The PCRE li ...

  9. android逆向学习小结--CrackMe_1

    断断续续的总算的把android开发和逆向的这两本书看完了,虽然没有java,和android开发的基础,但总体感觉起来还是比较能接收的,毕竟都是触类旁通的.当然要深入的话还需要对这门语言的细节特性和 ...

  10. XmlReader读取XML

    StringBuilder output = new StringBuilder(); String xmlString = @"<bookstore> <book gen ...