Java TransactionStatus.ACTIVE属性代码示例

@Sessional
@Override
public void render(WebSocketRegion region, @Nullable PageKey sourcePageKey) {
	if (dao.getSession().getTransaction().getStatus() == TransactionStatus.ACTIVE) {
		dao.doAfterCommit(new Runnable() {

			@Override
			public void run() {
				doRender(region, sourcePageKey);
			}
			
		});
	} else {
		doRender(region, sourcePageKey);
	}
}
 

/** {@inheritDoc} */
@Override public void onSessionEnd(CacheStoreSession ses, boolean commit) {
    Session hibSes = ses.attach(null);

    if (hibSes != null) {
        try {
            Transaction tx = hibSes.getTransaction();

            if (commit) {
                if (hibSes.isDirty())
                    hibSes.flush();

                if (tx.getStatus() == TransactionStatus.ACTIVE)
                    tx.commit();
            }
            else if (tx.getStatus().canRollback())
                tx.rollback();
        }
        catch (HibernateException e) {
            throw new CacheWriterException("Failed to end store session [tx=" + ses.transaction() + ']', e);
        }
        finally {
            hibSes.close();
        }
    }
}
 

/** {@inheritDoc} */
@Override protected void afterTest() throws Exception {
    super.afterTest();

    Session s = store.session(null);

    if (s == null)
        return;

    try {
        s.createQuery("delete from " + CacheHibernateBlobStoreEntry.class.getSimpleName())
                .setFlushMode(FlushMode.ALWAYS).executeUpdate();

        Transaction hTx = s.getTransaction();

        if (hTx != null && hTx.getStatus() == TransactionStatus.ACTIVE)
            hTx.commit();
    }
    finally {
        s.close();
    }
}
 

@Sessional
@Override
public MergePreview previewMerge(PullRequest request) {
	if (request.getMergeStrategy() != MergeStrategy.DO_NOT_MERGE) {
		MergePreview lastPreview = request.getLastMergePreview();
		if (request.isOpen() && !request.isMergeIntoTarget() 
				&& (lastPreview == null || lastPreview.isObsolete(request))) {
			int priority = RequestCycle.get() != null?UI_PREVIEW_PRIORITY:BACKEND_PREVIEW_PRIORITY;			
			if (dao.getSession().getTransaction().getStatus() == TransactionStatus.ACTIVE) {
				doAfterCommit(new Runnable() {

					@Override
					public void run() {
						batchWorkManager.submit(getMergePreviewer(request), new Prioritized(priority));
					}
					
				});
			} else {
				batchWorkManager.submit(getMergePreviewer(request), new Prioritized(priority));
			}
			return null;
		} else {
			return lastPreview;
		}
	} else {
		return null;
	}
}
 

@Sessional
protected void checkAsync(PullRequest request) {
	Long requestId = request.getId();
	Subject subject = SecurityUtils.getSubject();
	if (dao.getSession().getTransaction().getStatus() == TransactionStatus.ACTIVE) {
		doUnitOfWorkAsyncAfterCommit(newCheckStatusRunnable(requestId, subject));
	} else {
		unitOfWork.doAsync(newCheckStatusRunnable(requestId, subject));
	}
}
 

@Sessional
@Override
public void sendMailAsync(Collection<String> toList, String subject, String body) {
	if (dao.getSession().getTransaction().getStatus() == TransactionStatus.ACTIVE) {
		dao.doAsyncAfterCommit(newSendMailRunnable(toList, subject, body));
	} else {
		executorService.execute(newSendMailRunnable(toList, subject, body));
	}
}
 

public Object invoke(MethodInvocation mi) throws Throwable {
	if (persistManager.getSessionFactory() != null) {
		unitOfWork.begin();
		try {
			Session session = unitOfWork.getSession();
			if (session.getTransaction().getStatus() == TransactionStatus.ACTIVE) {
				return mi.proceed();
			} else {
				Transaction tx = session.beginTransaction();
				FlushMode previousMode = session.getFlushMode();
				session.setFlushMode(FlushMode.COMMIT);
				try {
					Object result = mi.proceed();
					tx.commit();
					return result;
				} catch (Throwable t) {
					try {
						tx.rollback();
					} catch (Throwable t2) {
					}
					throw t;
				} finally {
					session.setFlushMode(previousMode);
				}
			}
			
		} finally {
			unitOfWork.end();
		}
	} else {
		return mi.proceed();
	}
}
 

public List<String> search(String productName){
    try{ if(sessionFactory.getCurrentSession().getTransaction().getStatus() != TransactionStatus.ACTIVE)
        sessionFactory.getCurrentSession().getTransaction().begin();
        Query query = sessionFactory.getCurrentSession().createQuery("select name from Product where name like :name");
        query.setString("name",productName + "%");
        System.out.println(query.list().toString());
        return query.list();
    }catch(Exception e){
        return null;
    }
}
 

@Override
public void completeWorkflow() throws ProvisioningException {
	Session session = null;
	try {
		
		if (this.cfgMgr.getProvisioningEngine().getHibernateSessionFactory() != null) {
			session = this.cfgMgr.getProvisioningEngine().getHibernateSessionFactory().openSession();
			session.beginTransaction();
			DateTime now = new DateTime();
			Workflows wf = session.load(Workflows.class, this.id);
			wf.setCompleteTs(new Timestamp(now.getMillis()));
			session.save(wf);
			session.getTransaction().commit();
			
		}
	} finally {
		if (session != null) {
			
			if (session.getTransaction() != null && session.getTransaction().getStatus() == TransactionStatus.ACTIVE) {
				session.getTransaction().rollback();
			}
			
			session.close();
		}
	}
	
	
}
 

@Override
public void close() throws IOException {
    if (session.isOpen() && session.getTransaction().getStatus() == TransactionStatus.ACTIVE) {
        session.getTransaction().rollback();
        throw new IOException("Transaction not closed");
    }
}
 

/**
 * Ends hibernate session.
 *
 * @param ses Hibernate session.
 * @param tx Cache ongoing transaction.
 */
private void end(Session ses, Transaction tx) {
    // Commit only if there is no cache transaction,
    // otherwise sessionEnd() will do all required work.
    if (tx == null) {
        org.hibernate.Transaction hTx = ses.getTransaction();

        if (hTx != null && hTx.getStatus() == TransactionStatus.ACTIVE)
            hTx.commit();

        ses.close();
    }
}
 

private void rollbackTransaction(Session session, UnitOfWork uow) {
    if (uow.transactional()) {
        Transaction txn = session.getTransaction();
        if (txn != null && session.getTransaction().getStatus() != TransactionStatus.ACTIVE) {
            txn.rollback();
        }
    }

}
 

private void commitTransaction(Session session, UnitOfWork uow) {
    if (uow.transactional()) {
        Transaction txn = session.getTransaction();
        if (txn != null && session.getTransaction().getStatus() != TransactionStatus.ACTIVE) {
            txn.commit();
        }
    }

}
 

void addAction(SessionEventListener... listeners) throws HibernateException
{
	final Session session = sessionProvider.get();

	if (session.getTransaction().getStatus() != TransactionStatus.ACTIVE)
		throw new IllegalStateException("Cannot add transaction action with no active transaction!");

	session.addEventListeners(listeners);
}
 

public boolean hasHibernateManagedTransaction() {
	return (this.sessionHolder != null &&
			this.sessionHolder.getSession().getTransaction().getStatus() == TransactionStatus.ACTIVE);
}