Conhecendo o Payara Micro.

20150906224045
Logo Payara

Neste post vamos conhecer um pouco sobre o Payara Micro para desenvolver aplicações modernas com Java EE / Jakarta EE .

Introdução ao Payara Micro

Payara Micro é uma plataforma de middleware de código aberto criada a partir do lançamento do Payara Embedded Web para implementações de microsserviços Java EE (Jakarta EE) em container.

Com menos de 70 MB de tamanho, a Payara Micro não requer instalação ou configuração e não precisa de regravação de código – para que você possa criar e implantar um aplicativo totalmente funcional em poucos minutos.

Compatível com o Eclipse MicroProfile, o Payara Micro é uma versão pronta para microservices do Payara Server. Você pode executar arquivos war a partir da linha de comandos sem qualquer instalação do servidor de aplicativos. O cluster automático e elástico torna a Payara Micro ideal para executar aplicativos Java EE em uma infraestrutura virtualizada moderna.

 Além das api do MicroProfile 1.2 :

  • JAX-RS 2.0
  • CDI 2 (updated 1.2 → 2)
  • JSON-P 1.0
  • Annotation 1.2
  • Microprofile Config 1.1
  • Microprofile Fault Tolerance 1.0
  • Microprofile Health 1.0
  • Microprofile Metrics 1.0
  • Microprofile JWT Propagation 1.0

Payara micro tambem suporta as api do Java EE como :

  • Servlets, JSTL, EL and JSPs
  • WebSockets
  • JSF
  • JAX-RS
  • EJB lite
  • JTA
  • JPA
  • Bean Validation
  • CDI
  • Interceptors
  • JBatch
  • Concurrency
  • JCache
  • JCA
  • e muito mais.

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

Requisitos

Para podemos utilizar a versao mais recente do Payara Micro, precisamos atualizar o nosso JDK para a versão 8u162 ou maior, devido a uma restrição na versão mais recente do Grizzly . 

Feita essa atulização,podemos fazer o download o Payara micro aqui ou podemos fazer o uso de uma imagem docker .

Criando uma instancia 

Para criar uma instancia do Payara Micro basta passar o seguinte comando :


java -jar payara-micro-5.181.jar

com esse único comando você tem um micro servidor rodando conforme a imagem :

START

Deploy das Aplicações

Para realizamos o deploy das nossas aplicações Java EE/Jakarta EE tambem é muito simples conforme o comando abaixo :

java -jar payara-micro-5.181.jar --deploy caminhoDoMeuWAR

aqui o comando “–deploy” é opcional, desde a versão 4.1.2.181 e 5.181.

vejamos um exemplo de deploy de um app em Servlet :

java -jar payara-micro-5.181.jar demoServlet.war

run

após executar o comando, o micro servidor ira fazer o deploy do nosso demoServlet.war e no final ira exibir a url para acessar o recurso, que no caso seria , agora abra o url no browser e adicione ao final da url o caminho para chamar o servlet: “http://192.168.1.6/demoServlet/HelloPayaraMicro :

run2

Além disso podemos fazer deploy de multiplos war dentro do Payara Micro com o seguinte comando :

java -jar payara-micro-5.181.jar demoServlet.war demoServlet2.war

run3

agora temos duas Servlet rodando no Payara Micro, porem existe uma outra forma de fazer isso de maneira mais rapida, que seria criar um novo diretorio e dentro dele adicionar todos os war e em seguinda utilizar o seguinte comando  :

java -jar payara-micro-5.181.jar --deploymentDir /localDasWAR

 

Gerando Uber Jar

È possivel tambem com o Payara Micro gerar um jar executavel pela linha de comando, desta forma podemos empacotar o aplicativo (ou aplicativos), configuração e dependências em um único jar com o seguinte comando :

 

java -jar payara-micro-5.181.jar demoServlet.war --outputUberJar demoServlet.jar 

e em seguida executar o comando :

 

java -jar demoServlet.jar 

 

Clustering no Payara Micro

O Payara Micro Cluster é baseado no Hazelcast, similarmente ao clustering da Hazelcast no Payara Server. Cada nó em um cluster da Payara Micro é efetivamente um nó Hazelcast.

Isso facilita a escalabilidade da infraestrutura para nossos aplicativos dinamicamente, sem nenhuma configuração complexa ou tempo de inatividade.

A integração da Hazelcast na Payara Micro permite que as instâncias se agrupem automáticamente e dinamicamente. Quando duas instâncias são apontadas no mesmo endereço e porta multicast, elas serão automaticamente agrupadas.

Vejamos um exemplo de executação de 2 instancias do Payara Micro em porta diferentes :

java -jar payara-micro-5.181.jar demoServlet.war --autoBindHttp

a opçao “–autoBindHttp” é usado para obter diferente configuração de porta, ou seja, quando executarmo duas vezes o comando acima teremos 2 instancias do Payara Micro com o mesmo endereço IP porem com porta diferentes, algo como 8080,8081… .

após  a execução em um dos terminal vai esta conforme a imagem abaixo :

das

pronto temos nossas aplicações em modo cluster, em nosso caso, ele se juntou ao Domain Data Grid que é o novo modo de descoberta para o Payara Micro e Payara Server, você pode aprender um pouco mais sobre o mesmo nesse artigo .

Payara Micro Maven Plugin

Para finalizar, iremos ver como podemos executar e gerar um Uber Jar com o plugin do Maven .

Crie um novo projeto com o seguinte conteúdo no pom.xml:

para mais detalhes sobre o que cada tag representa, acessa o link da documentação.

Para executar faça o seguinte :


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

feito isso sua aplicação estará em execução escutando a porta 8080 que é a padrão.

Bem isso é tudo, espero que os leitores tenham gostado de conhecer um pouco sobre Payara Micro como alternativa light a servidores de aplicação full como Payara Server/GlassFish ,etc .

código de exemplo no meu github .

voce pode aprender mais nos seguintes links :

REFERÊNCIAS

Anúncios

Eclipse Che sua IDE na nuvem.

wl-eclipse-che

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

Introdução ao Eclipse Che

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

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

O eclipse Che suporta as seguintes Linguagens e Frameworks :

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

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

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

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

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

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

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

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

Requisitos

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

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

Instalando o Eclipse Che

Para instalar execute o seguinte comando :


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

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

start

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

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

docker stop che && docker rm che

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

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

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

/data/db:/data/db;

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

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

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

1-  Salvando as imagens :

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


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

a saída será semelhante a essa :

offline

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

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

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


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

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

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

Para iniciar o Eclipse Che execute o seguinte comando :


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

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

offiline2

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

workspace

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

Criando o WorkSpace

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

newWorkspacenewWorkspace2

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

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

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

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

1 – De um nome para o WorkSpace.

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

3 – Clique em “CREATE”

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

Apos isso ira abri o editor conforme a imagem :

tela

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

newProject

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

newProject2

logo apos ira ter um projeto chamado Demo na workspace :

project

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

 

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


package br.org.soujava.rio.minhaServlet;

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

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

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

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

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

 }
}

 

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

manage

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


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

 

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


$TOMCAT_HOME/bin/./startup.sh

 

e em “Preview URL adicione o seguinte comando:


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

 

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

servlet

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

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

para aprender mais sobre os comandos acesse o seguinte link.

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

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

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

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

stacks2

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

newStarkc

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

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

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

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

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

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


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

 

o arquivo final fica assim :

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

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

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

mongo

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

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

agora iremos modifica duas classes :

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

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

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

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

no “Command Line” adicione o seguinte trecho :


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

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

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

e em “Preview URL” adicionar o seguinte trecho :


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

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

payara

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

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

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

REFERÊNCIAS

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

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&amp;amp;amp;lt;Pessoa&amp;amp;amp;gt; pessoas = new ArrayList&amp;amp;amp;lt;&amp;amp;amp;gt;();
 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