Criando uma aplicação REST com SparkJava

Spark_Java_Logo
SparkJava-Logo

Neste post veremos como podemos utilizar o framework SparkJava para criamos api’s rest rapidamente.

Para esse post criaremos um simples hello-world e um CRUD com as seguintes tecnologias :

Introdução ao SparkJava

SparkJava é um micro framework para criação de aplicações web em Kotlin e Java 8 com mínimo de esforço.

A intenção da Spark é fornecer uma alternativa para os desenvolvedores de Kotlin / Java que desejam desenvolver suas aplicações web tão expressivas quanto possível. Com uma filosofia clara, a Spark foi projetada não só para torná-lo mais produtivo, mas também para melhorar o seu código sob a influência da sintaxe elegante, declarativa e expressiva da Spark.

Com a onda de microservice que a grande maioria utilizar Spring Rest ou até mesmo soluções Java EE com Jersey/RestEasy, o Spark não fica de fora dessa onda, a mesma fornece uma  API REST pronta para atender a JSON em menos de dez linhas de código.

Spark é usado principalmente para criar APIs REST, mas também oferece suporte a uma infinidade de template engines como :

Algo importante a se citar , não confundi com Apache Spark, apesar do mesmo nome, tem objetivos diferentes.

vejamos um simples Hello-World :

import static spark.Spark.*;

public class HelloWorld {
public static void main(String[] args) {
   get("/hello", (req, res) -> "Hello World");
   }
}

agora no navegador basta usar http://localhost:4567/hello e pronto.

Bem feita essa rápida introdução sobre o framework, vamos partir para construção do nosso projeto .

Criando o Projeto

Crie um projeto Maven com seguinte  pom.xml :

 

após criar o projeto, crie dois arquivo xml na pasta “resource/META-INF” conforme mostrado abaixo :

agora daremos inicio na construção das nossas classes,  começaremos pelas classes model :


package br.org.soujava.rio.model;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import lombok.Data;

@Data
@Entity
public class JUG implements Serializable {

private static final long serialVersionUID = 1L;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String nome;
private String leader;
private String descricao;
private String email;
}

e agora a classe que retorna um código e uma mensagem de resposta de sucesso ou erro durante o uso da api :


package br.org.soujava.rio.model;

import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class ResponseModel {

private int codigo;
private String mensagem;
}

agora criaremos duas classes produtoras utilizando o CDI, uma das classe é para o EntityManager – JPA e uma para JSON-B :


package br.org.soujava.rio.produces;

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.context.RequestScoped;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Produces;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

@ApplicationScoped
public class EntityManagerProducer {

@Produces
public EntityManager criarEntityManager() {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("soujava-rio");
return emf.createEntityManager();
}

public void closeEntityManager(@Disposes EntityManager manager) {
manager.close();
 }
}


package br.org.soujava.rio.produces;

import javax.enterprise.inject.Produces;
import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;

public class JsonBindProduces {

@Produces
public Jsonb createJsonB() {
Jsonb jsonb = JsonbBuilder.create();
return jsonb;
 }
}

aqui fizemos o uso de duas anotações do CDI o @Produces e @ApplicationScope :

  • @ApplicationScoped : mantém a instância durante todo o tempo de execução da aplicação. É um escopo que compartilha os objetos para todos os usuários do sistema.
  • @Produces: Os Producer Methods são apenas métodos que produzem objetos que serão administrados pelo container CDI e injetados em outros objetos.

JSON-B é uma camada de ligação padrão para converter objetos Java em / de mensagens JSON. Ele define um algoritmo de mapeamento padrão para conversão de classes Java existentes para JSON, enquanto permite que os desenvolvedores personalizem o processo de mapeamento através do uso de anotações Java.

JSON-B foi incluída no Java EE 8 e é uma alternativa ao Jackson e Gson.

Com os nossos produtores feitos, faremos a parte de persistência de  dados utilizando o DeltaSpike-Data.

O deltaSpike-Date é uma alternativa ao Spring-Data para fazermos nossas persistência de forma simples e objetiva, conforme pode ser visto abaixo :


package br.org.soujava.rio.repository;

import org.apache.deltaspike.data.api.EntityRepository;
import org.apache.deltaspike.data.api.Repository;

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

@Repository
public interface JUGRepository extends EntityRepository { }

em seguida criaremos uma classe uma classe utilitária que ira usar o ResponseTransformer do Spark  que transformam as rotas mapeadas a saída do método do identificador. Isso é feito estendendo o objeto ResponseTransformer e passando para o método de mapeamento. Exemplo de uma rota que transforma a saída para JSON usando o Json-B :


package br.org.soujava.rio.transformer;

import javax.inject.Inject;
import javax.json.bind.Jsonb;

import spark.ResponseTransformer;
public class JsonTransformer implements ResponseTransformer  {

@Inject
private Jsonb jsonb;

@Override
public String render(Object model) throws Exception {
return jsonb.toJson(model);
  }
}

Agora iremos fazer nossa classe Principal para nosso serviços Rest :

esse é a nossa classe principal para executarmos o nosso serviço, como pode ser visto não foi utilizado o metodo main como foi demostrado no exemplo do hello-world, neste caso a aplicação vai ser executada pelo conteiner do CDI, então irei explicar algumas partes do codigo :

Nas linhas 24 a 31 utilizamos a anotação @Inject para injetarmos nossas dependencias.

Na linha 33 temos um metodo chamado main contento uma anotação @Observes e uma classe chamada ContainerInitialized, essa anotação ficara observando ou de olho no evento ContainerInitialized, que será disparada quando a classe org.jboss.weld.environment.se.StartMain for chamada ao iniciar nossa aplicação, esse chamada foi declara no pom.xml na linha 89 .

Logo em seguida na linha 35 declaramos um metodo estatico port() passando o 8080 como a porta a ser utilizada na aplicação que por default é 4567 ,  em seguida tambem declaramos uma chamada de uma classe e o seu metodo estatico que habilita um filtro CORS para nossa aplicação poder ser usada em outros dominios, o conteudo da classe será mostrado depois .

Na linha 38 é onde começamos de fato a nossa api Rest, no SparkJava é chamado de Routes, nossa primeira rota é o Path, assim como no Jax-RS que é o equivalente ao @Path(“”) e no Spring RequestMapping(“”) .

logo depois temos as rotas Post,get,put e delete nas linhas 40 a  75 passando como paramentro o caminho para ser acessado, bem como os callback para request e response.  Como pode ser visto estamos utilizando o lambda do Java, dentro dela temos setado o tipo de conteudo que a api ira responder, no caso setamos para Json.

Em seguida declaramos um objeto JUG que recebe a variavel json.fromJson() do JSON-B para a mesma fazer a serialização de Json para objeto do tipo JUG e dentro desse metodo chamamos o req.body() que é o corpo de solicitação enviado pelo cliente, lego depois esse objeto é salvo no banco de dado H2 e depois retorna uma mensagem e um codigo em Json atraves da classe ResponseModel que foi feita a transformação atraves da chamada do metodo jsonTransformer que foi comentada algumas linhas acima.

isso em JAX-RS seria :


@POST
@Path("/cadastrar")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
	public Response cadastrarJUG(JUG jug) {
		try {
			jugRepository.save(jug);
			return Response.ok().entity(new ResponseModel(1,"JUG Adicionada Com Sucesso!")).build();
		} catch (Exception e) {
			return Response.ok().entity(new ResponseModel(0,e.getMessage())).build();
		}
	}

Na linha 56 tenho um get com parametros para codigo,  que o mesmo é pega utilizando o req.params(“codigo”); , traduzindo isso para Jax-RS é o equivalente a :


@GET
@Path("consultar/{codigo}")
public Response consultarJUG(@PathParam("codigo") Long codigo) {
JUG jug = this.jugRepository.findBy(codigo);
return Response.ok().entity(jug).build();
}

e para finalizar vejamos como fica a classe CorsFilter.enableCORS(); :


package br.org.soujava.rio.filter.cors;

import static spark.Spark.before;
import static spark.Spark.options;

public final class CorsFilter {

	public static void enableCORS() {

		options("/*", (request, response) -> {

			String accessControlRequestHeaders = request.headers("Access-Control-Request-Headers");
			if (accessControlRequestHeaders != null) {
				response.header("Access-Control-Allow-Headers", accessControlRequestHeaders);
			}

			String accessControlRequestMethod = request.headers("Access-Control-Request-Method");
			if (accessControlRequestMethod != null) {
				response.header("Access-Control-Allow-Methods", accessControlRequestMethod);
			}
			return "OK";
		});

		before((request, response) -> {
			response.header("Access-Control-Allow-Origin", "*");
			response.header("Access-Control-Request-Method", "GET, POST, PUT, DELETE, OPTIONS, HEAD");
			response.header("Access-Control-Allow-Headers", "origin, content-type, accept, authorization");
			response.type("application/json");
		});
	}

apos isso podemos fazer build de nossa aplicação com o comando :


mvn clean package

apos isso dentro da pasta target tera o seguinte conteúdo :

spark

a pasta dependency-jars contem as libs que utilizamos no nosso pom.xml, agora basta executar o jar com o comando :


java -jar SparkJava-sample.jar

e fazer o uso conforme mostrado usando o PostMan :

post

também pode fazer uso de algum framework JavaScript como Angula para consumir a api como mostrada na imagem abaixo :

front

Bem isso é tudo, espero que os leitores tenham gostado de conhecer um novo framework para construções de serviços Rest rapidamente como alternativa ao JAX-RS e Spring-Rest.

Código-fonte : https://github.com/SouJava-Rio/soujava-rio-labs/tree/master/spark-samples/CRUD-Deltaspike-CDI-Angular

Front-End : https://github.com/SouJava-Rio/soujava-rio-labs/tree/master/spark-samples/CRUD-Deltaspike-CDI-Angular/app-jug

Imagem Docker : https://hub.docker.com/r/danieldiasjava/sparkjava-crud/

REFERÊNCIAS

Anúncios

Executando sua aplicação Java na Oracle Application Container Cloud Service

cloudgs_appcontainer

Neste post veremos como  utilizar a plataforma de Cloud da Oracle executar nossas aplicações Java no serviço de Application Container .

Obtendo uma Conta Free

Antes de iniciarmos nossa aventura, você vai precisar criar uma conta na Oracle Cloud para poder utilizar os serviços.

Para isso basta acessar o site : http://cloud.oracle.com/ e criar uma conta trial que te dar $300(900 BRL) para testar a plataforma por 30 dias.

trial
http://cloud.oracle.com/

Bastando preencher os campos solicitado e informar o numero do cartão de credito para que o cadastro seja completado, porem não se preocupe que não sera cobrado nada apos o termino dos 30 dias, a menos que optar por fazer upgrade para uma conta paga para continuar a usar os serviços.

Feito o cadastro, basta aguardar um e-mail de boas vindas com as sua credenciais para acesse a plataforma Oracle Cloud , que leva mais ou menos uns 2 dias.

Oracle Application Container Cloud Service

O Oracle Application Container Cloud Service permite que você implemente aplicativos Java SE, Node.js, PHP, Python, Ruby, Go e .NET para Oracle Cloud. Você também pode implantar aplicações Java EE.

A inscrição no Oracle Application Container Cloud Service disponibiliza todos os tipos quando você faz o deploy. Seu aplicativo é executado em um recipiente Docker.

Com tudo esse serviço oferece os seguinte recursos :

  • Um ambiente pré-configurado para aplicativos Java SE, Java EE, Node.js, PHP, Python, Ruby, Go e .NET.
  • Java SE recursos avançados, como Java Flight Recorder, Java Mission Control, gerenciamento avançado de memória e atualizações de segurança.
  • Plataforma aberta que suporta todos os frameworks Java e contêineres, como Spring, Play, Tomcat e Jersey.
  • Suporte para linguagens baseadas em Java Virtual Machine (JVM), como JRuby. Você pode executar qualquer idioma que use o Java Virtual Machine neste serviço.
  • Suporte de nível empresarial da Oracle.
  • Interface de usuário baseada na Web e API REST.

Além disso, você pode optar por se integrar com outros serviços Oracle Cloud. Você pode desenvolver sua aplicação em seu sistema local ou pode usar o Oracle Developer Cloud Service.

Se você quiser armazenar e recuperar dados, você pode usar Oracle Cloud Infrastructure Object Storage Classic – uma assinatura está incluída. Você também pode se inscrever no Oracle Database Cloud Service ou no MySQL Cloud Service.

Para implantar um aplicativo e configurar um banco de dados em uma única etapa, você pode usar o Oracle Cloud Stack Manager.

Para comunicação, você pode se inscrever no Oracle Messaging Cloud Service. Sua aplicação se comunica com esse serviço através da sua API REST, portanto, nenhuma configuração de segurança especial é necessária.

Bem feita essa rápida introdução sobre o serviço, podemos da inicio ao processo de criação de um app e logo depois uma instancia na Oracle Cloud.

Criando o Projeto

Para esse post criaremos um simples app rest utilizando Payara-micro e Microprofile .

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

dep

dep2

feito isso crie duas classes com o seguinte conteúdo :


@ApplicationPath("app")
public class Boot extends Application { }

 

@Path("JUG")
@Produces(MediaType.APPLICATION_JSON)
public class JUGService {

@Inject
@ConfigProperty(name = "jug.nome")
private String jugNome;

@Inject
@ConfigProperty(name = "jug.leaders")
private String jugLeaders;

@Inject
@ConfigProperty(name = "jug.descricao")
private String descricao;

@GET
public Response getJUG() {
JsonObject json = Json.createObjectBuilder()
.add("Jug", jugNome)
.add("Lideres", jugLeaders)
.add("Descrição", descricao)
.build();

String resultado = json.toString();
return Response.ok().entity(resultado).build();
}
}

 

agora dentro da pasta “META-INF” crie um arquivo beans.xml e um “microprofile-config.properties” :

 

jug.nome = SouJava { Rio }
jug.leaders = Daniel Dias, Paulo Simões, Ulisses Telemaco
jug.descricao = SouJava - Fortalecendo a comunidade Java brasileira.
beans
beans.xml

 

agora podemos fazer o build do projeto e executa-lo localmente, para isso faça o seguinte comando :


mvn clean install

 

sera gerado o build do seu projeto alem de fazer o download do payara-micro conforme a seguinte imagem :

build

para executar seu projeto localmente faça o seguinte comando :


java -jar payara-micro.jar --deploy microprofile-sample.war

após executa-la você poderá acessar o serviço através da url apresentada no console :

payara

Como vimos o projeto funciona localmente, agora para correr o mesmo na Oracle Cloud iremos precisar criar um arquivo extra de configuração bem simples e logo depois zipa-lo para pode ser feito o upload para a Cloud .

Para isso vamos criar o arquivo manifest.json , esse arquivo é o que define como a nossa app vai iniciar, esse arquivo é o equivalente ao do Heroku que no caso é o “Procfile” , então configure o arquivo da seguinte maneira :


{
 "runtime":{"majorVersion":"8"},
 "command":"java -jar payara-micro.jar --deploy microprofile-sample.war --port $PORT"
}

mais detalhes sobre manisfest.json poderá acessar o seguinte link.

Com tudo feito, faça um arquivo zip contendo o war,payara-micro.jar e o arquivo manisfest.json . Apos isso podemos subir para a Oracle Cloud .

Acessando a Oracle Application Container Cloud

Logo apos ter feito o cadastro de uma conta trial e receber o e-mail de boas vindas juntamente com as credenciais para acessar os serviços podemos da inicio na criação de uma instancia do serviço de Contêiner .

Primeiramente acesse o link que você recebeu no e-mail e ao clicá-la sera levado a seguinte tela :

login

entre com seu usuário e senha recebido no e-mail, feito o login sera levado a tela de DashBoard contendo informações sobre seus serviços, valores, notificações, etc.

paineldeControle
Painel de Controle/DashBoard

A partir desta tela podemos criar novas instancias dos serviços disponíveis em nossa conta, com podem observar eu tenho dois serviços listados no meu painel, os mesmo estão sendo exposto aqui, eu especifiquei quais serviços eu quero mostrar em meu painel quando entro na minha conta, podemos adicionar mais serviço clicando no card “Personalizar Painel de Controle”.

Como entrar nessa tela pela primeira vez, temos somente o serviço de Identity Cloud apresentado, para criar uma nova instancia de algum serviço temos duas opções :

1 – Clicando no card “Criar Instancia” que ira da uma lista dos serviços disponíveis separados por categoria .

2 – Clicar no menu ao lado do nome “Oracle Cloud – Meus Serviços”, nisso ira lhe apresentar um menus com uma lista de opções e um outro menu chamado “serviços” que lista os serviços que temos disponíveis para usar.

Para esse post eu vou utilizar o serviço chamado “Application Container” para isso clique no Card criar instancia ou mesmo vai no menu e procurar por esse nome e você sera levado a tela do serviço , como pode ser visto na seguinte imagem :

appCloud

Agora para criarmos uma instancia desse serviço, vamos clicar no botão “Go to Console” e sera exibida a seguinte tela :

create

Clique no botão “Create Application” e sera aberto um popup conforme a imagem:

create2

Selecione o “Java SE” e ira abrir a seguinte tela :

deploy

Nesta tela preencha o que for necessário para você e aguarde a finalização do upload do projeto.

Logo depois você voltara para a tela de Applications com a sua instancia sendo criada conforme a imagem :

demo

clique no nome da sua application para ir para tela de detalhes :

detail

Nesta tela é mostrada os recursos, status de criação da instancia, bem como acesso a URL para podemos ter acesso as aplicações. Se necessário podemos aumentar a memoria e instancia, no meu caso eu tenho 1G memoria, então aumentei para 2 G para ficar no verde.

Para ver a sua app funcionando basta acessa a URL que é disponibilizada, que no meu caso é:

https://demo-danieldiasjava.uscom-east-1.oraclecloud.com/microprofile-sample/app/JUG

que resulta do seguinte resultado no navegador :

json

Agora iremos fazer a mesma coisa, porem com a opção Java EE, iremos fazer um upload de war com uma simples aplicação em Struts-1 :

Clique novamente em “Create Application” e logo depois em “Java EE ” abrindo a seguinte tela :

javaee

preencha o formulário e clique em “Create”, apos isso seu war sera processado e poderá utiliza-lo a a URL disponível  que no meu caso é :

https://struts-danieldiasjava.uscom-central-1.oraclecloud.com/

strutsCloud

 

strutsCloud2

 

Bem isso é tudo, espero que os leitores tenham gostado desse passo a passo na utilização de um dos serviços da Oracle Cloud.

Aproveite seus 30 dias e explore mais esse serviço e teste outros também.

Código-fonte: https://github.com/Daniel-Dos/DanielDiasjava-Blog/tree/master/Projeto-Cloud

REFERÊNCIAS

Conectando sua aplicação Java na Oracle DataBase Cloud

cgkjwwpx
Oracle DataBase Cloud

Neste post veremos como  utilizar a plataforma de Cloud da Oracle para conectar nossas aplicações Java no serviço de DataBase .

Obtendo uma Conta Free

Antes de iniciarmos nossa aventura, você vai precisar criar uma conta na Oracle Cloud para poder utilizar os serviços.

Para isso basta acessar o site : http://cloud.oracle.com/ e criar uma conta trial que te dar $300(900 BRL) para testar a plataforma por 30 dias.

trial
http://cloud.oracle.com/

Bastando preencher os campos solicitado e informar o numero do cartão de credito para que o cadastro seja completado, porem não se preocupe que não sera cobrado nada apos o termino dos 30 dias, a menos que optar por fazer upgrade para uma conta paga para continuar a usar os serviços.

Feito o cadastro, basta aguardar um e-mail de boas vindas com as sua credenciais para acesse a plataforma Oracle Cloud , que leva mais ou menos uns 2 dias.

Oracle DataBase Cloud Service

A Oracle Database Cloud Service fornece a capacidade de implantar bancos de dados Oracle na Cloud, com cada implantação de banco de dados contendo um único banco de dados Oracle.

Você tem acesso total aos recursos e operações disponíveis com o Oracle Database, mas com a Oracle fornecendo o poder de computação, armazenamento físico e ferramentas (opcionalmente) para simplificar a manutenção de banco de dados de rotina e as operações de gerenciamento.

Com tudo esse serviço oferece os seguinte recursos :

  • Versão do DataBase : Instâncias de banco de dados dedicadas com o Oracle Database 11g, 12.1 e 12.2, com sua escolha de Standard, Enterprise, High Performance ou Extreme Performance.
  • Service Packaging : Os pacotes Standard e Enterprise incluem seus respectivos recursos locais e adicionam Transparent Data Encryption. O Alto Desempenho adiciona todas as opções de banco de dados excluindo: RAC, Memória interna e Active Data Guard. Extreme Performance inclui todas as opções.
  • Containerização de banco de dados : O Oracle Database 12c inclui a opção Oracle Multitenant para gerenciar bancos de dados plugáveis.
  • DevOps : Criação de teste de mestre com máscara de dados sensível. Criação de clones e gerenciamento do ciclo de vida para o desenvolvimento ágil.
  • Acesso administrativo : Acesso administrativo via SSH, SQL Developer, Data Pump, SQL * Plus e outras ferramentas.
  • Acesso aos Dados : Use qualquer biblioteca de linguagem de cliente Oracle disponível, incluindo: Oracle Net (SQL * Net), JDBC, JSON e outros drivers para acessar suas instâncias dedicadas.
  • Ferramentas : Use Enterprise Manager, SQL Developer, Application Express ou outras ferramentas Oracle ou de terceiros .
  • Acesso seguro à rede : Opção IPsec VPN para acesso seguro.
  • Escalonamento :  Controle o armazenamento e o dimensionamento de computação através do console web (ou API REST). Explodir de assinatura para computação medida para efetivamente lidar com o pico de carga de trabalho.
  • Segurança : Use o console web do Compute Service (ou a API REST) para gerenciar as regras de segurança e as listas IPsec para uma segurança de rede flexível e de nível empresarial. Aproveite todos os recursos de segurança da Oracle Database em profundidade para obter a segurança completa de dados.
  • Patch e atualização : Use ferramentas de automação de patches incorporadas no console da Web (ou API REST) para fácil aplicação de patches trimestrais do banco de dados. Use processos de migração simples para validar atualizações.
  • Opções de backup : Programe a automação de backup para armazenamento local rápido, o Oracle Cloud Object Store ou ambos. Instanciar novos serviços a partir de cópias de backup para desenvolvimento e teste.
  • Elasticidade : Adicione ou remova recursos de computação, memória ou armazenamento conforme necessário

Bem feita essa rápida introdução sobre o serviço, podemos da inicio ao processo de criação da uma instancia na Oracle Cloud.

Acessando a Oracle DataBase Cloud

Logo apos ter feito o cadastro de uma conta trial e receber o e-mail de boas vindas juntamente com as credenciais para acessar os serviços podemos da inicio na criação de uma instancia do serviço de Contêiner .

Primeiramente acesse o link que você recebeu no e-mail e ao clicá-la sera levado a seguinte tela :

  login

entre com seu usuário e senha recebido no e-mail, feito o login sera levado a tela de DashBoard contendo informações sobre seus serviços, valores, notificações, etc.

paineldeControle
Painel de Controle/DashBoard

A partir desta tela podemos criar novas instancias dos serviços disponíveis em nossa conta, com podem observar eu tenho dois serviços listados no meu painel, os mesmo estão sendo exposto aqui, eu especifiquei quais serviços eu quero mostrar em meu painel quando entro na minha conta, podemos adicionar mais serviço clicando no card “Personalizar Painel de Controle”.

Como entrar nessa tela pela primeira vez, temos somente o serviço de Identity Cloud apresentado, para criar uma nova instancia de algum serviço temos duas opções :

1 – Clicando no card “Criar Instancia” que ira da uma lista dos serviços disponíveis separados por categoria .

2 – Clicar no menu ao lado do nome “Oracle Cloud – Meus Serviços”, nisso ira lhe apresentar um menus com uma lista de opções e um outro menu chamado “serviços” que lista os serviços que temos disponíveis para usar.

Para esse post eu vou utilizar o serviço chamado “DataBase” para isso clique no Card criar instancia ou mesmo vai no menu e procurar por esse nome e você sera levado a tela do serviço , como pode ser visto na seguinte imagem :

welcome

Agora para criarmos uma instancia desse serviço, vamos clicar na aba “Instances” e sera exibida a seguinte tela :

create

Clique no botão “Create Instance” e você sera levado a uma tela com um pequeno formulário para preencher para poder ser criado uma instancia :

form1

Preenche todos os dados e logo depois clique em Next para ir na tela de configuração do Banco. Nessa tela de instancia eu optei por utilizar o Oracle DataBase 12c R2 com essas configurações, mas os leitores podem utilizar outras opções.

form2

Nesta tela preencha o que for necessário para você, no meu caso não irei fazer o uso da configuração de backup. Agora anote o DB Name e PDB Name, pois vamos precisar uma delas para termos acesso a instancia remotamente.

Logo depois clique em Edit no campo “SSH Public Key” para termos acesso a instancia via terminal, nisso ira abrir um pop-pup oferecendo 3 opções para entrar com SSH :

ssh

Marque a opção “Create a New key”  , nisso será gerado uma chave publica e privada e a mesma dará opção fazer Download de um arquivo zip contendo a mesmo, feito isso a tela volta para o formulário com o campo preenchido com o valor da chave, logo em seguida clique em “Next” para ser levado a tela de confirmação das configurações, estando tudo certo clique em “Create” para ser levado novamente a tela de instancia aonde o seu serviço esta sendo criado :

criando

Nesta tela mostra todas as instancia criadas atualmente, bem como um pequeno sumario dos recursos utilizado por esse instancia.

Agora clique no nome do seu serviço para ser levado a tela onde ira conter mais detalhes sobre o serviço ainda em criação :

criando2

Nesta tela é mostrada os recursos, status de criação da instancia, bem como acesso ao ip publico para podemos conectar nossas aplicações com a instancia. Ira levar um tempinho para que o serviço esta ok.

Depois de tudo pronto podemos acessar o serviço, mas antes devemos configurar a regras de acesso para obtermos acesso remotamente, seguindo a imagem abaixo, vá no menu e clique em “Access Rules” :

acessRules

Apos clicar você sera levado a uma outra tela, aonde devemos habilitar duas regras de acesso a  no menu “Action” :

ora_p2_httpssl PUBLIC-INTERNET DB_1 443
ora_p2_dblistener PUBLIC-INTERNET DB_1 1521

feito isso estaremos pronto para acessar a instancia  remotamente via SSH, SQL Developer e através do JDBC e persistence.xml.

Conectando com  SQL Developer, SSH e JDBC/persistence.xml

Agora iremos fazer a conexão com a instancia através do Oracle SQL Developer. Caso não use essa ferramenta, poderá utilizar uma outra, bastando fazer as configurações necessárias .

SQL Developer

Com o SQL Developer clique no icome de “+” para criar uma nova conexão e entre com os dados da sua instancia conforma a imagem :

sqlDeveloper

feito isso basta clicar em conectar e começar a usar o Oracle DataBase Cloud .

SSH

A duas maneira des conectar via SSH, a primeira com o próprio SQL Developer ou via terminal, que no meu caso uso Linux , veremos da duas formas :

1 – Via SQL Developer :

Com o SQL Developer aberto vai no menu View -> SSH nisso ira abrir um aba de “SSH Hosts” , clique com o botão direito no nele e em new SSH Host e preencha da seguinte forma :

sshSQL

logo depois clique em conectar e em seguida alterar a conexão criada anteriormente conforme a imagem e conectar :

sshSQL2

2 – Via Terminal :

Abra o  seu terminal e digite o seguinte comando :

ssh -i local da chave privada oracle@ip-publico da instacia 

caso queria fazer um tunnel entre seu local e o remoto execute o seguinte comando :

ssh -i local da chave privada -L 1523:oracle@ip-publico da instacia 

JDBC / Persistence.xml

Agora para finalizar vamos utilizar com JDBC/persistence.xml para conectar nossas aplicações Java :

Com seu projeto Java aberto e com os jar’s necessário para adicionado no projeto, faça o seguinte :

 

try {
 Connection com = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1523:ORCL","System","Aka1suki6#");

 String insert = "INSERT INTO pessoa"
 + "(ID,IDADE, JOB, NOME) VALUES"
 + "(?,?,?,?)";
 PreparedStatement preparedStatement = com.prepareStatement(insert);

 preparedStatement.setInt(1, 1);
 preparedStatement.setInt(2, 26);
 preparedStatement.setString(3, "Java EE Developer");
 preparedStatement.setString(4, "Daniel");

 preparedStatement.executeUpdate();

 PreparedStatement stm = com.prepareStatement("SELECT * FROM pessoa");
 com.setAutoCommit(true);

 ResultSet resultado = stm.executeQuery();
 Pessoa pessoa = new Pessoa();

 while(resultado.next()) {
 List<Pessoa> pessoas = new ArrayList<>();
 pessoa.setId(resultado.getLong(1));
 pessoa.setIdade(resultado.getInt(2));
 pessoa.setJob(resultado.getString(3));
 pessoa.setNome(resultado.getString(4));

 pessoas.add(pessoa);
 pessoas.forEach(System.out::println);
}
 } catch (SQLException e) {
 e.printStackTrace();
 }

agora com persistence.xml com Java SE :

 
<?xml version="1.0" encoding="UTF-8" ?>
<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"
version="2.0" xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="WeHaveSciencePU"
transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.Oracle10gDialect" />
<property name="javax.persistence.jdbc.driver" value="oracle.jdbc.OracleDriver" />
<property name="javax.persistence.jdbc.url" value="jdbc:oracle:thin:@localhost:1523:ORCL" />
<property name="javax.persistence.jdbc.user" value="System" />
<property name="javax.persistence.jdbc.password" value="Aka1suki6#" />
<!-- <property name="hibernate.connection.provider_disables_autocommit" value="true"/> -->
<property name="javax.persistence.schema-generation.database.action" value="update"/>
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="hibernate.hbm2ddl.jdbc_metadata_extraction_strategy" value="individually"/>
</properties>
</persistence-unit>
</persistence>

Caso queira usar com DataSource, basta fazer uma pequena modificação e criar a conexão em algum servidor de aplicação, nesse exemplo vou utilizar o Wildfly-Swarm para configurar o DataSource de forma simples e rápida, dentro da pasta resource/META-INF criar o arquivo “project-default.yml” :

swarm:
 datasources:
 jdbc-drivers:
 oracle:
 driver-class-name: oracle.jdbc.OracleDriver
 driver-module-name: com.oracle

swarm:
 datasources:
 data-sources:
 OracleDS:
 driver-name: oracle
 connection-url: jdbc:oracle:thin:@localhost:1523:ORCL
 user-name: System
 password: suaSenha

e no persistence.xml :

</pre>
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">

<persistence-unit name="soujava-rio" transaction-type="JTA">
<jta-data-source>java:jboss/datasources/OracleDS</jta-data-source
<class>br.org.soujava.rio.model.JUG</class>
<class>br.org.soujava.rio.model.Localidade</class>

<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.Oracle10gDialect" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="update" />
</properties>

</persistence-unit>
</persistence>

agora olhando no banco os registros :

jug

Bem isso é tudo, espero que os leitores tenham gostado desse passo a passo na utilização de um dos serviços da Oracle Cloud.

Aproveite seus 30 dias e explore mais esse serviço e teste outros também.

REFERÊNCIAS

 

Executando sua aplicação Java na Oracle Container Cloud

occs_logo1
Oracle Container Cloud

Neste post veremos como  utilizar a plataforma de Cloud da Oracle para executar nossas imagens de docker com uma aplicação Java no serviço de Container.

O objetivo do post não é ensinar como fazer build de uma imagem com o dockerfile e subi a mesma para o docker hub ou até mesmo demonstrar a utilização docker. Mas sim mostrar como executar,fazer pull da imagem para Oracle Container Cloud. Basicamente considere o post como uma tradução do video do Adam Bien .

Diferente do video não estarei utilizando o Glassfish, mas sim usando duas imagens, uma web-app com Wildfly-Swarm e uma api rest com SparkJava com CRUD sendo consumido no Angular 2/4 .

Obtendo uma Conta Free

Antes de iniciarmos nossa aventura, você vai precisar criar uma conta na Oracle Cloud para poder utilizar os serviços.

Para isso basta acessar o site : http://cloud.oracle.com/ e criar uma conta trial que te dar $300(900 BRL) para testar a plataforma por 30 dias.

trial
http://cloud.oracle.com/

Bastando preencher os campos solicitado e informar o numero do cartão de credito para que o cadastro seja completado, porem não se preocupe que não sera cobrado nada apos o termino dos 30 dias, a menos que optar por fazer upgrade para uma conta paga para continuar a usar os serviços.

Feito o cadastro, basta aguardar um e-mail de boas vindas com as sua credenciais para acesse a plataforma Oracle Cloud , que leva mais ou menos uns 2 dias.

Oracle Cloud Container

Os serviços Oracle Cloud ajudam os usuários a criar contêineres e  oferece a
capacidade de criar serviços de forma rápida e fácil, aumentando assim a produtividade de uma empresa.

Este serviço usa ambientes especiais de produção, teste e pré-produção. O objetivo principal do Oracle Container Cloud Service é gerenciar o Docker e melhorar o controle para que os sistemas funcionem corretamente.

Com a Oracle Container Cloud oferece às equipes de Desenvolvimento e Operações os benefícios de um contentor Docker fácil e segura ao criar e implantar aplicativos.

Com tudo esse serviço oferece os seguinte benefícios :

  • fornece uma interface fácil de usar para gerenciar o ambiente Docker .
  • fornece exemplos imediatos de serviços contatados e pilhas de aplicativos que podem ser implantados em um clique.
  • permite que os desenvolvedores se conectem facilmente aos seus registros Docker privados (para que eles possam “trazer seus próprios contêineres”).
  • permite que os desenvolvedores se concentrem em criar imagens de aplicativos em contêineres e pipelines de Integração Contínua / Entrega Contínua (CI / CD), não em aprender tecnologias de orquestração complexas.

Bem feita essa rápida introdução sobre o serviço, podemos da inicio ao processo de criação da uma instancia na Oracle Cloud.

Acessando a Oracle Cloud Container

Logo apos ter feito o cadastro de uma conta trial e receber o e-mail de boas vindas juntamente com as credenciais para acessar os serviços podemos da inicio na criação de uma instancia do serviço de Contêiner .

Primeiramente acesse o link que você recebeu no e-mail e ao clicá-la sera levado a seguinte tela :

  login

entre com seu usuário e senha recebido no e-mail, feito o login sera levado a tela de DashBoard contendo informações sobre seus serviços, valores, notificações, etc.

paineldeControle
Painel de Controle/DashBoard

A partir desta tela podemos criar novas instancias dos serviços disponíveis em nossa conta, com podem observar eu tenho dois serviços listados no meu painel, os mesmo estão sendo exposto aqui, eu especifiquei quais serviços eu quero mostrar em meu painel quando entro na minha conta, podemos adicionar mais serviço clicando no card “Personalizar Painel de Controle”.

Como entrar nessa tela pela primeira vez, temos somente o serviço de Identity Cloud apresentado, para criar uma nova instancia de algum serviço temos duas opções :

1 – Clicando no card “Criar Instancia” que ira da uma lista dos serviços disponíveis separados por categoria .

2 – Clicar no menu ao lado do nome “Oracle Cloud – Meus Serviços”, nisso ira lhe apresentar um menus com uma lista de opções e um outro menu chamado “serviços” que lista os serviços que temos disponíveis para usar.

Para esse post eu vou utilizar o serviço chamado “Container Versão Classic ” para isso clique no Card criar instancia ou mesmo vai no menu e procurar por esse nome e você sera levado a tela do serviço , como pode ser visto na seguinte imagem :

container
Oracle Container Console

Agora para criarmos uma instancia desse serviço, vamos clicar na aba “Instances” e sera exibida a seguinte tela :

create

Clique no botão “Create Instance” e você sera levado a uma tela com um pequeno formulário para preencher para poder ser criado uma instancia :

new

Preenche todos os dados e logo depois clique em Edit no campo “SSH Public Key” para termos acesso a instancia via terminal, nisso ira abrir um pop-pup oferecendo 3 opções para entrar com SSH :

ssh

Marque a opção “Create a New key”  , nisso será gerado uma chave publica e privada e a mesma dará opção fazer Download de um arquivo zip contendo a mesmo, feito isso a tela volta para o formulário com o campo preenchido com o valor da chave, logo em seguida clique em “Next” para ser levado a tela de confirmação das configurações, estando tudo certo clique em “Create” para ser levado novamente a tela de instancia aonde o seu serviço esta sendo criado :

service

Nesta tela mostra todas as instancia criadas atualmente, bem como um pequeno sumario dos recursos utilizado por esse instancia.

Agora clique no nome do seu serviço para ser levado a tela onde ira conter mais detalhes sobre o serviço ainda em criação :

overview

Nesta tela é mostrada os recursos, status de criação da instancia, bem como acesso a url para acessar o console para podemos utilizar o serviço,etc. Ira levar um tempinho para que o serviço esta ok.

Depois de tudo pronto podemos acessar o serviço, para isso bastamos ir no menu como na imagem a seguir e clicar em “Container Console” :

menu

Apos clicar você sera levado a uma outra tela de login, aonde deve ser inserido o login e senha criado no momento da criação da instancia :

log

feito isso você estará dentro do console do serviço, ou seja o painel de controle/dashboard conforme a imagem e nesse link contem as descrição de cada função desta tela :

console

agora bastamos clicar em “Services” e seremos levados a seguinte tela :

images

aqui é mostrado uma lista de serviços pré-configurados bastando usá-los e modificá-los da sua maneira.

Agora para a gente fazer um pull da nossa imagem que fica no docker hub, precisaremos criar um serviço, para isso basta clicar no botão “New Serviçe” e vai abrir um pop-pup com um pequeno formulário para criação do nosso serviço nesse link contem as descrição de cada função desta tela  :

newService

bastando preencher o mesmo da seguinte forma para esse post fiz da seguinte maneira :

conf

conf2

conf3

indo na aba YAML você poderá ver como ficou a configuração :

yaml

feito isso basta clicar em salvar, nisso você voltara para a tela de serviços, bastando procura pelo nome do serviço que no meu caso é “danieldiasjava” e clicar em “Deploy” para da inicial ao pull da imagem do docker :

deploy

feito isso, clique no “Container Name” para ir para tela de detalhe e pegar o ip publico para acessar o app :

deploya

nesta tela va na aba “Environment Variable” para ser mostrado um log aonde ira comter o ip_publico conforme a imagem :

ip_public

pegando o ip que no meu caso é public_ip : 129.150.112.30 e utilizando o mesmo no navegador. Então para acessar a os serviço da imagem danieldiasjava/sparkjava-crud temos os seguintes endereços :

GET: http://localhost:8080/api/consultar
POST: http://localhost:8080/api/cadastrar
GET: http://localhost:8080/api/consultar/{codigo}
PUT: http://localhost:8080/api/editar
DELETE: http://localhost:8080/api/deletar/{codigo}

então utilizando o PostMan para testar nosso serviço com o Post da seguinte maneira :

restPost

e fazendo um Get com http://129.150.112.30:8080/api/consultar , trazendo o resultado :

resultado

 

também podemos fazer uso de um frond-end para esta consumindo esse rest, para tal tenho esse simples app feito em angular 2/4 disponível no seguinte link, bastando alterar o arquivo config.service.ts com o endereço do serviço  :

crud

para ver os logs , você pode clicar em “View Logs” no mesmo local quando vimos para pegar o ip_public :

logs

Agora iremo fazer o mesmo para a imagem do Wildfly-Swarm seguindo o mesmo passos, bastando apenas mudar a porta para 8081:8080 ,passando o nome da imagem  : danieldiasjava/ozark-demo , depois do deploy basta acessar o endereço que no meu caso é : http://129.150.112.30:8081/app/ :

souJava

Depois disso bastamos paramos nosso serviço e remover os mesmo no menu “Deployments”, se necessário também pode remover suas imagem no menu “Services”:

remove

Para sair do console do Container basta fazer logout e vamos agora remover nosso serviço de container voltando novamente na tela aonde criamos nossa instancia e acessar um pequeno menu e clicar em “Delete” e marcar uma check-box para forçar o delete :

remo

Bem isso é tudo, espero que os leitores tenham gostado desse passo a passo na utilização de um dos serviços da Oracle Cloud.

Aproveite seus 30 dias e explore mais esse serviço e teste outros também.

O código-fonte para o projeto SparkJava-crud pode ser encontrado aqui.

REFERÊNCIAS

 

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

 

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