Como ler arquivos XML e popular o banco de dados via Hibernate

Olá, pessoal! O artigo de hoje vai mostrar como popular um banco de dados↳Banco de dados134 conteúdosSQL ou NoSQL: eis a questão!!Data · mar 2020Banco de dados: como organizar e dar segurança para milhões de dados de loteriasData · mai 20215 serviços gratuitos na cloud para bancos de dados PostgresData · fev 2025Ver tudo em Data → 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↳Java42 conteúdosNovidades do Java 26 (para desenvolvedores)Dev (Back & Front) · mar 2026Visual Studio Code para Java: o guia completo (dicas, configuração e extensões)Dev (Back & Front) · out 2025Quarkus: Modernizando a linguagem Java para a era da nuvemDev (Back & Front) · nov 2020Ver tudo em Dev (Back & Front) → 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!