JSR-371 ( MVC 1.0 ) – Com TomCat & TomEE

Logo_MVC_twitter_cmyk
Barista Duke – [DOAG](https://www.doag.org/de/home/)

Neste post veremos como podemos utilizar o MVC 1.0 juntamente com TomCat e TomEE a partir do modulo Ozark-RestEasy que foi comentado no post anterior .

TOMCAT

Iniciaremos pelo Tomcat pois é o que da mais trabalho durante as configurações.

Crie um projeto maven com as seguinte dependências :


<!-- Get the API JARs for Java EE 7 -->
<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-web-api</artifactId>
    <version>7.0</version>
</dependency>

<!-- Weld  -->
<dependency>
    <groupId>org.jboss.weld.servlet</groupId>
    <artifactId>weld-servlet-core</artifactId>
    <version>2.4.3.Final</version>
</dependency>

<!-- RESTEasy -->
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-cdi</artifactId>
    <version>3.1.4.Final</version>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-servlet-initializer</artifactId>
    <version> 3.1.4.Final</version>
</dependency>

<!-- Bean Validation -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>5.4.1.Final</version>
</dependency>

<!-- MVC + Ozark for RESTEasy-->
<dependency>
    <groupId>javax.mvc</groupId>
    <artifactId>javax.mvc-api</artifactId>
    <version>1.0-pr</version>
</dependency>
<dependency>
    <groupId>org.mvc-spec.ozark</groupId>
    <artifactId>ozark-resteasy</artifactId>
    <version>1.0.0-m03</version>
</dependency>
 

feito isso, seguiremos para configuração dos arquivos beans.xml e context.xml :

dentro da pasta /src/main/webapp/WEB-INF crie um arquivo beans.xml com o seguinte conteudo :

 <?xml version="1.0"?>
<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
"version="1.1" bean-discovery-mode="all">

</beans>
 

agora na pasta src/main/resources/META-INF crie um arquivo context.xml com o seguinte conteudo :

 <?xml version="1.0" encoding="UTF-8"?>
<Context>

   <Resource name="BeanManager" auth="Container"
type="javax.enterprise.inject.spi.BeanManager"
factory="org.jboss.weld.resources.ManagerObjectFactory"/>

</Context>
 

Este arquivo é essencial para um correto funcionamento do CDI com o Tomcat, o mesmo é descrito aqui Weld Documentação .

Logo também devemos criar um aquivo web.xml na pasta src/main/webapp/WEB-INF com o seguinte conteúdo :

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

	<listener>
   	<listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>
</listener>

  <resource-env-ref>
    <resource-env-ref-name>BeanManager</resource-env-ref-name>
    <resource-env-ref-type>javax.enterprise.inject.spi.BeanManager</resource-env-ref-type>
  </resource-env-ref>

  <!--http://docs.jboss.org/resteasy/docs/3.1.4.Final/userguide/html_single/index.html#d4e143 -->
  <context-param>
    <param-name>resteasy.injector.factory</param-name>
    <param-value>org.jboss.resteasy.cdi.CdiInjectorFactory</param-value>
  </context-param>

</web-app>
 

Com tudo pronto, podemos da inicio a um Hello Tomcat seguindo os post anteriores.

TOMEE

O TomEE utilizar a CXF como implementação do Jax-RS, porem a Ozark no momento não suporta por causa de bugs no CXF causando problemas com a utilização do Ozark.

Como alternativa, podemos utilizar o modulo Ozark-RestEasy para o seu funcionamento.

crie um projeto maven com o seguinte conteúdo :

<dependency>
    <groupId>javax.mvc</groupId>
    <artifactId>javax.mvc-api</artifactId>
    <version>1.0-pr</version>
</dependency>

<dependency>
    <groupId>org.mvc-spec.ozark</groupId>
    <artifactId>ozark-resteasy</artifactId>
    <version>1.0.0-m03</version>
</dependency>

<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-cdi</artifactId>
    <version>3.1.4.Final</version>
</dependency>

<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-servlet-initializer</artifactId>
    <version>3.1.4.Final</version>
</dependency>

<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-web-api</artifactId>
    <version>8.0</version>
    <scope>provided</scope>
</dependency>
 

Da mesma forma que vimos para o TomCat vamos precisar configurar nosso XML, mas ao invés de 3, serão apenas o beans.xml e o web.xml.

o conteúdo do web.xml na pasta src/main/webapp/WEB-INF com o seguinte conteúdo :

 

<?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>tomee</display-name>
  <context-param>
	<param-name>resteasy.injector.factory</param-name>
	<param-value>org.jboss.resteasy.cdi.CdiInjectorFactory</param-value>
	</context-param>
</web-app>

Com tudo pronto, podemos da inicio a um Hello TomEE seguindo os post anteriores.

Bem isso é tudo, aqui aprendemos  como fazer a api MVC 1.0 funcionar no TomCat & TomEE, espero que gostem, o código pode se encontrado aqui .

Atualmente a SPEC esta em Public Review e também estão movendo para Fundação Eclipse sobre o Projeto EE4J.

Sinta-se livre para se juntar à nossa lista de discussão e nos informar o que você acha. Você pode publicar suas opiniões na lista ou registrar um problema no rastreador de problemas.

REFERÊNCIAS

 

Anúncios

JSR-371 ( MVC 1.0 ) – Validação

Logo_MVC_www_cmyk
Barista Duke – [DOAG](https://www.doag.org/de/home/)

Muita coisa mudou na SPEC desde no meu último post  sobre o tema, se não sabe do que estou falando, veja o post anterior aqui  para montar o projeto para esse post.

Uma dessas mudanças é era que originalmente a mesma só funcionava com uma versão especifica do Glassfish/Payara  por causa do Jersey na qual a spec foi construída. Pois bem, atualmente esse problema foi resolvido e podemos utilizar também com Wildfly através de um módulo chamado Ozark-RestEasy e um chamado Ozark-Jersey para GlassFish/Payara, desta maneira não ficamos agarrados somente com Jersey .

Neste post veremos rapidamente como fazemos validações com a SPEC e vamos roda-la utilizando o Payara-Micro e Wildfly-Swarm ( farei um post sobre isso em breve) com seus respectivos módulos .

Maven Dependencies

crie um projeto maven e configure o pom.xml da seguinte forma :

<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.org.soujava.rio</groupId>
	<artifactId>MVC-Validacao</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>MVC-Validacao Maven Webapp</name>
	<url>http://maven.apache.org</url>

	<organization>
		<name>SouJava { Rio }</name>
		<url>http://soujava-rio.github.io</url>
	</organization>

	<properties>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<failOnMissingWebXml>false</failOnMissingWebXml>
		<version.payara>1.0.0</version.payara>
		<version.swarm>2017.12.1</version.swarm>
	</properties>

	<developers>
		<developer>
			<name>Daniel Dias</name>
			<email>daniel.dias@soujava.org.br</email>
			<organization>SouJava { Rio }</organization>
		</developer>
	</developers>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.wildfly.swarm</groupId>
				<artifactId>bom-all</artifactId>
				<version>${version.swarm}</version>
				<scope>import</scope>
				<type>pom</type>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<dependencies>
		<dependency>
			<groupId>javax.mvc</groupId>
			<artifactId>javax.mvc-api</artifactId>
			<version>1.0-pr</version>
		</dependency>

		<dependency>
			<groupId>org.mvc-spec.ozark</groupId>
			<artifactId>ozark-core</artifactId>
			<version>1.0.0-m03</version>
		</dependency>

		<dependency>
			<groupId>org.eclipse.microprofile</groupId>
			<artifactId>microprofile</artifactId>
			<version>1.2</version>
			<type>pom</type>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.16.14</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<artifactId>hibernate-validator</artifactId>
			<groupId>org.hibernate</groupId>
			<version>5.4.1.Final</version>
		</dependency>

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

	<build>
		<finalName>MVC-VALIDACAO</finalName>
	</build>

	<profiles>
		<profile>
			<id>payara</id>
			<build>
				<plugins>
					<plugin>
						<groupId>fish.payara.maven.plugins</groupId>
						<artifactId>payara-micro-maven-plugin</artifactId>
						<version>${version.payara}</version>
						<executions>
							<execution>
								<goals>
									<goal>bundle</goal>
									<goal>start</goal>
								</goals>
							</execution>
						</executions>
						<configuration>
							<useUberJar>true</useUberJar>
							<deployWar>false</deployWar>
							<daemon>false</daemon>
							<payaraVersion>5.Beta1</payaraVersion>
						</configuration>
					</plugin>
				</plugins>
			</build>
			<dependencies>
				<dependency>
					<groupId>org.mvc-spec.ozark</groupId>
					<artifactId>ozark-jersey</artifactId>
					<version>1.0.0-m03</version>
				</dependency>
			</dependencies>
		</profile>

		<profile>
			<id>wildfly</id>
			<build>
				<plugins>
					<plugin>
						<groupId>org.wildfly.swarm</groupId>
						<artifactId>wildfly-swarm-plugin</artifactId>
						<version>${version.swarm}</version>
						<executions>
							<execution>
								<goals>
									<goal>package</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
			<dependencies>
				<dependency>
					<groupId>org.mvc-spec.ozark</groupId>
					<artifactId>ozark-resteasy</artifactId>
					<version>1.0.0-m03</version>
				</dependency>
			</dependencies>
		</profile>
	</profiles>
</project>

Criando as Classes

Vamos inicia pela a classe application.

Esta classe simplesmente inicia a nossa aplicação, para que funcione a validação corretamente  no Jersey devemos adicionar um pouco mais de código como pode ser visto abaixo :


@ApplicationPath("app")
public class APP extends Application {

	@Override
    public Map<String, Object> getProperties() {

		Map<String, Object> props = new HashMap<>();

        // https://github.com/jersey/jersey/issues/3659
        props.put("jersey.config.beanValidation.disable.validateOnExecutableCheck.server", true);

        return props;
    }
}
 

 

Na nossa classe modelo sera algo bem simples com dois atributos nome e e-mail juntamente com as anotações do Bean Validation/Hibernate Validation :

 


import javax.mvc.binding.MvcBinding;
import javax.validation.constraints.Size;
import javax.ws.rs.FormParam;

import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;

import lombok.Getter;

@Getter
public class JUG {

	@MvcBinding
	@NotEmpty
	@Size(min = 1, max = 20)
	@FormParam("nome")
	private String nome;

	@MvcBinding
	@Email
	@NotEmpty
	@FormParam("email")
	private String email;
} 

aqui a única novidade é a anotação @MvcBinding , que serve para habilitar as regras de vinculação específicas do MVC, para quando uma validação falhar não resulte em uma ConstraintViolationException. Em vez disto a correspondente ConstraintViolation é armazenada em uma instancia do BindingResult com escopo de solicitação que pode ser injetada no controlador.

Isso permite que o controlador manipule o erro ao invés de confiar em um mecanismo global de tratamento de erros, como um ExceptionMapper.

Vejamos como fica nosso controlador para o tratamento de erros de validação :


import java.util.stream.Collectors;

import javax.inject.Inject;
import javax.mvc.Models;
import javax.mvc.annotation.Controller;
import javax.mvc.annotation.View;
import javax.mvc.binding.BindingResult;
import javax.mvc.binding.ValidationError;
import javax.validation.Valid;
import javax.validation.executable.ExecutableType;
import javax.validation.executable.ValidateOnExecution;
import javax.ws.rs.BeanParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;

import br.org.soujava.rio.model.JUG;

@Controller
@Path("validacao")
public class ValidacaoController {

	@Inject
	private Models models;

	@Inject
	private BindingResult bindingResult;

	@POST
	@Path("validar")
	@ValidateOnExecution(type = ExecutableType.NONE)
	public String registrar(@Valid @BeanParam JUG jug) {
		if (bindingResult.isFailed()) {

			String erros = bindingResult.getAllValidationErrors()
					.stream()
					.map(ValidationError::getMessage)
					.collect(Collectors.joining("< br >"));

			models.put("erros", erros);
			return "form.jsp";
		}
		models.put("jug", jug);
		return "mensagem.jsp";
	}

	@GET
	@View("form.jsp")
	@Path("form")
	public void getForm() {
	}
}
 

Aqui precisamos injetar o nosso BindingResult e adicionar algumas configurações para que ocorra o tratamento de erros. Alem de injetar o BindingResult, precisamos também anotar nosso método com @ValidateOnExecution(type = ExecutableType.NONE) que de acordo com a SPEC , ela é necessária para garantir que o CDI e BV não abortem a invocação ao detectar uma violação. Assim, para garantir a semântica correta, a validação deve ser realizada pelo JAX-RS implementação antes do chamado método.

Para verificarmos os erros chamamos o método isFailed() que retorna TRUE se encontrar erros durante a validação.

Feito isso passamos para o para próxima instrução para pegarmos as mensagens de erros e exibir para usuário através da chamado getAllValidationErrors() que recuperar todos os erros de validação que ocorrer, fazemos um map para obter somente as mensagens de erros através da classe ValidationError do MVC , logo depois coletamos e juntamos com uma tag. Depois passo a minha variável para ser exibida na minha view através do Models que faz a ligação entre meu modelo e minha pagina .

Agora em nossa pagina JSP  fica da seguinte forma :


<%@ page contentType="text/html;charset=UTF-8" language="java"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MVC-VALIDACAO</title>
</head>
<body>

	<c:if test="${erros != null}">
<div>
<div>

< p style="background-color: red;" > ${erros} < / p ></div>
</div>
</c:if>
<form action="validar" method="post">

		<label for="nome">Nome:</label> <input id="nome" type="text" name="nome"/>
		<label for="email">Email:</label> <input id="email" type="text" name="email"/>

		<input type="submit" value="Registrar" />
	</form>

</body>
</html>

Agora bastamos rodar nossa aplicação com os seguinte comandos :

Payara-Micro :

mvn clean -P payara payara-micro:bundle && mvn -P payara payara-micro:start

bastando acessar a URL que sera exibida no terminal pronto .

Wildfly-Swarm :

mvn clean package -P wildfly && cd target/ && java -jar *.jar

bastando acessar a URL http://localhost:8080

error
Tela com erro de Validação .

Bem isso é tudo, aqui aprendemos  como fazer validação utilizado a api MVC 1.0 , espero que gostem, o código pode se encontrado aqui e uma demo rodando no Heroku com Wildfly-Swarm .

Atualmente a SPEC esta em Public Review e também estão movendo para Fundação Eclipse sobre o Projeto EE4J.

Sinta-se livre para se juntar à nossa lista de discussão e nos informar o que você acha. Você pode publicar suas opiniões na lista ou registrar um problema no rastreador de problemas.

REFERÊNCIAS

 

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

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.

 

 

COMUNICAÇÃO ENTRE JAVA E MONGODB

A Quinta postagem do blog será sobre a parte prática da  minha monografia de especialização em Desenvolvimento Java. Neste capitulo irá aprender a usar MongoDB juntamente com Java.

Boa Leitura.

Segundo o site da Oracle,

“Java é uma linguagem de programação e plataforma computacional lançada pela primeira vez pela Sun Microsystems em 1995. Existem muitas aplicações e sites que não funcionarão, a menos que você tenha o Java instalado, e mais desses são criados todos os dias. O Java é rápido, seguro e confiável. De laptops a data centers, consoles de games a supercomputadores científicos, telefones celulares à Internet, o Java está em todos os lugares!”

Segundo site do MongoDB (2016) para uma aplicação se comunicar com o MongoDB, precisamos de uma biblioteca cliente que chamamos de drivers. Estes drives lidam com toda a interação com o banco de dados em uma linguagem apropriada para a aplicação.

De acordo com Lennon (2012), “Drives oficiais disponíveis para C, C#, C++, Haskell, Java, JavaScript, Perl, PHP, Python, Ruby e Scala, com uma ampla variedade de drives suportados pela comunidade disponível para outras linguagens”.

OBTENDO O AMBIENTE DE TRABALHO

Nesta seção obteremos o nosso ambiente de desenvolvimento para trabalhar com o mongo no Java.

Inicialmente obteremos uma IDE para esta trabalhando com o Java, utilizaremos a plataforma eclipse, por ser considerada uma das melhores IDE para desenvolvimento na linguagem Java:

CRIANDO UM PROJETO JAVA COM MONGO

Iremos desenvolver uma simples aplicação Java utilizando o maven para esta obtendo o driver do mongo para sua conexão.

  • Vá em File → New → Maven Project e configure da conforme as figuras 43 e 44
43
Figura 43 – Novo Projeto Maven Fonte: Gerado pelo Eclipse
44
Figura 44 – Configuração do Projeto Maven. Fonte: Gerado pelo Eclipse.

Após seguir como demonstrada nas figuras 43 e 44, será gerada um projeto no eclipse chamado JavaMongo. Dentro deste projeto contém um arquivo chamado pom.xml, nele faremos umas configurações para o projeto bem como adicionar o driver do mongo para Java, como pode visto na figura 45:


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

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

Figura 45 – Adicionado o MongoDrive Fonte: Gerado pelo Eclipse

Conforme a figura 45, no arquivo pom.xml, adicionamos o driver do mongo como dependência do projeto, que ao salva o arquivo o maven irá fazer o download da biblioteca especificada, assim com outras bibliotecas que o mongo drive necessita.

A partir deste momento daremos início à criação das classes Java para funcionar com o mongodb.

CRIANDO A CONEXÃO

Segundo o site do Mongodb, o MongoDrive fornece 5 maneiras de está se conectando nossa aplicação com o banco, como observado na figura 46:

import java.util.Arrays;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;

public class ExemploConexao {

     // Primeiro método - Sem Parâmetro
     MongoClient primeiroExemplo = new MongoClient();

     // Segundo método - Somente ip/host
     MongoClient segundoExemplo = new MongoClient("localhost");

     // Terceiro método - ip/host e porta
     MongoClient terceiroExemplo = new MongoClient("localhost",27017);

     // Quarto método - Lista de Conexões
     MongoClient quartoExemplo = new MongoClient(
            Arrays.asList(
                    new ServerAddress("localhost",27017),
                    new ServerAddress("localhost",27018),
                    new ServerAddress("localhost",27019)
                  )
               );

     // Quinto método - conexão por URI
     MongoClientURI quintoExemplo = new MongoClientURI(
            "mongodb://localhost:27017,localhost:27018,localhost:27019");
     MongoClient quintoExemploURI = new MongoClient(quintoExemplo);

     // Acessando ou criando um dataBase / caso não exista, será criado.
     MongoDatabase dataBase = primeiroExemplo.getDatabase("TCC");
     System.out.println("Conectado com Sucesso!");
}

Figura 46 – Conexão com MongoDBB Fonte: Autoria Própria

Conforme visto na figura 46, foram exemplificadas as maneiras de está se conectando uma aplicação java. Ela é semelhante as conexões de bancos relacionais, principalmente na variável chamada quintoExemplo, onde é passada um endereço para sua conexão.

Ao executarmos esta classe, será criado automaticamente um banco de dados chamados TCC, caso o mesmo não exista.

INSERINDO DADOS NO BANCO

Para criar um documento, utilizamos a classe Document do mongo driver. No mongo driver, os métodos insertOne() e insertMany() estão presentes e são utilizados da mesma forma que no mongo shell e ainda podemos fazer uso de documentos incorporados.

Antes de estarmos inserindo documentos, precisaremos criar uma collection para esta armazenando os dados.

A figura 47, exemplifica a utilização tanto do método insertOne quanto do insertMany, acompanhado da criação da coleção:

      // Criando a conexão
      MongoClient conexao = new MongoClient();

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

      /*
       * Criando ou recuperando uma coleção
       * caso não exista, será criado uma collection usuarios
       */
        MongoCollection<Document> collection = dataBase.getCollection("usuarios");

       // Inserindo usando o insertOne()
       collection.insertOne(
               new Document("Nome","Daniel Dias")
                   .append("Idade",25)
                   .append("Info",
                         new Document("Email","daniel.dias.analistati@gmail.com")
                   .append("Telefone","21 1234-5678)
                 )
            );

     // Inserindo usando o insertMany()
     List<Document> documentos = new ArrayList<Document>();

     for(int i = 0; i < 2; i++) {
          documentos.add(
                  new Document("Nome","Daniel Dias")
                  .append("Idade",25)
                  .append("Info",
                         new Document("Email","daniel.dias.analistati@gmail.com")
                  .append("Telefone","21 1234-5678)
                )
           );
       }

       collection.insertMany(documentos);

Figura 47 – Inserir Autoria Própria

CONSULTANDO OS DADOS

Para retornar os dados utilizamos também o método find() que foi descrito em capítulo sobre o mongo shell.

Segundo o site do MongoDB, O método find() retorna uma instância de findIterable, que nos fornece uma interface fluente para encadear ou controlar as operações do find. Usando o método iterator() podemos obter um iterador sobre o conjunto de documentos que combinavam com a consulta e repita.

Podemos também querer retornar apenas um documento, através do método first() sobre o find(). Isso é útil para consultas que só deve corresponder a um único documento. A figura 48 demonstra o uso desses dois métodos:

     // Consultando todos os documentos
     MongoCursor cursor = collection.find().interator();

     try {
            while(cursor.hasNext()) {
                System.out.println(cursor.next().toJson());
            }
       } finally {
             cursor.close();
        }

      // Consultando o primeiro documento
      Document primeiroDocumento = 
                 collection.find(eq("Nome","Daniel Dias")).first();
      System.out.println(primeiroDocumento);

Figura 48 – Consultando Autoria Própria

ATUALIZANDO OS DADOS

Assim com o insert, o mongo drive oferece os mesmos métodos de update do shell que são updateOne e updateMany(). Esses dois métodos recebem dois argumentos para esta atualizando o documento, um é o critério de busca para o documento e a outra é um documento que contém os novos dados para atualização. A Figura 49 demonstra o uso dois métodos de update:

     // Atualizando o primeiro documento
     collection.updateOne(eq("Nome","Daniel Dias"),
          new Document("$set",
               new Document("Nome","Daniel")
             )
         );

    // Atualizando muitos documentos
    UpdateResult updateResult = 
                 collection.updateMany(eq("Nome","Daniel Dias"),
                     new Document("$set",
                           new Document("Info.Email","daniel@daniel.com.br")
                        )
                );      

Figura 49 – Alterando Autoria Própria

DELETANDO DADOS

O mongo drive contém métodos para remover documento de uma coleção. Os métodos correspondentes são deleteOne e deleteMany, que tem o mesmo funcionamento do que foi apresentado no mongo shell.  A figura 50 demonstra o uso destes dois métodos:

     // Deletando o primeiro documento
     collection.deleteOne(eq("Nome","Daniel"));

    // Deletendo todos os documentos
    DeleteResult deleteResult = 
             collection.deleteMany(eq("Nome","Daniel Dias")); 

Figura 50 – Deletando Autoria Própria

Algo importante a ser citado, tanto na operação de update quanto de deletar, foi incluída uma chama ao método eq, este método é utilizado para uma condição de busca no documento.

Para que o eclipse o reconheça será preciso importar sua classe com essa declaração :

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

Nesta sessão, abrangeu os primeiros passos com mongoDB e o Java, que permitiu executar as mesmas operações do mongo shell, que foi visto no capítulo anterior.

A sessão seguinte, iremos cria uma aplicação web simples utilizando o Java EE que usa Mongodb como armazenamento. Será demonstrada como esta tecnologia pode alavancar um cenário do mundo real usando construções simples.

REFERÊNCIAS

IBM – Lennon, Joe. Explore o MongoDB. 2011. Disponível em: < https://www.ibm.com/developerworks/br/library/os-mongodb4/ > Acesso em: 11 de maio 2016.

MongoDB. MongoDB Drivers and Client Libraries. 2016. Disponível em: < https://docs.mongodb.com/manual/applications/drivers/ >. Acesso em: 10 de junho 2016.

Oracle. O que é a Tecnologia Java e porque preciso dela? 2016. Disponível em: < https://www.java.com/pt_BR/download/faq/whatis_java.xml >. Acesso em: 10 de junho 2016.