Toxina Virtual: julho 2016

Anteriormente vimos dois tópicos que visam a integração do Spring com Web Service Rest (no back-end) e com Angularjs (no front-end). Considerando que já sabemos como criar um Web Service com Spring e que faça um databind em XML/JSON para retornar um objeto para a camada view, conforme os links abaixo, Vamos então para o consumo do serviço.

http://toxinavirtual.blogspot.com.br/2016/07/databind-com-jackson-e-com-google-json.html

http://toxinavirtual.blogspot.com.br/2016/07/spring-tutorial-parte-i-injecao-de_25.html

Segundo o manual do Spring, temos um exemplo em que uma URL fornece um JSON. O serviço roda na URL abaixo:

http://rest-service.guides.spring.io/greeting

E devolve o seguinte JSON:

{"id":1,"content":"Hello, World!"}

Para criar o projeto no Eclipse, vamos novamente em File>>New>>Other>>Dynamic Web Service e vamos criar um projeto com o nome WSAngularjsRest com a opção de criar web.xml selecionada.

Clicando com o botão direito do mouse sobre o projeto Configure>>Convert to Maven Project e deverá aparecer o arquivo pom.xml.

Vamos adicionar no arquivo as dependências embaixo da tag </build>.

<properties>
<spring.version>4.2.1.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>javax.xml</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-server</artifactId>
<version>1.17.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-servlet</artifactId>
<version>1.17.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-json</artifactId>
<version>1.17.1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>

Vamos criar o arquivo index.html dentro da pasta WebContent.

<!doctype html>
<html ng-app>
<head>
<title>Hello AngularJS</title>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.min.js"></script>
<script src="hello.js"></script>
</head>
<body>
<div ng-controller="Hello">
<p>The ID is {{greeting.id}}</p>
<p>The content is {{greeting.content}}</p>
</div>
</body>
</html>

Repare que o arquivo importa uma biblioteca do Angularjs e importa também um arquivo hello.js que deverá conter o código com o objeto que será impresso na div ng-controller.

Dentro da mesma pasta vamos criar o arquivo hello.js.

function Hello($scope, $http) {
$http.get('http://rest-service.guides.spring.io/greeting').
success(function(data) {
$scope.greeting = data;
});
}

Repare que existe uma solicitação GET para o Web Service Rest do manual do Spring. Embaixo o objeto é recebido em uma variável que será impresso no index.html.

Vamos agora configurar o arquivo web.xml com o arquivo de chamada.

<?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_0.xsd" id="WebApp_ID" version="3.0">
<display-name>WSAngularjsRest</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<!-- . <welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>. -->
<servlet>
<servlet-name>jersey-serlvet</servlet-name>
<servlet-class>
com.sun.jersey.spi.container.servlet.ServletContainer
</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>ngdemo.rest</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jersey-serlvet</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>

Basta rodar o arquivo agora no Tomcat clicando no projeto com o direito Run as>>Tomcat8>>OK.

A página deverá exibir algo como:

Repare que a página retornou os dados do JSON em formato de um objeto numa única variável. Este objeto poderia ser qualquer objeto e poderia ser invocado por diferentes URL. Por exemplo ser fosse um carro ou dados de uma pessoa:

http://rest-service.guides.spring.io/carro

http://rest-service.guides.spring.io/pessoa

Referencias:

https://spring.io/guides/gs/consuming-rest-angularjs/

https://spring.io/guides/gs/spring-boot/

Continuando a bateria de testes com o objetivo de estudar algumas arquiteturas interessantes e bastante utilizadas em projetos Java vamos testar um projeto com Spring e Web Service Rest.

O Spring é um framework largamente utilizado. Existem soluções Spring para diversos tipos de cenários. Pode ser utilizado para controle de sessão, para facilitar a divisão de camadas, pode ser utilizado com outras tecnologias como Hibernate e ultimamente tem sido utilizado como um atalho para os Web Services Rest.

O que o Spring faz? Basicamente o que o Spring faz Injeção de Dependência. Muito se fala hoje sobre Injeção de Dependência, mas neste contexto a Injeção de Dependência é apenas um atalho, uma forma de instanciar uma classe ou objeto.

Quando criamos uma nova instância geralmente utilizamos o comando abaixo para alocar o objeto em um novo espaço de memória do computador dentro de uma variável.

Object nomeObjeto = new Object();

Sendo que este objeto pode ser qualquer tipo de classe como um carro:

Carro carro = new Carro();

Quando utilizamos a Injeção de Dependência esse comando se faz desnecessário porque a chamada está ocorrendo em outro lugar. E no caso do Spring do Java esta instância é substituída por alguma anotação "annotation" que é caracterizado por um @ + palavra chave reservada, que é interpretada como um comando. Por exemplo o comando abaixo que é um comando de mapeamento:

@RequestMapping("/")

Quando ocorre este tipo de "chamada", dizemos que ocorre uma Inversão de Controle, isso porque o controle vem de uma classe "mais interna". Diferente de como se fazia antes ao criar uma instância numa classe "mais externa". Em muitos casos onde havia uma chamada de função o objeto é lançado dentro da função para retornar o parâmetro numa variável de escopo mais externo.

Interessante que a annotation acima é importada da API do Java:

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

Existem outras annotations que podem ser importadas de outras API's do Java, como pacotes Hibernate ou JAX-WS, e é aqui que parece ficar mais claro o limite entre uma tecnologia e outra. Apensar do Spring fazer Injeção de Dependência através de annotations, as annotations não se limitam ao Spring.

Em posts posteriores voltaremos a falar sobre Injeção de Dependência. Segue um artigo do próprio Martin Fowler falando sobre o tema:

http://martinfowler.com/articles/injection.html

Vamos aos testes agora.

Abra o Eclipse e crie um novo projeto Java em File>>New>>Other>>Dynamic Web Project com o nome de SistemaSpringMVC.

Clique com o direito do mouse sobre o projeto e Configure>>Convert to Maven Project e deverá aparecer o arquivo pom.xml dentro do projeto. Dentro do arquivo e abaixo da tag </build> vamos adicionar as API's.

<properties>
<spring.version>4.2.1.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>

Novamente com o botão direito sobre o projeto clique em Maven>>Update Project e as bibliotecas deverão aparecer em Java Resourcers>>Libraries>>Maven Dependences.

Vamos criar o index.jsp dentro de WebContent com o conteúdo abaixo.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Página Inicial</title>
<script type="text/javascript">
function Redirecionar() {
var nomeInformado = prompt("Favor informar um nome: ", "");
window.location.href = "sistema/boasvindas?nome=" + nomeInformado;
}
</script>
</head>
<body>
<center>
<h2>INICIANDO O SISTEMA EM SPRING MVC</h2>
<h3>
<a href="#" onclick="Redirecionar();">Click aqui para informar o
nome</a>
</h3>
</center>
</body>
</html>

Para que o index.jsp seja carregado temos que configurar o arquivo web.xml dentro de WEB-INF. Vamos colocar um dispatcher em web.xml que deverá carregar um outro arquivo.

<?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_0.xsd" id="WebApp_ID" version="3.0">
<display-name>SistemaSpringMVC</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>

Vamos criar agora o arquivo apontado WEB-INF/dispatcher-servlet.xml com o conteúdo abaixo.

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package="br.marcelo.rosa.controller"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/views/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>

Repare que neste arquivo existe uma tag context apontando para o pacote br.marcelo.rosa.controller. Existem também duas tags properties apontantando para um arquivo .jsp dentro da pasta /WEB-INF/views/. Vamos criar os dois arquivos. Primeiro clicamos com o direito na pasta Java Resources criando uma nova classe em New>>Class e preenchemos da forma abaixo:

Inserimos o conteúdo abaixo:

package br.marcelo.rosa.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
@Controller
@RequestMapping("/sistema")
public class SistemaController {
@RequestMapping(value = "/boasvindas", method = RequestMethod.GET)
public ModelAndView boasVindas(@RequestParam(value = "nome", required = false, defaultValue = "Cicero Ednilson") String nome) {
System.out.println("nome="+nome);
ModelAndView modelAndView = new ModelAndView("boasVindas");
modelAndView.addObject("mensagem", "Olá " + nome);
return modelAndView;
}
}

Repare que este arquivo está mapeado pelo seguinte endereço:

/sistema/boasvindas/

A arquivo recebe ainda um parâmetro nomedo tipo String via GET.

Vamos criar o arquivo boasVindas.jsp em /views/. Se a pasta não existe é necessário criar a pasta primeiro e em seguida inserir o conteúdo.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boas Vindas</title>
</head>
<body>
 <center>
  <h2>${mensagem}</h2>
  <h2>Nesse post aprendemos a configurar o Spring MVC</h2>
 </center>
</body>
</html>

Segue a estrutura do projeto para melhor visualização:

Para executar o projeto é necessário o Tomcat instalado, no meu caso estou usando o Tomcat8. Para que o Web Service funcione dentro do Tomcat é necessário instalar as API's de JAX-WS dentro de lib da pasta Tomcat.

Baixe o JAX-WS RI em https://jax-ws.java.net/ e descompacte.

As arquivos utilizados estão dentro da pasta lib. São utilizados apenas algumas libs:

jaxb-impl.jar
jaxws-api.jar
jaxws-rt.jar
gmbal-api-only.jar
management-api.jar
stax-ex.jar
streambuffer.jar
policy.jar

Feito isso é possível testar o arquivo com o direito em Run as >> Run on Server >> Tomcat8.

O aplicativo pode ser acessado pelo endereço:

http://localhost:8080/SistemaSpringMVC/

Ao clicar no link e preencher a janela aberta, ao dar OK o serviço será redirecionado com a palavra digitada para o endereço:

http://localhost:8080/SistemaSpringMVC/sistema/boasvindas?nome=Teste

E no Console deverá ser impresso o nome:
nome=Teste

Repare que apesar do Spring estar configurado, tecnicamente a parte do Rest ainda não foi complettamente implementada já que a característica do Web Service é receber um XML/JSON para devolver outro XML/JSON. Temos apenas a impressão de uma variável via GET, apesar do GET ser característica de chamada de Web Sevice. O objetivo inicial do Rest seria a comunicação entre sistemas distribuídos:

https://spring.io/understanding/REST

Referencias:
Os arquivos testados foram retirados do site abaixo:
http://www.ciceroednilson.com.br/configurando-um-projeto-java-com-spring-mvc-e-maven/

Um teste ainda mais simples pode ser encontrado no link abaixo. Considero este Tutorial excelente:
http://www.javatpoint.com/spring-3-mvc-tutorial

Manual do Spring:
http://projects.spring.io/spring-framework/

Para Deploy:
http://www.mkyong.com/webservices/jax-ws/deploy-jax-ws-web-services-on-tomcat/

Design Patterns:
http://www.tutorialspoint.com/design_pattern/

Toxina Virtual

terça-feira, 26 de julho de 2016

Spring Tutorial parte II - Consumindo o Web Service Rest com Angularjs

segunda-feira, 25 de julho de 2016

Spring Tutorial parte I - Injeção de Dependência e Web Service Rest