@Bean public HibernateTransactionManager transactionManager() { HibernateTransactionManager transactionManager = new HibernateTransactionManager(); transactionManager.setSessionFactory(sessionFactory().getObject()); return transactionManager; }
@Bean public LocalSessionFactoryBean sessionFactory() { LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean(); sessionFactoryBean.setDataSource(dataSource()); sessionFactoryBean.setPackagesToScan(ENTITYMANAGER_PACKAGES_TO_SCAN); Properties hibernateProperties = new Properties(); hibernateProperties.put("hibernate.dialect", HIBERNATE_DIALECT); hibernateProperties.put("hibernate.show_sql", HIBERNATE_SHOW_SQL); hibernateProperties.put("hibernate.hbm2ddl.auto", HIBERNATE_HBM2DDL_AUTO); sessionFactoryBean.setHibernateProperties(hibernateProperties); return sessionFactoryBean; }
/** * @see org.springframework.orm.hibernate3.LocalSessionFactoryBean#destroy() */ @Override public void destroy() throws HibernateException { try { super.destroy(); } catch (IllegalStateException e) { // ignore errors sometimes thrown by the CacheManager trying to shut down twice // see net.sf.ehcache.CacheManager#removeShutdownHook() } }
/** * Collect packages to scan that are set in core and for tests in modules. * <p> * It adds to the set instead of overwriting it with each call. */ @Override public void setPackagesToScan(String... packagesToScan) { this.packagesToScan.addAll(Arrays.asList(packagesToScan)); super.setPackagesToScan(this.packagesToScan.toArray(new String[0])); }
/** * @see org.openmrs.api.context.Context#closeSession() */ @Override public void closeSession() { log.debug("HibernateContext: closing Hibernate Session"); if (!participate) { log.debug("Unbinding session from synchronization manager (" + sessionFactory.hashCode() + ")"); if (TransactionSynchronizationManager.hasResource(sessionFactory)) { Object value = TransactionSynchronizationManager.unbindResource(sessionFactory); try { if (value instanceof SessionHolder) { Session session = ((SessionHolder) value).getSession(); SessionFactoryUtils.closeSession(session); } } catch (RuntimeException e) { log.error("Unexpected exception on closing Hibernate Session", e); } } } else { log.debug("Participating in existing session, so not releasing session through synchronization manager"); } }
@Override protected Object doSuspend(Object transaction) { HibernateTransactionObject txObject = (HibernateTransactionObject) transaction; txObject.setSessionHolder(null); SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(getSessionFactory()); txObject.setConnectionHolder(null); ConnectionHolder connectionHolder = null; if (getDataSource() != null) { connectionHolder = (ConnectionHolder) TransactionSynchronizationManager.unbindResource(getDataSource()); } return new SuspendedResourcesHolder(sessionHolder, connectionHolder); }
@Override public void openSession() { log.debug("HibernateContext: Opening Hibernate Session"); if (TransactionSynchronizationManager.hasResource(sessionFactory)) { if (log.isDebugEnabled()) { log.debug("Participating in existing session (" + sessionFactory.hashCode() + ")"); } participate = true; } else { if (log.isDebugEnabled()) { log.debug("Registering session with synchronization manager (" + sessionFactory.hashCode() + ")"); } Session session = sessionFactory.openSession(); session.setFlushMode(FlushMode.MANUAL); TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session)); } }
/** * Return the Hibernate SessionFactory used by this DAO. */ public final SessionFactory getSessionFactory() { return (this.hibernateTemplate != null ? this.hibernateTemplate.getSessionFactory() : null); }
@Override public boolean contains(final Object entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Boolean>() { @Override public Boolean doInHibernate(Session session) { return session.contains(entity); } }); }
/** * Collect the mapping resources for future use because the mappingResources object is defined * as 'private' instead of 'protected' */ @Override public void setMappingResources(String... mappingResources) { Collections.addAll(this.mappingResources, mappingResources); super.setMappingResources(this.mappingResources.toArray(new String[] {})); }
@Override public XSession currentSession() throws HibernateException { return (XSession)super.currentSession(); } }
/** * Create a new HibernateTransactionManager instance. * @param sessionFactory SessionFactory to manage transactions for */ public HibernateTransactionManager(SessionFactory sessionFactory) { this.sessionFactory = sessionFactory; afterPropertiesSet(); }
@Override public Serializable save(final String entityName, final Object entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<Serializable>() { @Override public Serializable doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); return session.save(entityName, entity); } }); }
@Override public void saveOrUpdate(final String entityName, final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { @Override public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.saveOrUpdate(entityName, entity); return null; } }); }
@Override public void persist(final Object entity) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { @Override public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.persist(entity); return null; } }); }
@Override public void flush() throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { @Override public Object doInHibernate(Session session) throws HibernateException { session.flush(); return null; } }); }
@Override public void clear() throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { @Override public Object doInHibernate(Session session) { session.clear(); return null; } }); }
@Override public void replicate(final String entityName, final Object entity, final ReplicationMode replicationMode) throws DataAccessException { executeWithNativeSession(new HibernateCallback<Object>() { @Override public Object doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); session.replicate(entityName, entity, replicationMode); return null; } }); }
@Override public <T> T merge(final String entityName, final T entity) throws DataAccessException { return executeWithNativeSession(new HibernateCallback<T>() { @Override @SuppressWarnings("unchecked") public T doInHibernate(Session session) throws HibernateException { checkWriteOperationAllowed(session); return (T) session.merge(entityName, entity); } }); }