Java tutorial
/** * Copyright 2010-2014 David L. Whitehurst * * 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.dlw.ai.blackboard.dao.hibernate; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.dlw.ai.blackboard.dao.GenericDao; import org.springframework.orm.ObjectRetrievalFailureException; import org.springframework.orm.hibernate3.HibernateTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Required; import org.hibernate.SessionFactory; import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; /** * This class serves as the Base class for all other DAOs - namely to hold * common CRUD methods that they might all use. You should only need to extend * this class when your require custom CRUD logic. * <p/> * <p>To register this class in your Spring context file, use the following XML. * <pre> * <bean id="fooDao" class="org.appfuse.dao.hibernate.GenericDaoHibernate"> * <constructor-arg value="org.appfuse.model.Foo"/> * <property name="sessionFactory" ref="sessionFactory"/> * </bean> * </pre> * * @author <a href="mailto:bwnoll@gmail.com">Bryan Noll</a> * @param <T> a type variable * @param <PK> the primary key for that type */ public class GenericDaoHibernate<T, PK extends Serializable> implements GenericDao<T, PK> { /** * Log variable for all child classes. Uses LogFactory.getLog(getClass()) from Commons Logging */ protected final Log log = LogFactory.getLog(getClass()); private Class<T> persistentClass; private HibernateTemplate hibernateTemplate; private SessionFactory sessionFactory; /** * Constructor that takes in a class to see which type of entity to persist. * Use this constructor when subclassing. * * @param persistentClass the class type you'd like to persist */ public GenericDaoHibernate(final Class<T> persistentClass) { this.persistentClass = persistentClass; } /** * Constructor that takes in a class and sessionFactory for easy creation of DAO. * * @param persistentClass the class type you'd like to persist * @param sessionFactory the pre-configured Hibernate SessionFactory */ public GenericDaoHibernate(final Class<T> persistentClass, SessionFactory sessionFactory) { this.persistentClass = persistentClass; this.sessionFactory = sessionFactory; this.hibernateTemplate = new HibernateTemplate(sessionFactory); } public HibernateTemplate getHibernateTemplate() { return this.hibernateTemplate; } public SessionFactory getSessionFactory() { return this.sessionFactory; } @Autowired @Required public void setSessionFactory(SessionFactory sessionFactory) { this.sessionFactory = sessionFactory; this.hibernateTemplate = new HibernateTemplate(sessionFactory); } /** * {@inheritDoc} */ @SuppressWarnings("unchecked") public List<T> getAll() { return hibernateTemplate.loadAll(this.persistentClass); } /** * {@inheritDoc} */ @SuppressWarnings({ "unchecked", "rawtypes" }) public List<T> getAllDistinct() { Collection result = new LinkedHashSet(getAll()); return new ArrayList(result); } /** * {@inheritDoc} */ @SuppressWarnings("unchecked") public T get(PK id) { T entity = (T) hibernateTemplate.get(this.persistentClass, id); if (entity == null) { log.warn("Uh oh, '" + this.persistentClass + "' object with id '" + id + "' not found..."); throw new ObjectRetrievalFailureException(this.persistentClass, id); } return entity; } /** * {@inheritDoc} */ @SuppressWarnings("unchecked") public boolean exists(PK id) { T entity = (T) hibernateTemplate.get(this.persistentClass, id); return entity != null; } /** * {@inheritDoc} */ @SuppressWarnings("unchecked") public T save(T object) { return (T) hibernateTemplate.merge(object); } /** * {@inheritDoc} */ public void remove(PK id) { hibernateTemplate.delete(this.get(id)); } /** * {@inheritDoc} */ @SuppressWarnings("unchecked") public List<T> findByNamedQuery(String queryName, Map<String, Object> queryParams) { String[] params = new String[queryParams.size()]; Object[] values = new Object[queryParams.size()]; int index = 0; for (String s : queryParams.keySet()) { params[index] = s; values[index++] = queryParams.get(s); } return hibernateTemplate.findByNamedQueryAndNamedParam(queryName, params, values); } }