segunda-feira, 25 de julho de 2016

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

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.

  1. Object nomeObjeto = new Object();

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

  1. 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:

  1. @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:

  1. 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.

  1. <properties>
  2.   <spring.version>4.2.1.RELEASE</spring.version>
  3.  </properties>
  5.  <dependencies>  
  6.  <!-- DEPENDÊNCIAS DO SPRING -->
  7.  <dependency>
  8.   <groupId>org.springframework</groupId>
  9.   <artifactId>spring-core</artifactId>
  10.   <version>${spring.version}</version>
  11.  </dependency>
  13.   <dependency>
  14.   <groupId>org.springframework</groupId>
  15.   <artifactId>spring-web</artifactId>
  16.   <version>${spring.version}</version>
  17.  </dependency>
  19.   <dependency>
  20.   <groupId>org.springframework</groupId>
  21.   <artifactId>spring-webmvc</artifactId>
  22.   <version>${spring.version}</version>
  23.  </dependency>
  25.  </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.


  1. <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
  2.  pageEncoding="ISO-8859-1"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  7. <title>Página Inicial</title>
  10. <script type="text/javascript">
  11.  function Redirecionar() {
  13.    var nomeInformado = prompt("Favor informar um nome: ", "");
  15.    window.location.href = "sistema/boasvindas?nome=" + nomeInformado;
  16.  }
  17. </script>
  19. </head>
  20. <body>
  22.   <center>
  23.   <h2>INICIANDO O SISTEMA EM SPRING MVC</h2>
  24.   <h3>
  25.    <a href="#" onclick="Redirecionar();">Click aqui para informar o
  26.     nome</a>
  27.   </h3>
  28.  </center>
  30. </body>
  31. </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.


  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <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">
  3.   <display-name>SistemaSpringMVC</display-name>
  4.   <welcome-file-list>
  5.     <welcome-file>index.html</welcome-file>
  6.     <welcome-file>index.htm</welcome-file>
  7.     <welcome-file>index.jsp</welcome-file>
  8.     <welcome-file>default.html</welcome-file>
  9.     <welcome-file>default.htm</welcome-file>
  10.     <welcome-file>default.jsp</welcome-file>
  11.   </welcome-file-list>
  12.   <servlet>
  13.  <servlet-name>dispatcher</servlet-name>
  14.  <servlet-class>
  15.   org.springframework.web.servlet.DispatcherServlet
  16.  </servlet-class>
  17.  <load-on-startup>1</load-on-startup>
  20. </servlet>
  22. <servlet-mapping>
  23.  <servlet-name>dispatcher</servlet-name>
  24.  <url-pattern>/</url-pattern>
  25. </servlet-mapping>
  28. <context-param>
  29.  <param-name>contextConfigLocation</param-name>
  30.  <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
  31. </context-param>
  33. <listener>
  34.  <listener-class>
  35.   org.springframework.web.context.ContextLoaderListener
  36.  </listener-class>
  37. </listener>
  39. </web-app>

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

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.  xmlns:context="http://www.springframework.org/schema/context"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  6.       http://www.springframework.org/schema/context
  7.       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
  9.   <context:component-scan base-package="br.marcelo.rosa.controller"/>
  11.   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  13.   <property name="prefix">
  14.    <value>/WEB-INF/views/</value>
  15.   </property>
  17.   <property name="suffix">
  18.    <value>.jsp</value>
  19.   </property>
  20.  </bean>
  22. </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:

  1. package br.marcelo.rosa.controller;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RequestMethod;
  6. import org.springframework.web.bind.annotation.RequestParam;
  7. import org.springframework.web.servlet.ModelAndView;
  9. @Controller
  10. @RequestMapping("/sistema")
  11. public class SistemaController {
  12.  @RequestMapping(value = "/boasvindas", method = RequestMethod.GET)
  13.  public ModelAndView boasVindas(@RequestParam(value = "nome", required = false, defaultValue = "Cicero Ednilson") String nome) {
  15.    System.out.println("nome="+nome);
  16.   ModelAndView modelAndView = new ModelAndView("boasVindas");
  17.   modelAndView.addObject("mensagem", "Olá " + nome);
  19.    return modelAndView;
  20.  }
  22. }


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/


Postado por às

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)