Criando uma aplicação com JSR-371(MVC 1.0)

Neste artigo criaremos uma aplicação simples para demostrar o uso da API MVC 1.0 (JSR 371) do Java EE 8 juntamente com MongoDB.

Boa Leitura.

mvc1-0capa

Introdução ao MVC 1.0

MVC é um padrão comum em frameworks web, onde este é usado predominantemente para criar aplicativos HTML. Frameworks web podem ser categorizados como Action-Based ou Component-Based. Em Action-Based, as solicitações HTTP são encaminhadas para controladores onde elas são transformadas em ações pelo código da aplicação. Em Component-Based, as solicitações HTTP são agrupadas e normalmente tratadas por framework de Componente, com pouca ou nenhuma interação do código da aplicação. Em outras palavras, um framework baseado em componentes, a maioria da sua lógica do controle é fornecida pelo framework em vez da aplicação.

Esta API se enquadra na categoria Action-Based, ela não se destina a substituição de frameworks baseado em componentes como a JSF, mas simplesmente uma alternativa para a construção de aplicações web para a plataforma Java EE.

Os Objetivos da API:

De acordo com a sua especificação está api propõe os seguintes objetivos:

  • Aproveitar as tecnologias Java EE existentes.
  • Integrar com CDI e Bean Validation
  • Definir um núcleo solido para construir aplicações MVC sem a necessidade suportar todas as funcionalidade em sua primeira versão.
  • Explora as camada em cima do JAX-RS com a finalidade de reutilizar suas camadas de Matching e binding.
  • Fornece suporte interno para JSP e Facelets.

Não são Objetivos da API:

  • Definir uma nova linguagem de visualização(template) e processador.
  • Suporte a serviços REST não baseads em JAX-RS.
  • Suporte a implementação autônoma do MVC executado fora do Java EE.
  • Fornecer suporte interno para views que não fazem parte do Java EE.

Criando o Projeto

Antes de inciarmos a criação do projeto devemos fazer o download do servidor de Aplicação para que o mesmo funcione. Porém até o momento ela funciona com uma versão especifica do GlassFish que pode ser baixada no seguinte link : http://download.oracle.com/glassfish/4.1/nightly/glassfish-4.1-b17-09_15_2015.zip .   Feito isso, podemos da inicio.

Com o Eclipse aberto, vá File -> New – > Maven Project irá abrir a seguinte Janela :

maven

 clique em Next para ir para a seguinte tela :

maven2

    clique em Next, na próxima deixe preenchida da seguinte forma  e clique em Finish:

mvc1

com o projeto criado,vá em src/main/webapp, nela apague a pasta WEB-INF. Depois clique com o botão direito do mouse e vá em Properties, navegue até a opção Targeted Runtimes, marque a opção, que no caso vamos utilizar o GlassFish, depois clique em Uninstall Facets… :

mvc2

mvc3

ao chegar nesta tela desmaque Dynamic Web Module , altere Java 1.5 para 1.8,marque CDI,Glassfish Web Extensions e JAX-RS e clique em Finish. Abra novamente a mesma tela e maque Dynamic Web Module e mude de 2.3 para 3.1 e clique em Next para configura a proxima tela e a configure como abaixo :

mvc5

Clique em Finish e depois em OK.

Agora iremos configurar nosso pom.xml, com a seguinte configurações :

<project
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=
"http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>br.com.danieldias</groupId>
  <artifactId>MVC1.0.Ozark</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>MVC1.0.Ozark Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
			<groupId>javax</groupId>
			<artifactId>javaee-web-api</artifactId>
			<version>7.0</version>
			<scope>provided</scope>
		</dependency>

	<!-- Mongo Driver -->
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongodb-driver</artifactId>
			<version>3.4.1</version>
		</dependency>

		<dependency>
            <groupId>org.glassfish.ozark</groupId>
            <artifactId>ozark</artifactId>
            <version>1.0.0-m02</version>
            <scope>compile</scope>
        </dependency>

         <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
			<groupId>org.glassfish.jersey.core</groupId>
			<artifactId>jersey-server</artifactId>
			<version>2.22</version>
		</dependency>
  </dependencies>
  <build>
    <finalName>MVC1.0.Ozark</finalName>
    		<plugins>
    		   <plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.5</version>
				<configuration>
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.5.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
  </build>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
</project>

 Na pasta WEB-INF , configure o beans.xml do CDI da seguinte forma :

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=
"http://xmlns.jcp.org/xml/ns/javaee
 http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd"
bean-discovery-mode="all">
</beans>

Ainda dentro de WEB-INF também crie uma pasta chamada views.
Depois clique em cima do projeto e de “Alt +F5” para fazer update do maven :

mvc6

Clique em OK e finalizamos a parte de criação projeto, podemos da inicio a codificação de nossas classes .

Criando a Constantes.java

Está classe é bem simples, ela irá somente conter valores constantes, que não serão modificadas. Isso para evitar ter muitas hardCode espalhado por todo o código, assim esse classe irá centralizar tudo de maneira organizada.

Crie uma classe chamada Constantes no package br.com.danieldias.commons, com o seguinte conteúdo :

package br.com.danieldias.commons;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class Constantes {

	/*Nome o Banco e da Collection*/
	public static final String BANCO_NOME = "danieldiasjava";
	public static final String COLLECTION_NOME = "pessoas";

	/*Nomes das Colunas para o MongoDB*/
	public static final String NOME = "nome";
	public static final String IDADE = "idade";
	public static final String ENDERECO = "endereco";
	public static final String ESTADO = "estado";
	public static final String JUGS = "jugs";
	public static final String DESCRICAO = "descricao";
	public static final String ID = "_id";
}

Criando as Entidades

Crie as classes Pessoa.java e Endereco.java no package br.com.danieldias.model , com o seguinte conteúdo :

package br.com.danieldias.model;

import javax.ws.rs.FormParam;

import org.bson.types.ObjectId;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class Pessoa {

	@FormParam("_id")
	private ObjectId _id;

	@FormParam("nome")
	private String nome;

	@FormParam("idade")
	private int idade;

	@FormParam("endereco")
	private Endereco endereco;

	@FormParam("jugs")
	private String jugs;

	@FormParam("descricao")
	private String descricao;

	public String getDescricao() {
		return descricao;
	}

	public void setDescricao(String descricao) {
		this.descricao = descricao;
	}

	public Pessoa() {
	}

	public Pessoa(String nome, Endereco endereco,
			String descricao,int idade,
			String jugs) {
		super();
		this.nome = nome;
		this.endereco = endereco;
		this.descricao = descricao;
		this.idade = idade;
		this.jugs = jugs;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public Endereco getEndereco() {
		return endereco;
	}

	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}

	public ObjectId get_id() {
		return _id;
	}

	public int getIdade() {
		return idade;
	}

	public void setIdade(int idade) {
		this.idade = idade;
	}

	public String getJugs() {
		return jugs;
	}

	public void setJugs(String jugs) {
		this.jugs = jugs;
	}
}

A anotação @FormParam, são utilizados para pegar os valores do form do html.

package br.com.danieldias.model;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class Endereco {

	private String estado;

	public String getEstado() {
		return estado;
	}

	public void setEstado(String estado) {
		this.estado = estado;
	}

	public Endereco() {
	}

	public Endereco(String estado) {
		super();
		this.estado = estado;
	}
}

Criando o Repositorio

Agora criaremos uma Inteface chamada MongoDAO ,uma classe chamada PessoaDAO e uma classe que ira criar a fabrica de conexão chamada MongoDBFactory no package br.com.danieldias.persistencia, com os seguintes conteúdos:

package br.com.danieldias.persistencia;

import com.mongodb.MongoClient;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class MongoDBFactory {

	public static MongoClient createConnection() {
		MongoClient conexao = null;
		if(conexao == null) {
			conexao = new MongoClient();
		}
		return conexao;
	}
}

A classe PessoaDAO é onde fica todas as operações de CRUD para o MongoDB, nada muito fora do comum, tudo muito simples e fácil compreensão. Repare que estamos usando a classe Constantes aqui no lugar de String para facilitar o entendimento e deixar o código mas limpo.

package br.com.danieldias.persistencia;

import static com.mongodb.client.model.Filters.eq;

import java.util.ArrayList;
import java.util.List;

import org.bson.Document;
import org.bson.types.ObjectId;

import com.mongodb.MongoClient;
import com.mongodb.MongoCursorNotFoundException;
import com.mongodb.MongoException;
import com.mongodb.MongoQueryException;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;

import br.com.danieldias.commons.Constantes;
import br.com.danieldias.model.Pessoa;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class PessoaDao implements MongoDAO<Pessoa> {

	MongoClient conexao;
	MongoCollection<Document> collectionPessoas;

	public PessoaDao() {
		conexao = MongoDBFactory.createConnection();
		collectionPessoas =
				conexao.getDatabase(Constantes.BANCO_NOME)
				.getCollection(Constantes.COLLECTION_NOME);
	}

	@Override
	public void inserir(Pessoa entidade) throws MongoException {

		List<Document> jugs = new ArrayList<>();
		jugs.add(new Document(Constantes.NOME,entidade.getJugs())
				.append(Constantes.DESCRICAO, entidade.getDescricao()));

		collectionPessoas.insertOne(new Document(Constantes.NOME,entidade.getNome())
				 .append(Constantes.ENDERECO,
							new Document(Constantes.ESTADO,entidade.getEndereco().getEstado())
							)
				 .append(Constantes.IDADE,entidade.getIdade())
				 .append(Constantes.JUGS, jugs)
				 );
	}

	@Override
	public void alterar(Pessoa entidade) throws MongoException {

		collectionPessoas.updateOne(porId(entidade.get_id()),
				new Document("$set",
						new Document(Constantes.IDADE,entidade.getIdade())
						.append(Constantes.NOME, entidade.getNome())
						.append(Constantes.ENDERECO,
								new Document(Constantes.ESTADO,entidade.getEndereco().getEstado()))
						)
				);
	}

	@Override
	public void deletar(ObjectId _id) throws MongoQueryException {
		collectionPessoas.findOneAndDelete(porId(_id));
	}

	@Override
	public MongoCursor<Document> listarTodos() throws MongoCursorNotFoundException, MongoQueryException {
		return collectionPessoas.find().iterator();
	}

	@Override
	public Document porId(ObjectId _id) throws MongoQueryException {
		return collectionPessoas.find(eq(Constantes.ID,_id)).first();
	}
}

Agora nossa interface generica:

package br.com.danieldias.persistencia;

import org.bson.Document;
import org.bson.types.ObjectId;

import com.mongodb.MongoCursorNotFoundException;
import com.mongodb.MongoException;
import com.mongodb.MongoQueryException;
import com.mongodb.client.MongoCursor;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public interface MongoDAO<T> {

	void inserir(T entidade) throws MongoException;
	void alterar(T entidade) throws MongoException;
	void deletar(ObjectId _id) throws MongoQueryException;
	MongoCursor<Document> listarTodos() throws MongoCursorNotFoundException,MongoQueryException;
	Document porId(ObjectId _id) throws MongoQueryException;
}

Criando os Controles

Entramos na parte principal, aqui veremos com a api funciona.

Crie uma nova classe chamada PessoaController no package br.com.danieldias.controller, com o seguinte conteúdo :

package br.com.danieldias.controller;

import javax.inject.Inject;
import javax.mvc.Models;
import javax.mvc.Viewable;
import javax.mvc.annotation.Controller;
import javax.mvc.annotation.View;
import javax.ws.rs.BeanParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;

import org.bson.types.ObjectId;

import br.com.danieldias.model.Pessoa;
import br.com.danieldias.persistencia.MongoDAO;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
@Controller
@Path("mvc")
public class PessoaController {

	@Inject
	Models models;

	@Inject
	MongoDAO<Pessoa> pessoaDao;

	@GET
	@Path("novo")
	public Viewable novo() {
		return new Viewable("inserir.jsp");
	}

	@GET
	@Path("mostrar")
	@View("mostrar.jsp")
	public void listar() {
	  this.models.put("listar", pessoaDao.listarTodos());
	}

	@POST
	@Path("add")
	public String adicionar(@BeanParam Pessoa pessoa) {
		pessoaDao.inserir(pessoa);

		return "redirect:mvc/mostrar";
	}

	@POST
	@Path("update")
	public String atualizar(@BeanParam Pessoa pessoa) {
		pessoaDao.alterar(pessoa);
		return "redirect:mvc/mostrar";
	}

	@GET
	@Path("atualizar/{_id}")
	public Viewable update(@PathParam("_id") ObjectId _id) {
		this.models.put("update",pessoaDao.porId(_id));
		return new Viewable("alterar.jsp",models);
	}

	@GET
	@Path("remover/{_id}")
	public String deletar(@PathParam("_id") ObjectId _id) {
		pessoaDao.deletar(_id);
		return "redirect:mvc/mostrar";
	}
}

O código é semelhante ao que usamos no Spring. Então nessa parte fica bem tranquila de aprender quando a API for lançada oficialmente, é até la vai haver muitas mudanças e melhoramentos.

O @Controller, quando aplicada a uma classe, todos os métodos nele são considerados como controladores. Ao usar a anotação @Controller em um subconjunto de métodos define uma classe hibrida em que certos métodos são controladores e outros são métodos tradicionais do JAX-RS.

O @Path é o endereço que iremos acessar determinada ação para o controlador e acessar outros métodos por outras endereços também, isso é semelhante ao @RequestMapping() do spring.

A class Viewable encapsula informações sobre uma visualização, bem como, opcionalmente, informações sobre como ele deve ser processado. Mais precisamente, uma instância Viewable pode incluir referências a Modelos e Objetos ViewEngine. Comparada ao Spring ela seria como ModelAndView.

Models é a interface que define um mapa entre nomes e objetos. O suporte para a interface Models é obrigatória para todos os view engines, porém podemos usar OPCIONALMENTE o @Named  do CDI que é fortemente recomendado para aproveitar a integração CDI e EL existente na plataforma.

Os métodos do controlador que retornam um tipo não-vazio(void) também podem ser decorados com @View como uma forma de especificar um padrão para o controlador. A visualização padrão deve ser usada somente quando tal controlador não vazio retorna um valor nulo.

A anotação @BeanParam é algo novo adicionado na especificação JAX-RS 2.0. Ele permite que você injete uma classe específica de aplicativo cujos métodos de propriedade ou campos são anotados com qualquer um dos parâmetros de injeção, como foi utilizada o @FormParam.

@PathParam permite que você injete o valor de parâmetros de caminho URI nomeados que foram definidos em expressões @Path.

Criando as Views

Agora daremos inicio a criação de 4 páginas para nossa aplicação que são : alterar.jsp, inserir.jsp ,mostrar.jsp  que devem ser criada na pasta views que fica dentro de WEB-INF, já a index.jsp deve ser criada em na pasta  webapp.

Iniciaremos pela a página mostrar.jsp, onde a mesma terá uma tabela onde os dados serão apresentados, 3 links um para chamar a paǵina alterar.jsp passando um parâmetro que é seu id e um que irá chamar no controle o deletar com parâmetro id e um para estarmos adicionando os dados no formulario inserir.jsp :

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Mostrar</title>
</head>
<body>
<h1 align="center">Listagem dos Dados</h1>
<a href="novo">Adicionar</a>
<table align="center" border="4">
<tr bgcolor="gray">
<th>ID</th>
<th>Nome</th>
<th>Idade</th>
<th>Estado</th>
<th>JUGS</th>
<th>Descrição</th>
<th>Editar</th>
<th>Deletar</th>
</tr>
<c:forEach items="${listar}" var="pessoas">
<tr>
<td>${pessoas._id}</td>
<td>${pessoas.nome}</td>
<td>${pessoas.idade}</td>
<td>${pessoas.endereco.estado}</td>
<td>${pessoas.jugs.get(0).nome}</td>
<td>
				<textarea rows="10" cols="60" name="descricao" disabled="disabled"> ${pessoas.jugs.get(0).descricao} </textarea></td>
<td><a href="atualizar/${pessoas._id }">Alterar</a></td>
<td><a href="remover/${pessoas._id}">Excluir</a></td>
</tr>
</c:forEach></table>
</body>
</html>

Algo importante nesta tela. Aqui os atributos passado devem SER o mesmo que estão no mongoDB, ou seja as colunas tem que ter os mesmo nome. A mesma coisa nesse techo : ${pessoas.jugs.get(0).nome}, aqui estou retornado o primeiro posição no array, se quisermos chamar outra posição fazemos assim : ${pessoas.jugs.get(1).lideres}.
A proxima tela é um formulario bem simples com o seguinte conteudo :

<%@ page language="java" contentType="text/html; charset=UTF-8"     pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Inserir</title>
</head>
<body>
<div align="center">
<form action="add" method="post">
<fieldset style="width: 400px">
<legend>Dados</legend>

	 Nome: <input type="text" name="nome" />

    Idade: <input type="number" name="idade"/>

   Estado: <input type="text" name="endereco"/>

   JUGS:<input type="radio" name="jugs" value="SouJava"/>SouJava
   <input type="radio" name="jugs" value="RioJug"/>RioJug
   <input type="radio" name="jugs" value="SouJava Campinas"/>SouJava Campinas

   <textarea rows="10" cols="30" name="descricao">Descrição</textarea>

   <input type="submit" value="Cadastrar Dados."/></fieldset>
</form></div>
</body>
</html>

e última tela que contem um formulário já preenchido com os valores do banco que podem ser alterados :

<%@page contentType="text/html" language="java" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Atualizar Dados</title>
</head>
<body>
<div align="center">
<form action="../update" method="post">
<fieldset style="width: 400px">
<legend>Alteração de Dados</legend>

		<input type="text" name="_id" value="${update._id }" hidden="true">

      Nome:<input type="text" name="nome" value="${update.nome }">

      Idade: <input type="number" name="idade" value="${update.idade }"/>

      Cidade<input type="text" name="endereco"  value="${update.endereco.estado}">

      <textarea rows="10" cols="30" name="descricao" disabled="disabled">${update.jugs.get(0).descricao}</textarea>

      <input type="submit" value="Atualizar"></fieldset>
</form></div>
</body>
</html>

agora nossa pagina index.jsp contendo a url para chamar a tela mostrar.jsp e iniciar a aplicação.

<%@ page language="java" contentType="text/html; charset=UTF-8"     pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Index MVC</title>
</head>
<body>
<h1 align="center">Demo JSR 371 - MVC 1.0</h1>
<div align="center">
<ul type="none">
	<li ><a href="app/mvc/mostrar">Listar Dados</a></li>
</ul>
</div>
</body>
</html>

por fim iniciar a aplicação devemos criar uma classe que extenda a javax.ws.rs.core.Application e anota-la com @ApplicationPath, essa classe deve ser criada no package br.com.danieldias.application com o seguinte conteúdo :

package br.com.danieldias.application;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
@ApplicationPath("app")
public class MVCApplication extends Application {
}

Rodando a Aplicação

Com tudo pronto, podemos testar a nossa aplicação:
Primeiramente inicie o MongoDB através do prompt/terminal com o seguinte comando : mongod, como na imagem:

mongod

Depois rode a aplicação no glassfish , com o botão direito do mouse clique no seu projeto e vá em Run As -> Run on Server, ao inicia a aplicação a página principal será carregada com abaixo :

indexmvc

Clique no link  para ser levado a pagina que lista todos os dados, como na imagem :

telamvc

Clique no link Adicionar, irá ser levado para a tela de formulário:

telamvc2

Ao clicar em Cadastrar Dados, voltará para a tela de listagem dos dados :

listagem

Agora clicando em Excluir irá deletar a informação através do ID que foi passado por parâmetro. Em Alterar será levado a tela de alteração de dados e retornara para tela de listagem :

alterar

Bem isso é tudo, aqui aprendemos a como fazer uma aplicação utilizado a api MVC1.0 do JEE 8 com MongoDB . O projeto pode ser baixado no meu GitHub.

Outros exemplos da API pode ser encontrados aqui : https://github.com/spericas/ozark/tree/master/test
Para saber mais sobre a API visite os seguintes sites :

mvc-spec

Ozark- RIOzark- RI

mvc-1-0-jsr-para-um-framework-mvc-action-based-na-java-ee-8

primeiros-passos-do-mvc-1-0

REFERÊNCIAS

https://dennis-xlc.gitbooks.io/restful-java-with-jax-rs-2-0-2rd-edition/content/en/index.html

https://jcp.org/en/jsr/detail?id=371

http://download.oracle.com/otn-pub/jcp/mvc-1-edr2-spec/JSR_371-EDR-Spec-MVC-1_0-10_2_15.pdf

Anúncios

Aplicação Spring MVC com MongoDB

Neste artigo criaremos um aplicação simples utilizando Spring MVC juntamente com MongoDB.

Boa Leitura.

capa

Antes de começarmos a criar nosso projeto, primeiramente tem que conhecer um pouco sobre  o banco de dados mongodb e Mongo Shell. Sua instalação pode ser vista aqui Obtendo e Configurando o MongoDB em seu Ambiente.

Spring MVC  é um framework  Action Based que tem ganhado bastante espaço ultimamente no universo Java para criação de projeto Web, antes dele era Struts 1 que também é um framework Action Based.

O projeto vai ser bem simples, um crud utilizando mongodb com um relacionamento entre dois documentos.

Criando o Projeto

Com o Eclipse aberto, vá File -> New – > Maven Project irá abrir a seguinte Janela :

maven

clique em Next para ir para a seguinte tela :

maven2

clique em Next, na próxima deixe preenchida da seguinte forma  e clique em Finish:

blog2

com o projeto criado,vá em src/main/webapp, nela apague a pasta WEB-INF. Depois clique com o botão direito do mouse e vá em Properties, navegue até a opção Targeted Runtimes, marque a opção, que no caso vamos utilizar o Tomcat, depois clique em Uninstall Facets… :

target-maven

facets

ao chegar nesta tela desmaque Dynamic Web Module , altere Java 1.5 para 1.8 e clique em Finish. Abra novamente a mesma tela e maque Dynamic Web Module e mude de 2.3 para 3.1 e clique em Next para configura a proxima tela e a configure como abaixo :

web

Clique em Finish e depois em OK.

Agora iremos configurar nosso pom.xml, com a seguinte configurações :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>br.com.danieldias</groupId>
	<artifactId>SpringMongo</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>SpringMongo Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<!-- Mongo Driver -->
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongodb-driver</artifactId>
			<version>3.2.2</version>
		</dependency>

		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.0.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.3.0.RELEASE</version>
		</dependency>

		<!-- JSTL -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
		</dependency>
	</dependencies>
	<build>
		<finalName>SpringMongo</finalName>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.5.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
</project>

Na pasta WEB-INF , configure o web.xml na seguinte forma :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation=" http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>SpringMongo</display-name>

  <servlet>
    <servlet-name>springDispatcherServlet</servlet-name>
    <servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/spring-context.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
<servlet-mapping>
    <servlet-name>springDispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

Ainda dentro de WEB-INF crie um xml com o nome spring-context.xml, com o seguinte conteúdo e também crie uma pasta chamada views:

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd">

<!-- scaneia todos os pacotes a procura de componentes do Spring-->
  <context:component-scan base-package="br.com.danieldias"/> 

      <context:annotation-config />
	<mvc:annotation-driven />

<!-- configura css,js,etc -->
<mvc:resources location="/recursos/" mapping="/recursos/**"/>

	<!-- Configurando a localização das Views. -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
			<property name="prefix" value="/WEB-INF/views/"/>
			<property name="suffix" value=".jsp"/>
	</bean>

</beans>

Agora na pasta webapp crie uma pasta chamada recursos com as seguinte subpastas : css, js e imagens, dentro de cada uma delas  seguinte arquivos :

  • jquery-ui-1.9.2.custom.min.css
  • calendar.gif
  • datepicker-pt-BR.js
  • jquery-3.1.0.min.js
  • jquery-ui-1.9.2.custom.min.js

Depois clique em cima do projeto e de “Alt +F5” para fazer update do maven :

f5

Clique em OK e finalizamos a parte de criação projeto, podemos da inicio a codificação de nossas classes .

Criando a Constantes.java

Está classe é bem simples, ela irá somente conter valores constantes, que não serão modificadas. Isso para evitar ter muitas hardCode espalhado por todo o código, assim esse classe irá centralizar tudo de maneira organizada.

Crie uma classe chamada Constantes no package br.com.danieldias.commons, com o seguinte conteúdo :

package br.com.danieldias.commons;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class Constantes {

	/*Nome o Banco e da Collection*/
	public static final String BANCO_NOME = "danieldiasjava";
	public static final String COLLECTION_NOME = "pessoas";

	/*Nomes das Colunas para o MongoDB*/
	public static final String NOME = "nome";
	public static final String IDADE = "idade";
	public static final String PROFISSAO = "profissao";
	public static final String ENDERECO = "endereco";
	public static final String CIDADE = "cidade";
	public static final String BAIRRO = "bairro";
	public static final String ESTADO = "estado";
	public static final String NASCIMENTO = "nascimento";
	public static final String JUGS = "jugs";
}

Criando as Entidades

Crie as classes Pessoa.java e Endereco.java no package br.com.danieldias.model , com o seguinte conteúdo :

package br.com.danieldias.model;

import java.util.Calendar;

import org.springframework.format.annotation.DateTimeFormat;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class Pessoa {

	private String nome;
	private String profissao;
	private String jugs;
	private int idade;
	private Endereco endereco;

	@DateTimeFormat(pattern="dd/MM/yyyy")
	private Calendar dataNascimento;

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

	public Pessoa(String nome, String profissao,
		      String jugs, int idade,
		      Endereco endereco,Calendar dataNascimento) {
		this.nome = nome;
		this.profissao = profissao;
		this.jugs = jugs;
		this.idade = idade;
		this.endereco = endereco;
		this.dataNascimento = dataNascimento;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public String getProfissao() {
		return profissao;
	}

	public void setProfissao(String profissao) {
		this.profissao = profissao;
	}

	public String getJugs() {
		return jugs;
	}

	public void setJugs(String jugs) {
		this.jugs = jugs;
	}

	public int getIdade() {
		return idade;
	}

	public void setIdade(int idade) {
		this.idade = idade;
	}

	public Endereco getEndereco() {
		return endereco;
	}

	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}

	public Calendar getDataNascimento() {
		return dataNascimento;
	}

	public void setDataNascimento(Calendar dataNascimento) {
		this.dataNascimento = dataNascimento;
	}
}

A classe pessoa bem simples, apenas com uma anotação na dataNascimento para o Spring lidar com esse tipo.

package br.com.danieldias.model;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public class Endereco {

	private String cidade;
	private String bairro;
	private String estado;

	public Endereco() {
		this("","","");
	}

	public Endereco(String cidade, String bairro, String estado) {
		this.setCidade(cidade);
		this.setBairro(bairro);
		this.setEstado(estado);
	}

	public String getCidade() {
		return cidade;
	}

	public void setCidade(String cidade) {
		this.cidade = cidade;
	}

	public String getBairro() {
		return bairro;
	}

	public void setBairro(String bairro) {
		this.bairro = bairro;
	}

	public String getEstado() {
		return estado;
	}

	public void setEstado(String estado) {
		this.estado = estado;
	}
}

Criando o Repositorio

Agora criaremos uma Inteface chamada MongoDAO e uma classe chamada PessoaDAO no package br.com.danieldias.persistencia, com os seguintes conteúdos:

package br.com.danieldias.persistencia;

import org.bson.Document;

import com.mongodb.client.MongoCursor;

import br.com.danieldias.model.Pessoa;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
public interface MongoDAO {

	void inserir(Pessoa pessoa);
	void atualizar(Pessoa pessoa);
	void excluir(Object _id);
	Document porId(Object _id);
	MongoCursor<Document>mostraTodos();
}

A classe PessoaDAO é onde fica todas as operações de CRUD para o MongoDB, nada muito fora do comum, tudo muito simples e fácil compreensão. Repare que estamos usando a classe Constantes aqui  no lugar de String para facilitar o entendimento e deixar o código mas limpo.

package br.com.danieldias.persistencia;

import static com.mongodb.client.model.Filters.eq;
import java.util.ArrayList;
import java.util.List;

import org.bson.Document;
import org.springframework.stereotype.Repository;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;

import br.com.danieldias.commons.Constantes;
import br.com.danieldias.model.Pessoa;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
@Repository
public class PessoaDAO implements MongoDAO {

	MongoClient conexao;
	MongoDatabase dataBase;
	MongoCollection<Document> collectionPessoas;

	public PessoaDAO() {
		conexao = new MongoClient();
		dataBase = conexao.getDatabase(Constantes.BANCO_NOME);
		collectionPessoas = dataBase.getCollection(Constantes.COLLECTION_NOME);
	}

	@Override
	public void inserir(Pessoa pessoa) {

		List<Document> jugs = new ArrayList<>();
		jugs.add(new Document(Constantes.NOME,pessoa.getJugs()));

		collectionPessoas.insertOne(
				new Document(Constantes.NOME,pessoa.getNome())
				.append(Constantes.IDADE, pessoa.getIdade())
				.append(Constantes.PROFISSAO, pessoa.getProfissao())
				.append(Constantes.ENDERECO,
						new Document(Constantes.CIDADE,pessoa.getEndereco().getCidade())
						.append(Constantes.BAIRRO, pessoa.getEndereco().getBairro())
						.append(Constantes.ESTADO, pessoa.getEndereco().getEstado())
						)
				.append(Constantes.NASCIMENTO, pessoa.getDataNascimento().getTime())
				.append(Constantes.JUGS,jugs)
				);
	}

	@Override
	public void atualizar(Pessoa pessoa) {

		collectionPessoas.updateOne(eq(Constantes.NOME,pessoa.getNome()),
				new Document("$set",
						new Document(Constantes.IDADE,pessoa.getIdade())
						.append(Constantes.PROFISSAO, pessoa.getProfissao())
						.append(Constantes.ENDERECO,
								new Document(Constantes.CIDADE,pessoa.getEndereco().getCidade())
								.append(Constantes.BAIRRO, pessoa.getEndereco().getBairro())
								.append(Constantes.ESTADO, pessoa.getEndereco().getEstado())
								)
						)
				);
	}

	@Override
	public void excluir(Object _id) {

		collectionPessoas.deleteOne(porId(_id));
	}

	@Override
	public Document porId(Object _id) {

		return collectionPessoas.find(eq("_id",_id)).first();
	}

	@Override
	public MongoCursor<Document> mostraTodos() {

		return collectionPessoas.find().iterator();
	}
}

Criando os Controles

O primeiro controle que iremos criar ,será o que chama a pagina principal listando todos os dados do banco quando iniciar a aplicação.

Crie uma nova classe chamada IndexController no package br.com.danieldias.controller, com o seguinte conteúdo :

package br.com.danieldias.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
@Controller
@RequestMapping("*")
public class IndexController {

	@RequestMapping("*")
	public String index() {
		return "redirect:/pessoas/listaPessoa";
	}
}

Ainda no mesmo package cria a classe PessoasControler com o seguinte conteúdo :

package br.com.danieldias.controller;

import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import br.com.danieldias.model.Pessoa;
import br.com.danieldias.persistencia.MongoDAO;

/**
 * @author daniel
 * github:Daniel-Dos
 * daniel.dias.analistati@gmail.com
 * twitter:@danieldiasjava
 */
@Controller
@RequestMapping("/pessoas")
public class PessoasControler {

	@Autowired
	MongoDAO dao;

	@GetMapping("/inserirPessoa.html")
	public ModelAndView cadastrar() {
		return new ModelAndView("inserirPessoa");
	}

	@GetMapping("/alterarPessoa.html/{_id}")
	public ModelAndView alterar(@PathVariable("_id") ObjectId _id) {
		return new ModelAndView("alterarPessoa","atualizar",dao.porId(_id));
	}

	@PostMapping("inserirPessoa")
	public String adicionar(Pessoa pessoa) {
		dao.inserir(pessoa);
		return "redirect:/pessoas/listaPessoa";
	}

	@GetMapping("listaPessoa")
	public String listar(Model model) {
		model.addAttribute("listas", dao.mostraTodos());
		return "lista";
	}

	@PostMapping("alterar")
	public String update(Pessoa pessoa) {
		dao.atualizar(pessoa);
		return "redirect:/pessoas/listaPessoa";
	}

	@GetMapping("remover/{_id}")
	public String deletar(@PathVariable("_id") ObjectId _id) {
		dao.excluir(_id);
		return "redirect:/pessoas/listaPessoa";
	}
}

Está classe também tem um conteúdo bem simples, a única diferença são as novas anotações para Mapping que a partir do Spring 4.3.0 , podemos está utilizando essas anotações : @GetMapping, @PostMapping, que são a mesma coisa quando fazemos desta maneira : @RequestMapping(value = “alterar”, method = “RequestMethod.POST”)

Criando as Views

Agora daremos inicio a criação de 3 páginas para nossa aplicação que são : alterarPessoa.jsp, inserirPessoa.jsp e lista.jsp, que devem ser criada na pasta views que fica dentro de WEB-INF .

Iniciaremos pela a página lista.jsp, onde a mesma terá uma tabela onde os dados serão apresentados, 3 links um para chamar a paǵina alterarPessoa.jsp passando um parâmetro que é seu id e um que irá chamar no controle o deletar com parâmetro id e um para estarmos adicionando os dados no formulario inserirPessoa.jsp

A página fica da seguinte forma :

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Lista de Pessoas</title>
</head>
<body>
		<h1 align="center">Listagem dos Dados</h1>
<a href="inserirPessoa.html">Adicionar</a>
		<table align="center" border="4">
		<tr bgcolor="gray">
		    <th>ID</th>
			<th>Nome</th>
			<th>Idade</th>
			<th>Profissão</th>
			<th>Cidade</th>
			<th>Bairro</th>
			<th>Estado</th>
			<th>Jugs</th>
			<th>Data</th>
			<th>Editar</th>
			<th>Deletar</th>
		</tr>
		<c:forEach items="${listas}" var="pessoas">
			<tr>
				<td>${pessoas._id}</td>
				<td>${pessoas.nome}</td>
				<td>${pessoas.idade}</td>
				<td>${pessoas.profissao}</td>
				<td>${pessoas.endereco.cidade}</td>
				<td>${pessoas.endereco.bairro}</td>
				<td>${pessoas.endereco.estado}</td>
				<td>${pessoas.jugs.get(0).nome}</td>
				<td>
				<fmt:formatDate value="${pessoas.nascimento}" pattern="dd/MM/yyyy"/>
				</td>
				<td><a href="alterarPessoa.html/${pessoas._id }">Alterar</a></td>
				<td><a href="remover/${pessoas._id}">Excluir</a></td>
			</tr>
		</c:forEach>
	</table>
</body>
</html>

Algo importante nesta tela. Aqui os atributos passado devem SER o mesmo que estão no mongoDB, ou seja as colunas tem que ter os mesmo nome. A mesma coisa nesse techo : ${pessoas.jugs.get(0).nome}, aqui estou retornado o primeiro posição no array, se quisermos chamar outra posição fazemos assim : ${pessoas.jugs.get(1).lideres}.

A proxima tela é um formulario bem simples com o seguinte conteudo :

<%@ page language="java" contentType="text/html; charset=UTF-8"     pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Inserir Pessoas</title>
	<link rel="stylesheet" href="../recursos/css/jquery-ui-1.9.2.custom.min.css">
<script src="../recursos/js/jquery-3.1.0.min.js"></script>
<script src="../recursos/js/jquery-ui-1.9.2.custom.min.js"></script>
<script src="../recursos/js/datepicker-pt-BR.js"></script>
<script type="text/javascript">
		$(function(){
		  $("#date").datepicker({
		      showOn:"button",
			  buttonImage:"../recursos/imagem/calendar.gif",
			  buttonImageOnly:true
		   });
		});
		</script>

</head>
<body>
<form  action="inserirPessoa" method="post">
<fieldset>
<legend>Dados</legend>

   Nome: <input type="text" name="nome" />

   Idade: <input type="number" name="idade"/>

   Profissão: <input type="text" name="profissao"/>

   Cidade: <input type="text" name="endereco.cidade"/>

   Bairro: <input type="text" name="endereco.bairro"/>

   Estado: <input type="text" name="endereco.estado"/>

   Data de Nascimento: <input id="date" type="text" name="dataNascimento" placeholder="dd/mm/yyyy"/>

   JUGS:
   <input type="checkbox" name="jugs" value="SouJava"/>SouJava
   <input type="checkbox" name="jugs" value="RioJug"/>RioJug
   <input type="checkbox" name="jugs" value="SouJava Campinas"/>SouJava Campinas

   <input type="submit" value="Cadastrar Dados."/></fieldset>
</form>

</body>
</html>

e última tela que contem um formulário já preenchido com os valores do banco que podem ser alterados :

<%@ page language="java" contentType="text/html; charset=UTF-8"     pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Alterar Pessoas</title>
</head>
<body>
<form  action="../alterar" method="post">
<fieldset>
<legend>Alteração de Dados</legend>

	Nome: <input type="text" name="nome" value="${atualizar.nome}" disabled="disabled"/>

    Idade: <input type="number" name="idade" value="${atualizar.idade}"/>

    Profissão: <input type="text" name="profissao" value="${atualizar.profissao}"/>

    Cidade: <input type="text" name="endereco.cidade" value="${atualizar.endereco.cidade}"/>

    Bairro: <input type="text" name="endereco.bairro" value="${atualizar.endereco.bairro}"/>

    Estado: <input type="text" name="endereco.estado" value="${atualizar.endereco.estado}"/>

              <input type="submit" value="Alterar Dados."/></fieldset>
</form>

</body>
</html>

Rodando a Aplicação

Com tudo pronto, podemos testar a nossa aplicação:

Primeiramente inicie o MongoDB  através do prompt/terminal com o seguinte comando : mongod, como na imagem

mongod

Depois rode a aplicação no tomcat , com o botão direito do mouse clique no seu projeto e vá em Run As -> Run on Server, ao inicia a aplicação a página principal será carregada com abaixo :

lista

Ao clicar em Adicionar irá para a tela de cadastro :

cadatrar

Ao clicar em adicionar, a pagina irá redirecionar para a tela principal novamente com os dados carregados :

retorno

Ao clicar no link Alterar, vai carregar a pagina de alteração de dados e se clicar em Excluir vai apagar o dado e vai voltar para a pagina principal :

alterar

RoboMongo

Com os nossos dados Gravados, podemos ver como fica a sua estrutura no banco, ao invés de utilizar o mongo Shell para visualizar os dados , irei usar uma ferramente de administraçao para está lidando com varias operações referente ao MongoDB, essa ferramente se chama RoboMongo , instalação facil basta descompactar e executar .

Ao executar o RoboMongo irá aparecer a seguinte tela :

robomongo

clique em Create , de um nome para a conexao e clique em OK :

teste

depois de salvo, clique em Connect, que irar leva-lo a seguinte pagina,basta clicar na collection pessoas e ira carregar os dados armazenados :

mostar

Bem isso é tudo, aqui aprendemos a como fazer uma aplicação Spring MVC com MongoDB e de quebra conhecemos uma nova ferramenta para o mesmo. O projeto pode ser baixado no meu GitHub.

REFERÊNCIAS

 http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/

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.

JAVA EE E MONGODB

A penúltima parte prática da  minha monografia de especialização em Desenvolvimento Java. Neste capitulo irá aprender a usar MongoDB juntamente com Java EE.

Boa Leitura.

Segundo Marchioni (2015) desenvolver uma aplicação para indústria de TI pode ser um grande desafio para qualquer desenvolvedor, pois a mesma precisa resolver algumas preocupações como segurança, portabilidade e alta disponibilidade. Sem contar que muito dessas aplicações precisa se comunicar com outros sistemas e ser gerado de um ponto central. Com a plataforma Java EE, podemos alavancar todas essas características e muito mais, com foco na preocupação mais importante, que é os seus requisitos de negócios.

Marchioni (2015) explica que o desenvolvimento da plataforma Java EE é feito através do Java Community Process (JCP), ela é uma comunidade encarregada de desenvolver as especificações para toda tecnologia Java. Esta comunidade é composta por especialista da indústria de TI que estabelecem a Java Specification Requests (JSRs), para as tecnologias Java EE. O Java EE é agora mais fácil e mais poderoso a cada novo lançamento. Seu conjunto de APIs disponíveis cresceu rapidamente e se tornando uma grande imagem da tecnologia,
como é mostrada na figura 51:

jee
Figura 51 – API Java EE Fonte: MARCHIONI,2015, p.88

Conforme mostrada na figura 51, o Java EE possuir muitas APIs para se está trabalhando. Utilizaremos alguns componentes do Java EE em nossos exemplos tais como Servlet para estar lidando com as requisições HTTP e a JSP para está interagindo com a Servlet, bem como usar como interface visual para o usuário.

Antes de iniciar o projeto, devemos obter um conteier para que o Java funcione na web. Nos exemplos será utilizado o Apache Tomcat que pode ser obtida em https://tomcat.apache.org/download-80.cgi, basta descompactar em qualquer local do computador e configurar o mesmo eclipse.

CRIANDO UM PROJETO JAVA WEB COM MONGO

Criaremos um projeto semelhante ao anterior utilizando também o maven, porem utilizando recursos do Java EE para construirmos uma aplicação baseada em web. Siga os passos nas figuras 52 a 54 para esta criando o projeto:

maven
Figura 52 – Novo Projeto Fonte: Gerado pelo Eclipse
maven2
Figura 53 – Seleção maven-archetype-webapp Fonte: Gerado pelo Eclipse
maven3
Figura 54 – Configurando o Projeto Fonte: Gerado pelo Eclipse

Após seguir como demonstrada nas figuras 52 a 54, será gerada um projeto no eclipse chamada JavaMongoWeb. Abra o arquivo pom.xml é configure de acordo com a figura 55:

   <dependencies>
           <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>1.2</version>
          </dependecy>

          <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
           </dependecy>

           <dependency>
                <groupId>org.mongodb</groupId>
                <artifactId>mongodb-driver</artifactId>
                <version>3.2.2</version>
           </dependecy>
    </dependencies>

 <build>
      <finalName>JavaMongoWeb</finalName>
         <plugins>
              <plugin>
                   <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.1</version>
                       <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                       </configutation>
                 </plugin>
          </plugins>
     </build>

Figura 55 – Adicionando Dependências – Fonte : Gerado pelo Eclipse

CRIANDO CLASSE MODELO

Nesta sessão será criada uma classe chamada Pessoa e será usado para mapear documentos MongoDB. Elas contêm os mesmos campos correspondentes do documento, conforme a figura 56:

public class Pessoa {

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

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

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

    // Getter e Setter foram emitido para abreviar.

Figura 56 – Classe Pessoa Fonte: Autoria Própria.

INSERINDO DADOS COM SEVLET E JSP

A figura 56 demonstra uma classe modelo para especificar um documento, esta classe contém quatro atributos declarados como private, juntamente com seus getters e setters que utilizaremos para recuperar e passar os valores, um construtor sem argumentos e um construtor com argumentos. Criaremos as próximas classes que serão quatro servlets para esta fazendo as operações no MongoDB.


@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 a conexao com o mongo
		MongoClient conexao = new MongoClient();

		// Acessando a DataBase TCC
		MongoDatabase database = conexao.getDatabase("TCC");

		// Recuperando a coleção
		MongoCollection<Document> collection = database.getCollection("usuarios");

		// inserindo os dados
		collection.insertOne(
				new Document("Nome",pessoa.getNome())
				.append("Idade", pessoa.getIdade())
				.append("Info",
						new Document("Email",pessoa.getEmail())
						.append("Telefone", pessoa.getTelefone())
						)
				);
	}

}

Figura 57 – Servlet Incluir Fonte: Autoria Própria.

Como podemos observar a inclusão dos dados, assim como as outras operações serão praticamente a mesma demonstrada na sessão anterior utilizando java puro. A figura 58 exibe um arquivo chamado incluir.jsp, e nele que inserimos os dados e o nosso servlet irá recuperar os valores passados para inclui-los no mongoDB:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"     pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Inserir Pessoa</title>
</head>
<body>
<form action="InserirControler" method="post">
		   Nome: <input type="text" name="nome"/>
		   Idade: <input type="number" name="idade"/>
		   Telefone: <input type="text" name="telefone"/>
		   Email: <input type="text" name="email"/>

	   <input type="submit" value="Cadastrar Dados no MongoDB"/>
	</form>

</body>
</html>

Figura 58 – incluir.jsp Fonte: Autoria Própria.

CONSULTANDO DADOS COM SEVLET E JSP

A figura 59 demonstra o servlet para retorna os dados do banco e apresentar os mesmos na jsp. A figura 60 demonstra como fica a página que irá exibir os dados vindos da servlet.

@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 a conexão
      MongoClient conexao = new MongoClient();

     // Acessando a DataBase TCC
     MongoDatabase dataBase = conexao.getDatabase("TCC");

     // Acessando a coleção
     MongoCollection<Document> collection = dataBase.getCollection("usuarios");

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

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

Figura 59 – Servlet Consultar Fonte: Autoria Própria.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" 	pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Lista dos Dados</title>
</head>
<body>
<form action="ConsultarTodosControler" method="post">
<table align="center" border="4">
<tr bgcolor="gray">
<th>Nome</th>
<th>Idade</th>
<th>Telefone</th>
<th>Email</th>
</tr>
<c:forEach items="${listas}" var="usuario">
<tr>
<td>${usuario.nome}</td>
<td>${usuario.idade}</td>
<td>${usuario.telefone}</td>
<td>${usuario.email}</td>
</tr>
</c:forEach></table>
<input type="submit" value="consultar" />
</form>

    </body>
</html>

Figura 60 – listar.jsp Fonte: Autoria Própria.

ATUALIZANDO DADOS COM SEVLET E JSP

A figura 61, demonstra o uso o update para estarmos alterando 3 campos
a partir de um critério de busca pelo campo nome para o primeiro documento
da coleção, lembrando de importar a classe import static com.mongodb.client.model.Filters.*; para utilização da função eq. A página dealteração dos dados é semelhante ao da figura 58, bastando alterar alguns itens, conforme é mostrada na figura 62.

@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 conexão
      MongoClient conexao = new MongoClient();

     // Acessando a DataBase TCC
     MongoDatabase dataBase = conexao.getDatabase("TCC");

     // Acessando a coleção
     MongoCollection<Document> collection = dataBase.getCollection("usuarios");

    // Update dos Dados
    UpdateResult update = collection.updateOne(eq("Nome",pessoa.getNome());
        new Document("$set",
            new Document("Info.Email",pessoa.getEmail())
                .append("Info.Telefone",pessoa.getTelefone())
                .append("Idade",pessoa.getIdate())
            ));
    }
}

Figura 61 – Servlet Update Fonte: Autoria Própria.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"     pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Atualizar Pessoa</title>
</head>
<body>
<form action="AlterarControler" method="post">
		   Nome: <input type="text" name="nome"/>
		   Idade: <input type="number" name="idade"/>
		   Telefone: <input type="text" name="telefone"/>
		   Email: <input type="text" name="email"/>

	   <input type="submit" value="Alterar Dados no MongoDB"/>
	</form>

</body>
</html>

Figura 62 – update.jsp Fonte: Autoria Própria.

DELETANDO DADOS COM SEVLET E JSP

Por último criaremos o servlet responsável por deletar os dados através de uma busca, passando como parâmetro o campo nome como critério, lembrando de importar a classe import static com.mongodb.client.model.Filters.*; para utilização da função eq. Como demonstrada na figura 63 e a página deletar.jsp na figura 64.

@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 conexão
      MongoClient conexao = new MongoClient();

     // Acessando a DataBase TCC
     MongoDatabase dataBase = conexao.getDatabase("TCC");

     // Acessando a coleção
     MongoCollection<Document> collection = dataBase.getCollection("usuarios");

    // Deletando dos Dados
    DeleteResult deleteResult = collection.deleteOne(eq("Nome",pessoa.getNome());
    }
}

Figura 63 – Servlet Deletar Fonte: Autoria Própria.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"     pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Deletar Pessoa</title>
</head>
<body>
<form action="DeletarControler" method="post">
		   Nome: <input type="text" name="nome"/>

	   <input type="submit" value="Alterar Dados no MongoDB"/>
	</form>

   </body>
</html>

Figura 64 – deletar.jsp Fonte: Autoria Própria.

Nesta sessão, abrangeu o uso da tecnologia Java EE trabalhando em conjunto com o MongoDB, através de Servlets e JSP para estarem interagindo e manipulando os dados entres os formulários web.

Como foi abordado ao longo dessas últimas sessões, a comunicação entre uma aplicação java seja ela web ou não com o Mongodb é bem simples de ser implementada e de fácil aprendizagem. Visto que não necessitamos utilizar SQL em nossos códigos e nem mesmo fazer uso de joins, tornando assim o desenvolvimento da aplicação bem rápida e pequena.

A próxima sessão será apresenta um framework Java de persistência especifico para bancos NoSQL, que irá facilitar ainda mais o desenvolvimento de muitas outras aplicações tanto web quanto aplicações para desktop.

REFERÊNCIAS

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