Revert back to java 8

Author: alturkovic

README.adoc

@@ -3,7 +3,7 @@
 Distributed lock ensures your method cannot be run in parallel from multiple JVMs (cluster of servers, microservices, ...).
 It uses a common store to keep track of used locks and your method needs to acquire one or more locks to run.
 
-By default, locks follow methods lifecycle. They are obtained at the start of the method and released at the end of the method.
+By default, locks follow methods lifecycle.They are obtained at the start of the method and released at the end of the method.
 Manual controlling is supported and explained later in this document.
 
 All locks acquired by lock implementations in this project will expire after 10 seconds, timeout after 1 second if unable to acquire lock and sleep for 50 ms between retries.
@@ -19,9 +19,9 @@ This will import the configuration that will autoconfigure the
 
 Project provides the following out-of-the-box lock implementations:
 
- * JDBC
- * Mongo
- * Redis
+* JDBC
+* Mongo
+* Redis
 
 === JDBC locks
 
@@ -124,6 +124,10 @@ public class LockConfiguration {
 
 Started tracking the changes since 1.2.0 so no changelogs available for earlier versions.
 
+==== 1.4.0
+
+- CHANGE: Switched back to Java 1.8 from 11 since most projects don't yet use 11
+
 ==== 1.3.0
 
 - CHANGE: Updated Java from 1.8 to 11

distributed-lock-api/pom.xml

@@ -8,7 +8,7 @@
   <parent>
     <groupId>com.github.alturkovic</groupId>
     <artifactId>distributed-lock</artifactId>
-    <version>1.3.0</version>
+    <version>1.4.0</version>
   </parent>
 
   <artifactId>distributed-lock-api</artifactId>

distributed-lock-core/pom.xml

@@ -8,7 +8,7 @@
   <parent>
     <groupId>com.github.alturkovic</groupId>
     <artifactId>distributed-lock</artifactId>
-    <version>1.3.0</version>
+    <version>1.4.0</version>
   </parent>
 
   <artifactId>distributed-lock-core</artifactId>

distributed-lock-core/src/main/java/com/github/alturkovic/lock/AbstractSimpleLock.java

@@ -41,7 +41,7 @@ public abstract class AbstractSimpleLock implements Lock {
   public String acquire(final List<String> keys, final String storeId, final long expiration) {
     Assert.isTrue(keys.size() == 1, "Cannot acquire lock for multiple keys with this lock");
 
-    final var token = tokenSupplier.get();
+    final String token = tokenSupplier.get();
     if (StringUtils.isEmpty(token)) {
       throw new IllegalStateException("Cannot lock with empty token");
     }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/advice/LockBeanPostProcessor.java

@@ -29,6 +29,7 @@
 import com.github.alturkovic.lock.key.KeyGenerator;
 import com.github.alturkovic.lock.retry.RetriableLockFactory;
 import lombok.AllArgsConstructor;
+import org.aopalliance.intercept.Interceptor;
 import org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor;
 import org.springframework.aop.support.DefaultPointcutAdvisor;
 import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;
@@ -48,8 +49,8 @@ public class LockBeanPostProcessor extends AbstractAdvisingBeanPostProcessor imp
 
   @Override
   public void afterPropertiesSet() {
-    final var pointcut = new AnnotationMatchingPointcut(null, Locked.class, true);
-    final var interceptor = new LockMethodInterceptor(keyGenerator, lockTypeResolver, intervalConverter, retriableLockFactory, taskScheduler);
+    final AnnotationMatchingPointcut pointcut = new AnnotationMatchingPointcut(null, Locked.class, true);
+    final Interceptor interceptor = new LockMethodInterceptor(keyGenerator, lockTypeResolver, intervalConverter, retriableLockFactory, taskScheduler);
 
     this.advisor = new DefaultPointcutAdvisor(pointcut, interceptor);
   }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/advice/LockMethodInterceptor.java

@@ -54,7 +54,7 @@ public class LockMethodInterceptor implements MethodInterceptor {
 
   @Override
   public Object invoke(final MethodInvocation invocation) throws Throwable {
-    final var context = new LockContext(invocation);
+    final LockContext context = new LockContext(invocation);
     try {
       return executeLockedMethod(invocation, context);
     } finally {
@@ -63,7 +63,7 @@ public Object invoke(final MethodInvocation invocation) throws Throwable {
   }
 
   private Object executeLockedMethod(final MethodInvocation invocation, final LockContext context) throws Throwable {
-    final var expiration = intervalConverter.toMillis(context.getLocked().expiration());
+    final long expiration = intervalConverter.toMillis(context.getLocked().expiration());
     try {
       context.setToken(retriableLockFactory.generate(context.getLock(), context.getLocked()).acquire(context.getKeys(), context.getLocked().storeId(), expiration));
     } catch (final Exception e) {
@@ -77,7 +77,7 @@ private Object executeLockedMethod(final MethodInvocation invocation, final Lock
   }
 
   private void scheduleLockRefresh(final LockContext context, final long expiration) {
-    final var refresh = intervalConverter.toMillis(context.getLocked().refresh());
+    final long refresh = intervalConverter.toMillis(context.getLocked().refresh());
     if (refresh > 0) {
       context.setScheduledFuture(taskScheduler.scheduleAtFixedRate(constructRefreshRunnable(context, expiration), refresh));
     }
@@ -88,13 +88,13 @@ private Runnable constructRefreshRunnable(final LockContext context, final long
   }
 
   private void cleanAfterExecution(final LockContext context) {
-    final var scheduledFuture = context.getScheduledFuture();
+    final ScheduledFuture<?> scheduledFuture = context.getScheduledFuture();
     if (scheduledFuture != null && !scheduledFuture.isCancelled() && !scheduledFuture.isDone()) {
       scheduledFuture.cancel(true);
     }
 
     if (StringUtils.hasText(context.getToken()) && !context.getLocked().manuallyReleased()) {
-      final var released = context.getLock().release(context.getKeys(), context.getLocked().storeId(), context.getToken());
+      final boolean released = context.getLock().release(context.getKeys(), context.getLocked().storeId(), context.getToken());
       if (released) {
         log.debug("Released lock for keys {} with token {} in store {}", context.getKeys(), context.getToken(), context.getLocked().storeId());
       } else {

distributed-lock-core/src/main/java/com/github/alturkovic/lock/configuration/DistributedLockConfiguration.java

@@ -54,7 +54,7 @@ public LockBeanPostProcessor lockBeanPostProcessor(final KeyGenerator keyGenerat
                                                      final IntervalConverter intervalConverter,
                                                      final RetriableLockFactory retriableLockFactory,
                                                      @Autowired(required = false) final TaskScheduler taskScheduler) {
-    final var processor = new LockBeanPostProcessor(keyGenerator, configurableBeanFactory::getBean, intervalConverter, retriableLockFactory, taskScheduler);
+    final LockBeanPostProcessor processor = new LockBeanPostProcessor(keyGenerator, configurableBeanFactory::getBean, intervalConverter, retriableLockFactory, taskScheduler);
     processor.setBeforeExistingAdvisors(true);
     return processor;
   }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/interval/BeanFactoryAwareIntervalConverter.java

@@ -42,7 +42,7 @@ public long toMillis(final Interval interval) {
   }
 
   private String resolveMilliseconds(final Interval interval) {
-    final var value = beanFactory.resolveEmbeddedValue(interval.value());
+    final String value = beanFactory.resolveEmbeddedValue(interval.value());
     if (!StringUtils.hasText(value)) {
       throw new IllegalArgumentException("Cannot convert interval " + interval + " to milliseconds");
     }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/key/SpelKeyGenerator.java

@@ -27,6 +27,7 @@
 import com.github.alturkovic.lock.exception.EvaluationConvertException;
 import java.lang.reflect.Method;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -47,9 +48,8 @@
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class SpelKeyGenerator extends CachedExpressionEvaluator implements KeyGenerator {
-  private final ConversionService conversionService;
   private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<>();
-  private final Map<AnnotatedElementKey, Method> targetMethodCache = new ConcurrentHashMap<>();
+  private final ConversionService conversionService;
 
   @Override
   public List<String> resolveKeys(final String lockKeyPrefix, final String expression, final Object object, final Method method, final Object[] args) {
@@ -74,7 +74,7 @@ protected List<String> convertResultToList(final Object expressionValue) {
     } else if (expressionValue.getClass().isArray()) {
       list = arrayToList(expressionValue);
     } else {
-      list = List.of(expressionValue.toString());
+      list = Collections.singletonList(expressionValue.toString());
     }
 
     if (CollectionUtils.isEmpty(list)) {
@@ -99,17 +99,17 @@ private Object evaluateExpression(final String expression, final Object object,
 
   private List<String> iterableToList(final Object expressionValue) {
     final TypeDescriptor genericCollection = TypeDescriptor.collection(Collection.class, TypeDescriptor.valueOf(Object.class));
-    final TypeDescriptor stringList = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
-
-    //noinspection unchecked
-    return (List<String>) conversionService.convert(expressionValue, genericCollection, stringList);
+    return toList(expressionValue, genericCollection);
   }
 
   private List<String> arrayToList(final Object expressionValue) {
     final TypeDescriptor genericArray = TypeDescriptor.array(TypeDescriptor.valueOf(Object.class));
-    final TypeDescriptor stringList = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
+    return toList(expressionValue, genericArray);
+  }
 
+  private List<String> toList(final Object expressionValue, final TypeDescriptor from) {
+    final TypeDescriptor listTypeDescriptor = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
     //noinspection unchecked
-    return (List<String>) conversionService.convert(expressionValue, genericArray, stringList);
+    return (List<String>) conversionService.convert(expressionValue, from, listTypeDescriptor);
   }
 }

distributed-lock-core/src/main/java/com/github/alturkovic/lock/retry/DefaultRetryTemplateConverter.java

@@ -27,7 +27,7 @@
 import com.github.alturkovic.lock.Locked;
 import com.github.alturkovic.lock.exception.LockNotAvailableException;
 import com.github.alturkovic.lock.interval.IntervalConverter;
-import java.util.Map;
+import java.util.Collections;
 import lombok.Data;
 import org.springframework.retry.RetryPolicy;
 import org.springframework.retry.backoff.FixedBackOffPolicy;
@@ -42,34 +42,34 @@ public class DefaultRetryTemplateConverter implements RetryTemplateConverter {
 
   @Override
   public RetryTemplate construct(final Locked locked) {
-    final var retryTemplate = new RetryTemplate();
+    final RetryTemplate retryTemplate = new RetryTemplate();
     retryTemplate.setRetryPolicy(resolveLockRetryPolicy(locked));
     retryTemplate.setBackOffPolicy(resolveBackOffPolicy(locked));
     return retryTemplate;
   }
 
   private CompositeRetryPolicy resolveLockRetryPolicy(final Locked locked) {
-    final var compositeRetryPolicy = new CompositeRetryPolicy();
+    final CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();
 
-    final var timeoutRetryPolicy = resolveTimeoutRetryPolicy(locked);
-    final var exceptionTypeRetryPolicy = resolveExceptionTypeRetryPolicy();
+    final RetryPolicy timeoutRetryPolicy = resolveTimeoutRetryPolicy(locked);
+    final RetryPolicy exceptionTypeRetryPolicy = resolveExceptionTypeRetryPolicy();
 
     compositeRetryPolicy.setPolicies(new RetryPolicy[]{timeoutRetryPolicy, exceptionTypeRetryPolicy});
     return compositeRetryPolicy;
   }
 
   private RetryPolicy resolveTimeoutRetryPolicy(final Locked locked) {
-    final var timeoutRetryPolicy = new TimeoutRetryPolicy();
+    final TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy();
     timeoutRetryPolicy.setTimeout(intervalConverter.toMillis(locked.timeout()));
     return timeoutRetryPolicy;
   }
 
   private RetryPolicy resolveExceptionTypeRetryPolicy() {
-    return new SimpleRetryPolicy(Integer.MAX_VALUE, Map.of(LockNotAvailableException.class, true));
+    return new SimpleRetryPolicy(Integer.MAX_VALUE, Collections.singletonMap(LockNotAvailableException.class, true));
   }
 
   private FixedBackOffPolicy resolveBackOffPolicy(final Locked locked) {
-    final var fixedBackOffPolicy = new FixedBackOffPolicy();
+    final FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
     fixedBackOffPolicy.setBackOffPeriod(intervalConverter.toMillis(locked.retry()));
     return fixedBackOffPolicy;
   }

distributed-lock-core/src/test/java/com/github/alturkovic/lock/advice/LockBeanPostProcessorTest.java

@@ -27,11 +27,14 @@
 import com.github.alturkovic.lock.Interval;
 import com.github.alturkovic.lock.Locked;
 import com.github.alturkovic.lock.advice.support.SimpleLock;
+import com.github.alturkovic.lock.advice.support.SimpleLock.LockedKey;
 import com.github.alturkovic.lock.advice.support.SimpleLocked;
 import com.github.alturkovic.lock.interval.BeanFactoryAwareIntervalConverter;
+import com.github.alturkovic.lock.interval.IntervalConverter;
 import com.github.alturkovic.lock.key.SpelKeyGenerator;
 import com.github.alturkovic.lock.retry.DefaultRetriableLockFactory;
 import com.github.alturkovic.lock.retry.DefaultRetryTemplateConverter;
+import com.github.alturkovic.lock.retry.RetriableLockFactory;
 import java.util.concurrent.TimeUnit;
 import org.assertj.core.data.Offset;
 import org.junit.Before;
@@ -51,20 +54,20 @@ public class LockBeanPostProcessorTest {
 
   @Before
   public void setUp() {
-    final var beanFactory = new DefaultListableBeanFactory();
+    final DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
     lock = new SimpleLock();
 
-    final var lockTypeResolver = Mockito.mock(LockTypeResolver.class);
+    final LockTypeResolver lockTypeResolver = Mockito.mock(LockTypeResolver.class);
     when(lockTypeResolver.get(SimpleLock.class)).thenReturn(lock);
 
-    final var scheduler = new ThreadPoolTaskScheduler();
+    final ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
     scheduler.afterPropertiesSet();
 
-    final var keyGenerator = new SpelKeyGenerator(new DefaultConversionService());
-    final var intervalConverter = new BeanFactoryAwareIntervalConverter(beanFactory);
-    final var retriableLockFactory = new DefaultRetriableLockFactory(new DefaultRetryTemplateConverter(intervalConverter));
+    final SpelKeyGenerator keyGenerator = new SpelKeyGenerator(new DefaultConversionService());
+    final IntervalConverter intervalConverter = new BeanFactoryAwareIntervalConverter(beanFactory);
+    final RetriableLockFactory retriableLockFactory = new DefaultRetriableLockFactory(new DefaultRetryTemplateConverter(intervalConverter));
 
-    final var processor = new LockBeanPostProcessor(keyGenerator, lockTypeResolver, intervalConverter, retriableLockFactory, scheduler);
+    final LockBeanPostProcessor processor = new LockBeanPostProcessor(keyGenerator, lockTypeResolver, intervalConverter, retriableLockFactory, scheduler);
     processor.afterPropertiesSet();
 
     beanFactory.addBeanPostProcessor(processor);
@@ -135,7 +138,7 @@ public void shouldLockFromImplementationWithImplementationDetail() {
   @Test
   public void shouldRefreshLock() throws InterruptedException {
     lockedInterface.sleep();
-    final var lockedKey = this.lock.getLockMap().get("lock").get(0);
+    final LockedKey lockedKey = this.lock.getLockMap().get("lock").get(0);
     assertThat(lockedKey.getUpdatedAt()).withFailMessage(lockedKey.toString()).isCloseTo(System.currentTimeMillis(), Offset.offset(200L));
     assertThat(lockedKey.getKey()).isEqualTo("com.github.alturkovic.lock.advice.LockBeanPostProcessorTest.LockedInterfaceImpl.sleep");
 

distributed-lock-core/src/test/java/com/github/alturkovic/lock/advice/support/SimpleLock.java

@@ -45,15 +45,18 @@ public class SimpleLock implements Lock {
   public String acquire(final List<String> keys, final String storeId, final long expiration) {
     log.debug("Acquiring lock for keys {} in store {} with expiration: {}", keys, storeId, expiration);
 
-    final var lockedKeysWithExpiration = lockMap.get(storeId);
+    final List<LockedKey> lockedKeysWithExpiration = lockMap.get(storeId);
     if (lockedKeysWithExpiration != null) {
-      final var locksForStore = lockedKeysWithExpiration.stream().map(LockedKey::getKey).collect(Collectors.toList());
+      final List<String> locksForStore = lockedKeysWithExpiration.stream()
+        .map(LockedKey::getKey)
+        .collect(Collectors.toList());
+
       if (keys.stream().anyMatch(locksForStore::contains)) {
         return null;
       }
     }
 
-    final var lockedKeys = lockMap.computeIfAbsent(storeId, s -> new ArrayList<>());
+    final List<LockedKey> lockedKeys = lockMap.computeIfAbsent(storeId, s -> new ArrayList<>());
     keys.forEach(key -> lockedKeys.add(new LockedKey(key, expiration, System.currentTimeMillis(), System.currentTimeMillis(), 0, false)));
 
     return UUID.randomUUID().toString();
@@ -62,7 +65,7 @@ public String acquire(final List<String> keys, final String storeId, final long
   @Override
   public boolean release(final List<String> keys, final String storeId, final String token) {
     log.debug("Releasing keys {} in store {} with token {}", keys, storeId, token);
-    final var lockedKeys = lockMap.get(storeId);
+    final List<LockedKey> lockedKeys = lockMap.get(storeId);
 
     if (CollectionUtils.isEmpty(lockedKeys)) {
       return false;
@@ -79,7 +82,7 @@ public boolean release(final List<String> keys, final String storeId, final Stri
   @Override
   public boolean refresh(final List<String> keys, final String storeId, final String token, final long expiration) {
     log.debug("Refreshing keys {} in store {} with token {} to expiration: {}", keys, storeId, token, expiration);
-    final var lockedKeys = lockMap.get(storeId);
+    final List<LockedKey> lockedKeys = lockMap.get(storeId);
 
     if (lockedKeys == null) {
       return false;

distributed-lock-core/src/test/java/com/github/alturkovic/lock/retry/DefaultRetriableLockFactoryTest.java

@@ -55,8 +55,8 @@ public class DefaultRetriableLockFactoryTest {
   public void shouldGenerateRetriableLock() {
     when(retryTemplateConverter.construct(eq(locked))).thenReturn(retryTemplate);
 
-    final var factory = new DefaultRetriableLockFactory(retryTemplateConverter);
-    final var retriableLock = factory.generate(lock, locked);
+    final RetriableLockFactory factory = new DefaultRetriableLockFactory(retryTemplateConverter);
+    final RetriableLock retriableLock = factory.generate(lock, locked);
 
     assertThat(retriableLock.getLock()).isEqualTo(lock);
     assertThat(retriableLock.getRetryTemplate()).isEqualTo(retryTemplate);