O que é Simple?

Simple é uma estrutura Java usada para simplificar o processo de serialização e desserialização XML. Ao usar o Simple, os desenvolvedores podem simplificar (por isso o nome) o processo de conversão de antigos objetos Java simples (POJOs) em documentos XML—um processo conhecido como serialização. O Simple também facilita a reversão: os desenvolvedores podem converter documentos XML em POJOs—um processo conhecido como desserialização.

O Simple corresponde ao seu nome usando anotações para possibilitar o processo de serialização ou desserialização. Os POJOs são anotados de acordo com como o documento XML correspondente deve aparecer. Alguns campos são anotados como atributos. Outros campos são anotados como elementos. A classe geralmente é anotada com o elemento-raiz. A estrutura lida com o tedioso processo de interpretar as anotações e produzir um documento XML correspondente durante o processo de serialização. Não é surpresa que as anotações também são interpretadas durante o processo de desserialização quando um documento XML é convertido em um POJO.

O uso do Simple tem muitas vantagens. Primeiro, ele facilita o rápido desenvolvimento de aplicativo. Pelo fato de o Simple ser tão simples, possibilita aos desenvolvedores implementar rapidamente aplicativos robustos que usam serialização e desserialização XML sem comprometer um gasto adicional de curva de aprendizado.

Depois, o Simple não precisa de configuração. Como mencionado previamente, o Simple usa anotações. Essas anotações estão no lugar dos arquivos de configuração baseados em XML que geralmente acompanham estruturas desta natureza.

Finalmente, o Simple agrega pouco à área de cobertura de aplicativos que o usam. O arquivo Java Archive (JAR) tem somente 239 kilobytes. O Simple também não depende de uma série de outros arquivos JAR, como é frequentemente o caso de estruturas concorrentes.

Obtendo o Simple

Antes de usar o Simple, você deve primeiro obtê-lo indo até o Web site do Simple listado em Recursos e fazer o download do archive. Porém, há uma boa e uma má notícia quanto a este processo. A boa notícia é que o archive é gratuito. A má notícia é que o arquivo está no formato .tar.gz. Assim, se você está contando com o extrator de archive nativo do Microsoft® Windows® para abrir este archive, você ficará desapontado. Você precisa do WinZip ou de outro utilitário de archive similar.

Após extrair os arquivos, observe que no diretório JAR existe, não surpreendentemente, um arquivo JAR (simple-xml-2.1.4.jar). Este é o arquivo JAR que é necessário no seu caminho de classe no tempo de compilação e tempo de execução.

Serializando

Serializar um objeto em um documento XML é um (surpresa!) processo simples. Este envolve duas etapas:

1. Criar o POJO com as anotações apropriadas.
2. Escrever algumas linhas de código que, de fato, executam o processo de serialização.

Para os propósitos deste artigo, você revisita o tema familiar (ao menos, familiar aos leitores dos meus artigos) das "iscas". Assim, A Lista 1 é um POJO que representa informações sobre iscas.

@Root
public class Lure {

     @Attribute
     private String type;
	
     @Element
     private String company;
	
     @Element
     private int quantityInStock;
	
     @Element
     private String model;

     public String getType() {
		return type;
     }

     public void setType(String type) {
          this.type = type;
     }

     public String getCompany() {
          return company;
     }

     public void setCompany(String company) {
          this.company = company;
     }

     public int getQuantityInStock() {
          return quantityInStock;
     }

     public void setQuantityInStock(int quantityInStock) {
          this.quantityInStock = quantityInStock;
     }

     public String getModel() {
          return model;
     }

     public void setModel(String model) {
          this.model = model;
     }
}

De fato, não há nada complicado sobre esse POJO. As únicas partes dele que podem não parecer familiar inicialmente são as anotações. Novamente, isso é intencional. Lembre-se de que a estrutura do Simple deve corresponder ao seu nome.

A anotação @Root descreve o elemento-raiz do documento XML. Porque cada documento XML necessita de um elemento-raiz, é importante que você inclua isto.

A anotação @Attribute acima do campo type identifica esse elemento como um atributo. Este atributo é incluído como um atributo no elemento-raiz.

O restante das anotações são anotações @Element . Elas ocorrem logo acima de três campos: company, quantityInStock, e model. Esses campos representam elementos dentro do documento XML.

O restante do POJO é composto de acessadores e mutadores de acordo com padrões JavaBean.

Agora que o POJO está completo, é hora de escrever o código de serialização. Consulte a Lista 2 para esse código.

public static void main(String[] args) {
     try {
          Serializer serializer = new Persister();
          Lure lure = new Lure();
          lure.setCompany("Donzai");
          lure.setModel("Marlin Buster");
          lure.setQuantityInStock(23);
          lure.setType("Trolling");
		
          File result = new File("lure.xml");
          serializer.write(lure, result);
     } catch (Exception e) {
          e.printStackTrace();
     }
}

A primeira coisa a fazer é instanciar um objeto Persister . Observe que esta classe faz parte da estrutura Simple e implementa a interface Serializer .

Em seguida, você instancia o objeto Lure e configura os campos apropriadamente. Neste caso, o nome da empresa que fabrica a isca é Donzai O nome do modelo é Marlin Buster. A quantidade em estoque é 23. Finalmente, o tipo de isca é Trolling.

Depois, você instancia um objeto File com o nome do arquivo que será o documento XML. Neste caso, esse nome é lure.xml.

Finalmente, você invoca o serializador para gravar o arquivo. Existem dois parâmetros fornecidos no método write() . O primeiro parâmetro é o POJO. O segundo parâmetro é o objetoFile .

Agora você pode executar este código. Lista 2 é um aplicativo Java, assim você pode usar o seu ambiente de desenvolvimento integrado (IDE) favorito para executá-lo. Certifique-se de que o simple-xml-2.1.4.jar está em seu caminho de classe. Se estiver usando o Eclipse, é possível simplesmente dar um clique com o botão direito do mouse sobre o arquivo, selecionar Run As, e depois selecionar Java Application no menu que aparece.

Se tudo funcionou (e deve ter funcionado—isso é simples, lembra?), então o documento XML restante deve se parecer com a Lista 3.

<lure type="Trolling">
   <company>Donzai</company>
   <quantityInStock>23</quantityInStock>
   <model>Marlin Buster</model>
</lure>

Observe duas coisas sobre a Lista 3. Primeiro, observe que o tipo de isca é um atributo do elemento-raiz. Isso faz sentido porque você anotou o campo type no POJO com @Attribute em oposição a @Element.

Outro ponto importante sobre o XML resultante é que os nomes de elementos seguem os padrões JavaBean. Por exemplo, o elemento-raiz é lure, apesar do nome da classe ser Lure. Os tês nomes do elemento filho correspondem perfeitamente aos nomes de campo. Novamente, isto é pragmático porque você não deseja que o nome do elemento-raiz esteja em caixa alta ou baixa enquanto os nomes dos filhos seguem um padrão diferente.

Desserializando

Porque serializar um objeto é tão fácil, desserializar um também deveria ser, certo? Certo!

Lembre-se que a desserialização é o processo de conversão de um documento XML em um POJO. A boa notícia é que você pode usar o documento XML que acabou de criar para este propósito.

A Lista 4 mostra o código de desserialização.

public static void main(String[] args) {
     try {
          Serializer serializer = new Persister();
          File source = new File("lure.xml");
          Lure lure = serializer.read(Lure.class, source);

          System.out.println(lure.getCompany());
          System.out.println(lure.getModel());
          System.out.println(lure.getQuantityInStock());
          System.out.println(lure.getType());
     } catch (Exception e) {
          e.printStackTrace();
     }
}

Novamente, você inicia instanciando um objeto (Persister) que implementa a interface Serializer .

Outra linha familiar é a instanciação do objeto File . Porém, aqui existe uma diferença distinta. Na Lista 3, você instanciou um objeto File para um arquivo que não existia. Aqui, supõem-se (e, de fato, este deve ser o caso) que o arquivo não existe.

A seguir, você instancia o POJO invocando o método read a partir do objeto Serializer . O método read assume dois parâmetros: a classe do POJO e o objeto File que representa o arquivo XML que contém os dados.

Finalmente, você imprime todas as informações do POJO para assegurar que tudo foi lido corretamente.

Ao executar este código, sua saída deve se parecer com a Lista 5.

Donzai
Marlin Buster
23
Trolling

Serializações de árvore integrais

Até aqui, o documento XML que você serializou e desserializou foi razoavelmente (surpresa!) simples.

A maioria dos documentos XML são bem mais complicados. Geralmente eles possuem camadas de elementos aninhados e, em alguns casos, de um a muitos elementos repetidos com vários elementos filhos cada um.

Felizmente, o Simple continua a fazer jus ao seu nome mesmo com documentos mais complexos. É tão simples quanto aninhar um POJO dentro de um POJO. Dê uma olhada na Lista 6.

@Attribute
private String type;

@Element
private String company;
	
@Element
private int quantityInStock;
	
@Element
private String model;
	
@Element
private ConfigurationScheme configurationScheme;

A classe AdvancedLure na Lista 6 é notavelmente similar à classe Lure descrita na Lista 1. A única exceção é a inclusão de outro campo: configurationScheme. O esquema de configuração é representado por outro POJO que é descrito na Lista 7.

@Root
public class ConfigurationScheme {
	
@Element
private String color;
	
@Element
private int size;

Em prol da brevidade, eu deixei os acessadores e os mutadores.

As anotações na Lista 7 devem parecer familiares. Elas são as mesmas anotações que foram usadas na Lista 1.

E isso o leva à Lista 8.

public static void main(String[] args) {
     try {
          Serializer serializer = new Persister();
          AdvancedLure lure = new AdvancedLure();
          lure.setCompany("Donzai");
          lure.setModel("Marlin Buster");
          lure.setQuantityInStock(23);
          lure.setType("Trolling");
			
          ConfigurationScheme configurationScheme = new ConfigurationScheme();
          configurationScheme.setColor("Blue");
          configurationScheme.setSize(3);
          lure.setConfigurationScheme(configurationScheme);
			
          File result = new File("advancedlure.xml");
          serializer.write(lure, result);
     } catch (Exception e) {
          e.printStackTrace();
     }
}

A grande diferença entre a Lista 8 e a Lista 2 é que você instancia um objeto ConfigurationScheme e configura o campo apropriado no objeto AdvancedLure .

Ao executar este código, a saída deve se parecer com a Lista 9.

<advancedLure type="Trolling">
   <company>Donzai</company>
   <quantityInStock>23</quantityInStock>
   <model>Marlin Buster</model>
   <configurationScheme>
      <color>Blue</color>
      <size>3</size>
   </configurationScheme>
</advancedLure>

Como você pode ver, os elementos aninhados são serializados exatamente de acordo com suas expectativas.

Enumerações

Frequentemente, os documentos XML contêm enumerações de certos elementos. Isto é, o mesmo nome de elemento se repete, embora com diferentes dados de atributo ou dados filhos. Felizmente, o Simple pode lidar bem com esta situação.

Você cria uma nova classe, com o propósito de demonstrar este recurso, chamadaInventory, que contém o nome do armazém no qual o inventário está localizado e uma lista de iscas localizadas neste local de inventário, como na Lista 10.

@Root
public class Inventory {
	
     @ElementList
     private List<AdvancedLure> lures;
	
     @Attribute
     private String warehouse;

Observe que você usa uma nova anotação: @ElementList. Esta anotação informa à estrutura do Simple que o objeto List representa uma eumeração de elementos XML.

O código usado para demonstrar a serialização deste POJO é tão fácil quando o código usado para serializar um POJO mais compacto, como aquele serializado na Lista 2. A única complexidade incluída na instanciação de todos os elementos necessários para propósitos de teste. Consulte a Lista 11.

Serializer serializer = new Persister();

AdvancedLure lure = new AdvancedLure();
lure.setCompany("Donzai");
lure.setModel("Marlin Buster");
lure.setQuantityInStock(23);
lure.setType("Trolling");
			
ConfigurationScheme configurationScheme = new ConfigurationScheme();
configurationScheme.setColor("Blue");
configurationScheme.setSize(3);
lure.setConfigurationScheme(configurationScheme);
			
			
AdvancedLure lure2 = new AdvancedLure();
lure2.setCompany("Ziggi");
lure2.setModel("Tuna Finder");
lure2.setQuantityInStock(44);
lure2.setType("Trolling");
		
ConfigurationScheme configurationScheme2 = new ConfigurationScheme();
configurationScheme2.setColor("Red");
configurationScheme2.setSize(5);
lure2.setConfigurationScheme(configurationScheme2);
			
List<AdvancedLure> lures = new ArrayList<AdvancedLure>();
lures.add(lure);
lures.add(lure2);
			
Inventory inventory = new Inventory();
inventory.setLures(lures);
inventory.setWarehouse("Midwest");
			
File result = new File("inventory.xml");

serializer.write(inventory, result);

Quando este código é executado, um arquivo XML chamado inventory.xml é criado. O conteúdo deste arquivo deve se parecer com a Lista 12.

<inventory warehouse="Midwest">
   <lures>
      <advancedLure type="Trolling">
         <company>Donzai</company>
         <quantityInStock>23</quantityInStock>
         <model>Marlin Buster</model>
         <configurationScheme>
            <color>Blue</color>
            <size>3</size>
         </configurationScheme>
      </advancedLure>
      <advancedLure type="Trolling">
         <company>Ziggi</company>
         <quantityInStock>44</quantityInStock>
         <model>Tuna Finder</model>
         <configurationScheme>
            <color>Red</color>
            <size>5</size>
         </configurationScheme>
      </advancedLure>
   </lures>
</inventory>

Como você pode ver, a saída imita perfeitamente o POJO que você instanciou e criou na Lista 11. Existem dois elementos advancedLure e cada um deles contém os dados que você usou para preencher os POJOs correspondentes. Observe que o aninhamento também é apropriado.

Construtores

É possível que o seu código use POJOs que sejam imutáveis. Neste caso, é possível abrir mão dos métodos setter para modificar as propriedades do campo e, em vez disso, confiar nos construtores para determinar esses valores. O Simple também pode lidar com esta situação.

Neste caso, as anotações são especificadas dentro dos parâmetros do construtor em vez de acima do nome do campo. As anotações também são necessárias acima dos métodos do acessador apropriados. Consulte a Lista 13.

public Inventory2(@ElementList(name="lures") List<AdvancedLure> lures,
 @Attribute(name="warehouse") String warehouse) {
     this.lures = lures;
     this.warehouse = warehouse;
}

@ElementList(name="lures")
public List<AdvancedLure> getLures() {
     return lures;
}

@Attribute(name="warehouse")
public String getWarehouse() {
     return warehouse;
}

Observe que ao especificar a anotação com parte dos parâmetros do construtor você também deve especificar o nome do campo ao qual ele corresponde. No caso do primeiro parâmetro, o nome do campo é lures. No caso do segundo parâmetro, o nome do campo é warehouse.

Depois, você fornece anotações e nomes de campo correspondentes acima dos métodos do acessador. Logo acima do getter para lures, é possível ver a anotação apropriada, que perfeitamente corresponde à anotação usada no construtor. Da mesma forma, a anotação acima do getter para warehouse corresponde perfeitamente à essa anotação.

Para executar este código, você modifica a Lista 11 apenas ligeiramente para incluir o código na Lista 14.

Inventory2 inventory = new Inventory2(lures,"MidWest");

Você usa o código na Lista 14 em vez dos métodos setter que você usou na Lista 11. Todo o restante permanece o mesmo.

Filtros de modelo

Outro grande recurso do Simple é sua habilidade de usar filtros de modelo ou valores padrão ao desserializar um documento XML.

Retorne ao lure.xml original, mas modifique-o ligeiramente, como na Lista 15.

<lure type="Trolling">
   <company>${lure.company}</company>
   <quantityInStock>23</quantityInStock>
   <model>Marlin Buster</model>
</lure>

Observe como o elemento da empresa não contém o nome de uma empresa real, mas em vez disso, uma declaração de variável parecida com Apache Ant. Neste caso, o nome da variável é lure.company.

Filtros de modelo permitem que você substitua a declaração de variável pelo valor real que você estabelece no tempo de execução. Uma maneira fácil de fazer isso é com um objeto Map que associa o nome da variável com seu valor. Então, você usa esse objeto Map para construir um objeto Filter a partir da estrutura do Simple. Depois, construa o objeto Persister usando esse objeto Filter . Dê uma olhada na Lista 16.

Map<String,String> map = new HashMap<String,String>();
map.put("lure.company", "Monmouth");
Filter filter = new MapFilter(map);
			
Serializer serializer = new Persister(filter);
File source = new File("lure2.xml");

Lure lure = serializer.read(Lure.class, source);

System.out.println(lure.getCompany());
System.out.println(lure.getModel());
System.out.println(lure.getQuantityInStock());
System.out.println(lure.getType());

A Lista 16 não se parece muito diferente da Lista 2. A principal diferença é que um HashMap que é instanciado associa uma valor String a uma chave String . A chave String neste caso é previsivelmente lure.company, que é o nome da variável que você usou na Lista 15. Aqui você dá a ela um valor de Monmouth em oposição a Donzai, que foi o valor no documento XML que você leu anteriormente.

Quando este código é executado, a saída deve se parecer com a Lista 17.

Monmouth
Marlin Buster
23
Trolling

Como você pode ver, o fitro do modelo substitui o nome da variável lure.company pelo valor real associado com o nome da chave no objeto Map . A saída é exatamente conforme o esperado.

Conclusão

Como você viu, o Simple é uma estrutura de serialização e desserialização XML robusta. Ela é fácil de usar, não necessita de configuração e agiliza o desenvolvimento.

Existem muito mais recursos poderosos do Simple. Porém, devido a restrições de espaço, somente alguns deles podem ser explorados aqui. Eu fortemente recomendo que os desenvolvedores que necessitam de serialização e desserialização XML dentro de suas iniciativas de desenvolvimento de software considerem o Simple para este propósito.

Voltar para parte superior

Download

Informações sobre métodos de download

Recursos

Aprender

• Tutorial XML: Experimente este tutorial no w3schools.com se você acabou de iniciar com o XML.
  
  
• Os Tutoriais Java: Aprofunde-se nas informações deste site se você acabou de iniciar com a linguagem de programação Java.
  
  
• O básico do XML para novos usuários: Uma introdução à marcação adequada (Kay Whatley, developerWorks, fevereiro de 2009): Se você é novo no XML, este artigo introduz a construção básica dos documentos XML assim como as regras que você deve seguir para criar XML bem formado, incluindo convenções de nomeação, aninhamento de tag adequado, diretrizes de atributo, declarações e entidades. Você também obterá um entendimento da validação em termos de ambos os usos, DTD e esquema.
  
  
• Introdução ao XML (Doug Tidwell, developerWorks, agosto de 2002): Saiba o que é XML e porque ele foi desenvolvido. Neste tutorial, você também abrange uma variedade de interfaces importantes e padrões de programação XML, e termina com dois estudos de caso mostrando como as empresas estão usando XML para resolver problemas de negócios.
  
  
• Novo para a programação Java: Obtenha uma visão geral do básico da tecnologia Java e como a tecnologia se ajusta no desenvolvimento de software contemporâneo. Investigue links para conteúdo introdutório relevante ao developerWorks, outros recursos educacionais, mais downloads e produtos IBM.
  
  
• Novo no XML: Visite este excelente ponto de início para recursos disponíveis a desenvolvedores XML no IBM developerWorks.
  
  
• Certificação XML da IBM: Descubra como se tornar um Desenvolvedor Certificado IBM em XML e tecnologias relacionadas.
  
  
• Biblioteca técnica de XML: Consulte a zona XML do developerWorks para uma ampla variedade de artigos técnicos e dicas, tutoriais, padrões e IBM Redbooks.
  
  
• Eventos técnicos e webcasts do developerWorks: Mantenha-se atualizado com a tecnologia nessas sessões.
  
  
• Podcasts do developerWorks: Ouça entrevistas e discussões interessantes para desenvolvedores de software.
  
  

Obter produtos e tecnologias

• Simple: Faça o download do Simple e saiba mais sobre ele.
  
  
• Eclipse: faça o download e instale o Eclipse a partir do Web site do Eclipse.
  
  
• Versões de avaliação de produto IBM: Faça o download ou explore as versões de avaliação disponíveis on-line no IBM SOA Sandbox e adquira as ferramentas de desenvolvimento de aplicativo e produtos de middleware do DB2®, Lotus®, Rational®, Tivoli®, e WebSphere®.
  
  

Discutir

• Participar do fórum de discussão.
  
  
• Fóruns de discussão da zona XML: Participe de qualquer uma das discussões relacionadas a XML.
  
  
• Blogs do developerWorks: Confira esses blogs e envolva-se.
  
  

Sobre o autor

Brian Carey é um consultor de sistemas de informação especializado na arquitetura, design e implementação de aplicativos corporativos Java.

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• O que é Simple?
• Obtendo o Simple
• Serializando
• Desserializando
• Serializações de árvore integrais
• Enumerações
• Construtores
• Filtros de modelo
• Conclusão
• Download
• Recursos
• Sobre o autor
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais