- 浏览: 177977 次
- 性别:
- 来自: 杭州
文章分类
最新评论
-
lotnhiro:
学习了
hibernate.hbm.xml总结 -
final54:
这是Java 还是JavaScript
JavaScript上传图片 -
w156445045:
你这生成的是物理模型 不是ER图吧?
PowerDesigner生成SQL ER图 说明文档 -
四个石头:
哦,我以为是对源码的分析呢
jdbctemplate源码 -
cloudgamer:
我写了个兼容图片预览例子
可是也只支持ie和ff
图片上传预览问题
/* * Copyright 2002-2009 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.orm.hibernate3; import java.io.Serializable; import java.lang.reflect.InvocationHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.SQLException; import java.util.Collection; import java.util.Iterator; import java.util.List; import org.hibernate.Criteria; import org.hibernate.Filter; import org.hibernate.FlushMode; import org.hibernate.Hibernate; import org.hibernate.HibernateException; import org.hibernate.LockMode; import org.hibernate.Query; import org.hibernate.ReplicationMode; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.criterion.DetachedCriteria; import org.hibernate.criterion.Example; import org.hibernate.engine.SessionImplementor; import org.hibernate.event.EventSource; import org.springframework.dao.DataAccessException; import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.util.Assert; /** * Helper class that simplifies Hibernate data access code. Automatically * converts HibernateExceptions into DataAccessExceptions, following the * <code>org.springframework.dao</code> exception hierarchy. * * <p>The central method is <code>execute</code>, supporting Hibernate access code * implementing the {@link HibernateCallback} interface. It provides Hibernate Session * handling such that neither the HibernateCallback implementation nor the calling * code needs to explicitly care about retrieving/closing Hibernate Sessions, * or handling Session lifecycle exceptions. For typical single step actions, * there are various convenience methods (find, load, saveOrUpdate, delete). * * <p>Can be used within a service implementation via direct instantiation * with a SessionFactory reference, or get prepared in an application context * and given to services as bean reference. Note: The SessionFactory should * always be configured as bean in the application context, in the first case * given to the service directly, in the second case to the prepared template. * * <p><b>NOTE: As of Hibernate 3.0.1, transactional Hibernate access code can * also be coded in plain Hibernate style. Hence, for newly started projects, * consider adopting the standard Hibernate3 style of coding data access objects * instead, based on {@link org.hibernate.SessionFactory#getCurrentSession()}.</b> * * <p>This class can be considered as direct alternative to working with the raw * Hibernate3 Session API (through <code>SessionFactory.getCurrentSession()</code>). * The major advantage is its automatic conversion to DataAccessExceptions as well * as its capability to fall back to 'auto-commit' style behavior when used outside * of transactions. <b>Note that HibernateTemplate will perform its own Session * management, not participating in a custom Hibernate CurrentSessionContext * unless you explicitly switch {@link #setAllowCreate "allowCreate"} to "false".</b> * * <p>{@link LocalSessionFactoryBean} is the preferred way of obtaining a reference * to a specific Hibernate SessionFactory, at least in a non-EJB environment. * The Spring application context will manage its lifecycle, initializing and * shutting down the factory as part of the application. * * <p>Note that operations that return an Iterator (i.e. <code>iterate</code>) * are supposed to be used within Spring-driven or JTA-driven transactions * (with HibernateTransactionManager, JtaTransactionManager, or EJB CMT). * Else, the Iterator won't be able to read results from its ResultSet anymore, * as the underlying Hibernate Session will already have been closed. * * <p>Lazy loading will also just work with an open Hibernate Session, * either within a transaction or within OpenSessionInViewFilter/Interceptor. * Furthermore, some operations just make sense within transactions, * for example: <code>contains</code>, <code>evict</code>, <code>lock</code>, * <code>flush</code>, <code>clear</code>. * * @author Juergen Hoeller * @since 1.2 * @see #setSessionFactory * @see HibernateCallback * @see org.hibernate.Session * @see LocalSessionFactoryBean * @see HibernateTransactionManager * @see org.springframework.transaction.jta.JtaTransactionManager * @see org.springframework.orm.hibernate3.support.OpenSessionInViewFilter * @see org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor */ public class HibernateTemplate extends HibernateAccessor implements HibernateOperations { private boolean allowCreate = true; private boolean alwaysUseNewSession = false; private boolean exposeNativeSession = false; private boolean checkWriteOperations = true; private boolean cacheQueries = false; private String queryCacheRegion; private int fetchSize = 0; private int maxResults = 0; /** * Create a new HibernateTemplate instance. */ public HibernateTemplate() { } /** * Create a new HibernateTemplate instance. * @param sessionFactory SessionFactory to create Sessions */ public HibernateTemplate(SessionFactory sessionFactory) { setSessionFactory(sessionFactory); afterPropertiesSet(); } /** * Create a new HibernateTemplate instance. * @param sessionFactory SessionFactory to create Sessions * @param allowCreate if a non-transactional Session should be created when no * transactional Session can be found for the current thread */ public HibernateTemplate(SessionFactory sessionFactory, boolean allowCreate) { setSessionFactory(sessionFactory); setAllowCreate(allowCreate); afterPropertiesSet(); } /** * Set if a new {@link Session} should be created when no transactional * <code>Session</code> can be found for the current thread. * The default value is <code>true</code>. * <p><code>HibernateTemplate</code> is aware of a corresponding * <code>Session</code> bound to the current thread, for example when using * {@link HibernateTransactionManager}. If <code>allowCreate</code> is * <code>true</code>, a new non-transactional <code>Session</code> will be * created if none is found, which needs to be closed at the end of the operation. * If <code>false</code>, an {@link IllegalStateException} will get thrown in * this case. * <p><b>NOTE: As of Spring 2.5, switching <code>allowCreate</code> * to <code>false</code> will delegate to Hibernate's * {@link org.hibernate.SessionFactory#getCurrentSession()} method,</b> * which - with Spring-based setup - will by default delegate to Spring's * <code>SessionFactoryUtils.getSession(sessionFactory, false)</code>. * This mode also allows for custom Hibernate CurrentSessionContext strategies * to be plugged in, whereas <code>allowCreate</code> set to <code>true</code> * will always use a Spring-managed Hibernate Session. * @see SessionFactoryUtils#getSession(SessionFactory, boolean) */ public void setAllowCreate(boolean allowCreate) { this.allowCreate = allowCreate; } /** * Return if a new Session should be created if no thread-bound found. */ public boolean isAllowCreate() { return this.allowCreate; } /** * Set whether to always use a new Hibernate Session for this template. * Default is "false"; if activated, all operations on this template will * work on a new Hibernate Session even in case of a pre-bound Session * (for example, within a transaction or OpenSessionInViewFilter). * <p>Within a transaction, a new Hibernate Session used by this template * will participate in the transaction through using the same JDBC * Connection. In such a scenario, multiple Sessions will participate * in the same database transaction. * <p>Turn this on for operations that are supposed to always execute * independently, without side effects caused by a shared Hibernate Session. */ public void setAlwaysUseNewSession(boolean alwaysUseNewSession) { this.alwaysUseNewSession = alwaysUseNewSession; } /** * Return whether to always use a new Hibernate Session for this template. */ public boolean isAlwaysUseNewSession() { return this.alwaysUseNewSession; } /** * Set whether to expose the native Hibernate Session to * HibernateCallback code. * <p>Default is "false": a Session proxy will be returned, suppressing * <code>close</code> calls and automatically applying query cache * settings and transaction timeouts. * @see HibernateCallback * @see org.hibernate.Session * @see #setCacheQueries * @see #setQueryCacheRegion * @see #prepareQuery * @see #prepareCriteria */ public void setExposeNativeSession(boolean exposeNativeSession) { this.exposeNativeSession = exposeNativeSession; } /** * Return whether to expose the native Hibernate Session to * HibernateCallback code, or rather a Session proxy. */ public boolean isExposeNativeSession() { return this.exposeNativeSession; } /** * Set whether to check that the Hibernate Session is not in read-only mode * in case of write operations (save/update/delete). * <p>Default is "true", for fail-fast behavior when attempting write operations * within a read-only transaction. Turn this off to allow save/update/delete * on a Session with flush mode NEVER. * @see #setFlushMode * @see #checkWriteOperationAllowed * @see org.springframework.transaction.TransactionDefinition#isReadOnly */ public void setCheckWriteOperations(boolean checkWriteOperations) { this.checkWriteOperations = checkWriteOperations; } /** * Return whether to check that the Hibernate Session is not in read-only * mode in case of write operations (save/update/delete). */ public boolean isCheckWriteOperations() { return this.checkWriteOperations; } /** * Set whether to cache all queries executed by this template. * <p>If this is "true", all Query and Criteria objects created by * this template will be marked as cacheable (including all * queries through find methods). * <p>To specify the query region to be used for queries cached * by this template, set the "queryCacheRegion" property. * @see #setQueryCacheRegion * @see org.hibernate.Query#setCacheable * @see org.hibernate.Criteria#setCacheable */ public void setCacheQueries(boolean cacheQueries) { this.cacheQueries = cacheQueries; } /** * Return whether to cache all queries executed by this template. */ public boolean isCacheQueries() { return this.cacheQueries; } /** * Set the name of the cache region for queries executed by this template. * <p>If this is specified, it will be applied to all Query and Criteria objects * created by this template (including all queries through find methods). * <p>The cache region will not take effect unless queries created by this * template are configured to be cached via the "cacheQueries" property. * @see #setCacheQueries * @see org.hibernate.Query#setCacheRegion * @see org.hibernate.Criteria#setCacheRegion */ public void setQueryCacheRegion(String queryCacheRegion) { this.queryCacheRegion = queryCacheRegion; } /** * Return the name of the cache region for queries executed by this template. */ public String getQueryCacheRegion() { return this.queryCacheRegion; } /** * Set the fetch size for this HibernateTemplate. This is important for processing * large result sets: Setting this higher than the default value will increase * processing speed at the cost of memory consumption; setting this lower can * avoid transferring row data that will never be read by the application. * <p>Default is 0, indicating to use the JDBC driver's default. */ public void setFetchSize(int fetchSize) { this.fetchSize = fetchSize; } /** * Return the fetch size specified for this HibernateTemplate. */ public int getFetchSize() { return this.fetchSize; } /** * Set the maximum number of rows for this HibernateTemplate. This is important * for processing subsets of large result sets, avoiding to read and hold * the entire result set in the database or in the JDBC driver if we're * never interested in the entire result in the first place (for example, * when performing searches that might return a large number of matches). * <p>Default is 0, indicating to use the JDBC driver's default. */ public void setMaxResults(int maxResults) { this.maxResults = maxResults; } /** * Return the maximum number of rows specified for this HibernateTemplate. */ public int getMaxResults() { return this.maxResults; } public <T> T execute(HibernateCallback<T> action) throws DataAccessException { return doExecute(action, false, false); } public List executeFind(HibernateCallback<?> action) throws DataAccessException { Object result = doExecute(action, false, false); if (result != null && !(result instanceof List)) { throw new InvalidDataAccessApiUsageException( "Result object returned from HibernateCallback isn't a List: [" + result + "]"); } return (List) result; } /** * Execute the action specified by the given action object within a * new {@link org.hibernate.Session}. * <p>This execute variant overrides the template-wide * {@link #isAlwaysUseNewSession() "alwaysUseNewSession"} setting. * @param action callback object that specifies the Hibernate action * @return a result object returned by the action, or <code>null</code> * @throws org.springframework.dao.DataAccessException in case of Hibernate errors */ public <T> T executeWithNewSession(HibernateCallback<T> action) { return doExecute(action, true, false); } /** * Execute the action specified by the given action object within a * native {@link org.hibernate.Session}. * <p>This execute variant overrides the template-wide * {@link #isExposeNativeSession() "exposeNativeSession"} setting. * @param action callback object that specifies the Hibernate action * @return a result object returned by the action, or <code>null</code> * @throws org.springframework.dao.DataAccessException in case of Hibernate errors */ public <T> T executeWithNativeSession(HibernateCallback<T> action) { return doExecute(action, false, true); } /** * Execute the action specified by the given action object within a Session. * @param action callback object that specifies the Hibernate action * @param enforceNewSession whether to enforce a new Session for this template * even if there is a pre-bound transactional Session * @param enforceNativeSession whether to enforce exposure of the native * Hibernate Session to callback code * @return a result object returned by the action, or <code>null</code> * @throws org.springframework.dao.DataAccessException in case of Hibernate errors */ protected <T> T doExecute(HibernateCallback<T> action, boolean enforceNewSession, boolean enforceNativeSession) throws DataAccessException { Assert.notNull(action, "Callback object must not be null"); Session session = (enforceNewSession ? SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession()); boolean existingTransaction = (!enforceNewSession && (!isAllowCreate() || SessionFactoryUtils.isSessionTransactional(session, getSessionFactory()))); if (existingTransaction) { logger.debug("Found thread-bound Session for HibernateTemplate"); } FlushMode previousFlushMode = null; try { previousFlushMode = applyFlushMode(session, existingTransaction); enableFilters(session); Session sessionToExpose = (enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session)); T result = action.doInHibernate(sessionToExpose); flushIfNecessary(session, existingTransaction); return result; } catch (HibernateException ex) { throw convertHibernateAccessException(ex); } catch (SQLException ex) { throw convertJdbcAccessException(ex); } catch (RuntimeException ex) { // Callback code threw application exception... throw ex; } finally { if (existingTransaction) { logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate"); disableFilters(session); if (previousFlushMode != null) { session.setFlushMode(previousFlushMode); } } else { // Never use deferred close for an explicitly new Session. if (isAlwaysUseNewSession()) { SessionFactoryUtils.closeSession(session); } else { SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory()); } } } } /** * Return a Session for use by this template. * <p>Returns a new Session in case of "alwaysUseNewSession" (using the same * JDBC Connection as a transactional Session, if applicable), a pre-bound * Session in case of "allowCreate" turned off, and a pre-bound or new Session * otherwise (new only if no transactional or otherwise pre-bound Session exists). * @return the Session to use (never <code>null</code>) * @see SessionFactoryUtils#getSession * @see SessionFactoryUtils#getNewSession * @see #setAlwaysUseNewSession * @see #setAllowCreate */ protected Session getSession() { if (isAlwaysUseNewSession()) { return SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()); } else if (isAllowCreate()) { return SessionFactoryUtils.getSession( getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator()); } else if (SessionFactoryUtils.hasTransactionalSession(getSessionFactory())) { return SessionFactoryUtils.getSession(getSessionFactory(), false); } else { try { return getSessionFactory().getCurrentSession(); } catch (HibernateException ex) { throw new DataAccessResourceFailureException("Could not obtain current Hibernate Session", ex); } } } /** * Create a close-suppressing proxy for the given Hibernate Session. * The proxy also prepares returned Query and Criteria objects. * @param session the Hibernate Session to create a proxy for * @return the Session proxy * @see org.hibernate.Session#close() * @see #prepareQuery * @see #prepareCriteria */ protected Session createSessionProxy(Session session) { Class[] sessionIfcs = null; Class mainIfc = (session instanceof org.hibernate.classic.Session ? org.hibernate.classic.Session.class : Session.class); if (session instanceof EventSource) { sessionIfcs = new Class[] {mainIfc, EventSource.class}; } else if (session instanceof SessionImplementor) { sessionIfcs = new Class[] {mainIfc, SessionImplementor.class}; } else { sessionIfcs = new Class[] {mainIfc}; } return (Session) Proxy.newProxyInstance( session.getClass().getClassLoader(), sessionIfcs, new CloseSuppressingInvocationHandler(session)); } //------------------------------------------------------------------------- // Convenience methods for loading individual objects //------------------------------------------------------------------------- public <T> T get(Class<T> entityClass, Serializable id) throws DataAccessException { return get(entityClass, id, null); } public <T> T get(final Class<T> entityClass, final Serializable id, final LockMode lockMode) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<T>() { @SuppressWarnings("unchecked") public T doInHibernate(Session session) throws HibernateException { if (lockMode != null) { return (T) session.get(entityClass, id, lockMode); } else { return (T) session.get(entityClass, id); } } }); } public Object get(String entityName, Serializable id) throws DataAccessException { return get(entityName, id, null); } public Object get(final String entityName, final Serializable id, final LockMode lockMode) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { if (lockMode != null) { return session.get(entityName, id, lockMode); } else { return session.get(entityName, id); } } }); } public <T> T load(Class<T> entityClass, Serializable id) throws DataAccessException { return load(entityClass, id, null); } public <T> T load(final Class<T> entityClass, final Serializable id, final LockMode lockMode) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<T>() { @SuppressWarnings("unchecked") public T doInHibernate(Session session) throws HibernateException { if (lockMode != null) { return (T) session.load(entityClass, id, lockMode); } else { return (T) session.load(entityClass, id); } } }); } public Object load(String entityName, Serializable id) throws DataAccessException { return load(entityName, id, null); } public Object load(final String entityName, final Serializable id, final LockMode lockMode) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { if (lockMode != null) { return session.load(entityName, id, lockMode); } else { return session.load(entityName, id); } } }); } public <T> List<T> loadAll(final Class<T> entityClass) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<List<T>>() { @SuppressWarnings("unchecked") public List<T> doInHibernate(Session session) throws HibernateException { Criteria criteria = session.createCriteria(entityClass); criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); prepareCriteria(criteria); return criteria.list(); } }); } public void load(final Object entity, final Serializable id) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { session.load(entity, id); return null; } }); } public void refresh(final Object entity) throws DataAccessException { refresh(entity, null); } public void refresh(final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { if (lockMode != null) { session.refresh(entity, lockMode); } else { session.refresh(entity); } return null; } }); } public boolean contains(final Object entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Boolean>() { public Boolean doInHibernate(Session session) { return session.contains(entity); } }); } public void evict(final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { session.evict(entity); return null; } }); } public void initialize(Object proxy) throws DataAccessException { try { Hibernate.initialize(proxy); } catch (HibernateException ex) { throw SessionFactoryUtils.convertHibernateAccessException(ex); } } public Filter enableFilter(String filterName) throws IllegalStateException { Session session = SessionFactoryUtils.getSession(getSessionFactory(), false); Filter filter = session.getEnabledFilter(filterName); if (filter == null) { filter = session.enableFilter(filterName); } return filter; } //------------------------------------------------------------------------- // Convenience methods for storing individual objects //------------------------------------------------------------------------- public void lock(final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { session.lock(entity, lockMode); return null; } }); } public void lock(final String entityName, final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { session.lock(entityName, entity, lockMode); return null; } }); } public Serializable save(final Object entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Serializable>() { public Serializable doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); return session.save(entity); } }); } public Serializable save(final String entityName, final Object entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Serializable>() { public Serializable doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); return session.save(entityName, entity); } }); } public void update(Object entity) throws DataAccessException { update(entity, null); } public void update(final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.update(entity); if (lockMode != null) { session.lock(entity, lockMode); } return null; } }); } public void update(String entityName, Object entity) throws DataAccessException { update(entityName, entity, null); } public void update(final String entityName, final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.update(entityName, entity); if (lockMode != null) { session.lock(entity, lockMode); } return null; } }); } public void saveOrUpdate(final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.saveOrUpdate(entity); return null; } }); } public void saveOrUpdate(final String entityName, final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.saveOrUpdate(entityName, entity); return null; } }); } public void saveOrUpdateAll(final Collection entities) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); for (Object entity : entities) { session.saveOrUpdate(entity); } return null; } }); } public void replicate(final Object entity, final ReplicationMode replicationMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.replicate(entity, replicationMode); return null; } }); } public void replicate(final String entityName, final Object entity, final ReplicationMode replicationMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.replicate(entityName, entity, replicationMode); return null; } }); } public void persist(final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.persist(entity); return null; } }); } public void persist(final String entityName, final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.persist(entityName, entity); return null; } }); } public <T> T merge(final T entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<T>() { @SuppressWarnings("unchecked") public T doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); return (T) session.merge(entity); } }); } public <T> T merge(final String entityName, final T entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<T>() { @SuppressWarnings("unchecked") public T doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); return (T) session.merge(entityName, entity); } }); } public void delete(Object entity) throws DataAccessException { delete(entity, null); } public void delete(final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); if (lockMode != null) { session.lock(entity, lockMode); } session.delete(entity); return null; } }); } public void delete(String entityName, Object entity) throws DataAccessException { delete(entityName, entity, null); } public void delete(final String entityName, final Object entity, final LockMode lockMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); if (lockMode != null) { session.lock(entityName, entity, lockMode); } session.delete(entityName, entity); return null; } }); } public void deleteAll(final Collection entities) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); for (Object entity : entities) { session.delete(entity); } return null; } }); } public void flush() throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) throws HibernateException { session.flush(); return null; } }); } public void clear() throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { public Object doInHibernate(Session session) { session.clear(); return null; } }); } //------------------------------------------------------------------------- // Convenience finder methods for HQL strings //------------------------------------------------------------------------- public List find(String queryString) throws DataAccessException { return find(queryString, (Object[]) null); } public List find(String queryString, Object value) throws DataAccessException { return find(queryString, new Object[] {value}); } public List find(final String queryString, final Object... values) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Query queryObject = session.createQuery(queryString); prepareQuery(queryObject); if (values != null) { for (int i = 0; i < values.length; i++) { queryObject.setParameter(i, values[i]); } } return queryObject.list(); } }); } public List findByNamedParam(String queryString, String paramName, Object value) throws DataAccessException { return findByNamedParam(queryString, new String[] {paramName}, new Object[] {value}); } public List findByNamedParam(final String queryString, final String[] paramNames, final Object[] values) throws DataAccessException { if (paramNames.length != values.length) { throw new IllegalArgumentException("Length of paramNames array must match length of values array"); } return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Query queryObject = session.createQuery(queryString); prepareQuery(queryObject); if (values != null) { for (int i = 0; i < values.length; i++) { applyNamedParameterToQuery(queryObject, paramNames[i], values[i]); } } return queryObject.list(); } }); } public List findByValueBean(final String queryString, final Object valueBean) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Query queryObject = session.createQuery(queryString); prepareQuery(queryObject); queryObject.setProperties(valueBean); return queryObject.list(); } }); } //------------------------------------------------------------------------- // Convenience finder methods for named queries //------------------------------------------------------------------------- public List findByNamedQuery(String queryName) throws DataAccessException { return findByNamedQuery(queryName, (Object[]) null); } public List findByNamedQuery(String queryName, Object value) throws DataAccessException { return findByNamedQuery(queryName, new Object[] {value}); } public List findByNamedQuery(final String queryName, final Object... values) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Query queryObject = session.getNamedQuery(queryName); prepareQuery(queryObject); if (values != null) { for (int i = 0; i < values.length; i++) { queryObject.setParameter(i, values[i]); } } return queryObject.list(); } }); } public List findByNamedQueryAndNamedParam(String queryName, String paramName, Object value) throws DataAccessException { return findByNamedQueryAndNamedParam(queryName, new String[] {paramName}, new Object[] {value}); } public List findByNamedQueryAndNamedParam( final String queryName, final String[] paramNames, final Object[] values) throws DataAccessException { if (paramNames != null && values != null && paramNames.length != values.length) { throw new IllegalArgumentException("Length of paramNames array must match length of values array"); } return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Query queryObject = session.getNamedQuery(queryName); prepareQuery(queryObject); if (values != null) { for (int i = 0; i < values.length; i++) { applyNamedParameterToQuery(queryObject, paramNames[i], values[i]); } } return queryObject.list(); } }); } public List findByNamedQueryAndValueBean(final String queryName, final Object valueBean) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Query queryObject = session.getNamedQuery(queryName); prepareQuery(queryObject); queryObject.setProperties(valueBean); return queryObject.list(); } }); } //------------------------------------------------------------------------- // Convenience finder methods for detached criteria //------------------------------------------------------------------------- public List findByCriteria(DetachedCriteria criteria) throws DataAccessException { return findByCriteria(criteria, -1, -1); } public List findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults) throws DataAccessException { Assert.notNull(criteria, "DetachedCriteria must not be null"); return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Criteria executableCriteria = criteria.getExecutableCriteria(session); prepareCriteria(executableCriteria); if (firstResult >= 0) { executableCriteria.setFirstResult(firstResult); } if (maxResults > 0) { executableCriteria.setMaxResults(maxResults); } return executableCriteria.list(); } }); } public List findByExample(Object exampleEntity) throws DataAccessException { return findByExample(null, exampleEntity, -1, -1); } public List findByExample(String entityName, Object exampleEntity) throws DataAccessException { return findByExample(entityName, exampleEntity, -1, -1); } public List findByExample(Object exampleEntity, int firstResult, int maxResults) throws DataAccessException { return findByExample(null, exampleEntity, firstResult, maxResults); } public List findByExample( final String entityName, final Object exampleEntity, final int firstResult, final int maxResults) throws DataAccessException { Assert.notNull(exampleEntity, "Example entity must not be null"); return executeWithNativeSession(new HibernateCallback<List>() { public List doInHibernate(Session session) throws HibernateException { Criteria executableCriteria = (entityName != null ? session.createCriteria(entityName) : session.createCriteria(exampleEntity.getClass())); executableCriteria.add(Example.create(exampleEntity)); prepareCriteria(executableCriteria); if (firstResult >= 0) { executableCriteria.setFirstResult(firstResult); } if (maxResults > 0) { executableCriteria.setMaxResults(maxResults); } return executableCriteria.list(); } }); } //------------------------------------------------------------------------- // Convenience query methods for iteration and bulk updates/deletes //------------------------------------------------------------------------- public Iterator iterate(String queryString) throws DataAccessException { return iterate(queryString, (Object[]) null); } public Iterator iterate(String queryString, Object value) throws DataAccessException { return iterate(queryString, new Object[] {value}); } public Iterator iterate(final String queryString, final Object... values) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Iterator>() { public Iterator doInHibernate(Session session) throws HibernateException { Query queryObject = session.createQuery(queryString); prepareQuery(queryObject); if (values != null) { for (int i = 0; i < values.length; i++) { queryObject.setParameter(i, values[i]); } } return queryObject.iterate(); } }); } public void closeIterator(Iterator it) throws DataAccessException { try { Hibernate.close(it); } catch (HibernateException ex) { throw SessionFactoryUtils.convertHibernateAccessException(ex); } } public int bulkUpdate(String queryString) throws DataAccessException { return bulkUpdate(queryString, (Object[]) null); } public int bulkUpdate(String queryString, Object value) throws DataAccessException { return bulkUpdate(queryString, new Object[] {value}); } public int bulkUpdate(final String queryString, final Object... values) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Integer>() { public Integer doInHibernate(Session session) throws HibernateException { Query queryObject = session.createQuery(queryString); prepareQuery(queryObject); if (values != null) { for (int i = 0; i < values.length; i++) { queryObject.setParameter(i, values[i]); } } return queryObject.executeUpdate(); } }); } //------------------------------------------------------------------------- // Helper methods used by the operations above //------------------------------------------------------------------------- /** * Check whether write operations are allowed on the given Session. * <p>Default implementation throws an InvalidDataAccessApiUsageException in * case of <code>FlushMode.MANUAL</code>. Can be overridden in subclasses. * @param session current Hibernate Session * @throws InvalidDataAccessApiUsageException if write operations are not allowed * @see #setCheckWriteOperations * @see #getFlushMode() * @see #FLUSH_EAGER * @see org.hibernate.Session#getFlushMode() * @see org.hibernate.FlushMode#MANUAL */ protected void checkWriteOperationAllowed(Session session) throws InvalidDataAccessApiUsageException { if (isCheckWriteOperations() && getFlushMode() != FLUSH_EAGER && session.getFlushMode().lessThan(FlushMode.COMMIT)) { throw new InvalidDataAccessApiUsageException( "Write operations are not allowed in read-only mode (FlushMode.MANUAL): "+ "Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition."); } } /** * Prepare the given Query object, applying cache settings and/or * a transaction timeout. * @param queryObject the Query object to prepare * @see #setCacheQueries * @see #setQueryCacheRegion * @see SessionFactoryUtils#applyTransactionTimeout */ protected void prepareQuery(Query queryObject) { if (isCacheQueries()) { queryObject.setCacheable(true); if (getQueryCacheRegion() != null) { queryObject.setCacheRegion(getQueryCacheRegion()); } } if (getFetchSize() > 0) { queryObject.setFetchSize(getFetchSize()); } if (getMaxResults() > 0) { queryObject.setMaxResults(getMaxResults()); } SessionFactoryUtils.applyTransactionTimeout(queryObject, getSessionFactory()); } /** * Prepare the given Criteria object, applying cache settings and/or * a transaction timeout. * @param criteria the Criteria object to prepare * @see #setCacheQueries * @see #setQueryCacheRegion * @see SessionFactoryUtils#applyTransactionTimeout */ protected void prepareCriteria(Criteria criteria) { if (isCacheQueries()) { criteria.setCacheable(true); if (getQueryCacheRegion() != null) { criteria.setCacheRegion(getQueryCacheRegion()); } } if (getFetchSize() > 0) { criteria.setFetchSize(getFetchSize()); } if (getMaxResults() > 0) { criteria.setMaxResults(getMaxResults()); } SessionFactoryUtils.applyTransactionTimeout(criteria, getSessionFactory()); } /** * Apply the given name parameter to the given Query object. * @param queryObject the Query object * @param paramName the name of the parameter * @param value the value of the parameter * @throws HibernateException if thrown by the Query object */ protected void applyNamedParameterToQuery(Query queryObject, String paramName, Object value) throws HibernateException { if (value instanceof Collection) { queryObject.setParameterList(paramName, (Collection) value); } else if (value instanceof Object[]) { queryObject.setParameterList(paramName, (Object[]) value); } else { queryObject.setParameter(paramName, value); } } /** * Invocation handler that suppresses close calls on Hibernate Sessions. * Also prepares returned Query and Criteria objects. * @see org.hibernate.Session#close */ private class CloseSuppressingInvocationHandler implements InvocationHandler { private final Session target; public CloseSuppressingInvocationHandler(Session target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // Invocation on Session interface coming in... if (method.getName().equals("equals")) { // Only consider equal when proxies are identical. return (proxy == args[0]); } else if (method.getName().equals("hashCode")) { // Use hashCode of Session proxy. return System.identityHashCode(proxy); } else if (method.getName().equals("close")) { // Handle close method: suppress, not valid. return null; } // Invoke method on target Session. try { Object retVal = method.invoke(this.target, args); // If return value is a Query or Criteria, apply transaction timeout. // Applies to createQuery, getNamedQuery, createCriteria. if (retVal instanceof Query) { prepareQuery(((Query) retVal)); } if (retVal instanceof Criteria) { prepareCriteria(((Criteria) retVal)); } return retVal; } catch (InvocationTargetException ex) { throw ex.getTargetException(); } } } }
发表评论
-
Spring配置事务
2009-06-10 14:04 1257在Spring中,通过实现org.springframewor ... -
Spring配置事务在DAO层和业务逻辑层
2009-06-10 10:57 798Spring通过AOP实现声明式事务管理。通常通过Transa ... -
No Hibernate Session bound to thread
2009-06-10 10:55 5758getHibernateTemplate().getSessi ... -
jdbctemplate源码
2009-06-08 08:44 3997import java.lang.reflect.Invoca ... -
Spring的事务
2009-05-27 15:05 17986.3 Spring的事务 Spring的事务管理不需与任 ... -
Twelve Best Practices For Spring XML Configuration
2009-05-27 14:54 1304Spring is a powerful Java appli ...
相关推荐
源代码中,`JdbcTemplate`和`SimpleJdbcInsert`简化了JDBC操作,`HibernateTemplate`和`SessionFactoryBean`为Hibernate提供了便捷的封装。对于NoSQL数据库,Spring Data提供了统一的访问接口。 Spring Web模块包含...
这个“Spring+hibernate整合源代码”应该包含了实现上述整合步骤的示例代码,可以作为学习和参考的资源。通过学习和实践这些代码,你可以更好地理解和掌握 Spring 和 Hibernate 整合的细节,提升你的 Java Web 开发...
通过使用`HibernateTemplate`,可以减少大量重复性的代码编写工作,同时提高代码的可维护性和可读性。 #### 二、HibernateTemplate的使用场景 1. **基础数据访问操作**:如查询、插入、更新、删除等常见数据库操作...
《深入解析Hr人力资源管理系统源代码:基于Struts2+Spring+Hibernate的集成实践》 在信息化时代,人力资源管理系统的应用已经成为企业管理的核心组成部分。本文将深入探讨一款名为“Hr人力资源管理系统”的源代码,...
### MySQL-JDBC-Spring源代码分析 #### 一、引言 MySQL-JDBC与Spring框架的结合,在现代Java企业级应用开发中极为常见。通过Spring框架管理数据访问层(DAO层),可以极大地简化数据库操作,并提供一致的异常处理...
源代码分析对于深入理解其工作原理、优化应用性能以及进行二次开发至关重要。让我们一起深入探究Spring源码中的关键知识点。 首先,Spring的核心组件之一是IoC容器。IoC容器通过反转控制权,使得对象的创建和依赖...
【hibernate和spring源代码】的分析与详解 Hibernate是一个强大的对象关系映射(ORM)框架,它在Java开发中被广泛使用,为开发者提供了便捷的数据持久化服务。3.3.2.GA版本是Hibernate的一个稳定版本,它包含了对...
本篇文章将详细探讨Hibernate3与Spring2.5.6的源代码,帮助开发者深入理解这两个框架的核心机制及其整合方式。 一、Hibernate3:持久层的革命者 Hibernate3是一款优秀的对象关系映射(ORM)框架,它极大地简化了...
在这里,我们将深入探讨Spring 2.5.6源代码和API中的一些重要知识点。 1. **依赖注入(Dependency Injection, DI)**:Spring的核心特性之一就是依赖注入,它允许开发者通过配置文件或注解来管理对象之间的依赖关系...
使用HibernateTemplate可以简化代码,避免直接与Session对象打交道,减少出错的可能性。 3. Spring的依赖注入:DI是Spring框架的核心特性之一,它允许我们在不直接实例化对象的情况下,通过配置文件或注解来管理...
这个“SSH的多表联合源代码”很可能是为了展示如何在SSH框架下实现数据库中的多表关联查询和操作。下面将详细解释SSH框架的各个组成部分以及它们在多表联合操作中的应用。 1. **Struts2**:这是一个基于MVC设计模式...
【Java网盘项目源代码】是一个基于SSH(Spring、Struts、Hibernate)框架开发的Java应用程序,用于实现网络存储服务,允许用户上传、下载、管理他们的文件。SSH框架是Java Web开发中的常用技术栈,结合了Spring的...
在 JavaEE 应用中,使用 SSH 框架进行源代码开发时,通常会涉及到对 Hibernate 的使用。Hibernate 提供了 HibernateDaoSupport 和 HibernateTemplate 两个工具类来简化数据库操作。 HibernateDaoSupport 是 Spring ...
这个源代码库对于初学者来说是一个宝贵的资源,可以帮助他们理解和掌握这些技术的集成应用。 首先,我们来看ExtJS。ExtJS是一个强大的JavaScript库,用于构建富客户端的Web应用。它提供了丰富的组件库,如表格、...
这个压缩包文件包含了该书作者在书中所用到的所有源代码示例,是学习和深入理解Spring框架的重要参考资料。 1. **依赖注入(Dependency Injection, DI)**:Spring的核心特性之一,通过DI,对象之间的依赖关系被外部...
**S2SH框架整合源代码详解** S2SH框架,全称为Struts2 + Spring + Hibernate,是Java Web开发中的经典组合,常用于构建企业级应用。这个框架整合旨在为初学者提供一个易于理解的增删改查(CRUD)功能实现,帮助他们...
这本"Struts2+Spring3+Hibernate框架技术精讲与整合案例"书籍及源代码提供了深入理解这三大框架以及它们如何相互集成的宝贵资源。 Struts2是MVC(Model-View-Controller)架构的一个实现,主要用于控制应用程序的...
本源代码包"myeclipse整合spring和hibernate和struts的源代码"正是这样一个典型的Java企业级应用集成示例。下面将详细介绍这三个框架的整合方式以及它们各自的核心功能。 1. **Spring框架**:Spring是一个开源的...