Olá, pessoal! O artigo de hoje vai mostrar como popular um banco de dados quando os seus dados estão em um arquivo XML. Se você ainda não precisou realizar essa operação no seu trabalho, não se preocupe que o momento vai chegar.

Existem várias formas de fazer a leitura do arquivo XML e popular o banco. Para este artigo, eu escolhi o Xstream e o Hibernate – eu costumo usar o Hibernate por padrão, e o Xstream é, de fato, uma boa API. Há também a SAPX, mas essa eu não cheguei a testar.

Requisitos

Você vai precisar de:

• Java 5/superior;
• Hibernate 3/Superior;
• Eclipse;
• Xstream : faça o download da API;
• MySql.

Iniciando

Para começar, você precisa criar um Java Project no seu Eclipse e ter as bibliotecas do Hibernate adicionadas ao projeto. Não se esqueça de adicionar os .jars do MySql e do Xstream (apenas xstream-1.3.1.jar). Abaixo, temos o nosso banco vazio, aguardando os dados do XML.

Vamos usar as annotations para o mapeamento do nosso bean com o Hibernate – se tiver dúvidas de como fazer isso, faça uma busca nos artigos mais antigos meus no iMasters. Falo bastante sobre Hibernate com annotations. 

A seguir, temos a imagem de como vai ficar nosso projeto. Você já pode adicionar as classes e as bibliotecas. Ao decorrer do artigo, vamos apresentando os códigos relevantes.

Antes de mais nada, faça o download do arquivo XML que possui os dados dos usuários que vamos popular. Adicione-o, também, à raiz do projeto. Para fazer isso, basta clicar com o botão direito no projeto, escolher importar ==> File System e buscar pelo arquivo XML no seu computador.

Baixar o usuarios.xml 

Note que no arquivo usuarios.xml não temos o campo id para representar a coluna no banco, uma vez que este será gerado de forma automática. Então, ao abrir o arquivo, sentirá falta dele.

Resolvi colocar poucos dados no XML só para teste.

Acima temos a imagem do projeto atualizado com o arquivo xml. Bom, acho que até aqui estamos bem. Na próxima etapa, vamos trabalhar com os codes das classes.

Desenvolvimento

Primeiramente, você deve criar o Bean, ou seja, a classe Usuario, e fazer as devidas anotações, conforme o code abaixo. Remove os gets/sets, para poupar espaço:

@Entity
@Table
public class Usuario {
 @Id
 @GeneratedValue
 private int id;
 @Column
 private String nome;
 @Column
 private String  email;
 @Column
 private String senha;
 @Column
 private String  tipo;

Agora, configure o seu arquivo hibernate-cfg.xml com os dados de conexão do seu banco. Não se esqueça de definir o mapping para a classe bean, veja como ficou o meu:

Agora, vamos criar os métodos para persistência em nossa classe HibernateDAO, ficando assim:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateDAO {
 private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
 private static final SessionFactory sessionFactory = new AnnotationConfiguration()
   .configure().buildSessionFactory();

 public Session getSession() {
  Session session = threadLocal.get();
  if (session == null) {
   session = sessionFactory.openSession();
  }
  return session;
 }

 public void begin() {
  getSession().beginTransaction();
 }

 public void commit() {
  getSession().getTransaction().commit();
 }

 public void rollBack() {
  getSession().getTransaction().rollback();
 }
 public void close() {
  getSession().close();
 }}

Agora vamos atualizar a classe UsuarioDAO, que é a classe que solicita que a persistência aconteça.

public class UsuarioDAO extends HibernateDAO{

 public void create(List<Usuario> listUser){
  
  for (Usuario usuario : listUser) { 
   begin();
   getSession().save(usuario);
   try{
   commit();
   }catch (HibernateException e) {
    e.printStackTrace();
    rollBack();    
   }   
  }}}

Para quem já trabalha com Hibernate, nada de especial até aqui. Lembrando que o objetivo do artigo não é explicar Hibernate e, sim mostrar como popular dados de um xml no banco. Então, não vou entrar em detalhe sobre o code acima. Qualquer dúvida, basta consultar outros artigos meus aqui no iMasters, nos quais explico em detalhe o Hibernate.

Agora vamos atualizar a classe LerDadosXML:

public class LerDadosXML {
 private List<Usuario> listUsuario;  
 public List<Usuario> lerXml(Reader fonte){
  XStream stream = new XStream(new DomDriver());
  stream.alias("Usuario", Usuario.class);
  List<Usuario> fromXML = (List<Usuario>) stream.fromXML(fonte);  
 popularData(fromXML);
 return fromXML;
}

public void popularData(List<Usuario> listUsuario){
  new UsuarioDAO().create(listUsuario);
 } 
}

Bom, a única novidade que temos ai é o uso da API Xstream, que será responsável por ler os dados do xml. Para lê-los, como você pode ver, é bem simples: basta chamar xStream.fromXML(fonteOrigem);  no nosso caso, o local onde está o arquivo xml deverá ser passado para o argumento do método, mas poderíamos definir isso assim: readerFile = new FileReader(new File(“nomedoarquivo.xml”));

Testando

Para testar, farei um unit test. Se não quiser usar esse método, pode criar a classe com o método main e executar.

A seguir, temos o teste passando e o banco populado:

public class LerDadosXMLTest {
@Test
public void testLerDadosXMLEPopulaNoBanco() throws FileNotFoundException{
  FileReader fileReader = new FileReader(new File("usuarios.xml"));
   LerDadosXML lerDadosXML = new LerDadosXML();
   assertFalse(lerDadosXML.lerXml(fileReader).isEmpty());  
}
}

Bom, espero que tenham gostado do artigo e que ele lhes tenha sido útil. E assim fechamos a série de Hibernate.

Até a próxima!