JFox Service-Oriented Application Framework

Clover coverage report - JFox Service-Oriented Application Framework - 1.0

Coverage timestamp: 星期一八月 21 2006 22:56:01 CST

FRAMES NO FRAMES

file stats:	LOC:	472		Methods:	0
	NCLOC:	63		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

HibernateService.java

 /**
  * @(#)HibernateService.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.persistence;
 
 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.SessionFactory;
 import net.sf.hibernate.type.Type;
 
 import org.huihoo.jfox.soaf.exception.DAOException;
 
 /**
  * <p>
  * Hibernate persistence service, Wrapper service for hibernate.
  * </p>
  * 
  * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
  * @version $Revision: 1.6 $ $Date: 2006/02/15 08:45:45 $
  * @version Revision: 1.0
  */
 
 public interface HibernateService {
 
     /**
      * Set SessionFactory
      * 
      * @param sessionFactory
      */
     void setSessionFactory(SessionFactory sessionFactory);
 
     /**
      * Create database connection and open a Session on it.
      * 
      * @return a Hibernate Session object
      */
     Session openSession() throws HibernateException;
 
     /**
      * commit transaction currently underway, and start new one ( as side effect
      * hibernate session will be flushed )
      */
     void commit() throws HibernateException;
 
     /**
      * rollback active transaction if any was started. transaction will be reset
      * 
      * @throws HibernateException
      *             if transaction can not be rolled back
      */
     void rollback() throws HibernateException;
 
     /**
      * normal session close. commit transaction is any
      */
     void closeSession() throws HibernateException;
 
     /**
      * reset and clean up everything. shall be used is something went wrong (
      * for example you received hibernate exception )
      */
     void reset();
 
     /**
      * 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
      */
     boolean contains(Object object) throws HibernateException, DAOException;
 
     /**
      * Remove a persistent instance from the datastore.
      * 
      * @param object
      * @throws HibernateException
      */
     void delete(Object object) throws HibernateException, DAOException;
 
     /**
      * Remove a persistent instance from the datastore with lock mode.
      * 
      * @param object
      * @param lockMode
      * @throws HibernateException
      */
     void delete(Object object, LockMode lockMode) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     int delete(String query) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     int delete(String query, Object value, Type type)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     int delete(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     void evict(Object object) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     List find(String query) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     List find(String query, Object value, Type type) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     List find(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     Object get(Class clazz, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     Object get(Class clazz, final Serializable id, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     Iterator iterate(String query) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     Iterator iterate(String query, Object value, Type type)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     Iterator iterate(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     Object load(Class clazz, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     Object load(Class clazz, final Serializable id, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * Read the persistent state associated with the given identifier into the
      * given transient instance.
      * 
      * @param object
      * @param id
      * @throws HibernateException
      * @throws DAOException
      */
     void load(Object object, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     void lock(Object object, LockMode lockMode) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     void update(Object object) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     void update(Object object, final Serializable id)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     Object saveOrUpdateCopy(Object object) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     Object saveOrUpdateCopy(Object object, final Serializable id)
             throws HibernateException, DAOException;
 
     /**
      * 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
      */
     void refresh(Object object) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     void refresh(Object object, LockMode lockMode) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     Serializable save(Object object) throws HibernateException, DAOException;
 
     /**
      * 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
      */
     void save(Object object, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * 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
      */
     void saveOrUpdate(Object object) throws HibernateException, DAOException;
 
 }

1		/**
2		* @(#)HibernateService.java
3		*
4		* JFoxSOAF, Service-Oriented Application Framework
5		*
6		* Copyright(c) JFoxSOAF Team
7		*
8		* Licensed under the GNU LGPL, Version 2.1 (the "License");
9		* you may not use this file except in compliance with the License.
10		* You may obtain a copy of the License at
11		*
12		* http://www.gnu.org/copyleft/lesser.html
13		*
14		* Unless required by applicable law or agreed to in writing, software
15		* distributed under the License is distributed on an "AS IS" BASIS,
16		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17		* See the License for the specific language governing permissions and
18		* limitations under the License.
19		*
20		* For more information, please visit:
21		* http://www.jfox.cn/confluence/display/JFoxSOAF/Home
22		* http://www.huihoo.org/jfox/jfoxsoaf
23		*/
24
25		package org.huihoo.jfox.soaf.services.persistence;
26
27		import java.io.Serializable;
28		import java.util.Iterator;
29		import java.util.List;
30
31		import net.sf.hibernate.HibernateException;
32		import net.sf.hibernate.LockMode;
33		import net.sf.hibernate.Session;
34		import net.sf.hibernate.SessionFactory;
35		import net.sf.hibernate.type.Type;
36
37		import org.huihoo.jfox.soaf.exception.DAOException;
38
39		/**
40		* <p>
41		* Hibernate persistence service, Wrapper service for hibernate.
42		* </p>
43		*
44		* @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
45		* @version $Revision: 1.6 $ $Date: 2006/02/15 08:45:45 $
46		* @version Revision: 1.0
47		*/
48
49		public interface HibernateService {
50
51		/**
52		* Set SessionFactory
53		*
54		* @param sessionFactory
55		*/
56		void setSessionFactory(SessionFactory sessionFactory);
57
58		/**
59		* Create database connection and open a Session on it.
60		*
61		* @return a Hibernate Session object
62		*/
63		Session openSession() throws HibernateException;
64
65		/**
66		* commit transaction currently underway, and start new one ( as side effect
67		* hibernate session will be flushed )
68		*/
69		void commit() throws HibernateException;
70
71		/**
72		* rollback active transaction if any was started. transaction will be reset
73		*
74		* @throws HibernateException
75		* if transaction can not be rolled back
76		*/
77		void rollback() throws HibernateException;
78
79		/**
80		* normal session close. commit transaction is any
81		*/
82		void closeSession() throws HibernateException;
83
84		/**
85		* reset and clean up everything. shall be used is something went wrong (
86		* for example you received hibernate exception )
87		*/
88		void reset();
89
90		/**
91		* Check if this instance is associated with this Session
92		*
93		* @param object
94		* an instance of a persistent class
95		* @return true if the given instance is associated with this Session
96		* @throws HibernateException
97		* @throws DAOException
98		*/
99		boolean contains(Object object) throws HibernateException, DAOException;
100
101		/**
102		* Remove a persistent instance from the datastore.
103		*
104		* @param object
105		* @throws HibernateException
106		*/
107		void delete(Object object) throws HibernateException, DAOException;
108
109		/**
110		* Remove a persistent instance from the datastore with lock mode.
111		*
112		* @param object
113		* @param lockMode
114		* @throws HibernateException
115		*/
116		void delete(Object object, LockMode lockMode) throws HibernateException,
117		DAOException;
118
119		/**
120		* Delete all objects returned by the query. Return the number of objects
121		* deleted.
122		*
123		* @param query
124		* @return the number of instances deleted
125		* @throws HibernateException
126		* @throws DAOException
127		*/
128		int delete(String query) throws HibernateException, DAOException;
129
130		/**
131		* Delete all objects returned by the query. Return the number of objects
132		* deleted.
133		*
134		* @param query
135		* @return the number of instances deleted
136		* @throws HibernateException
137		* @throws DAOException
138		*/
139		int delete(String query, Object value, Type type)
140		throws HibernateException, DAOException;
141
142		/**
143		* Delete all objects returned by the query. Return the number of objects
144		* deleted.
145		*
146		* @param query
147		* @return the number of instances deleted
148		* @throws HibernateException
149		* @throws DAOException
150		*/
151		int delete(String query, Object[] values, Type[] types)
152		throws HibernateException, DAOException;
153
154		/**
155		* Remove this instance from the session cache. Changes to the instance will
156		* not be synchronized with the database. This operation cascades to
157		* associated instances if the association is mapped with cascade="all" or
158		* cascade="all-delete-orphan".
159		*
160		* @param object
161		* object - a persistent instance
162		* @throws HibernateException
163		* @throws DAOException
164		*/
165		void evict(Object object) throws HibernateException, DAOException;
166
167		/**
168		* Execute a query.
169		*
170		* @param query
171		* a query expressed in Hibernate's query language
172		* @return a distinct list of instances (or arrays of instances)
173		* @throws HibernateException
174		* @throws DAOException
175		*/
176		List find(String query) throws HibernateException, DAOException;
177
178		/**
179		* Execute a query with bind parameters. Bind a value to a "?" parameter in
180		* the query string.
181		*
182		* @param query
183		* @param value
184		* @param type
185		* @return a distinct list of instances (or arrays of instances)
186		* @throws HibernateException
187		* @throws DAOException
188		*/
189		List find(String query, Object value, Type type) throws HibernateException,
190		DAOException;
191
192		/**
193		* Execute a query with bind parameters. Binding an array of values to "?"
194		* parameters in the query string.
195		*
196		* @param query
197		* @param values
198		* @param types
199		* @return a distinct list of instances
200		* @throws HibernateException
201		* @throws DAOException
202		*/
203		List find(String query, Object[] values, Type[] types)
204		throws HibernateException, DAOException;
205
206		/**
207		* Return the persistent instance of the given entity class with the given
208		* identifier, or null if there is no such persistent instance.
209		*
210		* @param clazz
211		* @param id
212		* @return a persistent instance or null
213		* @throws HibernateException
214		* @throws DAOException
215		*/
216		Object get(Class clazz, final Serializable id) throws HibernateException,
217		DAOException;
218
219		/**
220		* Return the persistent instance of the given entity class with the given
221		* identifier, or null if there is no such persistent instance. Obtain the
222		* specified lock mode if the instance exists.
223		*
224		* @param clazz
225		* @param id
226		* @param lockMode
227		* @return a persistent instance or null
228		* @throws HibernateException
229		* @throws DAOException
230		*/
231		Object get(Class clazz, final Serializable id, LockMode lockMode)
232		throws HibernateException, DAOException;
233
234		/**
235		* Execute a query and return the results in an iterator. If the query has
236		* multiple return values, values will be returned in an array of type
237		* Object[]. Entities returned as results are initialized on demand. The
238		* first SQL query returns identifiers only. So iterate() is usually a less
239		* efficient way to retrieve objects than find().
240		*
241		* @param query
242		* @return an iterator
243		* @throws HibernateException
244		* @throws DAOException
245		*/
246		Iterator iterate(String query) throws HibernateException, DAOException;
247
248		/**
249		* Execute a query and return the results in an iterator. Write the given
250		* value to "?" in the query string. If the query has multiple return
251		* values, values will be returned in an array of type Object[]. Entities
252		* returned as results are initialized on demand. The first SQL query
253		* returns identifiers only. So iterate() is usually a less efficient way to
254		* retrieve objects than find().
255		*
256		* @param query -
257		* the query string
258		* @param value -
259		* a value to be witten to a "?" placeholder in the query string
260		* @param type -
261		* the hibernate type of value
262		* @return an iterator
263		* @throws HibernateException
264		* @throws DAOException
265		*/
266		Iterator iterate(String query, Object value, Type type)
267		throws HibernateException, DAOException;
268
269		/**
270		* Execute a query and return the results in an iterator. Write the given
271		* values to "?" in the query string. If the query has multiple return
272		* values, values will be returned in an array of type Object[]. Entities
273		* returned as results are initialized on demand. The first SQL query
274		* returns identifiers only. So iterate() is usually a less efficient way to
275		* retrieve objects than find().
276		*
277		* @param query
278		* @param values
279		* @param types
280		* @return
281		* @throws HibernateException
282		* @throws DAOException
283		*/
284		Iterator iterate(String query, Object[] values, Type[] types)
285		throws HibernateException, DAOException;
286
287		/**
288		* Return the persistent instance of the given entity class with the given
289		* identifier, assuming that the instance exists. You should not use this
290		* method to determine if an instance exists (use find() instead). Use this
291		* only to retrieve an instance that you assume exists, where non-existence
292		* would be an actual error.
293		*
294		* @param clazz
295		* @param id
296		* @return the persistent instance or proxy
297		* @throws HibernateException
298		* @throws DAOException
299		*/
300		Object load(Class clazz, final Serializable id) throws HibernateException,
301		DAOException;
302
303		/**
304		* Return the persistent instance of the given entity class with the given
305		* identifier, obtaining the specified lock mode, assuming the instance
306		* exists.
307		*
308		* @param clazz
309		* @param id
310		* @param lockMode
311		* @return the persistent instance or proxy
312		* @throws HibernateException
313		* @throws DAOException
314		*/
315		Object load(Class clazz, final Serializable id, LockMode lockMode)
316		throws HibernateException, DAOException;
317
318		/**
319		* Read the persistent state associated with the given identifier into the
320		* given transient instance.
321		*
322		* @param object
323		* @param id
324		* @throws HibernateException
325		* @throws DAOException
326		*/
327		void load(Object object, final Serializable id) throws HibernateException,
328		DAOException;
329
330		/**
331		* Obtain the specified lock level upon the given object.
332		*
333		* @param object -
334		* a persistent or transient instance
335		* @param lockMode -
336		* the lock level
337		* @throws HibernateException
338		* @throws DAOException
339		*/
340		void lock(Object object, LockMode lockMode) throws HibernateException,
341		DAOException;
342
343		/**
344		* Update the persistent instance with the identifier of the given transient
345		* instance. If there is a persistent instance with the same identifier, an
346		* exception is thrown. If the given transient instance has a null
347		* identifier, an exception will be thrown.
348		*
349		* @param object -
350		* a transient instance containing updated state
351		* @throws HibernateException
352		* @throws DAOException
353		*/
354		void update(Object object) throws HibernateException, DAOException;
355
356		/**
357		* Update the persistent state associated with the given identifier. An
358		* exception is thrown if there is a persistent instance with the same
359		* identifier in the current session.
360		*
361		* @param object -
362		* a transient instance containing updated state
363		* @param id -
364		* identifier of persistent instance
365		* @throws HibernateException
366		* @throws DAOException
367		*/
368		void update(Object object, final Serializable id)
369		throws HibernateException, DAOException;
370
371		/**
372		* Copy the state of the given object onto the persistent object with the
373		* same identifier. If there is no persistent instance currently associated
374		* with the session, it will be loaded. Return the persistent instance. If
375		* the given instance is unsaved or does not exist in the database, save it
376		* and return it as a newly persistent instance. Otherwise, the given
377		* instance does not become associated with the session.
378		*
379		* @param object
380		* @return an updated persistent instance
381		* @throws HibernateException
382		* @throws DAOException
383		*/
384		Object saveOrUpdateCopy(Object object) throws HibernateException,
385		DAOException;
386
387		/**
388		* Copy the state of the given object onto the persistent object with the
389		* given identifier. If there is no persistent instance currently associated
390		* with the session, it will be loaded. Return the persistent instance. If
391		* there is no database row with the given identifier, save the given
392		* instance and return it as a newly persistent instance. Otherwise, the
393		* given instance does not become associated with the session.
394		*
395		* @param object -
396		* a persistent or transient instance with state to be copied
397		* @param id -
398		* the identifier of the instance to copy to
399		* @return an updated persistent instance
400		* @throws HibernateException
401		* @throws DAOException
402		*/
403		Object saveOrUpdateCopy(Object object, final Serializable id)
404		throws HibernateException, DAOException;
405
406		/**
407		* Re-read the state of the given instance from the underlying database. It
408		* is inadvisable to use this to implement long-running sessions that span
409		* many business tasks. This method is, however, useful in certain special
410		* circumstances.
411		*
412		* @param object
413		* a persistent or transient instance
414		* @throws HibernateException
415		* @throws DAOException
416		*/
417		void refresh(Object object) throws HibernateException, DAOException;
418
419		/**
420		* Re-read the state of the given instance from the underlying database,
421		* with the given LockMode. It is inadvisable to use this to implement
422		* long-running sessions that span many business tasks. This method is,
423		* however, useful in certain special circumstances.
424		*
425		* @param object
426		* a persistent or transient instance
427		* @param lockMode
428		* the lock mode to use
429		* @throws HibernateException
430		* @throws DAOException
431		*/
432		void refresh(Object object, LockMode lockMode) throws HibernateException,
433		DAOException;
434
435		/**
436		* Persist the given transient instance, first assigning a generated
437		* identifier.
438		*
439		* @param object - -
440		* a transient instance of a persistent class
441		* @return the generated identifier
442		* @throws HibernateException
443		*/
444		Serializable save(Object object) throws HibernateException, DAOException;
445
446		/**
447		* Persist the given transient instance, using the given identifier.
448		*
449		* @param object -
450		* a transient instance of a persistent class
451		* @param id -
452		* an unused valid identifier
453		* @throws HibernateException
454		* @throws DAOException
455		*/
456		void save(Object object, final Serializable id) throws HibernateException,
457		DAOException;
458
459		/**
460		* Either save() or update() the given instance, depending upon the value of
461		* its identifier property. By default the instance is always saved. This
462		* behaviour may be adjusted by specifying an unsaved-value attribute of the
463		* identifier property mapping.
464		*
465		* @param object -
466		* a transient instance containing new or updated state
467		* @throws HibernateException
468		* @throws DAOException
469		*/
470		void saveOrUpdate(Object object) throws HibernateException, DAOException;
471
472		}