return this.lockableComponent;
}
@Override
public Object processInvocation(final InterceptorContext context) throws Exception {
final InvocationContext invocationContext = context.getInvocationContext();
LockableComponent lockableComponent = this.getLockableComponent();
// get the invoked method
Method invokedMethod = invocationContext.getMethod();
if (invokedMethod == null) {
throw MESSAGES.invocationNotApplicableForMethodInvocation(invocationContext);
}
// get the Lock applicable for this method
Lock lock = getLock(lockableComponent, invokedMethod);
// the default access timeout (will be used in the absence of any explicit access timeout value for the invoked method)
AccessTimeoutDetails defaultAccessTimeout = lockableComponent.getDefaultAccessTimeout();
// set to the default values
long time = defaultAccessTimeout.getValue();
TimeUnit unit = defaultAccessTimeout.getTimeUnit();
AccessTimeoutDetails accessTimeoutOnMethod = lockableComponent.getAccessTimeout(invokedMethod);
if (accessTimeoutOnMethod != null) {
if (accessTimeoutOnMethod.getValue() < 0) {
// for any negative value of timeout, we just default to max timeout val and max timeout unit.
// violation of spec! But we don't want to wait indefinitely.
ROOT_LOGGER.debug("Ignoring a negative @AccessTimeout value: " + accessTimeoutOnMethod.getValue() + " and timeout unit: "
+ accessTimeoutOnMethod.getTimeUnit().name() + ". Will default to timeout value: " + defaultAccessTimeout.getValue()
+ " and timeout unit: " + defaultAccessTimeout.getTimeUnit().name());
} else {
// use the explicit access timeout values specified on the method
time = accessTimeoutOnMethod.getValue();
unit = accessTimeoutOnMethod.getTimeUnit();
}
}
// try getting the lock
boolean success = lock.tryLock(time, unit);
if (!success) {
throw MESSAGES.concurrentAccessTimeoutException(invocationContext,time + unit.name());
}
try {
// lock obtained. now proceed!
return invocationContext.proceed();
} finally {
lock.unlock();
}
}