1 /*
2 * Copyright 2002-2008 the original author or authors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package org.springframework.orm.hibernate3;
18
19 import java.io.Serializable;
20 import java.lang.reflect.InvocationHandler;
21 import java.lang.reflect.InvocationTargetException;
22 import java.lang.reflect.Method;
23 import java.lang.reflect.Proxy;
24 import java.sql.SQLException;
25 import java.util.Collection;
26 import java.util.Iterator;
27 import java.util.List;
28
29 import org.hibernate.Criteria;
30 import org.hibernate.Filter;
31 import org.hibernate.FlushMode;
32 import org.hibernate.Hibernate;
33 import org.hibernate.HibernateException;
34 import org.hibernate.LockMode;
35 import org.hibernate.Query;
36 import org.hibernate.ReplicationMode;
37 import org.hibernate.Session;
38 import org.hibernate.SessionFactory;
39 import org.hibernate.criterion.DetachedCriteria;
40 import org.hibernate.criterion.Example;
41 import org.hibernate.engine.SessionImplementor;
42 import org.hibernate.event.EventSource;
43
44 import org.springframework.dao.DataAccessException;
45 import org.springframework.dao.DataAccessResourceFailureException;
46 import org.springframework.dao.InvalidDataAccessApiUsageException;
47 import org.springframework.util.Assert;
48
49 /**
50 * Helper class that simplifies Hibernate data access code. Automatically
51 * converts HibernateExceptions into DataAccessExceptions, following the
52 * <code>org.springframework.dao</code> exception hierarchy.
53 *
54 * <p>The central method is <code>execute</code>, supporting Hibernate access code
55 * implementing the {@link HibernateCallback} interface. It provides Hibernate Session
56 * handling such that neither the HibernateCallback implementation nor the calling
57 * code needs to explicitly care about retrieving/closing Hibernate Sessions,
58 * or handling Session lifecycle exceptions. For typical single step actions,
59 * there are various convenience methods (find, load, saveOrUpdate, delete).
60 *
61 * <p>Can be used within a service implementation via direct instantiation
62 * with a SessionFactory reference, or get prepared in an application context
63 * and given to services as bean reference. Note: The SessionFactory should
64 * always be configured as bean in the application context, in the first case
65 * given to the service directly, in the second case to the prepared template.
66 *
67 * <p><b>NOTE: As of Hibernate 3.0.1, transactional Hibernate access code can
68 * also be coded in plain Hibernate style. Hence, for newly started projects,
69 * consider adopting the standard Hibernate3 style of coding data access objects
70 * instead, based on {@link org.hibernate.SessionFactory#getCurrentSession()}.</b>
71 *
72 * <p>This class can be considered as direct alternative to working with the raw
73 * Hibernate3 Session API (through <code>SessionFactory.getCurrentSession()</code>).
74 * The major advantage is its automatic conversion to DataAccessExceptions as well
75 * as its capability to fall back to 'auto-commit' style behavior when used outside
76 * of transactions. <b>Note that HibernateTemplate will perform its own Session
77 * management, not participating in a custom Hibernate CurrentSessionContext
78 * unless you explicitly switch {@link #setAllowCreate "allowCreate"} to "false".</b>
79 *
80 * <p>{@link LocalSessionFactoryBean} is the preferred way of obtaining a reference
81 * to a specific Hibernate SessionFactory, at least in a non-EJB environment.
82 * The Spring application context will manage its lifecycle, initializing and
83 * shutting down the factory as part of the application.
84 *
85 * <p>Note that operations that return an Iterator (i.e. <code>iterate</code>)
86 * are supposed to be used within Spring-driven or JTA-driven transactions
87 * (with HibernateTransactionManager, JtaTransactionManager, or EJB CMT).
88 * Else, the Iterator won't be able to read results from its ResultSet anymore,
89 * as the underlying Hibernate Session will already have been closed.
90 *
91 * <p>Lazy loading will also just work with an open Hibernate Session,
92 * either within a transaction or within OpenSessionInViewFilter/Interceptor.
93 * Furthermore, some operations just make sense within transactions,
94 * for example: <code>contains</code>, <code>evict</code>, <code>lock</code>,
95 * <code>flush</code>, <code>clear</code>.
96 *
97 * @author Juergen Hoeller
98 * @since 1.2
99 * @see #setSessionFactory
100 * @see HibernateCallback
101 * @see org.hibernate.Session
102 * @see LocalSessionFactoryBean
103 * @see HibernateTransactionManager
104 * @see org.springframework.transaction.jta.JtaTransactionManager
105 * @see org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
106 * @see org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor
107 */
108 public class HibernateTemplate extends HibernateAccessor implements HibernateOperations {
109
110 private boolean allowCreate = true;
111
112 private boolean alwaysUseNewSession = false;
113
114 private boolean exposeNativeSession = false;
115
116 private boolean checkWriteOperations = true;
117
118 private boolean cacheQueries = false;
119
120 private String queryCacheRegion;
121
122 private int fetchSize = 0;
123
124 private int maxResults = 0;
125
126
127 /**
128 * Create a new HibernateTemplate instance.
129 */
130 public HibernateTemplate() {
131 }
132
133 /**
134 * Create a new HibernateTemplate instance.
135 * @param sessionFactory SessionFactory to create Sessions
136 */
137 public HibernateTemplate(SessionFactory sessionFactory) {
138 setSessionFactory(sessionFactory);
139 afterPropertiesSet();
140 }
141
142 /**
143 * Create a new HibernateTemplate instance.
144 * @param sessionFactory SessionFactory to create Sessions
145 * @param allowCreate if a non-transactional Session should be created when no
146 * transactional Session can be found for the current thread
147 */
148 public HibernateTemplate(SessionFactory sessionFactory, boolean allowCreate) {
149 setSessionFactory(sessionFactory);
150 setAllowCreate(allowCreate);
151 afterPropertiesSet();
152 }
153
154
155 /**
156 * Set if a new {@link Session} should be created when no transactional
157 * <code>Session</code> can be found for the current thread.
158 * The default value is <code>true</code>.
159 * <p><code>HibernateTemplate</code> is aware of a corresponding
160 * <code>Session</code> bound to the current thread, for example when using
161 * {@link HibernateTransactionManager}. If <code>allowCreate</code> is
162 * <code>true</code>, a new non-transactional <code>Session</code> will be
163 * created if none is found, which needs to be closed at the end of the operation.
164 * If <code>false</code>, an {@link IllegalStateException} will get thrown in
165 * this case.
166 * <p><b>NOTE: As of Spring 2.5, switching <code>allowCreate</code>
167 * to <code>false</code> will delegate to Hibernate's
168 * {@link org.hibernate.SessionFactory#getCurrentSession()} method,</b>
169 * which - with Spring-based setup - will by default delegate to Spring's
170 * <code>SessionFactoryUtils.getSession(sessionFactory, false)</code>.
171 * This mode also allows for custom Hibernate CurrentSessionContext strategies
172 * to be plugged in, whereas <code>allowCreate</code> set to <code>true</code>
173 * will always use a Spring-managed Hibernate Session.
174 * @see SessionFactoryUtils#getSession(SessionFactory, boolean)
175 */
176 public void setAllowCreate(boolean allowCreate) {
177 this.allowCreate = allowCreate;
178 }
179
180 /**
181 * Return if a new Session should be created if no thread-bound found.
182 */
183 public boolean isAllowCreate() {
184 return this.allowCreate;
185 }
186
187 /**
188 * Set whether to always use a new Hibernate Session for this template.
189 * Default is "false"; if activated, all operations on this template will
190 * work on a new Hibernate Session even in case of a pre-bound Session
191 * (for example, within a transaction or OpenSessionInViewFilter).
192 * <p>Within a transaction, a new Hibernate Session used by this template
193 * will participate in the transaction through using the same JDBC
194 * Connection. In such a scenario, multiple Sessions will participate
195 * in the same database transaction.
196 * <p>Turn this on for operations that are supposed to always execute
197 * independently, without side effects caused by a shared Hibernate Session.
198 */
199 public void setAlwaysUseNewSession(boolean alwaysUseNewSession) {
200 this.alwaysUseNewSession = alwaysUseNewSession;
201 }
202
203 /**
204 * Return whether to always use a new Hibernate Session for this template.
205 */
206 public boolean isAlwaysUseNewSession() {
207 return this.alwaysUseNewSession;
208 }
209
210 /**
211 * Set whether to expose the native Hibernate Session to
212 * HibernateCallback code.
213 * <p>Default is "false": a Session proxy will be returned, suppressing
214 * <code>close</code> calls and automatically applying query cache
215 * settings and transaction timeouts.
216 * @see HibernateCallback
217 * @see org.hibernate.Session
218 * @see #setCacheQueries
219 * @see #setQueryCacheRegion
220 * @see #prepareQuery
221 * @see #prepareCriteria
222 */
223 public void setExposeNativeSession(boolean exposeNativeSession) {
224 this.exposeNativeSession = exposeNativeSession;
225 }
226
227 /**
228 * Return whether to expose the native Hibernate Session to
229 * HibernateCallback code, or rather a Session proxy.
230 */
231 public boolean isExposeNativeSession() {
232 return this.exposeNativeSession;
233 }
234
235 /**
236 * Set whether to check that the Hibernate Session is not in read-only mode
237 * in case of write operations (save/update/delete).
238 * <p>Default is "true", for fail-fast behavior when attempting write operations
239 * within a read-only transaction. Turn this off to allow save/update/delete
240 * on a Session with flush mode NEVER.
241 * @see #setFlushMode
242 * @see #checkWriteOperationAllowed
243 * @see org.springframework.transaction.TransactionDefinition#isReadOnly
244 */
245 public void setCheckWriteOperations(boolean checkWriteOperations) {
246 this.checkWriteOperations = checkWriteOperations;
247 }
248
249 /**
250 * Return whether to check that the Hibernate Session is not in read-only
251 * mode in case of write operations (save/update/delete).
252 */
253 public boolean isCheckWriteOperations() {
254 return this.checkWriteOperations;
255 }
256
257 /**
258 * Set whether to cache all queries executed by this template.
259 * <p>If this is "true", all Query and Criteria objects created by
260 * this template will be marked as cacheable (including all
261 * queries through find methods).
262 * <p>To specify the query region to be used for queries cached
263 * by this template, set the "queryCacheRegion" property.
264 * @see #setQueryCacheRegion
265 * @see org.hibernate.Query#setCacheable
266 * @see org.hibernate.Criteria#setCacheable
267 */
268 public void setCacheQueries(boolean cacheQueries) {
269 this.cacheQueries = cacheQueries;
270 }
271
272 /**
273 * Return whether to cache all queries executed by this template.
274 */
275 public boolean isCacheQueries() {
276 return this.cacheQueries;
277 }
278
279 /**
280 * Set the name of the cache region for queries executed by this template.
281 * <p>If this is specified, it will be applied to all Query and Criteria objects
282 * created by this template (including all queries through find methods).
283 * <p>The cache region will not take effect unless queries created by this
284 * template are configured to be cached via the "cacheQueries" property.
285 * @see #setCacheQueries
286 * @see org.hibernate.Query#setCacheRegion
287 * @see org.hibernate.Criteria#setCacheRegion
288 */
289 public void setQueryCacheRegion(String queryCacheRegion) {
290 this.queryCacheRegion = queryCacheRegion;
291 }
292
293 /**
294 * Return the name of the cache region for queries executed by this template.
295 */
296 public String getQueryCacheRegion() {
297 return this.queryCacheRegion;
298 }
299
300 /**
301 * Set the fetch size for this HibernateTemplate. This is important for processing
302 * large result sets: Setting this higher than the default value will increase
303 * processing speed at the cost of memory consumption; setting this lower can
304 * avoid transferring row data that will never be read by the application.
305 * <p>Default is 0, indicating to use the JDBC driver's default.
306 */
307 public void setFetchSize(int fetchSize) {
308 this.fetchSize = fetchSize;
309 }
310
311 /**
312 * Return the fetch size specified for this HibernateTemplate.
313 */
314 public int getFetchSize() {
315 return this.fetchSize;
316 }
317
318 /**
319 * Set the maximum number of rows for this HibernateTemplate. This is important
320 * for processing subsets of large result sets, avoiding to read and hold
321 * the entire result set in the database or in the JDBC driver if we're
322 * never interested in the entire result in the first place (for example,
323 * when performing searches that might return a large number of matches).
324 * <p>Default is 0, indicating to use the JDBC driver's default.
325 */
326 public void setMaxResults(int maxResults) {
327 this.maxResults = maxResults;
328 }
329
330 /**
331 * Return the maximum number of rows specified for this HibernateTemplate.
332 */
333 public int getMaxResults() {
334 return this.maxResults;
335 }
336
337
338 public Object execute(HibernateCallback action) throws DataAccessException {
339 return doExecute(action, false, false);
340 }
341
342 public List executeFind(HibernateCallback action) throws DataAccessException {
343 Object result = doExecute(action, false, false);
344 if (result != null && !(result instanceof List)) {
345 throw new InvalidDataAccessApiUsageException(
346 "Result object returned from HibernateCallback isn't a List: [" + result + "]");
347 }
348 return (List) result;
349 }
350
351 /**
352 * Execute the action specified by the given action object within a
353 * new {@link org.hibernate.Session}.
354 * <p>This execute variant overrides the template-wide
355 * {@link #isAlwaysUseNewSession() "alwaysUseNewSession"} setting.
356 * @param action callback object that specifies the Hibernate action
357 * @return a result object returned by the action, or <code>null</code>
358 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
359 */
360 public Object executeWithNewSession(HibernateCallback action) {
361 return doExecute(action, true, false);
362 }
363
364 /**
365 * Execute the action specified by the given action object within a
366 * native {@link org.hibernate.Session}.
367 * <p>This execute variant overrides the template-wide
368 * {@link #isExposeNativeSession() "exposeNativeSession"} setting.
369 * @param action callback object that specifies the Hibernate action
370 * @return a result object returned by the action, or <code>null</code>
371 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
372 */
373 public Object executeWithNativeSession(HibernateCallback action) {
374 return doExecute(action, false, true);
375 }
376
377 /**
378 * Execute the action specified by the given action object within a Session.
379 * @param action callback object that specifies the Hibernate action
380 * @param enforceNativeSession whether to enforce exposure of the native
381 * Hibernate Session to callback code
382 * @return a result object returned by the action, or <code>null</code>
383 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
384 * @deprecated as of Spring 2.5, in favor of {@link #executeWithNativeSession}
385 */
386 public Object execute(HibernateCallback action, boolean enforceNativeSession) throws DataAccessException {
387 return doExecute(action, false, enforceNativeSession);
388 }
389
390 /**
391 * Execute the action specified by the given action object within a Session.
392 * @param action callback object that specifies the Hibernate action
393 * @param enforceNewSession whether to enforce a new Session for this template
394 * even if there is a pre-bound transactional Session
395 * @param enforceNativeSession whether to enforce exposure of the native
396 * Hibernate Session to callback code
397 * @return a result object returned by the action, or <code>null</code>
398 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
399 */
400 protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession)
401 throws DataAccessException {
402
403 Assert.notNull(action, "Callback object must not be null");
404
405 Session session = (enforceNewSession ?
406 SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());
407 boolean existingTransaction = (!enforceNewSession &&
408 (!isAllowCreate() || SessionFactoryUtils.isSessionTransactional(session, getSessionFactory())));
409 if (existingTransaction) {
410 logger.debug("Found thread-bound Session for HibernateTemplate");
411 }
412
413 FlushMode previousFlushMode = null;
414 try {
415 previousFlushMode = applyFlushMode(session, existingTransaction);
416 enableFilters(session);
417 Session sessionToExpose =
418 (enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));
419 Object result = action.doInHibernate(sessionToExpose);
420 flushIfNecessary(session, existingTransaction);
421 return result;
422 }
423 catch (HibernateException ex) {
424 throw convertHibernateAccessException(ex);
425 }
426 catch (SQLException ex) {
427 throw convertJdbcAccessException(ex);
428 }
429 catch (RuntimeException ex) {
430 // Callback code threw application exception...
431 throw ex;
432 }
433 finally {
434 if (existingTransaction) {
435 logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
436 disableFilters(session);
437 if (previousFlushMode != null) {
438 session.setFlushMode(previousFlushMode);
439 }
440 }
441 else {
442 // Never use deferred close for an explicitly new Session.
443 if (isAlwaysUseNewSession()) {
444 SessionFactoryUtils.closeSession(session);
445 }
446 else {
447 SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());
448 }
449 }
450 }
451 }
452
453 /**
454 * Return a Session for use by this template.
455 * <p>Returns a new Session in case of "alwaysUseNewSession" (using the same
456 * JDBC Connection as a transactional Session, if applicable), a pre-bound
457 * Session in case of "allowCreate" turned off, and a pre-bound or new Session
458 * otherwise (new only if no transactional or otherwise pre-bound Session exists).
459 * @return the Session to use (never <code>null</code>)
460 * @see SessionFactoryUtils#getSession
461 * @see SessionFactoryUtils#getNewSession
462 * @see #setAlwaysUseNewSession
463 * @see #setAllowCreate
464 */
465 protected Session getSession() {
466 if (isAlwaysUseNewSession()) {
467 return SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor());
468 }
469 else if (isAllowCreate()) {
470 return SessionFactoryUtils.getSession(
471 getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());
472 }
473 else {
474 try {
475 return getSessionFactory().getCurrentSession();
476 }
477 catch (HibernateException ex) {
478 throw new DataAccessResourceFailureException("Could not obtain current Hibernate Session", ex);
479 }
480 }
481 }
482
483 /**
484 * Create a close-suppressing proxy for the given Hibernate Session.
485 * The proxy also prepares returned Query and Criteria objects.
486 * @param session the Hibernate Session to create a proxy for
487 * @return the Session proxy
488 * @see org.hibernate.Session#close()
489 * @see #prepareQuery
490 * @see #prepareCriteria
491 */
492 protected Session createSessionProxy(Session session) {
493 Class[] sessionIfcs = null;
494 Class mainIfc = (session instanceof org.hibernate.classic.Session ?
495 org.hibernate.classic.Session.class : Session.class);
496 if (session instanceof EventSource) {
497 sessionIfcs = new Class[] {mainIfc, EventSource.class};
498 }
499 else if (session instanceof SessionImplementor) {
500 sessionIfcs = new Class[] {mainIfc, SessionImplementor.class};
501 }
502 else {
503 sessionIfcs = new Class[] {mainIfc};
504 }
505 return (Session) Proxy.newProxyInstance(
506 session.getClass().getClassLoader(), sessionIfcs,
507 new CloseSuppressingInvocationHandler(session));
508 }
509
510
511 //-------------------------------------------------------------------------
512 // Convenience methods for loading individual objects
513 //-------------------------------------------------------------------------
514
515 public Object get(Class entityClass, Serializable id) throws DataAccessException {
516 return get(entityClass, id, null);
517 }
518
519 public Object get(final Class entityClass, final Serializable id, final LockMode lockMode)
520 throws DataAccessException {
521
522 return executeWithNativeSession(new HibernateCallback() {
523 public Object doInHibernate(Session session) throws HibernateException {
524 if (lockMode != null) {
525 return session.get(entityClass, id, lockMode);
526 }
527 else {
528 return session.get(entityClass, id);
529 }
530 }
531 });
532 }
533
534 public Object get(String entityName, Serializable id) throws DataAccessException {
535 return get(entityName, id, null);
536 }
537
538 public Object get(final String entityName, final Serializable id, final LockMode lockMode)
539 throws DataAccessException {
540
541 return executeWithNativeSession(new HibernateCallback() {
542 public Object doInHibernate(Session session) throws HibernateException {
543 if (lockMode != null) {
544 return session.get(entityName, id, lockMode);
545 }
546 else {
547 return session.get(entityName, id);
548 }
549 }
550 });
551 }
552
553 public Object load(Class entityClass, Serializable id) throws DataAccessException {
554 return load(entityClass, id, null);
555 }
556
557 public Object load(final Class entityClass, final Serializable id, final LockMode lockMode)
558 throws DataAccessException {
559
560 return executeWithNativeSession(new HibernateCallback() {
561 public Object doInHibernate(Session session) throws HibernateException {
562 if (lockMode != null) {
563 return session.load(entityClass, id, lockMode);
564 }
565 else {
566 return session.load(entityClass, id);
567 }
568 }
569 });
570 }
571
572 public Object load(String entityName, Serializable id) throws DataAccessException {
573 return load(entityName, id, null);
574 }
575
576 public Object load(final String entityName, final Serializable id, final LockMode lockMode)
577 throws DataAccessException {
578
579 return executeWithNativeSession(new HibernateCallback() {
580 public Object doInHibernate(Session session) throws HibernateException {
581 if (lockMode != null) {
582 return session.load(entityName, id, lockMode);
583 }
584 else {
585 return session.load(entityName, id);
586 }
587 }
588 });
589 }
590
591 public List loadAll(final Class entityClass) throws DataAccessException {
592 return (List) executeWithNativeSession(new HibernateCallback() {
593 public Object doInHibernate(Session session) throws HibernateException {
594 Criteria criteria = session.createCriteria(entityClass);
595 prepareCriteria(criteria);
596 return criteria.list();
597 }
598 });
599 }
600
601 public void load(final Object entity, final Serializable id) throws DataAccessException {
602 executeWithNativeSession(new HibernateCallback() {
603 public Object doInHibernate(Session session) throws HibernateException {
604 session.load(entity, id);
605 return null;
606 }
607 });
608 }
609
610 public void refresh(final Object entity) throws DataAccessException {
611 refresh(entity, null);
612 }
613
614 public void refresh(final Object entity, final LockMode lockMode) throws DataAccessException {
615 executeWithNativeSession(new HibernateCallback() {
616 public Object doInHibernate(Session session) throws HibernateException {
617 if (lockMode != null) {
618 session.refresh(entity, lockMode);
619 }
620 else {
621 session.refresh(entity);
622 }
623 return null;
624 }
625 });
626 }
627
628 public boolean contains(final Object entity) throws DataAccessException {
629 Boolean result = (Boolean) executeWithNativeSession(new HibernateCallback() {
630 public Object doInHibernate(Session session) {
631 return (session.contains(entity) ? Boolean.TRUE : Boolean.FALSE);
632 }
633 });
634 return result.booleanValue();
635 }
636
637 public void evict(final Object entity) throws DataAccessException {
638 executeWithNativeSession(new HibernateCallback() {
639 public Object doInHibernate(Session session) throws HibernateException {
640 session.evict(entity);
641 return null;
642 }
643 });
644 }
645
646 public void initialize(Object proxy) throws DataAccessException {
647 try {
648 Hibernate.initialize(proxy);
649 }
650 catch (HibernateException ex) {
651 throw SessionFactoryUtils.convertHibernateAccessException(ex);
652 }
653 }
654
655 public Filter enableFilter(String filterName) throws IllegalStateException {
656 Session session = SessionFactoryUtils.getSession(getSessionFactory(), false);
657 Filter filter = session.getEnabledFilter(filterName);
658 if (filter == null) {
659 filter = session.enableFilter(filterName);
660 }
661 return filter;
662 }
663
664
665 //-------------------------------------------------------------------------
666 // Convenience methods for storing individual objects
667 //-------------------------------------------------------------------------
668
669 public void lock(final Object entity, final LockMode lockMode) throws DataAccessException {
670 executeWithNativeSession(new HibernateCallback() {
671 public Object doInHibernate(Session session) throws HibernateException {
672 session.lock(entity, lockMode);
673 return null;
674 }
675 });
676 }
677
678 public void lock(final String entityName, final Object entity, final LockMode lockMode)
679 throws DataAccessException {
680
681 executeWithNativeSession(new HibernateCallback() {
682 public Object doInHibernate(Session session) throws HibernateException {
683 session.lock(entityName, entity, lockMode);
684 return null;
685 }
686 });
687 }
688
689 public Serializable save(final Object entity) throws DataAccessException {
690 return (Serializable) executeWithNativeSession(new HibernateCallback() {
691 public Object doInHibernate(Session session) throws HibernateException {
692 checkWriteOperationAllowed(session);
693 return session.save(entity);
694 }
695 });
696 }
697
698 public Serializable save(final String entityName, final Object entity) throws DataAccessException {
699 return (Serializable) executeWithNativeSession(new HibernateCallback() {
700 public Object doInHibernate(Session session) throws HibernateException {
701 checkWriteOperationAllowed(session);
702 return session.save(entityName, entity);
703 }
704 });
705 }
706
707 public void update(Object entity) throws DataAccessException {
708 update(entity, null);
709 }
710
711 public void update(final Object entity, final LockMode lockMode) throws DataAccessException {
712 executeWithNativeSession(new HibernateCallback() {
713 public Object doInHibernate(Session session) throws HibernateException {
714 checkWriteOperationAllowed(session);
715 session.update(entity);
716 if (lockMode != null) {
717 session.lock(entity, lockMode);
718 }
719 return null;
720 }
721 });
722 }
723
724 public void update(String entityName, Object entity) throws DataAccessException {
725 update(entityName, entity, null);
726 }
727
728 public void update(final String entityName, final Object entity, final LockMode lockMode)
729 throws DataAccessException {
730
731 executeWithNativeSession(new HibernateCallback() {
732 public Object doInHibernate(Session session) throws HibernateException {
733 checkWriteOperationAllowed(session);
734 session.update(entityName, entity);
735 if (lockMode != null) {
736 session.lock(entity, lockMode);
737 }
738 return null;
739 }
740 });
741 }
742
743 public void saveOrUpdate(final Object entity) throws DataAccessException {
744 executeWithNativeSession(new HibernateCallback() {
745 public Object doInHibernate(Session session) throws HibernateException {
746 checkWriteOperationAllowed(session);
747 session.saveOrUpdate(entity);
748 return null;
749 }
750 });
751 }
752
753 public void saveOrUpdate(final String entityName, final Object entity) throws DataAccessException {
754 executeWithNativeSession(new HibernateCallback() {
755 public Object doInHibernate(Session session) throws HibernateException {
756 checkWriteOperationAllowed(session);
757 session.saveOrUpdate(entityName, entity);
758 return null;
759 }
760 });
761 }
762
763 public void saveOrUpdateAll(final Collection entities) throws DataAccessException {
764 executeWithNativeSession(new HibernateCallback() {
765 public Object doInHibernate(Session session) throws HibernateException {
766 checkWriteOperationAllowed(session);
767 for (Iterator it = entities.iterator(); it.hasNext();) {
768 session.saveOrUpdate(it.next());
769 }
770 return null;
771 }
772 });
773 }
774
775 public void replicate(final Object entity, final ReplicationMode replicationMode)
776 throws DataAccessException {
777
778 executeWithNativeSession(new HibernateCallback() {
779 public Object doInHibernate(Session session) throws HibernateException {
780 checkWriteOperationAllowed(session);
781 session.replicate(entity, replicationMode);
782 return null;
783 }
784 });
785 }
786
787 public void replicate(final String entityName, final Object entity, final ReplicationMode replicationMode)
788 throws DataAccessException {
789
790 executeWithNativeSession(new HibernateCallback() {
791 public Object doInHibernate(Session session) throws HibernateException {
792 checkWriteOperationAllowed(session);
793 session.replicate(entityName, entity, replicationMode);
794 return null;
795 }
796 });
797 }
798
799 public void persist(final Object entity) throws DataAccessException {
800 executeWithNativeSession(new HibernateCallback() {
801 public Object doInHibernate(Session session) throws HibernateException {
802 checkWriteOperationAllowed(session);
803 session.persist(entity);
804 return null;
805 }
806 });
807 }
808
809 public void persist(final String entityName, final Object entity) throws DataAccessException {
810 executeWithNativeSession(new HibernateCallback() {
811 public Object doInHibernate(Session session) throws HibernateException {
812 checkWriteOperationAllowed(session);
813 session.persist(entityName, entity);
814 return null;
815 }
816 });
817 }
818
819 public Object merge(final Object entity) throws DataAccessException {
820 return executeWithNativeSession(new HibernateCallback() {
821 public Object doInHibernate(Session session) throws HibernateException {
822 checkWriteOperationAllowed(session);
823 return session.merge(entity);
824 }
825 });
826 }
827
828 public Object merge(final String entityName, final Object entity) throws DataAccessException {
829 return executeWithNativeSession(new HibernateCallback() {
830 public Object doInHibernate(Session session) throws HibernateException {
831 checkWriteOperationAllowed(session);
832 return session.merge(entityName, entity);
833 }
834 });
835 }
836
837 public void delete(Object entity) throws DataAccessException {
838 delete(entity, null);
839 }
840
841 public void delete(final Object entity, final LockMode lockMode) throws DataAccessException {
842 executeWithNativeSession(new HibernateCallback() {
843 public Object doInHibernate(Session session) throws HibernateException {
844 checkWriteOperationAllowed(session);
845 if (lockMode != null) {
846 session.lock(entity, lockMode);
847 }
848 session.delete(entity);
849 return null;
850 }
851 });
852 }
853
854 public void delete(String entityName, Object entity) throws DataAccessException {
855 delete(entityName, entity, null);
856 }
857
858 public void delete(final String entityName, final Object entity, final LockMode lockMode)
859 throws DataAccessException {
860
861 executeWithNativeSession(new HibernateCallback() {
862 public Object doInHibernate(Session session) throws HibernateException {
863 checkWriteOperationAllowed(session);
864 if (lockMode != null) {
865 session.lock(entityName, entity, lockMode);
866 }
867 session.delete(entityName, entity);
868 return null;
869 }
870 });
871 }
872
873 public void deleteAll(final Collection entities) throws DataAccessException {
874 executeWithNativeSession(new HibernateCallback() {
875 public Object doInHibernate(Session session) throws HibernateException {
876 checkWriteOperationAllowed(session);
877 for (Iterator it = entities.iterator(); it.hasNext();) {
878 session.delete(it.next());
879 }
880 return null;
881 }
882 });
883 }
884
885 public void flush() throws DataAccessException {
886 executeWithNativeSession(new HibernateCallback() {
887 public Object doInHibernate(Session session) throws HibernateException {
888 session.flush();
889 return null;
890 }
891 });
892 }
893
894 public void clear() throws DataAccessException {
895 executeWithNativeSession(new HibernateCallback() {
896 public Object doInHibernate(Session session) {
897 session.clear();
898 return null;
899 }
900 });
901 }
902
903
904 //-------------------------------------------------------------------------
905 // Convenience finder methods for HQL strings
906 //-------------------------------------------------------------------------
907
908 public List find(String queryString) throws DataAccessException {
909 return find(queryString, (Object[]) null);
910 }
911
912 public List find(String queryString, Object value) throws DataAccessException {
913 return find(queryString, new Object[] {value});
914 }
915
916 public List find(final String queryString, final Object[] values) throws DataAccessException {
917 return (List) executeWithNativeSession(new HibernateCallback() {
918 public Object doInHibernate(Session session) throws HibernateException {
919 Query queryObject = session.createQuery(queryString);
920 prepareQuery(queryObject);
921 if (values != null) {
922 for (int i = 0; i < values.length; i++) {
923 queryObject.setParameter(i, values[i]);
924 }
925 }
926 return queryObject.list();
927 }
928 });
929 }
930
931 public List findByNamedParam(String queryString, String paramName, Object value)
932 throws DataAccessException {
933
934 return findByNamedParam(queryString, new String[] {paramName}, new Object[] {value});
935 }
936
937 public List findByNamedParam(final String queryString, final String[] paramNames, final Object[] values)
938 throws DataAccessException {
939
940 if (paramNames.length != values.length) {
941 throw new IllegalArgumentException("Length of paramNames array must match length of values array");
942 }
943 return (List) executeWithNativeSession(new HibernateCallback() {
944 public Object doInHibernate(Session session) throws HibernateException {
945 Query queryObject = session.createQuery(queryString);
946 prepareQuery(queryObject);
947 if (values != null) {
948 for (int i = 0; i < values.length; i++) {
949 applyNamedParameterToQuery(queryObject, paramNames[i], values[i]);
950 }
951 }
952 return queryObject.list();
953 }
954 });
955 }
956
957 public List findByValueBean(final String queryString, final Object valueBean)
958 throws DataAccessException {
959
960 return (List) executeWithNativeSession(new HibernateCallback() {
961 public Object doInHibernate(Session session) throws HibernateException {
962 Query queryObject = session.createQuery(queryString);
963 prepareQuery(queryObject);
964 queryObject.setProperties(valueBean);
965 return queryObject.list();
966 }
967 });
968 }
969
970
971 //-------------------------------------------------------------------------
972 // Convenience finder methods for named queries
973 //-------------------------------------------------------------------------
974
975 public List findByNamedQuery(String queryName) throws DataAccessException {
976 return findByNamedQuery(queryName, (Object[]) null);
977 }
978
979 public List findByNamedQuery(String queryName, Object value) throws DataAccessException {
980 return findByNamedQuery(queryName, new Object[] {value});
981 }
982
983 public List findByNamedQuery(final String queryName, final Object[] values) throws DataAccessException {
984 return (List) executeWithNativeSession(new HibernateCallback() {
985 public Object doInHibernate(Session session) throws HibernateException {
986 Query queryObject = session.getNamedQuery(queryName);
987 prepareQuery(queryObject);
988 if (values != null) {
989 for (int i = 0; i < values.length; i++) {
990 queryObject.setParameter(i, values[i]);
991 }
992 }
993 return queryObject.list();
994 }
995 });
996 }
997
998 public List findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)
999 throws DataAccessException {
1000
1001 return findByNamedQueryAndNamedParam(queryName, new String[] {paramName}, new Object[] {value});
1002 }
1003
1004 public List findByNamedQueryAndNamedParam(
1005 final String queryName, final String[] paramNames, final Object[] values)
1006 throws DataAccessException {
1007
1008 if (paramNames != null && values != null && paramNames.length != values.length) {
1009 throw new IllegalArgumentException("Length of paramNames array must match length of values array");
1010 }
1011 return (List) executeWithNativeSession(new HibernateCallback() {
1012 public Object doInHibernate(Session session) throws HibernateException {
1013 Query queryObject = session.getNamedQuery(queryName);
1014 prepareQuery(queryObject);
1015 if (values != null) {
1016 for (int i = 0; i < values.length; i++) {
1017 applyNamedParameterToQuery(queryObject, paramNames[i], values[i]);
1018 }
1019 }
1020 return queryObject.list();
1021 }
1022 });
1023 }
1024
1025 public List findByNamedQueryAndValueBean(final String queryName, final Object valueBean)
1026 throws DataAccessException {
1027
1028 return (List) executeWithNativeSession(new HibernateCallback() {
1029 public Object doInHibernate(Session session) throws HibernateException {
1030 Query queryObject = session.getNamedQuery(queryName);
1031 prepareQuery(queryObject);
1032 queryObject.setProperties(valueBean);
1033 return queryObject.list();
1034 }
1035 });
1036 }
1037
1038
1039 //-------------------------------------------------------------------------
1040 // Convenience finder methods for detached criteria
1041 //-------------------------------------------------------------------------
1042
1043 public List findByCriteria(DetachedCriteria criteria) throws DataAccessException {
1044 return findByCriteria(criteria, -1, -1);
1045 }
1046
1047 public List findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults)
1048 throws DataAccessException {
1049
1050 Assert.notNull(criteria, "DetachedCriteria must not be null");
1051 return (List) executeWithNativeSession(new HibernateCallback() {
1052 public Object doInHibernate(Session session) throws HibernateException {
1053 Criteria executableCriteria = criteria.getExecutableCriteria(session);
1054 prepareCriteria(executableCriteria);
1055 if (firstResult >= 0) {
1056 executableCriteria.setFirstResult(firstResult);
1057 }
1058 if (maxResults > 0) {
1059 executableCriteria.setMaxResults(maxResults);
1060 }
1061 return executableCriteria.list();
1062 }
1063 });
1064 }
1065
1066 public List findByExample(Object exampleEntity) throws DataAccessException {
1067 return findByExample(null, exampleEntity, -1, -1);
1068 }
1069
1070 public List findByExample(String entityName, Object exampleEntity) throws DataAccessException {
1071 return findByExample(entityName, exampleEntity, -1, -1);
1072 }
1073
1074 public List findByExample(Object exampleEntity, int firstResult, int maxResults) throws DataAccessException {
1075 return findByExample(null, exampleEntity, firstResult, maxResults);
1076 }
1077
1078 public List findByExample(
1079 final String entityName, final Object exampleEntity, final int firstResult, final int maxResults)
1080 throws DataAccessException {
1081
1082 Assert.notNull(exampleEntity, "Example entity must not be null");
1083 return (List) executeWithNativeSession(new HibernateCallback() {
1084 public Object doInHibernate(Session session) throws HibernateException {
1085 Criteria executableCriteria = (entityName != null ?
1086 session.createCriteria(entityName) : session.createCriteria(exampleEntity.getClass()));
1087 executableCriteria.add(Example.create(exampleEntity));
1088 prepareCriteria(executableCriteria);
1089 if (firstResult >= 0) {
1090 executableCriteria.setFirstResult(firstResult);
1091 }
1092 if (maxResults > 0) {
1093 executableCriteria.setMaxResults(maxResults);
1094 }
1095 return executableCriteria.list();
1096 }
1097 });
1098 }
1099
1100
1101 //-------------------------------------------------------------------------
1102 // Convenience query methods for iteration and bulk updates/deletes
1103 //-------------------------------------------------------------------------
1104
1105 public Iterator iterate(String queryString) throws DataAccessException {
1106 return iterate(queryString, (Object[]) null);
1107 }
1108
1109 public Iterator iterate(String queryString, Object value) throws DataAccessException {
1110 return iterate(queryString, new Object[] {value});
1111 }
1112
1113 public Iterator iterate(final String queryString, final Object[] values) throws DataAccessException {
1114 return (Iterator) executeWithNativeSession(new HibernateCallback() {
1115 public Object doInHibernate(Session session) throws HibernateException {
1116 Query queryObject = session.createQuery(queryString);
1117 prepareQuery(queryObject);
1118 if (values != null) {
1119 for (int i = 0; i < values.length; i++) {
1120 queryObject.setParameter(i, values[i]);
1121 }
1122 }
1123 return queryObject.iterate();
1124 }
1125 });
1126 }
1127
1128 public void closeIterator(Iterator it) throws DataAccessException {
1129 try {
1130 Hibernate.close(it);
1131 }
1132 catch (HibernateException ex) {
1133 throw SessionFactoryUtils.convertHibernateAccessException(ex);
1134 }
1135 }
1136
1137 public int bulkUpdate(String queryString) throws DataAccessException {
1138 return bulkUpdate(queryString, (Object[]) null);
1139 }
1140
1141 public int bulkUpdate(String queryString, Object value) throws DataAccessException {
1142 return bulkUpdate(queryString, new Object[] {value});
1143 }
1144
1145 public int bulkUpdate(final String queryString, final Object[] values) throws DataAccessException {
1146 Integer updateCount = (Integer) executeWithNativeSession(new HibernateCallback() {
1147 public Object doInHibernate(Session session) throws HibernateException {
1148 Query queryObject = session.createQuery(queryString);
1149 prepareQuery(queryObject);
1150 if (values != null) {
1151 for (int i = 0; i < values.length; i++) {
1152 queryObject.setParameter(i, values[i]);
1153 }
1154 }
1155 return new Integer(queryObject.executeUpdate());
1156 }
1157 });
1158 return updateCount.intValue();
1159 }
1160
1161
1162 //-------------------------------------------------------------------------
1163 // Helper methods used by the operations above
1164 //-------------------------------------------------------------------------
1165
1166 /**
1167 * Check whether write operations are allowed on the given Session.
1168 * <p>Default implementation throws an InvalidDataAccessApiUsageException in
1169 * case of <code>FlushMode.NEVER/MANUAL</code>. Can be overridden in subclasses.
1170 * @param session current Hibernate Session
1171 * @throws InvalidDataAccessApiUsageException if write operations are not allowed
1172 * @see #setCheckWriteOperations
1173 * @see #getFlushMode()
1174 * @see #FLUSH_EAGER
1175 * @see org.hibernate.Session#getFlushMode()
1176 * @see org.hibernate.FlushMode#NEVER
1177 * @see org.hibernate.FlushMode#MANUAL
1178 */
1179 protected void checkWriteOperationAllowed(Session session) throws InvalidDataAccessApiUsageException {
1180 if (isCheckWriteOperations() && getFlushMode() != FLUSH_EAGER &&
1181 session.getFlushMode().lessThan(FlushMode.COMMIT)) {
1182 throw new InvalidDataAccessApiUsageException(
1183 "Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): "+
1184 "Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition.");
1185 }
1186 }
1187
1188 /**
1189 * Prepare the given Query object, applying cache settings and/or
1190 * a transaction timeout.
1191 * @param queryObject the Query object to prepare
1192 * @see #setCacheQueries
1193 * @see #setQueryCacheRegion
1194 * @see SessionFactoryUtils#applyTransactionTimeout
1195 */
1196 protected void prepareQuery(Query queryObject) {
1197 if (isCacheQueries()) {
1198 queryObject.setCacheable(true);
1199 if (getQueryCacheRegion() != null) {
1200 queryObject.setCacheRegion(getQueryCacheRegion());
1201 }
1202 }
1203 if (getFetchSize() > 0) {
1204 queryObject.setFetchSize(getFetchSize());
1205 }
1206 if (getMaxResults() > 0) {
1207 queryObject.setMaxResults(getMaxResults());
1208 }
1209 SessionFactoryUtils.applyTransactionTimeout(queryObject, getSessionFactory());
1210 }
1211
1212 /**
1213 * Prepare the given Criteria object, applying cache settings and/or
1214 * a transaction timeout.
1215 * @param criteria the Criteria object to prepare
1216 * @see #setCacheQueries
1217 * @see #setQueryCacheRegion
1218 * @see SessionFactoryUtils#applyTransactionTimeout
1219 */
1220 protected void prepareCriteria(Criteria criteria) {
1221 if (isCacheQueries()) {
1222 criteria.setCacheable(true);
1223 if (getQueryCacheRegion() != null) {
1224 criteria.setCacheRegion(getQueryCacheRegion());
1225 }
1226 }
1227 if (getFetchSize() > 0) {
1228 criteria.setFetchSize(getFetchSize());
1229 }
1230 if (getMaxResults() > 0) {
1231 criteria.setMaxResults(getMaxResults());
1232 }
1233 SessionFactoryUtils.applyTransactionTimeout(criteria, getSessionFactory());
1234 }
1235
1236 /**
1237 * Apply the given name parameter to the given Query object.
1238 * @param queryObject the Query object
1239 * @param paramName the name of the parameter
1240 * @param value the value of the parameter
1241 * @throws HibernateException if thrown by the Query object
1242 */
1243 protected void applyNamedParameterToQuery(Query queryObject, String paramName, Object value)
1244 throws HibernateException {
1245
1246 if (value instanceof Collection) {
1247 queryObject.setParameterList(paramName, (Collection) value);
1248 }
1249 else if (value instanceof Object[]) {
1250 queryObject.setParameterList(paramName, (Object[]) value);
1251 }
1252 else {
1253 queryObject.setParameter(paramName, value);
1254 }
1255 }
1256
1257
1258 /**
1259 * Invocation handler that suppresses close calls on Hibernate Sessions.
1260 * Also prepares returned Query and Criteria objects.
1261 * @see org.hibernate.Session#close
1262 */
1263 private class CloseSuppressingInvocationHandler implements InvocationHandler {
1264
1265 private final Session target;
1266
1267 public CloseSuppressingInvocationHandler(Session target) {
1268 this.target = target;
1269 }
1270
1271 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
1272 // Invocation on Session interface coming in...
1273
1274 if (method.getName().equals("equals")) {
1275 // Only consider equal when proxies are identical.
1276 return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);
1277 }
1278 else if (method.getName().equals("hashCode")) {
1279 // Use hashCode of Session proxy.
1280 return new Integer(System.identityHashCode(proxy));
1281 }
1282 else if (method.getName().equals("close")) {
1283 // Handle close method: suppress, not valid.
1284 return null;
1285 }
1286
1287 // Invoke method on target Session.
1288 try {
1289 Object retVal = method.invoke(this.target, args);
1290
1291 // If return value is a Query or Criteria, apply transaction timeout.
1292 // Applies to createQuery, getNamedQuery, createCriteria.
1293 if (retVal instanceof Query) {
1294 prepareQuery(((Query) retVal));
1295 }
1296 if (retVal instanceof Criteria) {
1297 prepareCriteria(((Criteria) retVal));
1298 }
1299
1300 return retVal;
1301 }
1302 catch (InvocationTargetException ex) {
1303 throw ex.getTargetException();
1304 }
1305 }
1306 }
1307
1308 }
Save This Page