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

 

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, 

ThroubleShooting: Resolvendo .OutputLabelRenderer.encodeEnd PrimeFaces

Olá Pessoal,

O throubleshooting de hoje, é algo muito bobo,mas chato que acontece ao usarmos o <p:outputLabel />do Primefaces. Se vc faz isso:

<p:outputLabel value=”Tipo da Conta” />

Simplesmente verá algo assim:

The error is the following:

java.lang.NullPointerException     at org.primefaces.component.outputlabel.OutputLabelRenderer.encodeEnd(OutputLabelRenderer.java:38)

Mas, por que isso acontece?

Simplesmente, pq esse componente requer  que o atributo for esteja associado a um id no input. E dai para resolver basta fazer isso:

<p:outputLabel for=”accountType” value=”Tipo da Conta” />

<h:inputText id=”accountType” value=”#{accountBean.account.type}”/>

Ou seja, nós temos um for para o id.

Simples assim. Não? Mas, muito chato de resolver. :).

abracos vou ficando por aqui.

See ya!!

ThroubleShooting:Adicionando AutoComplete XHTML PrimeFaces projeto Maven

Olá Pessoal,

No post de hoe veremos um troubleshooting  quando criamos um projeto Maven e precisamos do auto-complete  nos XHTML.

Lets go…

Starting…

Ao criar um projeto maven para uma aplicação web, por default ele não fornece o autocomplete para arquivo xhtml, e evidente que para componentes externos como PrimeFaces também não terá por default .

E como resolver?

A solução não é das melhores, mas é o que tem que ser feito, vamos ver os passos:

1. Se vc usar tomcat/jetty baixe a versão  no caso do exemplo estou usando Jetty 8.x

2. Garante que você tem o .jar do primefaces adicionar ao pom do projeto

3. clique com o botão direito no projeto >> configure >> add...

 

Na tela que abrir clique em next, observe o arquivo web.xml vai sofrer alteração, pois vamos adicionar suporte ao JSF.

Depois clique em Finish.

Se você não tem um servidor de aplicação configurado no seu eclipse, vá em Windows >> preferences >> Server >> Runtime Environment e adicione.

** Você deve apontar para a pasta onde tá o servidor instalado, no caso do jetty ele não é instalado, após descompactar o arquivo .zip, apenas aponta para a raiz da pasta descompactada. Assim o Eclipse encontrará o .jar que ele precisa.

Vou ficando por aqui, espero que tenham curtindo o post.

Abraços,  see ya!!

Navegação Implicita JSF 2.x

Olá pessoal,

Hoje veremos um recurso legal que  temos no JSF 2.x, apesar da versão 2.0 ter sido lançada há um bom tempo já, eu ainda brincava com a versão antiga 1.2. Apesar de ter acompanhado os updates da versão mais recente, porém não tinha colocado nada em prática do no dia-dia. E algo que curtir bastante foi esse tal de “nagevação implícita” e não é que o trem é bão e produtivo? Vamos ver…

Lets GO…

Starting

A navegação implícita é um recurso novo que temos no JSF que nos ajuda a não ter que fazer declarações no face-config.xml. Na verdade no JSF 2.0 não é requerido ter um face-config.xml, mas há situações  que é preciso ter, mas não entraremos nesse contexto. A pergunta é como a navegação implícita pode nos ajudar?

Ela pode nos ajudar quando precisamos navegar entre as páginas e que não é requerido validação. Na versão 1.2 tinhamos que passar isso no face-config.xml.  Com navegação implícita não precisamos fazer as declarações de <navigation-rule> <navigation-case>, a única coisa que é requerida é que o nome do arquivo seja igual ao que passamos para o action de um componente JSF.

<h:commandLink  value=”/pages/greeting” action=”/pages/greeting” />

<h:commandLink value=”contato” action=”contato”/>

Observe que podemos passar arquivos dentro de diretórios ou na raiz que o JSF vai entender sem problemas.

E o problema?

– É que você não pode ter dois arquivos  com o mesmo nome no mesmo local (obvio);

– o nome do arquivo não pode ser alterado, caso seja terá que alterar todos os componentes que usam a navegação implícita com aquele arquivo, na versão com face-config.xml, há uma vantagem você precisa apenas atualizar o face-config.xml.

Quando usar?

Não há receita de bolo em dizer que no caso X deve sempre usar navegação implícita ou não. A questão é saber se o contexto que você tem, o recurso de navegação implícita agrega valor ou não.

Exemplo

Veja um exemplo simples que eu fiz, para criar o JSF Project estou usando o plugin Jboss Tools,caso não tenha veja como instalar  no final que está no final do post.

Crie um projeto JSF Project

File >> New >> JSF Project

Crie dois arquivos XHTML: contato.xhtml e navimplicit.xhtml e deixe dentro de WebContent

Abra o arquivo navimplicit.xhtml  e codifique o código a seguir:

<h:body>

<h:form>

<h:outputText value=“Usando Navegação Implicita JSF 2.0”/> <br/>

<h:commandLink  value=“/pages/greeting” action=/pages/greeting /><br/>

<h:commandLink value=“contato” action=contato/>

</h:form>

</h:body>

Não há nada de especial no código, exceto o conteúdo para o atributo action, o qual passamos  a página ou o caminho onde está a página que desejamos abrir. Observe que não  informamos o formato do arquivo,  não é necessário informar.

A diferença entre os links é que no primeiro usamos a navegação implícita com um arquivo que está no diretório, enquanto no segundo, estamos pegando um arquivo que está na raiz do WebContent.

Executando

Para executar é bem simples, basta clicar com o botão direito e escolher a opção Run As >> Run on Server . é necessário ter um servidor de aplicação como tomcat, jetty etc. Para o exemplo estou usando o TomCat 7.0.

Acessando

Após ter feito o deploy, vamos testar o recurso.  Então digite no browser:

http://localhost:8080/ExJSF20NavImplicit/navimplicit.jsf

Observe que no final adicionamos a página que tem os links com o recurso de navegação implícita. A sua página deve ter o conteúdo conforme a imagem a seguir:

Clique em um dos links e terá o resultado conforme a imagem a seguir:

E assim temos o resultado sem precisar configura o face-config.xml.

Abraços, vou ficando por aqui e espero que tenham gostado do post.

See ya!!!

JSF com Spring Security

olá pessoal,

Neste post vou abordar algo que pode ser bem interessante para quem está usando o SpringSecurity como framework de segurança em suas aplicações JEE. Se você usa o JSF, há possibilidade de fazer a validação do role que temos no Spring dentro do form. Eu já apresentei em outros posts a solução para role a nível de banco de dados, veremos aqui uma opção que não depende de função específica do banco.

Lets go…

Iniciando

Vimos neste post, a solução do ROLE quando temos que usar em um banco de dados. Porém, depois de uma experiência em um projeto JEE que tinha JSF + BD + SpringSecurity eu fiquei pensando como implementar a solução para o ROLE sem ficar dependendo do banco, já que a função de concatenar é dependente do fabricante. E uma vez que o banco mudar eu teria que lembrar de atualizar o code com o método que faz a concatenação daquele banco em específico. Não achei nada legal, daí por acaso conheci o uso do rendered no JSF, onde nesse post apresentei o uso do atributo. Resolvi fazer o teste para o ROLE do Spring e deu “bingo”. A seguir veremos parte de um código que faz o teste.

Desenvolvimento

Para entender o código a seguir vamos imaginar um programador que não sabia como tirar o ROLE do Spring antes de ir para o banco. E acabou tendo que gravar as informações na coluna Cargo ROLE_Administrador (mas, ele queria apenas Administrador). Porém, ao exibir os dados ao usuário final em uma tabela não está nada legal termos ROLE_Administrador e o role não faz maior sentindo para o usuário final, e a primeira solicitação do cliente será removê-lo.

No banco

O que queremos é exibir esses dados na tabela sem o role, para isso na sua pagina que exibi os usuarios, teremos que comparar os dados que vem do BD e alterar somente para o view no JSF.

<td jsfc=”h:column”>

<f:facet name=”header”>

<h:outputText value=”Cargo”/>

</f:facet>

<h:outputText rendered=”#{us.cargo==’ROLE_Administrador’}” value=”Administrador”/>

<h:outputText rendered=“#{us.cargo==’ROLE_Usuario’}” value=”Usuario”/>

</td>

Basicamente é isso que você precisa,  pelo menos agora não precisa se preocupar mais em alterar funções no BD.

Vou ficando por aqui, espero que tenham gostado, esse post foi bem curto, mas causa grande impacto quando estamos usando JSF + SpringSecurity.

Abracos, see ya!!