vRaptor 3 + Hibernate | Sessions não são fechadas... =T

Boa noite a todos.

Estou tentando fazer as sessions fecharem pois estou tendo continuos problemas de queda do banco de dados pq as sessions estouram por não serem fechadas. Estou utilizando os interceptors padrão do vRaptor para abrirem as sessions, fecharem, começarem a transação e comitarem.

Por favor, se possível, me digam onde está o erro.

Obrigado.

Seguem as classes:

/**
 * Hibernate Utility class with a convenient method to get Session Factory object.
 *
 * @author helio
 */
@ApplicationScoped
@Component
public class HibernateUtil {
    private static final Configuration cfg;
    private static final SessionFactory sessionFactory;

    static {
        try {
            cfg = new AnnotationConfiguration()
                    .addAnnotatedClass(Usuario.class)
                    .addAnnotatedClass(Pregador.class)
                    .addAnnotatedClass(Pregacao.class)
                    .addAnnotatedClass(Comentario.class)
                    .addAnnotatedClass(Video.class)
                    .addAnnotatedClass(Evento.class)
                    .addAnnotatedClass(Imagem.class)
                    .addAnnotatedClass(Categoria.class)
                  /*.addAnnotatedClass(Louvor.class)
                    .addAnnotatedClass(Levita.class)*/
                    .addAnnotatedClass(Folheto.class)
                    .addAnnotatedClass(Foto.class)
                    .addAnnotatedClass(ImagemFolheto.class)
                    .addAnnotatedClass(Mensagem.class)
                    .addAnnotatedClass(DestinatarioMensagem.class)
                    .addAnnotatedClass(ConfiguracaoAdminSMS.class)
                    .addAnnotatedClass(ConfiguracaoUsuarioSMS.class)
                    .addAnnotatedClass(LancamentoSMS.class)
                    .addAnnotatedClass(Endereco.class)
                    .addAnnotatedClass(Aquisicao.class)
                    .addAnnotatedClass(Servico.class)
                    .addAnnotatedClass(ServicoAquisicao.class)
                    .addAnnotatedClass(DepartamentoIgreja.class)
                    .addAnnotatedClass(Igreja.class)
                    .addAnnotatedClass(MembroDepartamento.class)
                    .addAnnotatedClass(MembroIgreja.class);
            
            sessionFactory = cfg.buildSessionFactory();

        } catch (Throwable ex) {
            // Log the exception. 
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void printStatistics(){
        Statistics s = sessionFactory.getStatistics();
        if(s.isStatisticsEnabled()){
            System.out.println("--------- Estatisticas do Hibernate ---------");
            System.out.println("| Statements Fechados = "+s.getCloseStatementCount());
            System.out.println("| Transações = "+s.getTransactionCount());
            System.out.println("| Transações com sucesso = "+s.getSuccessfulTransactionCount());
            System.out.println("| Conexões = "+s.getConnectCount());
            System.out.println("| Sessoes abertas = "+s.getSessionOpenCount());
            System.out.println("| Sessoes fechadas = "+s.getSessionCloseCount());
        } else {
            System.out.println("Estatisticas estao desabilitadas");
        }        
    }
}

classe Database ( Componente que retorna os Dao’s já com a session )

@Component
public class Database {
    private final Session sessao;
    private Transaction transaction;

    public Database(Session session){
        sessao = session;//HibernateUtil.getSessionFactory().openSession();
    }

    /**
     * Inicia uma transacao
     */
    public void beginTransaction(){
        transaction = sessao.beginTransaction();
    }

    /**
     * Comita a transacao
     */
    public void commit(){
        if(transaction.isActive() && (!transaction.wasCommitted())){
            transaction.commit();
        } 
    }

    /**
     * Desfaz uma transacao
     */
    public void rollback(){
        transaction.rollback();
    }

    /**
     * Verifica se tem uma transacao
     *
     * @return
     */
    public boolean hasTransaction(){
        // Se a transacao for nula, é porque nao iniciou, entao nao tem
        return (transaction != null && transaction.isActive());
    }

    public boolean wasCommited(){
        return transaction.wasCommitted();
    }

    public boolean wasRolledback(){
        return transaction.wasRolledBack();
    }

    /**
     * Retorna a fullTextSession
     * @return
     */
    public FullTextSession getFullTextSession(){
        return Search.getFullTextSession(sessao);
    }

    /**
     * Consulta as pregacoes cadastradas no sistema e as indexa
     * 
     * @param fullTextSession
     */
    private void indexarPregacoes(FullTextSession fullTextSession){
        Paginacao pag = new Paginacao(1, 5000, 0, 0);
        List<Pregacao> pregacoes = getPregacaoDao().getLista(new Pregacao(), pag);

        for(Pregacao p : pregacoes){
            System.out.println("indexando pregação "+p.getTitulo());
            fullTextSession.index(p);
            //fullTextSession.flushToIndexes();
        }
    }

    /**
     * Passa por todos os pregadores e vai indexando-os
     *
     * @param fullTextSession
     */
    private void indexarPregadores(FullTextSession fullTextSession){
        Paginacao pag = new Paginacao(1, 5000, 0, 0);
        List<Pregador> pregadores = getPregadorDao().getLista(new Pregador(), pag);
        System.out.println("Encontrados "+pregadores.size()+" pregadores");
        for(Pregador pr : pregadores){
            System.out.println("Indexando pregador "+pr.getNome());
            fullTextSession.index(pr);
            //fullTextSession.clear();
        }
    }    

    /**
     * Cria os arquivos de busca do hibernate search
     * 
     * @param obj
     */
    public void gerarIndicesHibernateSearch(Object obj){
        // Limpa os indices
        FullTextSession session = getFullTextSession();
        Transaction tr = session.beginTransaction();
        if(obj.equals(Pregacao.class)){
            System.out.println("Limpando pregacoes");
            session.purgeAll(Pregacao.class);
        } else if(obj.equals(Pregador.class)){
            System.out.println("Limpando pregadores");
            session.purgeAll(Pregador.class);
        }
        tr.commit();

        FullTextSession fullTextSession = getFullTextSession();
        Transaction tx = fullTextSession.beginTransaction();
        tx.begin();
        System.out.println("---- Begin FullText Transaction ----");
        fullTextSession.setCacheMode(CacheMode.IGNORE);
        fullTextSession.setFlushMode(FlushMode.MANUAL);

        if(obj.equals(Pregacao.class)){
            indexarPregacoes(fullTextSession);
        }
        if(obj.equals(Pregador.class)){
            indexarPregadores(fullTextSession);
        }

        System.out.println("Terminou");
        if(tx.isActive()){
            System.out.println("Está ativa, vai comitar");
            try {
                tx.commit();                
                //fullTextSession.getSessionFactory().close();
                //fullTextSession.close();
                System.out.println("---- Comitou a FullTextSession e fechou ----");
            } catch(HibernateException e){
                tx.rollback();
                System.out.println("---- Rollback FullTextSession ----");
            }
        }
    }

    /**
     * Retorna uma FullTextQuery
     * 
     * @param busca
     * @return
     */
    public org.hibernate.Query fullTextSearch(String busca){
        FullTextSession fullTextSession = getFullTextSession();        

        // Criando a consulta
        String[] campos = new String[]{"titulo", "descricao", "tags", "pregador_nome"};

        MultiFieldQueryParser parser = new MultiFieldQueryParser(campos, new StandardAnalyzer());
        
        org.hibernate.Query hibQuery = null;
        org.apache.lucene.search.Query lucQuery = null;
        try { // Query do lucene
            //System.out.println("titulo:"+busca+" OR descricao:~"+busca+" OR tags:"+busca+" OR pregador_nome:"+busca);
            //lucQuery = parser.parse("titulo:"+busca+" OR descricao:"+busca+" OR tags:"+busca+" OR pregador_nome:"+busca);
            lucQuery = parser.parse(busca);
        } catch(ParseException e){
            e.printStackTrace();
        }
        if(lucQuery != null){
            // Query do hibernate
            hibQuery = fullTextSession.createFullTextQuery(lucQuery, Pregacao.class);
        }
        return hibQuery;
    }

    /**
     * Fecha a conexao
     */
    public void close(){
        sessao.close();
        /*HibernateUtil.closeFactory();
        if(!sessao.getSessionFactory().isClosed()){
            sessao.getSessionFactory().close();
            System.out.println("---- Fechou a Session Factory ----");
        }
        if(sessao.isOpen()){
            sessao.close();
            System.out.println("---- Fechou a Session ----");
        }*/
    }

    public FolhetoDao getFolhetoDao(){
        return new FolhetoDao(sessao);
    }

    public FotoDao getFotoDao(){
        return new FotoDao(sessao);
    }

    public ComentarioDao getComentarioDao(){
        return new ComentarioDao(sessao);
    }

    public EventoDao getEventoDao(){
        return new EventoDao(sessao);
    }

    public PregadorDao getPregadorDao(){
        return new PregadorDao(sessao);
    }

    public UsuarioDao getUsuarioDao(){
        return new UsuarioDao(sessao);
    }

    public PregacaoDao getPregacaoDao(){
        return new PregacaoDao(sessao);
    }

    public VideoDao getVideoDao(){
        return new VideoDao(sessao);
    }

    public ImagemDao getImagemDao(){
        return new ImagemDao(sessao);
    }

    public LevitaDao getLevitaDao(){
        return new LevitaDao(sessao);
    }

    public ServicoDao getServicoDao(){
        return new ServicoDao(sessao);
    }

    public MensagemDao getMensagemDao(){
        return new MensagemDao(sessao);
    }

    public AquisicaoDao getAquisicaoDao(){
        return new AquisicaoDao(sessao);
    }

    public MembroIgrejaDao getMembroIgrejaDao(){
        return new MembroIgrejaDao(sessao);
    }

    public IgrejaDao getIgrejaDao(){
        return new IgrejaDao(sessao);
    }   

    public DepartamentoIgrejaDao getDepartamentoIgrejaDao(){
        return new DepartamentoIgrejaDao(sessao);
    }

    public ConfiguracaoSMSDao getConfiguracaoSMSDao(){
        return new ConfiguracaoSMSDao(sessao);
    }

    public LancamentoDao getLancamentoDao(){
        return new LancamentoDao(sessao);
    }
}

Agora um dos controllers, para terem uma idéia de como estou utilizando os controllers

@Resource
public class EventoController {
    private Result result;
    private EventoDao dao;
    private HttpSession sessao;

    public EventoController(Result result, Database database, HttpSession sessao){
        this.result = result;
        this.sessao = sessao;
        dao = database.getEventoDao();
    }

    /**
     * Exibe a listagem de administração de eventos
     * 
     * @param page
     */
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void index(int page){
        page = (page <= 0) ? 1 : page;
        Paginacao paginacao = new Paginacao(page, 20, 0, 0);
        List<Evento> eventos = dao.getLista(new Evento(), paginacao);
        result.include("eventoList", eventos);
        result.include("paginacao", paginacao);
    }

    /**
     * Exibe a lista geral de eventos
     *
     * @param page
     */
    public void lista_eventos(int page){
        page = (page <= 0) ? 1 : page;
        Paginacao paginacao = new Paginacao(page, 20, 0, 0);
        List<Evento> eventos = dao.getLista(new Evento(), paginacao);
        result.include("eventoList", eventos);
    }

    /**
     * Exibe a pagina de cadastro de novo evento
     */
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void novo(){
        
    }

    /**
     * Salva um evento
     * 
     * @param evento
     */
    @Transacao
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void salvar(Evento evento){
        dao.cadastrar(evento);
        sessao.setAttribute("flash", "Evento cadastrado com sucesso!");
        result.use(Results.logic()).redirectTo(EventoController.class).index(1);
    }

    /**
     * Exibe o formulario de edicao do evento
     *
     * @param evento
     */
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void editar(Evento evento){
        Evento e = dao.getEvento(evento);
        result.include("evento", e);
    }

    /**
     * Atualiza as informações de um evento
     *
     * @param evento
     */
    @Transacao
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void atualizar(Evento evento){
        dao.atualizar(evento);
        sessao.setAttribute("flash", "Evento atualizado com sucesso!");
        result.use(Results.logic()).redirectTo(EventoController.class).index(1);
    }

    /**
     * Exclui um evento
     * 
     * @param evento
     */
    @Transacao
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void excluir(Evento evento){
        dao.excluir(dao.getEvento(evento));
        sessao.setAttribute("flash", "Evento excluido com sucesso!");
        result.use(Results.logic()).redirectTo(EventoController.class).index(1);
    }

    /**
     * Visualiza o evento na area administrativa
     * 
     * @param evento
     */
    @Logado(tiposUsuario={TipoUsuario.ADMIN})
    public void ver(Evento evento){
        result.include("evento", dao.getEvento(evento));
    }

    /**
     * Visualizacao geral do evento
     *
     * @param evento
     */
    public void ver_evento(Evento evento){
        Evento e = dao.getEvento(evento);
        result.include("evento", e);
        result.include("pregadorList", dao.getPregadores(e));
    }    
}

Agora o Web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <!-- Configuração do VRaptor 3 -->
    <context-param>
        <param-name>br.com.caelum.vraptor.packages</param-name>
        <param-value>br.com.manaespiritual</param-value>
    </context-param>
    <filter>
        <filter-name>vraptor</filter-name>
        <filter-class>br.com.caelum.vraptor.VRaptor</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>vraptor</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>FORWARD</dispatcher>
        <dispatcher>REQUEST</dispatcher>
    </filter-mapping>

    <!-- Configuração para Sessions do Hibernate -->
    <context-param>
        <param-name>br.com.caelum.vraptor.provider</param-name>
        <param-value>br.com.caelum.vraptor.util.hibernate.HibernateCustomProvider</param-value>
    </context-param>

    <!-- Configuração do Tiles -->
    <servlet>
        <servlet-name>tiles</servlet-name>
        <servlet-class>org.apache.tiles.web.startup.TilesServlet</servlet-class>
        <init-param>
            <param-name>org.apache.tiles.impl.BasicTilesContainer.DEFINITIONS_CONFIG</param-name>
            <param-value>/WEB-INF/tiles-defs.xml</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <!-- Serve para nada pq o vraptor da conta -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/jsp/erro/404.jsp</location>
    </error-page>

</web-app>

Agora segue o hibernate.properties

hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class = com.mysql.jdbc.Driver
hibernate.connection.url = jdbc:mysql://127.0.0.1:3306/mana_espiritual
hibernate.connection.username = xyz
hibernate.connection.password = 1234
hibernate.connection.provider_class = org.hibernate.connection.C3P0ConnectionProvider
hibernate.show_sql = true

hibernate.c3p0.timeout = 100
hibernate.c3p0.idleTestPeriod = 30
hibernate.c3p0.minSize = 0
hibernate.c3p0.maxSize = 100
hibernate.c3p0.acquireIncrement = 1
hibernate.c3p0.maxStatements=100
hibernate.c3p0.maxStatementsPerConnection = 12
hibernate.c3p0.numHelperThreads=2

Por favor,

no que puderem ajudar, ficarei grato.

fiquem com Deus,

Jesus te ama. =)

5 Respostas

Topicos relacionados