06 - Persistência - NoSQL

Prévia do material em texto

17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 1/10
 
 
 
 
 
 
 
 
 
Persistência - NoSQL
 
 
 
 
Rômulo Ferreira Douro
SIN2
Sumário
1 Introdução
1.1 Banco de dados Relacional
1.2 Banco de dados NoSQL
2 Aplicação com Persistência em Java
2.1 Principais métodos
2.1.1 Observação
2.2 Projeto prático
2.3 O código
2.3.1 Classe de modelo
2.3.2 Classe gerenciadora de dados
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 2/10
2.3.3 Classe executável
 
1 Introdução
O intuito desse documento é abordar de forma abreviada e
simplificada a prática de persistência de dados usando NoSQL com
objetos em Java.
1.1 Banco de dados Relacional
A abordagem Relacional para bancos de dados é usada desde a
década de 1970. É de fácil uso e manutenção. Tal abordagem é
validada pela álgebra relacional dada a modelagem dos dados em
tabelas e registros.
Existem atualmente vários SGBD’s (Sistemas Gerenciadores de
Bancos de Dados) em uso tais como MySQL1, PostgreSQL2 e
MariaDB3 entre outros.
Com a popularização do uso da Internet observou-se um gargalo em
relação à velocidade de ampliação e consumo das bases de dados
levando vários mantenedores de sites e redes sociais
(principalmente) a incrementar a abordagem de seus bancos de
dados utilizando também aquelas bases chamadas NoSQL.
1.2 Banco de dados NoSQL
Bancos de dados NoSQL geralmente são denotados por não usarem
somente o esquema relacional para associar os dados em tabelas e
registros, levando em consideração abordagens de armazenamento
diversas.
Dentre os bancos de dados que podem ser destacados nessa classe
podemos citar o MongoDB4 e a Apache Cassandra5, mas existem
muitos outros6.
2 Aplicação com Persistência em Java
Para uma abordagem prática podemos utilizar uma base de dados
que seja de fácil utilização.
Ao passo em que abordaremos a implementação em uma aplicação
Desktop é viável que utilizemos uma base embarcada (embedded) –
pode-se dizer é um banco de dados cujo sistema gerenciador de
dados é mantido em conjunto com a própria aplicação.
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 3/10
Para nossa atividade usaremos a base de código aberto Nitrite
(https://www.dizitart.org/nitrite-database.html) da Diziart – cujo
código pode ser obtido facilmente no Github do projeto
(https://github.com/nitrite/nitrite-java).
2.1 Principais métodos
Para usarmos essa base precisamos conhecer seus principais
métodos obtidos em https://www.dizitart.org/nitrite-database/:
Nitrite db = Nitrite.builder()
 .compressed()
 .filePath("base.db")
 .openOrCreate("root", "salesiano");
 
Cria uma base de dados baseada em
arquivo (“base.db”) configurada para
ser usada com acesso ao usuário
“root” usando a senha “salesiano”
@Indices({
 @Index(value = "nome", type = IndexType.Unique)
})
public class Pessoa implements Serializable {
 @Id
 public NitriteId id;
 public String nome;
 
Indica que a classe Pessoa servirá
para armazenamento de dados
usando um identificador gerenciado
pelo sistema de dados (NitriteId).
Ainda nota-se que os dados serão
indexados pelo nome da pessoa (o
qual é único e não pode ser
duplicado)
rPessoas = db.getRepository(Pessoa.class);
 
Cria um repositório para entidades do
tipo Pessoa.
rPessoas, no caso, será o objeto
responsável por inserir, excluir,
recuperar e atualizar dados de
entidades do tipo Pessoa no banco
de dados.
FindOptions sortBy = FindOptions.sort("nome", SortOrder.Ascending);
List<Pessoa> pessoas = ControlaDB.rPessoas.find(sortBy).toList();
 
Obtém uma lista de pessoas
executando o método find do
repositório em conjunto com a opção
sortBy (que configura a forma de
ordenação da lista – ordenada de
forma ascendente pelo nome de cada
pessoa)
rPessoas.insert(pessoa);
 
O método insert insere um objeto no
banco de dados
rPessoas.update(pessoa); O método update atualiza um objeto
https://www.dizitart.org/nitrite-database.html
https://github.com/nitrite/nitrite-java
https://www.dizitart.org/nitrite-database/
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 4/10
no banco de dados
rPessoas.remove(pessoa); O método remove exclui um objeto
no banco de dados
rPessoas.find(eq("id", idP)).firstOrDefault();
 
Utiliza o método find em conjunto da
opção que verifica a igualdade do
campo “id” com o valor da variável
idP passada como parâmetro. Esse
método com a execução a posterior
de firstOrDefault() busca uma única
entidade pelo seu atributo ‘id’
 
2.1.1 Observação
É importantíssimo que a entidade tenha um atributo identificador!
Esse atributo é responsável pelo gerenciamento da seleção,
atualização e exclusão de uma entidade.
2.2 Projeto prático
Usaremos agora o gerenciador de build Maven.
Para tanto criaremos nosso projeto da seguinte forma:
 
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 5/10
•
•
•
•
•
 
O que devemos preencher:
Project Name → nome do projeto 
Project Location → diretório onde será criado o projeto (preenche
automaticamente) 
Group Id → pacote principal (geralmente leva o nome da
organização de trabalho) 
Version → versão do projeto 
Package → é o pacote de nossos dados (forma de organização em
Java) 
Após a criação do projeto, sua estrutura deverá ser semelhante à
apresentada na próxima figura:
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 6/10
 
Abra o arquivo pom.xml e adicione as seguintes linhas após a seção
</properties>
<dependencies>
 <dependency>
 <groupId>org.dizitart</groupId>
 <artifactId>nitrite</artifactId>
 <version>3.4.2</version>
 </dependency>
 </dependencies>
 <build>
 <plugins>
 <plugin>
 <artifactId>maven-dependency-plugin</artifactId>
 <executions>
 <execution>
 <phase>install</phase>
 <goals>
 <goal>copy-dependencies</goal>
 </goals>
 <configuration>
 <outputDirectory>${project.build.directory}/lib</outputDirectory>
 </configuration>
 </execution>
 </executions>
 </plugin>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-jar-plugin</artifactId>
 <version>2.4</version>
 <configuration>
 <archive>
 <manifest>
 <addClasspath>true</addClasspath>
 <classpathPrefix>lib/</classpathPrefix>
 <mainClass>${mainClass}</mainClass>
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 7/10
 </manifest>
 </archive>
 </configuration>
 </plugin>
 </plugins>
 </build>
 
 
A parte com o valor ${mainClass} pode ser alterada posteriormente e
é muito útil em aplicações GUI usando Swing → essa configuração
indica o ponto de partida na execução de uma aplicação Java.
Com a adição das linhas é feita uma consulta no cache da máquina
para verificar se as dependências da aplicação são satisfeitas. Caso
não tenham todas as bibliotecas disponíveis o próprio projeto dá
uma indicação (o triângulo de alerta no ícone do projeto):
 
e oferece uma solução ao clicar com o botão direito no projeto e no
menu “Resolve Project Problems...”:
 
2.3 O código
Para o código iremos criar três classes: o modelo (Pessoa.java), o
gerenciador de dados (BaseDados.java) e o executável
Feito isso, aguarde que o sistema atualize as dependências.
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 8/10
(Programa.java).
2.3.1 Classe de modelo
Segue o código comentado
package br.unisales.testen;
import org.dizitart.no2.IndexType;import org.dizitart.no2.NitriteId;
import org.dizitart.no2.objects.Id;
import org.dizitart.no2.objects.Index;
import org.dizitart.no2.objects.Indices;
/**
 *
 * @author romulo
 *
 * classe de modelo que representa a entidade Pessoa
 */
@Indices({
 @Index(value = "nome", type = IndexType.Unique)
})
public class Pessoa {
 /**
 * a entidade pessoa tem dois atributos id que é a chave interna do banco de
 * dados nome que representa o nome da pessoa
 */
 @Id
 public NitriteId id;
 public String nome;
 @Override
 public String toString() {
 return "Pessoa{" + "id=" + id.getIdValue() + ", nome=" + nome + '}';
 }
}
 
2.3.2 Classe gerenciadora de dados
Segue o código comentado
package br.unisales.testen;
import org.dizitart.no2.Nitrite;
import org.dizitart.no2.objects.ObjectRepository;
/**
 *
 * @author romulo
 *
 * classe responsável por gerenciar as atividades do repositório de dados
 */
public class BaseDados {
 /**
 * um campo ou método public static pode ser acessado em qualquer parte do
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 9/10
 * programa através do nome da classe
 */
 //cria um repositório para as entidades do tipo Pessoa
 public static ObjectRepository<Pessoa> rPessoas;
 /**
 * um campo ou método public static pode ser acessado em qualquer parte do
 * programa através do nome da classe
 */
 //inicia a base de dados no arquivo 'baseDados.db'
 public static void iniciaDados() {
 Nitrite db = Nitrite.builder()
 .compressed()
 .filePath("baseDados.db")
 .openOrCreate("root", "salesiano");
 //incia o repositório para a entidade pessoa
 rPessoas = db.getRepository(Pessoa.class);
 }
}
 
2.3.3 Classe executável
Segue o código comentado
package br.unisales.testen;
import java.util.List;
import org.dizitart.no2.FindOptions;
import org.dizitart.no2.SortOrder;
import static org.dizitart.no2.objects.filters.ObjectFilters.eq;
/**
 *
 * @author romulo
 */
public class Programa {
 public static void main(String[] args) {
 //inicia os dados
 BaseDados.iniciaDados();
 //cria um objeto do tipo Pessoa
 Pessoa p = new Pessoa();
 p.nome = "clemente";
 //insere no banco de dados a pessoa
 BaseDados.rPessoas.insert(p);
 //cria uma opção de ordenação ascendente pelo nome das pessoas inseridas no banco
 FindOptions sortBy = FindOptions.sort("nome", SortOrder.Ascending);
 //recupera a lista com as pessoas inseridas no banco de dados
 List<Pessoa> pessoas = BaseDados.rPessoas.find(sortBy).toList();
 long idPessoa = 0;
 //mostra as pessoas
 for (Pessoa paux : pessoas) {
 System.out.println(paux);
 //recupera o valor numérico do id da pessoa
17/10/2020 - no title specified
moodlep.ucv.edu.br/moodle/pluginfile.php/353971/mod_resource/content/0/06 - Persistencia - NoSQL.html 10/10
 idPessoa = paux.id.getIdValue();
 }
 //executa uma query no repositório recuperando uma pessoa pelo seu id
 p = BaseDados.rPessoas.find(eq("id", idPessoa)).firstOrDefault();
 //altera o nome do objeto p2 (tipo Pessoa)
 p.nome = "clemente tadeu";
 //atualiza os dados no banco de dados
 BaseDados.rPessoas.update(p);
 //executa uma query no repositório recuperando uma pessoa pelo seu id
 p = BaseDados.rPessoas.find(eq("id", idPessoa)).firstOrDefault();
 System.out.println(p);
 //exclui a pessoa do banco de dados
 BaseDados.rPessoas.remove(p);
 //recupera a lista com as pessoas inseridas no banco de dados
 pessoas = BaseDados.rPessoas.find().toList();
 //mostra a quantidade de pessoas inseridas no banco de dados
 System.out.println(pessoas.size());
 }
}
 
Execute a classe Programa para verificar a execução do código.
Observe que é criado um arquivo na pasta do projeto.
 
Esse arquivo é o próprio banco de dados!
 
 
1https://www.mysql.com
2 https://www.postgresql.org
3 https://mariadb.org
4 https://www.mongodb.com
5 https://cassandra.apache.org
6 https://hostingdata.co.uk/nosql-database/
https://www.mysql.com/
https://www.postgresql.org/
https://mariadb.org/
https://www.mongodb.com/
https://cassandra.apache.org/
https://hostingdata.co.uk/nosql-database/