GenericDAOImpl.java

// Copyright 2007-2008 Thiago H. de Paula Figueiredo
//
// 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 br.com.arsmachina.dao.hibernate;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.hibernate.criterion.Example;
import org.hibernate.metadata.ClassMetadata;

import br.com.arsmachina.dao.DAO;
import br.com.arsmachina.dao.SortCriterion;

/**
 * {@link AbstractDAO} implementation using Hibernate. All methods use {@link #getSession()} to get
 * a {@link Session}. All methods delegate its calls to an internal {@link ReadableDAOImpl} or
 * {@link WriteableDAOImpl} instance.
 * 
 * @author Thiago H. de Paula Figueiredo
 * @param <T> the entity class related to this DAO.
 * @param <K> the type of the field that represents the entity class' primary key.
 */
public class GenericDAOImpl<T, K extends Serializable> implements DAO<T, K> {

	final private InternalReadableDAOImpl readableDAO;

	final private InternalWriteableDAOImpl writeableDAO;

	/**
	 * Single public constructor.
	 * 
	 * @param sessionFactory a {@link SessionFactory}. It cannot be null.
	 */
	@SuppressWarnings("unchecked")
	public GenericDAOImpl(SessionFactory sessionFactory) {

		if (sessionFactory == null) {
			throw new IllegalArgumentException("Parameter sessionFactory cannot be null");
		}

		final Type genericSuperclass = getClass().getGenericSuperclass();
		final ParameterizedType parameterizedType = ((ParameterizedType) genericSuperclass);
		Class clasz = (Class<T>) parameterizedType.getActualTypeArguments()[0];

		readableDAO = new InternalReadableDAOImpl(clasz, sessionFactory);
		writeableDAO = new InternalWriteableDAOImpl(clasz, sessionFactory);

	}

	/**
	 * Constructor made specifically for {@link ConcreteDAOImpl}. It shouldn't be used in
	 * any other class. 
	 * 
	 * @param clasz the entity class. It cannot be null.
	 * @param sessionFactory a {@link SessionFactory}. It cannot be null.
	 */
	GenericDAOImpl(Class<T> clasz, SessionFactory sessionFactory) {
		
		if (clasz == null) {
			throw new IllegalArgumentException("Parameter clasz cannot be null");
		}
		
		if (sessionFactory == null) {
			throw new IllegalArgumentException("Parameter sessionFactory cannot be null");
		}
		
		readableDAO = new InternalReadableDAOImpl(clasz, sessionFactory);
		writeableDAO = new InternalWriteableDAOImpl(clasz, sessionFactory);
		
	}

	public int countAll() {
		return readableDAO.countAll();
	}

	public List<T> findAll() {
		return readableDAO.findAll();
	}

	public List<T> findAll(int firstResult, int maximumResults, SortCriterion... sortingConstraints) {
		return readableDAO.findAll(firstResult, maximumResults, sortingConstraints);
	}

	public List<T> findByExample(T example) {
		return readableDAO.findByExample(example);
	}

	public T findById(K id) {
		return readableDAO.findById(id);
	}

	public List<T> findByIds(K... ids) {
		return readableDAO.findByIds(ids);
	}

	public void refresh(T object) {
		readableDAO.refresh(object);
	}

	public void delete(T object) {
		writeableDAO.delete(object);
	}

	public void delete(K id) {
		writeableDAO.delete(id);
	}

	public void evict(T object) {
		writeableDAO.evict(object);
	}

	public boolean isPersistent(T object) {
		return writeableDAO.isPersistent(object);
	}

	public void save(T object) {
		writeableDAO.save(object);
	}

	public T update(T object) {
		return writeableDAO.update(object);
	}

	public T reattach(T object) {
		return readableDAO.reattach(object);
	}

	public SortCriterion[] getDefaultSortCriteria() {
		return readableDAO.getDefaultSortCriteria();
	}

	/**
	 * Invokes <code>readableDAO.addSortCriteria()<code>.
	 * @param criteria
	 * @see br.com.arsmachina.dao.hibernate.ReadableDAOImpl#addSortCriteria(org.hibernate.Criteria)
	 */
	protected void addSortCriteria(Criteria criteria) {
		readableDAO.addSortCriteria(criteria);
	}
	
	
	
	/**
	 * Invokes <code>delegate.addSortCriteria()<code>.
	 * @param criteria
	 * @param sortCriteria
	 * @see br.com.arsmachina.dao.hibernate.ReadableDAOImpl#addSortCriteria(org.hibernate.Criteria, br.com.arsmachina.dao.SortCriterion[])
	 */
	public final void addSortCriteria(Criteria criteria, SortCriterion... sortCriteria) {
		readableDAO.addSortCriteria(criteria, sortCriteria);
	}

	/**
	 * Invokes <code>readableDAO.createCriteria()<code>.
	 * @return
	 * @see br.com.arsmachina.dao.hibernate.ReadableDAOImpl#createCriteria()
	 */
	protected Criteria createCriteria() {
		return readableDAO.createCriteria();
	}
	
	

	/**
	 * Invokes <code>delegate.createCriteria()<code>.
	 * @param sortCriteria
	 * @return
	 * @see br.com.arsmachina.dao.hibernate.ReadableDAOImpl#createCriteria(br.com.arsmachina.dao.SortCriterion[])
	 */
	protected Criteria createCriteria(SortCriterion... sortCriteria) {
		return readableDAO.createCriteria(sortCriteria);
	}
	
	

	/**
	 * Invokes <code>delegate.createCriteria()<code>.
	 * @param firstIndex
	 * @param maximumResults
	 * @param sortCriteria
	 * @return
	 * @see br.com.arsmachina.dao.hibernate.ReadableDAOImpl#createCriteria(int, int, br.com.arsmachina.dao.SortCriterion[])
	 */
	public Criteria createCriteria(int firstIndex, int maximumResults,
			SortCriterion... sortCriteria) {
		return readableDAO.createCriteria(firstIndex, maximumResults, sortCriteria);
	}

	/**
	 * Invokes <code>readableDAO.createExample()<code>.
	 * @param entity
	 * @return
	 * @see br.com.arsmachina.dao.hibernate.ReadableDAOImpl#createExample(java.lang.Object)
	 */
	protected Example createExample(T entity) {
		return readableDAO.createExample(entity);
	}

	/**
	 * Returns the entity class handled by this DAO.
	 * 
	 * @return a {@link Class<T>}.
	 */
	protected final Class<T> getEntityClass() {
		return readableDAO.getEntityClass();
	}

	/**
	 * Returns a {@link Session}. This implementation returns
	 * {@link SessionFactory#getCurrentSession()} and can be overriden if needed.
	 * 
	 * @return a {@link Session}.
	 */
	protected Session getSession() {
		return getSessionFactory().getCurrentSession();
	}

	/**
	 * Returns this DAO's {@link SessionFactory}.
	 * 
	 * @return a {@link SessionFactory}.
	 */
	protected final SessionFactory getSessionFactory() {
		return readableDAO.getSessionFactory();
	}

	/**
	 * Returns the {@link ClassMetadata} for the corresponding entity class.
	 * 
	 * @return a {@link ClassMetadata}.
	 */
	final protected ClassMetadata getClassMetadata() {
		return readableDAO.getClassMetadata();
	}

	/**
	 * Returns the name of the property.
	 * 
	 * @return a {@link String}.
	 */
	public String getPrimaryKeyPropertyName() {
		return readableDAO.getPrimaryKeyPropertyName();
	}

	/**
	 * Concrete {@link ReadableDAOImpl} subclass.
	 * 
	 * @author Thiago H. de Paula Figueiredo
	 * @param <T>
	 * @param <K>
	 */
	private final class InternalReadableDAOImpl extends ReadableDAOImpl<T, K> {

		public InternalReadableDAOImpl(Class<T> clasz, SessionFactory sessionFactory) {
			super(clasz, sessionFactory);
		}

	}

	/**
	 * Concrete {@link WriteableDAOImpl} subclass.
	 * 
	 * @author Thiago H. de Paula Figueiredo
	 * @param <T>
	 * @param <K>
	 */
	private final class InternalWriteableDAOImpl extends WriteableDAOImpl<T, K> {

		public InternalWriteableDAOImpl(Class<T> clasz, SessionFactory sessionFactory) {
			super(clasz, sessionFactory);
		}

	}

}