Java TransactionTemplate.setReadOnly方法代码示例

import org.springframework.transaction.support.TransactionTemplate; //导入方法依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
    // Our transaction template will be read-only
    readonlyTransactionTemplate = new TransactionTemplate(transactionManager);
    readonlyTransactionTemplate.setReadOnly(true);

    cachedWriters = new HashMap<Class<?>, IndexWriter>();

    statusFile = new File(indexHandler.getIndexRoot(), "status");
    status = new Properties();
    try {
        status.load(new FileReader(statusFile));
        long time = Long.parseLong(status.getProperty(LAST_OPERATION_TIME));
        lastOperationTime = new GregorianCalendar();
        lastOperationTime.setTimeInMillis(time);
        lastOperationId = Long.parseLong(status.getProperty(LAST_OPERATION_ID));
    } catch (Exception e) {
        // Ok, ignore. We'll start with empty properties
        lastOperationTime = null;
        lastOperationId = null;
    }

    // Start the thread
    thread = new Thread(this, "IndexOperationRunner");
    thread.start();
}
 

import org.springframework.transaction.support.TransactionTemplate; //导入方法依赖的package包/类
@Test
public void testTransactionWithIsolationAndReadOnly() throws Exception {
	given(con.getTransactionIsolation()).willReturn(Connection.TRANSACTION_READ_COMMITTED);
	given(con.getAutoCommit()).willReturn(true);

	TransactionTemplate tt = new TransactionTemplate(tm);
	tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
	tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
	tt.setReadOnly(true);
	assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
	tt.execute(new TransactionCallbackWithoutResult() {
		@Override
		protected void doInTransactionWithoutResult(TransactionStatus status) {
			assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
			assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
			// something transactional
		}
	});

	assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
	InOrder ordered = inOrder(con);
	ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
	ordered.verify(con).setAutoCommit(false);
	ordered.verify(con).commit();
	ordered.verify(con).setAutoCommit(true);
	ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
	verify(con).close();
}
 

import org.springframework.transaction.support.TransactionTemplate; //导入方法依赖的package包/类
public final void setTransactionManager(PlatformTransactionManager transactionManager) {
    this.transactionManager = transactionManager;

    transactionTemplate = new TransactionTemplate(transactionManager);
    transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

    transactionTemplateReadOnly = new TransactionTemplate(transactionManager);
    transactionTemplateReadOnly.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    transactionTemplateReadOnly.setReadOnly(true);
}
 

import org.springframework.transaction.support.TransactionTemplate; //导入方法依赖的package包/类
@Test
public void testTransactionCommitWithReadOnly() throws Exception {
	Connection con = mock(Connection.class);
	final SessionFactory sf = mock(SessionFactory.class);
	Session session = mock(Session.class);
	Transaction tx = mock(Transaction.class);
	Query query = mock(Query.class);

	final List list = new ArrayList();
	list.add("test");
	given(sf.openSession()).willReturn(session);
	given(session.beginTransaction()).willReturn(tx);
	given(session.connection()).willReturn(con);
	given(session.isOpen()).willReturn(true);
	given(session.createQuery("some query string")).willReturn(query);
	given(query.list()).willReturn(list);
	given(session.isConnected()).willReturn(true);
	given(con.isReadOnly()).willReturn(true);

	HibernateTransactionManager tm = new HibernateTransactionManager(sf);
	TransactionTemplate tt = new TransactionTemplate(tm);
	tt.setReadOnly(true);
	assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
	assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

	Object result = tt.execute(new TransactionCallback() {
		@Override
		public Object doInTransaction(TransactionStatus status) {
			assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
			assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
			assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
			HibernateTemplate ht = new HibernateTemplate(sf);
			return ht.find("some query string");
		}
	});
	assertTrue("Correct result list", result == list);

	assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
	assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

	verify(session).setFlushMode(FlushMode.MANUAL);
	verify(con).setReadOnly(true);
	verify(tx).commit();
	verify(con).setReadOnly(false);
	verify(session).close();
}
 

import org.springframework.transaction.support.TransactionTemplate; //导入方法依赖的package包/类
@Inject
public void setTransactionManager(final PlatformTransactionManager transactionManager) {
    transactionTemplate = new TransactionTemplate(transactionManager);
    transactionTemplate.setReadOnly(true);
}