SAX解析XMLpackage simpleTestwxh zt

wxhwhmanshan

SAX解析XMLpackage simpleTest;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.Locator;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.helpers.DefaultHandler;
import java.io.IOException;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

class TestSAX extends DefaultHandler
{
private StringBuffer buf;

public TestSAX()
{
super();
}
public void setDocumentLocator(Locator locator)
{
}
public void startDocument() throws SAXException
{
buf=new StringBuffer();
System.out.println("*******开始解析文档*******");
}
public void endDocument() throws SAXException
{
System.out.println("*******文档解析结束*******");
}

public void startPrefixMapping( String prefix, String uri )
{
System.out.println("\n前缀映射: " + prefix +" 开始!"+ " 它的URI是:" + uri);
}

public void endPrefixMapping( String prefix )
{
System.out.println("\n前缀映射: "+prefix+" 结束!");
}
public void processingInstruction( String target, String instruction )
throws SAXException
{
}
public void ignorableWhitespace( char[] chars, int start, int length ) throws SAXException
{
}

public void skippedEntity( String name ) throws SAXException
{
}

public void startElement(String namespaceURI,String localName,String qName,Attributes atts)
{
System.out.println("*******开始解析元素*******");
System.out.println("元素名"+qName);
for(int i=0;i<atts.getLength();i++)
{
System.out.println("元素名"+atts.getLocalName(i)+"属性值"+atts.getValue(i));
}
}

public void endElement(String namespaceURI,String localName,String fullName )throws SAXException
{
System.out.println("******元素解析结束********");
}
public void characters( char[] chars, int start, int length )throws SAXException
{
//将元素内容累加到StringBuffer中
buf.append(chars,start,length);
}

public static void main(String args[])
{
try{

SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
TestSAX testsax=new TestSAX();
sp.parse(new InputSource("D:\\test\\simpleTest\\classes\\simpleTest\\test.xml"),testsax);

}catch(IOException e)
{
e.printStackTrace();
}catch(SAXException e)
{
e.printStackTrace();
}catch(Exception e)
{
e.printStackTrace();
}



}
}
XML文件如下:
<?xml version="1.0" encoding="gb2312"?>
<row>
<person>
<name>wxh</name>
<college>xy</college>
<telephone>5214656</telephone>
<notes>565565</notes>
</person>
</row> 　

SevenCat

#ifndef __ZQ_COMMON_XERCESXMLP_H__
#define __ZQ_COMMON_XERCESXMLP_H__
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/parsers/AbstractDOMParser.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>
#include <xercesc/dom/DOMImplementationRegistry.hpp>
#include <xercesc/dom/DOMBuilder.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMNodeList.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMNamedNodeMap.hpp>
#include <xercesc/dom/DOMAttr.hpp>
#include <xercesc/dom/DOMnode.hpp>
#include <xercesc/util/XMLString.hpp>
using namespace XERCES_CPP_NAMESPACE;
#include <string>


namespace ZQ{
namespace common{

class XercesXmlNode
{
        friend class XercesXmlDomTree;
public:
        XercesXmlNode(){_node=NULL;}
        XercesXmlNode(DOMNode *node){_node=node;}
public:
        bool isValid(){return _node!=NULL;}
public:
        XercesXmlNode begin(){DOMNode *pnode=_node->getFirstChild();return XercesXmlNode(pnode);}
        XercesXmlNode end(){return XercesXmlNode(NULL);}
        XercesXmlNode back(){DOMNode *pnode=_node->getLastChild();return XercesXmlNode(pnode);}
        XercesXmlNode &operator++(int){_node=_node->getNextSibling();return *this;}
        XercesXmlNode &operator--(int){_node=_node->getPreviousSibling();return *this;}
        bool operator!=(XercesXmlNode &right){        return _node!=right._node;}

public:
        std::string getAttribute(const char *attrname);
        std::string getTextContent();
        std::string getName();
public:
        bool isElementNode();
private:
        DOMNode *_node;
};

class XercesXmlDomTree
{
public:
        typedef XercesXmlNode ChildIterator;
public:
        XercesXmlDomTree(){}
        bool open(const char *filename);
        void close();
public:
        ChildIterator begin();
        ChildIterator end();
private:
        DOMBuilder *_builder;
        DOMElement *_root;
};

}}//end of namespace

SevenCat

#include "XercesXmlP.h"

namespace ZQ{
namespace common{

class StrX
{
public :
        StrX(const XMLCh* const toTranscode){fLocalForm = XMLString::transcode(toTranscode);}
        ~StrX(){XMLString::release(&fLocalForm);}
        const char* localForm() const{        return fLocalForm;}
        operator const char* (){return fLocalForm;}
private :
        char *fLocalForm;
};

class StrY
{
public:
        StrY(const char *const toTranscode){fXmlch=XMLString::transcode(toTranscode);}
        ~StrY(){XMLString::release(&fXmlch);}
        const XMLCh *get_xmlch(){return fXmlch;}
        operator const XMLCh *(){return fXmlch;}
private:
        XMLCh *fXmlch;
};

bool XercesXmlDomTree:pen(const char *filename)
{
        try
        {
                XMLPlatformUtils::Initialize();
        }
        catch (...)
        {
                return false;
        }

        static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
        DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
        _builder=((DOMImplementationLS*)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);

        if(_builder==NULL)
                return false;

        XERCES_CPP_NAMESPACE:OMDocument *rootdoc=NULL;
        try
        {
                _builder->resetDocumentPool();
                rootdoc = _builder->parseURI(filename);
        }
        catch (...)
        {
                rootdoc=NULL;
        }

        if(rootdoc==NULL)
                return false;
       
        _root=rootdoc->getDocumentElement();
        return true;

}

void XercesXmlDomTree::close()
{
        if(_builder) _builder->release();
        XMLPlatformUtils::Terminate();
}

XercesXmlDomTree::ChildIterator XercesXmlDomTree::begin()
{
        DOMNode *pnode=_root->getFirstChild();
        return XercesXmlNode(pnode);
}

XercesXmlDomTree::ChildIterator XercesXmlDomTree::end()
{
        return XercesXmlNode(NULL);
}

//====================XercesXmlNode================
std::string XercesXmlNode::getAttribute(const char *attrname)
{
        const XMLCh* ret=((DOMElement *)_node)->getAttribute(StrY(attrname));
        return std::string(StrX(ret));
}

std::string XercesXmlNode::getTextContent()
{
        const XMLCh *nodevalue=_node->getTextContent();
        return std::string(StrX(nodevalue));
}

std::string XercesXmlNode::getName()
{
        const XMLCh *nodename=_node->getNodeName();
        return std::string(StrX(nodename));
}

bool XercesXmlNode::isElementNode()
{
        return _node->getNodeType()==DOMNode::ELEMENT_NODE;
}

}}//end of namespace

SevenCat

#ifndef __ZQ_COMMON_MSXMLNODE_H__
#define __ZQ_COMMON_MSXMLNODE_H__
#include <MsXml2.h>
#include <comutil.h>
#include <string>

namespace ZQ{
namespace common{

#define DEFAULT_XMLL_BUFFER

/**MBCS to unicode conversion*/
class StrX
{
public:
        StrX(const char *str)
        {
                size_t strsize=strlen(str);
                _newstr=new WCHAR[strsize+2];
                mbstowcs(_newstr,str,(strsize+2)*2);
        }
        ~StrX(){delete _newstr;}
        WCHAR *getWchar(){return _newstr;}
private:
        WCHAR *_newstr;
};

/**Unicode to MBCS conversion*/
class StrY
{
public:
        StrY(const WCHAR *wstr)
        {
                size_t wstrsize=2*(wcslen(wstr));
                _newstr=new char[wstrsize+4];
                wcstombs(_newstr,wstr,wstrsize+4);
        }
        ~StrY(){delete _newstr;}
        char *getChar(){return _newstr;}
private:
        char *_newstr;
};

//damn com, i dislike it.
/**wrap of xmlNode*/
class MsXmlNode
{
public:
        /**
        default ctor,DON"T use it
         */
        MsXmlNode();

        /**
        ctor
         */
        MsXmlNode(IXMLDOMNode *pnode);

        /**
        copy ctor
         */
        MsXmlNode(const MsXmlNode &rhs);

        /**
        copy ctor
         */
        MsXmlNode &operator=(const MsXmlNode &rhs);

        /**
        dtor, release com pointer
         */
        ~MsXmlNode();

        /**
        @return first child node
         */
        MsXmlNode begin()const;

        /**
        @return NULL node
         */
        static MsXmlNode end();

        /**
        @return last child node (may be NULL node)
         */
        MsXmlNode back()const;

        /**like std::iterator*/
        MsXmlNode &operator++(int)
        {
                IXMLDOMNode *pnode=NULL;
                _pnode->get_nextSibling(&pnode);
                _pnode->Release();
                _pnode=pnode;
                return *this;
        }

        /**like std::iterator*/
        MsXmlNode &operator++()
        {
                IXMLDOMNode *pnode=NULL;
                _pnode->get_nextSibling(&pnode);
                _pnode->Release();
                _pnode=pnode;
                return *this;
        }

        /**like std::iterator*/
        MsXmlNode &operator--(int)
        {
                IXMLDOMNode *pnode=NULL;
                _pnode->get_previousSibling(&pnode);
                _pnode->Release();
                _pnode=pnode;
                return *this;
        }

        /**like std::iterator*/
        MsXmlNode &operator--()
        {
                IXMLDOMNode *pnode=NULL;
                _pnode->get_previousSibling(&pnode);
                _pnode->Release();
                _pnode=pnode;
                return *this;
        }

        bool operator!=(const MsXmlNode &right){return _pnode!=right._pnode;}

        bool operator==(const MsXmlNode &right){return _pnode==right._pnode;}

        bool isValid()const{return _pnode!=NULL;}

public:

        /**
        internal use!!!
         */
        MsXmlNode &next();

        /**
        @return node's name
         */
        std::string getName()const;

        /**
        TODO:return node type directly?
         */
        bool isElementNode()const;

        std::string getAttribute(const char *attrname)const;

        /**
        @return node with given name (may return NULL node)
         */
        MsXmlNode findNodeByName(const char *nodename)const;

//        std::string getTextContent();

private:
        IXMLDOMNode *_pnode;
};
}}

SevenCat

#include "MsXmlNode.h"
namespace ZQ{
        namespace common{

MsXmlNode::MsXmlNode()
{
        _pnode=NULL;
}

MsXmlNode::MsXmlNode(IXMLDOMNode *pnode)
{
        _pnode=pnode;
}

MsXmlNode::MsXmlNode(const MsXmlNode &rhs)
{
        _pnode=rhs._pnode;
        _pnode->AddRef();
}


MsXmlNode::~MsXmlNode()
{
        if(_pnode)
                _pnode->Release();
}

MsXmlNode &MsXmlNode::next()
{
        IXMLDOMNode *pnext=NULL;
        _pnode->get_nextSibling(&pnext);
        _pnode=pnext;
        return *this;
}


std::string MsXmlNode::getName()const
{
        WCHAR *pname=NULL;
        HRESULT hr=_pnode->get_nodeName(&pname);
        if(!SUCCEEDED(hr)) return std::string("");
        StrY str(pname);
        return std::string(str.getChar());
}

bool MsXmlNode::isElementNode()const
{
        DOMNodeType nodetype;
        HRESULT hr=_pnode->get_nodeType(&nodetype);
        if(!SUCCEEDED(hr)) return false;
        return nodetype==NODE_ELEMENT;
}

std::string MsXmlNode::getAttribute(const char *attrname)const
{
        static const CLSID ClsId = {0x2933bf86, 0x7b36, 0x11d2, {0xb2, 0x0e, 0x00, 0xc0, 0x4f, 0x98, 0x3e, 0x60}};
        IXMLDOMElement *pelement=NULL;
        HRESULT hr=_pnode->QueryInterface(ClsId,(void**)&pelement);
        //this node is not element node!!!
        if(!SUCCEEDED(hr)) return std::string("");
        StrX strname(attrname);
        VARIANT varO;
        VariantInit(&varO);
        hr=pelement->getAttribute(strname.getWchar(),&varO);
        if(!SUCCEEDED(hr))
        {
                pelement->Release();
                return std::string("");
        }
        WCHAR *ret=(WCHAR*)varO.pbstrVal;
        if(ret==NULL)
        {
                pelement->Release();
                return std::string("");
        }
        else
        {
                StrY retname(ret);
                pelement->Release();
                return std::string(retname.getChar());
        }
}

MsXmlNode MsXmlNode::begin()const
{
        IXMLDOMNode *pnode=NULL;
        _pnode->get_firstChild(&pnode);
        return MsXmlNode(pnode);
}

MsXmlNode MsXmlNode::end()
{
        return MsXmlNode(NULL);
}

MsXmlNode MsXmlNode::back()const
{
        IXMLDOMNode *pnode=NULL;
        _pnode->get_lastChild(&pnode);
        return MsXmlNode(pnode);
}

MsXmlNode MsXmlNode::findNodeByName(const char *nodename)const
{
        for(MsXmlNode node=begin();node!=end();node++)
                if(node.getName()==nodename) return node;
        return MsXmlNode(NULL);
}

}}

SevenCat

public static void writeConfig()
                {
                        XmlTextWriter writer = null;
                        try
                        {
                               
                                writer = new XmlTextWriter(configFileName,System.Text.Encoding.Unicode);
                                writer.Formatting = Formatting.Indented;

                                writer.WriteStartDocument();
                                writer.WriteStartElement("SasunVod");

                                writer.WriteElementString("mac_name",macName);
                                writer.WriteElementString("media_server_name",mediaServerName);
                                writer.WriteElementString("media_template",mediaTemplate);
                                writer.WriteElementString("media_push_server_port",mediaPushServerPort.ToString());
                                writer.WriteElementString("database_server_name",databaseServerName);
                                writer.WriteElementString("ftp_server",ftpServer);
                                writer.WriteElementString("ftp_port",ftpPort.ToString());
                                writer.WriteElementString("ftp_user_name",ftpUsername);
                                writer.WriteElementString("ftp_password",ftpPassword);
                                writer.WriteElementString("ftp_remote_dir",ftpRemotedir);
                                writer.WriteElementString("broadcast_file_name",broadCastFileName);

                                writer.WriteEndElement();
                                writer.WriteEndDocument();
                                writer.Close();
                        }
                        catch(Exception excep)
                        {
                                gLogger.WriteLine(excep.ToString());
                        }
                }