JFox Service-Oriented Application Framework

Clover coverage report - JFox Service-Oriented Application Framework - 1.0-M3
Coverage timestamp: 星期日五月 22 2005 15:41:44 CST
FRAMES NO FRAMES
file stats:	LOC:	830		Methods:	29
	NCLOC:	467		Classes:	1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
Source file
Conditionals
Statements
Methods
TOTAL
AbstractHibernateDAO.java
8.3%
13.8%
8.8%
 /**
  * @(#)AbstractHibernateDAO.java
  * 
  * JFoxSOAF, Service-Oriented Application Framework
  * 
  * Copyright(c) JFoxSOAF Team
  * 
  * Licensed under the GNU LGPL, Version 2.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.gnu.org/copyleft/lesser.html
  * 
  * 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. 
  * 
  * For more information, please visit:
  * http://www.jfox.cn/confluence/display/JFoxSOAF/Home
  * http://www.huihoo.org/jfox/jfoxsoaf
  */
 
 package org.huihoo.jfox.soaf.services.dao;
 
 import java.io.Serializable;
 import java.util.Iterator;
 import java.util.List;
 
 import net.sf.hibernate.HibernateException;
 import net.sf.hibernate.LockMode;
 import net.sf.hibernate.Session;
 import net.sf.hibernate.type.Type;
 
 import org.huihoo.jfox.soaf.container.ServiceFactory;
 import org.huihoo.jfox.soaf.exception.DAOException;
 import org.huihoo.jfox.soaf.services.persistence.HibernateService;
 
 /**
  * <p>
  * Abstract Hibernate DAO Template.
  * </p>
  * 
  * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
  * @version $Revision: 1.1 $ $Date: 2005/05/22 06:49:10 $
  * @version Revision: 1.0
  */
 
 public abstract class AbstractHibernateDAO extends AbstractDAO {
 
     private HibernateService hibernateService;
 
     /**
      * Default Construector.
      */
     public AbstractHibernateDAO() {
         hibernateService = (HibernateService) ServiceFactory.getInstance()
                 .getService(HibernateService.class);
     }
 
     /**
      * Check if this instance is associated with this Session
      * 
      * @param object an instance of a persistent class
      * @return true if the given instance is associated with this Session
      * @throws HibernateException
      * @throws DAOException
      */
     public boolean contains(Object object) throws HibernateException,
             DAOException {
         boolean isContains = false;
         Session session;
         try {
             session = hibernateService.openSession();
             session.contains(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return isContains;
     }
 
     /**
      * Remove a persistent instance from the datastore.
      * 
      * @param object
      * @throws HibernateException
      */
     public void delete(Object object) throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.delete(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Remove a persistent instance from the datastore with lock mode.
      * 
      * @param object
      * @param lockMode
      * @throws HibernateException
      */
     public void delete(Object object, LockMode lockMode)
             throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.lock(object, lockMode);
             session.delete(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new HibernateException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Delete all objects returned by the query. Return the number of objects
      * deleted.
      * 
      * @param query
      * @return the number of instances deleted
      * @throws HibernateException
      * @throws DAOException
      */
     public int delete(String query) throws HibernateException, DAOException {
         int instancesCount = 0;
         Session session;
         try {
             session = hibernateService.openSession();
             instancesCount = session.delete(query);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return instancesCount;
     }
 
     /**
      * Delete all objects returned by the query. Return the number of objects
      * deleted.
      * 
      * @param query
      * @return the number of instances deleted
      * @throws HibernateException
      * @throws DAOException
      */
     public int delete(String query, Object value, Type type)
             throws HibernateException, DAOException {
         int instancesCount = 0;
         Session session;
         try {
             session = hibernateService.openSession();
             instancesCount = session.delete(query, value, type);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return instancesCount;
     }
 
     /**
      * Delete all objects returned by the query. Return the number of objects
      * deleted.
      * 
      * @param query
      * @return the number of instances deleted
      * @throws HibernateException
      * @throws DAOException
      */
     public int delete(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException {
         int instancesCount = 0;
         Session session;
         try {
             session = hibernateService.openSession();
             instancesCount = session.delete(query, values, types);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return instancesCount;
     }
 
     /**
      * Remove this instance from the session cache. Changes to the instance will
      * not be synchronized with the database. This operation cascades to
      * associated instances if the association is mapped with cascade="all" or
      * cascade="all-delete-orphan".
      * 
      * @param object object - a persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public void evict(Object object) throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.evict(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Execute a query.
      * 
      * @param query a query expressed in Hibernate's query language
      * @return a distinct list of instances (or arrays of instances)
      * @throws HibernateException
      * @throws DAOException
      */
     public List find(String query) throws HibernateException, DAOException {
         List list;
         Session session;
         try {
             session = hibernateService.openSession();
             list = session.find(query);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return list;
     }
 
     /**
      * Execute a query with bind parameters. Bind a value to a "?" parameter in
      * the query string.
      * 
      * @param query
      * @param value
      * @param type
      * @return a distinct list of instances (or arrays of instances)
      * @throws HibernateException
      * @throws DAOException
      */
     public List find(String query, Object value, Type type)
             throws HibernateException, DAOException {
         List list;
         Session session;
         try {
             session = hibernateService.openSession();
             list = session.find(query, value, type);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return list;
     }
 
     /**
      * Execute a query with bind parameters. Binding an array of values to "?"
      * parameters in the query string.
      * 
      * @param query
      * @param values
      * @param types
      * @return a distinct list of instances
      * @throws HibernateException
      * @throws DAOException
      */
     public List find(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException {
         List list;
         Session session;
         try {
             session = hibernateService.openSession();
             list = session.find(query, values, types);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return list;
     }
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, or null if there is no such persistent instance.
      * 
      * @param clazz
      * @param id
      * @return a persistent instance or null
      * @throws HibernateException
      * @throws DAOException
      */
     public Object get(Class clazz, Serializable id) throws HibernateException,
             DAOException {
         Object object;
         Session session;
         try {
             session = hibernateService.openSession();
             object = session.get(clazz, id);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return object;
     }
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, or null if there is no such persistent instance. Obtain the
      * specified lock mode if the instance exists.
      * 
      * @param clazz
      * @param id
      * @param lockMode
      * @return a persistent instance or null
      * @throws HibernateException
      * @throws DAOException
      */
     public Object get(Class clazz, Serializable id, LockMode lockMode)
             throws HibernateException, DAOException {
         Object object;
         Session session;
         try {
             session = hibernateService.openSession();
             object = session.get(clazz, id, lockMode);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return object;
     }
 
     /**
      * Execute a query and return the results in an iterator. If the query has
      * multiple return values, values will be returned in an array of type
      * Object[]. Entities returned as results are initialized on demand. The
      * first SQL query returns identifiers only. So iterate() is usually a less
      * efficient way to retrieve objects than find().
      * 
      * @param query
      * @return an iterator
      * @throws HibernateException
      * @throws DAOException
      */
     public Iterator iterate(String query) throws HibernateException,
             DAOException {
         Iterator iter;
         Session session;
         try {
             session = hibernateService.openSession();
             iter = session.iterate(query);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return iter;
     }
 
     /**
      * Execute a query and return the results in an iterator. Write the given
      * value to "?" in the query string. If the query has multiple return
      * values, values will be returned in an array of type Object[]. Entities
      * returned as results are initialized on demand. The first SQL query
      * returns identifiers only. So iterate() is usually a less efficient way to
      * retrieve objects than find().
      * 
      * @param query - the query string
      * @param value - a value to be witten to a "?" placeholder in the query
      *            string
      * @param type - the hibernate type of value
      * @return an iterator
      * @throws HibernateException
      * @throws DAOException
      */
     public Iterator iterate(String query, Object value, Type type)
             throws HibernateException, DAOException {
         Iterator iter;
         Session session;
         try {
             session = hibernateService.openSession();
             iter = session.iterate(query, value, type);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return iter;
     }
 
     /**
      * Execute a query and return the results in an iterator. Write the given
      * values to "?" in the query string. If the query has multiple return
      * values, values will be returned in an array of type Object[]. Entities
      * returned as results are initialized on demand. The first SQL query
      * returns identifiers only. So iterate() is usually a less efficient way to
      * retrieve objects than find().
      * 
      * @param query
      * @param values
      * @param types
      * @return
      * @throws HibernateException
      * @throws DAOException
      */
     public Iterator iterate(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException {
         Iterator iter;
         Session session;
         try {
             session = hibernateService.openSession();
             iter = session.iterate(query, values, types);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return iter;
     }
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, assuming that the instance exists. You should not use this
      * method to determine if an instance exists (use find() instead). Use this
      * only to retrieve an instance that you assume exists, where non-existence
      * would be an actual error.
      * 
      * @param clazz
      * @param id
      * @return the persistent instance or proxy
      * @throws HibernateException
      * @throws DAOException
      */
     public Object load(Class clazz, Serializable id) throws HibernateException,
             DAOException {
         Object object;
         Session session;
         try {
             session = hibernateService.openSession();
             object = session.load(clazz, id);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return object;
     }
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, obtaining the specified lock mode, assuming the instance
      * exists.
      * 
      * @param clazz
      * @param id
      * @param lockMode
      * @return the persistent instance or proxy
      * @throws HibernateException
      * @throws DAOException
      */
     public Object load(Class clazz, Serializable id, LockMode lockMode)
             throws HibernateException, DAOException {
         Object object;
         Session session;
         try {
             session = hibernateService.openSession();
             object = session.load(clazz, id, lockMode);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return object;
     }
 
     /**
      * Read the persistent state associated with the given identifier into the
      * given transient instance.
      * 
      * @param object
      * @param id
      * @throws HibernateException
      * @throws DAOException
      */
     public void load(Object object, Serializable id) throws HibernateException,
             DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.load(object, id);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Obtain the specified lock level upon the given object.
      * 
      * @param object - a persistent or transient instance
      * @param lockMode - the lock level
      * @throws HibernateException
      * @throws DAOException
      */
     public void lock(Object object, LockMode lockMode)
             throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.lock(object, lockMode);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Update the persistent instance with the identifier of the given transient
      * instance. If there is a persistent instance with the same identifier, an
      * exception is thrown. If the given transient instance has a null
      * identifier, an exception will be thrown.
      * 
      * @param object - a transient instance containing updated state
      * @throws HibernateException
      * @throws DAOException
      */
     public void update(Object object) throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.update(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Update the persistent state associated with the given identifier. An
      * exception is thrown if there is a persistent instance with the same
      * identifier in the current session.
      * 
      * @param object - a transient instance containing updated state
      * @param id - identifier of persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public void update(Object object, Serializable id)
             throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.update(object, id);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Copy the state of the given object onto the persistent object with the
      * same identifier. If there is no persistent instance currently associated
      * with the session, it will be loaded. Return the persistent instance. If
      * the given instance is unsaved or does not exist in the database, save it
      * and return it as a newly persistent instance. Otherwise, the given
      * instance does not become associated with the session.
      * 
      * @param object
      * @return an updated persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public Object saveOrUpdateCopy(Object object) throws HibernateException,
             DAOException {
         Session session;
         Object obj;
         try {
             session = hibernateService.openSession();
             obj = session.saveOrUpdateCopy(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return obj;
     }
 
     /**
      * Copy the state of the given object onto the persistent object with the
      * given identifier. If there is no persistent instance currently associated
      * with the session, it will be loaded. Return the persistent instance. If
      * there is no database row with the given identifier, save the given
      * instance and return it as a newly persistent instance. Otherwise, the
      * given instance does not become associated with the session.
      * 
      * @param object - a persistent or transient instance with state to be
      *            copied
      * @param id - the identifier of the instance to copy to
      * @return an updated persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public Object saveOrUpdateCopy(Object object, Serializable id)
             throws HibernateException, DAOException {
         Session session;
         Object obj;
         try {
             session = hibernateService.openSession();
             obj = session.saveOrUpdateCopy(object, id);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return obj;
     }
 
     /**
      * Re-read the state of the given instance from the underlying database. It
      * is inadvisable to use this to implement long-running sessions that span
      * many business tasks. This method is, however, useful in certain special
      * circumstances.
      * 
      * @param object a persistent or transient instance
      * @throws HibernateException
      * @throws DAOException
      */
     public void refresh(Object object) throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.refresh(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Re-read the state of the given instance from the underlying database,
      * with the given LockMode. It is inadvisable to use this to implement
      * long-running sessions that span many business tasks. This method is,
      * however, useful in certain special circumstances.
      * 
      * @param object a persistent or transient instance
      * @param lockMode the lock mode to use
      * @throws HibernateException
      * @throws DAOException
      */
     public void refresh(Object object, LockMode lockMode)
             throws HibernateException, DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.refresh(object, lockMode);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Persist the given transient instance, first assigning a generated
      * identifier.
      * 
      * @param object - - a transient instance of a persistent class
      * @return the generated identifier
      * @throws HibernateException
      */
     public Serializable save(Object object) throws HibernateException,
             DAOException {
         Serializable seriaObj;
         Session session;
         try {
             session = hibernateService.openSession();
             seriaObj = session.save(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
         return seriaObj;
     }
 
     /**
      * Persist the given transient instance, using the given identifier.
      * 
      * @param object - a transient instance of a persistent class
      * @param id - an unused valid identifier
      * @throws HibernateException
      * @throws DAOException
      */
     public void save(Object object, Serializable id) throws HibernateException,
             DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.save(object, id);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             System.out.println("save close session");
             session = null;
             hibernateService.closeSession();
         }
     }
 
     /**
      * Either save() or update() the given instance, depending upon the value of
      * its identifier property. By default the instance is always saved. This
      * behaviour may be adjusted by specifying an unsaved-value attribute of the
      * identifier property mapping.
      * 
      * @param object - a transient instance containing new or updated state
      * @throws HibernateException
      * @throws DAOException
      */
     public void saveOrUpdate(Object object) throws HibernateException,
             DAOException {
         Session session;
         try {
             session = hibernateService.openSession();
             session.saveOrUpdate(object);
             hibernateService.commit();
         } catch (Exception e) {
             hibernateService.rollback();
             throw new DAOException(e);
         } finally {
             session = null;
             hibernateService.closeSession();
         }
     }
 
 }