com.evasion.dao.api.AbstractJPAGenericDAO Maven / Gradle / Ivy

Go to download
/*
 * Document confidentiel - Diffusion interdite 
 */
package com.evasion.dao.api;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.Query;

/**
 * Implementation Hibernate du GenericDAO.
 * 
 * @param 
 *            le type persistent
 * @param 
 *            le type de la clef primaire de l'objet persistent
 */
public abstract class AbstractJPAGenericDAO
        implements GenericDAO {

    /** LOGGER */
    public static final Logger LOGGER = Logger.getLogger(AbstractJPAGenericDAO.class.getName());

    private EntityManager em;

    /** persistentClass */
    private final Class persistentClass;

    /**
     * Constructeur.
     * @param  namePU
     */
    @SuppressWarnings("unchecked")
    public AbstractJPAGenericDAO() {
        super();
        final ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
        this.persistentClass = (Class) type.getActualTypeArguments()[0];
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void clear() {
        LOGGER.log(Level.FINE, "Nettoyage (clear) de la session.");
        this.em.clear();
    }

    /**
     * {@inheritDoc}
     */
    @SuppressWarnings("unchecked")
    @Override
    public List findAll() {
        Query query = this.em.createQuery("SELECT e FROM " + this.persistentClass.getSimpleName() + " e");
        final List result = (List) query.getResultList();
        LOGGER.log(Level.FINE,
                "La recherche de toute les entités de type {} a retourné {} résultats",
                 new Object[]{this.persistentClass, result.size()});
        return result;
    }

    /**
     * {@inheritDoc}
     */
    @SuppressWarnings("unchecked")
    public T findById(final PK id) {
        final T result = (T) this.em.find(this.persistentClass,
                id);
        LOGGER.log(Level.FINE,
                "La recherche de l'entite de type {} avec l'id {} a retourn� {}",
                new Object[]{this.persistentClass, id, result});
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public void flush() {
        LOGGER.log(Level.FINE, "Synchronisation (flush) de la session counrante.");
        this.em.flush();
    }

    /**
     * {@inheritDoc}
     */
    @SuppressWarnings("unchecked")
    public T getReference(final PK id) {
        LOGGER.log(Level.FINE,
                "R�cup�ration d'une r�f�rence � l'entite de type {} avec l'id {}",
                new Object[]{this.persistentClass, id});
        return (T) this.em.getReference(persistentClass, id);
    }

    /**
     * {@inheritDoc}
     */
    @SuppressWarnings("unchecked")
    public T merge(final T entity) {
        LOGGER.log(Level.FINE,"Merging entity {}", new Object[]{entity});
        return (T) em.merge(entity);
    }

    /**
     * {@inheritDoc}
     */
    public void persist(final T entity) {
        LOGGER.log(Level.FINE,"Persisting entity {}", entity);
        this.em.persist(entity);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void remove(T entity) {
        LOGGER.log(Level.FINE,"Suppression de l'entite {}", entity);
        this.em.remove(entity);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public EntityManager getEntityManager() {
        return em;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setEntityManager(EntityManager em) {
        this.em = em;
    }
}