Olá, pessoal! No artigo 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 a configuração de cada um dos frameworks, mas na hora de fazer a integração, veio aquela pergunta: “E agora como faço?”.

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 defaulte é 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á tenhsa tudo isso antes de começar a desenvolver.

Desenvolvimento

Agora vamos meter a mão na massa. Primeiro crie um Spring template Project  na lista de opções e escolha Spring Hibernate Utility. Apesar de não usar o 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:

Note: se vc já tem um projeto JEE, só vai precisar adicionar suporte ao Spring. Você também poderia criar um JSF Project e adicionar o Spring. Enfim, há N possibilidades.

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

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

Na tela a seguir bastar dar ok:

Adicione os .jars na pasta lib:

Crie os packages a seguir:

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.

[java]User.java

public class User {

private String name;

private String lastName;

private Integer age;

//getters/setters omitidos

}[/java]

Criaremos uma interface para o serviço:

UserService.java

[java]public interface UserService {

public User getUserDetails();

}[/java]

Agora temos a implementação da interface:

[java]@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;

}

}[/java]

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

[java]<listener>

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

</listener>[/java]

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

[java]<context-param>

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

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

</context-param>[/java]

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

[java]<listener>

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

</listener-class>

</listener>[/java]

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

[java]<face-config>

<application>

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

</application>

</faces-config>[/java]

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.

Portanto, crie um arquivo .xml conforme a seguir:

[java]<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>[/java]

Só isso que precisamos.

Criando a classe controller

UserController.java

[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;

}

}[/java]

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 adicone:

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

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:

[java]<servlet-mapping>

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

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

</servlet-mapping>[/java]

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

Abraços!