Fabio Brandão – Blog

Freemarker + Sitemesh + Spring

Depois de muito tempo consegui fazer minha aplicação utilizando Freemarker (template engine) + Sitemesh (web page layout framework) + Spring (IOC, etc) funcionar.

Basicamente, basta configurar no web.xml o filtro do Sitemesh (com.opensymphony.sitemesh.webapp.SiteMeshFilter), a servlet do Freemarker que vem com o Sitemesh (com.opensymphony.module.sitemesh.freemarker.FreemarkerDecoratorServlet) e a servlet do Spring MVC (org.springframework.web.servlet.DispatcherServlet).

O filtro do Sitemesh é aplicado a todas as requisições, a servlet do freemarker às urls *.ftl e a servlet do Spring às urls *.html.

O problema que eu tive foi que os templates do Freemarker e do Sitemesh não eram encontrados. No web.xml, um dos parâmetros iniciais da servlet do Freemarker é o diretório dos templates (TemplatePath). Configurei este parâmetro para “/WEB-INF/templates/”. E no arquivo decorators.xml configurei que os templates do Sitemesh ficavam no diretório “/decorators”. O que acontecia é que o diretório dos templates do Sitemesh deveriam ficar dentro do diretório dos templates do Freemarker. Logo a estrutura de diretórios é dessa maneira: /WEB-INF/templates/decorators.

Segue abaixo o link com a aplicação de exemplo desta integração:
http://www.fnbrandao.com.br/blog/files/freemarker.tar.gz

Spring gerenciando as transações

Após duas longas semanas resolvi o problema que estava tendo com o Spring gerenciando as transações de banco de dados. O que acontecia é que nenhuma transação era aberta na classe marcada com a anotação “@Transactional”. Segue abaixo um exemplo de como utilizar o gerenciamento de transações do Spring:

package br.com.test;

public interface IService {

    int myServiceMethod(String myServiceParameter);

}

Segue abaixo a implementação, repare no uso da anotação “@Transactional” na classe (isto indica que a classe toda deve estar associada à um contexto transacional. É possível também marcar métodos:

package br.com.test;

import org.springframework.transaction.annotation.Transactional;

@Transactional
public class ServiceBean implements IService {

    public int myServiceMethod(String myServiceParameter) {
        return Integer.parseInt(myServiceParameter);
    }

}

Agora só falta configurar o “applicationContext.xml” do Spring:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  
  <bean id="myService" class="br.com.test.ServiceBean"/>

  <tx:annotation-driven transaction-manager="txManager"/>

  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
  </bean>
</beans>

Repare no uso da tag “<tx:annotation-driven transaction-manager=”txManager”/>”. Esta tag ativa a configuração de transações baseada em anotações.

Até aí é muito simples utilizar o gerenciamento de transações do Spring. O problema que tive foi o seguinte: meu serviço possuía uma interface, e esta interface estava sendo implementada por uma classe abstrata. Essa classe abstrata definia o método que eu queria que fosse transacional. Depois eu criei uma terceira classe que extendia essa classe abstrata. Coloquei a anotação “@Transactional” na classe concreta, e o Spring não gerenciava as transações no método definido na classe abstrata. Para resolver o problema só foi necessário colocar a anotação da classe abstrata.

JSF + Spring + JPA + Hibernate

Ao tentar fazer o deploy de uma aplicação utilizando JSF, Spring e JPA (com implementação do hibernate) é recebida a seguinte exception:

javax.persistence.PersistenceException: org.hibernate.SessionException: Session is closed!

Para resolver este problema, basta apenas adicionar o seguinte filtro no “web.xml”:

<filter>
	<filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
	<filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
</filter>

<filter-mapping>
	<filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>