Eclipse Che sua IDE na nuvem.

wl-eclipse-che

Neste post veremos como podemos utilizar a IDE Cloud Eclipse Che para para desenvolver nossas aplicações Java .

Introdução ao Eclipse Che

Eclipse Che é um servidor de WorkSpace baseado em Java de código aberto uma IDE em nuvem que fornece uma plataforma de desenvolvimento remoto para fins de multiusuários . O Servidor de WorkSpace vem com um serviço de RestFul e oferece alta flexibilidade, além de conter um SDK que pode ser usado para criar plugins para linguagens, ferramente ou frameworks.

A principal diferença entre o Eclipse Che e o Eclise IDE padrão é a capacidade de criar contêiner Docker para executar os aplicativos.

O eclipse Che suporta as seguintes Linguagens e Frameworks :

  • C++ , Java, JavaScript, PHP, Python, Ruby, SQL
  • .Net 2.0, AngularJS, Docker, OpenShift, Yeoman
  • Ant, Bower, Grunt, Gulp Maven, Npm
  • Git, Orion, SSH, SubVersion

Após a carga inicial, a IDE fornece uma interface de usuário dinâmica, incluindo componentes conhecidos como assistentes, editores, barras de ferramentas e muito mais. O usuário tem a oportunidade de criar espaços de trabalho, projetos, ambientes, máquinas e muitos outros módulos que são necessários para criar um projeto a partir do zero.

A comunicação entre a interface do usuário e o servidor é feita usando as APIs RESTful que interagem com o chamado Master de WorkSpace .

Um espaço de trabalho pode incluir zero ou mais projetos e deve, pelo menos, incluir um ambiente, que ele próprio contém pelo menos uma máquina.

Uma máquina é um tempo de execução que possui o software necessário. Se o usuário adicionar, por exemplo, um projeto que usa o Apache Maven, o Workspace Master instala o Maven em qualquer máquina no espaço de trabalho para garantir que o projeto possa ser executado em cada máquina.

Che vem com algumas pilhas de tecnologia predefinidas para configurar rapidamente uma nova máquina. Para garantir alta flexibilidade e extensibilidade, o usuário também pode definir pilhas de tecnologia personalizadas que podem ser usadas para configurar novas máquinas. Por padrão o Eclipse Che é executado em um servidor Apache Tomcat utilizando a porta 8080.

O leitor pode ler mais sobre o assunto nos seguintes links :

Bem feita essa rápida introdução sobre o Eclipse Che, vamos partir para a parte legal, a prática .

Requisitos

  • Docker 17+  instalado em sua maquina -> Download .

Feito a instalação do Docker , podemos seguir com a instalação do Eclipse Che .

Instalando o Eclipse Che

Para instalar execute o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 start

A  apos esse comando, ele ira baixar as imagens necessárias para sua inicialização e a saída sera semelhante a essa :

start

Antes de fazemos qualquer coisa, iremos modificar algumas coisa em sua configuração, como habilitar o uso externo do Maven local, utilizar o Eclipse Che em modo OFFLINE e alterar o modo de como o Eclipse Che faz o Pull das imagens .

Primeiro de tudo, pare a execução do container e remova o mesmo com o seguinte comando :

docker stop che && docker rm che

apos isso vamos alterar o seguinte arquivo  “che.env” que fica localizado da pasta Data na hora de monta o volume, no meu caso fica em “/home/daniel/eclipseChe/data“, abra o arquivo dando acesso para alteração ao mesmo e procure e descomente os seguintes trechos :

  • CHE_DOCKER_ALWAYS__PULL__IMAGE=false : Se TRUE, o Che sempre ira fazer PULL de uma imagem do registro, mesmo que seja armazenada em Cache. Se FALSE, o Docker so faz pull se a imagem não existir localmente.
  • CHE_WORKSPACE_VOLUME= : Uma lista separada por “;” para montagem de volumes. Che ira montar o volume destas pasta host em cada workspace. Esse é uma maneira de permitir que você forneça acesso compartilhado em vários workspace . No meu caso ficaria assim :

CHE_WORKSPACE_VOLUME=/opt/apache-maven-3.5.2/repo:/home/user/.m2/repository;

/data/db:/data/db;

/home/daniel/oracle/postgre/data/:/var/lib/postgresql/data;

feita essas mudanças salve o arquivo, vamos partir para o modo OFFLINE .

A instalação offline baixa a CLI, as principais imagens do sistema e todas as imagens de pilha enquanto você está dentro de uma DMZ de rede com acesso DockerHub. Você pode então mover esses arquivos para um ambiente seguro e começar o Che.

1-  Salvando as imagens :

Enquanto estiver conectado a internet o Che ira fazer o download das imagens docker com o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 offline

a saída será semelhante a essa :

offline

no meu caso ele só fez o download do “docker_compose:1.10.1.tar”, pois já tenho as outras imagem baixadas anteriormente.

A CLI irá baixar imagens e salvá-las em /backup/*.tar com cada imagem salva como seu próprio arquivo. Você pode salvar esses arquivos em uma localização diferente por volume, montando uma pasta local para: / data / backup. A tag de versão da imagem CLI Docker será usada para determinar quais versões de imagens dependentes para download. Há cerca de 1GB de dados que serão salvos.

Você também pode fazer o download das Stacks separadamente com o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 offline --list

ao executar ira mostrar uma lista de imagens conforme a imagem :
stacks
para fazer o download de uma stack especifica executamos o seguinte comando :
docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data
eclipse/che:6.1.1 offline --image:nomeDaImagem

feito isso podemos iniciar nosso Eclipse Che em modo OFFLINE e iniciar nosso Hello-World .

Para iniciar o Eclipse Che execute o seguinte comando :


docker run -it --rm
-v /var/run/docker.sock:/var/run/docker.sock
-v seuCaminho:/data:/data eclipse/che:6.1.1 start --offline

a saída sera semelhante a essa com todos os tar’s carregados :

offiline2

agora basta abri o seu navegador passando o endereço informado na tela, que no meu caso é http://192.168.1.100:8090 e a seguinte tela ira abrir :

workspace

No meu caso meu “Dashboard” contem um workspace criado com 2 projetos nele. Vamos criar um do zero agora .

Criando o WorkSpace

Primeiramente clique em “Create Workspace “, isso ira abri a seguinte tela :

newWorkspacenewWorkspace2

Nesta tela é aonde criamos nosso workspace com algumas stack prontas uso .

Uma Stack é um modelo de configuração de workspace e algumas meta-informações como escopo, tags, componentes, descrição, nome e ID. As Stacks são usadas pelo Dashboard para facilitar a criação de workspace e bem como projetos de exemplo de filtro compatíveis com uma pilha escolhida.

As pilhas são exibidas no Painel do Usuário na página Criar uma área de trabalho. Você pode filtrá-los por tipo (single vs multi machine), scope (os exibidos por padrão vs outros), bem como procurar uma pilha por palavra-chave.

Para o primeiro exemplo iremos criar um projeto simples com uma Servlet, então fazemos o seguinte :

1 – De um nome para o WorkSpace.

2 – Escolha a Stack “Java” abaixo da Stack “Blank”

3 – Clique em “CREATE”

4 – ira apresentar uma popup com duas opções “Edit” ou “Open in IDE”, escolha a segunda opção .

Apos isso ira abri o editor conforme a imagem :

tela

Com a tela aberta vá no menu “Workspace” e clique em “Create Project” ou aperte “Alt + X” ira abir a seguinte tela :

newProject

escolha “Maven” e preencha o formulário de next e configure da seguinte forma :

newProject2

logo apos ira ter um projeto chamado Demo na workspace :

project

feito isso, abra o pom.xml e configure da seguinte forma :

 

depois clique com botão direito no seu projeto e vá no menu “Maven” ->”ReImport”, feito isso crie um “pacote” na pasta “java”  e em seguida cria uma classe Java com o seguinte conteúdo :


package br.org.soujava.rio.minhaServlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/minhaServlet")
public class MinhaServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {

  PrintWriter out = response.getWriter();
  out.println("<h1>Minha Primeira Servlet com Eclipse CHE.</h1>");
  }
}

 

feito isso, vá na aba “Manage Commands” conforme a imagem :

manage

em seguida altere o “build ” com o seguinte comando  na parte “Command Line”, clique em “Save” e depois em “Run” :


mvn -f ${current.project.path} clean install
cp ${current.project.path}/target/*.war /home/user/tomcat8/webapps/

 

Apos isso, seu o projeto vai esta na pasta do Tomcat, agora para executar vamos criar um outro comando, para isso clique me “RUN” escolha a opção “Maven” e adicione o seguinte comando na “Command Line:


$TOMCAT_HOME/bin/./startup.sh

 

e em “Preview URL adicione o seguinte comando:


${server.tomcat8}/Demo-1.0-SNAPSHOT/minhaServlet

 

salve e execute e acesse o seguinte endereço : http://seuIp:32769/Demo-1.0-SNAPSHOT/minhaServlet :

servlet

parabéns conseguimos executar nossa primeira Servlet com Eclipse Che .

Os comandos são instruções de script que são injetadas na máquina do espaço de trabalho para execução. Os comandos são salvos no armazenamento de configuração do seu espaço de trabalho e fazem parte de qualquer exportação de espaço de trabalho.

para aprender mais sobre os comandos acesse o seguinte link.

A próxima demo faremos uso de múltipla maquinas onde iremos conectar nossas aplicações ao um Banco de Dados ou qualquer outra coisa. No nosso caso iremos usar um banco de dados.

Se o leitor percebeu la no começo quando estávamos criando uma workspace tinha varias stacks prontas para uso inclusive uma com Java + MySQL, porem o leitor pode não querer usar o MySQL, mas sim um PostGres ou até mesmo um NoSQL como MONGO DB.

Como podemos perceber não temos Stack para a mesma, então a gente ira criar uma stack personalizada se baseando na stack do MySQL.

Para isso vamos no menu “Stacks” conforme a imagem :

stacks2

nessa tela procure por “Java-MySQL” e clique em “Duplicate Stack” , logo em seguida clique na Stack duplicada e sera apresentada a seguinte tela :

newStarkc

agora vamos configurá-la para ele ser um Stack com banco NoSQL- MongoDB

1 – Altere o nome da stack para Java-Mongo ou qualquer outro nome.

2 – em “Machines” altere o “db”  :

2-1 – em “Source” adicionar : “mongo:latest” esse é o nome da imagem que o docker ira fazer o pull .

2-2 – em “Servers” alterar a porta para “27017” e mudar o reference também.

3 – vá em “Raw Configuration” e altere o trecho “content” para :


content": "services:\n db:\n image: 'mongo:latest'\n mem_limit: 1073741824\n dev-machine:\n image: eclipse/ubuntu_jdk8\n mem_limit: 2147483648\n depends_on:\n - db\n"

 

o arquivo final fica assim :

logo em seguida salve a nova Stack e vamos utilizá-la agora, para isso crie um novo workspace e selecione a nova stack criada.

La no começo eu ensinei a apontar a pasta local para se comunicar com a pasta do conteiner no trecho : CHE_WORKSPACE_VOLUME= , aonde eu aponta minha pasta “data/db” para a do conteiner.

Feito isso clique me Create e em “Open in IDE”, ele ira iniciar o Mongo e logo em seguida ira iniciar o a maquina de Dev :

mongo

agora iremos criar um projeto para utilizar essa nova stack, para isso va no menu “Workspace” e clique em “Import Project” > “Git” e adicione o seguinte endereço :  https://github.com/Adopt-a-JSR/MVC1.0.Ozark.git e clique em import, logo em seguida selecione “Maven” depois em “Next”, selecione “war” e depois clique em “Save” .

feito isso, abra o pom.xml para fazermos algumas modificações :

agora iremos modifica duas classes :

1 – DocumentCollectionProducer.java = alterar “localhost” para “db” que é o nome da maquina do mongodb

2- PersonController.java =  adicionar o import  org.mvcspec.ozark.engine.Viewable;”

essa mudança é necessária pois estamos usando uma versão nova da lib da Ozark.

feito isso, vamos criar um comando para fazer o build e executar a aplicação .

no “Command Line” adicione o seguinte trecho :


mvn clean package -f ${current.project.path}

&& cd ${current.project.path}/target

&& java -jar payara-micro.jar --deploy MVC1.0.Ozark.war

e em “Preview URL” adicionar o seguinte trecho :


${server.tomcat8}/${current.project.relpath}

e clique em “Run” e acesso  o endereço : http://192.168.1.100:32802/MVC1.0.Ozark/ :

payara

Bem isso é tudo, espero que os leitores tenham gostado de conhecer um pouco sobre Eclipse Che.

Continue seus estudos explorando mais essa IDE e criando novos Stacks personalizadas.

mais exemplos: https://www.eclipse.org/che/docs/tutorials/multi-machine/index.html

REFERÊNCIAS

Anúncios

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.

Logo_MVC_twitter_cmyk

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. Aqui vamos utilizar uma versão especifica do GlassFish que pode ser baixada no seguinte link : http://download.oracle.com/glassfish/5.0.1/nightly/latest-web.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 :

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

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 {

	MongoClient conexao;
	MongoCollection 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 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 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 {

	void inserir(T entidade) throws MongoException;
	void alterar(T entidade) throws MongoException;
	void deletar(ObjectId _id) throws MongoQueryException;
	MongoCursor 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 org.mvcspec.ozark.engine.Viewable;
import javax.mvc.Controller;
import javax.mvc.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 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 :

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 :

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

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

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

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.