Top Posts

Série CI:Maven + Jenkins + Git

Continue lendo

Série Spring: Aplicação JEE com JSF 2.0 + Spring 3.0

Posted by camilolopes | Posted in JSF, Series, Spring | Posted on 23-05-2013

6

 

Olá Pessoal,

No post de hoje veremos como usar Spring em nossas aplicações JEE tendo o JSF no nosso front-end. Vou considerar que você já conhece o básico e configuração de cada um dos frameworks, mas na hora de fazer a integração, veio aquela pergunta: “E agora como faço?”.

Lets go… 

Starting…

Primeiramente precisamos ter nosso ambiente de desenvolvimento pronto, para isso  você precisa ter os .jars do JSF 2.x e do Spring core 3.x.  No nosso exemplo estou usando a versão do Spring 3.2 e o JSF 2.0.9 e como IDE optei pelo STS Tools. O motivo que ele  vem com vários plugins já por default  e é uma mão  na roda.

Nossos .jars:

  • – JSF 2.X
  • – Spring 3.x
  • -commons-logging-1.1.1.jar

Note: como Servidor app estou usando o Tomcat 7.0

Garanta que você já tem tudo isso antes de começar a desenvolver.

Desenvolvimento

Agora vamos meter mão na massa. Primeiro crie um Spring template Project  na lista de opções escolha Spring Hibernate Utility Apesar que não vamos usar nada de Hibernate, o template já vem com a estrutura do projeto para web e precisamos apenas dar uns tapas para ficar como queremos, para isso o projeto vai está “quebrando” ou seja, com uma exclamação:

helloSpringJSFProject

Note: se vc já tem um projeto JEE, só vai precisar adicionar suporte ao Spring.

Note 2: você também poderia criar um JSF Project e adicionar o Spring, enfim há N possibilidades.

Vamos deletar os arquivos que veio no template que não precisamos:

hellospringjsfdelete

Agora vamos adicionar suporte ao JSF para o projeto. Basta clicar com o botão direito do mouse no projeto e escolher:

 

configurejsfhellospringproject

Na tela a seguir bastar dar ok:

jsfscreenspringhello

Adicione os .jars na pasta lib:

 

jarslibhellopspring

Crie os packages a seguir:

hellospringpackages

A nossa aplicação será bem simples, daremos um Hello para um determinado usuário que será criado quando o método getUserInformation é invocado pelo controller.

User.java

public class User {

    private String name;

    private String lastName;

    private Integer age; 

//getters/setters  omitidos

}

Criaremos uma interface para o serviço

UserService.java

public interface UserService {

    public User getUserDetails();

}

 Agora temos a implementação da interface:

@Service

public class UserServiceImpl implements UserService {

     private User user;   

    public UserServiceImpl() {

     user = new User();

     user.setName(“camilo”);

     user.setLastName(“lopes”);

     user.setAge(10);

    }

    @Override

    public User getUserDetails() {       

        return user;

    } 

}

 Antes de criarmos a classe de controller precisamos fazer umas configurações no arquivo web.xml e também criarmos o nosso arquivo de configuração do Spring. Primeiro vamos alterar o web.xml

Adicione o cara que carrega as configurações do Spring

<listener>

  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

 </listener>

 

Vamos dizer para ele onde pegar as configurações do Spring:

<context-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>/WEB-INF/springconfiguration.xml</param-value>

 </context-param>

 Apesar que não criamos  o arquivo springconfiguration.xml , mas não há problemas algum.

E agora vamos colocar o cara que permitirá utilizar os escopos padrões de uma aplicação web

<listener>

  <listener-class>org.springframework.web.context.request.RequestContextListener

</listener-class>

 </listener>

 E assim terminamos a configuração do web.xml

Face-config.xml

E agora vamos dizer ao JSF para delegar a criação do ManagedBeans para o Spring, mas para isso vamos alterar o arquivo face-config.xml

<face-config>

<application>

  <el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>

 </application>

</faces-config>

Criando o  arquivo de configuração do Spring

Aqui chamei meu arquivo de configuração do Spring de springconfiguration.xml e como vimos anteriormente informamos ele no web.xml para que ao iniciar aplicação o application context saiba onde e quem buscar.

hellpspringconfigurationfile

Portanto crie um arquivo .xml conforme a seguir:

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

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=“*”/> 

</beans>

 

Só isso que precisamos. 

Criando a classe controller

UserController.java

@Controller

@Scope(“request”)

public class UserController {

    @Autowired

    private UserService userServ; 

    public User getUserInformation(){       

        return userServ.getUserDetails();

    }

    public void setUserServ(final UserService userServ) {

        this.userServ = userServ;

    }

}

Se você já conhece o Spring nada de especial aqui, apenas trocamos as anotações do JSF pela dos Spring.

Criando a página .xhtml

Vamos criar uma página home.xhtml que terá o código JSF. Para isso crie uma .xhtml withou facets.

E no body da página adiicone:

Hello <h:outputText value=“#{userController.userInformation.name}” />

 Agora clique com o botão direito do mouse no projeto e escolha Run On Server e o resultado será:

<img hellospringresultado>

Acessando http://localhost:8080/nomedoprojet/home.jsf

Note: lembrando que para dar suporte .jsf você precisa dizer isso no web.xml, assim:

<servlet-mapping>

  <servlet-name>Faces Servlet</servlet-name>

  <url-pattern>*.jsf</url-pattern>

 </servlet-mapping>

 

Pronto. Agora temos o nosso projeto JEE integrado com o Spring e tirar todo o beneficio que o framework nos traz. Simples não?

Abraços, 

Criando WebServices Java 6

Posted by camilolopes | Posted in AngularJS | Posted on 13-10-2012

5

Olá pessoa­­­l,

Preparei este post para quem quer começar a brincar com WebService. Fiz três posts: um “hello world”, outro onde veremos como criar um cliente para consumir o serviço e por último criar um WebService envolvendo banco de dados que será consumido. Usaremos alguns recursos do Java 6 para criar e publicar um WebService.  Eu espero que vocês gostem da série. O objetivo maior é poder compartilhar o conhecimento com quem está chegando, eu tive dificuldades no inicio de juntar todo quebra-cabeça e ver uma simples mensagem. Nem sempre é fácil quando estamos dando os primeiros passos e o objetivo do post é ajudar quem está nesse contexto. Enfim, teremos uma pequena jornada nas próximas semanas.

Lets GO…

WebService

Não vou falar sobre o que é um WebService, pois há vários artigos, posts em blog, Wikipedia explicando exatamente o proposto da tecnologia, o post aqui tem foco de ser prático, ou seja, algo mão na massa, e vou considerar que você já leu sobre o assunto, porém agora quer ver a coisa funcionado. Eu não sou muito bom de teoria, e vou darei um exemplo bem alto nível somente para tentar exemplificar o que é um WebService, caso você tenha dúvida do conceito (eu particularmente quando li o sobre o assunto pela primeira fiquei meio perdido).  Imagine a Amazon (é o servidor) e você é um cliente da Amazon como fornecedor. Você tem uma livraria em parceria com Amazon, porém a aplicação que controla os livros que você tem na sua livraria é diferente do sistema de controle da Amazon, porém você gostaria de realizar uma pesquisa no “banco” da Amazon e poder efetuar compras de livros como fornecedor quando não tivesse o exemplar na livraria fisicamente, como fazer isso a partir da sua aplicação? Através de um WebService. A Amazon disponibiliza esse serviço de consultar e comprar livros como fornecedor e vc como consumidor vai pegar esse serviço e incorporar ao seu sistema, sem precisar adaptar seu sistema (mudar linguagem, banco etc) para nada especifico da Amazon. Supondo que seu sistema é em .NET e o da Amazon em Java, isso pouco importa via WebServices.

Por que Java 6?

No Java 6 foi adicionado anotações que permitem, definimos se a nossa classe é um WebService e quais métodos queremos publicar. Além de outras anotações relacionadas. E isso nos ajuda a criar e publicar um WebService sem precisar de um container (TomCat,Jetty etc). É isso mesmo, vc não vai precisar instalar um desses servidores para criar e testar seus webservices durante desenvolvimento. Evidente que essa forma não vai substitui os benefícios que temos ao usar um servidor de aplicação.  Mas, é uma mão durante o desenvolvimento.

Nosso exemplo

No nosso exemplo vamos fazer um  Hello World + <nomepassado> ou seja, “Hello World Camilo”. É algo muito simples, mas para quem está iniciando é uma felicidade em ver as coisas funcionando mesma que seja com uma mensagem tão tradicional como a nossa.

O que você precisa saber antes de começar:

É importante que você conheça os termos abaixo:

SEI Service Endpoint Interface: temos a interface com as operações (métodos) do webservice

SIB Service Implementation Bean: representa a classe que implementa a interface. Este sempre tem um link através da anotação @WebService para o SEI, ou seja, o endPoint.

WSDL: é um contrato entre o meu serviço com os mais consumidores

SOAP: é um protocolo usado na criação WS

Comando wsimport: usado pelo consumidor, ou seja, pelo cliente que vai usar o webservice. Esse comando tem a responsabilidade de criar o cliente webservice para o webservice (estranho mais é isso que acontece na pratica)

Comando apt: gera o javaws(pacote/package) para o publish do serviço.

apt:<caminho da classe WebService>

@WebService = é sinal que temos um SEI

@WebMethod = é sinal que cada método é uma operação do service

Praticando

Neste primeiro exemplo veremos como criar um WebServices e publicá-lo para que terceiros possa consumir o serviço que disponibilizamos:

  1. Crie um projeto no Eclipse JavaApplication
  2. criamos os três packages: 1 para colocar a classe que é responsável por publicar o webservice, outra para ter a interface (SEI) e mais um para a classe que implementada a interface (SIB).

Interface SEI

Vamos criar a nossa interface que terá dois métodos a serem implementados pela classe que estará no package SIB. Onde o objetivo é dar boas vindas ao usuário em dois idiomas: inglês e português. O código deve ficar assim:

@WebService

public interface Welcome {

@WebMethod

String welcomePt(String nome);

@WebMethod

String welcomeEn(String nome);

}

SIB – Classe que implementa a interface

Vamos criar a classe que tem a responsabilidade dá “colocar” carne no esqueleto. Vale lembrar que poderíamos fazer isso tudo em uma classe sem o uso da interface etc. Mas, por boas praticas de desenvolvimento fizemos assim.

import javax.jws.WebService;

import br.com.camilolopes.ws.sei.Welcome;

@WebService(endpointInterface=”br.com.camilolopes.ws.sei.Welcome”)

public class WelcomeImpl implements Welcome {

@Override

public String welcomePt(String nome) {

// TODO Auto-generated method stub

return “Olá “+ nome;

}

@Override

public String welcomeEn(String nome) {

// TODO Auto-generated method stub

return “Hello ” +nome;

}}

Anotação @WebService na classe é necessário fazer, pois precisamos indicar o endPointInterface que nesse caso é a nossa classe que colocamos no package xx.sib

Publicando o Serviço

Para publicarmos é muito simples. Criaremos uma classe responsável, como a seguir:

public class WelcomePublish {

public static void main(String[] args) {

Endpoint.publish(“http://localhost:9876/welcome”, new WelcomeImpl());

}}

No código acima estamos informando onde será publicado o serviço: endereço (localhost) e a porta (9876). Depois informamos à classe que tem a implementação do serviço. É o mesmo que dizer: publique neste endereço, o que temos na classe WelcomeImpl.Na pratica é isso que acontece.

Note: cuidado com a porta se estiver ocupada veja qual o processo está usando e finalize. Normalmente a porta acima está disponível. Depois que terminar de publicar seu serviço e quiser subir outro na mesma porta, vá ao gerenciador de tarefa e mate o process javaws, ele será o que o seu webservice estava usando ou pare sua aplicação via Eclipse.

Testando o Serviço

Para testarmos se o nosso serviço está funcionando, vamos publicá-lo executando a classe WelcomePublish. Ao rodar a classe devemos ter a imagem a seguir no console:

Verificando serviço publicado

Para verificar o serviço, vamos acessar usando o browser e obter o wsdl. Certifique que a classe WelcomePublish está rodando e acesse: http://localhost:9876/welcome?wsdl . Já temos o serviço publicado, e agora qualquer outra pessoa pode criar o cliente e consumir. Acesse o link e veja o resultado :).

Acho que por hoje é só isso, no próximo vamos conhecer a SOAPUI e como criar um cliente para consumir esse serviço.Não se preocupe por agora como será consumido e sim entender a base de WebService e praticar um pouco mais.

Abraços,  espero que tenham gostado. See ya!!