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