org.viafirma.persistencia.dao.GenericEjb3Dao.java Source code

Introduction

Here is the source code for org.viafirma.persistencia.dao.GenericEjb3Dao.java

Source

/*
 * GenericEjb3Dao.java
 *
 * Created on 12 de octubre de 2006, 15:06
 *
 *
 * Copyright 2006-2007 Felix Garcia Borrego (borrego at gmail.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package org.viafirma.persistencia.dao;

import java.util.Collection;
import java.util.List;
import java.util.logging.Logger;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceException;
import javax.persistence.Query;

import org.apache.commons.lang.NotImplementedException;
import org.viafirma.excepciones.CodigoError;
import org.viafirma.persistencia.excepciones.ExcepcionNoCreado;
import org.viafirma.persistencia.excepciones.ExcepcionNoEncontrado;
import org.viafirma.persistencia.vo.Entidad;

/**
 * Implementacin generica de la funcionalidad que debe ofrecer Toda
 * implementacin Dao que se base en Ejb3.0 Esta es la plantilla que deberan
 * extender/implementar todos los Ejb3Dao
 * 
 */
@Deprecated
public class GenericEjb3Dao<T extends Entidad, ID extends Long> implements GenericDao<T, ID> {
    Logger log = Logger.getLogger(GenericDao.class.getName());

    /**
     * Factoria para obtener manejadores de entidades EJB 3.0
     */
    private EntityManagerFactory emf;

    /**
     * Clase sobre la que esta trabajando el Dao
     */
    protected Class<T> persistentClass;

    /**
     * Retorna un manejador para ser usado El EntityManager es una session que
     * debera de ser cerrada cuando la operacin se de por terminada
     */
    protected EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    protected GenericEjb3Dao(Class<T> persistentClass, EntityManagerFactory emf) {
        this.emf = emf;
        this.persistentClass = persistentClass;
    }

    /**
     * Persiste la entidad indicada
     * @throws ExcepcionNoCreado 
     */
    public T create(T entidad) throws ExcepcionNoCreado {
        EntityManager manager = getEntityManager();
        try {
            manager.getTransaction().begin();
            log.config("Creando " + entidad);
            manager.persist(entidad);
            manager.getTransaction().commit();
            return entidad;
        } catch (PersistenceException e) {
            manager.getTransaction().rollback();
            log.severe("Error al crear entidad" + e.getMessage());
            throw new ExcepcionNoCreado(e.getMessage());
        } finally {
            manager.close();
        }
    }

    /**
     * Elimina la entidad indicada
     * @throws ExcepcionNoCreado 
     */
    public void delete(ID id) throws ExcepcionNoCreado {
        log.finest("Eliminando " + persistentClass + " con identificador " + id);
        EntityManager manager = getEntityManager();
        T entidad = null;
        entidad = manager.find(persistentClass, id);
        if (entidad == null) {
            throw new ExcepcionNoCreado("No se puede eliminar " + id);
        }

        try {

            manager.getTransaction().begin();
            manager.remove(entidad);
            manager.getTransaction().commit();
        } catch (Exception e) {
            log.severe("No se puede eliminar " + entidad + " " + e.getMessage());
            manager.getTransaction().rollback();
        } finally {
            manager.close();
        }
    }

    /**
     * Actualiza la entidad indicada
     */
    public void update(T entidad) {
    }

    public Collection<T> findAll() {
        EntityManager manager = getEntityManager();
        try {
            Query query = manager.createQuery("SELECT e from " + persistentClass.getSimpleName() + " e");
            return (Collection<T>) query.getResultList();
        } finally {
            manager.close();
        }
    }

    public List<T> findByTemplate(T template) {
        throw new NotImplementedException();
    }

    /**
     * Recupera el objeto con el identificador indicado
     * @throws ExcepcionNoEncontrado Cuando no se puede recuperar la indentidad con el identificador indicado
     */
    public T findById(ID id) throws ExcepcionNoEncontrado {
        EntityManager manager = getEntityManager();
        try {
            T entidad = manager.find(persistentClass, id);
            if (entidad == null) {
                throw new ExcepcionNoEncontrado(CodigoError.ERROR_IDENTIFICADOR_NO_ENCONTRADO);
            }
            return entidad;
        } finally {
            manager.close();
        }
    }

}