PERSISTINDO DADOS COM HIBERNATE OGM

A última parte prática da  minha monografia de especialização em Desenvolvimento Java. Neste capitulo irá aprender a usar o Framework de Persistência Hibernate OGM para bancos NoSQL .

Boa Leitura.

Assim como existe o Hibernate ORM (object-relational mapping), que é utilizado para mapeamentos entre os bancos relacionais, existe também o Hibernate OGM (Object/Grid Mapper) para estar trabalhando com bancos NoSQL.

Segundo Leonard (2013), o Hibernate OGM utiliza módulos do Hibernate ORM tanto quanto possível, a arquitetura OGM essencialmente estende a arquitetura ORM, ligando diferentes componentes dentro e fora. De acordo com ele, o Hibernate ORM converte e persiste dado entre os bancos relacionais e as linguagens de programação orientada a objetos, utilizando um conjunto de interfaces e classes. Este inclui uma camada JDBC para esta ligando as bases de dados e envio de consultas e as interfaces persistentes e carregadores, que são responsáveis pela persistência e entidades de carga e coleções.

Leonard (2013) explica que o Hibernate OGM é destinado a realizar os mesmos objetivos que o ORM, porem usando NoSQL. A diferença entre eles, é que no ORM precisamos da camada JDBC, mas no OGM essa camada não é necessária, em vez disso ela oferece dois novos elementos que são: um provedor de armazenamento de dados e um dialeto de armazenamento de dados.

Marchioni (2015) explica que uma aplicação ira interagir com a JPA ou com a API nativa do Hibernate. Uma vez que ela utiliza os recursos do ORM como explicado anteriormente, onde estão contidos no núcleo do Hibernate. Por sua vez, são delegados do núcleo hibernate a execução de consultas e operações CRUD para o Hibernate OGM.

De acordo Marchioni (2015) o mecanismo de consulta ira conduzir a execução de instruções JP-QL para o armazenamento subjacente. Outras operações de CRUD vai ser executada para ser diretamente armazenada, com a mediação do provedor de armazenamento de dados, que seria o uso do controlador MongoDB para o nosso caso.

A figura 65 descreve a arquitetura do Hibernate OGM, mostrando sua relação com o Hibernate ORM, como foi explicado por Marchioni.

ogm
Figura 65 – Arquitetura Hibernate OGM Fonte: MARCHIONI, 2015. p. 118

CRIANDO UM PROJETO JAVA WEB UTILIZANDO HIBERNATE OGM

Iremos reaproveitar o projeto web criado na sessão anterior, para esta atualizando o mesmo para esta funcionando com o Hibernate OGM.

Primeiramente vamos adicionar a dependência do Hibernate OGM no arquivo pom.xml do projeto anterior. O arquivo deve contém os seguintes trechos:

      <depencendyManagement>
            <dependencies>
                  <dependency>
                         <groupId>org.hibernate.ogm</groupId>
                         <artifactId>hibernate-ogm-bom</artifactId>
                         <version>5.0.0.Final</version>
                         <type>pom</type>
                         <scope>import</scope>
                    </dependency>
              </dependencies>
      </dependencyManagement>

     <dependencies>
           <dependency>
                <groupId>org.hibernate.ogm</groupId>
                <artifactId>hibernate-ogm-mongodb</artifactId>
           </dependency>
    </dependencies>

Figura 66 – Dependência Hibernate OGM Fonte: Autoria Própria

A Figura 66, adicionamos duas dependências para o projeto. A primeira ira ser feita o download de toda a biblioteca para o Hibernate OGM. O segundo irá fazer o download do mongo drive.

MAPEANDO AS COLEÇÕES DE BANCO DE DADOS

Vamos agora adicionar classes Java, para fazer o mapeamento. Aqui utilizaremos a mesma classe da figura 56, mas com elementos para funcionar com framework. A figura 67, adicionamos anotações na classe para que seja reconhecida no hibernate OGM.

Assim como no Hibernate ORM, estas anotações têm o mesmo efeito no Hibernate OGM, onde:

  • @Entity: Uma classe anotada com ela se torna uma classe entidade, ou seja,
    se torna um documento e os seus atributos se tornam os campos do
    documento.
  • @Id: Diz que o atributo é chave primaria da tabela.
@Entity
public class Pessoa {

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid2")
     private String id;

     private String nome;
     private int idade;
     private String email;
     private String telefone;

     public Pessoa(String id,String nome, int idade, String email, String telefone) {
          this.id = id;
          this.nome = nome;
          this.idade = idade;
          this.email = email;
          this.telefone = telefone;
       }

     public Pessoa() {
       this.("","",0,"","");
   }

    // Getter e Setter foram emitido para abreviar.
 

Figura 67 – Classe entidade Fonte: Autoria Própria

CONFIGURANDO O PERSISTENCE.XML

Para podemos está acessando banco de dados, teremos que configura um arquivo de configuração do JPA chamado persistence.xml a sua configuração é bem semelhante quando se uso o Hibernate ORM.

Esse arquivo deve ser criado na seguinte pasta do projeto src/main/resources/META-INF:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

	<persistence-unit name="TCC" transaction-type="RESOURCE_LOCAL">
		<provider>org.hibernate.ogm.jpa.HibernateOgmPersistence</provider>
		<class>br.com.danieldias.tcc.modelo.Pessoa</class>

		<properties>
			<property name="hibernate.transaction.jta.platform" value="org.hibernate.service.jta.platform.internal.JBossAppServerJtaPlatform" />
			<property name="hibernate.ogm.datastore.database" value="TCC" />
			<property name="hibernate.ogm.datastore.host" value="127.0.0.1" />
			<property name="hibernate.ogm.datastore.provider" value="MONGODB" />
			<property name="hibernate.ogm.datastore.port" value="27017" />
			<property name="hibernate.ogm.datastore.create_database" value="true" />
		</properties>
	</persistence-unit>
</persistence>

Figura 68 – persistence.xml Fonte: Autoria Própria

INSERINDO COM HIBERNATE OGM

Modificaremos a classe InserirControle, para esta utilizando o JPA para persistir. O código sofrera poucas mudanças, pois iremos apenas mudar a parte de conexão.

Na Figura 69, trocamos a conexão que foi feita na Figura 57. Como podemos notar, o código diminuiu bastante se comparado com a outra.

@WebServlet("/InserirControler")
public class InserirControle extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // criando uma instancia de Pessoa
        Pessoa pessoa = new Pessoa();

        //Recuperando dados do JSP
        pessoa.setNome(request.getParameter("nome"));
        pessoa.setIdade(Integer.parseInt(request.getParameter("idade")));
        pessoa.setTelefone(request.getParameter("telefone"));
        pessoa.setEmail(request.getParameter("email"));

        // Criando o EntityManager
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("TCC");
        EntityManager em = emf.createEntityManager();

        // Criando a transação
        em.getTransaction.begin();

       // Persistindo Dados
       em.persist(pessoa);

      // Enviando o commit para o banco
      em.getTransaction.commit();
      em.close(); // Fechando a conexão
    }
}

Figura 69 – InserirControle Fonte: Autoria Própria.

LISTANDO COM HIBERNATE OGM

Modificaremos a classe ConsultarTodosControler, para trazer os dados a partir do JPA. A figura 70, demonstra como podemos trazer todos os dados da nossa coleção utilizando o JP-QL.

@WebServlet("/ConsultarTodosControler")
public class ConsultarTodosControler extends HttpServlet {
      private static final long serialVersionUID = 1L;

      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        RequestDispacher visao = null;

        // Criando o EntityManager
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("TCC");
        EntityManager em = emf.createEntityManager();

       // Criando a transação
       em.getTransaction().begin();

      // Criando uma lista de pessoa / JP-QL
      List<Pessoa> pessoas = em.createQuery("FROM Pessoa",Pessoa.class).getResultList();
      em.getTransaction().commit();
      em.close();

     // Configurando um atributo para JSP listar os dados
     request.setAttribute("listas",pessoas);

    // Retorna para a pagina listar.jsp
    visao = request.getRequestDispacher("listar.jsp");
    visao.forward(request,response);
  }
}

Figura 70 – ConsultarTodosControle Fonte: Autoria Própria.

ATUALIZANDO COM HIBERNATE OGM

A classe AlterarControler, irá atualizar 3 campos da collection a partir de uma consulta pelo nome passando o parâmetro utilizando JP-QL, como demonstrada na figura 71.

@WebServlet("/AlterarControler")
public class AlterarControler extends HttpServlet {
     private static final long serialVersionUID = 1L;

     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

      Pessoa pessoa = new Pessoa();

     // Recuperando dados do JSP
     pessoa.setNome(request.getParameter("nome"));
     pessoa.setIdade(Integer.parseInt(request.getParameter("idade")));
     pessoa.setTelefone(request.getParameter("telefone"));
     pessoa.setEmail(request.getParameter("email"));

      // Criando a EntityManager
      EntityManagerFactory emf = Persistence.createEntityManagerFactroy("TCC");
      EntityManager em = emf.createEntityManager();

     // Criando a transação
     em.getTransaction().begin();

     //Criando uma consulta
     Query query = em.createQuery("FROM Pessoa where nome=:nome",Pessoa.class);
     query.setParameter("nome",pessoa.getNome());

     Pessoa id (Pessoa) query.getSingleResult();
     pessoa.setId(id.getId());
     pessoa.setNome(id.getNome());

     em.merge(pessoa);
     em.getTransaction().commit();
     em.close();
    }
}

Figura 71 – AlterarControle Fonte: Autoria Própria.

Após a fazer a consulta, irá trazer um único registro que coincide com o argumento passado. Logo após os métodos setId e setNome, recebe o valor da variável id, para que a mesma são sejam alteradas e que não criem um novo registro no banco.

DELETANDO COM HIBERNATE OGM

Por último, será modificada a classe DeletarControler. Onde utilizamos consulta nativa do MongoDB para estarmos deletando os dados. Onde foi criada uma variável String contendo a operação nativa do MongoDB, que no caso iremos deletar todos os documentos que contém o nome especificado ao passarmos o parâmetro no formato Json do MongoDB, conforme demonstrado na figura 72 .

@WebServlet("/DeletarControle")
public class DeletarControler extends HttpServlet {
     private static final long serialVersionUID = 1L;

     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

      Pessoa pessoa = new Pessoa();

     // Recuperando dados do JSP
     pessoa.setNome(request.getParameter("nome"));

      // Criando a EntityManager
      EntityManagerFactory emf = Persistence.createEntityManagerFactroy("TCC");
      EntityManager em = emf.createEntityManager();

     // Criando a transação
     em.getTransaction().begin();

    // Criando uma consulta nativa
    String query1 = "db.Pessoa.remove({'nome': '" + pessoa.getNome() + "'})";

    Query query = (Query) em.createNativeQuery(query1, Pessoa.class);
    query.executeUpdate();

    em.getTransaction().commit();
    em.close();
    }
}

Figura 72 – DeletarControle Fonte: Autoria Própria.

Contudo, finalizamos este capitulo demonstrando como podemos está construindo sistemas em Java sendo desktop ou web, utilizando MongoDB para armazenamento.

Visto que a implementação para fazer operações no banco via Driver Java é bem simples, já que os métodos contidos no driver são praticamente o mesmo apresentado no Mongo Shell, o que facilita muito no desenvolvimento.

Foi apresentado o Hibernate OGM, um framework para manipulação dos dados no MongoDB, que utilizar módulos do Hibernate ORM.

O framework facilitou ainda mais interação com o MongoDB utilizando JPA ou a API nativa do Hibernate e ainda permite a utilização de operações nativa do MongoDB, que é uma boa escolha se caso sentirmos limitado ao utilizar o Hibernate OGM.

REFERÊNCIAS

Leonard, Anghel. Pro Hibernate and MongoDB. Apress,2013.

Marchioni, Francesco. MongoDB for Java Developers. Birmingham: Packt Publishing Ltd,2015.

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s