Java – Persistência com XML

Uma maneira bem simples de trabalhar com XML em java.
Esta maneira utiliza a biblioteca javax.xml.bind.

Este modo de trabalho com XML é simples pois ele trabalha com sua estrutura de objetos usando annotations,
você define toda sua estrutura de xml de acordo com seus objetos.

Exemplo:

Objeto A{
List B b;
}

Objeto B{
String nome;
String telefone;
}

Main{
a = novo A;
a.add(novo B(teste1,1111111111));
a.add(novo B(teste2,1111111111));
gravarEmXML(a);
}

XML:

< a >
 < b >
 < nome > teste1 < / nome >
    < telefone > 1111111111 < / telefone >
    < / b >
 < b >
    < nome > teste2 < / nome >
    < telefone > 1111111111 < / telefone >
 < / b >
< / a >

Simples não? tendo o XML também pode-se fazer o inverso:

Main{
a = pegarXML();
//seu objeto A já vai estar com os dados teste1 e teste2 conforme você gravou.
}

Porem você deve usar as tag’s annotations em seus objetos como no exemplo abaixo seguindo o mesmo raciocínio:

Objeto Agenda:

//Define que é a TAG pai
@XmlRootElement(name = "AGENDA")
//Estou definindo que só sera gravado os campos anotados.
@XmlAccessorType(XmlAccessType.NONE)
public class ObAgenda {

    //Defino um array de elementos do tipo ObContato com a TAG CONTATO
    @XmlElements(
    @XmlElement(name = "CONTATO", type = ObContato.class))
    private ArrayList contatos;

    public ObAgenda() {
        this(new ArrayList());
    }

    public ObAgenda(ArrayList contatos) {
        this.contatos = contatos;
    }

    public ArrayList getContatos() {
        return contatos;
    }

    public void setContatos(ArrayList contatos) {
        this.contatos = contatos;
    }
}

Objeto contato:

@XmlAccessorType(XmlAccessType.NONE)
public class ObContato {

    @XmlElement(name = "NOME")
    private String nome;
    @XmlElement(name = "RESIDENCIAL")
    private String residencial;

    public ObContato() {
        this.nome = "";
	this.residencial = "";
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getResidencial() {
        return residencial;
    }

    public void setResidencial(String residencial) {
        this.residencial = residencial;
    }
}

Existe varias anotações que pode incrementar sua estrutura XML,
Segue um link aonde explica todas as anotações :

http://www.caucho.com/resin-3.1/doc/jaxb-annotations.xtp

Essa é a parte mais importante.
Para a penúltima etapa temos que criar o controle do xml, abaixo segue o código que criei responsável por esse controle.
O Código está simples e documentado, acredito que da para entender perfeitamente.

package agenda.persistencia.xml;

import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

/**
 *
 * @author guilherme
 */
public class ControlerXML {

    private Marshaller marshaller;
    private Unmarshaller unmarshaller;

    public ControlerXML(Class... clas) throws JAXBException {
        //Cria uma instancia de JAXBContext, o parametro passado é a classe
        //principal que representa o seu xml.

        JAXBContext context = JAXBContext.newInstance(clas);

        //Marshaller é responsável por transcrever sua estrutura de objetos em xml

        marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        //Unmarshaller é responsável por transcrever seu xml na sua estrutura de objetos

        unmarshaller = context.createUnmarshaller();
    }

    /**Converte a extrutura de objetos em xml;
     *
     * @throws JAXBException
     */
    public void object_to_Xml(Object objeto, File arquivo) throws JAXBException {
        //Gravo minha estrutura de objetos no arquivo.
        marshaller.marshal(objeto, arquivo);
    }

    /**Converte o xml na extrutura de objetos;
     *
     * @throws JAXBException
     */
    public Object xml_to_Object(File arquivo) throws JAXBException {
        //Pego meu xml e converto para minha lista.
        return unmarshaller.unmarshal(arquivo);

    }
}

Para concluirmos segue a etapa de implementação:

    private File arquivoXml;
    private ControlerXML controlerXML;

    public PersistenciaXML() throws JAXBException, IOException {
 	controlerXML = new ControlerXML(ObAgenda.class);
	//Defino aonde o arquivo xml vai ser salvo de acordo com meu SO
        if (System.getProperties().getProperty("os.name").toUpperCase().startsWith("WINDOWS")) {
            arquivoXml = new File("c:/agenda.xml");
        } else if (System.getProperties().getProperty("os.name").toUpperCase().startsWith("LINUX")) {
            arquivoXml = new File("/home/guilherme/agenda.xml");
        }

	//Se o arquivo não existir eu crio um novo e gravo uma estrutura de agenda vazia.
        if (!arquivoXml.exists()) {
            arquivoXml.createNewFile();
            controlerXML.object_to_Xml(new ObAgenda(), arquivoXml);
        }
    }

    //TODO

Pronto agora tá facil né?.

Olha como ficou o XML depois que inseri alguns dados:

<!--?xml version="1.0" encoding="UTF-8" standalone="yes"?-->
< AGENDA >
    < CONTATO >
        < NOME > Joao < / NOME >
	< RESIDENCIAL > 1111 < / RESIDENCIAL>
    < / CONTATO >
    < CONTATO >
        < NOME > Guilherme < / NOME >
        < RESIDENCIAL > 333 < / RESIDENCIAL>
    < / CONTATO >
< / AGENDA >

FONTE IMAGEM: http://techmindviews.blogspot.com/2010/04/xml-xsd-java-jaxb-xjc.html