org.kuali.rice.kcb.quartz
Class ConcurrentJob<T>

java.lang.Object
  org.kuali.rice.kcb.quartz.ConcurrentJob<T>

Direct Known Subclasses:

MessageProcessingJob

public abstract class ConcurrentJob<T>
extends Object

Base class for jobs that must obtain a set of work items atomically

Author:

Kuali Rice Team (rice.collab@kuali.org)

Field Summary

protected ExecutorService	executor
protected org.apache.log4j.Logger	LOG
protected org.springframework.transaction.PlatformTransactionManager	txManager

Constructor Summary

ConcurrentJob()

Method Summary

protected org.springframework.transaction.support.TransactionTemplate	createNewTransaction() Helper method for creating a TransactionTemplate initialized to create a new transaction
protected <X> X	executeInTransaction(org.springframework.transaction.support.TransactionCallback callback)
protected void	finishProcessing(ProcessingResult<T> result) Template method called after processing of work items has completed
protected Collection<Collection<T>>	groupWorkItems(Collection<T> workItems, ProcessingResult<T> result) Template method that subclasses should override to group work items into units of work
protected abstract Collection<T>	processWorkItems(Collection<T> items) Template method that subclasses should override to process a given work item and mark it as untaken afterwards
ProcessingResult<T>	run() Main processing method which invokes subclass implementations of template methods to obtain available work items, and process them concurrently
void	setExecutorService(ExecutorService executor) Sets the ExecutorService to use to process work items.
void	setTransactionManager(org.springframework.transaction.PlatformTransactionManager txManager) Sets the PlatformTransactionManager
protected abstract Collection<T>	takeAvailableWorkItems() Template method that subclasses should override to obtain a set of available work items and mark them as taken
protected abstract void	unlockWorkItem(T item) Template method that subclasses should override to unlock a given work item when procesing has failed.
protected void	unlockWorkItemAtomically(T workItem)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

protected final org.apache.log4j.Logger LOG

executor

protected ExecutorService executor

txManager

protected org.springframework.transaction.PlatformTransactionManager txManager

Constructor Detail

ConcurrentJob

public ConcurrentJob()

Method Detail

setExecutorService

public void setExecutorService(ExecutorService executor)

Sets the ExecutorService to use to process work items. Default is single-threaded.

Parameters:

executor - the ExecutorService to use to process work items. Default is single-threaded.

setTransactionManager

public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager txManager)

Sets the PlatformTransactionManager

Parameters:

txManager - the PlatformTransactionManager

createNewTransaction

protected org.springframework.transaction.support.TransactionTemplate createNewTransaction()

Helper method for creating a TransactionTemplate initialized to create a new transaction

Returns:

a TransactionTemplate initialized to create a new transaction

takeAvailableWorkItems

protected abstract Collection<T> takeAvailableWorkItems()

Template method that subclasses should override to obtain a set of available work items and mark them as taken

Returns:

a collection of available work items that have been marked as taken

groupWorkItems

protected Collection<Collection<T>> groupWorkItems(Collection<T> workItems,
                                                   ProcessingResult<T> result)

Template method that subclasses should override to group work items into units of work

Parameters:

workItems - list of work items to break into groups

result - ProcessingResult to modify if there are any failures...this is sort of a hack because previously failure to obtain a deliverer was considered a work item failure, and now this method has been factored out... but the tests still want to see the failure

Returns:

a collection of collection of work items

processWorkItems

protected abstract Collection<T> processWorkItems(Collection<T> items)

Template method that subclasses should override to process a given work item and mark it as untaken afterwards

Parameters:

item - the work item

Returns:

a collection of success messages

unlockWorkItem

protected abstract void unlockWorkItem(T item)

Template method that subclasses should override to unlock a given work item when procesing has failed.

Parameters:

item - the work item to unlock

run

public ProcessingResult<T> run()

Main processing method which invokes subclass implementations of template methods to obtain available work items, and process them concurrently

Returns:

a ProcessingResult object containing the results of processing

finishProcessing

protected void finishProcessing(ProcessingResult<T> result)

Template method called after processing of work items has completed

unlockWorkItemAtomically

protected void unlockWorkItemAtomically(T workItem)

executeInTransaction

protected <X> X executeInTransaction(org.springframework.transaction.support.TransactionCallback callback)