Aplicación JSF + Spring

Bueno parece que este mes estoy un poco más activo y puedo escribir un poco más. Hoy me han pedido un pequeño esqueleto de aplicación JSF y Spring 2.5.6 por lo que he aprovechado para escribir este post y para enseñar que realmente crear un proyecto con Spring no es algo muy complejo.Por norma general a parte de disponer del jar de Spring solo necesitamos incluir en nuestro web.xml las siguientes lineas:

El parametro de la ubicación del fichero de configuración.

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>

El listener propio de Spring.

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

Creamos el fichero de configuración de Spring en WEB-INF/ con el nombre de applicationContext.xml como ya hemos visto en el parametro que definimos anteriormente en nuestro web.xml. No os pegare la definición del fichero por que realmente es muy grande.

Una vez visto como se configura Spring basta con configurar en nuestro web.xml la parte correspondiente a JSF. Esto ya es todo un clásico así que voy a obviar las explicaciones:

<context-param>
<param-name>com.sun.faces.verifyObjects</param-name>
<param-value>false</param-value>
</context-param>
<context-param>
<param-name>com.sun.faces.validateXml</param-name>
<param-value>true</param-value>
</context-param>
<context-param>
<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
<param-value>client</param-value>
</context-param>
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>

Bueno ya tenemos la configuración ahora viene lo interesante. Spring basa principalmente su funcionamiento en la Inversión de Control(IoC) y un ejemplo seria:

<!-- dao -->
<bean id="dao" class="com.nc.dao.impl.DaoImpl">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- service -->
<bean id="service" class="com.nc.srv.impl.ServiceImpl">
<property name="dao" ref="dao" />
</bean>

Esta es la forma de definir los beans en nuestro applicationContext.xml. Como se observa Spring genera una instancia de las clase definida en la etiqueta bean y les asigna el nombre del identificador del campo id. Tras cargar todos los bean inyecta las referencias en las propiedades de cada uno. El código de uno de estos Beans seria algo así:

public class ServiceImpl implements Service {
private Dao dao;
public void setDao(Dao dao) {
this.dao = dao;
}
public List<PersonVO> getPeople() {
return dao.getPeople();
}
}

Siempre que definimos una propiedad inyectable en nuestro applicationContext.xml el bean debe de disponer como minimo el metodo setter de la misma.

Visto esto el siguiente paso es ¿Como se inyectan beans definidos en Spring en beans definidos para JSF?. Spring no solo realiza la inversión de control, sino que además dispone de adaptadores y otras librerías que le permiten trabajar combinadamente con otros frameworks. Para trabajar con JSF, Spring ofrece un variable-resolver propio que basta con agregar a nuestro fichero faces-config.xml de esta manera:

<application>
<variable-resolver>
org.springframework.web.jsf.DelegatingVariableResolver
</variable-resolver>
</application>

Una vez hecho disponemos de las referencias descritas en el applicationContext.xml dentro de nuestro faces-config.xml por lo que solo debemos declarar propiedades en nuestros Beans de JSF y las referencias como podeis ver en este ejemplo:

<managed-bean>
<managed-bean-name>index</managed-bean-name>
<managed-bean-class>com.nc.jsf.IndexBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
<managed-property>
<property-name>service</property-name>
<value>#{service}</value>
</managed-property>
</managed-bean>

Las referencias definidas anteriormente en el applicationContext.xml son usadas para ser inyectadas en nuestros Beans de JSF, por lo que podemos acceder a ellas sin problemas:

private Service service;
public void setService(Service service) {
this.service = service;
}
public String getText() {
List<PersonVO> people = service.getPeople();

Hasta aquí llega la explicación así que si teneís dudas podeís descargaros el proyecto NetBeans aquí y probarlo por vosotros mismos.

Proyecto Netbeans JSF + Spring

¡Ojo este proyecto usa una BD Derby y una de las BD de prueba denominada travel! por ello deberiais cambiar las opciones de conexión definidas en el applicationContext.xml y cambiar los mapeos de hibernate del proyecto(solo es una tabla con id,valor).

Espero que os haya ayudado y en un futuro tratare de ampliar un poco más este post hablando de la parte de Hibernate que tiene integrada Spring.