×
Namespaces

Variants
Actions

Manipulando arquivos XML com a API NanoXML

From Nokia Developer Wiki
Jump to: navigation, search
Article Metadata

Exemplo de código
Artigo
Tradução:
Por thiagobrunoms
Última alteração feita por lpvalente em 05 Oct 2013

A linguagem de marcação XML (acrônimo de eXtensible Markup Language) é bastante utilizada para descrever formatos de dados baseado em árvore. Esta linguagem tem sido bastante utilizada para permitir interoperabilidade entre diferentes tipos de aplicações e plataformas através do compartilhamento de dados semi-estruturados. Na plataforma JavaME, existem diversas APIs para minipular conteúdos XML. Este artigo mostra algumas dessas alternativas.

Apesar de existir diversas soluções para minipulação de conteúdos XML para a plataforma JavaME, a API NanoXML parece ser a mais fácil (na minha opnião, apesar da falta de uma boa documentação!).

A melhor maneira de entender como utilizar o NanoXML é através de exemploes. Considere a seguinte estrutura XML:

<BreakFast_Menu>
<food Type="Mass">
<name>Macaroni</name>
<price>3.0</price>
<description>Fetucinni</description>
<calories>213</calories>
</food>
<food Type="desert">
<name>chocolat</name>
<price>6.0</price>
<description>laka</description>
<calories>334</calories>
</food>
</BreakFast_Menu>

O exemplo acima descreve um cardápio contendo dois tipos de alimento (massa e um tipo de sobremesa). Através da API NanoXML, mostrarei como criar e ler um arquivo XML com esta estrutura de dados. No código abaixo é descrito como criar o arquivo XML. Para cada novo alimento, cria-se um elemento "filho" e adiciona-o no elemento principal (objeto mainElement):

//Cria um novo nó
private kXMLElement createElement(String name, String str) {
kXMLElement element = new kXMLElement(name); //adiciona o nome do nó
element.setContent(str); //adiciona o conteúdo ao nó corrente
return element;
}
 
//Adiciona um novo nó (elemento) na árvore XML
public void addNode(String foodName, double price, ...) {
kXMLElement child = new kXMLElement("food"); //Cria uma referência para um nó
 
//O método addChild adiciona um novo filho ao nó de referência
child.addChild(createElement("name", foodName));
child.addChild(createElement("price", String.valueOf(price)));
child.addChild(createElement("description", description));
child.addChild(createElement("calories", String.valueOf(calories)));
 
child.addProperty(type, typeName); //adiciona um atributo ao nó
mainElement.addChild(child); //adiciona o nó ao elemento (nó) principal
}
... ....
 
addNode("Macaroni", ...);
addNode("Chocolat", ...);

Para salvar este arquivo XML, utilizei a JSR 75 (FileConnection API).

private void initFileSystem() {
connection = (FileConnection)Connector.open("file:///"+
rootFileSystem+"Foods/");
if(!connection.exists())
connection.mkdir(); //cria uma nova pasta
 
connection = (FileConnection) Connector.open("file:///"+
rootFileSystem+"Foods/food.xml", Connector.READ_WRITE);
if(!connection.exists())
connection.create(); //cria um novo arquivo caso não exista
}
 
private void save() {
try {
OutputStream out = connection.openOutputStream();
out.write(mainElement.toString().getBytes());
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}

Para recuperar o arquivo salvado, faz-se necessário apenas abrir uma stream de leitura e aplicar os dados lido a uma referência kXMLElement, como mostrado a seguir:

//Através do método parseFromReader, 
//o conteúdo é carregado a intância do nó principal do conteúdo XML
private readFile() {
mainElement.parseFromReader(new InputStreamReader(
connection.openInputStream()));
}
 
//Ler recursivamente o conteúdo do arquivo XML
public void readMenu(kXMLElement element) {
Enumeration e = element.enumerateChildren();
 
kXMLElement childElement = null;
while(e.hasMoreElements()) {
childElement = (kXMLElement) e.nextElement();
if(childElement.getTagName().equals("food")) {
this.formView.append(new StringItem("Tipo",
childElement.getProperty("Tipo")));
readMenu(childElement);
} else {
this.formView.append(new StringItem(
childElement.getTagName(), childElement.getContents()));
}
}
}

Os métodos getTagName() e getContents() methods retornam o nome da tag XML ("name", "price", "calories") e os respectivos valores. Por outro lado, o método childElement.getProperty(String) retorna um valor de atributo de uma tag XML ("desert" ou "mass", por exemplo).

Example1NanoXML.jpg

Um outro exemplo objetiva criar um arquivo XML através de um texto "codificado" em XML (ou seja, um texto com estruturas em XML). Considere o seguinte conteúdo XML:

<person>
<name>Thiago</name>
<age>23</age>
</person>

Ao obter um texto com estruturas em XML, para recuperar cada informação considerando a estrutura do conteúdo XML utilizando NanoXML é mostrado a seguir:

public class Example2 extends MIDlet {
 
private Display d;
private Form f;
 
public Example2() {
d = Display.getDisplay(this);
f = new Form("Person");
 
kXMLElement element = new kXMLElement();
// Este texto está formatado numa estrutura XML. Este pode-se, por exemplo, ter sido
// recuperado da Web
element.parseString("<person><name>Thiago</name><age>23</age></person>");
 
 
Enumeration elements = element.enumerateChildren();
while(elements.hasMoreElements()) {
kXMLElement e = ((kXMLElement)elements.nextElement());
String tag = e.getTagName();
f.append(new StringItem(tag, e.getContents()));
}
 
}
 
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {}
protected void pauseApp() {}
 
protected void startApp() throws MIDletStateChangeException {
this.d.setCurrent(this.f);
}
 
}

O resultado deste exemplo é:

Example2NanoXML.png

Os exemplos apresentados aqui estão disponíveis em: File:ExampleNanoXML.zip

This page was last modified on 5 October 2013, at 02:50.
90 page views in the last 30 days.
×