Java tutorial
package us.mn.state.health.lims.common.daoimpl; /** * The contents of this file are subject to the Mozilla Public License * Version 1.1 (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.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the * License for the specific language governing rights and limitations under * the License. * * The Original Code is OpenELIS code. * * Copyright (C) The Minnesota Department of Health. All Rights Reserved. */ import java.io.Serializable; import java.util.List; import org.apache.commons.beanutils.PropertyUtils; import org.hibernate.criterion.Example; import us.mn.state.health.lims.audittrail.dao.AuditTrailDAO; import us.mn.state.health.lims.audittrail.daoimpl.AuditTrailDAOImpl; import us.mn.state.health.lims.common.action.IActionConstants; import us.mn.state.health.lims.common.dao.BaseDAO; import us.mn.state.health.lims.common.dao.GenericDAO; import us.mn.state.health.lims.common.exception.LIMSRuntimeException; import us.mn.state.health.lims.common.log.LogEvent; import us.mn.state.health.lims.common.valueholder.SimpleBaseEntity; import us.mn.state.health.lims.hibernate.HibernateUtil; // actually BaseDOAImpl assumes keys can be represented as Strings public abstract class GenericDAOImpl<Key extends Serializable, Entity extends SimpleBaseEntity<Key>> extends BaseDAOImpl implements BaseDAO, GenericDAO<Key, Entity> { /** * This is the class of the rows being saved in the database */ protected Class<Entity> entityClass; /** * this is the (simple) name of the rows to persist. */ protected String entityName; /** * The name of the table in the database (with underscores, not camel case). Actually this is the name as is it spelled in the reference_tables DB table activity log. * In this table older tables from the original OpenElis (MN) are capitalized while newer ones are not. Both have underscores in their names. */ protected String tableName; /** * This is basic (simple) name of the DAO class which is used in logging/audit messages. */ protected String daoName; /** * Given classes to save and the name of the table (for logging and audit records). * @param entityClass objects of the rows to save using this DAO * @param tableName table name in DB. There is probably aw way to ask hibernate for this answer, but we can leave this for now. */ public GenericDAOImpl(Class<Entity> entityClass, String tableName) { this.entityClass = entityClass; this.tableName = tableName; this.daoName = this.getClass().getSimpleName(); this.entityName = entityClass.getSimpleName(); } public void delete(List<Entity> entities) throws LIMSRuntimeException { throw new UnsupportedOperationException(daoName + ".delete(list) not supported"); // If you want to be able to delete entites override this method and cCall the other delete method with delete(entities, new MyEntity()); // delete(entities, new ObservationHistory()); } /*** * Delete all the entities in the list and record the auditing information. * @param entities all the entities to delete. * @param oneNew - pass a new empty object for use in the history audit logging processing */ public void delete(List<Entity> entities, Entity oneNewData) throws LIMSRuntimeException { try { AuditTrailDAO auditDAO = new AuditTrailDAOImpl(); for (Entity data : entities) { Entity oldData = readEntity(data.getId()); String sysUserId = data.getSysUserId(); String event = IActionConstants.AUDIT_TRAIL_DELETE; auditDAO.saveHistory(oneNewData, oldData, sysUserId, event, tableName); } for (Entity data : entities) { data = readEntity(data.getId()); HibernateUtil.getSession().delete(data); flushAndClear(); } } catch (Exception e) { throw createAndLogException("deleteData()", e); } } /** * Just because I hate to say the same thing many times. */ protected void flushAndClear() { HibernateUtil.getSession().flush(); HibernateUtil.getSession().clear(); } /** * Read all entities from the database. */ @SuppressWarnings("unchecked") public List<Entity> getAll() throws LIMSRuntimeException { List<Entity> entities; try { String sql = "from " + this.entityName; org.hibernate.Query query = HibernateUtil.getSession().createQuery(sql); entities = query.list(); flushAndClear(); } catch (Exception e) { throw createAndLogException("getAll()", e); } return entities; } /** * Read all entities from the database sorted by an appropriate column */ @SuppressWarnings("unchecked") public List<Entity> getAllOrderBy(String columnName) throws LIMSRuntimeException { List<Entity> entities; try { String sql = "from " + this.entityName + " ORDER BY " + columnName; org.hibernate.Query query = HibernateUtil.getSession().createQuery(sql); entities = query.list(); flushAndClear(); } catch (Exception e) { throw createAndLogException("getAllOrderBy()", e); } return entities; } /** * Find one entity given an ID */ @SuppressWarnings("unchecked") public Entity getById(Entity entity) throws LIMSRuntimeException { try { Entity re = (Entity) HibernateUtil.getSession().get(entityClass, entity.getId()); flushAndClear(); return re; } catch (Exception e) { throw createAndLogException("getEntityById()", e); } } /*** * get one entity, by the ID contained in the given Entity, filling in the given entity with the values. */ public void getData(Entity entity) throws LIMSRuntimeException { Entity tmpEntity = readEntity(entity.getId()); // PAH reused readEntity instead of doing the code again. if (tmpEntity != null) { try { PropertyUtils.copyProperties(entity, tmpEntity); } catch (Exception e) { throw createAndLogException("getData()", e); } } else { entity.setId(null); } } /*** * save the given entity into the database */ @SuppressWarnings("unchecked") public boolean insertData(Entity entity) throws LIMSRuntimeException { try { Key id = (Key) HibernateUtil.getSession().save(entity); entity.setId(id); AuditTrailDAO auditDAO = new AuditTrailDAOImpl(); String sysUserId = entity.getSysUserId(); auditDAO.saveNewHistory(entity, sysUserId, tableName); flushAndClear(); } catch (Exception e) { throw createAndLogException("insertData()", e); } return true; } /*** * update the given existing entity in the database */ public void updateData(Entity entity) throws LIMSRuntimeException { Entity oldData = readEntity(entity.getId()); Entity newData = entity; //add to audit trail try { AuditTrailDAO auditDAO = new AuditTrailDAOImpl(); String sysUserId = entity.getSysUserId(); String event = IActionConstants.AUDIT_TRAIL_UPDATE; auditDAO.saveHistory(newData, oldData, sysUserId, event, tableName); HibernateUtil.getSession().merge(entity); flushAndClear(); HibernateUtil.getSession().evict(entity); HibernateUtil.getSession().refresh(entity); } catch (Exception e) { throw createAndLogException("updateData()", e); } } /** * Read one entity */ @SuppressWarnings("unchecked") public Entity readEntity(Key id) throws LIMSRuntimeException { Entity data = null; try { data = (Entity) HibernateUtil.getSession().get(entityClass, id); flushAndClear(); } catch (Exception e) { throw createAndLogException("readEntity()", e); } return data; } /** * Read a list of entities which match those fields(members) in the entity which are filled in. */ @SuppressWarnings("unchecked") public List<Entity> readByExample(Entity entity) throws LIMSRuntimeException { List<Entity> results; try { results = (List<Entity>) HibernateUtil.getSession().createCriteria(entityClass) .add(Example.create(entity)).list(); } catch (Exception e) { throw createAndLogException("readByExample()", e); } return results; } /** * Given a bit of HQL and few other bits find a bunch of the right types of Entities * @param the whole HQL with one or more params in the some statement " id = param1 AND title = :param2" etc. in it. * @param fieldValue one value to match with * @param orderByClause more HQL to finish the entire statement (aka the order by clause). * @return a list of * @throws LIMSRuntimeException */ protected List<Entity> readByHQL(String hql, String[] fieldValues) throws LIMSRuntimeException { try { org.hibernate.Query query = HibernateUtil.getSession().createQuery(hql); for (int i = 0; i <= fieldValues.length; i++) { query.setParameter("param1", fieldValues[i]); } @SuppressWarnings("unchecked") List<Entity> list = query.list(); HibernateUtil.getSession().flush(); HibernateUtil.getSession().clear(); return list; } catch (Exception e) { throw createAndLogException("findByHQL( \"" + hql + "\")", e); } } /** * Utility routine for (1) logging an error and (2) creating a new RuntimeException * @param methodName * @param e * @return new RuntimeException */ protected LIMSRuntimeException createAndLogException(String methodName, Exception e) { LogEvent.logError(daoName, methodName, e.toString()); // PAHill original code said " Error in " + entityName , but that isn't actually correct. return new LIMSRuntimeException("Error in " + daoName + " " + methodName, e); } }